网盘搜索网站如何做的他达那非副作用太强了
多态是面向对象编程的三大特性之一（封装、继承、多态），它允许不同类的对象对同一消息做出不同的响应。
多态的基本概念
1、定义
多态(Polymorphism)指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
父类的引用指向子类的对象，只能调用父类的方法和子类重写的父类的方法，不能调用子类独有的方法。
2、多态的必要条件
-
继承关系：存在继承或实现关系
-
方法重写：子类重写父类方法
-
父类引用指向子类对象：向上转型(Upcasting)
3、多态的表现形式
-
编译时多态：方法重载(Overload)
-
运行时多态：方法重写(Override)
多态的实现方式
1、方法重写实现多态
class Animal {public void makeSound() {System.out.println("动物发出声音");}
}class Cat extends Animal {@Overridepublic void makeSound() {System.out.println("喵喵喵");}
}class Dog extends Animal {@Overridepublic void makeSound() {System.out.println("汪汪汪");}
}public class Test {public static void main(String[] args) {Animal a1 = new Cat(); // 向上转型Animal a2 = new Dog(); // 向上转型a1.makeSound(); // 输出"喵喵喵" - 运行时多态a2.makeSound(); // 输出"汪汪汪" - 运行时多态}
}2、接口实现多态
interface Shape {void draw();
}class Circle implements Shape {@Overridepublic void draw() {System.out.println("绘制圆形");}
}class Square implements Shape {@Overridepublic void draw() {System.out.println("绘制方形");}
}public class Test {public static void main(String[] args) {Shape s1 = new Circle();Shape s2 = new Square();s1.draw(); // 输出"绘制圆形"s2.draw(); // 输出"绘制方形"}
}3、抽象类、抽象方法实现多态
abstract class Shape {abstract double area(); // 抽象方法void display() { // 具体方法System.out.println("面积：" + area());}
}class Circle extends Shape {private double radius;Circle(double r) { this.radius = r; }@Overridedouble area() {return Math.PI * radius * radius;}
}// 使用多态
Shape shape = new Circle(5.0);
shape.display(); // 输出"面积：78.53981633974483"多态中的类型转换
1、向上转型
Animal animal = new Cat(); // 向上转型自动类型转换
子类转父类
安全，不会抛出异常
2、向下转型
Animal animal = new Cat();if (animal instanceof Cat) {Cat cat = (Cat) animal; // 向下转型cat.catchMouse(); // 调用Cat特有方法
}强制类型转换
父类转子类
不安全，可能抛出ClassCastException
建议先用instanceof检查
多态的特点
-
可替换性：多态对已存在的代码具有可替换性
-
可扩展性：新增子类不影响多态特性的使用
-
灵活性：在应用中体现了灵活多样的操作
-
简化性：简化了应用代码的编写和修改过程
多态与重载的区别
1、基本定义对比
2、方法签名对比
3、继承关系对比
多态的实例 【理解方法调用】
//创建子对象时一定先创建父对象
Animal a1=new Cat();
Cat cat = new Cat();
//Cat:类名
//cat:变量
//new:关键字
//Cat():构造器Java当中的数据类型，决定数据在内存中的存储形式
在下面的实例中，一共有4个类：A、B、C、D
//A类
public class A {public String Show(D obj) {return "A and D";}public String Show(A obj) {return "A and A";}
}
//B类
public class B extends A{public String Show(Object obj) {return "B and B";}public String Show(A obj) {return "B and A";}
}
//C类
public class C extends B{
}
//D类
public class D extends B{}测试类：
public class Test {public static void main(String[] args) {A a1 = new A();A a2 = new B();B b = new B();C c = new C();D d = new D();System.out.println("1---"+a1.Show(b));System.out.println("2---"+a1.Show(c));System.out.println("3---"+a1.Show(d));System.out.println("4----"+a2.Show(b));System.out.println("5----"+a2.Show(c));System.out.println("6----"+a2.Show(d));System.out.println("7---"+b.Show(b));System.out.println("8---"+b.Show(c));System.out.println("9---"+b.Show(d));}
}结果：
实例解析：
a1.show()内存图（简略版）如下：
a1只能调用A中的两个方法，要么输出A and D,要么输出A and A;
1、a1.show(b)
传入的参数为B类型的b，而B类继承自A类，自动向上转型至A类【此时涉及到多态】；
输出A and A;
2、a1.show(c)：
C类的c向上转型2次至A类，输出A and A；
3、a1.show(d):
传入的参数为D类型的d，A类方法本身有show(D obj),不需要向上转型
a2.show()内存图:
a2为A类型，调用B类时，会先生成B类的父类A类，所以在堆中有两个类，但是a2指向A类；
当A类中的方法被子类B类重写时，A类方法失效，原方法指向B类中的新方法；
a2输出的语句要么为A and D,要么为 B and A;
4、a2.show(b)
传入的参数为B类型的b，向上转型为A类，输出B and A;
5、a2.show(c)
传入的参数为C类型的c，向上转型两次为A类，输出B and A
6、a2.show(d)
方法本身有D类型的参数，不需要转型，直接输出A and D;
b.show():
B b=new B()---这种纯子类的方式，不掺杂任何其他类型时，既能利用到父类，也能利用到子类【继承】；
因为子类重写父类show（A）方法，所以A类对应方法失效；
所以b可以调用3种方法；
7、b.show(b)
传入B类型的b，向上转型为A类，输出B and A；
8、b.show(c)
传入C类型的c，向上转型2次为A类，输出B and A；
9、b.show(d)
不需要转型，直接输出 A and D；