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

// 抽象類和抽象方法需要被 abstract 關(guān)鍵字修飾
abstract class Shape {
    // 抽象類中的方法一般要求都是抽象方法，抽象方法沒有方法體
    abstract void draw();
}
// 當(dāng)一個(gè)普通類繼承一個(gè)抽象類后，這個(gè)普通類必須重寫抽象類中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重寫抽象類中的draw方法
        System.out.println("畫一個(gè)圓圈");
    }
}
 
public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象類雖然不能直接實(shí)例化
        // 但可以把一個(gè)普通類對(duì)象傳給一個(gè)抽象類的引用呀，即父類引用指向子類對(duì)象
        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)一個(gè)普通類繼承一個(gè)抽象類的時(shí)候，再這個(gè)子類中必須重寫抽象類中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重寫會(huì)報(bào)錯(cuò)，但如果繼承的是普通類則不會(huì)報(bào)錯(cuò)，用抽象類更安全
    public void draw() {
        System.out.println("畫一個(gè)圓圈");
    }
}
class Flower extends Shape { // 不同的子類對(duì)父類的draw方法進(jìn)行了不同的重寫
    @Override
    public void draw() {
        System.out.println("畫一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("畫一個(gè)正方形");
    }
}
 
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ù)組中每一個(gè)元素都是一個(gè)父類引用
        // 在這個(gè)過程其實(shí)也發(fā)生了向上轉(zhuǎn)型，對(duì)抽象類中的方法進(jìn)行了重寫
        Shape[] shapes = {cycle, flower, square};  // 父類引用引用不同的子類對(duì)象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父類引用shape指向—>當(dāng)前所對(duì)應(yīng)的子類對(duì)象
 
            shape.draw();  // 通過父類引用調(diào)用子類重寫的draw方法
        }
 
    }
}

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

//接口的定義格式與定義類的格式基本相同，將class關(guān)鍵字換成 interface 關(guān)鍵字，就定義了一個(gè)接口
 
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("接口中的其他方法");//接口中的其他方法也可以實(shí)現(xiàn)，但要用default修飾
    }
    public static void test() {
        System.out.println("這是接口當(dāng)中的一個(gè)靜態(tài)的方法");
    }
}
 
// 一個(gè)普通的類要想實(shí)現(xiàn)接口，可以用implement, 
//因?yàn)榻涌谝彩浅橄蠓椒ǖ?，所以?shí)現(xiàn)接口的這個(gè)類也要重寫抽象方法
class Cycle implements IShape {
 
    @Override
    public void draw() {
        System.out.println("畫一個(gè)圓圈");
    }
}
class Square implements IShape {
    @Override
    public void draw() {
        System.out.println("畫一個(gè)正方形");
    }
}
class Flower implements IShape {
 
    @Override
    public void draw() {
        System.out.println("畫一朵花");
    }
}
public class Test4 {
    public static void main(String[] args) {
        // IShape iShape = new IShape(); 接口也不能直接實(shí)例化
        Cycle cycle = new Cycle();
        Square square = new Square();
        Flower flower = new Flower();
        // 這里的IShape接口就相當(dāng)與抽象類中父類，接口類型也是一種引用類型
 
        IShape[] iShapes = {cycle, square, flower}; // 這個(gè)過程其實(shí)就發(fā)生了向上轉(zhuǎn)型
 
        for (IShape iShape : iShapes) { // 增強(qiáng)型的for—each循環(huán)，也可以寫成普通的for循環(huán)形式
            iShape.draw();              // 通過重寫實(shí)現(xiàn)了多態(tài)
        }
    }
}
引用變量cycle和square都賦值給了Shape類型的引用變量shape,
但當(dāng)執(zhí)行shape.draw()時(shí)，java虛擬機(jī)到底要調(diào)用誰重寫的的draw方法，
就看此時(shí)接口引用的是那個(gè)對(duì)象的，是shape的、還是cycle的

由于 Java 中單繼承的特性，導(dǎo)致一個(gè)類只能繼承一個(gè)類，但是可以實(shí)現(xiàn)一個(gè)或多個(gè)接口，此時(shí)可以使用接口。
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();
}
// 小鴨子，不僅會(huì)跑，還會(huì)游泳、飛行
一個(gè)類繼承父類，并實(shí)現(xiàn)多個(gè)接口，間接的解決java中不能多繼承的問題
class Duck extends Animal implements IRunning, ISwimming, IFlying {
 
    public Duck(String name) {  // 子類構(gòu)造方法
        super(name);            // 必須在子類構(gòu)造方法的第一行
        // 在給實(shí)現(xiàn)子類的構(gòu)造方法前，先要用super()調(diào)用實(shí)現(xiàn)父類的構(gòu)造方法，比較先有父后有子呀！
        // 因?yàn)楦割愖约憾x了構(gòu)造方法，編譯器不會(huì)自動(dòng)給給子類構(gòu)造方法中添加super();來實(shí)現(xiàn)父類的構(gòu)造方法，需要我們自己實(shí)現(xiàn)
    }
    // 對(duì)接口中的抽象方法進(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("第一個(gè)小鴨子");  // 實(shí)例化鴨子對(duì)象
        duck.fly();  // 通過引用 變量名.方法名 輸出重寫后的方法
        duck.run();
        duck.swimming();
    }
}
有人可能會(huì)說干嘛用接口，我直接在父類Animal中實(shí)現(xiàn)fly、run、swimming這些屬性，
然后不同的動(dòng)物子類再繼承父類這些方法不行嗎？
 
但問題是，鴨子會(huì)fly、swimming，那貓會(huì)飛和游泳嗎？你再寫個(gè)其他動(dòng)物的子類是不是就不行了
而用接口呢？我們只是把這種飛、游泳的行為給抽象出來了，
 
只要一個(gè)子類有這種行為，他就可以實(shí)現(xiàn)相對(duì)應(yīng)的接口，接口是更加靈活的
 

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