抽象类

抽象类：

使用abstract关键字修饰的类就是抽象类

抽象类不能创建对象，主要是用来给子类继承的

格式:
                    public abstract class 类名{
                        成员变量
                        构造方法
                        成员方法
                        抽象方法
                    }
               抽象类成员:
                    成员变量
                    构造方法
                    成员方法
                    抽象方法

不同类和抽象类的区别：

1. 普通类可以创建对象，抽象类不可以创建对象
2. 普通类没有抽象方法，抽象类有抽象方法

抽象方法:

抽象方法是没有方法体的，通过abstract进行修饰的方法就是抽象方法

抽象方法要求必须强制重写子类的重写

注意事项：

1. 抽象类不能被创建对象，只能作为父类，被子类继承
2. 抽象类可以有“构造方法”，为成员变量初始化使用
3. 抽象方法中可以没有抽象方法，但是抽象方法必须在抽象类中
4. 子类继承抽象类，必须重写抽象类中的所有方法，否则子类必须也是一个抽象类

package com.itheima.demo15_抽象类的注意事项;

/**
 * @Author：pengzhilin
 * @Date: 2020/9/6 15:00
 */
abstract class Animal{
    private String name;
    private int age;

    public Animal() {
    }

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

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

    // 抽象类没有抽象方法
}
class Dog extends Animal{
    public Dog() {
        super();
    }

    public Dog(String name, int age) {
        super(name, age);
    }
}

abstract class Person{
    // 抽象方法
    public abstract void eat();
    public abstract void drink();

}

//普通子类继承抽象类后,必须重写抽象类中所有的抽象方法
class Student extends Person{

    @Override
    public void eat() {
        // ...
    }

    @Override
    public void drink() {
        // ...
    }
}

//抽象子类继承抽象类后,可以不用重写抽象类中的抽象方法
 abstract class Teacher extends Person{
    @Override
    public void eat() {
        // ... 可以重写...
    }
}


public class Test {
    public static void main(String[] args) {
        /*
            抽象类的注意事项:
            - 抽象类不能被创建对象，就是用来做“父类”，被子类继承的。
            - 抽象类不能被创建对象，但可以有“构造方法”——为成员变量初始化。
            - 抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中(抽象类中不一定有抽象方法,但抽象方法一定在抽象类中)
            - 子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类

         */
        // 抽象类不能被创建对象，就是用来做“父类”，被子类继承的。
        //Animal anl = new Animal();

        // 抽象类不能被创建对象，但可以有“构造方法”——为成员变量初始化。
        Dog d = new Dog("旺财", 2);
        d.show();// 旺财,2
    }
}

模板设计模式：

抽象类可以作为一种模板的格式进行使用，抽取具体事务中的不确定的抽象方法，在方法外再次定义方法通过子类重写进行调用，剩下相同确定的事务直接使用，这样就能产生模板的效果。

设计模板就是为了解决一些问题时的固定思路，也就是代码设计思路上的总结。

public abstract class Person{
    // 有方法体的方法: 通用模板
    public void sleep(){
        System.out.println("两眼一闭,就睡觉...");
    }
    
    // 没有方法体的方法(抽象方法):  填充模板(要子类重新实现的)
   public abstract void eat();
}

抽象类体现的就是模板设计思想，模板是将通用的东西在抽象类中具体的实现，而模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求

模板实现的步骤：

1. 定义抽象父类作为模板

2. 在父类中定义"模板方法"--- 实现方法(通用模板)+抽象方法(填充模板)

3. 子类继承父类,重写抽象方法(填充父类的模板)

4. 测试类:创建子类对象，通过子类调用父类的“实现的方法”+ “子类重写后的方法”