//抽象类不可以被实例化，抽象类中可以没有抽象方法，但有抽象方法的类必须声明为抽象类
//抽象方法的声明必须使用abstract修饰符修饰
//抽象类中可以存在成员变量以及成员方法
//抽象方法重写 方法名以及参数列表 返回值必须保持一致
//被final修饰的类不可继承，方法不可重写，成员变量值不可更改，参数不可更改
//static 静态方法 ，属于类，不可被重写,在编译时被静态编译

//接口中的成员变量默认被修饰为 public static final
//接口中的方法默认被修饰为 public abstract
//接口默认为public 修饰
//继承接口的类必须实现所有的接口中的方法

//如若同时继承抽象类和接口 两者存在同名未实现方法 若在子类中实现其方法 则等于对
//接口中的方法实现 并且抽象类中的同名方法也会调用接口中子类实现的方法

//如若同时继承父类和接口 两者存在同名方法 若在子类中实现其方法 则等于对
//父类已实现的方法的重写 并且接口中的同名方法也会调用被重写的父类方法

//如若同时继承两个接口 两者存在同名方法 若在子类中实现其方法 则等于对
//接口中的方法实现 并且两个接口中的同名方法也会调用子类实现的接口中的方法

//方法实现(重写)优先级： 父类 > 接口 > 抽象父类

//接口可以继承接口


public class AbstractMain {
    public static void main(String[] args){

        System.out.println("Test Abstract Class");
/*
        X _a = new A(123,456);
        X _b = new B(888,999);

        _a.testPrint();
        _b.testPrint();

        ((A) _a).testPrintA();
        ((B) _b).testPrintB();

        System.out.println(_a);
        System.out.println(_b);


        Behavior _bc = new BC(000,111);

        _bc.eat();
        _bc.fuck();

        BehaviorCopy _bcbc = new BCBC(321,123);
        _bcbc.eat();
        _bcbc.fuck();
        */

        BehaviorCopy _cccc = new CCCC();

        _cccc.eat();
        _cccc.fuck();

    }
}

abstract class X {
   public int a;
   public int b;

    X(){}
    X(int a,int b){
        this.a = a;
        this.b = b;
    }

    public abstract void testPrint();

}

class A extends X {

    A(int a, int b) {
        super(a, b); //初始化
    }


    public void testPrint() {
        System.out.println("我是A类对象");
    }

    public void testPrintA() {
        System.out.println("类A独有方法");
    }

    @Override
    public String toString() {
        return a + " " + b;
    }
}

class B extends X {
    public final int bb = 33;


    B(final int a, int b){
        super(a,b); //初始化
    }


    public void testPrint(){
        System.out.println("我是B类对象");
    }

    public final void testPrintB(){
        System.out.println("类B独有方法");
    }

    @Override
    public String toString() {
        return a + " " + b;
    }
}
class BC extends B implements Behavior,BehaviorCopy{

    BC(int a,int b){
        super(a,b);

    }
   public void eat(){
        System.out.println("I eat food");
    }

   public void fuck(){
        System.out.println("I Fuck you");
    }


}

class BCBC extends BC{

    BCBC(int a,int b){
        super(a,b);
    }

    public void eat(){
        System.out.println("Super I eat food");
    }

    public void fuck(){
        System.out.println("Super I Fuck you");
    }

}

interface Behavior {

    void eat();
    void fuck();
}
 abstract class CC{
    abstract void eat();
    abstract void fuck();
}

interface BehaviorCopy {

    void eat();
    void fuck();
}
class CCCC extends CC implements BehaviorCopy{

    public void eat(){
        System.out.println(" I eat food");
    }

    public void fuck(){
        System.out.println(" I Fuck you");
    }