Java多态详解-优快云博客

多态的语法格式

1.父类类名引用名称 = new 子类类名（）；
2.当时多态时，该引用名称只能访问父类中的属性,但是优先访问子类重写以后的方法；这样造成了多个对象调用同一方法，执行不同的操作结果。子类不重写会有一样的结果；必须有继承关系，
3. 实现多态后，只能访问父类的属性和方法，但优先访问子类重写后的父类方法。

满足多态的条件
1.子类必须继承父类
2.子类必须重写父类的构造方法或重写父类的方法
父类

			class Vehicle{
	String brand;
	String id;
	public Vehicle(){}
	public Vehicle(String brand,String id){
		this.id=id;
		this.brand=brand;
	}
	public double getSumRent(int days){
		return 0;}
	public void print(){
		System.out.println("ok");
	}
}

子类

	class Car extends Vehicle{
	String type;
	public Car(){
		super();
		this.type="两箱";
	}
	public Car(String brand,String id,String type){

		super(brand,id);
		this.type=type;
	}
	//重写父类的租金
	public double getSumRent(int days){
		switch(this.type){//当type属性没有赋值时，改值为null。在Java中，switch表达式会出空指针异常。
			//在子类的无参构造中设置初始值，
			case "两箱" :
				return 300*days;
		
			case "越野" :
				return 500*days;
			default :
				return 500*days;
		}
		 
	}
}

实现多态

	class Test1
{
	public static void main(String[] args){
		/*
		多态的语法格式：
			父类类名 引用名称 = new 子类类名（）；
			当时多态时，该引用名称只能访问父类中的属性,但是优先访问子类重写以后的方法
		 这样造成了多个对象调用同一方法，执行不同的操作结果。子类不重写会有一样的结果
		必须有继承关系，
		*/

		Vehicle c =new Car();//new谁，就执行谁的无参构造。地址给了c
		//c是Vehicle类，对象地址给了c ，
		System.out.println(c.brand);//null
		System.out.println(c.id);//null
		// System.out.println(c.type);//报错，找不到符号，引用名称时父类类型，只能访问父类的属性
		//将c改成Car子类，就可以访问了，当是父类继承多态时，只能访问父类的属性和方法
		c.print();
		System.out.println(c.getSumRent(1));
	}
}

多态原理

通过面向对象的方式双重调用
1.第一层 Master a =new Master();
通过a.feed()调用方法feed,而feed(Pet pet)的括号里是子类对象
2.第二层 Cat b =new Cat()
通过 Cat b =new Cat(); b就是先继承了父类Pet,把b传递的对象给feed()方法
3. a.feed(b);实现双层调用。相当于 Pet a =new Cat();就是多态
4. 方法的形参写父类类型，实参写子类类型，会属于多态，相当于Pet pet=new Cat();直接写子类类型，及在Master类中重复写方法喂可以把形参写成子类，但是要多次重复写用来适合不同的子类对象.
Pet类

package 多态;

public class Pet {
	public void eat() {
		System.out.println("吃");
	}

}

Cat子类

	package 多态;

public class Cat extends Pet{
	public void eat() {
		System.out.println("猫吃猫粮");
	}
	

}

Master调用类

package 多态;

public class Master {
	public void feed(Pet pet) {
		pet.eat();
	}

}

	 测试类

	package 多态;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Master a=new Master();
		Cat b =new Cat();
		a.feed(b);//通过面向对象的方式双重调用
		/*1.第一层 Master a =new Master();
		 * 		通过a.feed()调用方法feed,而feed(Pet pet)的括号里是子类对象
		 * 2.第二次
		 * 		通过 Cat b =new Cat(); b就是先继承了父类Pet,把b传递的对象给feed()方法
		 * 
		 * */

	}

}

子类中的独有方法调用需要强转，从多态的父类型强转为子类

class Cat extends Pet
{
	public void eat(){
		System.out.println("猫在吃猫粮");
	}
	public void print(){
		System.out.println("猫爬树");
	}

}
class Dog extends Pet
{
	public void eat(){
		System.out.println("狗在吃狗粮");
	}
	public void print(){
		System.out.println("狗吃屎");
	}
	
}
class Test4
{
	public static void main(String[] args){
		//创建主人对象
		Master m =new Master();
		//创建狗对象
		Dog d =new Dog();
		//主人喂养宠物 
		m.feed(d);//相当于把d给父类Pet pet =d 
		Cat c =new Cat();
		m.feed(c);
		

	}
}
//方法的形参写父类类型，实参写子类类型，会属于多态，相当于Pet pet=new Dog();直接写子类类型，及在Master类中重复写方法喂可以把形参写成子类，但是要多次重复写用来适合不同的子类对象
//编写独有的方法，比如狗玩飞盘，猫爬树
class Test5
{
	public static void main(String[] args){
		Pet p =new Cat();//多态
		p.eat();
		//p.print();//报错，必须进行向下转型

		Cat c =(Cat)p;//像下转型。因为p存的时猫的对象，才能转的。现实里猫不能转成人
		c.print();//不报错
		double a=3.14;
		int b= (int)a;
	}}		//Dog d =(Dog)p;//报错。不能强转的。p内存的是猫的灵魂属性
		//解决办法：当进行向下转型时，建议先进行判断，当合法则转，否使用instanceof关键字。
		
		}
}
//多态两种类型转换
//		向上转型（自动类型转换）//          *父类类型 引用名称 = new 子类类名（）;构成多态，只能访问父类的属性或方法，优先子类的重写

 //      向下转型 也叫强制类型转换
 //           *当时多态时，并且访问子类独有的属性或方法时，则必须进行向下转型
//             重要：当是多态，并且访问子类独有的属性或方法时，必须进行向下转型。

多态的三种使用方式

1.Animal a =new Dog();的方式；更简洁；优先调用子类的重写方法；使多个对象调用同一方法有不同的执行结果。
父类执行子类的方法，要先用instanceof判断；是的化进行向下转型；才可以使用子类独有的方法

package 练习10;

public class Test1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal animal =new Cat();
		animal.eat();
		if(animal instanceof Cat) {
			Cat a=(Cat)animal;
			a.play();
		}
		
		Animal animal1 =new Dog();
		animal1.eat();
		if(animal1 instanceof Dog) {
			Dog b=(Dog)animal1;
			b.play();
		}

	}


}
class Animal{
	public void eat() {
		System.out.println("chi");
	}
	
}
class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	public void play() {
		System.out.println("猫咪在爬树");
	}
}
class Dog extends Animal{
	public void eat() {
		System.out.println("狗吃骨头");
	}
	public void play() {
		System.out.println("狗在玩飞盘");
	}
	
}

2.作为方法的入参，让当前入参传入的类型更多

 public void flow (Pet pet){
 	feed(pet);
 }

安琪拉是亚瑟的所有物

package 练习10;


public class Test2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Pet pet =new Pet();
		pet.name="安其拉";
		Hero hero=new Hero("亚瑟",pet);
		hero.run(pet);

	}

}
class Hero{
	private String name;
	private Pet pet;//has a；一个类在一个归属类中作为成员变量使用

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	public Hero() {
		
	}
	public Hero(String name,Pet pet) {
		this.name=name;
		this.pet=pet;
	}
	public void run(Pet pet) {
		System.out.println(name+"再跑");
		pet.flow();
	}
}