【Java语言基础】6.1 Java面向对象进阶

Java面向对象进阶

1. static关键字

1.1 static修饰成员变量

• static是静态的意思，可以修饰成员变量和成员方法。
• static修饰成员变量表示该成员变量在内存中只存储一份，可以被共享访问、修改。
• 静态成员变量（有static修饰，属于类，内存中加载一次）：常表示如在线人数信息、等需要被共享的信息，可以被共享访问。
• 实例成员变量（无static修饰，存在于每个对象中）：常表示姓名name、年龄age、等属于每个对象的信息。

public class User {
    // 用户在线人数
    public static int onlineNumber = 100;

    public String name;

    public int age;
}

/**
 * 目标：理解static修饰成员变量的作用和访问特点
 */
public class StaticFieldDemo1 {
    public static void main(String[] args) {
        System.out.println(User.onlineNumber); // 100

        User user = new User();
        user.name = "tom";
        user.age = 15;
        user.onlineNumber++;
        System.out.println(user.onlineNumber); // 101
        System.out.println(user.name); // tom
        System.out.println(user.age); // 15

        User user1 = new User();
        user1.name = "jack";
        user1.age = 13;
        user1.onlineNumber++;
        System.out.println(user1.onlineNumber); // 102
        System.out.println(user1.name); // jack
        System.out.println(user1.age); // 13

        System.out.println(User.onlineNumber); // 102
    }
}

1.2 static修饰成员方法

• 静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。
• 实例成员方法（无static修饰，归属于对象），只能用对象触发访问。

public class Student {
    public String name;

    public static int getMax(int a,int b){
        return a > b ? a : b;
    }

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

/**
 * 目标：理解static修饰成员方法的作用和访问特点
 */
public class StaticFieldDemo2 {
    public static void main(String[] args) {
        System.out.println(Student.getMax(5, 3)); // 5

        Student student = new Student();
        student.name = "张三";
        System.out.println(student.getMax(3, 6)); // 6
        student.study(); // 张三在学习
    }
}

使用场景：

1. 表示对象自己的行为的，且方法中需要访问实例成员的，则该方法必须申明成实例方法。
2. 如果该方法是以执行一个共用功能为目的的，则可以申明成静态方法。

• static访问注意事项：
  • 静态方法只能访问静态的成员，不可以直接访问实例成员。
  • 实例方法可以访问静态的成员，也可以访问实例成员。
  • 静态方法中是不可以出现this关键字的。

2. static应用知识

2.1 工具类

• 类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的。
• 调用方便，提高代码复用。（一次编写，处处可用）
• 由于工具类里面都是静态方法，直接用类名即可访问，因此，工具类无需创建对象，建议将工具类的构造器进行私有化。

2.2 代码块

• 代码块是类的5大成分之一（成员变量、构造器、方法、代码块、内部类），定义在类中方法外。
• 在Java类下，使用{}括起来的代码被称为代码块。
• 静态代码块：
  • 格式：static{}
  • 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次。
  • 使用场景：在类加载的时候做一些静态数据初始化的操作，以便后续使用。
• 构造代码块（了解即可）：
  • 格式：{}
  • 特点：每次创建对象，调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行。
  • 使用场景：初始化实例资源。

2.3 单例设计模式

• 开发中经常遇到一些问题，一个问题通常有n种解法，但其中肯定有一种解法是最优的，这个最优的解法被人总结出来，称之为设计模式。
• 设计模式有20多种，对应20多种软件开发中可能会遇到的问题。
• 单例模式：
  • 可以保证系统中，应用该模式的这个类永远只有一个实例，即一个类永远只能创建一个对象。
  • 例如任务管理器对象我们只需要一个就可以解决问题了，这样可以节省内存空间。
  • 单例模式有多种，如饿汉单例模式、懒汉单例模式等等。
• 饿汉单例设计模式：
  • 在用类获取对象的时候，对象已经提前为你创建好了。
  • 设计步骤：
    • 定义一个类，把构造器私有。
    • 定义一个静态变量存储一个对象。

/**
 * 饿汉单例模式
 */
public class SingleInstance {
    public static SingleInstance singleInstance = new SingleInstance();

    private SingleInstance() {
    }
}

• 懒汉单例设计模式：
  • 在真正需要该对象的时候，才去创建一个对象（延迟加载对象）。
  • 设计步骤：
    • 定义一个类，把构造器私有。
    • 定义一个静态变量存储一个对象。
    • 提供一个返回单例对象的方法。

/**
 * 懒汉单例模式
 */
public class SingleInstance2 {
    private static SingleInstance2 singleInstance;

    private SingleInstance2() {
    }

    public static SingleInstance2 getSingleInstance() {
        if (singleInstance == null){
            singleInstance = new SingleInstance2();
        }
        return singleInstance;
    }
}

2. 面向对象三大特征—继承

• Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。
  publi class Student extends People {}
• Student称为子类（派生类），People称为父类（基类或超类）。
• 作用：当子类继承父类后，就可以直接使用父类公共的属性和方法。
• 使用继承，将众多子类的共同特征提取为父类，子类继承父类，依然拥有这些属性和行为，提高了代码的复用性。

public class People {
    private String name;
    private int age;

    public People() {
    }

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

    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 void run(){
        System.out.println(this.name + "在奔跑");
    }
}

public class Student extends People{
    public void study(){
        System.out.println("学生在学习");
    }
}

public class Teacher extends People{
    public void teach(){
        System.out.println("老师在讲课");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("小明");
        student.setAge(15);
        student.study(); // 学生在学习
        student.run(); // 小明在奔跑

        Teacher teacher = new Teacher();
        teacher.setName("tony");
        teacher.setAge(25);
        teacher.teach(); // 老师在讲课
        teacher.run(); // tony在奔跑
    }
}

• 继承的特点：
  • 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
  • Java是单继承模式：一个类只能继承一个直接父类。
  • Java不支持多继承，但是支持多层继承。
  • Java中所有的类都是Object的子类。
• 在子类方法中访问成员（成员变量、成员方法）满足：就近原则。
  • 在子类局部范围找
  • 然后子类成员范围找
  • 然后父类成员范围找，如果父类范围还没有找到则报错。
• 如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的，则需要使用到super关键字。
• 在继承体系中，子类出现了和父类中一摸一样的方法声明，我们就称子类这个方法是重写的方法。
• 当子类需要父类的功能，但父类的该功能不完全满足自己的需求时，子类可以重写父类中的方法。
• @Override重写注解
  • @Override是放在重写后的方法上，作为重写是否正确的校验注解。
  • 加上该注解后如果重写错误，编译阶段会出现错误提示。
  • 建议重写方法都加上@Override注解，代码安全，优雅。
• 方法重写注意事项和要求
  • 重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
  • 私有方法不能被重写。
  • 子类重写父类方法时，访问权限必须不小于父类。
  • 子类不能重写父类的静态方法，如果重写会报错。