一、抽象类的基本概念
    普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。
    那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。
    而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。
    范例：定义一个抽象类

    1. abstract class A{//定义一个抽象类
    3.     public void fun(){//普通方法
    4.         System.out.println("存在方法体的方法");
    5.     }
    7.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
    9. }
    10. • 1
    11. • 2
    12. • 3
    13. • 4
    14. • 5
    15. • 6
    16. • 7
    17. • 8
    18. • 9

    二、抽象类的使用
    我们先看范例。
    范例：直接实例化抽象类的对象

    1. package com.wz.abstractdemo;
    2. abstract class A{//定义一个抽象类
    4.     public void fun(){//普通方法
    5.         System.out.println("存在方法体的方法");
    6.     }
    8.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
    10. }
    11. public class TestDemo {
    12.     public static void main(String[] args) {
    13.         A a = new A();
    14.     }
    15. }
    16. • 1
    17. • 2
    18. • 3
    19. • 4
    20. • 5
    21. • 6
    22. • 7
    23. • 8
    24. • 9
    25. • 10
    26. • 11
    27. • 12
    28. • 13
    29. • 14
    30. • 15
    31. • 16
    32. • 17
    33. • 18

    运行：

    1. Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    2.     Cannot instantiate the type A
    3.     at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)
    4. • 1
    5. • 2
    6. • 3
    7. • 4
    8. • 5

    从上可知，A是抽象的，无法直接进行实例化操作。为什么不能直接实例化呢？当一个类实例化之后，就意味着这个对象可以调用类中的属性或者放过了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。
    抽象类的使用原则如下：
    （1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
    （2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
    （3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
    （4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
    范例：

    1. package com.wz.abstractdemo;
    2. abstract class A{//定义一个抽象类
    4.     public void fun(){//普通方法
    5.         System.out.println("存在方法体的方法");
    6.     }
    8.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
    10. }
    11. //单继承
    12. class B extends A{//B类是抽象类的子类，是一个普通类
    13.     @Override
    14.     public void print() {//强制要求覆写
    15.         System.out.println("Hello World !");
    16.     }
    18. }
    19. public class TestDemo {
    20.     public static void main(String[] args) {
    21.         A a = new B();//向上转型
    23.         a.print();//被子类所覆写的过的方法
    24.     }
    25. }
    26. • 1
    27. • 2
    28. • 3
    29. • 4
    30. • 5
    31. • 6
    32. • 7
    33. • 8
    34. • 9
    35. • 10
    36. • 11
    37. • 12
    38. • 13
    39. • 14
    40. • 15
    41. • 16
    42. • 17
    43. • 18
    44. • 19
    45. • 20
    46. • 21
    47. • 22
    48. • 23
    49. • 24
    50. • 25
    51. • 26
    52. • 27
    53. • 28
    54. • 29

    运行结果：

    1. Hello World !
    2. • 1
    3. • 2

    现在就可以清楚的发现：
    （1）抽象类继承子类里面有明确的方法覆写要求，而普通类可以有选择性的来决定是否需要覆写；
    （2）抽象类实际上就比普通类多了一些抽象方法而已，其他组成部分和普通类完全一样；
    （3）普通类对象可以直接实例化，但抽象类的对象必须经过向上转型之后才可以得到。
    虽然一个类的子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类尽量不要去继承另外一个普通类，而是去继承抽象类。
    三、抽象类的使用限制
    （1）抽象类中有构造方法么？
    由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。
    并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。
    范例如下：

    1. package com.wz.abstractdemo;
    2. abstract class A{//定义一个抽象类
    4.     public A(){
    5.         System.out.println("*****A类构造方法*****");
    6.     }
    7.     public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
    9. }
    10. //单继承
    11. class B extends A{//B类是抽象类的子类，是一个普通类
    12.     public B(){
    13.         System.out.println("*****B类构造方法*****");
    14.     }
    16.     @Override
    17.     public void print() {//强制要求覆写
    18.         System.out.println("Hello World !");
    19.     }
    21. }
    22. public class TestDemo {
    23.     public static void main(String[] args) {
    24.         A a = new B();//向上转型
    25.     }
    26. }
    27. • 1
    28. • 2
    29. • 3
    30. • 4
    31. • 5
    32. • 6
    33. • 7
    34. • 8
    35. • 9
    36. • 10
    37. • 11
    38. • 12
    39. • 13
    40. • 14
    41. • 15
    42. • 16
    43. • 17
    44. • 18
    45. • 19
    46. • 20
    47. • 21
    48. • 22
    49. • 23
    50. • 24
    51. • 25
    52. • 26
    53. • 27
    54. • 28
    55. • 29
    56. • 30
    57. • 31
    58. • 32

    执行结果：

    1. *****A类构造方法*****
    2. *****B类构造方法*****
    3. • 1
    4. • 2

    （2）抽象类可以用final声明么？
    不能，因为抽象类必须有子类，而final定义的类不能有子类；
    （3）抽象类能否使用static声明？
    先看一个关于外部抽象类的范例：

    1. package com.wz.abstractdemo;
    2. static abstract class A{//定义一个抽象类
    4.     public abstract void print();
    6. }
    7. class B extends A{
    9.     public void print(){
    10.         System.out.println("**********");
    11.     }
    12. }
    13. public class TestDemo {
    14.     public static void main(String[] args) {
    15.         A a = new B();//向上转型
    16.         a.print();
    17.     }
    18. }
    19. • 1
    20. • 2
    21. • 3
    22. • 4
    23. • 5
    24. • 6
    25. • 7
    26. • 8
    27. • 9
    28. • 10
    29. • 11
    30. • 12
    31. • 13
    32. • 14
    33. • 15
    34. • 16
    35. • 17
    36. • 18
    37. • 19
    38. • 20
    39. • 21
    40. • 22
    41. • 23

    执行结果

    1. Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    2.     Illegal modifier for the class A; only public, abstract & final are permitted
    3.     at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
    4.     at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
    5.     at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)
    6. • 1
    7. • 2
    8. • 3
    9. • 4
    10. • 5
    11. • 6
    12. • 7

    再看一个关于内部抽象类：

    1. package com.wz.abstractdemo;
    2. abstract class A{//定义一个抽象类
    4.     static abstract class B{//static定义的内部类属于外部类
    5.         public abstract void print();
    6.     }
    8. }
    9. class C extends A.B{
    11.     public void print(){
    12.         System.out.println("**********");
    13.     }
    14. }
    15. public class TestDemo {
    16.     public static void main(String[] args) {
    17.         A.B ab = new C();//向上转型
    18.         ab.print();
    19.     }
    20. }
    21. • 1
    22. • 2
    23. • 3
    24. • 4
    25. • 5
    26. • 6
    27. • 7
    28. • 8
    29. • 9
    30. • 10
    31. • 11
    32. • 12
    33. • 13
    34. • 14
    35. • 15
    36. • 16
    37. • 17
    38. • 18
    39. • 19
    40. • 20
    41. • 21
    42. • 22
    43. • 23
    44. • 24
    45. • 25

    执行结果：

    1. **********
    2. • 1

    由此可见，外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。
    （4）可以直接调用抽象类中用static声明的方法么？
    任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。
    范例如下：

    1. package com.wz.abstractdemo;
    2. abstract class A{//定义一个抽象类
    4.     public static void print(){
    5.         System.out.println("Hello World !");
    6.     }
    8. }
    9. public class TestDemo {
    10.     public static void main(String[] args) {
    11.         A.print();
    12.     }
    13. }
    14. • 1
    15. • 2
    16. • 3
    17. • 4
    18. • 5
    19. • 6
    20. • 7
    21. • 8
    22. • 9
    23. • 10
    24. • 11
    25. • 12
    26. • 13
    27. • 14
    28. • 15
    29. • 16
    30. • 17
    31. • 18

    运行结果：

    1. Hello World !
    2. • 1
    3. • 2

    （5）有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。
    范例如下：

    1. package com.wz.abstractdemo;
    2. abstract class A{//定义一个抽象类
    3.     public abstract void print();
    5.     private static class B extends A{//内部抽象类子类
    7.         public void print(){//覆写抽象类的方法
    8.             System.out.println("Hello World !");
    9.         }
    10.     }
    12.     //这个方法不受实例化对象的控制
    13.     public static A getInstance(){
    14.         return new B();
    15.     }
    17. }
    18. public class TestDemo {
    19.     public static void main(String[] args) {
    21.         //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
    22.         A a = A.getInstance();
    23.         a.print();
    24.     }
    25. }
    26. • 1
    27. • 2
    28. • 3
    29. • 4
    30. • 5
    31. • 6
    32. • 7
    33. • 8
    34. • 9
    35. • 10
    36. • 11
    37. • 12
    38. • 13
    39. • 14
    40. • 15
    41. • 16
    42. • 17
    43. • 18
    44. • 19
    45. • 20
    46. • 21
    47. • 22
    48. • 23
    49. • 24
    50. • 25
    51. • 26
    52. • 27
    53. • 28
    54. • 29

    运行结果：

    1. Hello World !
    2. • 1

    四、抽象类的应用——模板设计模式
    例如，现在有三类事物：
    （1）机器人：充电，工作；
    （2）人：吃饭，工作，睡觉；
    （3）猪：进食，睡觉。
    现要求实现一个程序，可以实现三种不同事物的行为。
    先定义一个抽象行为类：

    1. package com.wz.abstractdemo;
    2. public abstract class Action{
    4.     public static final int EAT = 1 ;
    5.     public static final int SLEEP = 3 ;
    6.     public static final int WORK = 5 ;
    8.     public abstract void eat();
    9.     public abstract void sleep();
    10.     public abstract void work();
    12.     public void commond(int flags){
    13.       switch(flags){
    14.         case EAT:
    15.             this.eat();
    16.             break;
    17.         case SLEEP:
    18.             this.sleep();
    19.             break;
    20.         case WORK:
    21.             this.work();
    22.             break;
    23.         case EAT + SLEEP:
    24.             this.eat();
    25.             this.sleep();
    26.             break;
    27.         case SLEEP + WORK:
    28.             this.sleep();
    29.             this.work();
    30.             break;
    31.         default:
    32.             break;
    33.         }
    34.     }
    35. }
    36. • 1
    37. • 2
    38. • 3
    39. • 4
    40. • 5
    41. • 6
    42. • 7
    43. • 8
    44. • 9
    45. • 10
    46. • 11
    47. • 12
    48. • 13
    49. • 14
    50. • 15
    51. • 16
    52. • 17
    53. • 18
    54. • 19
    55. • 20
    56. • 21
    57. • 22
    58. • 23
    59. • 24
    60. • 25
    61. • 26
    62. • 27
    63. • 28
    64. • 29
    65. • 30
    66. • 31
    67. • 32
    68. • 33
    69. • 34
    70. • 35
    71. • 36
    72. • 37

    定义一个机器人的类：

    1. package com.wz.abstractdemo;
    2. public class Robot extends Action{
    3.     @Override
    4.     public void eat() {
    5.         System.out.println("机器人充电");
    7.     }
    8.     @Override
    9.     public void sleep() {
    11.     }
    12.     @Override
    13.     public void work() {
    14.         System.out.println("机器人工作");
    16.     }
    18. }
    19. • 1
    20. • 2
    21. • 3
    22. • 4
    23. • 5
    24. • 6
    25. • 7
    26. • 8
    27. • 9
    28. • 10
    29. • 11
    30. • 12
    31. • 13
    32. • 14
    33. • 15
    34. • 16
    35. • 17
    36. • 18
    37. • 19
    38. • 20
    39. • 21
    40. • 22
    41. • 23
    42. • 24

    定义一个人的类：

    1. package com.wz.abstractdemo;
    2. public class Human extends Action{
    3.     @Override
    4.     public void eat() {
    5.         System.out.println("人吃饭");
    7.     }
    8.     @Override
    9.     public void sleep() {
    10.         System.out.println("人睡觉");
    12.     }
    13.     @Override
    14.     public void work() {
    15.         System.out.println("人工作");
    17.     }
    19. }
    20. • 1
    21. • 2
    22. • 3
    23. • 4
    24. • 5
    25. • 6
    26. • 7
    27. • 8
    28. • 9
    29. • 10
    30. • 11
    31. • 12
    32. • 13
    33. • 14
    34. • 15
    35. • 16
    36. • 17
    37. • 18
    38. • 19
    39. • 20
    40. • 21
    41. • 22
    42. • 23

    定义一个猪的类：

    1. package com.wz.abstractdemo;
    2. public class Pig extends Action{
    3.     @Override
    4.     public void eat() {
    5.         System.out.println("猪进食");
    7.     }
    8.     @Override
    9.     public void sleep() {
    10.         System.out.println("猪睡觉");
    12.     }
    13.     @Override
    14.     public void work() {
    17.     }
    19. }
    20. • 1
    21. • 2
    22. • 3
    23. • 4
    24. • 5
    25. • 6
    26. • 7
    27. • 8
    28. • 9
    29. • 10
    30. • 11
    31. • 12
    32. • 13
    33. • 14
    34. • 15
    35. • 16
    36. • 17
    37. • 18
    38. • 19
    39. • 20
    40. • 21
    41. • 22
    42. • 23
    43. • 24

    测试主类：

    1. package com.wz.abstractdemo;
    2. public class AbstractDemo {
    3.     public static void main(String[] args) {
    5.         fun(new Robot());
    7.         fun(new Human());
    9.         fun(new Pig());
    10.     }
    12.     public static void fun(Action act){
    13.         act.commond(Action.EAT);
    14.         act.commond(Action.SLEEP);
    15.         act.commond(Action.WORK);
    16.     }
    17. }
    18. • 1
    19. • 2
    20. • 3
    21. • 4
    22. • 5
    23. • 6
    24. • 7
    25. • 8
    26. • 9
    27. • 10
    28. • 11
    29. • 12
    30. • 13
    31. • 14
    32. • 15
    33. • 16
    34. • 17
    35. • 18
    36. • 19
    37. • 20
    38. • 21
    39. • 22

    运行结果：

    1. 机器人充电
    2. 机器人工作
    3. 人吃饭
    4. 人睡觉
    5. 人工作
    6. 猪进食
    7. 猪睡觉
    8. • 1
    9. • 2
    10. • 3
    11. • 4
    12. • 5
    13. • 6
    14. • 7
    15. • 8

    所有的子类如果要想正常的完成操作，必须按照指定的方法进行覆写才可以，而这个时候抽象类所起的功能就是一个类定义模板的功能。