Java의 세 가지 주요 기능 중 다형성에 대한 심층적인 이해

Java의 세 가지 주요 기능

객체 지향 프로그래밍에는 캡슐화, 상속, 다형성이라는 세 가지 주요 기능이 있습니다.

캡슐화는 클래스의 내부 구현 메커니즘을 숨기며 클래스 사용에 영향을 주지 않고 클래스의 내부 구조를 변경할 수 있으며 데이터도 보호합니다. 내부 세부 정보만 외부 세계에 숨겨지고 액세스 방법만 외부 세계에 노출됩니다.

상속은 상위 클래스 코드를 재사용하는 것입니다. 두 클래스 사이에 IS-A 관계가 있는 경우 상속을 사용할 수 있습니다. , 그리고 상속은 또한 다형성을 실현할 수 있는 길을 열어줍니다. 그렇다면 다형성이란 무엇입니까? 다형성의 구현 메커니즘은 무엇입니까? 하나씩 공개하는 것을 지켜봐주세요:

소위 다형성이란 프로그램에서 정의한 참조 변수가 가리키는 특정 유형과 참조 변수를 통해 발행되는 메소드 호출이 실행 중에 결정되지 않는다는 것을 의미합니다. 프로그래밍은 프로그램을 실행하는 동안 결정됩니다. 즉, 참조 변수가 어떤 클래스 인스턴스 객체를 가리킬지 결정되며, 참조 변수에 의해 호출되는 메소드는 어떤 클래스에서 구현되는지, 실행 중에 결정되어야 합니다. 프로그램 실행. 특정 클래스는 프로그램이 실행 중일 때만 결정되기 때문에 소스 프로그램 코드를 수정하지 않고도 참조 변수를 다양한 클래스 구현에 바인딩할 수 있으므로 참조에서 호출하는 특정 메서드가 그에 따라 변경됩니다. 프로그램 코드는 프로그램이 실행 중일 때 프로그램에 바인딩된 특정 코드를 변경하여 프로그램이 여러 실행 상태를 선택할 수 있도록 합니다.

예를 들어, 당신은 와인의 신이고 와인을 특별히 좋아하는 사람입니다. 어느 날 집에 갔는데 테이블 위에 화이트 와인이 가득 담긴 잔이 몇 개 있었는데, 겉으로는 어떤 와인인지 알 수가 없었습니다. 마시고 나서야 어떤 와인인지 짐작할 수 있었습니다. 마시면 건안춘, 다시 마시면 우량예, 다시 마시면 구의주…

와인 b = 우량예

와인 c = 지우의주

…

여기서 표현되는 것은 다형성이다. Jiannanchun, Wuliangye 및 Jiuguijiu는 모두 와인의 하위 클래스입니다. 이는 와인의 상위 클래스를 통해서만 서로 다른 하위 클래스를 참조할 수 있습니다. 이는 실행 시 참조 변수의 특정 지점만 알 수 있습니다.

다형성을 이해하려면 "상향 변환"이 무엇인지 이해해야 하는 것은 사실입니다. 상속에서는 상향 변환을 간략하게 소개했습니다. 위의 음주 예에서 Wine(Win)이 상위 클래스이고 Jiannanchun(JNC), Wuliangye(WLY) 및 Jiuguijiu(JGJ)가 하위 클래스입니다. 우리는 다음 코드를 정의합니다:

JNC a = new JNC();

Jian Nanchun 객체를 인스턴스화하는 것에 지나지 않는 이 코드를 이해하는 것은 매우 쉽습니다! 하지만 이건 어때요?

Wine a = new JNC();

여기서 우리는 JNC 객체 인스턴스를 가리키는 Wine 유형 a가 여기에 정의되어 있음을 이해합니다. JNC는 Wine에서 상속되기 때문에 JNC는 자동으로 Wine으로 변환될 수 있으므로 a는 JNC 인스턴스 개체를 가리킬 수 있습니다. 이렇게 하면 매우 큰 이점이 있습니다. 상속에서는 하위 클래스가 하위 클래스를 가리키는 상위 클래스 참조 유형을 정의하는 경우 상위 클래스보다 더 강력한 기능을 제공할 수 있다는 것을 알고 있습니다. , 그런 다음 상위 클래스의 공통 기능을 참조할 수 있을 뿐만 아니라 하위 클래스의 강력한 기능도 사용할 수 있습니다.

그러나 상향 변환에는 몇 가지 단점이 있습니다. 즉, 일부 방법과 속성이 손실되어 얻을 수 없게 된다는 것입니다. 따라서 상위 클래스 타입의 참조는 상위 클래스에 정의된 모든 속성과 메서드를 호출할 수 있지만 하위 클래스에만 존재하는 메서드와 속성의 범위를 벗어납니다---1.

public class Wine {
 public void fun1(){
  System.out.println("Wine 的Fun.....");
  fun2();
 }
  
 public void fun2(){
  System.out.println("Wine 的Fun2...");
 }
}
 
public class JNC extends Wine{
 /**
  * @desc 子类重载父类方法
  *  父类中不存在该方法，向上转型后，父类是不能引用该方法的
  * @param a
  * @return void
  */
 public void fun1(String a){
  System.out.println("JNC 的 Fun1...");
  fun2();
 }
  
 /**
  * 子类重写父类方法
  * 指向子类的父类引用调用fun2时，必定是调用该方法
  */
 public void fun2(){
  System.out.println("JNC 的Fun2...");
 }
}
 
public class Test {
 public static void main(String[] args) {
  Wine a = new JNC();
  a.fun1();
 }
}
-------------------------------------------------
Output:
Wine 的Fun.....
JNC 的Fun2...

프로그램 실행 결과에서 a.fun1()은 먼저 상위 클래스 Wine에서 fun1()을 실행한 다음 하위 클래스 JNC에서 fun2()를 실행하는 것을 발견했습니다.

분석: 이 프로그램에서 하위 클래스 JNC는 상위 클래스 Wine의 fun1() 메서드를 오버로드하고 fun2()를 다시 작성하며, 오버로드된 fun1(String a)과 fun1()은 동일한 메서드가 아닙니다. 상위 클래스에 해당 메소드가 없기 때문에 상향 변환 후 메소드가 손실되므로 JNC를 실행하는 Wine 유형 참조는 fun1(String a) 메소드를 참조할 수 없습니다. 하위 클래스 JNC는 fun2()를 다시 작성하므로 JNC를 가리키는 Wine 참조는 JNC의 fun2() 메서드를 호출합니다.

따라서 다형성을 다음과 같이 요약할 수 있습니다.

하위 클래스를 가리키는 상위 클래스 참조는 상향 변환되며 상위 클래스가 소유한 메서드와 속성에만 액세스할 수 있습니다. subclass 부모 클래스에는 메서드가 있지만 부모 클래스에는 없으면 해당 메서드가 오버로드되어도 해당 참조를 사용할 수 없습니다. 하위 클래스가 상위 클래스의 일부 메서드를 재정의하는 경우 이러한 메서드를 호출할 때 하위 클래스에 정의된 메서드(동적 연결, 동적 호출)를 사용해야 합니다.

객체 지향 목적으로만 다형성은 컴파일 타임 다형성과 런타임 다형성으로 구분됩니다. 그 중 편집 시 다형성은 주로 메소드 오버로딩을 의미하며, 편집 후에는 런타임에 두 가지 다른 기능이 됩니다. 런타임 다형성은 동적이며 동적 바인딩을 통해 달성됩니다. 이를 다형성이라고 합니다.

다형성 구현

2.1 구현 조건

在刚刚开始就提到了继承在为多态的实现做了准备。子类Child继承父类Father，我们可以编写一个指向子类的父类类型引用，该引用既可以处理父类Father对象，也可以处理子类Child对象，当相同的消息发送给子类或者父类对象时，该对象就会根据自己所属的引用而执行不同的行为，这就是多态。即多态性就是相同的消息使得不同的类做出不同的响应。

Java实现多态有三个必要条件：继承、重写、向上转型。

      继承：在多态中必须存在有继承关系的子类和父类。

      重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

      向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。

对于Java而言，它多态的实现机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。

2.2实现形式

在Java中有两种形式可以实现多态。继承和接口。

2.2.1、基于继承实现的多态

基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

public class Wine {
 private String name;
  
 public String getName() {
  return name;
 }
 
 public void setName(String name) {
  this.name = name;
 }
 
 public Wine(){
 }
  
 public String drink(){
  return "喝的是 " + getName();
 }
  
 /**
  * 重写toString()
  */
 public String toString(){
  return null;
 }
}
 
public class JNC extends Wine{
 public JNC(){
  setName("JNC");
 }
  
 /**
  * 重写父类方法，实现多态
  */
 public String drink(){
  return "喝的是 " + getName();
 }
  
 /**
  * 重写toString()
  */
 public String toString(){
  return "Wine : " + getName();
 }
}
 
public class JGJ extends Wine{
 public JGJ(){
  setName("JGJ");
 }
  
 /**
  * 重写父类方法，实现多态
  */
 public String drink(){
  return "喝的是 " + getName();
 }
  
 /**
  * 重写toString()
  */
 public String toString(){
  return "Wine : " + getName();
 }
}
 
public class Test {
 public static void main(String[] args) {
  //定义父类数组
  Wine[] wines = new Wine[2];
  //定义两个子类
  JNC jnc = new JNC();
  JGJ jgj = new JGJ();
   
  //父类引用子类对象
  wines[0] = jnc;
  wines[1] = jgj;
   
  for(int i = 0 ; i < 2 ; i++){
   System.out.println(wines[i].toString() + "--" + wines[i].drink());
  }
  System.out.println("-------------------------------");
 
 }
}
OUTPUT:
Wine : JNC--喝的是 JNC
Wine : JGJ--喝的是 JGJ
-------------------------------

在上面的代码中JNC、JGJ继承Wine，并且重写了drink() 、toString()方法，程序运行结果是调用子类中方法，输出JNC、JGJ的名称，这就是多态的表现。不同的对象可以执行相同的行为，但是他们都需要通过自己的实现方式来执行，这就要得益于向上转型了。

我们都知道所有的类都继承自超类Object，toString()方法也是Object中方法，当我们这样写时：

Object o = new JGJ();
 
  System.out.println(o.toString());

 输出的结果是Wine : JGJ。

Object、Wine、JGJ三者继承链关系是：JGJ—>Wine—>Object。所以我们可以这样说：当子类重写父类的方法被调用时，只有对象继承链中的最末端的方法才会被调用。

但是注意如果这样写：

Object o = new Wine();
 
System.out.println(o.toString());

输出的结果应该是Null，因为JGJ并不存在于该对象继承链中。

所以基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。

如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

2.2.2、基于接口实现的多态

继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

三、经典实例。

通过上面的讲述，可以说是对多态有了一定的了解。现在趁热打铁，看一个实例。该实例是有关多态的经典例子，摘自：http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx。

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)); 
 }
}

运行结果：

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

在这里看结果1、2、3还好理解，从4开始就开始糊涂了，对于4来说为什么输出不是“B and B”呢？

首先我们先看一句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个概括。其实在继承链中对象方法的调用存在一个优先级：this.show(O) 、super.show(O)、this.show((super)O) 、super.show((super)O) 。

分析：

从上面的程序中我们可以看出A、B、C、D存在如下关系。

먼저 5, a2.show(c)를 분석합니다. a2는 A 유형의 참조 변수이므로 이는 A, a2.show(c)를 나타내며 클래스 A에는 없으므로 A 찾기로 이동합니다. )O의 슈퍼 클래스에 있는 (super)는 B와 A이고, 이것도 A입니다. Show(A obj)는 A에서 발견됩니다. 동시에 a2는 클래스 B의 참조이고 클래스 B는 show(를 재정의하므로) A obj), 서브루틴은 결국 클래스 B의 show(A obj) 메소드가 호출되며 결과는 B와 A입니다.

같은 방법으로 다른 답변도 확인할 수 있습니다.

메서드를 찾았지만 여기서는 여전히 약간의 의심이 듭니다. 슈퍼클래스 객체 참조 변수가 서브클래스 객체를 참조할 때 참조되는 객체의 유형이 아닙니다. 참조 변수는 누구의 멤버 메서드가 호출되는지 결정하지만 호출되는 메서드는 슈퍼 클래스, 즉 하위 클래스에 의해 재정의되는 메서드에 정의되어야 합니다. 이 문장의 의미를 설명하기 위해 예를 들어보겠습니다. a2.show(b)

여기서 a2는 A 유형의 참조 변수입니다. 이는 B 객체를 참조하므로 위의 내용에 따릅니다. 문장이란 말은 B가 어떤 메소드를 호출할지 결정하므로 a2.show(b)는 B에서 show(B obj)를 호출해야 하고 결과는 "B와 B"가 되어야 하는데 이전과 다른 이유는 무엇입니까? ? 실행 결과에 차이가 있나요? 여기서는 "그러나 여기서 호출되는 메서드는 슈퍼 클래스에 정의되어야 합니다"라는 문장을 무시합니다. 그렇다면 show(B obj)가 클래스 A에 존재합니까? 존재하지 않습니다! 그럼 이 문장은 여기에는 적용되지 않는 건가요? 그럼 이 문장은 잘못된 걸까요? 아니요! 사실 이 문장은 이 문장을 암시하기도 합니다. 상속 체인에서 호출 메서드의 우선 순위에 따라 여전히 확인이 필요합니다. 이것이 바로 클래스 A에서 show(A obj)를 찾는 이유입니다. 동시에 B가 이 메서드를 다시 작성했기 때문에 클래스 B의 메서드를 호출하고, 그렇지 않으면 클래스 A의 메서드를 호출합니다.

그래서 다형성 메커니즘이 따르는 원리는 다음과 같이 요약할 수 있습니다. 슈퍼클래스 객체 참조 변수가 서브클래스 객체를 참조할 때 참조 변수의 유형이 아닌 참조된 객체의 유형에 따라 누구의 멤버 메소드가 결정됩니다. 호출되는 메서드는 슈퍼클래스에서 정의되어야 합니다. 즉, 메서드가 하위 클래스에 의해 재정의되지만 상속 체인에서 메서드 호출의 우선순위에 따라 메서드를 확인해야 합니다. 우선순위는 this.show(O) , super.show(O) , this.show((super)O) , super.show((super)O) 입니다.

요약

이 글의 내용이 모두의 공부나 업무에 조금이라도 도움이 되었으면 좋겠습니다. 소통하라는 메시지.

자바의 3대 특징 중 다형성에 대해 좀 더 깊이 있게 이해하고 싶다면 PHP 중국어 홈페이지를 주목해주세요!