58.向上（向下）转型
<父类型><引用变量名>=new<子类型>()
通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法
通过父类引用变量无法调用子类特有的方法
（使用向上转型无法调用子类独有的方法，可使用向下转型）
<子类型><引用变量名>=(<子类型>)<父类型的引用变量>;
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常
（向下转型，如果没有转化为真实的子类类型，此时会引发ClassCastException）
Java中提供了instanceof运算符来进行类型的判断减少在向下转型的过程中，没有转换为真实子类类型的类型转换异常（instanceof：进行类型判断，减少向下转型时的ClassCastException）
对象名 instanceof 类型
使用instanceof时，对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系
public class Dog extends Pet{
//品种
private String strain="聪明的拉布拉多犬";
public Dog(){
System.out.println("子类狗狗的无参构造方法");
}
public Dog(String name,int health,int love){
super(name,health,love);
System.out.println("子类狗狗带三个参数的构造方法");
}
public Dog(String name,int health,int love,String strain){
/*//通过super调用父类的构造方法，必须是第一行
//super();注意参数顺序必须和父类一致
super(name,health,love);*/
this(name,health,love);
this.strain=strain;
System.out.println("子类狗狗的带四个参数的构造方法");
}
public String getStrain() {
return this.strain;
}
public void setStrain(String strain) {
this.strain = strain;
}
public void print(){
//调用父类的非private方法print()
super.print();
System.out.println(",我是一只："+this.strain);
}
//宠物生病后看病
public void toHospital(){
System.out.println("打针、吃药");
this.setHealth(60);
}
//狗狗吃骨头
public void eat(){
if (this.getHealth()>100){
System.out.println("狗狗"+this.getName()+"吃饱了，不想吃了！");
}else{
//狗狗的健康值加3
this.setHealth(this.getHealth()+3);
System.out.println("狗狗"+this.getName()+"感觉很好吃，健康值增加3！");
}
}
//狗狗叼飞碟
public void catchFly(){
System.out.println("狗狗叼飞碟！");
}
}
public class Penguin extends Pet {
//性别
private String sex="Q仔";
public Penguin(){
System.out.println("子类企鹅的无参构造方法");
}
public Penguin(String name,int health,int love,String sex){
super(name,health,love);
this.sex=sex;
System.out.println("子类企鹅带三个参数的构造方法");
}
public String getSex() {
return this.sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public void print(){
//调用父类的print()
super.print();
System.out.println(",我的性别是："+this.sex);
}
//宠物生病后看病
public void toHospital(){
System.out.println("吃药、疗养");
this.setHealth(60);
}
//企鹅吃鱼
public void eat(){
if(this.getHealth()>100){
System.out.println("企鹅"+this.getName()+"吃饱了，够了够了！");
}else{
//企鹅健康值加3
this.setHealth(this.getHealth()+5);
System.out.println("企鹅"+this.getName()+"感觉很美味，健康值增加了5！");
}
}
//企鹅在南极游泳
public void swim(){
System.out.println("企鹅在南极游泳！");
}
}
import java.util.Scanner;
public class TestPet {
public static void main(String[] args) {
Master master=new Master();
Scanner input=new Scanner(System.in);
System.out.println("欢迎来到宠物店！");
System.out.println("请输入您要领养宠物的名字：");
String name = input.next();
System.out.println("请输入您要领养的宠物类型：1.狗狗 2.企鹅");
int typeNo = input.nextInt();
switch (typeNo) {
case 1:
//接受用户键盘输入值
System.out.println("请输入宠物的健康值：");
int ghealth = input.nextInt();
System.out.println("请输入宠物与主人的亲密度：");
int glove = input.nextInt();
System.out.println("请输入宠物的品种：");
String strain = input.next();
/*//创建狗狗对象，并为狗狗属性赋值
Dog dog = new Dog();
dog.setName(name);
dog.health=-1000;
dog.love=3;
dog.name="多多";
dog.strain="吉娃娃";
dog.print();
//dog.m1();*/
//Pet pet=new Pet(); 类名 对象名=new 类名();
//Person p=new Student();
//Person p=new Teacher();
//父类类型指向子类对象，向上转型
Pet dog=new Dog("狗蛋",30,23,"二哈");
//使用向上转型无法调用子类独有的方法
//可使用向下转型
/*Dog d=(Dog)dog;
d.catchFly();*/
//向下转型，如果没有转化为真实的子类类型，此时会引发ClassCastException
/*Penguin p1=(Penguin)dog;
p1.swim();*/
//可使用instanceof进行类型判断
if(dog instanceof Dog){
Dog d=(Dog)dog;
d.catchFly();
}else if(dog instanceof Penguin){
Penguin p=(Penguin)dog;
p.swim();
}
/*dog.print();
System.out.println("*************************");
//主人为狗狗看病
master.cure(dog);
//主人给狗狗喂食
master.feed(dog);
System.out.println("**************************");
dog.print();
*/
break;
case 2:
//接受用户键盘录入值
System.out.println("请选择宠物的性别：1.Q妹 2.Q仔");
int sexId = input.nextInt();
String sex = (sexId == 1) ? "Q妹" : "Q仔";
System.out.println("请输入宠物的健康值：");
int qhealth = input.nextInt();
System.out.println("请输入宠物和主人的亲密度：");
int qlove = input.nextInt();
/*//创建企鹅对象，并为企鹅属性赋值
Penguin p = new Penguin();*/
/*p.health=-1000;
p.love=3;
p.name="Q仔";
p.sex="男";*/
/*p.setName(name);
p.setHealth(qhealth);
p.setLove(qlove);
p.setSex(sex);
p.print();*/
Pet p=new Penguin(name,qhealth,qlove,sex);
if(p instanceof Dog){
Dog d=(Dog)p;
d.catchFly();
}else if(p instanceof Penguin){
Penguin penguin=(Penguin)p;
penguin.swim();
}
/*System.out.println("*************************");
//主人为企鹅看病
master.cure(p);
//主人给企鹅喂食
master.feed(p);
System.out.println("**************************");
p.print();*/
break;
default:
System.out.println("暂时没有这个类型的宠物，请在1或者2之间选择数值输入！");
break;
}
}
}
//抽象类不能被实例化，实例化没有任何意义
public abstract class Pet {
//1.隐藏属性（添加private）
//昵称，默认值是“无名氏”
private String name="无名氏";
//健康值，默认值是100，健康值在0-100之间，小于60为不健康
private int health=100;
//亲密度
private int love=0;
public Pet(){
System.out.println("父类无参构造方法");
}
public Pet(String name){
this.name=name;
}
public Pet(String name,int health,int love){
//this(name); //this可调用本类的构造方法，且必须在第一行
this.name=name;
this.health=health;
this.love=love;
System.out.println("父类的带参构造方法");
}
//2.添加属性的setter/getter方法（方法公开）,并加入属性控制语句
//setter:1.属性赋值。2.属性的操作（正确判断等）
public void setHealth(int health){
if(health<0||health>100){
System.out.println("请输入0-100的值!");
this.health=60;
return;
}
this.health=health;
}
//getter:属性取值
public int getHealth(){
return this.health;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public int getLove() {
return this.love;
}
public void setLove(int love) {
if(love<0||love>100){
System.out.println("请输入0-100的值!");
this.love=60;
return;
}
this.love=love;
}
/**
* 输出宠物的信息
* */
public void print(){
System.out.println("宠物的自白：\n我的名字叫"+this.name+"，健康值为"+this.health+
"，和主人的亲密度为"+this.love+"。");
// if(this.health<0||this.health>100){
// System.out.println("请输入0-100的值!");
// this.health=60;
// }else{
// this.health=health;
// }
}
//宠物生病后看病
//抽象方法所在的类必须定义为抽象类
//抽象类里可以没有抽象方法
//抽象方法必须在子类中被实现，除非子类是抽象类
public abstract void toHospital();
//宠物吃饭
public abstract void eat();
}
public class Master {
//为宠物看病：如果宠物健康值小于50，就要去宠物医院看病
public void cure(Pet pet){
if(pet.getHealth()<50){
pet.toHospital();
}
}
//给宠物喂食
public void feed(Pet pet){
pet.eat();
}
}