阶段二12_面向对象高级_继承3

知识点内容：

抽象类
模板设计模式
final关键字

一.抽象类

(1)抽象类概述
抽象方法：将共性的行为（方法）抽取到父类之后，发现该方法的实现逻辑
无法在父类中给出具体明确，该方法就可以定义为抽象方法。
抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。

(2)抽象方法的定义格式：
public abstract 返回值类型 方法名(参数列表);

(3)抽象类的定义格式：
public abstract class 类名{}

二.抽象类入门案例

需求：

定义猫类（Cat）和狗类（Dog）
猫类成员方法：eat（猫吃鱼）drink（喝水…）
狗类成员方法：eat（狗吃肉）drink（喝水…）

分析：

猫类和狗类中存在共性内容，应向上抽取出一个动物类（Animal）
父类Animal中，无法将 eat 方法具体实现描述清楚，所以定义为抽象方法
抽象方法需要存活在抽象类中，将Animal定义为抽象类
让 Cat 和 Dog 分别继承 Animal，重写eat方法
测试类中创建 Cat 和 Dog 对象，调用方法测试

代码实现：
(1)抽象父类

public abstract class Animal {
    public Animal(){}
    public void drink(){ System.out.println("喝水"); }
    public abstract void eat();
}

(2)抽象子类

public class Cat extends Animal {
    @Override
    public void eat() { System.out.println("猫吃鱼"); }
}

(3)抽象子类

public class Dog extends Animal {
    @Override
    public void eat() {  System.out.println("狗吃肉"); }
}

(4)测试类：

public class Test1Animal {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.eat();
        d.drink();
        Cat c = new Cat();
        c.drink();
        c.eat();
    }
}

三.抽象类注意事项

1. 抽象类不能创建对象
2. 抽象类中有构造方法
3. 抽象类的子类
   A: 必须要重写父类中所有的抽象方法
   B: 可以将自己也变成一个抽象类
4. 抽象类中的方法
   抽象类中可以没有抽象方法, 但是有抽象方法的类一定是抽象类

四.模板设计模式

(1)模板设计模式：
把抽象类整体就可以看做成一个模板，模板中不能决定的东西定义成抽象方法
让使用模板的类（继承抽象类的类）去重写抽象方法实现需求。

(2)作文模板设计实现
①编写模板抽象类：

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("那是一个秋天, 风儿那么缠绵,记忆中, " +
       "那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");
    }
}

③测试模板类

public class Test {
    public static void main(String[] args) {
        Tom t = new Tom();
        t.write();
    }
}

打印结果：

<<我的爸爸>>
那是一个秋天, 风儿那么缠绵,记忆中, 那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...
啊~ 这就是我的爸爸

(3)小结：

模板设计模式的优势，模板已经定义了通用结构，使用者只需要关心自己需要实现的功能即可

五.final关键字

(1)final 关键字是最终的意思，可以修饰（方法，变量，类）
(2)final 修饰的特点
修饰方法：
表明该方法是最终方法，不能被重写

修饰变量：
表明该变量是常量，不能再次被赋值
修饰类：
表明该类是最终类，不能被继承

(3)final修饰变量:
基本数据类型变量: 其值不能被更改

常量的命名规范: 如果是一个单词, 所有字母大写, 如果是多个单词, 所有字母大写, 但是中间需要使用_分隔。
>>final int MAX = 10;
>>final int MAX_VALUE = 20;

引用数据类型变量: 地址值不能被更改, 但是可以修改对象的属性值

>>final Student stu = new Student();
>>stu.setName("张三");
>>stu.setName("李四");
 >>就改引用地址保存 // stu = new Student(); 

final修饰成员变量初始化时机

>>在创建的时候, 直接给值
>>在构造方法结束之前, 完成赋值

六.代码块

(1).在Java中，使用 { } 括起来的代码被称为代码块
(2).分类：

   局部代码块
		位置：方法中定义
		作用：限定变量的生命周期，及早释放，提高内存利用率
	构造代码块
		位置：类中方法外定义
		特点：每次构造方法执行的时，都会执行该代码块中的代码，并且在构造方法执行前执行
		作用：将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性
	静态代码块
		位置：类中方法外定义
		特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
		作用：在类加载的时候做一些数据初始化的操作

(3)案例普通代码块【限定变量的生命周期，及早释放，提高内存利用率】

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

(4)案例构造代码块【将多个构造方法中相同的代码，抽取到构造代码块中，提高代码的复用性】

 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("带参数构造方法...........");
    }
  }

(5)案例静态代码块【在类加载的时候做一些数据初始化的操作】

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类的带...........参数构造方法");
    }
  }