抽象类

1.1 概述

1.1.1 抽象类引入

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了(因为子类对象会调用自己重写的方法)。换句话说，父类可能知道子类应该有哪个功能，但是功能具体怎么实现父类是不清楚的（由子类自己决定），父类完全只需要提供一个没有方法体的方法签名即可，具体实现交给子类自己去实现。我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

• 抽象方法 ： 没有方法体的方法。
• 抽象类：包含抽象方法的类。

1.2 abstract使用格式

abstract是抽象的意思，用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

1.2.1 抽象方法

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

代码举例：

public abstract void run()；

1.2.2 抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。注意：抽象类不一定有抽象方法，但是有抽象方法的类必须定义成抽象类。

定义格式：

abstract class 类名字 { 
  
}

代码举例：

public abstract class Animal {
    public abstract void run()；
}

1.2.3 抽象类的使用

要求：继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。

代码举例：

// 父类,抽象类
abstract class Employee {
	private String id;
	private String name;
	private double salary;
	
	public Employee() {
	}
	
	public Employee(String id, String name, double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	// 抽象方法
	// 抽象方法必须要放在抽象类中
	abstract public void work();
}

// 定义一个子类继承抽象类
class Manager extends Employee {
	public Manager() {
	}
	public Manager(String id, String name, double salary) {
		super(id, name, salary);
	}
	// 2.重写父类的抽象方法
	@Override
	public void work() {
		System.out.println("管理其他人");
	}
}

// 定义一个子类继承抽象类
class Cook extends Employee {
	public Cook() {
	}
	public Cook(String id, String name, double salary) {
		super(id, name, salary);
	}
	@Override
	public void work() {
		System.out.println("厨师炒菜多加点盐...");
	}
}

// 测试类
public class Demo10 {
	public static void main(String[] args) {
		// 创建抽象类,抽象类不能创建对象
		// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
//		Employee e = new Employee();
//		e.work();
		
		// 3.创建子类
		Manager m = new Manager();
		m.work();
		
		Cook c = new Cook("ap002", "库克", 1);
		c.work();
	}
}

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

1.3 抽象类的特征

抽象类的特征总结起来可以说是 有得有失

有得：抽象类得到了拥有抽象方法的能力。

有失：抽象类失去了创建对象的能力。

其他成员（构造器，实例方法，静态方法等）抽象类都是具备的。

1.4 抽象类的注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

   理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2. 抽象类中，可以有构造器，是供子类创建对象时，初始化父类成员使用的。

   理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

   理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

   理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

5. 抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。

   理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

1.5 抽象类存在的意义

抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义，抽象类体现的是模板思想，模板是通用的东西抽象类中已经是具体的实现（抽象类中可以有成员变量和实现方法），而模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求，这是典型的模板思想。

1.6 第一个设计模式：模板模式

目标：使用抽象类设计一个模板模式。

设计模式：是前人（技术大牛，或者一些技术协会，或者一些大型知名的IT公司）
         已经研发好或者设计好的优秀软件设计思想，
         后来者可以直接使用就能够得到很好的软件模式。

模板模式是一种设计模式思想：
模板模式的作用：部分实现，部分抽象，可以极大的简化功能代码，提高开发效率
写一个模板模式的案例：作文模板。
    作文模板：标题和第一段 以及最后一段是固定的，正文部分交给使用模板的人自己来实现。

public class ExtendsDemo {
    public static void main(String[] args) {
        Student lty = new Student();
        lty.write();

        Teacher boZai = new Teacher();
        boZai.write();
    }
}


class Teacher extends Template{
    @Override
    public String writeMain() {
        return "\t\t我爸也挺好！";
    }
}

class Student extends Template{
    @Override
    public String writeMain() {
        return "\t\t我的爸爸很牛逼，我经常叼别人，我大概还需要2年才能出来，真香！";
    }
}

// 抽象类定义的作文模板
abstract class Template{
    // 标题和第一段 以及最后一段是固定的 : 部分实现
    private String title = "\t\t\t\t\t\t《我的爸爸》";
    private String one = "\t\t接下来介绍我的爸爸，我的爸爸很牛逼，到底有多牛逼拿，请看正文！";
    private String last = "\t\t我的爸爸真好，下辈子还要做他儿子。";

    // 提供一个写作文的方法
    public void write(){
        System.out.println(title);
        System.out.println(one);
        // 正文部分：交给使用模板的人来实现。所以定义成抽象方法！
        System.out.println(writeMain());
        System.out.println(last);
    }

    // 抽象方法：交给子类继承重写写正文
    public abstract String writeMain();
}

小结：
        模板模式的思想是：部分实现，部分抽象。
        模板是把能够确定的功能自己实现，不确定并且是由子类完成的定义成抽象方法，交给使用模板的人去实现。
        这样可以极大的简化功能代码！

总结
	 1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
         理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

     2. 抽象类一定有而且是必须有构造器，是供子类创建对象时，初始化父类成员使用的。
         理解：子类的构造器中，有默认的super()，需要访问父类构造器。

     3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

     4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类。

     5. 抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。
        理解：抽象类中已经实现的是模板中确定的成员，
        抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。