本文详细介绍了Java中的多态性，包括多态的概念，实现多态需要的条件（向上转型、方法重写及通过父类引用调用），方法重写的原则和与重载的区别。同时，探讨了向上和向下转型的用法及其优缺点，展示了如何利用多态简化代码并增强可扩展性。
1. 多态的概念
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。 （同样一件事，我和你去做是两种效果）
总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。
2. 多态实现条件
在java中要实现多态，必须要满足如下几个条件，缺一不可：
- 完成向上转型
- 完成方法重写
- 通过父类的引用调用重写的方法
class Animal{ private String name; private int age; public Animal(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void eat(){ System.out.println("正在吃饭(Animal)"); } @Override public String toString() { return "Animal{" + "name='" + name + '\'' + ", age=" + age + '}'; } } class Dog extends Animal{ public Dog(String name, int age) { super(name, age); } public void eark(){ System.out.println(getName()+"正在汪汪汪"); } @Override public void eat() { System.out.println(getName()+"正在吃狗粮"); } } class Bird extends Animal{ public String wing; public Bird(String name, int age) { super(name, age); } public void fly(){ System.out.println(getAge()+"正在飞"); } @Override public void eat(){ System.out.println(getName()+"要吃鸟粮");//动态绑定：重写 } } public class Test { //----------------------类的调用者实现的------------------------// private static void func(Animal animal){ animal.eat();//不论引用的对象 } public static void main(String[] args) { //父类引用，引用了子类对象，通过父类的引用，调用这个重写的方法，此时发生了动态绑定！ //此时 父类引用只有一个，我引用的对象不一样，但是通过调用同一个方法，我们发现此时表现的形式是不一样 //把这个现象称为:多态 func(new Bird("小鸟",1)); func(new Dog("狗子",1)); } }
在上述代码中, 分割线上方的代码是 类的实现者 编写的, 分割线下方的代码是 类的调用者 编写的.
当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为多态.
3. 重写
重写(override)：也称为覆盖。
重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
重写
class Animal{ private String name; private int age; public Animal(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void eat(){ System.out.println("正在吃饭(Animal)"); } @Override public String toString() { return "Animal{" + "name='" + name + '\'' + ", age=" + age + '}'; } } class Dog extends Animal{ public Dog(String name, int age) { super(name, age); } public void eark(){ System.out.println(getName()+"正在汪汪汪"); } } class Bird extends Animal{ public String wing; public Bird(String name, int age) { super(name, age); } public void fly(){ System.out.println(getAge()+"正在飞"); } public void eat(){ System.out.println(getName()+"要吃鸟粮");//动态绑定：重写 } } public class Test { public static void main(String[] args) { Bird bird = new Bird("鹦鹉",2); Animal animal=bird;//向上转型，把子类的类给父类 //animal.fly error:fly是bird类的，在这里我们是用的animal类 //animal.wing error:不可以调用了，此时通过父类引用，只能调用自己特有的方法 animal.eat(); } } //运行结果:鹦鹉要吃鸟粮
【方法重写的规则】
被重写的方法返回值类型可以不同，但是必须是具有父子关系的！！class a{ public a eat(){ return new a(); } } //子类的返回值和父类是父子类关系也可以【协变类型】 class b extends a{ public b eat(){ return new b(); } }当我们不想让方法重写时：只需加上final
【重写和重载的区别】
| 区别点 | 区别点 重载(override) | 重写(override |
| 参数列表 | 必须修改 | 一定不能修改 |
| 返回类型 | 可以修改 | 一定不能修改 |
| 访问限定符 | 可以修改 | 一定不能做更严格的限制（可以降低限制） |
即：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
【重写的设计原则】
对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，
并且添加或者改动新的内容。
例如：若干年前的手机，只能打电话，发短信，来电显示只能显示号码，而今天的手机在来电显示的时候，不仅仅
可以显示号码，还可以显示头像，地区等。在这个过程当中，我们不应该在原来老的类上进行修改，因为原来的
类，可能还在有用户使用，正确做法是：新建一个新手机的类，对来电显示这个方法重写就好了，这样就达到了我
们当今的需求了。
4. 向上转移和向下转型
4.1 向上转型
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用
语法格式：
父类类型 对象名 = new 子类类型() Animal animal = new Cat("喵喵",2);animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换
使用场景：
- 直接赋值
- 方法传参
- 方法返回
public class TestAnimal { // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象 public static void eatFood(Animal a){ a.eat(); } // 3. 作返回值：返回任意子类对象 public static Animal buyAnimal(String var){ if("狗" == var){ return new Dog("狗狗",1); }else if("猫" == var){ return new Cat("猫猫", 1); }else{ return null; } } public static void main(String[] args) { Animal cat = new Cat("喵喵",2); // 1. 直接赋值：子类对象赋值给父类对象 Dog dog = new Dog("汪汪", 1); eatFood(cat); eatFood(dog); Animal animal = buyAnimal("狗"); animal.eat(); animal = buyAnimal("猫"); animal.eat(); } }向上转型的优点：让代码实现更简单灵活
向上转型的缺陷：不能调用到子类特有的方法
4.2 向下转型
将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的
方法，此时：将父类引用再还原为子类对象即可，即向下转换。
class Animal{ private String name; private int age; public Animal(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void eat(){ System.out.println("正在吃饭(Animal)"); } @Override public String toString() { return "Animal{" + "name='" + name + '\'' + ", age=" + age + '}'; } } class Dog extends Animal{ public Dog(String name, int age) { super(name, age); } public void eark(){ System.out.println(getName()+"正在汪汪汪"); } @Override public void eat() { System.out.println(getName()+"正在吃狗粮"); } } class Bird extends Animal{ public String wing; public Bird(String name, int age) { super(name, age); } public void fly(){ System.out.println(getName()+"正在飞"); } @Override public void eat(){ System.out.println(getName()+"要吃鸟粮");//动态绑定：重写 } } public class Test { public static void main(String[] args) { Animal animal= new Bird("鹦鹉",2); Bird bird = (Bird)animal; bird.fly(); /*********************************************************/ //error：不是所有的动物都是鸟 /*Animal animal1=new Dog("狗子",1); Bird bird = (Bird)animal; bird.fly();*/// } } //运行结果:鹦鹉正在飞向下转型需要向上转型完毕后再去向下转型，向下转型成功后，可以调用子类的对应方法了
向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了
instanceof，如果该表达式为true，则可以安全转换。public class Test { public static void main(String[] args) { Bird bird = new Bird("鹦鹉",2); Dog dog = new Dog("汪汪", 1); // 向上转型 Animal animal = bird; animal.eat(); animal = dog; animal.eat(); //animal 是不是引用了 Bird这个对象 if(animal instanceof Bird){ bird = (Bird)animal; bird.new(); } //animal 是不是引用了 Dog这个对象 if(animal instanceof Dog){ dog = (Dog)animal; dog.bark(); } } }
5. 多态的优缺点
使用多态的好处：
1.避免使用大量的 if - else在没有多态的情况下：
public static void drawShapes() { Rect rect = new Rect(); Cycle cycle = new Cycle(); Flower flower = new Flower(); String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"}; for (String shape : shapes) { if (shape.equals("cycle")) { cycle.draw(); } else if (shape.equals("rect")) { rect.draw(); } else if (shape.equals("flower")) { flower.draw(); } } }在多态的情况下：如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单
class Shape{ //属性... public void draw(){ System.out.println("画图形！"); } } class Rect extends Shape{ @Override public void draw() { System.out.println("♦"); } } class Cycle extends Shape{ @Override public void draw() { System.out.println("●"); } } class Triangle extends Shape{ @Override public void draw() { System.out.println("▲"); } } class Flower extends Shape{ @Override public void draw() { System.out.println("🌹"); } } public class Test2 { public static void drawMap(Shape shape){ shape.draw(); } public static void main(String[] args) { Rect rect = new Rect(); Cycle cycle = new Cycle(); Triangle triangle =new Triangle(); Flower flower = new Flower(); /*drawMap(rect); drawMap(cycle); drawMap(triangle); drawMap(flower);*/ Shape[] shapes = {rect,cycle,triangle,flower}; for (Shape shape:shapes){ //当前shape引用的对象重写draw方法就调用，没有就调用shape自己的 shape.draw(); } } }
2.可扩展能力更强
如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低class Triangle extends Shape { @Override public void draw() { System.out.println("△"); } }
扫一扫
119
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
