抽象类的定义及使用

抽象类的定义及使用

抽象类只是在普通类的基础上扩充了一些抽象方法，抽象方法是只声明未实现

所有抽象方法要用abstract定义，抽象方法的类也要使用abstract定义类，表示抽象类

抽象类就是比普通多了抽象方法而已，

abstract class A{
    private String msg="www.mldn.cn";//属性
    public void print(){//方法
        System.out.println(msg);
    }
    //{}为方法体，所有抽象方法上是不包含方法体的
    public abstract void fun();//抽象方法
}
class B extends A{//定义抽象类的子类。
    public void fun(){
        System.out.println("hello world");
    }
}
public class Newbegin{
    public static void main(String args    []) {
        A a=new B();//实例化子类对象
        a.fun();
    }
} 

抽象类的使用原则：

1.所有的抽象类必须有子类

2.抽象类的子类（不是抽象类）必须覆写抽象类的所有方法

　　方法的覆写一定要考虑到权限问题，抽象方法可以使用任意权限，权限尽量都用public

3.抽象类的对象可以用个对象的多态性，子类为其实例化

抽象类，有抽象方法 有子类继承抽象类。子类要覆写抽象类中的抽象方法。

抽象类的相关规定

1.抽象类只比普通多了一些抽象方法，抽象类也有构造方法，实例化子类前，一定要调用父类的构造方法，

范例：在抽象类中定义构造方法。

　　

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(this.num);
    }
}
public class Newbegin{
    public static void main(String args    []) {
        new B(30);//实例化子类对象。
    }
}

2.抽象类中允许不定义任何的抽象方法，此时抽象类对象依然无法直接实例化处理

3.抽象类不能用final声明，因为抽象类必须有子类，

  抽象方法不能使用private定义，因为抽象方法必须被覆写。

4.抽象类分为内部抽象类和外部抽象类可以使用static定义，描述为外部抽象类

范例：观察内部抽象类

abstract class A{
    public abstract void print();
    abstract class B{
        public abstract void printB();
    }
}
class X extends A{
    public void print(){
        
    }
    class Y extends B{
        public void printB(){
        
        }
    }
}
public class Newbegin{
    public static void main(String args    []) {
        
    }
}

我们要在外部抽象类上使用了static那么就是语法错误，但内部抽象类加上static就没有错

模板设计模式

abstract class Action{
    public static final int EAT=1;
    public static final int SLEEP=5;
    public static final int WORK=10;
    public void command(int cmd){
        switch(cmd){
            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 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(){    
    }
}
class Robot extends Action{
    public void eat(){
        System.out.println("机器人吃饭");
    }
    public void sleep(){
    }
    public void work(){
        System.out.println("机器人工作");
    }

}
public class Newbegin{
    public static void main(String args    []) {
        fun(new Human());
        fun(new Pig());
        fun(new Robot());
    }
    public static void fun(Action action){
        action.command(Action.EAT+Action.SLEEP+Action.WORK);
    }
}