五、JAVA的static和final关键字

1. static

1.1 概念

1、 是java中的一个关键字

2、 用于修饰成员（成员变量和成员方法）

1.2 特点

1、 可以修饰成员变量，成员方法

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

3、 只加载一次，就会一直存在，不再开辟新空间

4、 全局唯一，全局共享

5、 可以直接被类名调用

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

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

1.3 案例

public class aa {

       public static void main(String[] args) {
              //特点2，优先于对象加载，有没有对象都有static
              int i = Student.age;
              System.out.println(i);
       
              //特点3,只加载一次，就会一直存在，不再开辟新空间
              //创建对象
              Student s = new Student();
              Student s1 = new Student();
              //调用方法
              System.out.println(s.name);
              System.out.println(s.age);
              s.speak();
              s.eat();
           
       }
}

class Student{
       String name="张三";
       static int age=20;
  
       public void eat(){
              System.out.println("eat..");
       }
      
       public static void speak(){
              System.out.println("speak...");
       }
}

1.4 静态方法内存图

1.5静态调用关系案例

静态只能调用静态（变量或者方法），非静态可以访问所有的不管是不是静态

public class O {
       public static void main(String[] args) {
              Teacher t = new Teacher();
              t.speak();
       }
}
 
class Teacher{
       static int age=30;
       String name="王康";
      
       //非静态测试
       public void speak(){
              System.out.println(age);//非静态能调用静态变量
              System.out.println(name);//非静态能调用非静态变量
              qiao();//非静态能调用静态方法
       }
       //静态测试
       public static void qiao(){
              System.out.println(age);//静态能调用静态
//           System.out.println(name);//静态不能调用非静态变量，只能调用静态变量
//           speak();//静态不能调用非静态方法，只能调用静态方法
       }
      
}

1.6 静态代码块、构造代码块、局部代码块

1.6.1 静态代码块

随着类的加载而加载，并且只被加载一次，一般用于项目的初始化

static{
…
}

1.6.2 概述

1、 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化

2、 构造代码块：在调用构造方法前会自动调用，每次创建对象都会被调用

3、 局部代码块：方法里的代码块，方法被调用时才会执行

4、 静态代码块：static{ }，位置：在类里方法外

5、 静态代码块 - >构造代码块 -> 构造方法 -> 局部

1.6.3 案例

public class Test {
    public static void main(String[] args) {
       Car c = new Car();c.show();
       Car c2 = new Car();
    }
}

class Car{
    //静态代码块
    //1，在类第一次加载时就加载到内存中并一直驻存，
    //并全局共享,直到类消失静态资源才消失
    //2，并且静态资源只被加载一次
       static {
           System.out.println(1);
       }
      
       //构造代码块
       {
           System.out.println(2);
       }
      
       //  构造方法
       public Car() {
           System.out.println(3);
       }
      
       public void show() {
//     局部代码块
           {
              System.out.println(6);
           }
           System.out.println(4);
           System.out.println(5);
       }
}

2. final

2.1 概念

1、 是java提供的一个关键字

2、 final是最终的意思

3、 final可以修饰类，方法，成员变量

初衷是因为：java出现了继承后，子类可以更改父类的功能，当父类功能不许子类改变时可以利用final关键字修饰父类。

2.2 特点

1、 被final修饰的类，不能被继承

2、 被final修饰的方法，不能被重写

3、 被final修饰的变量是个常量，值不能被更改

4、 常量的定义形式： final 数据类型 常量名 = 值

2.3 入门案例

public class P {
       public static void main(String[] args) {
              Zi d = new Zi();
              d.speak();
              System.out.println(d.name);
              d.test();
       }
}

class Fu{
//final class Fu{//1，被final的类，不能被继承
       final String name="欢欢";
       //2，被final的方法，不能被重写
       public final void speak(){
              System.out.println("Fu..speak()");
       }
}

class Zi extends Fu{
       /*
        //2，被final的方法，不能被重写
        * public void speak(){
              System.out.println("Fu..speak()");
       }*/
      
       public void test(){
//           super.name="大黄";//3，被final的变量，不能重新被赋值
              System.out.println(super.name);
       }
}