面向对象（继承、多态、接口）

继承的例子

class Person {
    public String name = "小明";
    public int age = 20;

}

class Student extends Person {
    void study() {
        System.out.println("I want to study!");
    }
}

public class JiCheng {
    public static void main(String args[]) {
        Student stu = new Student();
        stu.study();
        System.out.println("姓名:" + stu.name + "\n" + "年龄:" + stu.age);
    }
}

运行结果

重写的例子

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.run();
    }
}

class Animal {
    public void run() {
        System.out.println("Animal is running");
    }
}

class Dog extends Animal {
    public void run() {
        super.run();
        System.out.println("Dog is running");
    }
}

运行结果

上述代码若注释掉super.run(); 则不执行父类里的run函数

继承中构造方法的关系
子类中所有的构造方法默认都会访问父类中空参数的构造方法，因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。每一个构造方法的第一条语句默认都是：super()；
继承中成员变量的关系
在子类中访问一个变量的查找顺序(“就近原则”)
a: 在子类的方法的局部范围找,有就使用
b: 在子类的成员范围找,有就使用
c: 在父类的成员范围找,有就使用
d:如果还找不到,就报错
例

 class Fu {
    public int num = 10;

    public Fu() {
        System.out.println("fu");
    }
}

class Zi extends Fu {
    public int num = 20;

    public Zi() {
        System.out.println("zi");
    }

    public void show() {
        int num = 30;
        System.out.println(num);//30
        System.out.println(this.num);//20
        System.out.println(super.num);//10
    }
}

class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

运行结果

因为要执行子类构造前先执行父类构造所以先打印fu 然后是zi ，num是30，this.num是子类里的num20，super.num是父类里的num10。

多态的例子

class A {
   public void show() {
      show2();
   }

   public void show2() {
      System.out.println("我");
   }
}

class B extends A {
   public void show2() {
      System.out.println("爱");
   }
}

class C extends B {
   public void show() {
      super.show();
   }

   public void show2() {
      System.out.println("你");
   }
}

public class DuoTaiTest4 {
         public static void main(String[] args) {
            A a = new B();
            a.show();
            
            B b = new C();
            b.show();
         }
      }

运行结果

抽象类的例子

public abstract class Father {
    public Father() {
        System.out.println("父类的构造方法执行了");
    }

    public abstract void eat();
    public abstract void drink();
    public void show(){
        System.out.println("父类的show方法");
    }
}

public class Son extends Father {

    public Son() {
        System.out.println("子类的构造方法执行了");
    }

    @Override
    public void eat() {
        System.out.println("子类 吃");
    }

    @Override
    public void drink() {
        System.out.println("子类 喝");
    }
}

public class Test {
    public static void main(String[] args) {
        //抽象类不能直接实例化,可以通过多态的形式间接实列化他
        Father f = new Son();
        f.eat();
        f.drink();
        f.show();
    }
}

接口的例子

public abstract class Animal {
    public abstract void eat();
    public  abstract void sleep();
}
public class Cat extends Animal{
    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }
}
public class Dog extends Animal implements MyInterface{
    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void fire() {
        System.out.println("狗经过学习,会钻火圈了");
    }

    @Override
    public void hehe() {
        System.out.println("呵呵");
    }
}
public interface MyInterface {
    int NUM = 100;
    public static final double D = 100;

    public abstract void fire();

    void hehe();

}
public class Test {
    public static void main(String[] args) {
        //接口不能实例化
        MyInterface my = new Dog(); //多态的形式
        my.fire();
    }
}