Java10--static+静态代码块、构造代码块、局部代码块+final

1 static

1.1 概念

1、 是java中的一个关键字

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

1.2 特点

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

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

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

4、 全局唯一，全局共享

5、 可以直接被类名调用

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

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

1.3 练习1：入门案例

package cc;

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 练习2：静态调用关系

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

package cc;

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();//静态不能调用非静态方法，只能调用静态方法

       }
}

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

2.1 静态代码块

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

static{…}

2.2 概述

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

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

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

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

5、 TODO创建测试类，类中写好静态代码块，构造代码块，构造方法，普通方法里嵌套局部代码块。测试他们的执行顺序。

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

2.3 测试

package cn.tedu.staticdemo;
public class Test4 {
    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);
       }
}

3 final

3.1 概念

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

2、 final是最终的意思

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

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

3.2 特点

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

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

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

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

3.3 入门案例

package cc;

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 lass Fu{//1，被final的类，不能被继承
       final String name="欢欢";

       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);

       }
}