面向对象进阶：static，继承-EW帮帮网

// JavaBean类
public class Student {
    private String name;
    private int age;
    private String gender;
    public String teacherName;

    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getTeacherName() {
        return teacherName;
    }

    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }

    public void study(){
        System.out.println(name+"正在学习");
    }

    public void show(){
        System.out.println(name+", "+age+", "+gender+", "+teacherName);
    }
}

// 测试类
public class StudentTset {
    public static void main(String[] args) {
        // 创建第一个学生对象
        Student s1 = new Student();
        s1.setName("zhangsan");
        s1.setAge(20);
        s1.setGender("male");
        s1.teacherName = "Mr Li";

        s1.study();
        s1.show();

        // 创建第二个学生对象
        Student s2 = new Student();
        s2.setName("lisi");
        s2.setAge(20);
        s2.setGender("female");

        s2.study();
        s2.show();
    }
}

teacherName 是每一个对象的属性
现在只给第一个 s1 对象赋值了，所以有值
第二个 s2 对象没赋值，所以是 null

这不合理，因为一个班所有的学生应是共享同一个老师的

静态变量（需要共享时使用）

静态变量推荐使用类名调用
因为静态不属于对象，还用对象调用，不合理

被该类所有对象共享

// javabean类
public class Student {
    private String name;
    private int age;
    private String gender;
    private static String teacherName; // 加上static
}

static 静态变量内存图

程序刚开始启动，main 方法先进栈

然后是 main 方法当中的第一行代码
- 在这行代码当中，用类名（Student）调用了静态变量 teacherName，并赋值“阿玮老师”
用到了 Student 这个类，在内存中，就会把 Student 这个类的字节码文件加载到堆内存中（jdk8以后），并在内存中，创建了一个单独存放静态变量的空间（静态区）
- teacherName 引用数据类型，默认初始化值 null
内存中没有对象，静态变量随着类的加载而加载，优先于对象出现

第一行赋值完成，静态区中的 null 被覆盖成“阿玮老师”

第二行，有 new 关键字了，在堆中开辟了一个空间（即对象），在这空间里存储所有的非静态的成员变量，并进行默认初始化
再把小空间的地址赋值给 s1

赋值

用 s1 调用 show() 方法，show() 方法调用进栈
因为 show 方法的调用者是 s1，就会通过 s1 去找 name，age
然后再去找到静态区中的 teacherName

方法执行完毕，出栈

创建 s2，new，在堆中开辟空间
通过 s2 调用 show 方法，show 方法加载进栈。通过 s2 找属性，然后再到静态区中找 teacherName

show 方法执行完成，出栈

总结

静态区中的变量，是对象共享的，在内存中只有一份。而非静态的变量，每一个对象（每一个小空间）里单独存放的

静态方法

工具类

书写规则：类名见名知意

util，即 utility，工具

public class ArrUtil {

}

书写规则：私有化构造方法

构造方法私有后，外界不能创建这个类的对象
因为工具类不是描述一类事物的，创建它的对象没有意义

public class ArrUtil {

    private ArrUtil() {

    }
}

书写规则：方法定义为静态

方法定义为静态，方便调用

例：定义数组工具类

// 工具类
public class ArrayUtil {

    // 私有化构造方法
    // 目的：为了不让外界创建它的对象
    private ArrayUtil() {}

    // 工具方法定义为静态的，方便调用
    // 拼接数组方法
    public static String printArr(int[] arr){
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length-1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]+",");
            }
        }
        sb.append("]");
        return sb.toString(); // 把StringBuilder变回字符串
    }

    // 返回平均值方法
    public static double getAverage(double[] arr){
        double sum = 0;
        for(int i = 0; i < arr.length; i++){
            sum += arr[i];
        }
        return sum/arr.length;
    }
}

// 测试类
public class TestDemo {
    public static void main(String[] args) {
        // 测试工具类中的两个方法是否正确

        int[] arr1 = {1, 2, 3, 4, 5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);

        double[] arr2 = {11.4, 5.14, 1.919, 8.10};
        double avg = ArrayUtil.getAverage(arr2);
        System.out.println(avg);
    }
}