1.多态的定义

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

总的来说：多态性指基类型的引用对象指向派生类，指采用多种形式的能力；

在Java中, 引用变量可以是多态的， 即它可以存放不同类对象的地址，只要这些类是它声明的类的派生类即可。

2.实例

向上转型

public class triangle {

    public void printArea() {
        System.out.println("triangle 's area = ");
    }

    public static void main(String[] args) {
        isoscelesTriangle i = new isoscelesTriangle();
        i.printArea();

        triangle t = new isoscelesTriangle();// （1）向上转型
        t.printArea();           // （2）动态绑定
      //t. perimeter();  （3）此方法不能编译，报错说trangle类没有此方法
    }
}

class isoscelesTriangle extends triangle {
    @Override
    public void printArea() {
        System.out.println("triangle 's area = ");
    }
}

向下转型

public class trangle {
    public void printArea() {
        System.out.println("trangle 's area = ");
    }
    public static void main(String[] args) {
    // (1）向上转型
        isoscelesTriangle i1 = new isoscelesTriangle();
        trangle t1 = i1;      
        t1.printArea();
        //t1.printPerimeter();   // 此时需要向下转型，否则不能调用printPerimeter方法。
        
//        // （2）向下转型
//        trangle t2 = new isoscelesTriangle();
//        trangle t2 = i2;  
//        i2 = (isoscelesTriangle) t2;         
//        t2.printPerimeter(); 
        
//        // （3）向下转型：失败
//        trangle t3 = new trangle();
//        isoscelesTriangle i3 = (isoscelesTriangle)t3;
//        t3.printPerimeter();   //此时会出现运行时错误，所以可以用instanceOF判断 
//        
//        // （4）向下转型：类型防护
//        trangle t4 = new trangle();
//        if (t4 instanceof isoscelesTriangle){  
//         //因为t4不是isoscelesTriangle的实例，所以不执行if内部代码
//             isoscelesTriangle i4 = (isoscelesTriangle)t4;
//             t4.printPerimeter();
//        }
    }
}
class isoscelesTriangle extends trangle {
    @Override
    public void printArea() {
        System.out.println("trangle 's area = ");
    }

    public void printPerimeter() {
        System.out.println("trangle 's perimeter = ");
    }
}

基类型对象访问派生类重写的方法

public static void main(String[] args) {

GradedActivity[] tests = new GradedActivity[3];

// 第一次考试采用五级计分制，考了75
tests[0] = new GradedActivity();
tests[0].setScore(75);

// 第二次考试采用二级计分制（P或者F）。总共20题，每题分值相同，考生答错5题。
// 通过的最低分数线是60分
tests[1] = new PassFailExam(20, 5, 60);

// 第三次是期末考试也采用五级计分制. 总共50题，每题分值相同，考试答错7题
tests[2] = new FinalExam(50, 7);

// 显示每次考试的分数和等级
for(int i=0; i<tests.length; i++){
   showValue(tests[i]);
}
}

public static void showValue(GradedActivity exam){
System.out.println("Score: " + exam.getScore()+ "\t" + 
"Grade: " + exam.getGrade());
}

3.使用

前提:多态对象把自己看做是父类类型

1. 成员变量: 使用的是父类的
2. 成员方法: 由于存在重写现象,所以使用的是子类的
3. 静态成员: 随着类的加载而加载,谁调用就返回谁的

4.总结

多态指使用父类对象的地方都可以使用子类的对象，多态意味着父类型的变量可以引用子类型的对象。多态的好处是多态可以让我们不用关心某个对象到底具体是什么类型,就可以使用该对象的某些方法；提高了程序的可扩展性和可维护性。

只是小白的学习笔记，有错轻喷🥬

除封装和继承之外，面向对象程序设计的第三个支柱。简单来说，多态意味着父类型的变量可以引用子类型的对象

💡 多态：同一个行为具有不同表现形式或形态的能力，即对象多种表现形式的体现，例如子类的实例也可作为父类的实例（Student类是Person类的子类，则一个Student的对象便既是Student，也是Person）

• 定义与使用格式

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

  例如，通过Object p = new Person(); 代码定义一个变量p

• 多态中成员的特点

  成员变量：

  Father f=new Son();
  System.out.println(f.num);//f是Father中的值，只能取到父中的值
  

  成员方法：

  Father f1=new Son();
  System.out.println(f1.show());//f1的门面类型是Father,但实际类型是Son,所以调用的是重写后的方法。
  

  例如Object p = new Person();中的变量p只能调用Person类的方法，只能访问Object类的属性

如图所示，扫描二维码可以对映三种不同的支付方式

//支付抽象类或者接口
public abstract class Pay {
    abstract public String pay();
}
//支付宝支付
public class AliPay extends Pay {
    @Override
    public String pay() {
        System.out.println("支付宝pay");
        return "success";
    }
}
//微信支付
public class WeixinPay extends Pay {
    @Override
    public String pay() {
        System.out.println("微信pay");
        return "success";
    }
}
//银联支付
public class YinlianPay extends Pay {
    @Override
    public String pay() {
        System.out.println("银联支付");
        return "success";
    }
}

//测试支付
public static void main(String[] args) {
 //支付宝支付
    Pay pay = new AliPay();
    pay.pay();

 //微信支付
    pay = new WeixinPay();
    pay.pay();

 //银联支付
    pay = new YinlianPay();
    pay.pay();
}

输出结果如下：

支付宝pay
微信pay
银联支付

• 多态产生的必要条件

  1. 继承
  2. 重写
  3. 父类引用指向子类对象

• 多态的转换

   💡 对象转换：一个对象的引用可以类型转换为对另外一个对象的引用

  ---

  1. 隐式转换

     将对象 new Student() 赋值给一个 Object 类型的参数→ Object o = new Student();

     由于Student的实例也是Object的实例，所以语句合法。

  2. 显式转换

     Object o = new Student();
     Student b = o;//编译错误
     

     编译错误原因：通过隐式转换虽然看上去o是一个Student的实例，但是本质仍然为Object，故不能赋值给Student类型的b

     //将（目标对象的类型）放到要转换的对象前面
     Object o = new Student();
     Student b = (Student)o;
     

  3. 向上转换（多态本身就是向上转型过的过程）

     将子类的实例转换为父类的变量

     父类类型 变量名=new 子类类型();

  4. 向下转换（使用（子类名）进行显示转换）

     将父类的实例转换为子类变量

     子类类型 变量名=（子类类型） 父类类型的变量；

• instanceof操作符

  💡 instanceof操作符：用来判断某个对象是否属于某种数据类型，返回值为布尔类型

• 多态的优点

1. 可替换性。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如椭圆，也同样工作。
2. 可扩充性。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性，继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，对等边三角形的操作，不会影响直角三角形
3. 接口性。多态是超类通过方法签名， 向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。
4. 灵活性。它在应用中体现了灵活多样的操作，提高了使用效率。
5. 简化性。简化了对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。​​​​​​​

//实例
public class A {
    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    } 

}

public class B extends A{
    public String show(B obj){
        return ("B and B");
    }
    
    public String show(A obj){
        return ("B and A");
    } 
}

public class C extends B{

}

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));      
    }
}
//摘自https://blog.csdn.net/thinkGhoster/article/details/2307001

//运行结果
1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

多态：同样的引用调用同样的方法却做了不同的事情。

概述：

在设计一个方法时，通常希望该方法具备定的通用性。 例如要实现一个动物叫的方法，由于每种动物的叫声是不同的，因此可以在方法中接收一个动物类型的参数，当传入猫类对象时就发出猫类的叫声，传人犬类对象时就发出犬类的叫声。在同一个方法中，这种由于参数类型不同而导致执行效果各异的现象就是多态。

在Java中为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。

接下来通过一个程序来演示：

abstract class Animal {
	public abstract void shout(); // 定义抽象shout()方法
}

//定义Cat类继承Animal
class Cat extends Animal {
	// 实现shout()方法
	public void shout() {
		System.out.println("喵喵...");
		
	}
}

//定义Dog类继承Animal
class Dog extends Animal {
	// 实现shout()方法
	public void shout() {
		System.out.println("汪汪...");
		
	}
}

public class Duotai {
	public static void main(String[] args) {
		Animal cat = new Cat();
		Animal dog = new Dog();
		
		animalShout(dog);
		animalShout(cat);
//		运行结果：
//				汪汪...
//				喵喵...
	
	}
	
	// 定义一个静态的animalShout()方法,接收一个Animal类型的对象
	public static void animalShout(Animal animal) {
		animal.shout();// 调用实际参数的shout()方法
	}
}

Animal cat = new Cat();和 Animal dog = new Dog(); 两行代码实现了父类类型变量引用不同的子类对象。

调用animalShout()方法时，将父类引用的两个不同子类对象分别传入，结果打印出了“汪汪...”和“喵喵...”。

由此可见，多态不仅解决了方法同名的问题，而且还使程序变得更加灵括，从而有效地提高程序的可扩展性和可维护性。

对象的类型转换

在多态的学习中，涉及到将子类对象当作父类类型使用的情况，例如下面两行代码：

Animal cat = new Cat();        //将Cat对象当作Animal类型来使用

Animal dog = new Dog();     //将Dog对象当作Animal类型来使用

将子类对象当作父类使用时不需要任何显式地声明，需要注意的是，此时不能通过父类变量去调用子类中的某些方法。

这种不需要显式声明的类型转换叫自动类型转换。

对于animalShout()方法来说，传入的对象可以是Animal类型，还可以是Animal的子类型，它要怎么知道传入的到到底是哪一个类型呢？Java提供了一个instanceof关键字来判断一个对象的类型，其使用格式如下：

对象（或对象的引用变量）  instanceof  类（或接口）

对上面animalShout()方法代码进行修改：

	public static void animalShout(Animal animal) {
		if (animal instanceof Cat) {
			Cat cat = (Cat) animal;
			cat.shout();
		} else if (animal instanceof Dog) {
			Dog dog = (Dog) animal;
			dog.shout();
		} else {
			animal.shout();
		}
	}

利用instanceof进行类型判断的好处就是避免了强制类型转换过程中类型不匹配的错误。

多态思维导图：

JAVA基础思维导图 <<