// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
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(); // 这称作：向上转型
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 这是向上转型的另一种写法
         */
        shape.draw();         // 通过父类引用调用被子类重写的方法
    }
}

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具体的语句
}
// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
    @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();
        // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
        // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写
        Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象
            shape.draw();  // 通过父类引用调用子类重写的draw方法
        }
    }
}

// 对上面的代码补充一下
// 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
// 但上面的代码就相当于 
 Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀！数组大小为3
// (将指向->子类对象)的子类引用赋值给父类对象，不就相当于该夫类引用指向->所对应的子类对象吗
//这是向上转型的另一种写法，应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
 shapes1[0] = cycle;  // 如果前面没实例化子类对象，就要写成shape1[0] = new Cycle
 shapes1[1] = flower;
 shapes1[2] = square;

接口可以看成是一种特殊的类，只能用 interface 关键字修饰
interface IShape {
    int a = 10;   接口当中的成员变量默认都是public static final
    int b = 23;
    void draw();  接口当中的成员方法一般只能是抽象方法，默认是public abstract（JDK1.8以前）
    default void show() {
        System.out.println("接口中的其他方法");//接口中的其他方法也可以实现，但要用default修饰
    }
    public static void test() {
        System.out.println("这是接口当中的一个静态的方法");
    }
}
// 一个普通的类要想实现接口，可以用implement, 
//因为接口也是抽象方法的，所以实现接口的这个类也要重写抽象方法
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接口就相当与抽象类中父类，接口类型也是一种引用类型
        IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型
        for (IShape iShape : iShapes) { // 增强型的for—each循环，也可以写成普通的for循环形式
            iShape.draw();              // 通过重写实现了多态
        }
    }
}
引用变量cycle和square都赋值给了Shape类型的引用变量shape,
但当执行shape.draw()时，java虚拟机到底要调用谁重写的的draw方法，
就看此时接口引用的是那个对象的，是shape的、还是cycle的

class Robot implements IRunning {
    private String name;
    public Robot(String name) {
        this.name = name;
    }
    // 对run方法进行重写
    @Override
    public void run() {
        System.out.println("机器人" + this.name + "正在跑");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Robot robot1 = new Robot("图图");
        robot1.run();
    }
}
// 执行结果
机器人图图正在跑