java抽象类详解
目录
一、抽象类基本概念
二、抽象类的使用
三、抽象类的相关规定（使用限制）
四、抽象类的应用——模板设计模式
一、抽象类基本概念
含有抽象方法的类就是抽象类。普通类中可以含有构造方法，普通方法，static方法，常量和变量等内容，而抽象类就是在普通类的结构里增加了抽象方法。
抽象方法：我们知道所有的普通方法都会有一对“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用，而抽象方法就是没有方法体的方法。
且抽象方法必须用abstract修饰，而抽象方法所在的类必须用abstract声明，表示抽象类。
范例（定义一个抽象类）：
abstract class Person{ //定义一个抽象类
public void fun1() { //普通方法
System.out.println("有方法体的普通方法");
}
public abstract void fun2();//抽象方法(1)没有方法体 (2)有abstract修饰
}二、抽象类的使用
首先，如果直接实例化抽象类的对象
范例：
abstract class Person{ //定义一个抽象类
public void fun1() { //普通方法
System.out.println("有方法体的普通方法");
}
public abstract void fun2();//抽象方法(1)没有方法体 (2)有abstract修饰
}
public class TestDemo5 {
public static void main(String[]args){
Person student=new Person();
}
}
运行结果：
分析栗子可知：Person是抽象类，无法实例化，抽象类含有抽象方法，而抽象方法没有方法体，也就是没有具体实现，也就无法调用，因此抽象类不能直接产生实例化对象。
所以，小结一下：
抽象类的使用原则:
1、所有的抽象类必须有子类，使用关键字extends继承，一个子类只能继承一个抽象类；
2、抽象类不能直接实例化（不能直接new）,需要依靠子类向上转型的方式来处理；
3、抽象方法必须为public或protected（如果是private则不能被子类继承，子类无法实现该方法），缺省情况下，默认为public；
4、子类（非抽象类）必须复写父类（抽象类）中全部的抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为abstract）;
5、子类（抽象类），那么作为派生类的抽象类可以不实现父类的抽象方法。
范例（子类继承抽象类）：
abstract class Person{ //定义一个抽象类
public void fun1() { //普通方法
System.out.println("有方法体的普通方法");
}
public abstract void fun2();//抽象方法(1)没有方法体 (2)有abstract修饰
}
class Human extends Person{ //非抽象类单继承父类
@Override
public void fun2() { //强制覆写父类的抽象方法
System.out.println("实现父类的抽象方法");
}
}
public class TestDemo5 {
public static void main(String[]args){
Person student=new Human();//向上转型
//student.fun1();
student.fun2();//调用被子类覆写过的抽象方法
}
}
运行结果：
通过以上的例子可以知道，子类继承抽象类和非抽象类的区别：
1、继承抽象类，子类有明确的方法覆写要求，继承普通类，可以有选择性的来决定是否需要重写；
2、普通类对象可以直接实例化，而抽象类对象必须通过向上转型才能得到。
三、抽象类的相关规定（使用限制）
1、抽象类中的构造方法
抽象类只是比普通类多了一些抽象方法而已，因此，抽象类也有构造方法，并且，子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。
范例：
abstract class Person{ //定义一个抽象类
public Person() {
System.out.println("父类Person的构造方法");
}
/* public void fun1() { //普通方法
System.out.println("有方法体的普通方法");
}*/
public abstract void fun2();//抽象方法(1),没有方法体(2),有abstract修饰
}
//单继承
class Human extends Person{ //Human是Person的一个子类，是个普通类
public Human() {
System.out.println("子类Human的构造方法");
}
@Override
public void fun2() { //强制要求覆写
System.out.println("实现父类的抽象方法");
}
}
public class TestDemo5 {
public static void main(String[]args){
Person student=new Human(); //向上转型
student.fun2();
}
}运行结果：
2、fianal声明
抽象类不能用final声明，因为抽象类必须有子类，而final定义的类不能有子类。
3、抽象类能否用static声明
范例（外部抽象类用static）：
static abstract class Person{ //定义一个抽象类
public abstract void fun3();
}
class Human extends Person{
@Override
public void fun3() {
System.out.println("===华丽的分割线===");
}
}
public class TestDemo5{
public static void main(String[]args){
Person student=new Human();
student.fun3();
}
}运行结果：
范例（内部抽象类用static修饰）：
abstract class Person{ //定义一个抽象类
static abstract class A{
public abstract void fun3();
}
}
class Human extends Person.A{
@Override
public void fun3() {
System.out.println("===华丽的分割线===");
}
}
public class TestDemo5{
public static void main(String[]args){
Person.A student=new Human();
student.fun3();
}
}运行结果：
由此可知，外部的抽象类不允许用static修饰，而内部的抽象类可以用static修饰，使用static修饰的内部抽象类相当于一个外部抽象类，继承的时候使用“外部抽象类.内部抽象类”来表示类名称
4、思考：可以直接调用static修饰的方法吗?
任何时候，要执行类中static方法的时候，都可以在没有对象的情况下直接调用，抽象类也不例外。调用语法：类名.static修饰的方法
范例：
abstract class Person{ //定义一个抽象类
public static void fun4() {
System.out.println("===华丽的分割线===");
}
}
public class TestDemo5{
public static void main(String[]args){
Person.fun4();
}
}5、有时候，抽象类中只需要一个特点的系统子类操作，所以可以忽略掉外部子类，此模式非正常模式，但是对一些封装性有一定好处，目的是隐藏用户不需要知道的子类
范例：
abstract class Person{ //定义一个抽象类
public abstract void fun5();
private static class B extends Person{ //内部抽象类子类
@Override
public void fun5() { //覆写抽象方法
System.out.println("======");
}
}
public static Person getInstance() {
return new B();
}
}
public class TestDemo5{
public static void main(String[]args){
//此时取得抽象类对象的时候完全不需要知道B这个子类
Person student=Person.getInstance();
student.fun5();
}
}四、抽象类的应用——模板设计模式
开闭原则：一个软件实体如类，模板，函数，应该对扩展开放，对修改关闭
4.1、模板设计模式定义
定义一个操作的算法框架，而将一些步骤延迟到子类中。使得一个子类可以不改变一个算法的框架，即可重定义某些算法的特定步骤。
栗子：现有三类事务：
①学生：吃饭，学习，睡觉
②工人：吃饭，工作，睡觉
③婴儿：喝奶，睡觉
设计程序，实现三种不同事务的行为
类图：
（1）先定义一个抽象行为类，然后三类不同的人去实现它：
package com.WFG;
/**
* @Author WFG
* @Date 2019/4/19 16:34
*/
public abstract class Behavior {
protected abstract void eat();//吃饭
protected abstract void work();//工作
protected abstract void sleep();//休息
final void day(){
this.eat();
this.work();
this.sleep();
}
}
（2）定义学生类
package com.WFG;
/**
* @Author WFG
* @Date 2019/4/19 16:36
*/
public class Student extends Behavior {
@Override
protected void eat() {
System.out.println("学生吃饭");
}
@Override
protected void work() {
System.out.println("学生学习");
}
@Override
protected void sleep() {
System.out.println("学生休息");
}
}
（3）定义工人类
package com.WFG;
/**
* @Author WFG
* @Date 2019/4/19 16:40
*/
public class Woker extends Behavior {
@Override
protected void eat() {
System.out.println("工人吃饭");
}
@Override
protected void work() {
System.out.println("工人工作");
}
@Override
protected void sleep() {
System.out.println("工人休息");
}
}
（4）定义婴儿类
package com.WFG;
/**
* @Author WFG
* @Date 2019/4/19 16:43
*/
public class Baby extends Behavior{
@Override
protected void eat() {
System.out.println("婴儿喝奶");
}
@Override
protected void work() {
}
@Override
protected void sleep() {
System.out.println("婴儿休息");
}
}
（5）测试类：
package com.WFG;
/**
* @Author WFG
* @Date 2019/4/19 17:21
*/
public class TestDemo {
public static void main(String[]args){
Behavior student=new Student();
student.day();
Behavior woker=new Woker();
woker.day();
Behavior baby=new Baby();
baby.day();
}
}
（6）运行结果：
4.2、在上述例子中模板设计模式体现在哪呢？
注意：所谓模板设计模式就是定义一个操作的算法框架，很明显，抽象类中的day方法就是这个算法的框架也就是模板。
范例：看一个通用的模板设计模式
public abstract class AbstractClass{ //定义抽象类（包含子类的行为抽象以及模板）
abstract void Behavior1(); //基本行为（抽象方法）
abstract void Behavior2(); //基本行为（抽象方法）
final void tempeteMethod() { //模板方法
this.Behavior1();
this.Behavior2();
}
}public class ConcreteClass1 extends AbstractClass{
@Override
void Behavior1() {
//具体实现
}
@Override
void Behavior2() {
//具体实现
}
}public class ConcreteClass2 extends AbstractClass{
@Override
void Behavior1() {
//具体实现
}
@Override
void Behavior2() {
//具体实现
}
}4.3、模板设计模式的优点：
- 封装不变的内容，扩展可变的部分，如果我们要添加一个老人类，只需要继承父类就可以了；
- 提取公共部分的代码便于维护
- 行为由父类控制，子类实现，基本方法是由子类实现的，因此子类可以通过扩展的方法增加相应的功能，符合开闭原则
4.5、钩子方法
在上面的day方法中，eat（）、woke（）、sleep（）是子类必须实现的，而这三个方法的修改对应了不同的类，这个方法叫做基本方法，基本方法有三种：在抽象类中实现的基本方法叫做具体方法；在抽象类中没有实现，在子类中实现的基本方法叫做抽象方法；栗子所列出的几种方法都是抽象方法，还有一种钩子方法，如下：
钩子方法：模板模式的拓展
上述例子有个问题，人吃饭是默认进食，但吃饭与否的选择并没有实现
在原来设计的类图上增加一个方法：
isEat()，要不要吃饭，这就是钩子方法，修改抽象类：
package com.WFG;
/**
* @Author WFG
* @Date 2019/4/19 16:34
*/
public abstract class Behavior {
protected abstract void eat();//吃饭
protected abstract void work();//工作
protected abstract void sleep();//休息
final void day(){
if(this.isEat()) {
this.eat();
}
this.work();
this.sleep();
}
//钩子方法（默认做某事）子类视情况用不用覆盖它
protected boolean isEat() {
return true;
}
}
钩子方法是由抽象类实现的，子类可视情况重写：
（1）范例：学生永远不吃饭（好像不太恰当哈）
package com.WFG;
/**
* @Author WFG
* @Date 2019/4/19 16:36
*/
public class Student extends Behavior {
@Override
protected void eat() {
System.out.println("学生吃饭");
}
@Override
protected void work() {
System.out.println("学生学习");
}
@Override
protected void sleep() {
System.out.println("学生休息");
}
@Override
protected boolean isEat() {
return false;
}
}
（2范例：工人决定要吃饭
package com.WFG;
import java.util.Set;
/**
* @Author WFG
* @Date 2019/4/19 16:40
*/
public class Woker extends Behavior {
private boolean eatFlag=true;
@Override
protected void eat() {
System.out.println("工人吃饭");
}
@Override
protected void work() {
System.out.println("工人工作");
}
@Override
protected void sleep() {
System.out.println("工人休息");
}
@Override
protected boolean isEat() {
return this.eatFlag;
}
public void setEatFlag(boolean eatFlag) {
this.eatFlag =isEat();
}
}
测试代码：
public class TestDemo {
public static void main(String[]args){
Behavior student=new Student();
student.day();
Behavior woker=new Woker();
woker.day();
((Woker) woker).setEatFlag(true);
Behavior baby=new Baby();
baby.day();
}
}