1多态案例:向上转型及向下转型及抽象类/方法

Animal one = new Animal();//1标准父类实例化的

向上转型&向下转型

向上转型

向上转型/隐式转型/自动转型,及小类转型为大类
父类引用指向子类实例,可以调用子类重写父类的方法以及父类派生的方法哦
无法调用子类独有的方法
注意:父类中的静态放无法被子类重写,所以向上转型之后,只能调用到父类原有的静态方法
如果想调用子类的静态方法只能通过向下强制转换数据类型 列如:Cat cat=(cat)two;

向下转型

向下转型/强制类型转换
子类引用指向父类对象,此处必须进行强转,可以调用子类特有的方法
必须满足转型条件才能转换
instanceof 判断左边的对象是不是右边的实例 返回true/false

抽象类&抽象方法

抽象类

使用 abstract修饰class
父类public abstract void eat();
抽象类不允许实例化,可以通过向上转型,指向子类实例
继承父类关系,避免父类无意义的实例化 禁止了子类设计的随意性

抽象方法

public abstract Cat();
不允许有方法体!在子类创建的时候就会有方法重写的提醒

使用规则

1 abstract定义抽象类
2 抽象类不能直接实例化 只能被继承 可以通过向上转型完成对象实例
3 abstract定义抽象方法,不需要具体实现
4 包含抽象方法类一定是抽象类
5 抽象类中可以没有抽象方法

案例:

创建package 命名com.imooc.test 生成3个类分别Animal父类子类Cat及Dog(介绍向上向下转型)
另外一个是抽象方法案例Master.java
Animal.java

package com.imooc.animal;
//abstract修饰的类是抽象类 
//抽象类不允许实例化 可以通过向上转型,指向子类实例
//继承父类关系   避免父类无意义的实例化 禁止了子类设计的随意性
public abstract class Animal {
//属性: 昵称\ 年龄
	private String name;
	private int month;
	//无参构造方法
	public Animal() {
		
	}
	//带参构造方法
	public Animal(String name,int month) {
		this.name = name;
		this.month = month;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		this.month = month;
	}
	//方法:吃东西
	//方法加abstract修饰的抽象方法 子类必须有重写方法,否则子类也要变成抽象类
	//不允许包含方法体 static final private不能与abstract并存
	public abstract void eat();
	
}

Cat.java

package com.imooc.animal;

public class Cat extends Animal {
	//子类特有属性: 体重
	private double weight;
	//无参构造方法
	public Cat() {
		
	}
	//带参构造方法
	public Cat(String name,int month,double weight) {
		super(name,month);
		this.weight = weight;
	}
	public double getWeight() {
		return weight;
	}
	public void setWeight(double weight) {
		this.weight = weight;
	}
	//子类特有方法:跑动
	public void run() {
		System.out.println("小猫快乐的奔跑");
	}
	//子类独有的静态方法
	public static void say() {
		System.out.println("小猫碰胡须");
	}
	//方法:吃东西 (重写父类方法)
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

Dog.java

package com.imooc.animal;

public class Dog extends Animal {
//子类特有属性:性别
	private String sex;
	//无参构造方法
	public Dog(){
		
	}
	//带参构造方法
	public Dog(String name,int month,String sex){
		this.setMonth(month);
		this.setName(name);
		this.setSex(sex);
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	//子类特有方法:睡觉
	public void sleep() {
		System.out.println("小狗有午睡的习惯");
	}
	//方法:吃东西(重写父类方法)
	public void eat() {
		System.out.println("狗吃肉");
	}
	
}

Master.java (抽象方法关于主人喂养宠物及因时间选择饲养种类 )

package com.imooc.animal;

public class Master {
	/*喂宠物
	 * 喂猫咪:吃完东西后,主人会带着去跑动
	 * 喂狗狗:吃完东西后,主人会带着去睡觉
	 */
	//方案一 编写方法 传入不同类型的动物,调用各自的方法
//	public void feed(Cat cat) {
//		cat.eat();
//		cat.run();
//	}
//	public void feed (Dog dog) {
//		dog.eat();
//		dog.sleep();
//	}
	
	//方案2  编写方法 传入动物的父类 方法中通过类型转换,调用指定子类的方法
	public void feed(Animal obj) {
		obj.eat();//共有方法可以直接写在判断外面直接调用 缩小代码的冗余
		if(obj instanceof Cat) {
			Cat temp=(Cat)obj;
		//	temp.eat();  //共有的方法写在判断体外面
			temp.run();
		}else if(obj instanceof Dog) {
			Dog temp=(Dog)obj;
		//	temp.eat();  //共有的方法写在判断体外面
			temp.sleep();
		}
	}
	/*
	 * 饲养何种宠物
	 * 空闲时间多:养狗狗
	 * 空闲时间不多:养猫咪
	 */
	//方案一:
//	public Dog hasManyTime() {
//		System.out.println("主人时间比较充足,适合养狗狗");
//		return new Dog();
//	}
//	public Cat haslittleTiem() {
//		System.out.println("主人平时比较忙碌,适合养猫咪");
//		return new Cat();
//	}
	
	//方案2:
	public Animal raise(boolean isManyTime) {
		if(isManyTime) {
			System.out.println("主人时间比较充足,适合养狗狗");
			return new Dog();
		}else {
			System.out.println("主人平时比较忙碌,适合养猫咪");
			return new Cat();
		}
	}
	
}

创建测试包com.imooc.test 有Test.java / MasterTest.java
Test.java

package com.imooc.test;

import com.imooc.animal.Animal;
import com.imooc.animal.Cat;
import com.imooc.animal.Dog;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
			//Animal one = new Animal();//1标准实例化的
			/*向上转型/隐式转型/自动转型,及小类转型为大类
			 * 父类引用指向子类实例,可以调用子类重写父类的方法以及父类派生的方法哦
			 * 无法调用子类独有的方法
			 * 注意:父类中的静态放无法被子类重写,所以向上转型之后,只能调用到父类原有的静态方法
			 * 如果想调用子类的静态方法只能通过向下强制转换数据类型 列如:Cat cat=(cat)two;
			 */
			Animal two = new Cat();//2 向上转型
			Animal three = new Dog();//3  向上转型
//			one.eat();  //abstract抽象方法后无意义调用被限制
//			two.eat(); //abstract抽象方法后无意义调用被限制
//			three.eat(); //abstract抽象方法后无意义调用被限制
			System.out.println("==============================");
			/*向下转型/强制类型转换
			 * 子类引用指向父类对象,此处必须进行强转,可以调用子类特有的方法
			 * 必须满足转型条件才能转换
			 * instanceof 判断左边的对象是不是右边的实例 返回true/false
			 */
			if(two instanceof Cat) {
				Cat temp =(Cat) two;
				temp.eat();
				temp.run();//向下转型 强制后转换后可以调用子类特有方法
				temp.say();//也可以调用独有静态方法
				temp.getMonth();
				System.out.println("two可以转换为Cat类型");
			}
			if(two instanceof Dog) {
			Dog temp2 =(Dog) two; //这个instanceof跟dog类没有关系返回false
			temp2.eat();
			temp2.sleep();
			temp2.getMonth();
			System.out.println("three可以转换为Dog类型");
			}
	}

}

Master.java

package com.imooc.test;

import com.imooc.animal.Animal;
import com.imooc.animal.Cat;
import com.imooc.animal.Dog;
import com.imooc.animal.Master;

public class MasterTest {
	public static void main(String[] args) {
		Master master = new Master();
		Cat one =new Cat();
		Dog two =new Dog();
		master.feed(one);
		master.feed(two);
		System.out.println("============================");
		boolean isManyTime=false; //主人时间是否空余较多
//		方案一调用方法
//		Animal temp;  //创建一个Animal对象 接收待会来的结果并打印出来查看
//		if(isManyTiem) {
//			temp= master.hasManyTime();
//			
//		}else {
//			temp= master.haslittleTiem();
//		}
//		System.out.println(temp);
		
		
//		方案二调用方法
		Animal temp = master.raise(isManyTime);
		System.out.println(temp);
	}
}