抽象类

抽象类：普通类中添加抽象方法，不能实例化，【向上转型】之后实例化
        一定要（非抽象类的）子类覆写抽象类（父类）中●全部●的抽象方法【强制子类重写】
    ★★★强制规定了子类必须要做的事情，可以与自身的普通方法配合★★★
    ★缺点:单继承局限★
普通类：可以直接产生实例化对象，可以包含构造方法、普通方法、static方法、常量、变量的内容

抽象方法：没有{}，同时使用关键字abstract进行定义
抽象方法一定在抽象类（一定要使用abstract声明）中，抽象类中可以不要抽象方法

范例：
【class文件名和public对应的类名是一样的，class文件只能有一个public】
/**
 * 父类
 */
public abstract class B {
    /**
     * 普通方法
     */
    public void fun(){
        System.out.println("存在有方法体的方法！");
    }
    
    /**
     * 抽象方法
     */
    public abstract void print();
    
}

/**
 * 子类:一个子类只能继承一个抽象类，属于单继承局限
 */
class F extends B{
    @Override
    public void print() {//强制重写的抽象父类的抽象方法
        System.out.println("Hello");
    }
}

class Test{
    public static void main(String[] args) {
        B b= new F();//向上转型
        b.fun();
        b.print();//重写的print()方法
    }
}

注意：
    1.抽象类可以存在属性,那么抽象类就一定会存在构造方法,目的：为属性初始化，并且子类对象实例化
      的时候依然先执行父类构造，再调用子类构造
    2.抽象类不能用final定义:抽象类必须有子类，而final定义的类不能有子类
    3.外部抽象类不允许用static,内部的抽象类可以使用static,（此时的内部抽象类 = 外部抽象类）
      继承时使用“外部类.内部类”的形式表示类名称
范例：
/**
 * 父类
 */
public abstract class C {
    //static 定义的内部类属于外部类
    static abstract class G{
        public abstract void print();
    }
}

/**
 * 子类
 */
class X extends C.G{    //调用G的抽象方法
    @Override
    public void print() {
        System.out.println("*************");
    }
}


class TestC{
    public static void main(String[] args) {
        C.G cg= new X(); //调用G的抽象方法
        cg.print();
    }
}

任何情况下，如果要执行类中的static方法【抽象类】的时候，都可以在没有对象的时候直接调用
范例：
public abstract class StaticDemo {
    
    //静态普通方法
    public static void print(){
        System.out.println("Hello");
    }
}

class TestSttic{
    public static void main(String[] args) {
        //不要实例化对象，直接【类.方法】
        StaticDemo.print();
    }
}


★继承：唯一的对象，单例★
有时，抽象类只需一个特定的系统子类操作，可以忽略外部子类（父类内的带static的子类）
    为用户隐藏不需要知道的子类
范例：
public abstract class InsideSonType {
    public abstract void print();
    
    private static class B extends InsideSonType{  //内部抽象类子类
        public void print(){    //覆写抽象类的方法
            System.out.println("Hello World！");
        }
    }
    
    //这个方法不受实例化对象的控制
    public static InsideSonType getInstance(){
        return new B();
    }
    
public class Test {

    public static void main(String[] args) {    
        //此时取得抽象类对象的时候，完全可以不需知道子类B的存在
        InsideSonType insideSonType = InsideSonType.getInstance(); 
        insideSonType.print();
    }
}

类实例创建过程：
    按照父子继承关系进行初始化，首先执行父类的初始化块，然后执行父类的构造方法，
    其次执行继承的子类的初始化块，最后执行子类的构造方法
类实例销毁：
    先销毁子类部分，再销毁父类部分
范例:
public abstract class AbstractNum {
    /**
     * 父类的构造方法
     */
    public AbstractNum(){
        this.print();//调用print()方法
    }
    
    /**
     * 抽象方法
     */
    abstract void print();
    
    /**
     * 子类
     */
    class B extends AbstractNum{
        private int num = 100;
        ★没声明调用父类的构造方法，子类默认执行的是父类的无参构造方法★
        public B(int num){    //子类带参构造方法
            this.num = num;
        }
        @Override
        void print() {
            System.out.println("num = " + num);
        }
    }
}

public class Test {

    public static void main(String[] args) {
        new B(30);//只执行到父类的构造方法
    }
}


◆◆◆◆◆◆◆◆◆模板设计模式◆◆◆◆◆◆◆◆◆(工具画类图：umll)
☉机器人：充电、工作；
☉人：吃饭、工作、睡觉；
☉猪： 吃饭、睡觉。 
☉要求可以实现以上的操作控制，即：可以任意的控制人、机器人、猪的操作行为（吃、睡、工作）
abstract class Action {
    public static final int EAT = 1;    //常量，奇数比较合适
    public static final int SLEEP = 5;
    public static final int WORK = 7;
    public void command(int flag){
        //switch 只支持数值判断，而if支持条件判断
        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();
}

//子类Robot
public class Robot extends Action {
    public void eat(){
        System.out.println("机器人补充能量！");
    }
    public void sleep(){}
    public void work(){
        System.out.println("机器人正在努力工作！");
    }
}

//子类Human
public class Human extends Action {
     public void eat(){
         System.out.println("人类正在吃饭！");
     }
     public void sleep(){
        System.out.println("人类正在睡觉休息！"); 
     }
     public void work(){
         System.out.println("人为了梦想在努力工作！");
     }
}

//子类Pig
public class Pig extends Action{
     public void eat(){
         System.out.println("猪正在啃食槽！");
     }
     public void sleep(){
        System.out.println("猪在睡觉养膘！"); 
     }
     public void work(){}
}

//测试类
public class TestDemo {
    public static void main(String args[]){
        fun(new Robot());//调用static方法，不需实例化对象，直接调方法
        fun(new Human());
        fun(new Pig());
    }
    public static void fun(Action act){
        act.command(Action.EAT);
        act.command(Action.SLEEP);
        act.command(Action.WORK);
    }
}