作业一：使用多态实现主人领养宠物，和宠物玩的功能，
父类，宠物类：
package com.polym02;
/**
* 父类 ，宠物类
*/
public abstract class Pet {
//宠物被领养的方法
public Pet yang(Pet pet){
return pet;
}
}
子类狗：
package com.polym02;
/**
* 狗狗类
*/
public class Dog extends Pet {
//玩的方法
public void wang() {
System.out.println("陪狗狗去接飞盘");
}
//重写父类被领养的方法
public Pet yang(Pet pet){
System.out.println("给你一只狗狗");
return pet;
}
}
子类企鹅：
package com.polym02;
/**
* 企鹅类
*/
public class Penguin extends Pet {
//玩的方法
public void wang(){
System.out.println("带企鹅去游泳。。。。。。");
}
//重写父类被领养的方法
public Pet yang(Pet pet){
System.out.println("给你一只企鹅。。。。。");
return pet;
}
}
主人类：
package com.polym02;
/**
* 主人类
*/
public class Master {//带宠物出去玩的方法
public void quWang(Pet pet){
if(pet instanceof Dog){
Dog dog = (Dog)pet
dog.wang();
}else if (pet instanceof Penguin){
Penguin pen =(Penguin)pet
pen.wang();
}
}
//领养宠物的方法
public Pet lingYang(Pet pet) {
Pet p = null;
if (pet instanceof Dog) {
pet.yang(p1);
p = pet;
}else if(pet instanceof Penguin){
pet.yang(p2);
p =pet;
}
return p;
}
}
测试类：
package com.polym02;
import java.util.Scanner;
public class Test {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
Master m = new Master();
Pet P1 = new Dog();
Pet P2 = new Penguin();
System.out.println("请输入要陪玩的宠物：1，狗狗 2，企鹅");
int choose = sc.nextInt();
if (choose==1){
m.quWang(P1);
}else{
m.quWang(P2);
}
System.out.println("请输入你需要的宠物：1，狗狗 2，企鹅");
int choose02 = sc.nextInt();
if (choose02==1){
m.lingYang(P1);
}else{
m.lingYang(P2);
}
}
}
输出结果图：
作业二2：
使用多态实现为宠物喂食：
父类宠物类：
/**
* 宠物健康值
*/
private int intimacy=46;
/**
* 宠物亲密度
*/
private int health=0;
public int getHealth() {
return health;
}
public void setHealth(int health) {
this.health = health;
}
public int getIntimacy() {
return intimacy;
}
public void setIntimacy(int intimacy) {
this.intimacy = intimacy;
}
/**
* 宠物吃食的方法
*/
public abstract void eat();
}
子类狗：
package com.Polym;
public class Dog extends Pet {
public void eat(){
if(getIntimacy()<50){
System.out.println("给狗狗吃狗粮和肉骨头");
setIntimacy(getIntimacy()+20);
System.out.println("狗狗现在的健康值是："+getIntimacy());
setHealth(getHealth()+10);
System.out.println("狗狗现在和你的亲密度是："+getHealth());
}
}
}
子类猫咪：
package com.Polym;
public class Cat extends Pet {
public void eat(){
if(getIntimacy()<50){
System.out.println("给猫咪吃猫粮和小鱼仔。。。。");
setIntimacy(getIntimacy()+30);
System.out.println("猫咪现在的健康值是："+getIntimacy());
setHealth(getHealth()+10);
System.out.println("猫咪现在和你的亲密度是："+getHealth());
}
}
}
主人类：
package com.Polym;public class Master { public void feed(Pet pet){ if(pet instanceof Dog){ pet.eat(); }else if(pet instanceof Cat){ pet.eat(); } }}
测试类：
public class Test {
public static void main(String[] args){
Master m1 = new Master();
Dog P1 = new Dog();
Cat P2 = new Cat();
System.out.println("狗狗现在的健康值是："+P1.getIntimacy());
System.out.println("狗狗现在和你的亲密度是："+P1.getHealth());
m1.feed(P1);
System.out.println("猫咪现在的健康值是："+P2.getIntimacy());
System.out.println("猫咪现在和你的亲密度是："+P2.getHealth()); m1.feed(P2); } }
输出结果图：
课堂笔记：
多态：
同一个引用类型，使用不同的实参执行不同操作
同一个类型使用不同的对象执行的结果有多种就是多态
一般就两种一种是父类作为参数，一种是父类作为反回值
继承，方法重写，父类引用指向子类对象，是实现多态的基础
1.使用多态时，是使用父类类型，但是对象还是子类对象
2.如果子类不重写父类方法，那么当使用多态时，是不能调用子类独有的方法
3.当子类重写父类方法，使用多态调用的方法，看似时父类的方法但实际调用的时子类中重写父类的那个方法，
一个方法没方法体就叫抽象方法
当一个类中有抽象方法的时候这个类就是抽象类，抽象类不一定有抽象方法，
抽象类不能被实列化，实列化没意义
抽象类的子类可以是普通类，该普通方法必须实现抽象类中抽象方法
抽象类的子类是抽象类时，此时可以不实现抽象类中抽象方法
抽象方法必须加关键词abstract
例： public abstract void a();
向上转型：
子类转化父类
父类型 引用变量名 = new 子类型（）； 自动转化类型
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类本身的方法
此时通过父类引用变量无法调用子类特有的方法
向下转型：
父类转化子类
子类型 引用变量名 = (子类型）父类的引用变量； 需要强制类型转
实列方法：动态绑定机制 调用属性和方法是子类中的
静态方法：静态绑定机制 调用属性和方法是父类中的
代码下载链接：https://pan.baidu.com/s/1JBE5GSu7-Fd_i8pnGsYTng
提取码：ghzq
来源：https://www.cnblogs.com/cxlbzdcom/p/10300851.html