多态的含义

目录

 一、多态核心

二、多态中的重写

三、引用类型转换

四、抽象

---

 一、多态核心

class Animal{
	public void eat() {
		System.out.println("动物正在吃...");
	}
}

class Dog extends Animal{
	public void run() {
		System.out.println("狗正在吃...");
	}
}

public class Test1 {
	public static void main(String[] args) {
		Animal an = new Dog();//父类引用指向子类对象
		an.eat();//可以调用父类
		//an.run();//但不能调用子类
	}
}

二、多态中的重写

直接引用多态

class Animal{
	public void eat() {
		System.out.println("动物正在吃...");
	}
}

class Dog extends Animal{
	public void run() {
		System.out.println("狗正在吃...");
	}
}

public class Test1 {
	public static void main(String[] args) {
		Animal an = new Dog();//父类引用指向子类对象
		an.eat();//可以调用父类
		//an.run();//但不能调用子类
	}
}

class Animal2{//直接引用多态
	public void eat() {
		System.out.println("动物正在吃...");
	}
}

class Dog2 extends Animal2{
	public void run() {
		System.out.println("狗正在跑...");
	}
	@Override
	public void eat() {
		System.out.println("狗正在吃...");
	}
}


public class Test2 {
	public static void main(String[] args) {
		Animal2 an = new Dog2();
		an.eat();//优先调用子类重写的方法
	}
}

传参引用多态

注意开闭原则：对外新增的代码持开放状态——扩展性，对内修改的代码持关闭状态——维护性，灵活性

//传参引用的多态
//案例：主人喂养宠物，狗，猫都可当成宠物看待；都有吃的方法；完成该案例
//分析：类-Mater，Pet，Dog，Cat  方法-喂养，吃
class Pet{  //宠物类的吃的方法
	public void eat() {
		System.out.println("宠物正在吃");
	}
}
class Cat extends Pet{
	@Override
	public void eat() {
		System.out.println("猫正在吃");
	}
}
class Dog extends Pet{
	@Override
	public void eat() {
		System.out.println("狗正在吃");
	}
}
class Master{  //主人类
	//--------重载的方法----------
	/*
	public void feed(Dog dog) {
		dog.eat();  //狗正在吃
	}
	public void feed(Cat cat) {
		cat.eat();  //猫正在吃
	}*/
	//问题：违背了面向对象的ocp原则--开闭原则
	//o-open: 对外新增的代码(新增其他宠物类)持开放状态---扩展性
	//c-close：对内修改的代码（重载）持关闭状态---维护性，灵活性
	//传参方式实现多态，调用子类重写方法
	public void feed(Pet pet) {//Pet pet = new Cat();
		pet.eat();
	}
}
public class Test1 {
	public static void main(String[] args) {
		Master master = new Master(); //实例化主人对象
		master.feed(new Dog());  //主人喂养狗
		master.feed(new Cat());  //主人喂养猫
	}
}

返回值引用多态

class Pet2{
	
}
class Dog2 extends Pet2{
	
}
class Cat2 extends Pet2{
	
}
class Mastere{
	public Pet2 buy(int type) {
		if(type==1) {//标记，返回Dog对象
			return new Dog2();
		}else if(type==2) {
			return new Cat2();
		}else {
			return null;
		}
	}
}

public class Return_test1 {
	public static void main(String[] args) {
		Mastere mastere = new Mastere();
		//父类引用去接收——返回值多态
		Pet2 pet = mastere.buy(1);
		System.out.println(pet);
		Pet2 pet1 = mastere.buy(2);
		System.out.println(pet1);
	}
}

三、引用类型转换

子类转父类：默认转

父类转子类：强转（有隐患）

Animal animal = new Dog();//子类转父类默认转
		Dog dog = (Dog) animal;//父类转子类强转

class Pet{
	
}
class Bird extends Pet{
	
}
class Cat extends Pet{
	
}

public class Test2 {
	public static void main(String[] args) {
		Pet pet = new Cat();//子转父是默认转
		if(pet instanceof Bird) {
			Bird bird = (Bird)pet;
			System.out.println("本身是鸟类转鸟类");
		}else if(pet instanceof Cat){
			Cat cat = (Cat)pet;//如果15行是猫类，则这里应该是猫类转为猫类，
			System.out.println("本身是猫类转成猫类");
		}
	}
}

四、抽象

抽象是指一个类有某种方法，但不知道如何实现，这种方法叫做抽象方法，具体的实现交给子类来完成（重写），设计抽象类的目的是为了更为自然的使用多提；一般抽象方法作为模板来使用

直接引用多态

abstract class Animale{
	public void bark() {
		
	}
}

class Doge extends Animale{
	@Override
	public void bark() {
		System.out.println("来福正在叫");
	}
}

public class Test1_1 {
	public static void main(String[] args) {
		Animale an = new Doge();
		an.bark();
	}
}