技術標籤：面向物件萌新基礎object抽象類多型

object類是所有類的父類

object類中有幾個方法
toString() 返回當前物件本身的有關資訊，按字串物件返回
equals()比較兩個物件是否是同一個物件
比較兩個物件是否是同一個物件，是則返回true
操作符==
簡單資料型別，直接比較值。如1==2
引用型別，比較兩者是否為同一物件

hashCode() 返回物件的雜湊程式碼值
生成隨機的雜湊值

getClass()獲取當前物件所屬的類資訊，返回Class物件

abstract關鍵字建立抽象類 例如 public abstract class 類名{}
abstract也可用於方法——抽象方法

首先寵物類：

public abstract class Pet {

    private String name;

    public abstract void run();


    public String getName() {
        return name;
    }
 


    public void setName(String name) {
        this.name = name;
    }

}

抽象方法後一定不能有方法體

狗類：

public class Dog extends Pet {

    @Override
    public void run() {
        System.out.println("狗正在跑");
    }
}

繼承父類並重寫方法
編寫測試類：

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

結果：狗正在跑

final關鍵字的作用在類中使用
public final class 類名{}
代表此類為最終類，不能被其他類繼承
public final 方法返回值 方法名(){}
代表此方法不能被重寫
final在屬性變數中代表常量

多型：同一個引用型別，使用不同例項而執行不同操作
編寫具有繼承關係的父類和子類
子類重寫父類方法
使用父類的引用指向子類的物件

例如給寵物餵食是需要一個主人類，正常的操作是
狗類一個吃的方法，企鵝類一個吃的方法，然後主人類中一個喂狗的方法 一個喂企鵝的方法
但是使用多型就可以省去主人的喂狗方法而是直接喂成寵物類，前提條件 企鵝和狗必須都屬於寵物類

定義抽象寵物類：

public abstract class Pet {
    private String name;
    private int health;
    private int love;

    public  abstract void eat();
     public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHealth() {
        return health;
    }

    public void setHealth(int health) {
        this.health = health;
    }

    public int getLove() {
        return love;
    }

    public void setLove(int love) {
        this.love = love;
    }
}

其中sett和get方法可以忽略不計因為這裡只顯示多型的使用。

首先定義抽象方法吃

狗類

public class Dog extends Pet {

    private  String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    @Override
    public void eat() {
        System.out.println("吃狗糧");
        super.setHealth(super.getHealth()+5);

    }

狗類繼承父類寵物類並重寫吃的方法

public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }


    @Override
    public void eat() {
        System.out.println("吃魚");
        super.setHealth(super.getHealth()+6);
    }

企鵝繼承父類寵物類並重寫吃的方法

主人類

public class Master {
    public void feed(Pet pet){pet.eat();
    }

使用父類作為方法形參實現多型

方法體中引用父類的吃方法

測試類

public class TestMaster {
    public static void main(String[] args) {
        Pet dog=new Dog();
       Pet penguin=new Penguin();
        Master master=new Master();
        master.feed(dog);
        master.feed(penguin);

主人類中的餵食帶參方法
引數為寵物型別的狗物件
就是狗吃的方法
為寵物型別的企鵝物件
就是企鵝吃的方法
結果：

第一種方法為使用父類作為方法形參實現多型
下面演示第二種方法
使用父類作為方法返回值實現多型

實現控制檯輸入領養寵物
輸入編號領養

大體不變
寵物類：

public abstract class Pet {
    private String name;
    private int health;
    private int love;
    public abstract void print();

狗類

public class Dog extends Pet {

    private  String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }
     @Override
    public void print() {
        System.out.println("這是一條狗");
    }

企鵝類

public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
     @Override
    public void print() {
        System.out.println("這是一隻企鵝");
    }

主人類：

public class Master {
 public Pet getPet(int typeid){
        Pet pet=null;
        if (typeid==1){
            pet=new Dog();
        }else if (typeid==2){
            pet=new Penguin();
        }
        return pet;
    }
}

這裡直接以父類為返回值把控制檯輸入的編號作為引數傳入方法， 然後判斷如果輸入為1 寵物物件為狗型別 則返回狗的print方法
輸入2 寵物物件為企鵝型別返回企鵝的print方法

測試類：

public class TestMaster {
    public static void main(String[] args) {
        Pet dog=new Dog();
       Pet penguin=new Penguin();
        Master master=new Master();
         Scanner input=new Scanner(System.in);
        System.out.println("請選擇寵物1.狗2.企鵝");
        int typeid=input.nextInt();
        Pet pet=master.getPet(typeid);
        pet.print();

結果：

instanceof運算子判斷其左邊物件是否為其右邊類的例項
返回的值為boolean值
例如實現寵物玩耍 狗玩飛碟 企鵝游泳
這裡也會用到強制轉換
寵物類：

public abstract class Pet {
    private String name;
    private int health;
    private int love;

狗類：

ublic class Dog extends Pet {

    private  String strain;

    public String getStrain() {
        return strain;
    }

    public void setStrain(String strain) {
        this.strain = strain;
        
    }
     public void playplate(){
        System.out.println("狗狗在玩飛碟");
    }
}

企鵝類：

public class Penguin extends Pet {
    private String sex;

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
        public void swimming(){
        System.out.println("企鵝在游泳");
    }
    }
    

主人類：

public class Master {
public void play(Pet pet){
        if (pet instanceof Dog){
            Dog dog=(Dog) pet;
            dog.playplate();
        }else if (pet instanceof Penguin){
            Penguin penguin=(Penguin) pet;
            penguin.swimming();
        }
    }
}

利用instanceof運算子判斷是否一致
如果不一致則要使用強制型別轉換

測試類：

public class TestMaster {
    public static void main(String[] args) {
        Pet dog=new Dog();
       Pet penguin=new Penguin();
        Master master=new Master();
         master.play(dog);
        master.play(penguin);
        

結果：