Java基础-面向对象相关（二）

继承

子类继承父类使用的是extends关键字。Java继承的特点是单继承。

优点

1.提高代码的复用性。
2.让类与类之间产生了关系，为多态提供了前提。

使用场景

当事物之间存在着所属关系时，可以通过继承来体现这个关系。

对比多继承

多继承复用性更高，单继承复用性低。
多继承关系复杂且有菱形缺陷，单继承没有。
PS：
1.菱形缺陷：B、C两个类同时继承于A，D继承于B和C，如果B和C中存在同名方法，不知道执行从哪个类种中继承过来的。
2.所有类的根类是Object。

子类重写父类方法Override

前提：

子类可以访问父类方法。

注意事项：

1.子类方法覆盖父类方法，必须保证权限大于等于父类的权限。
2.静态只能覆盖静态，或者被静态覆盖。
PS：注意是覆盖，不是重写。写上super.run（）;会报错

参考代码

父类-Person类

public class Person {
    private String name;// 私有变量能继承，不能访问
    private int age;

    public Person() {
        System.out.println("Person init");
    }

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

    public void eat() {

    }

    public static void run() {
        System.out.println("run");
    }

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

子类-Teacher类

public class Teacher extends Person {

    private int number;
    public static String haha = "haha";


    public Teacher() {
        System.out.println("Teacher init");
    }// 会先调用父类的无参构造方法

    public Teacher(String name, int age, int number) {
        super(name, age);//调用父类的构造器
        this.number = number;
    }


    /**
     * 重写父类方法
     * 注意事项：
     *     子类方法权限大于等于父类方法权限
     *     子类可以访问父类被重写的方法；
     */

    @Override/*加上注解会为我们检测父类是否拥有当前方法，
    如果没有代表不是重写，会提示我们*/
    public void eat() {
        super.eat();// super指的是父类的空间，不是父类对象
        System.out.println(getName());
    }

    public static void run() {
        System.out.println("Teacher Run!");
    }// 静态只能覆盖静态，或者被静态覆盖 注意是覆盖，不是重写。 
    方法内写super.run（）;会报错
}

单例设计模式

解决问题

保证一个类的对象在内存中的唯一性。

应用场景

多处需要共享数据的时候。

步骤

1.类中构造函数私有化。
2.在本类中new一个对象。
3.定义一个静态方法返回该对象。

代码

饿汉式

public class Singleton {
    // 在本类中创建一个对象
    private static final Singleton s = new Singleton();

    // 构造器私有化
    private Singleton() {

    }
    // 在静态方法中将对象返回
    public static Singleton getInstance() {

        return s;
    }

}

懒汉式

public class SingletonSecond {
    private static SingletonSecond s = null;

    private SingletonSecond() {
    }

    // 延迟加载内存，不调用getInstance()，不开辟内存
    public static SingletonSecond getInstance(){
        if (s ==null) {
            s = new SingletonSecond();
        }
        return s;
    }

}

final关键字

1.可以修饰类：被final修饰的类不可被继承（断子绝孙）
2.可以修饰方法：被final修饰的方法不能被重写
3.可以修饰变量：被final修饰的变量被初始化后不能被更改值（只初始化一次）