权限修饰符与状态修饰符

1.1 ：修饰符的分类

• 权限修饰符

• 状态修饰符

1.2权限修饰符：

修饰符	同一类中	同一包中子类	无关类 不同包的子类	不同包的无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

• 
  对号表示：可以被访问

• 在同一个类中,private、默认、protected、public都可以被访问到

  package play;
   public class Father{
      private void show1(){
          System.out.println("私有");
      }
      void show2(){
          System.out.println("默认");
      }
      protected void show3(){
          System.out.println("protected");
      }
      public void show4(){
          System.out.println("public");
      }
  ​
      public static void main(String[] args) {
          Father father = new Father();
          //在同一个类中,private、默认、protected、public都可以被访问到
          father.show1();//私有
          father.show2();//默认
          father.show3();//protected
          father.show4();//public
      }
  }

• 在同一个包类中子类,private修饰的不能被访问，默认、protected、public可以被访问

  package play;
  ​
  public class Son extends Father{
      public static void main(String[] args) {
          Son son = new Son();
          //在同一个包类中子类,private修饰的不能被访问，默认、protected、public可以被访问
  //        son.show1();//报错
          son.show2();//默认
          son.show3();//protected
          son.show4();//public
      }
  }

• 在不同一个包类中子类,private、默认修饰的不能被访问，protected、public可以被访问

  package play2;
  ​
  import play.Father;
  ​
  public class Son2 extends Father {
      public static void main(String[] args) {
          Son2 son2 = new Son2();
          //在不同一个包类中子类,private、默认修饰的不能被访问，protected、public可以被访问
  //         son2.show1();//报错
  //        son2.show2();//默认
          son2.show3();
          son2.show4();
      }
  }

• 在不同一个包类中无关类,private、默认、protected修饰的不能被访问，public可以被访问

  package play2;
  ​
  import play.Father;
  ​
  public class Demo {
      public static void main(String[] args) {
          Father father = new Father();
          //在不同一个包类中无关类,private、默认、protected修饰的不能被访问，public可以被访问
  //        father.show1();//报错
  //        father.show2();//报错
  //        father.show3();//报错
          father.show4();
      }
  }

   

1.3状态修饰符

• final*（最终态）

• static（静态）

 

final关键字

final关键字是最终的意思，可以修饰成员方法，成员变量，类

final修饰的特点

• 修饰方法，表明该方法是最终方法，不能被重写

• 修饰变量：表明改变量是常量，不能被重新赋值

• 修饰类：表明该类是最终类，不能被继承

final修饰局部变量

• 变量是基本类型：final修饰指的是基本类型的数据值不能发生改变

  代码演示：

  public class Finaltest {
      public static void main(String[] args) {
          int age =20;
          System.out.println(age);//20
          age = 100;
          System.out.println(age);//100
          //final 修饰基本类型
          final int age1= 20;
          System.out.println(age);//20
  //        age1 =100;//报错--->final修饰指的是基本类型的数据值不能发生改变
      }
  }

• 变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容可以发生改变

  public class Finaltest {
      public static void main(String[] args) {
          Student student = new Student();
          System.out.println(student.age);//100
          //给age重新赋值
          student.age = 10;
          System.out.println(student.age);//10
          student = new Student();//给student(地址值)重新赋值
          System.out.println(student.age);//地址发生改变，值不变
  ​
          //final修饰引用类型： 指的是s的值不能变------s表示的是地址值
          final Student s = new Student();
          //可以给age赋值，因为是s.age是s里面的内容不是地址值，可以发生改变
          s.age =200;
          System.out.println(s.age);//200
  //        s= new Student();//报错--测试地址值不能发生改变
      }
  }
  class Student{
      int age =100;
  }

   

static关键字

static 关键字是静态的意思，可以修饰成员方法，成员变量

static修饰特点

1. 可以修饰成员变量与成员方法

2. 随着类的加载而加载，优先于对象加载

3. 只加载一次，就会一直存在，不再开辟新空间, 直到类消失才一起消失

4. 静态资源也叫做类资源,全局唯一,被全局所有对象共享-----------这也是我们判断是否使用静态关键字的条件

5. 可以直接被类名调用，当然也可通过对象名调用------------推荐：通过类名调用

6. 静态只能调用静态，非静态可以随意调用

7. static不能和this或者super共用，因为有static时可能还没有对象

静态资源

• 被static修饰的资源（变量、方法）被称为静态资源

• 被全局对象共享，可以不用new，而直接通过类名调用

public class oopStatic {
    public static void main(String[] args) {
        /*静态资源可以直接通过 类名调用-------->
        原因：静态资源优先于对象进行加载,它是随着类的加载而加载的
        比对象先加载进入内存，所以没对象也将可以通过类名直接调用
        */
        System.out.println("不创建对象直接通过类名调用静态资源name:" + Student.name);
//        Student.speak();报错
        Student.study();//别闹，学Java呢
        Student student = new Student();
        System.out.println("通过创建对象1调用非静态资源sno：" + student.sno);//0
        System.out.println("通过创建对象1调用静态资源name：" + student.name);//null
        student.sno = 10;//给非静态资源赋值
        student.name = "常世超";//给静态资源赋值
        System.out.println("给非静态资源赋值后,对象1的sno：" + student.sno);//10
        System.out.println("给静态资源赋值后,对象1的name：" + student.name);//常世超
        System.out.println("给静态资源赋值后,直接通过类名调用name：" + Student.name);//常世超
        student.speak();//会要大声说出来
        student.study();//别闹，学Java呢
        //创建多个对象
        //证明静态资源被全局所有对象共享
        Student student1 = new Student();
        System.out.println("通过创建对象2调用非静态资源sno：" + student1.sno);//0
        System.out.println("通过创建对象2调用静态资源name：" + student1.name);//常世超
        System.out.println("通过创建对象2,直接通过类名调用name：" + Student.name);//常世超
        student1.sno = 20;//给非静态资源赋值
        student1.name = "赵亚楠";//给静态资源重新赋值
        System.out.println("给非静态资源赋值后,对象1的sno：" + student.sno);//10
        System.out.println("给非静态资源赋值后,对象2的sno：" + student1.sno);//20
        System.out.println("给静态资源赋值后,对象1的name：" + student.name);//赵亚楠
        System.out.println("给静态资源赋值后,对象2的name：" + student1.name);//赵亚楠
        System.out.println("给静态资源赋值后,直接通过类名调用的name:" + Student.name);//赵亚楠
        student1.speak();//会要大声说出来
        student1.study();//别闹，学Java呢
    }
}
class Student{
    int sno;
    static String name;
   public static void study(){
        System.out.println("别闹，学Java呢");
    }
    public void speak(){
        System.out.println("会要大声说出来");
    }
}

static的访问特点

非静态的成员方法：

• 能访问静态的成员变量

• 能访问非静态的成员变量

• 能访问静态的成员方法

• 能访问非静态的成员方法

静态的成员方法：

• 能访问静态的成员变量

• 能访问静态的成员方法

总结：静态的成员方法只能访问静态成员