一、多态概论

1.定义

面向对象程序设计的三大支柱是封装，继承和多态。不同类的对象对同一消息作出不同的响应就叫做多态。

2.满足的条件

a.子类继承父类
b. 子类重写父类方法
c. 子类对象指向父类声明（最关键一点）

3.多态的定义与使用格式

定义格式：父类类型 变量名=new 子类类型();

二、向上转型和向下转型

1.向上转型：多态本身是子类类型向父类类型向上转换的过程（默认）。当父类引用指向一个子类对象时，便是向上转型。

向上转型不要强制转型

父类引用指向的或者调用的方法是子类的方法,这个叫动态绑定

向上转型后父类引用不能调用子类自己的方法

public class Human {
	public void sleep() {
	    System.out.println("Human sleep..");
	}
	
    public static void main(String[] args) {
    	Male m = new Male();
	    m.sleep();
	    
	    Human h = new Male();// （1） 向上转型
	    h.sleep();   //(2）动态绑定
	    //h.speak();  //(3)此方法不能编译，报错说Human类没有此方法
    }
}
	    
	
	class Male extends Human {
		@Override
		public void sleep() {
			System.out.println("Male sleep.");
		}
		public void speak () {
			System.out.println("I am Male");
	}
}
	
	class Female extends Human {
		
	@Override
	public void sleep() {
		System.out.println("Female sleep.");
	}
	public void speak() {
		System.out.println("I am Female");
	}
 
}

运行结果为：Male sleep.

                      Male sleep.

2.向下转型（用的比较少）：父类类型向子类类型向下转换的过程（强制）。一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，就是向下转型。

//接上段
 
//向下转型:成功
Male m2 = new Male();
Human h2 = m2;       //向上转型
m2 = (Male)h2;       //向下转型
m2.speak();
 
//向下转型：失败
Human h3 = new Human();
Male m3 = (Male)h3;
m3.speak();         //运行时会出现错误，可以用instanceof诊断
 
//向下转型：类型防护
Human h4 = new Human();
if (h4 instanceof Male){  //因为h4不是Male的实例，所以不执行if内部代码
    Male m4 = (Male)h4;
    m4.speak;
}

三、instanceof关键字

作用：用来判断某个对象是否属于某种数据类型。

注意： 返回类型为布尔

四、多态的应用

一个完整的 代码实例：

1.首先，创造动物类

// 动物类
class Animal {
    int age;
    String name;
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    // 动物类里面有叫和吃两个方法
    public void cry() {
        System.out.println("我不知道叫什么");
    }
 
    public void eat() {
        System.out.println("我不知道吃什么");
    }
}

2.2.其次，分别创造猫类和狗类（他们继承于动物类）：

// 狗类继承于动物类
class Dog extends Animal {
    // 覆盖（重写）方法
    public void cry() {
        System.out.println("旺旺");
    }
 
    public void eat() {
        System.out.println("我是狗，我爱吃骨头");
    }
}

// 猫类继承于动物类
class Cat extends Animal {
    // 覆盖（重写）方法
    public void cry() {
        System.out.println("喵喵");
    }
 
    public void eat() {
        System.out.println("我是猫，我爱吃鱼");
    }
}

3.再者，创建食物类：

// 食物类
class Food {
 
    String name;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    // 食物类里面让它有一个方法
    public void showName() {
 
    }
}

4.再者，猫和狗都有自己不同的爱吃的食物（他们继承于食物类）：

// 鱼（食物的一种）继承于食物
class Fish extends Food {
    public void showName() {
        System.out.println("食物：鱼");
    }
}

// 骨头（食物的一种）继承于食物
class Bone extends Food {
    public void showName() {
        System.out.println("食物：骨头");
    }
}

5.主人类（就可以将动物和对应的食物统一起来）：

// 主人类 存在一种喂食方法
class Master {
    // 给动物喂食物，如果没有多态，他要写给猫喂食和给狗喂食两个方法
    // 有了多态，以后即使再来好多动物，用这一个函数就可以了
    public void feed(Animal an, Food f) {
        an.eat();
        f.showName();
 
    }
}

6.最后，方法的调用（测试）：

public class DuoTaiDemo {
 
    public static void main(String args[]) {
 
        Master master = new Master();
        master.feed(new Dog(), new Bone());
 
        master.feed(new Cat(), new Fish());
 
    }
}

结果

 五、引用

 Java 多态 ——一个案例 彻底搞懂它_vaychen的博客-CSDN博客

标签：Java,void,多态,System,println,Male,public,out
来源： https://blog.csdn.net/For_Forever__/article/details/122308842