Java-final、static关键字

知识点1- final的定义

在Java中，final关键字有最终的，不可修改的含义
final 用于声明属性，方法和类

属性：定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能修改。

方法：定义必须有实现代码，并且子类里不可被覆盖。

类：不能被定义为抽象类或是接口,不可被继承。

知识点2- final修饰属性

如果某个变量被final修饰，那么该变量就成为常量，不能被修改，一般语法：

常量在声明时必须初始化，声明之后不能对其进行二次赋值，其后任何试图对常量进行赋值的语句都将报错。
final修饰类的成员变量时，成员变量可以不在定义时初始化，而在构造函数中初始化
规范：定义常量的时候，变量名所有字母都大写，每个单词之间使用下划线
赋值两种方式：构造方法赋值和声明时等号赋值
一些数学定理中的常量经常使用final修饰

eg:π= 3.14159265358979; E= 2.718281828459045;
对参数做final修饰
- 在方法参数前面加final关键字，为了防止数据在方法体中被修改。

package com.tjetc.myfinal;
public class FinalTest {
    //方式一：定义常量直接赋值
    public static final int USER_ROLE = 1; //final修改属性，属性就是常量，不能二次赋值
    //public static final int ADMIN_ROLE; //当使用方法二构造方法进行给常量值赋值的情况，不能使用static
    public final int ADMIN_ROLE;
    // new一个对象开内存空间，常量的值是不变的，意味着没有必要为常量开多个内存空间。多个对象共享一个常量，static保证多个对象共享一个。
    // 一般情况：定义常量static+final一起用
    //方式二：构造方法给常量赋值
    public FinalTest(int adminRole) {
        this.ADMIN_ROLE = adminRole;
    }
    public void test() {
        //USER_ROLE=2; //不能二次赋值
        System.out.println("常量USER_ROLE=" + USER_ROLE);
        System.out.println("常量ADMIN_ROLE=" + ADMIN_ROLE);
    }
    public static void main(String[] args) {
        FinalTest test = new FinalTest(6);
        test.test();
        System.out.println("常量USER_ROLE=" + test.USER_ROLE);
    }
}
/**
 * 常量USER_ROLE=1
 * 常量ADMIN_ROLE=6
 * 常量USER_ROLE=1
 */

知识点3- final修饰方法

如果将某个成员方法修饰为final，则意味着该方法不能被子类覆盖，这就和抽象方法必须由子类实现的规定互相矛盾，因此，final和abstract不能同时修饰一个方法
final方法的一般声明格式是：

知识点4- final修饰类

如果将某个类修饰为final，则说明该类无法被继承，一般语法：
Java中有一个最常用的final类：java.lang.String

知识点5-静态的定义

static被称为静态，可以用来修饰类的属性或者方法。
如果类的某个属性，不管创建多少个对象，属性的存储空间只有唯一的一个，那么这个属性就应该用static修饰，被static修饰的属性被称为静态属性，被static修饰的方法被称为静态方法。
static属性可以使用对象调用，也可以直接用类名调用。
静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中只有一个。

知识点6-静态成员变量

被static修饰的成员变量被称为静态成员变量或者是静态属性

package com.tjetc.myfinal;
public class Employee {
    String name;
    double salary;
    //默认是0  静态成员变量  是所有对象共享的一个成员变量，可以使用对象调用也可以使用类名称调用
    static int count;
    //默认是0  成员变量    每个对象 有各自的成员变量，不共享的
    int myCount;
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
        //让count和myCount 都自增1
        count++;
        myCount++;
    }
    public static void main(String[] args) {
        Employee e1 = new Employee("carat", 10000);
        System.out.println("姓名:" + e1.name + "\t工资：" + e1.salary + "\tcount:" + e1.count + "\tmyCount:" + e1.myCount);
        Employee e2 = new Employee("seventeen", 15000);
        System.out.println("姓名:" + e2.name + "\t工资：" + e2.salary + "\tcount:" + e2.count + "\tmyCount:" + e2.myCount);
    }
}
/**
 * 姓名:carat    工资：10000.0    count:1    myCount:1
 * 姓名:seventeen    工资：15000.0    count:2    myCount:1
 */

知识点7-静态方法

如果某个方法不需要与某个特定的对象绑定，那么该方法可以使用static修饰，被static修饰的方法称为静态方法。
静态方法可以被重载，不能被覆盖（重写）

静态方法如何调用：static方法可以使用对象调用，也可以直接用类名调用，建议用类名直接调用。

package com.tjetc.myfinal;
public class SellTicket {
    private static int a = 10;//静态成员变量
    private int b;   //成员变量

    //静态方法 能够只用静态的成员变量
    public static void sell() {
        //静态方法中 可以定义局部变量并且使用
        int c = 4;
        System.out.println("使用局部变量c=" + c);
        //静态方法 不能够使用成员变量（非静态）
        //b = 2;b无法使用
        a -= 1;
        System.out.println("使用静态成员变量：" + a);
    }
    public static void main(String[] args) {
        //通过类名调用方法,以下两种都可以
        SellTicket.sell();
        sell();
        //通过对象名调用
        SellTicket sell1 = new SellTicket();
        sell1.sell();
    }
}
/**
 * 使用局部变量c=4
 * 使用静态成员变量：9
 * 使用局部变量c=4
 * 使用静态成员变量：8
 * 使用局部变量c=4
 * 使用静态成员变量：7
 */

知识点7-静态方法-总结

本类的方法之间的调用
- 静态方法可以被任何方法(静态方法和非静态方法)直接调用；
- 非静态方法可以被非静态方法直接调用；
- 非静态方法不能被静态方法直接调用，需要创建对象，用对象名调用。
不同类方法之间的调用
- 调用静态方法，使用类名直接调用 ;
- 非静态方法不能直接调用，需要创建对象，用对象名调用。

知识点8-静态代码块

static代码块

随着类的加载而加载，只执行一次，用于给类进行初始化

看JVM加载类的过程：装载、连接、初始化（静态代码块，静态变量）

static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。
构造代码块（实例代码块）
构造方法给对象初始化
静态类不能被继承
static代码块和构造代码块同时出现时优先级

静态代码块>构造代码块>构造方法

package mystatic;
//优先父类初始化
class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }
    //在实例化对象过冲程中，早于构造方法执行
    {
        System.out.println("I'm A class");
    }
    //static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。在实例化对象之前
    static {
        System.out.println("static A");
    }
}
class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    {
        System.out.println("I'm B class");
    }

    static {
        System.out.println("static B");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}
/**
 * static A
 * static B
 * I'm A class
 * HelloA
 * I'm B class
 * HelloB
 */