java狗具有特别的接飞盘的方法_JAVA多态

== 什么是多态==

多态是具有表现多种形态的能力的特征，更专业化的说法，同一个实现接口，使用不同的实例而执行不同的操作。

下面的图将有助于我们理解多态：

对图进行解释：打印机可以看做父类，黑白打印机，彩色打印机是它的两个子类，父类打印机中的方法“打印”在每个子类中有不同的实现方式。

子类到父类的转换(向上转换)

实际上，在引用数据类型的子类和父类之间，也存在着类型转换，如以下代码：

Dog dog=new Dog("欧欧"，"雪纳瑞");//不涉及类型转换

dog.eat();

Pet pet=new Dog("欧欧"，"雪纳瑞");//子类到父类的转换

pet.eat();//会调用Dog类重写的eat()方法，而不是eat类的eat()方法。

pet.CatChingDisc();//编译错误，父类的引用无法调用子类特有的方法。

下面我们将进一步的证明来更深刻的理解以上代码：

1.Pet pet=new Dog(“欧欧”，“雪纳瑞”);

主人需要一只宠物，一条狗狗肯定符合其要求，不用特别声明，所以可以直接将子类对象赋给父类引用变量。

2.pet.eat();

主人给宠物喂食时看到的肯定是狗狗在吃饭而不是企鹅在吃饭，也不是抽象的pet在吃饭。

3.pet.CatChingDisc();

假定主人可以同时和狗狗和企鹅喂食，但只能和狗狗玩接飞盘游戏，只能和企鹅玩游泳游戏，在没有判定宠物是狗狗时，主人不能和宠物玩飞盘游戏，因为他需要的是一只宠物，但是没有明确需求需要一条狗狗，所以很有可能得到的是一只企鹅，因此不能确定是玩接飞盘游戏还是游泳游戏。

使用父类作为方法形参实现多态

代码如下：

/*

* 宠物类，狗狗和企鹅的父类

*/

public abstract class Pet {

protected String name="无名氏";

protected int health=100;

protected int love=0;

public Pet(String name){

this.name=name;

}

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;

}

/*

* 输出宠物的信息

*/

public void print(){

System.out.println("宠物的自白:\n我的名字叫"+this.name+",健康值是"+this.health+",和主人的亲密度是"+this.love+"。");

}

/*

* 抽象方法eat(),负责宠物吃饭功能

*/

public abstract void eat();

}

让Dog类重写Pet类的eat()方法，实现狗狗吃饭功能，代码如下：

/*

* 狗狗类，宠物的子类

*/

public class Dog extends Pet {

private String strain;//品种

public Dog(String name,String strain){

super(name);

this.strain=strain;

}

/*

* 重写父类的print()方法

*/

public void print(){

super.print();//调用父类的print方法

System.out.println("我是一只"+this.strain+"。");

}

/*

* 实现狗狗吃饭的方法

*/

public void eat(){

super.health=super.health+3;

System.out.println("狗狗"+super.name+"吃饱啦！健康值加3");

}

}

让Penguin类重写Pet类的eat()方法，实现企鹅吃放功能，代码如下：

/*

* 企鹅类，宠物的子类

*/

public class Penguin extends Pet {

private String sex;//性别

public Penguin(String name,String sex){

super(name);

this.sex=sex;

}

/*

*重写父类的print()方法

*/

public void print(){

super.print();

System.out.println("性别是"+this.sex+"。");

}

/*

* 实现企鹅吃饭的方法

*/

public void eat(){

super.health=super.health+5;

System.out.println("企鹅"+super.name+"吃饱啦！健康值加3");

}

}

创建主人类Master,在类中添加feed(Dog dog)方法，调用Dog类的eat()方法，实现狗狗的喂养，添加feed(Penguin pgn)方法，调用Penguin类的eat()方法，实现企鹅的喂养

/*

* 主人类

*/

public class Master {

private String name="";//主人名字

private int money=0;//元宝数

public Master(String name,int money){

this.name=name;

this.money=money;

}

/*

* 主人给宠物喂食

*/

public void feed(Pet pet){

pet.eat();

}

/*

* 主人给Dog喂食

*/

public void feed(Dog dog){

dog.eat();

}

/*

* 主人给Penguin喂食

*/

public void feed(Penguin pgn){

pgn.eat();

}

测试类代码如下：

public class Test {

public static void main(String[] args) {

Pet pet=new Dog("欧欧","雪纳瑞");

//Penguin pgn=new Penguin("楠楠","Q妹");

Master master=new Master("王先生",100);

master.feed(pet);//主人给宠物喂食

运行结果为：狗狗欧欧吃饱啦！健康值加3

如果将"Pet pet=new Dog(“欧欧”,“雪纳瑞”);“这一行注释掉，取消”//Penguin pgn=new Penguin(“楠楠”,“Q妹”);"这一行的注释

运行结果为：企鹅楠楠吃饱啦！健康值加5

由此我们可以看出使用父类作为方法形参的优势，或者说是使用多态的优势：可以减少代码量，提高代码的可扩展性和可维护性。

即使增加子类也无需添加或者修改feed()方法，为了证明这一点，我们来添加宠物Cat类，继承Pet并重写eat()方法。

代码如下：

/*

* 猫类，宠物的子类

*/

public class Cat extends Pet {

private String color;//颜色

public Cat(String name,String color){

super(name);

this.color=color;

}

/*

* 实现吃饭的方法

*/

public void eat(){

super.health=super.health+4;

System.out.println("猫咪"+super.name+"吃饱啦！健康值加4。");

}

}

测试类代码如下：

public class Test {

public static void main(String[] args) {

//Pet pet=new Dog("欧欧","雪纳瑞");

//Penguin pgn=new Penguin("楠楠","Q妹");

Master master=new Master("王先生",100);

Pet pet=new Cat("粒粒","黄色");

master.feed(pet);//主人给宠物喂食

运行结果为：猫咪粒粒吃饱啦！健康值加4。

通过上面的介绍大家对多态的特点是不是有了更深入的了解呢？下面让我们学习多态的另一种场合。

使用父类作为方法返回值实现多态

先修改Master类添加getPet(String tupeId)方法，以父类Pet作为返回值类型实现领养功能，代码如下：

/*

* 主人类

*/

public class Master {

private String name="";//主人名字

private int money=0;//元宝数

public Master(String name,int money){

this.name=name;

this.money=money;

}

/*

* 主人领养宠物

*/

public Pet getPet(int typeId){

Pet pet=null;

if(typeId==1){

pet=new Dog("欧欧","雪纳瑞");

}else if(typeId==2){

pet=new Penguin("楠楠","Q妹");

}

return pet;

}

/*

* 主人给宠物喂食

*/

public void feed(Pet pet){

pet.eat();

}

/*

* 主人给Dog喂食

*/

public void feed(Dog dog){

dog.eat();

}

/*

* 主人给Penguin喂食

*/

public void feed(Penguin pgn){

pgn.eat();

}

在Test类中添加领养信息，代码如下：

public class Test {

public static void main(String[] args) {

Master master=new Master("王先生",100);

Scanner input=new Scanner(System.in);

System.out.println("欢迎您来到宠物店");

System.out.println("请选择要领养的宠物类型:(1.狗狗 2.企鹅)");

int typeId=input.nextInt();

Pet pet=master.getPet(typeId);

if(pet!=null){

System.out.println("领养成功");

master.feed(pet);

}

else{

System.out.println("对不起，没有此类型的宠物，领养失败");

}

}

}

运行结果如下：

通过以上的示例对多态功能的详解，总结出实现多态的三个条件

1.继承的存在(继承是多态的基础，没有继承就没有多态)

2.子类重写父类的方法(多态下调用自类重写后的方法)

3.父类引用变量指向子类对象(子类到父类的类型转换)

instanceof运算符

当进行向下转型时，如果没有转换为真实子类类型，就会出现类型转换异常。Java提供了 instanceof运算符来进行类型的判断。

语法：

对象 instanceof 类和接口

该运算符用来判断一个对象是否属于一个类或者实现了一个接口，结果为true或false，在强制类型转换之前通过 instanceof运算符检查对象的真实类型，从而额提高代码的健壮性。