1、抽象类的定义语法；
2、抽象类的使用限制；
3、抽象类的实际应用。
抽象类
普通类可以直接产生实例化对象，并且在普通类之中可以包含有构造方法、普通方法、static方法、常量、变量等内容。而所谓的抽象类就是指增加了抽象方法的普通类。
所有的普通方法上都会有一个“{}”，表示方法体，有方法体的方法可以被对象直接使用。而抽象方法指得是没有方法体的方法，同时抽象方法必须使用abstract关键字进行定义。
拥有抽象方法的类一定属于抽象类，抽象类要使用_abstract_声明。
范例： 定义抽象类
abstract class A { // 定义一个抽象类
public void fun() { // 普通方法
System.out.println("存在方法体的方法！");
}
// 此方法并没有方法体的声明，并存在abstract关键字，表示抽象方法
public abstract void print();
}
既然定义好了抽象类，那么下面使用这个抽象类。
范例： 直接实例化对象？？？？？
public class MainClass {
public static void main(String[] args) {
A a = new A(); // A是抽象的，无法实例化
a.fun();
a.print();
}
}
这个时候发现根本就不能直接实例化A类对象。之所以不能实例化的原因：当一个类的对象实例化之后，就意味着这个对象可以调用类中的属性或者方法，但是在抽象类中存在有抽象方法，抽象方法没有方法体，无法进行调用。
对于抽象类的使用原则如下：
抽象类必须有子类，即：每一个抽象类一定要被子类所继承；
抽象类的子类（如果该子类不是抽象类）必须要覆写抽象类之中的全部抽象方法（强制子类覆写）；
抽象类的对象实例化需要依靠子类完成，采用向上转型的方式处理。
范例： 正确使用抽象类
abstract class A { // 定义一个抽象类
public void fun() { // 普通方法
System.out.println("存在方法体的方法！");
}
// 此方法并没有方法体的声明，并存在abstract关键字，表示抽象方法
public abstract void print();
}
// 一个子类只能够继承一个抽象类，属于单继承
class B extends A { // B类是抽象类的子类，并且是一个普通类
public void print() { // 强制要求覆写
System.out.println("Hello World");
}
}
public class MainClass {
public static void main(String[] args) {
A a = new B(); // 向上转型
a.fun();
a.print();
}
}
总结
1、抽象类继承子类里面会有明确的方法覆写要求，而普通类并没有；
2、抽象类只比普通方法多了一些抽象方法的定义，其他的组成部分与普通类完全一样；
3、普通类对象可以直接实例化，但是抽象类的对象必须经过向上转型之后才可以得到实例化对象。
虽然一个子类可以去继承任意的一个普通类，可是从开发的实际要求来讲，普通类不要去继承另一个普通类，而只能继承抽象类。
抽象类的相关限制
抽象类的组成和普通类的区别不大，但是由于有一点点使用以及定义上的区别，所以会有以下的概念可能会被忽略：
1、由于抽象类里面存在有属性，那么抽象类之中一定有构造方法，目的：初始化属性。子类调用的时候依然满足先执行父类构造再执行子类构造；
2、抽象类不能够使用final定义，因为抽象类必须由子类，而final定义的类不能够有子类；
3、外部的抽象类不允许使用static声明，而内部抽象类允许使用static声明，使用static声明的内部抽象类就相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。
abstract class A { // 定义一个抽象类
// static定义的内部类属于外部类
static abstract class B {
public abstract void print();
}
}
class X extends A.B {
public void print() {
System.out.println("Hello World");
}
}
public class MainClass {
public static void main(String[] args) {
A.B ab = new X(); // 向上造型
ab.print();
}
}
4、任何情况下，如果要执行类中的static方法，都可以在没有类实例对象的时候直接调用，对于抽象类也是一样。
abstract class A { // 定义一个抽象类
public static void print() {
System.out.println("Hello World");
}
}
public class MainClass {
public static void main(String[] args) {
A.print();
}
}
5、有些时候，由于抽象类只需要一个特定的系统操作，所以可以忽略掉外部子类。
abstract class A { // 定义一个抽象类
public abstract void print();
private static class B extends A { // 内部抽象类实现类
public void print() { // 覆写抽象类的方法
System.out.println("Hello World");
}
}
// 这个方法不受治理化对象的控制
public static A getInstance() {
return new B();
}
}
public class MainClass {
public static void main(String[] args) {
// 此时取得A类实例化对象的时候完全不需要知道B类的存在
A a = A.getInstance();
a.print();
}
}
这样的设计在系统类库之中会比较常见，目的：为用户隐藏不需要知道的子类。
对于之前有一个遗留的问题，下面来看一段代码，分析执行的结果。
abstract class A {
public A() { // 2、父类构造方法
this.print(); // 3、调用方法
}
public abstract void print();
}
class B extends A {
private int num = 100;
public B(int num) {
this.num = num;
}
public void print() { // 4、调用覆写后的方法
// num还没初始化，内容是其对应类型的默认值
System.out.println("num=" + num);
}
}
public class MainClass {
public static void main(String[] args) {
new B(100); // 1、执行构造
}
}
解决思路：在任何一个类的构造执行完之前，所有属性的内容都是其对应数据类型的默认值，而子类构造执行之前一定先执行父类构造，那么此时子类构造没有执行，所以num就是0。
抽象类应用 —— 模板设计
例如，现在有三类事务：
要求可以实现以上的操作控制，即：可以实现任意的控制人、机器人、猪的操作行为。
范例： 定义的是一个行为类
abstract class Action {
public static final int EAT = 1;
public static final int SLEEP = 5;
public static final int WORK = 7;
public void command(int flag) {
switch (flag) {
case EAT:
this.eat();
break;
case SLEEP:
this.sleep();
break;
case WORK:
this.work();
break;
case EAT + WORK:
this.eat();
this.work();
break;
}
}
public abstract void eat();
public abstract void sleep();
public abstract void work();
}
范例： 定义机器人的类
class Robot extends Action {
public void eat() {
System.out.println("机器人补充能量！");
}
public void sleep() {
}
public void work() {
System.out.println("机器人正在工作！");
}
}
范例： 定义人的类
class Human extends Action {
public void eat() {
System.out.println("人类正在吃饭！");
}
public void sleep() {
System.out.println("人类正在休息！");
}
public void work() {
System.out.println("人类正在工作！");
}
}
范例： 定义猪的类
class Pig extends Action {
public void eat() {
System.out.println("猪在吃饭！");
}
public void sleep() {
System.out.println("猪在睡觉！");
}
public void work() {}
}
这三个都属于行为的子类，所以都可以通过行为来控制。
public class MainClass {
public static void main(String[] args) {
fun(new Robot());
fun(new Human());
fun(new Pig());
}
public static void fun(Action action) {
action.command(Action.EAT);
action.command(Action.SLEEP);
action.command(Action.WORK);
}
}
这些不同的类型最终都在行为上成功的进行了抽象，即：如果想要使用行为操作，那么就必须按照Action类的标准来实现子类。
总结
1、如果要使用类继承那么就使用抽象类；
2、抽象类强制规定了子类必须要做的事情，而且可以与抽象类的普通方法相配合；
3、不管抽象类如何努力都有一个天生最大的问题：单继承局限。
