Java基础之多态

多态：多种形态。面向对象的三大特性之一。多态是建立在封装和继承之上

方法的重载和重写就是多态的体现形式

package com.qfedu.a_fun;

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);
	}
}
public class Demo1 {
	public static void main(String[] args) {
		
	}

}

1.一个对象的编译类型和运行类型是不一样的
2.编译类型是在定义对象的时候就已经确定好的
3.运行类型是可以改变的
4.编译类型看=的左边，运行类型看=的右边
Pizza pizza = new haiPizza();

package com.yu.a_test;
 abstract class  Pizza{
	private String nameString;
	private double privice;
	private int size;
	public String getNameString() {
		return nameString;
	}
	public void setNameString(String nameString) {
		this.nameString = nameString;
	}
	public double getPrivice() {
		return privice;
	}
	public void setPrivice(double privice) {
		this.privice = privice;
	}
	public int getSize() {
		return size;
	}
	public void setSize(int size) {
		this.size = size;
	}
	public Pizza()  {
		
	}
	public abstract void show();
}
class peiPizza extends Pizza{
	public void show() {
		System.out.println("培根披萨");
	}
}
class haiPizza extends Pizza {
	@Override
	public void show() {
		// TODO Auto-generated method stub
		System.out.println("海鲜披萨");
	}
}
class PizzaFactory {
	public void show(Pizza pizza) {
		// TODO Auto-generated method stub
		pizza.show();
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Pizza pizza = new haiPizza();
		PizzaFactory pizzaFactory = new PizzaFactory();
		pizzaFactory.show(pizza);
	}
}

多态：向上转型 和 向下转型

向上转型：父类引用指向子类对象（自动完成）

语法格式：

	父类  父类引用 =  new  子类（）；

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

向下转型：可以调用子类独有的方法

父类类型 父类引用 = new  子类();
子类类型 子类引用 = (子类类型)父类的引用; //向下转型需要强制转换

class TestA {
	//Object 是所有类的父类
	public void test (Object obj ) {
		//必须给我打印一个String类型的狗蛋，我不要Object类型的狗蛋
		//String str = (String) obj; 
		//System.out.println(str);
		int i1 = (int)obj;
		System.out.println(i1);	
	}
}
public class Demo4 {
	public static void main(String[] args) {
		TestA testA = new TestA();
		//testA.test("狗蛋");
		Object object = "狗蛋";
		testA.test(98);
		testA.test('狗');
	}

}

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

语法格式：

对象引用  instanceof  运行类型

用来判断对象的运行类型（=右边）， 是否是xx类型或者xx类型的子类

目的是为了在强转的时候不出现问题

class AA {}
class BB extends AA {}
public class Demo1 {
	public static void main(String[] args) {
		BB bb = new BB();
		BB bb1 = new BB();
		AA aa = new AA();
		//instanceof  的左边放的对象的引用，右边是类
		System.out.println(bb instanceof BB);//true
		System.out.println(bb1 instanceof BB);//true
		//判断对象bb是否是AA的对象或者子类的对象
		System.out.println(bb instanceof AA);//true
		System.out.println(aa instanceof AA);//true
		System.out.println(aa instanceof BB);//false
		//总结： 左边 的辈分小（对象的引用）  右边辈分大（类）  屡试不爽
		AA aa2 = new BB();
		System.out.println(aa2 instanceof AA);//true
		System.out.println(aa2 instanceof BB);//true
		
		//
		Object object = new Object();
		System.out.println(object instanceof AA);//false
		System.out.println(object instanceof Object);//true
		
		String string = "qwer";
		System.out.println(string instanceof Object);//true
	}
}