抽象类

---

1.抽象类的定义

抽象类就是指在普通类的结构里面增加抽象方法，抽象方法就是没有方法体的方法，还必须使用abstract关键字定义，其他结构与普通方法完全一样。拥有抽象方法的类就是抽象类，抽象类也要使用abstract声明。

---

2.抽象类的使用

关于使用抽象类必须要遵循的原则：

• 抽象类必须有子类，即每一个抽象类都必须被子类所继承，在JAVA中每一个子类只能继承一个抽象类（单继承局限）；
• 抽象类的子类必须覆写抽象类中所有的抽象方法（强制子类覆写）；
• 抽象类不能直接实例化，必须依靠其子类向上转型完成抽象类的实例化对象操作。
  程序示例1：

abstract class A{
	public void fun(){
		System.out.println("抽象类中的普通方法！");
	}
	public abstract void paint();
}
class B extends A{
	public void paint(){
		System.out.println("Hello!");
	}
}
public class Test{
	public static void main(String[] args){
		A a = new B();
		a.paint();
	}
}
程序执行结果：Hello

3.抽象类的使用限制

（1）抽象类中同样存在构造方法，子类对象实例化时先执行父类构造在调用子类构造；
（2）抽象类不能使用fianl定义，应为抽象类必须有子类，而final定义的类不能有子类；
（3）抽象类中可以没有任何抽象方法，但是只要是抽象类，就不能直接使用new实例化对象；
（4）抽象类中依然可以定义内部的抽象类，而实现的子类也可以根据需求选择是否定义内部类来继承抽象内部类；
程序示例2：

abstract class A{                      //定义一个抽象类
	abstract class B{                  //定义一个内部抽象类
		public abstract void print();
	}
}
class X extends A{
	public void print(){
		System.out.println("Hello");
	}
	class Y extends B{
		public void print(){
		
		}
	}
}

（5）外部抽象类不允许使用static声明，而内部的抽象类允许使用static声明，使用static声明的内部抽象类就相当于一个外部抽象类，继承时使用 “外部类·内部类”的形式表示类名称。
程序示例3：

abstract class A{                      //定义一个抽象类
	static abstract class B{                  //定义一个内部抽象类
		public abstract void print();
	}
}
class X extends A.B{
	public void print(){
		System.out.println("Hello");
	}
}
public class Test{
	public static void main(String args[]){
		A.B ab = new X();
		ab.print();
	}
}

（6）在抽象类中，如果定义了static属性或方法时，就可以在没有对象时使用类名称直接调用。
程序示例4：

abstract class A{                      //定义一个抽象类
	public static void print(){             
		System.out.println("Hello World!");
	}
}
public class Test{
	public static void main(String[] args){
		A.print();         //直接调用static方法
	}
}
程序执行结果：Hello World!

拓展1：通过内部类的方式定义抽象子类，来隐藏抽象子类（static可以在抽象类中定义不受实例化对象限制的方法）。
程序示例：

abstract class A{                      //定义一个抽象类
	public abstract void print();
	private static class B extends A{
		public void print(){
			System.out.println("Hello CSDN");
		}
	}
	public static A getInstance(){
		return new B();
	}
}
public class Test{
	public static void main(String args[]){
		//此时取得抽象类对象时完全不需要知道子类B的存在
		A a =A.getInstance();
		a.print();
	}
}

拓展2：关于构造方法的补充（在任何一个类的构造执行完成前，所有的属性内容都是其对应默认值）
程序示例：

abstract class A{                      //定义一个抽象类
	public A(){                        //第二步
		this.print();                  //第三步
	}
	public abstract void print();
}
class B extends A{
	private int num=100;
	public B(int num){
		this.num=num;
	}
	public void print(){                //第四步
		System.out.println("num="+num);
	}
}
public class Test{
	public static void main(String args[]){
		new B(30);                     //第一步
	}
}
程序执行结果：num=0

4.抽象类的应用——模板设计模式

程序示例：

/**
 * 抽象类应用——模板设计模式
 * @author 2019-09-14
 *
 */

abstract class Action{    //定义一个抽象的行为类，行为不是具体的
	public static final int EAT=1;
	public static final int SLEEP=5;
	public static final int WORK=7;
	/**
	 * 控制操作行为。所有的行为都通过类中的属性来描述：EAT SLEEP WORK
	 * 还可以使用命令的叠加：EAT+WORK（边吃饭边工作）
	 */
	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 TestDDM {
	public static void main(String[] args) {
		fun(new Robot());
		fun(new Human());
		fun(new Pig());
	}
	public static void fun(Action act) {
		act.command(Action.EAT);
		act.command(Action.SLEEP);
		act.command(Action.WORK);
	}
}