（一)Java的抽象类

1.1 什么是抽象类?

• 在Java中有一个关键字叫:abstract，它就是抽象的意思，可以用它修饰类、成员方法
• abstract修饰类，这个类就是抽象类;
• abstract修饰方法，这个方法就是抽象方法。
  

1.2 抽象类的注意事项、特点

• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类，
• 类该有的成员(成员变量、方法、构造器)抽象类都可以有。
• 抽象类最主要的特点:抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现
• 一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类

1.3 认识一下抽象类

• 创建一个抽象类 该类有成员(成员变量、方法、构造器)

package com.qianxin.chouxiang;
//创建一个抽象类abstract
public abstract class A {
    //类该有的成员(成员变量、方法、构造器)抽象类都可以有
    private String name;
    public static String schoolName;

    // 抽象方法:必须用abstract修饰，但是方法只有方法签名 一定不能有方法体
    public abstract void  run();

    public A() {
    }

    public A(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static String getSchoolName() {
        return schoolName;
    }

    public static void setSchoolName(String schoolName) {
        A.schoolName = schoolName;
    }
}

抽象类最主要的特点:抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现

public class Test {

    public static void main(String[] args) {
        // 目标:认识抽象类和其特点。
        // 注意:抽象类不能创建对象
        A a = new A();  //报错
        a.run();
    }
}

一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则自己也要是抽象类 （alt+回车键重写方法）

public class B extends A{

    @Override
    public void run() {

    }
}

1.4 抽象类的场景和好处

• 父类知道每个子类都要做某个行为，但每个子类要做的情况不一样，父类就定义成抽象方法，交给子类去重写实现我们设计这样的抽象类，就是为了更好的支持多态

1.4.1 抽象类案例

需求

• 某宠物游戏，需要管理猫、狗的数据。
• 猫的数据有:名字;行为是:喵喵喵的叫~
• 狗的数据有:名字;行为是:汪汪汪的叫~
• 请用面向对象编程设计该程序。

再写一个测试类

• 实例化一个cat类，调用cry方法
• cat方法继承了animal的变量和方法

public class Test {
    public static void main(String[] args) {
        // 目标:掌握抽象类的好处,
        Animal a = new cat();
        a.setName("叮当猫");
        a.cry();// 更好的支持了多态
    }
}

1.5 抽象类的常见应用场景:模板方法设计模式

1.5.1 模板方法设计模式作用

• 解决方法中存在重复代码的问题。

1.5.1 模板方法设计模式的写法

• 1、定义一个抽象类。
• 2、在里面定义2个方法
  • 一个是模板方法:把相同代码放里面去
  • 一个是抽象方法:奥具体实现交给子类完成

第一步先来举个例子简单用来理解模板方法设计模式

• 学生，老师都要写一篇作文:我的爸爸
• 第一段是一样的
• 正文部分自由发挥
• 最后一段也是一样的。

那么我们就可以把相同的部分拿出来做模板，不同的部分作为变量来调用填充
下面这两段代码，可以对比一下重复的代码挺多的，我们可以做个模板

public class Teacher {
    public void write() {
        System.out.println("\t\t\t\t\t《我的爸爸》");
        System.out.println("\t\t我的爸爸好啊，牛逼啊，来看看我的爸爸有多牛");
        System.out.println("我的爸爸也挺好的，让我站在这里别走，他去买点橘子~~~");
        System.out.println("有这样的爸爸太好!");
    }
}

public class student {
    public void write() {
        System.out.println("\t\t\t\t\t《我的爸爸》");
        System.out.println("\t\t我的爸爸好啊，牛逼啊，来看看我的爸爸有多牛");
        System.out.println("我的爸爸特别牛，我开车都不看红绿灯的，下辈子还要做他的儿子~~");
        System.out.println("有这样的爸爸太好!");
    }
}

模板可以定义一个people类，把重复的代码写进去，然后用抽象类抽象方法，实现多态机制，让子类来重写writeMain()

public abstract class People {
/**
* 设计模板方法设计模式
* 1、定义一个模板方法出来次
 **/
    public final void write() { //final防止子类重写write方法  做个保护
        System.out.println("\t\t\t\t\t《我的爸爸》");
        System.out.println("\t\t我的爸爸好啊，牛逼啊，来看看我的爸爸有多牛");
        //2、模板方法并不清楚正文部分到底应该怎么写，但是它知道子类肯定要写。
        System.out.println(writeMain());//调用子类重写的方法来完整作文的正文
        System.out.println("有这样的爸爸太好!");
    }
    // 3、设计一个抽象方法写正文，具体的实现交给子类来完成
    public abstract String writeMain();
}

然后学生和老师那这个模板去写作文就行，正文自己重写自己的，代码可以这样写

public class Student extends People{

    @Override
    public String writeMain() {
        return "我的爸爸特别牛，我开车都不看红绿灯的，下辈子还要做他的儿子~~";
    }
}

public class Teacher extends People{

    @Override
    public String writeMain() {
        return "我的爸爸也挺好的，让我站在这里别走，他去买点橘子~~.";
    }
}

写一个测试类调用一下看看能不能写出作文

public class Test {
    public static void main(String[] args) {
        FoodOperator operator = new FoodOperator();
        operator.start();
        Teacher t = new Teacher();
        t.write();
        Students=new student();
		s.write();
    }
}

作文写的挺好

《我的爸爸》
我的爸爸好啊，牛逼啊，来看看我的爸爸有多牛
我的爸爸也挺好的，让我站在这里别走，他去买点橘子~~~


《我的爸爸》
我的爸爸好啊，牛逼啊，来看看我的爸爸有多牛
我的爸爸特别牛，我开车都不看红绿灯的，下辈子还要做他的儿子~~
有这样的爸爸太好!