Java の 3 つの主要な機能 - カプセル化、継承、およびポリモーフィズム

Java では、オブジェクト指向プログラミングには、カプセル化、継承、ポリモーフィズムという 3 つの主要な機能があります。

まず梱包について話しましょう。

カプセル化は、その名前が示すように、抽象データ型を介してデータとデータベースの操作を結合することです(つまり、ADT、データ型とそのデータ型で可能な操作を結合するために定義された型) それらを独立した「エンティティ」にするために一緒にカプセル化します。

まず、Person クラスを見てみましょう:

 1 public class Person implements Comparable<Person> { 2     
 private String firstname; 3     private String lastname; 4  5     
 public String getFirstname() { 6         return firstname; 7     } 
 public void setFirstname(String firstname) {10         this.firstname = firstname;    }    
 public String getLastname() {14         return lastname;15     }16 17     
 public void setLastname(String lastname) {18         this.lastname = lastname;19     }
  hash = 83 * hash + Objects.hashCode(this.firstname);25         
ride30  
  return true;34         }35         
 //检查参数是否是正确的类型36         if (!(obj 
 on)) {37             
 return false;38         }39         //将参数转换成正确的类型40         
 Person person = (Person) obj;41         //对实体域进行匹配42         
 return Objects.equals(this.firstname, person.firstname)43                 
 && Objects.equals(this.lastname, person.lastname);44     }45 46     
 @Override47     public int compareTo(Person o) {48         
 if (this == o) {49             return 0;50         }         
 if (null == o) {52             return 1;53         }         //先判断姓氏是否相同55         int comparison = this.firstname.compareTo(o.firstname);56         if (comparison != 0) {57             return comparison;58         }59         //姓氏相同则比较名60         comparison = this.lastname.compareTo(o.lastname);61         return comparison;62     }63 }

カプセル化のアイデアについては、可能な限り内部の詳細を隠し、一部の外部操作のみを保持する必要があります。

たとえば、Person クラスでは、2 つのメンバー変数 firstname と lastname を定義しただけです。setter メソッドで、最初の文字を大文字にし、残りを小文字にするなど、名前と姓のいくつかの形式を設定できます。 「フォーマット」。ゲッターを開いて変数の値を取得します。

次に、カプセル化の利点を要約しましょう:

1. メンバー変数をより適切に制御でき、さらにはクラスの内部構造も管理できます。

2. 適切なカプセル化により、結合が軽減され、コードがより堅牢になります。外部プログラムは、実装の詳細に注意を払うことなく、外部インターフェイスを介してそれにアクセスできます。

継承 についてもう一度話しましょう。 継承は、コードを再利用する方法であり、クラスを定義して実装するときに、既存のクラスを拡張できます。独自のコンテンツを追加したり、さまざまなニーズに合わせて元のメソッドを変更したりできます。

2 つの例を見てみましょう:

 1 public class Person { 2  3     private String name; 4     
 private String sex; 5     private int age; 6  7     
 Person(String name, String sex, int age) { 8         
 this.name = name; 9         this.sex = sex;10         
 this.age = age;11     }12 13     //省略setter和getter方法...14  37 }

 1 public class Yang extends Person { 2  3     
 Yang(String name, String sex, int age) { 4         
 super(name, sex, age); 5     } 6  7     
 public String getName() { 8         
 return super.getName() + " is " + "genius"; 9     }
  }

1   public static void main(String... argc) {2 
//        
Yang yang = new Yang("yang", "male", 23);3         
Person person = new Yang("yang", "male", 23);4         
out.print(person.getName());5     }

输出： yang is genius 

注意，如果父类没有默认的构造器，子类构造函数中需要指定父类的构造器，否则编译将会失败！

从上面的代码中不得不引出关于继承的三大重要的东西，即构造器，protected关键字以及向上转型。

我们知道，构造器是不能被继承的，只许被调用！需要注意的是，子类是依赖于父类的（这也说明了一个弊端，即继承是一种强耦合关系），子类拥有父类的非private属性和方法（弊端二：破坏了封装），所以父类应先于子类被创建。

所以当父类没有默认构造器时，子类需要指定一个父类的构造器，并且写于子类构造器的第一行！当然父类有默认构造器，子类就无需super了，Java会自动调用。

再说protected关键字。插一句，只有合理使用访问修饰符，程序才能更好的为我们服务！！

对于子类，为了使用父类的方法，我们可以修改它的访问修饰符为protected，而不是一股脑儿的写上public！一劳永逸的做法可能会带来更大的危害！

而对于类的成员变量，保持它的private！

最后是向上转型了，它是一个重要的方面。从上面的的代码中，我写上了Person person = new Yang("yang", "male", 23); 这样结果是将Yang向上转型为Person，带来的影响可能就是属性和方法的丢失，但是它将是安全的。

同时它最大的作用是.....子类能够提供父类更加强大的功能以适用于不同的场合，完成不同的操作。

不太清楚可以看看这两个： List arrayList = new ArrayList<>(); 和 List linkedList = new LinkedList<>(); 

我们知道ArrayList是数组实现，查找更快；而LinkedList是链表实现，添加元素和删除元素效率更好！

但是向上转型有一个弊端，指向子类的父类引用因为向上转型了，它将只拥有父类的属性和方法，同时子类拥有而父类没有的方法，是无法使用了的！

所以，继承实现了软件的可重用性和可拓展性。但是Java是单继承的，并且继承也有多个弊端（上面有提），其实还有一个弊端是父类一旦改变，子类可能也得进行改变！所以慎用吧。

 

最后一个特性是多态了。多态性就是不同的子类型可以对同一个请求做出不同的操作。同时多态性分为编译时多态性和运行时多态性，对应着方法重载overload和方法重写override！

对于方法重写，存在在继承中。它作为运行时多态性的表现，首先需要子类继承和实现父类的方法，然后向上转型，父类引用子类对象，对同一件事作出不同的响应。

方法重写时，需要注意的是子类的访问修饰符的访问范围不能小于父类，如父类的一个方法修饰符为protected，那么子类继承时，只能选用public或者protected。除了访问修饰符，其余完全相同于父类！

对于方法重载，出现在同一个类中，它是编译时多态性的表现。定义为：同名的方法如果有不同的参数列表便视为重载。

 

最后有一道经典的题目作为结尾，我也不知道出自哪....Look and think!

 1 public class A {   
 public String show(D obj) { 4         
 return ("Father and D"); 5     } 6  7     
 public String show(A obj) { 8         
 return ("Father and Father"); 9     } 
 }
 class B extends A {13 14     
 public String show(B obj) {15         
 return ("Child and Child");    
 }
 public String show(A obj) {19         
 return ("Child and Father");20     }21 } 
 class C extends B {24 }25 26 class D extends B {27 }
 class Test {30     public static void main(String[] args) {31         
 A a1 = new A();32         A a2 = new B();33         
 B b = new B();34         C c = new C();35         
 D d = new D();36 37         
 System.out.println("1--" + a1.show(b));38         
 System.out.println("2--" + a1.show(c));39         
 System.out.println("3--" + a1.show(d));40         
 System.out.println("4--" + a2.show(b));41         
 System.out.println("5--" + a2.show(c));42         
 System.out.println("6--" + a2.show(d));43         
 System.out.println("7--" + b.show(b));44         
 System.out.println("8--" + b.show(c));45         
 System.out.println("9--" + b.show(d));46     } }

以上がJava の 3 つの主要な機能 - カプセル化、継承、およびポリモーフィズムの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。