【Java 多态详解】

1.Java中的多态

Java的三大特性：封装，继承，多态

多态的定义：多种形态，是面向对象的三大特征，多态的基础是继承和封装

1.1方法的多态

在方法中，方法的重写和重载其实就是一种方法的多态

class Person {
	public void eat () {    //方法的重载
		System.out.println("吃饭");
	}
	public void eat (String food) {
		System.out.println("吃" + food);
	}
}
class Man extends Person {
	@Override
	public void eat() {  //方法的重写
		System.out.println("吃枸杞");
	}
	@Override
	public void eat(String food) {
		System.out.println("吃"+ food);
	}
}

1.2对象的多态

多态就是：父类的引用指向子类的对象

通俗的说：多态就是不同对象对同一物体或事件发出不同的反应或响应。比如stuendt是一个父类，那么在操场上上体育课的学生和在教室里面的学生就是它的子类。这时上课铃声响了，上体育课的学生去操场，在教室里面上课的学生则是回教室，不同的学生有着不同的反应，这就是多态。

Animal animal = new Dog();

Animal anima1 = new Cat();

实现多态的条件：

1.继承：子类继承父类。

2.重写：子类需要对父类中的一些方法进行重写

3.向上转型：在多态中需要将子类的引用赋给父类的对象，只有这样才能调用父类的方法和子类的方法

案例：

class Person {
	public void feed (Animal animal) {  //创建一个方法无返回值，参数为animal对象
		animal.eat();
	}
}
interface Animal {  //定义的Animal接口
	public void eat (); 
}
class Dog implements Animal{
	@Override   //重写eat方法
	public void eat () {
		System.out.println("狗在吃骨头......");
	}
}
class Cat implements Animal{
	@Override   //重写eat方法
	public void eat () {
		System.out.println("猫吃鱼......");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		
		Person person = new Person();
		Animal animal = new Cat();  //多态  父类的引用指向子类对象
		person.feed(animal);
		Animal animal1 = new Dog(); //多态  父类的引用指向子类对象
		person.feed(animal1);
	}

}

编写程序实现比萨制作。需求说明编写程序，可供选择的比萨有：培根比萨和海鲜比萨。

实现思路及关键代码

1) 分析培根比萨和海鲜比萨

2) 定义比萨类

3) 属性：名称、价格、大小

4) 方法：展示

5) 定义培根比萨和海鲜比萨继承自比萨类

6) 定义比萨工厂类，根据输入信息产生具体的比萨对象
PizzaFactory {
	createPizza(Pizza);//如果传的参数培根披萨就是生产培根披萨  如果传的是海鲜披萨就是生产的海鲜披萨
}

案例：

package com.qfedu.class1;

class Pizza {
	private String name;
	private double price;
	private int size;
	
	public void show() {
		System.out.println(name+":"+price+":"+size);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	public int getSize() {
		return size;
	}

	public void setSize(int size) {
		this.size = size;
	}
}
class Hpizza extends Pizza {
	@Override
	public void show() {
		System.out.println(this.getName()+":"+this.getPrice()+":"+this.getSize());
	}
}
class Ppizza extends Pizza {
	@Override
	public void show() {
		System.out.println(this.getName()+":"+this.getPrice()+":"+this.getSize());
	}
}
class PizzaFactory {
	public void createPizza(Pizza pizza) {
		pizza.show();
	}
}
public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Pizza pizza1 = new Hpizza();
		pizza1.setName("海鲜披萨");
		pizza1.setPrice(36.2);
		pizza1.setSize(14);
		PizzaFactory pizzaFactory = new PizzaFactory();
		pizzaFactory.createPizza(pizza1);
		Pizza pizza2 = new Ppizza();
		pizza2.setName("培根披萨");
		pizza2.setPrice(35.1);
		pizza2.setSize(12);
		pizzaFactory.createPizza(pizza2);
		
	}

}

1.3多态的转型

多态的向上转型：

就是父类的引用指向子类的对象

语法格式：

父类 父类的引用 = new 子类（）;

将子类的对象赋值给了父类的引用。小范围（子类） 转为大范围（父类）自动转

父类的引用可以调用父类的所有成员方法，可以调用子类的重写父类的方法，但是不能调用子类独有的方法。

案例：

class Person {
	public void eat () {  //定义了一个没有具体操作的方法
	}
}
class Student extends Person {   //学生类去继承Person类
	@Override
	public void eat() {   //重写父类的方法
		System.out.println("学生要吃饭");
	}
	public void sleep () {  //子类自己的方法
		System.out.println("中午不谁下午崩溃！！！");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Person person = new Student();//向上转型 ，多态的体现
		person.eat();  
		//person.sleep();
	}

}

多态向下转型：

语法格式：

父类类型 父类的引用 = new 子类();
子类类型 子类的引用 = (子类类型)父类的引用;  //向下转型

案例：

class TestA {
	//Object 是所有类的父类
	public void test (Object obj ) {
	//传入一个String类型的数据 就相当于 Object obj = new TestA("狗蛋"); 
	//先进行向上转型  ， 在进行向下转型
//		String str = (String) obj; 
//		System.out.println(str);
//传入一个Int类型的数据 就相当于 Object obj = new TestA(98);
		int i1 = (int)obj;
		System.out.println(i1);	
	}
}
public class Demo4 {
	public static void main(String[] args) {
		TestA testA = new TestA();
		testA.test(98);
	}

}

1.4instanceof 关键字

比较操作符，返回值是布尔类型的数据

语法格式：

对象的引用 instanceof 运行类型

用来判断对象的运行类型，是否是谁的子类，是为了在强转的时候不出现问题

案例：

class Employee {}
class Monkey {
	//这个方法的返回值是一个字符串
	public String xixi(Object obj) {
		//   Object obj 相当于 Object obj = new String("狗蛋");
		//obj  instanceof String
		if (obj instanceof String) {  //判断是否 是平级 或者是子类 返回值为true 或 false
			String string = (String)obj; //向下转型
			return "传给我的 参数是字符串类型的数据";
		}  else if (obj instanceof Integer) {
			Integer i1 = (Integer)obj;
			return "传给我的 参数是int类型的数据";
		} else if (obj instanceof Employee) {
			Employee employee = (Employee)obj;
			return "传给我的参数是一个Employee对象";
		}
		else {
			return "参数不合法";
		}
		
		
	}
}
public class Demo3 {
	public static void main(String[] args) {
		Monkey monkey = new Monkey();
		//System.out.println(monkey.xixi("狗蛋"));
		
		//System.out.println(monkey.xixi(89));
		Employee employee = new Employee();
		System.out.println(monkey.xixi(employee));
		String string = new String();
	}

}

多态的优点

1.可替换性，多态对已存在代码具有可替换性。

2.可扩充性，多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。

3.接口性，多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。

4.灵活性，它在应用中体现了灵活多样的操作，提高了使用效率。

5.简化性，多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。