// 抽象類和抽象方法需要被 abstract 關(guān)鍵字修飾
abstract class Shape {
    // 抽象類中的方法一般要求都是抽象方法，抽象方法沒有方法體
    abstract void draw();
}

// 抽象類和抽象方法需要被 abstract 關(guān)鍵字修飾
abstract class Shape {
    // 抽象類中的方法一般要求都是抽象方法，抽象方法沒有方法體
    abstract void draw();
}
// 當(dāng)一個普通類繼承一個抽象類后，這個普通類必須重寫抽象類中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重寫抽象類中的draw方法
        System.out.println("畫一個圓圈");
    }
}
 
public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象類雖然不能直接實例化
        // 但可以把一個普通類對象傳給一個抽象類的引用呀，即父類引用指向子類對象
        Shape shape = new Cycle(); // 這稱作：向上轉(zhuǎn)型
        
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 這是向上轉(zhuǎn)型的另一種寫法
         */
        shape.draw();         // 通過父類引用調(diào)用被子類重寫的方法
    }
}

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具體的語句
}
// 當(dāng)一個普通類繼承一個抽象類的時候，再這個子類中必須重寫抽象類中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重寫會報錯，但如果繼承的是普通類則不會報錯，用抽象類更安全
    public void draw() {
        System.out.println("畫一個圓圈");
    }
}
class Flower extends Shape { // 不同的子類對父類的draw方法進(jìn)行了不同的重寫
    @Override
    public void draw() {
        System.out.println("畫一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("畫一個正方形");
    }
}
 
public class Test4 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();   // 子類引用cycle
        Flower flower = new Flower(); // 子類引用flower
        Square square = new Square();
        
        // 數(shù)組的類型是Shape,即數(shù)組中每一個元素都是一個父類引用
        // 在這個過程其實也發(fā)生了向上轉(zhuǎn)型，對抽象類中的方法進(jìn)行了重寫
        Shape[] shapes = {cycle, flower, square};  // 父類引用引用不同的子類對象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父類引用shape指向—>當(dāng)前所對應(yīng)的子類對象
 
            shape.draw();  // 通過父類引用調(diào)用子類重寫的draw方法
        }
 
    }
}

// 對上面的代碼補充一下
// 可能你對 Shape[] shapes = {cycle, flower, square};不太理解
// 但上面的代碼就相當(dāng)于 
 
 Shape[] shapes1 = new Shape[3]; // 有三個不同的子類對象呀！數(shù)組大小為3
 
// (將指向->子類對象)的子類引用賦值給父類對象，不就相當(dāng)于該夫類引用指向->所對應(yīng)的子類對象嗎
//這是向上轉(zhuǎn)型的另一種寫法，應(yīng)為前面已經(jīng)實例化了子類對象  Cycle cycle = new Cycle();   
 shapes1[0] = cycle;  // 如果前面沒實例化子類對象，就要寫成shape1[0] = new Cycle
 shapes1[1] = flower;
 shapes1[2] = square;

//接口的定義格式與定義類的格式基本相同，將class關(guān)鍵字換成 interface 關(guān)鍵字，就定義了一個接口
 
public interface 接口名稱{
// 定義變量
int a = 10;      // 接口當(dāng)中的成員變量默認(rèn)都是public static final
 
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不寫
void method2();  //  接口當(dāng)中的成員方法默認(rèn)都是public abstract, 更推薦用第二種來定義方法 
}

接口可以看成是一種特殊的類，只能用 interface 關(guān)鍵字修飾
interface IShape {
    int a = 10;   接口當(dāng)中的成員變量默認(rèn)都是public static final
    int b = 23;
    void draw();  接口當(dāng)中的成員方法一般只能是抽象方法，默認(rèn)是public abstract（JDK1.8以前）
  
    default void show() {
        System.out.println("接口中的其他方法");//接口中的其他方法也可以實現(xiàn)，但要用default修飾
    }
    public static void test() {
        System.out.println("這是接口當(dāng)中的一個靜態(tài)的方法");
    }
}
 
// 一個普通的類要想實現(xiàn)接口，可以用implement, 
//因為接口也是抽象方法的，所以實現(xiàn)接口的這個類也要重寫抽象方法
class Cycle implements IShape {
 
    @Override
    public void draw() {
        System.out.println("畫一個圓圈");
    }
}
class Square implements IShape {
    @Override
    public void draw() {
        System.out.println("畫一個正方形");
    }
}
class Flower implements IShape {
 
    @Override
    public void draw() {
        System.out.println("畫一朵花");
    }
}
public class Test4 {
    public static void main(String[] args) {
        // IShape iShape = new IShape(); 接口也不能直接實例化
        Cycle cycle = new Cycle();
        Square square = new Square();
        Flower flower = new Flower();
        // 這里的IShape接口就相當(dāng)與抽象類中父類，接口類型也是一種引用類型
 
        IShape[] iShapes = {cycle, square, flower}; // 這個過程其實就發(fā)生了向上轉(zhuǎn)型
 
        for (IShape iShape : iShapes) { // 增強型的for—each循環(huán)，也可以寫成普通的for循環(huán)形式
            iShape.draw();              // 通過重寫實現(xiàn)了多態(tài)
        }
    }
}
引用變量cycle和square都賦值給了Shape類型的引用變量shape,
但當(dāng)執(zhí)行shape.draw()時，java虛擬機到底要調(diào)用誰重寫的的draw方法，
就看此時接口引用的是那個對象的，是shape的、還是cycle的

由于 Java 中單繼承的特性，導(dǎo)致一個類只能繼承一個類，但是可以實現(xiàn)一個或多個接口，此時可以使用接口。
class Animal {
    String name;        // 不能使用private,后面的子類也要用
 
    public Animal(String name) { // 父類的自定義的構(gòu)造方法
        this.name = name;
    }
}
interface IFlying {   // 自定義多種接口
    void fly();
}
interface IRunning {
    void run();
}
interface ISwimming {
    void swimming();
}
// 小鴨子，不僅會跑，還會游泳、飛行
一個類繼承父類，并實現(xiàn)多個接口，間接的解決java中不能多繼承的問題
class Duck extends Animal implements IRunning, ISwimming, IFlying {
 
    public Duck(String name) {  // 子類構(gòu)造方法
        super(name);            // 必須在子類構(gòu)造方法的第一行
        // 在給實現(xiàn)子類的構(gòu)造方法前，先要用super()調(diào)用實現(xiàn)父類的構(gòu)造方法，比較先有父后有子呀！
        // 因為父類自己定義了構(gòu)造方法，編譯器不會自動給給子類構(gòu)造方法中添加super();來實現(xiàn)父類的構(gòu)造方法，需要我們自己實現(xiàn)
    }
    // 對接口中的抽象方法進(jìn)行重寫
    @Override
    public void fly() {
        System.out.println(this.name + "正在用翅膀飛");
    }
 
    @Override
    public void run() {
        System.out.println(this.name + "正在用兩條腿跑");
    }
 
    @Override
    public void swimming() {
        System.out.println(this.name + "正在漂在水上");
    }
 
}
 
public class 接口的使用 {  // 不用學(xué)我用中文名作為類名，我只是為演示方便
    public static void main(String[] args) {
        Duck duck = new Duck("第一個小鴨子");  // 實例化鴨子對象
        duck.fly();  // 通過引用 變量名.方法名 輸出重寫后的方法
        duck.run();
        duck.swimming();
    }
}
有人可能會說干嘛用接口，我直接在父類Animal中實現(xiàn)fly、run、swimming這些屬性，
然后不同的動物子類再繼承父類這些方法不行嗎？
 
但問題是，鴨子會fly、swimming，那貓會飛和游泳嗎？你再寫個其他動物的子類是不是就不行了
而用接口呢？我們只是把這種飛、游泳的行為給抽象出來了，
 
只要一個子類有這種行為，他就可以實現(xiàn)相對應(yīng)的接口，接口是更加靈活的
 

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    // 對run方法進(jìn)行重寫
    @Override
    public void run() {
        System.out.println("機器人" + this.name + "正在跑");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Robot robot1 = new Robot("圖圖");
        robot1.run();
    }
}
// 執(zhí)行結(jié)果
機器人圖圖正在跑