在上海乐字节学习Java的第十五天

Java多态（上）

多态意味着允许不同类的对象对同一消息做出不同的响应

编译时多态（设计时多态，一般为方法重载）

运行时多态（程序运行时动态决定调用哪个方法）

必要条件：
满足继承关系
父类引用指向子类对象
从一定角度来看，封装和继承几乎都是为多态准备的
现实中，多态的例子数不胜数
动物们都有吃东西、跑、跳、叫的方法，不同的动物表现方式不同

类型转换向上转型（Upcast）：将子类型转换为父类型
隐式/自动类型转换，是小类型到大类型的转换
对于向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名
向下转型（Downcast）：将父类型转换为子类型
将一个指向子类对象的父类引用赋值给一个子类的引用
强制类型转换，是大类型到小类型
父类型的引用必须指向转型的子类的对象，即指向谁才能转换谁。不然也会编译出错
通过instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题，提高代码的强壮性

注意
父类引用指向子类实例时，可以调用子类重写父类的方法以及直接继承父类的方法，无法调用子类的特有的方法
静态static方法属于特殊情况，静态方法只能继承，不能重写。调用的时候用谁的引用，则调用谁的版本
代码实现

Animal类

package com.SH.animal;

//抽象类：不允许实例化，可以通过向上转型，指向子类实例
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;
	}
	
	//方法：吃东西
	//抽象方法：不允许包含方法体；子类中需要重写父类的抽象方法,否则，子类也是抽象类
	//static final private不能与abstract并存
	public abstract void eat();
	
	public static void say(){
		System.out.println("动物间打招呼");
	}
}

Cat类

package com.SH.animal;

public class Cat extends Animal {
	//属性：体重
	private double weight;
	
	public Cat(){
		
	}
	
	public Cat(String name,int month,double weight){
		super(name,month);
//		this.setMonth(month);
		this.weight=weight;
	}

	public double getWeight() {
		return weight;
	}

	public void setWeight(double weight) {
		this.weight = weight;
	}
	
	
	//方法：跑动
	public void run(){
		System.out.println("小猫快乐的奔跑");
	}
	
	
	//方法：吃东西（重写父类方法）
	@Override
	public void eat() {
		System.out.println("猫吃鱼~~");
	}
	
	public static void say(){
		System.out.println("小猫碰胡须");
	}

	public void playBall() {
		// TODO Auto-generated method stub
		System.out.println("小猫喜欢玩线球");
	}

Dog类

package com.SH.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("小狗有午睡的习惯");
	}
	
	
	//方法：吃东西（重写父类方法）
	@Override
	public void eat() {
		System.out.println("狗吃肉~~");
		
	}
}

Test类

package com.SH.test;

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

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		Animal one=new Animal();//1

向上转型、隐式转型、自动转型
父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法

注意：父类中的静态方法无法被子类重写，所以向上转型之后，只能调用到父类原有的静态方法
小类转型为大类

		*/
		Animal two=new Cat();//2
		two.say();
		Cat cat=(Cat)two;
		cat.say();

		Cat cat=new Cat();
		two=cat;
		Animal three=new Dog();//3
		
		one.eat();
		two.eat();
		two.setMonth(2);
		two.getMonth();
		two.run();
		three.eat();
		System.out.println("=================");
		/*向下转型、强制类型转换
		 * 子类引用指向父类对象，此处必须进行强转，可以调用子类特有的方法
		 * 必须满足转型条件才能进行强转
		 * instanceof运算符：返回true/false
		 */
	if(two instanceof Cat){
			Cat temp=(Cat)two;
			temp.eat();
			temp.run();
			temp.getMonth();
			System.out.println("two可以转换为Cat类型");
		}
	
		if(two instanceof Dog){
			Dog temp2=(Dog)two;
			temp2.eat();
		temp2.sleep();
			temp2.getSex();
			System.out.println("two可以转换为Dog类型");
	}

		if(two instanceof Animal){
			System.out.println("Animal");
		}
	
		if(two instanceof Object){
			System.out.println("Object");
	}
		

类型转换案例
Master类

package com.SH.animal;

public class Master {
喂宠物
喂猫咪：吃完东西后，主人会带着去玩线球
喂狗狗：吃完东西后，主人会带着狗狗去睡觉
养兔子、养鹦鹉、养乌龟

方案1：编写方法，传入不同类型的动物，调用各自的方法

public void feed(Cat cat){
cat.eat();
cat.playBall();
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.playBall();
}else if(obj instanceof Dog){
Dog temp=(Dog)obj;
temp.sleep();
}

	

饲养何种宠物
空闲时间多：养狗狗

空闲时间不多:养猫咪

方案1：

public Dog hasManyTime(){
System.out.println("主人休闲时间比较充足，适合养狗狗");
return new Dog();
public Cat hasLittleTime(){
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();
}

MasterTest类

package com.SH.test;
import com.SH.animal.Animal;
import com.SH.animal.Cat;
import com.SH.animal.Dog;
import com.SH.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=master.raise(isManyTime);
if(isManyTime){
temp=master.hasManyTime();
}else{
temp=master.hasLittleTime();
System.out.println(temp);
}

抽象类&抽象方法
应用场景：
某个父类只是知道其他子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法

abstract定义抽象类
抽象类不能直接实例化，只能被继承，可以通过向上转型完成对象实例
abstract定义抽象方法，不需要具体实现
包含抽象方法的类是抽象类
抽象类中可以没有抽象方法
子类如果没有重写父类所以抽象方法，则也要定义为抽象类
abstract不能与 static、final、private共存
抽象方法在子类实现时访问权限必须大于等于父类方法