第七章 面向对象基础---下（静态）

1.静态

1.1 静态关键字（static）

        在类中声明的实例变量，其值是每一个对象独立的。但是有些成员变量的值不需要或不能每一个对象单独存储一份，即有些成员变量和当前类的对象无关。

        在类中声明的实例方法，在类的外面必须要先创建对象，才能调用。但是有些方法的调用和当前类的对象无关，那么创建对象就有点麻烦了。

此时，就需要将和当前类的对象无关的成员变量、成员方法声明为静态的（static）。

1.2 静态变量

1、语法格式

        有static修饰的成员变量就是静态变量。

【修饰符】 class 类{
	【其他修饰符】 static 数据类型  静态变量名;
}

2、静态变量的特点

• 静态变量的默认值规则和实例变量一样。

• 静态变量值是所有对象共享。

• 静态变量的值存储在方法区。

• 静态变量在本类中，可以在任意方法、代码块、构造器中直接使用。

• 如果权限修饰符允许，在其他类中可以通过“类名.静态变量”直接访问，也可以通过“对象.静态变量”的方式访问（但是更推荐使用类名.静态变量的方式）。

• 静态变量的get/set方法也静态的，当局部变量与静态变量重名时，使用“类名.静态变量”进行区分。

分类	数据类型	默认值
基本类型	整数（byte，short，int，long）	0
	浮点数（float，double）	0.0
	字符（char）	'\u0000'
	布尔（boolean）	false
	数据类型	默认值
引用类型	数组，类，接口	null

演示代码:

// 实例时记录有多少员工
public class Employee {
    private int id;
    private String name;
    private String password;
    static int total;

    {
        total++;
        this.id = total;
    }

    // 构造器
    public Employee(String name, String password) {
        this.name = name;
        this.password = password;
    }

    public Employee() {
    }

    // get/set 方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public static int getTotal() {
        return total;
    }

    public static void setTotal(int total) {
        Employee.total = total;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

public class TestEmployee {
    public static void main(String[] args) {
        Employee em1 = new Employee();
        Employee em2 = new Employee("员工1", "123");
        Employee em3 = new Employee("员工2", "123");
        Employee em4 = new Employee("员工3", "123");
        System.out.println(em1);
        System.out.println(em2);
        System.out.println(em3);
        System.out.println(em4);
        System.out.println(em1.total);
        System.out.println(Employee.total);
    }
    /*运行结果：
    Employee{id=1, name='null', password='null'}
    Employee{id=2, name='员工1', password='123'}
    Employee{id=3, name='员工2', password='123'}
    Employee{id=4, name='员工3', password='123'}
    4
    4*/
}

3、静态变量内存分析

4、静态类变量和非静态实例变量、局部变量

• 静态类变量（简称静态变量）：存储在方法区，有默认值，所有对象共享，生命周期和类相同，还可以有权限修饰符、final等其他修饰符

• 非静态实例变量（简称实例变量）：存储在堆中，有默认值，每一个对象独立，生命周期每一个对象也独立，还可以有权限修饰符、final等其他修饰符

• 局部变量：存储在栈中，没有默认值，每一次方法调用都是独立的，有作用域，只能有final修饰，没有其他修饰符

1.3 静态方法

1、语法格式

        有static修饰的成员方法就是静态方法。

【修饰符】 class 类{
	【其他修饰符】 static 返回值类型 方法名(形参列表){
        方法体
    }
}

2、静态方法的特点

• 静态方法在本类的任意方法、代码块、构造器中都可以直接被调用。

• 只要权限修饰符允许，静态方法在其他类中可以通过“类名.静态方法“的方式调用。也可以通过”对象.静态方法“的方式调用（但是更推荐使用类名.静态方法的方式）。

• 静态方法可以被子类继承，但不能被子类重写。

• 静态方法的调用都只看编译时类型。

// static 静态方法不能被重写，静态方法成不了虚方法
public class TestStaticMethod {
    public static void main(String[] args) {
        Father s = new Son();
        s.method();
        ((Son) s).method();
    }
}

class Father {
    private String name;

    public Father() {
    }

    public Father(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void method() {
        System.out.println("father---method");
    }
}

class Son extends Father {
    public static void method() {
        // 看似是重写，实则不是，static 修饰的静态方法，不允许被重写
        System.out.println("son---method");
    }
}
// 运行结果：
// father---method
// son---method

1.4 静态代码块

如果想要为静态变量初始化，可以直接在静态变量的声明后面直接赋值，也可以使用静态代码块。

1、语法格式

在代码块的前面加static，就是静态代码块。

【修饰符】 class 类{
    static{
        静态代码块
    }
}

2、静态代码块的特点

每一个类的静态代码块只会执行一次。

静态代码块的执行优先于非静态代码块和构造器。

public class Chinese {
//    private static String country = "中国";

    private static String country;
    private String name;

    {
        System.out.println("非静态代码块，country = " + country);
    }

    static {
        country = "中国";
        System.out.println("静态代码块");
    }

    public Chinese(String name) {
        this.name = name;
    }
}

public class TestStaticBlock {
    public static void main(String[] args) {
        Chinese c1 = new Chinese("张三");
        Chinese c2 = new Chinese("李四");
    }
}

3、静态代码块和非静态代码块

静态代码块在类初始化时执行，只执行一次

非静态代码块在实例初始化时执行，每次new对象都会执行

1.5 类初始化

Java 的执行顺序
加载时：静态的代码块，属性，方法都会在类加载时加载
实例化类：普通的属性 -> 普通的代码块 -> 构造方法 -> 普通方法顺序进行执行

父类的static 修饰的(属性，方法，代码区)->
子类的static 修饰的(属性，方法，代码区)->
当前的主程序->
父类的普通的属性->父类普通代码块->父类构造方法
子类的普通的属性->子类普通代码块->子类构造方法
子类的普通方法
注意：父类的普通方法根据子类的调用父类的普通方法的先后顺序来执行

（1）类的初始化就是为静态变量初始化。实际上，类初始化的过程时在调用一个<clinit>()方法，而这个方法是编译器自动生成的。编译器会将如下两部分的所有代码，按顺序合并到类初始化<clinit>()方法体中。

• 静态类成员变量的显式赋值语句

• 静态代码块中的语句

（2）每个类初始化只会进行一次，如果子类初始化时，发现父类没有初始化，那么会先初始化父类。

（3）类的初始化一定优先于实例初始化。

1、类初始化代码只执行一次

public class Fu{
    static{
        System.out.println("Fu静态代码块1，a = " + Fu.a);
    }
    private static int a = 1;
    static{
        System.out.println("Fu静态代码块2，a = " + a);
    }
    
    public static void method(){
        System.out.println("Fu.method");
    }

}

public class TestClassInit {
    public static void main(String[] args) {
        Fu.method();
    }
}

2、父类优先于子类初始化

public class Zi extends Fu{
    static{
        System.out.println("Zi静态代码块");
    }
}

public class TestZiInit {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}

3、类初始化优先于实例初始化

public class Fu{
    static{
        System.out.println("Fu静态代码块1，a = " + Fu.a);
    }
    private static int a = 1;
    static{
        System.out.println("Fu静态代码块2，a = " + a);
    }

    {
        System.out.println("Fu非静态代码块");
    }
    public Fu(){
        System.out.println("Fu构造器");
    }

    public static void method(){
        System.out.println("Fu.method");
    }
}
public class Zi extends Fu{
    static{
        System.out.println("Zi静态代码块");
    }
    {
        System.out.println("Zi非静态代码块");
    }
    public Zi(){
        System.out.println("Zi构造器");
    }
}

public class TestZiInit {
    public static void main(String[] args) {
        Zi z1 = new Zi();
        Zi z2 = new Zi();
    }
}

1.6 静态和非静态的区别

1、本类中的访问限制区别

        静态的类变量和静态的方法可以在本类的任意方法、代码块、构造器中直接访问。

非静态的实例变量和非静态的方法==只能==在本类的非静态的方法、非静态代码块、构造器中直接访问。

即：

• 静态直接访问静态，可以

• 非静态直接访问非静态，可以

• 非静态直接访问静态，可以

• 静态直接访问非静态，不可以

2、在其他类的访问方式区别

        静态的类变量和静态的方法可以通过“类名.”的方式直接访问；也可以通过“对象."的方式访问。（但是更推荐使用类名的方式）

非静态的实例变量和非静态的方法==只能==通过“对象."方式访问。

3、this和super的使用

        静态的方法和静态的代码块中，==不允许==出现this和super关键字，如果有重名问题，使用“类名.”进行区别。

        非静态的方法和非静态的代码块中，可以使用this和super关键字。

1.7 静态导入

        如果大量使用另一个类的静态成员，可以使用静态导入，简化代码。

import static 包.类名.静态成员名;
import static 包.类名.*;

演示代码：

import static java.lang.Math.*;

public class TestStaticImport {
    public static void main(String[] args) {
        //使用Math类的静态成员
        System.out.println(Math.PI);
        System.out.println(Math.sqrt(9));
        System.out.println(Math.random());

        System.out.println("----------------------------");
        System.out.println(PI);
        System.out.println(sqrt(9));
        System.out.println(random());
    }
}

后续内容，正在更新...