抽象类

在设计父类时优先考虑抽象类（类继承在于扩充已有类功能，但子类覆写是不被强制约定的），它的主要作用在于通过abstract方法对子类覆写方法进行约定。
abstract关键字定义没有方法体的抽象方法，有抽象方法的类必须是抽象类，抽象类可以包含抽象方法或普通方法

抽象类的使用：
抽象类必须被子类使用extends继承
抽象类的子类（不是抽象类）一定要覆写抽象类中的全部抽象方法；
抽象类的对象实例化可以利用对象多态性通过子类向上转型的方式完成

abstract class Message{//定义抽象类
	private String type;
	public void setType(String type){//定义普通方法
		this.type=type;
	}
	public String getType(S){
		return this.type;
	}
	public abstract String getConnectInfo();//定义抽象方法，方法体在子类中实现
}
class DatabaseMessage extends Message{
	public String getConnectInfo(){//覆写抽象方法（**方法覆写要求权限不能更严格所以是public，参数同）**
		return "hhh";
	}
}
public class JavaDemo{
	public static void main(String[] args){
		Message mag=new DatabaseMessage();//向上转型
		mag.setType("kk");
		System.out.println(mag.getType());
		Syatem.out.println(mag.getConnectInfo());
	}
}

从整体来看，抽象类比普通类增加了抽象方法以及强制性覆写

注意
1）抽象类主要目的是进行过度操作使用，往往用来处理继承问题带来的代码重复问题

2）抽象类无法直接实例化，抽象类的子类才可以实例化
3）在定义抽象类时不能使用final关键字，因为final定义类不能再有子类
4）抽象类可以提供static方法，并且该方法不受到抽象类实例化对象或结构的局限，直接可以通过类名称调用(普通方法只能通过抽象类子类的实例化对象调用)

abstract class Message{
	public abstract String getInfo();//抽象方法
	public static Message getInstance(){//static修饰
		return new DatabaseMessage();
	}
}
class DatabaseMessage extends Message{
	public String getInfo(){
		return "ddd";
	}
}
public class JavaDemo{
	public static void main(String args[]){
		Message msg=new DatabaseMessage();
		System.out.println(msg.getInfo());//输出ddd
		Message msg=Message.getInstance();
		System.out.println(msg.getInfo());//输出ddd
	}
}

5）抽象类是在普通类基础上增加抽象方法扩展而来的，所以具有属性方法 也就具有构造方法，并且子类会按照子类对象的实例化原则进行父类构造使用（父类只有显式有参构造，那么子类必须要通过有参构造完成实例化）

抽象类的应用
抽象类的设计应该是比普通类更高一层的设计，模板设计模式
以下command方法好比万能遥控器，控制Robot Person执行不同的方法以及同一方法的不同行为

abstract class Action{
	public static final int EAT=1;//类名称调用 Action.EAT
	public static final int SLEEP=5;
	public static final int WORK=10;
	public void command(int code){//通过command做一个方法的选择
		switch(code){
			case EAT:{this.eat(); break;}
			case SLEEP:{this.sleep();break;}
			case WORK:{this.work();break;}
			case EAT+SLEEP+WORK:{
				this.eat();
				this.sleep();
				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("rr")}
	public void sleep(){System.out.println("rr")}
	public void work(){System.out.println("rr")}
}
class Person extends Action{
	public void eat(){System.out.println("pp")}
	public void sleep(){System.out.println("pp")}
	public void work(){System.out.println("pp")}
}
public class JavaDemo{
	public static void main(String[] args){
		Action robotAction=new Robot();
		Action personAction=new Person();
		robotAction.command(Action.SLEEP);//子类对象调用继承的command方法，参数static直接通过类名称调用
		robotAction.command(Action.WORK);
		personAction.command(Action.SLEEP);//抽象方法在不同子类不同的实现
		personAction.command(Action.WORK);
	}
}

程序实现了一个行为的抽象处理，抽象类对所有行为规范进行统一处理，（提供了一个操作的模板）
如果子类自己定义一个方法想进行操作，父类不知道 则无法生效功能
抽象类实现了对子类方法的统一管理 自身提供普通方法调用抽象方法（抽象方法在子类提供实现则生效）