目录

• 一、继承的概念
• 二、继承中成员变量的访问
• 三、继承中成员方法的访问
• 四、方法重写
• 五、继承中构造方法的访问
• 六、抽象类
• 七、模板设计模式
• 八、final关键字
• 九、代码块

一、继承的概念

• 继承的概念：继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
• 实现继承的格式：继承通过extends实现；格式：class 子类 extends 父类 { }
  • class Dog extends Animal { }
• 继承的特点：继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员
• 继承的好处
  • 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
  • 提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
• 继承的弊端：继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
• 继承的应用场景：使用继承，需要考虑类与类之间是否存在is…a的关系，不能盲目使用继承
  • is…a的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

  public class Fu {
      public void show() {
          System.out.println("show方法被调用");
      }
  }
  public class Zi extends Fu {
      public void method() {
          System.out.println("method方法被调用");
      }
  }
  public class Demo {
      public static void main(String[] args) {
          //创建对象，调用方法
          Fu f = new Fu();
          f.show();

          Zi z = new Zi();
          z.method();
          z.show();
      }
  }

• 继承的特点
  • Java中类只支持单继承，不支持多继承
    • 错误范例：class A extends B, C { }
  • Java中类支持多层继承

public class A {
    public void methodA(){
        System.out.println("AAA..类中的method方法");
    }
}
public class B extends A {
    public void methodB(){
        System.out.println("BBB...类中的method方法");
    }
}
public class C extends B{

}
public class TestExtends {
    public static void main(String[] args) {
        C c = new C();
        c.methodA();
        c.methodB();
    }
}

二、继承中成员变量的访问

• 继承变量的访问特点：在子类方法中访问一个变量，采用的是就近原则
  • a）子类局部范围找
  • b）子类成员范围找
  • c）父类成员范围找
• 重名的访问特点：如果子父类中，出现了重名的成员变量，通过就近原则，会优先使用子类的；如果一定要使用父类的，可以通过super关键字进行区分
• this和super
  • this：代表本类对象的引用
  • super：代表父类存储空间的标识（可以理解为父类对象引用）

public class Fu {
    int a = 10;
}
public class Zi extends Fu {

    // 子父类当中, 出现了重名的成员变量
    int a = 20;

    public void method(){
        int a = 30;
        System.out.println(a);  // 30
        // 需求1: 在控制台打印本类成员变量 20
        System.out.println(this.a);
        // 需求2: 在控制台打印父类成员变量 10
        System.out.println(super.a);
    }
}
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

三、继承中成员方法的访问

• 通过子类对象访问一个方法
  • 子类成员范围找
  • 父类成员范围找

public class Fu {
    public void show(){
        System.out.println("父类show方法");
    }
}
public class Zi extends Fu {
    public void show(){
        System.out.println("子类show方法");
    }

    public void method(){
        this.show();
        super.show();
    }
}
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
    }
}

四、方法重写

• 方法重写概念：子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
• 方法重写的应用场景：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
• Override注解：用来检测当前的方法，是否是重写的方法，起到【校验】的作用

public class iPearV1 {
    /*
        1. 定义手机类 iPearV1
                    call(String name) : 打电话方法
                    smallBlack() : 语音助手 (speak english...)
     */
    public void call(String name){
        System.out.println("给" + name + "打电话");
    }

    public void smallBlack(){
        System.out.println("speak english...");
    }
}
public class iPearV2 extends iPearV1 {
    /*
        2. 定义新手机类 iPearV2
                    call(String name) : 打电话方法
                    smallBlack() : 语音助手 (speak english...  说中文)
     */
    public void smallBlack(){
        super.smallBlack();
        System.out.println("说中文");
    }
}
public class TestOverride {
    public static void main(String[] args) {
        iPearV2 i = new iPearV2();
        i.smallBlack();
    }
}

• 方法重写的注意事项
  • 父类中私有方法不能被重写(父类私有成员子类是不能继承的)
  • 父类非静态方法，子类也必须通过非静态方法进行重写；静态方法不能被重写
  • 子类重写父类方法时，访问权限必须大于等于父类(public > 默认 > 私有)
• 权限修饰符
  

public class Fu {
    private void show() {
        System.out.println("Fu中show()方法被调用");
    }
    void method() {
        System.out.println("Fu中method()方法被调用");
    }
}
public class Zi extends Fu {
    /* 编译【出错】，子类不能重写父类私有的方法*/
    @Override
    private void show() {
        System.out.println("Zi中show()方法被调用");
    }
    /* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    private void method() {
        System.out.println("Zi中method()方法被调用");
    }
    /* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
    @Override
    public void method() {
        System.out.println("Zi中method()方法被调用");
    }
}

五、继承中构造方法的访问

• 继承中构造方法的访问特点
  • 子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化， 原因在于，每一个子类构造方法的第一条语句默认都是：super()
  • 如果我们编写的类，没有手动指定父类，系统也会自动继承Object类（java体系中最顶层的父类）
• 如果父类没有无参构造，只有有参构造的情况
  • 解决方案：通过使用super关键字去显示的调用父类的带参构造方法

public class Test2 {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}
class Fu {
    int age;
    // 带参数构造方法
    public Fu(int age){
        this.age = age;
    }
}
class Zi extends Fu {
    public Zi(int age){
        super(age);
    }
}

六、抽象类

• 抽象类的概述：当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了
  • 在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类
• 抽象类的特点
  • 抽象类和抽象方法必须使用 abstract 关键字修饰
  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  • 抽象类不能实例化
  • 抽象类可以有构造方法
  • 抽象类的子类：要么重写抽象类中的所有抽象方法、要么是抽象类
• 案例：猫和狗

public abstract class Animal {
    public void drink(){
        System.out.println("喝水");
    }
    public abstract void eat();
}
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}
public class Test1Animal {
    /*
        需求：定义猫类（Cat）和狗类（Dog）
            猫类成员方法：eat（猫吃鱼）drink（喝水…）
            狗类成员方法：eat（狗吃肉）drink（喝水…）
        步骤：
            1. 猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）
            2. 父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法
            3. 抽象方法需要存活在抽象类中，将Animal定义为抽象类
            4. 让 Cat 和 Dog 分别继承 Animal，重写eat方法
            5. 测试类中创建 Cat 和 Dog 对象，调用方法测试
     */
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.drink();

        Cat c = new Cat();
        c.drink();
        c.eat();
		
		//抽象类不能实例化
        //Animal a = new Animal();
        //a.eat();
    }
}

七、模板设计模式

• 设计模式：设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结；使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性
• 模板设计模式：把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法，让使用模板的类（继承抽象类的类）去重写抽象方法实现需求
• 模板设计模式的优势：模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可

/*
    作文模板类
 */
public abstract class CompositionTemplate {
    public final void write(){
        System.out.println("<<我的爸爸>>");
        body();
        System.out.println("啊~ 这就是我的爸爸");
    }
    public abstract void body();
}
public class Tom extends CompositionTemplate {

    @Override
    public void body() {
        System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " +
                "那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");
    }
}

八、final关键字

• final概念：final代表最终的意思，可以修饰成员方法，成员变量，类
• final修饰的特点
  • 修饰方法：表明该方法是最终方法，不能被重写
  • 修饰变量：表明该变量是常量，不能再次被赋值
  • 修饰类：表明该类是最终类，不能被继承
• final修饰变量
  • 基本数据类型变量：其值不能被更改
  • 引用数据类型变量：地址值不能被更改，但是可以修改对象的属性值
• final修饰变量的初始化时机
  • 在创建的时候, 直接给值
  • 在构造方法结束之前, 完成赋值

public class TestFinal {
    public static void main(String[] args) {
        // 常量的命名规范: 如果是一个单词, 所有字母大写, 如果是多个单词, 所有字母大写, 但是中间需要使用_分隔
        final int A = 10;
        // a = 10;
        final int MAX = 10;
        final int MAX_VALUE = 20;
        final Student stu = new Student();
        stu.setName("张三");
        stu.setName("李四");
        // stu = new Student();
    }
}

九、代码块

• 局部代码块
  • 位置：方法中定义
  • 作用：限定变量的生命周期，及早释放，提高内存利用率

public class Test {
    public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }
    }
}

• 构造代码块
  • 位置：类中方法外定义
  • 特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
  • 作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
  • 应用场景：如果多个构造方法中存在相同的代码或业务逻辑，就可以考虑使用构造代码块
    • 如下面的案例，每个Student初始化的时候都要打印“好好学习”，不论是无参构造还是有参构造

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        Student stu2 = new Student(10);
    }
}
class Student {
    {
        System.out.println("好好学习");
    }
    public Student(){
        System.out.println("空参数构造方法");
    }
    public Student(int a){
        System.out.println("带参数构造方法...........");
    }
}

• 静态代码块
  • 位置：类中方法外定义
  • 特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
  • 作用：在类加载的时候做一些数据初始化的操作

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person(10);
    }
}
class Person {
    static {
        System.out.println("我是静态代码块, 我执行了");
    }
    public Person(){
        System.out.println("我是Person类的空参数构造方法");
    }
    public Person(int a){
        System.out.println("我是Person类的带...........参数构造方法");
    }
}