Java面向對象之類、接口、多態

Java面向對象之類、接口、多態

類

class Person {
    // 實例屬性
    int age;
        String name;
    // 類屬性
    static int v = 1;
    
    // 構造器
    public Person() {}
    // 構造器重載
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    // 實例方法
    public void tell_age() {
        System.out.println(this.age);
    }
    // 方法重載
    public void tell_age(String s) {
            System.out.println(this.age + " " + s);
    }
  
    // 類方法
    public static void print_v() {
        System.out.println(v);
    }
}

// 類的繼承
// 繼承能夠繼承除了private的一切方法和屬性
// Object是Java的頂級父類
class Man extends Person {
    // 方法覆蓋
    @Override
    public void tell_age() {
        super.tell_age(); // 執行父類的此方法
        System.out.print("Man eat...");
    }
}

接口

指interface，相似於swift的protocal

interface中的變量都是默認public static final修飾的

interface中的方法都是默認public abstract修飾的

注意點：

　　這些修飾詞能夠省略一個，也能夠省略多個（甚至都省略），可是不能用其餘修飾詞修飾.

　　不寫public 不是默認的 default；寫default會報錯

變量：

　　　public static final int MAX_LENGTH = 1000；

　　　final int MAX_LENGTH = 1000;

　　　static int MAX_LENGTH = 1000;

　　　public int MAX_LENGTH = 1000;

　　　int MAX_LENGTH = 1000;

方法：

　　　public abstract void method();

　　　public void method();

　　　abstract void method();

　　　void method();

interface Animal {
    public void eat();
    public void sleep();
    public void play();
}

interface Fish extends Animal {
    public void swim();
}

class AFish implements Fish {
        @Override
    public void swim() {
      
    }
    @Override
    public void sleep() {
      
    }
    @Override
    public void play() {
      
    }
    @Override
    public void eat() {
        
    }
}
// 固然，一個類也能夠實現多個interface 彼此之間用逗號隔開：
// class ClassA implements interfaceA, interfaceB, interfaceC {
//
// }

多態

public class Demo {
    public static void main(String[] args) {
        Cat c = new Cat();
        // Java 多態 一個方法有多種狀態
        Animal cat = new Cat();
        Animal dog = new Dog();
        cat.eat(); // cat eat ...
        cat.sleep(); // cat sleep...
        dog.eat(); // dog eat ...
        dog.sleep(); // dog sleep...
        Person p = new Person();
        p.care(cat);
        p.care(dog);
    }
}

interface Animal {
    public void eat();
    public void sleep();
}

class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("cat eat...");
    }
    @Override
    public void sleep() {
        System.out.println("cat sleep...");
    }
}

class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("dog eat...");
    }
    @Override
    public void sleep() {
        System.out.println("dog sleep...");
    }
}

class Person {
    public void care(Animal a) {
        a.sleep();
        a.eat();
    }
}

多態使程序更加具備擴展性：向上類型轉化、方法的動態綁定