Java-抽象类

一、什么是抽象类

  1. 抽象方法,使用abstract修饰,没有方法体。
  2. 包含抽象方法的类,称为抽象类。abstract class A{…}。
  3. 抽象类的对象不能直接new实例化。

二、抽象类使用原则

  1. 抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类;
  2. 子类必须覆写抽象类中的所有抽象方法;
  3. 抽象类对象可以使用对象的向上转型方式,通过子类进行实例化操作。

三、抽象类注意事项

Q1:抽象类是否可以用final定义?
A1:不能,因为抽象类必须含有子类,final定义的太监类没有子类。
Q2:抽象类中能否包含构造方法?
A2:可以,因为抽象类中除了包含构造方法外,还包含普通方法和属性,而属性一定要在构造方法执行完毕之后才能进行初始化操作。
Q3:抽象类之中能都不包含抽象方法?
A3:可以,抽象类中可以没有抽象方法,但如果有抽象方法,这个类一定是抽象类。即使抽象类中没有抽象方法,也不能被直接实例化。
package com.joeaaa.demo07;

/*
* 抽象类
* 狗:吃饭+睡觉+跑
* 机器人:吃饭+工作
* 人:吃饭+睡觉+跑+工作
*/


/*
* 定义行为
*/
abstract class Action{
    public static final int EAT = 1;
    public static final int SLEEP = 2;
    public static final int RUN = 4;
    public static final int WORK = 8;
    
    // 任务列表
    public void order(int flag){
        switch(flag){
            case EAT:
                this.eat();
                break;
            case SLEEP:
                this.sleep();
                break;
            case RUN:
                this.run();
                break;
            case WORK:
                this.work();
                break;
            case EAT+SLEEP+RUN:
                this.eat();
                this.sleep();
                this.run();
                break;
            case EAT+WORK:
                this.eat();
                this.work();
                break;
            case EAT+SLEEP+RUN+WORK:
                this.eat();
                this.sleep();
                this.run();
                this.work();
                break;
        }
    }
    public abstract void eat();
    public abstract void sleep();
    public abstract void run();
    public abstract void work();
}

/*
* 定义狗的行为
*/
class Dog extends Action{
    public void eat(){
        System.out.println("dog is eating.");
    }
    public void sleep(){
        System.out.println("dog is sleeping");
    }
    public void run(){
        System.out.println("dog is running");
    }
    public void work(){}
}

/*
* 定义机器人的行为
*/
class Robot extends Action{
    public void eat(){
        System.out.println("robot is eating.");
    }
    public void sleep(){ }
    public void run(){ }
    public void work(){
        System.out.println("robot is working");
    }
}

/*
* 定义人的行为
*/
class Human extends Action{
    public void eat(){
        System.out.println("human is eating.");
    }
    public void sleep(){
        System.out.println("human is sleeping.");
    }
    public void run(){
        System.out.println("human is running.");
    }
    public void work(){
        System.out.println("human is working");
    }
}

public class AbstractTest {
    public static void main(String[] args) {
        Action act1 = new Dog();
        act1.order(Action.EAT + Action.SLEEP+ Action.RUN);
        System.out.println("-----------------");
        Action act2 = new Robot();
        act2.order(Action.EAT + Action.WORK);
        System.out.println("-----------------");
        Action act3 = new Human();
        act3.order(Action.EAT + Action.SLEEP+ Action.RUN + Action.WORK);
    }
}
dog is eating.
dog is sleeping
dog is running
-----------------
robot is eating.
robot is working
-----------------
human is eating.
human is sleeping.
human is running.
human is working