抽象类

普通类的特征是：类的结构很完整，而且可以直接产生实例化对象并使用。但是普通类之中所定义的方法都是具备方法体的“{}”，但是如果所现在一个
类之中的某些方法希望被子类强制进行重写，则可以将其定义为抽象方法，抽象方法使用abstract关键字声明，而且声明时没有方法体，而包含抽象方法的类

称为抽象类，抽象类也要使用abstract关键字进行定义

abstract class Aa{
private String msg="hello";
public void peint(){//普通方法
System.out.println("hello wordl");
}
public abstract void fun();//抽象方法

}

但是抽象类定义完成之后不能像普通类那样直接使用关键字new进行对象实例化操作（但是可以声明），因为一旦一个类实例化对象产生了，那么意味着可以
通过此对象调用类中的方法，可是抽象方法没有方法体，所以一定无法进行调用，那么对于抽象类的使用原则如下：
Aa a=null;//声明对象
a=new Aa();//实例化对象
抽象类一定要被子类所继承；
抽象类的子类（如果不是抽象类）则必须重写抽象类之中全部的抽象方法（强制重写）

抽象可以通过子类对象的向上转型实现类对象实例化操作

package polymorphic;
//abstract声明
abstract class Aa{
private String msg="hello";
public void peint(){//普通方法
System.out.println("hello wordl");
}
public abstract void fun();//抽象方法
}
class B extends Aa{
public void fun() {
System.out.println("输出数据");
}
}
public class Abstract {
public static void main(String[] args) {
// TODO Auto-generated method stub
Aa a=new B();
a.fun();
}
}

可以发现抽象类就是比普通类多了抽象方法的定义，但是在进行继承关系操作的时候，发现可以比普通类具备更强的制约性。即抽象类的子类
必须有明确的方法重写要求，而普通类没有。
问题1：请问抽象类在定义的时候能否使用final关键字？
不能，因为抽象类必须有子类，而final的定义的类不能有子类，所以这是矛盾的。
问题二：请问抽象之中能否定义构造方法？
能，因为抽象类只是比普通类多了抽象方法而已，其它的结构（属性，全局变量，普通方法）全都存在，而既然有属性了，那么一定要有构造方法
问题三：如果一个抽象类没有抽象方法是否正确？那么此时的抽象类能否直接产生实例化对象？
抽象类之中可以没有抽象方法，但是此时依然无法直接产生抽象类的实例化对象。
问题四：请问抽象类是否可以使用static关键字定义？（Abstracta）
如果现在在定义的是一个普通的外部类的话，那么无法使用static来定义抽象类，
如果现在在定义的是一个内部类，那么就可以使用static定义，因为使用static定义的内部类就成为了一个外部类。
package polymorphic;
abstract  class Ab{
public abstract void fun();
abstract static class B{//内部抽象类
public abstract void print();
}
}
class X extends Ab.B{
public void print() {
System.out.println("hello world");
}
}
public class Abstracta {
public static void main(String[] args) {
// TODO Auto-generated method stub
Ab.B b=new X();
b.print();
}


}
问题五：请问一个抽象类能否在此抽象类的内部提供实现此抽象类的子类昵？
一个抽象类的内部可以直接定义一个内部类继承本继承本抽象类
abstract class Ac{
public abstract void fun();
private class X extends Ac{
public void fun() {
System.out.println("hello wordl");
}
}
}
那么既然可以，请问如何取得Ac类实例化对象？此时Ac类四无法进行对象实例化的（Abstractb）
但是只有static方法可以不受类实例化对象的控制。
package polymorphic;
abstract class Ac{
public abstract void fun();
private static class Xa extends Ac{
public void fun() {
System.out.println("hello wordl .");
}
}
public static Ac getInstance() {
return new Xa();//Xa是Ac的子类
}
}
public class Abstractb {
public static void main(String[] args) {
// TODO Auto-generated method stub
Ac a=Ac.getInstance();
a.fun();
}

}

结果：hello wordl .

抽象类应用
首先抽象类一定不是一个具体的类，它只是一个半成品，而子类负责实现这些未实现的功能，
例如：现在做这样的一个程序，假设说现在有三个按钮，每个一个按钮就表示一种操作，而现在提供三个操作
吃饭，睡觉，工作。而现在又有三类事物
机器=吃饭，工作
猪=吃饭，睡觉
人=吃饭，睡觉，工作
那么现在该如何实现这样的类结构？
范例：代码实现：
package polymorphic;
abstract class Action{//操作行为
public static final int SLEEP=1;
public static final int EAT=5;
public static final int WORK=10;
public abstract void eat();
public abstract void sleep();
public abstract void work();
public void command(int flag) {
switch(flag) {
case SLEEP :
this.sleep();
break ;
case EAT :
this.eat();
break ;
case WORK :
this.work();
break ;
case SLEEP+EAT :
this.sleep();
this.eat();
break ;
case WORK+EAT :
this.work();
this.eat();
break ;
case SLEEP+EAT+WORK :
this.sleep();
this.eat();
this.work();
break ;
default :
System.out.println("错误：未知的命令");
}
}
}
class Robot extends Action{
public void eat() {
System.out.println("机器人补充能量：");
}
public void sleep() {}
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() {}
}
class Person extends Action{
public void eat() {
System.out.println("人在吃饭");
}
public void sleep() {
System.out.println("人在睡觉：");
}
public void work() {
System.out.println("人在工作和学习");
}
}
public class Abstractc {
public static void main(String[] args) {
// TODO Auto-generated method stub
Action actA=new Robot();
actA.command(Action.WORK+Action.EAT);
Action actB=new Pig();
actB.command(Action.SLEEP+Action.EAT);
Action actC=new Person();
actC.command(Action.SLEEP+Action.EAT+Action.WORK);
}

}

结果：

机器人在工作：
机器人补充能量：
猪在睡觉：
猪在进食
人在睡觉：
人在吃饭
人在工作和学习