Java初学笔记（类及成员修饰符+static）（11.18）

---

一、Java访问修饰符

1）类的访问修饰符

1.public修饰符修饰类：共有访问级别

2.默认修饰符：对于类和接口声明，默认值为包私有

package Q;
//import S.DefaultClass;
import S.PublicClass;
//public修饰类
public class Test1 {
    public static void main(String[] args) {
        //在公共修饰符测试类中创建对象,需要导入PublicClass类所在的包
        PublicClass pc1 = new PublicClass();
        //public修饰的Test1 类在Q包里，无法使用在S包中default修饰类
        //DefaultClass dc2 = new DefaultClass();
    }
}

package Q;
//import S.DefaultClass;
import S.PublicClass;
//默认修饰符类
class Test2 {
    public static void main(String[] args) {
        //在默认修饰符测试类中创建PublicClass类和DefaultClass类对象
        PublicClass pc1 = new PublicClass();
        //默认修饰符修饰的测试类在Q包中，无法使用S包默认符修饰修饰类
        //DefaultClass dc2 = new DefaultClass();
    }
}

• 总结：在同一包中，有public类和默认类，在测试类中都可创建public类对象和默认类对象；在不同包中，public类和默认类只可创建public类对象（需要导包），无法创建默认类对象。

2）类成员的访问修饰符

1.public修饰符

（1）public修饰符表示公开的，公共的。不同类，不同包下都可以访问。

（2）1个java文件中只可以有一个public修饰的类，并且类名需要和文件名相同

2.protected修饰符

（1）protected修饰符表示受保护的，它主要的作用是保护子类，子类可以用它修饰的成员，其他的不可以

（2）protected修饰符可以被本类、同一个包中的类、不同包中的子类所访问到

（3）protected可以修饰属性、方法，但是不能修饰外部类，可以修饰内部类

3.default修饰符

（1）当定义变量、方法以及类时，没有写访问修饰符，则代表默认的修饰符default。

（2）default修饰的属性、方法、类，只能被本类或者同一个包中的其他类访问到，针对本包访问而设计，任何处于本包下的属性、方法、类、接口等，都可以相互访问

4.private修饰符

（1）可用来修饰内部类、属性、方法。

（2）“私有的”，即被private修饰的属性、方法、类只能被该类的对象访问，其子类不能访问，更不能允许跨包访问

• 案例：

public class Student {
    public String name;
    protected int age;
    String address;
    private char gender;
    public static void main(String[] args) {
        Student stu1 = new Student();
        //同一个类中，四个类成员访问修饰符都可使用
        stu1.name = "张三";
        stu1.age = 18;
        stu1.address = "安徽";
        stu1.gender = '男';
    }
}

public class StudentTest1 {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.name = "王五";
        stu1.age = 18;
        stu1.address = "城南";
//        在同一个包中
//        无法在Student类之外的其他类中直接访问使用private修饰的属性或方法
//        stu1.gender = '男';
    }
}

import a.Student;
public class StudentTest2 {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.name = "王五";
//        无法在Student类所在包的其他包中的类里直接访问使用protected修饰的属性
//        stu1.age = 20;
//        无法在Student类所在包的其他包中的类里直接访问使用默认修饰的属性
//        stu1.address = "aij";
//        无法在Student类所在包的其他包中的类里直接访问使用private修饰的属性
//        stu1.gender = '男';
    }
}

二、static修饰符

1）static变量（属性）

（1）用static修饰的属性称为静态变量或者类变量，没有使用static修饰的属性称为实例变量。

（2）使用static修饰的属性不依赖于任何对象，属于该类，在类内部，可在任何方法内直接访问静态变量；在其它类中，可以直接通过类名访问。

• static修饰成员变量表示该成员变量在内存中只存储一份，可以被共享访问，修改。
• 每创建一个实例就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

（3）在实际开发中，用static关键字修饰属性的最常用场景就是定义使用final关键字修饰的常量。
使用final关键字修饰的常量在整个程序运行时都不能被改变，和具体的对象没关系，因此使用static修饰。常量名由大写字母组成，多个单词之间使用下划线“_”分隔。

public class Static01 {
//没有使用static修饰的变量，称之为实例变量
    public int num = 10;
//使用static修饰的变量，称之为静态变量(类变量)
    public static int num2 = 100;
//  使用final关键字修饰的常量。
    public static final  int NUM3 = 277;

    public void test1(){
        System.out.println(num);
        System.out.println(num2);
    }
}

//通过类名直接调用
        System.out.println(Static01.num2);//100

2）static方法

（1）用static修饰的方法称为静态方法或者类方法，不用static关键字修饰的方法称为实例方法。

• 静态方法中不能使用this和super
• 静态方法必须被实现（main就是最常用的静态方法）

（2）静态方法可直接通过类名访问，可直接访问类的静态变量和方法，不能直接访问所属类的实例变量和实例方法。

（3）实例方法通过实例访问，可以直接访问所属类中定义的静态变量，静态方法，实例变量和实例方法。

3）修饰代码块

（1）用static修饰的代码块称为静态代码块。

public class StaticBlock01 {
    public StaticBlock01(){
        System.out.println("我是无参构造方法");
    }
    //写静态代码块
    static {
        System.out.println("我是静态代码块2");
    }
    static {
        System.out.println("我是静态代码块1");
    }
    static {
        System.out.println("我是静态代码块3");
    }
}

（2）静态代码块随着类的加载一起执行，当一个类中有多个静态代码块时，按照顺序从上往下依次执行，只执行一次。

public class Test1 {
    public static void main(String[] args) {
        //使用static修饰的代码块属于类所有，随着虚拟机的加载先加载
        StaticBlock01 staticBlock01 = new StaticBlock01();
    }
}