权限修饰符-代码块-static

权限修饰符

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

• public：公共的
• protected：受保护的
• (空的)：默认的
• private：私有的

不同权限的访问能力

	public	protected	（空的）	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

public class AAA {
    public void method1(){}
    protected void method2(){}
     void method3(){}
    private void method4(){}

    // 同一个类中
    public void method(){
        method1();
        method2();
        method3();
        method4();
    }
}
public class Test {
    public static void main(String[] args) {
        AAA a = new AAA();
        a.method1();
        a.method2();
        a.method3();
        // a.method4(); 私有方法 编译报错
    }
}

包:com.itheima.demo10_权限修饰符
public class Zi extends AAA {
    public void show(){
        method1();
        method2();
        //method3();编译报错
        //method4();编译报错
    }
}
public class Test {
    public static void main(String[] args) {
        AAA a = new AAA();
        a.method1();
        //a.method2();// 编译报错
        //a.method3();// 编译报错
        //a.method4();// 编译报错
    }
}

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

• 成员变量使用private ，隐藏细节。

• 构造方法使用public ，方便创建对象。

• 成员方法使用public ，方便调用方法。

代码块

• 构造代码块
• 静态代码块
• 局部代码块

1.构造代码块（每次在调用构造方法的时候，就会执行，比构造方法执行要早）

格式: {}
位置: 类中,方法外
执行: 每次在调用构造方法的时候,就会执行. 比构造方法执行要早
使用场景: 统计创建了多少个该类对象

例如:
public class Person{
    {
        构造代码块执行了
    }
}

2. 静态代码块（当类被加载的时候执行,并只执行一次）

格式：

格式:static{}
位置: 类中,方法外
执行: 当类被加载的时候执行,并只执行一次
使用场景: 例如加载驱动,这种只需要执行一次的代码就可以放在静态代码块中         

public class Person {
	private String name;
	private int age;
 //静态代码块
	static{
		System.out.println("静态代码块执行了");
	}
}

3.局部代码块

格式:{}
位置: 方法中
执行: 调用方法,执行到局部代码块的时候就执行
使用场景: 节省内存空间,没有多大的意义
例如:
public static void main(String[] args) {
     int a = 10;
     //局部代码块
     //局部代码块的作用就是限制变量的作用域,早早的从内存中消失，节约内存
     //但是现在内存不值钱,所以局部代码块没有使用意义
     {
         int b = 20;
     }

     //int a = 30;    //在同一个区域不能定义重名变量
     //不报错，以为作用域不同
     int b = 40;
 }

static的使用

static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。static修饰的成员被多个对象共享。static修饰的成员属于类，但是会影响每一个对象。被static修饰的成员又叫类成员，不叫对象的成员。

定义和使用格式

类变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

• 类变量：使用 static关键字修饰的成员变量。

定义格式：

static 数据类型 变量名； 

举例：

static String room；

public class Student {
  private String name;
  private int age;
  // 类变量，记录学生学习的学校
  public static String school = "学校";

  public Student(String name, int age){
    this.name = name;
    this.age = age;     
  }

  // 打印属性值
  public void show() {
    System.out.println("name=" + name + ", age=" + age + ", shool=" + shool );
  }
}

public class StuDemo {
  public static void main(String[] args) {
    Student s1 = new Student("张三", 23);
    Student s2 = new Student("李四", 24);
    Student s3 = new Student("王五", 25);
    Student s4 = new Student("赵六", 26);

    s1.show(); // Student : name=张三, age=23, shool=黑马程序员学校
    s2.show(); // Student : name=李四, age=24, shool=黑马程序员学校
    s3.show(); // Student : name=王五, age=25, shool=黑马程序员学校
    s4.show(); // Student : name=赵六, age=26, shool=黑马程序员学校
  }
}

静态方法

当static 修饰成员方法时，该方法称为类方法。静态方法在声明中有static ，建议使用类名来调用，而不需要创建类的对象。调用方式非常简单。

• 类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。

定义格式：

修饰符 static 返回值类型 方法名 (参数列表){ 
	// 执行语句 
}

举例：在Student类中定义静态方法

public static void showNum() {
  System.out.println("num:" +  numberOfStudent);
}

• 静态方法调用的注意事项：
  • 静态方法可以直接访问类变量和静态方法。
  • 静态方法不能直接访问普通成员变量或成员方法。成员方法可以直接访问类变量或静态方法。
  • 静态方法中，不能使用this关键字。
• 静态只能访问静态
• 非静态可以访问静态

小贴士：静态方法只能访问静态成员。

调用格式

被static修饰的成员可以并且建议通过**类名直接访问**。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：

// 访问类变量
类名.类变量名；

// 调用静态方法
类名.静态方法名(参数)； 

调用演示，代码如下：

public class StuDemo2 {
  public static void main(String[] args) {      
    // 访问类变量
    System.out.println(Student.numberOfStudent);
    // 调用静态方法
    Student.showNum();
  }
}

小结：static修饰的内容是属于类的，可以通过类名直接访问