Java 面向對象的編程 · ZetCode 中文系列教程

# Java 面向對象的編程原文：http://zetcode.com/lang/java/oop/ Java 教程的這一部分是 Java 面向對象編程的簡介。我們提到了 Java 對象，對象屬性和方法，對象構造器以及訪問修飾符。此外，我們討論了`super`關鍵字，構造器鏈接，類常量，繼承，最終類和私有構造器。共有三種廣泛使用的編程示例：過程編程，函數編程和面向對象的編程。 Java 原則上是一種面向對象的編程語言。從 Java8 開始，它對函數式編程提供了一些支持。 ## 面向對象編程面向對象編程（OOP）是一種使用對象及其相互作用設計應用和計算機程序的編程示例。以下是 OOP 中的基本編程概念： * 抽象 * 多態 * 封裝 * 繼承抽象通過建模適合該問題的類來簡化復雜的現實。多態是將運算符或函數以不同方式用于不同數據輸入的過程。封裝對其他對象隱藏了類的實現細節。繼承是一種使用已經定義的類形成新類的方法。 ## Java 對象對象是 Java OOP 程序的基本構建塊。對象是數據和方法的組合。在 OOP 程序中，我們創建對象。這些對象通過方法進行通信。每個對象都可以接收消息，發送消息和處理數據。創建對象有兩個步驟。首先，我們定義一個類。類是對象的模板。它是一個藍圖，描述了類對象共享的狀態和行為。一個類可以用來創建許多對象。在運行時從類創建的對象稱為該特定類的實例。 `SimpleObject.java` ```java package com.zetcode; class Being {} public class SimpleObject { public static void main(String[] args) { Being b = new Being(); System.out.println(b); } } ``` 在第一個示例中，我們創建一個簡單的對象。 ```java class Being {} ``` 這是一個簡單的類定義。模板的主體為空。它沒有任何數據或方法。 ```java Being b = new Being(); ``` 我們創建`Being`類的新實例。為此，我們使用了`new`關鍵字。 `b`變量是創建對象的句柄。 ```java System.out.println(b); ``` 我們將對象打印到控制臺以獲取該對象的一些基本描述。打印對象是什么意思？實際上，當我們打印對象時，我們將其稱為`toString()`方法。但是我們還沒有定義任何方法。這是因為創建的每個對象都繼承自基本`Object`。它具有一些基本功能，可以在所有創建的對象之間共享。其中之一是`toString()`方法。 ```java $ javac com/zetcode/SimpleObject.java $ ls com/zetcode/ Being.class SimpleObject.class SimpleObject.java ``` 編譯器創建兩個類文件。 `SimpleObject.class`是應用類，`Being.class`是我們在應用中使用的自定義類。 ```java $ java com.zetcode.SimpleObject com.zetcode.Being@125ee71 ``` 我們獲得對象是實例的類的名稱，@字符以及對象的哈希碼的無符號十六進制表示形式。 ## Java 對象屬性對象屬性是捆綁在類實例中的數據。對象屬性稱為實例變量或成員字段。實例變量是在類中定義的變量，該類中的每個對象都有一個單獨的副本。 `ObjectAttributes.java` ```java package com.zetcode; class Person { public String name; } public class ObjectAttributes { public static void main(String[] args) { Person p1 = new Person(); p1.name = "Jane"; Person p2 = new Person(); p2.name = "Beky"; System.out.println(p1.name); System.out.println(p2.name); } } ``` 在上面的 Java 代碼中，我們有一個帶有一個成員字段的`Person`類。 ```java class Person { public String name; } ``` 我們聲明一個名稱成員字段。 `public`關鍵字指定可以在類塊之外訪問成員字段。 ```java Person p1 = new Person(); p1.name = "Jane"; ``` 我們創建`Person`類的實例，并將名稱變量設置為`"Jane"`。我們使用點運算符來訪問對象的屬性。 ```java Person p2 = new Person(); p2.name = "Beky"; ``` 我們創建`Person`類的另一個實例。在這里，我們將變量設置為`"Beky"`。 ```java System.out.println(p1.name); System.out.println(p2.name); ``` 我們將變量的內容打印到控制臺。 ```java $ java com.zetcode.ObjectAttributes Jane Beky ``` 我們看到了程序的輸出。 `Person`類的每個實例都有一個單獨的名稱成員字段副本。 ## Java 方法方法是在類主體內定義的函數。它們用于通過對象的屬性執行操作。方法將模塊化帶入我們的程序。在 OOP 范式的封裝概念中，方法至關重要。例如，我們的`AccessDatabase`類中可能有一個`connect()`方法。我們無需知道方法`connect()`如何精確地連接到數據庫。我們只需要知道它用于連接數據庫。這對于劃分編程中的職責至關重要，尤其是在大型應用中。對象組的狀態和行為。方法代表對象的行為部分。 `Methods.java` ```java package com.zetcode; class Circle { private int radius; public void setRadius(int radius) { this.radius = radius; } public double area() { return this.radius * this.radius * Math.PI; } } public class Methods { public static void main(String[] args) { Circle c = new Circle(); c.setRadius(5); System.out.println(c.area()); } } ``` 在代碼示例中，我們有一個`Circle`類。在該類中，我們定義了兩個方法。 `setRadius()`方法為`radius`成員分配一個值，`area()`方法根據類成員和常數計算圓的面積。 ```java private int radius; ``` 我們的類只有一個成員字段。它是圓的半徑。 `private`關鍵字是訪問說明符。它表明變量僅限于外部世界。如果要從外部修改此變量，則必須使用公共可用的`setRadius()`方法。這樣我們可以保護我們的數據。 ```java public void setRadius(int radius) { this.radius = radius; } ``` 這是`setRadius()`方法。 `this`變量是一個特殊變量，我們用它來訪問方法中的成員字段。 `this.radius`是實例變量，而`radius`是局部變量，僅在`setRadius()`方法內部有效。 ```java Circle c = new Circle(); c.setRadius(5); ``` 我們創建`Circle`類的實例，并通過在圓對象上調用`setRadius()`方法來設置其半徑。點運算符用于調用該方法。 ```java public double area() { return this.radius * this.radius * Math.PI; } ``` `area()`方法返回圓的面積。 `Math.PI`是內置常數。 ```java $ java com.zetcode.Methods 78.53981633974483 ``` 運行示例，我們得到上面的輸出。 ## Java 訪問修飾符訪問修飾符設置方法和成員字段的可見性。 Java 具有三個訪問修飾符：`public`，`protected`和`private`。可以從任何地方訪問`public`成員。 `protected`成員只能在類本身內，被繼承的類以及同一包中的其他類訪問。最后，`private`成員僅限于包含類型，例如僅在其類或接口內。如果不指定訪問修飾符，則將具有包專用的可見性。在這種情況下，成員和方法可在同一包中訪問。訪問修飾符可防止意外修改數據。它們使程序更強大。 | | 類 | 包 | 子類（相同的包） | 子類（其他包） | 全局 | | --- | --- | --- | --- | --- | --- | | `public` | `+` | `+` | `+` | `+` | `+` | | `protected` | `+` | `+` | `+` | `+` | `o` | | 沒有修飾符 | `+` | `+` | `+` | `o` | `o` | | `private` | `+` | `o` | `o` | `o` | `o` | 上表總結了 Java 訪問修飾符（`+`是可訪問的，`o`是不可訪問的）。 `AccessModifiers.java` ```java package com.zetcode; class Person { public String name; private int age; public int getAge() { return this.age; } public void setAge(int age) { this.age = age; } } public class AccessModifiers { public static void main(String[] args) { Person p = new Person(); p.name = "Jane"; p.setAge(17); System.out.println(String.format("%s is %d years old", p.name, p.getAge())); } } ``` 在上面的程序中，我們有兩個成員字段：`public`和`private`。 ```java public int getAge() { return this.age; } ``` 如果成員字段是私有的，則訪問它的唯一方法是通過方法。如果要在類外部修改屬性，則必須將方法聲明為`public`。這是數據保護的重要方面。 ```java public void setAge(int age) { this.age = age; } ``` `setAge()`方法使我們能夠從類定義之外更改私有`age`變量。 ```java Person p = new Person(); p.name = "Jane"; ``` 我們創建`Person`類的新實例。因為`name`屬性是`public`，所以我們可以直接訪問它。但是，不建議這樣做。 ```java p.setAge(17); ``` `setAge()`方法修改`age`成員字段。由于已聲明`private`，因此無法直接訪問或修改。 ```java System.out.println(String.format("%s is %d years old", p.name, p.getAge())); ``` 最后，我們訪問兩個成員以構建一個字符串，該字符串將打印到控制臺。 ```java $ java com.zetcode.AccessModifiers Jane is 17 years old ``` 運行示例，我們將獲得以下輸出。以下程序顯示訪問修飾符如何影響子類繼承成員的方式。 `ProtectedMember.java` ```java package com.zetcode; class Base { public String name = "Base"; protected int id = 5323; private boolean isDefined = true; } class Derived extends Base { public void info() { System.out.println("This is Derived class"); System.out.println("Members inherited:"); System.out.println(this.name); System.out.println(this.id); // System.out.println(this.isDefined); } } public class ProtectedMember { public static void main(String[] args) { Derived drv = new Derived(); drv.info(); } } ``` 在此程序中，我們有一個`Derived`類，該類繼承自`Base`類。 `Base`類具有三個成員字段，所有成員字段均具有不同的訪問修飾符。 `isDefined`成員未繼承。 `private`修飾符可以防止這種情況。 ```java class Derived extends Base { ``` `Derived`類繼承自`Base`類。要從另一個類繼承，我們使用`extends`關鍵字。 ```java System.out.println(this.name); System.out.println(this.id); // System.out.println(this.isDefined); ``` `public`和`protected`成員由`Derived`類繼承。可以訪問它們。 `private`成員未繼承。訪問成員字段的行被注釋。如果我們取消注釋該行，則代碼將無法編譯。 ```java $ java com.zetcode.ProtectedMember This is Derived class Members inherited: Base 5323 ``` 運行程序，我們收到此輸出。 ## Java 構造器構造器是一種特殊的方法。創建對象時會自動調用它。構造器不返回值，也不使用`void`關鍵字。構造器的目的是初始化對象的狀態。構造器與類具有相同的名稱。構造器是方法，因此它們也可以重載。構造器不能直接調用。 `new`關鍵字調用它們。構造器不能聲明為同步，最終，抽象，本地或靜態。構造器不能被繼承。它們按繼承順序被調用。如果我們不為類編寫任何構造器，則 Java 提供隱式默認構造器。如果提供任何類型的構造器，則不提供默認值。 `Constructor.java` ```java package com.zetcode; class Being { public Being() { System.out.println("Being is created"); } public Being(String being) { System.out.println(String.format("Being %s is created", being)); } } public class Constructor { @SuppressWarnings("ResultOfObjectAllocationIgnored") public static void main(String[] args) { new Being(); new Being("Tom"); } } ``` 我們有一個存在類。此類具有兩個構造器。第一個不帶參數，第二個不帶參數。 ```java public Being() { System.out.println("Being is created"); } ``` 該構造器不接受任何參數。 ```java public Being(String being) { System.out.println(String.format("Being %s is created", being)); } ``` 此構造器采用一個字符串參數。 ```java @SuppressWarnings("ResultOfObjectAllocationIgnored") ``` 此注釋將禁止警告我們不要將創建的對象分配給任何變量。通常，這將是可疑的活動。 ```java new Being(); ``` 創建`Being`類的實例。創建對象時將調用無參數構造器。 ```java new Being("Tom"); ``` 創建`Being`類的另一個實例。這次，在創建對象時調用帶有參數的構造器。 ```java $ java com.zetcode.Constructor Being is created Being Tom is created ``` 這是程序的輸出。在下一個示例中，我們初始化類的數據成員。變量的初始化是構造器的典型工作。 `MemberInit.java` ```java package com.zetcode; import java.util.Calendar; import java.util.GregorianCalendar; class MyFriend { private GregorianCalendar born; private String name; public MyFriend(String name, GregorianCalendar born) { this.name = name; this.born = born; } public void info() { System.out.format("%s was born on %s/%s/%s\n", this.name, this.born.get(Calendar.DATE), this.born.get(Calendar.MONTH), this.born.get(Calendar.YEAR)); } } public class MemberInit { public static void main(String[] args) { String name = "Lenka"; GregorianCalendar born = new GregorianCalendar(1990, 3, 5); MyFriend fr = new MyFriend(name, born); fr.info(); } } ``` 我們有一個帶有數據成員和方法的`MyFriend`類。 ```java private GregorianCalendar born; private String name; ``` 類定義中有兩個私有變量。 ```java public MyFriend(String name, GregorianCalendar born) { this.name = name; this.born = born; } ``` 在構造器中，我們啟動兩個數據成員。 `this`變量是一個處理器，用于從方法中引用對象變量。如果構造器參數的名稱與成員的名稱相等，則需要使用`this`關鍵字。否則，用法是可選的。 ```java MyFriend fr = new MyFriend(name, born); fr.info(); ``` 我們創建帶有兩個參數的`MyFriend`對象。然后我們調用對象的`info()`方法。 ```java $ java com.zetcode.MemberInit Lenka was born on 5/3/1990 ``` 這是`com.zetcode.MemberInit`程序的輸出。 ## Java `super`關鍵字 `super`關鍵字是在子類中用于引用直接父類對象的引用變量。它可以用來引用父對象的 a）實例變量，b）構造器，c）方法。 `SuperVariable.java` ```java package com.zetcode; class Shape { int x = 50; int y = 50; } class Rectangle extends Shape { int x = 100; int y = 100; public void info() { System.out.println(x); System.out.println(super.x); } } public class SuperVariable { public static void main(String[] args) { Rectangle r = new Rectangle(); r.info(); } } ``` 在示例中，我們使用`super`關鍵字引用了父變量。 ```java public void info() { System.out.println(x); System.out.println(super.x); } ``` 在`info()`方法內部，我們使用`super.x`語法引用父級的實例變量。如果構造器未顯式調用超類構造器，則 Java 將自動插入對超類的無參數構造器的調用。如果超類沒有無參數構造器，則會得到編譯時錯誤。 `ImplicitSuper.java` ```java package com.zetcode; class Vehicle { public Vehicle() { System.out.println("Vehicle created"); } } class Bike extends Vehicle { public Bike() { // super(); System.out.println("Bike created"); } } public class ImplicitSuper { public static void main(String[] args) { Bike bike = new Bike(); System.out.println(bike); } } ``` 該示例演示了對父級構造器的隱式調用。 ```java public Bike() { // super(); System.out.println("Bike created"); } ``` 如果我們取消注釋該行，則會得到相同的結果。 ```java $ java com.zetcode.ImplicitSuper Vehicle created Bike created com.zetcode.Bike@15db9742 ``` 創建`Bike`對象時，將調用兩個構造器。一個類中可以有多個構造器。 `SuperCalls.java` ```java package com.zetcode; class Vehicle { protected double price; public Vehicle() { System.out.println("Vehicle created"); } public Vehicle(double price) { this.price = price; System.out.printf("Vehicle created, price %.2f set%n", price); } } class Bike extends Vehicle { public Bike() { super(); System.out.println("Bike created"); } public Bike(double price) { super(price); System.out.printf("Bike created, its price is: %.2f %n", price); } } public class SuperCalls { public static void main(String[] args) { Bike bike1 = new Bike(); Bike bike2 = new Bike(45.90); } } ``` 該示例使用`super`的不同語法來調用不同的父構造器。 ```java super(); ``` 在這里，我們稱為父級的無參數構造器。 ```java super(price); ``` 此語法調用具有一個參數的父級構造器：自行車的價格。 ```java $ java com.zetcode.SuperCalls Vehicle created Bike created Vehicle created, price 45.90 set Bike created, its price is: 45.90 ``` 這是示例輸出。 ## Java 構造器鏈接構造器鏈接是從構造器調用另一個構造器的能力。要從同一類調用另一個構造器，我們使用`this`關鍵字。要從父類中調用另一個構造器，我們使用`super`關鍵字。 `ConstructorChaining.java` ```java package com.zetcode; class Shape { private int x; private int y; public Shape(int x, int y) { this.x = x; this.y = y; } protected int getX() { return this.x; } protected int getY() { return this.y; } } class Circle extends Shape { private int r; public Circle(int r, int x, int y) { super(x, y); this.r = r; } public Circle() { this(1, 1, 1); } @Override public String toString() { return String.format("Circle: r:%d, x:%d, y:%d", r, getX(), getY()); } } public class ConstructorChaining { public static void main(String[] args) { Circle c1 = new Circle(5, 10, 10); Circle c2 = new Circle(); System.out.println(c1); System.out.println(c2); } } ``` 我們有一個`Circle`類。該類具有兩個構造器。一種采用一個參數，一種不采用任何參數。 ```java class Shape { private int x; private int y; ... } ``` `Shape`類負責處理各種形狀的`x`和`y`坐標。 ```java public Shape(int x, int y) { this.x = x; this.y = y; } ``` `Shape`類的構造器使用給定的參數啟動`x`和`y`坐標。 ```java protected int getX() { return this.x; } protected int getY() { return this.y; } ``` 我們定義了兩種方法來檢索坐標值。成員是私有的，因此唯一可能的訪問是通過方法。 ```java class Circle extends Shape { private int r; ... } ``` `Circle`類繼承自`Shape`類。它定義了特定于此形狀的`radius`成員。 ```java public Circle(int r, int x, int y) { super(x, y); this.r = r; } ``` `Circle`類的第一個構造器采用三個參數：`radius`以及`x`和`y`坐標。使用`super`關鍵字，我們調用傳遞坐標的父級構造器。請注意，`super`關鍵字必須是構造器中的第一條語句。第二條語句啟動`Circle`類的`radius`成員。 ```java public Circle() { this(1, 1, 1); } ``` 第二個構造器不帶參數。在這種情況下，我們提供一些默認值。 `this`關鍵字用于調用同一類的三參數構造器，并傳遞三個默認值。 ```java @Override public String toString() { return String.format("Circle: r:%d, x:%d, y:%d", r, getX(), getY()); } ``` 在`toString()`方法內部，我們提供`Circle`類的字符串表示形式。要確定`x`和`y`坐標，我們使用繼承的`getX()`和`getY()`方法。 ```java $ java com.zetcode.ConstructorChaining Circle: r:5, x:10, y:10 Circle: r:1, x:1, y:1 ``` 這是示例的輸出。 ## Java 類常量可以創建類常量。這些常量不屬于具體對象。他們屬于類。按照約定，常量用大寫字母表示。 `ClassConstant.java` ```java package com.zetcode; class Math { public static final double PI = 3.14159265359; } public class ClassConstant { public static void main(String[] args) { System.out.println(Math.PI); } } ``` 我們有一個帶有`PI`常量的`Math`類。 ```java public static final double PI = 3.14159265359; ``` `final`關鍵字用于定義常數。使用`static`關鍵字可以引用成員而無需創建類的實例。 `public`關鍵字使它可以在類的主體之外訪問。 ```java $ java com.zetcode.ClassConstant 3.14159265359 ``` Running the example we get the above output. ## Java `toString`方法每個對象都有`toString()`方法。它返回人類可讀的對象表示形式。默認實現返回`Object`類型的標準名稱。當我們以對象作為參數調用`System.out.println()`方法時，將調用`toString()`。 `ThetoStringMethod.java` ```java package com.zetcode; class Being { @Override public String toString() { return "This is Being class"; } } public class ThetoStringMethod { public static void main(String[] args) { Being b = new Being(); Object o = new Object(); System.out.println(o.toString()); System.out.println(b.toString()); System.out.println(b); } } ``` 我們有一個`Being`類，其中我們重寫了`toString()`方法的默認實現。 ```java @Override public String toString() { return "This is Being class"; } ``` 創建的每個類都從基`Object`繼承。 `toString()`方法屬于此對象類。 `@Override`注解通知編譯器該元素旨在替代超類中聲明的元素。然后，編譯器將檢查我們是否未創建任何錯誤。 ```java Being b = new Being(); Object o = new Object(); ``` 我們創建兩個對象：一個自定義對象和一個內置對象。 ```java System.out.println(o.toString()); System.out.println(b.toString()); ``` 我們在這兩個對象上顯式調用`toString()`方法。 ```java System.out.println(b); ``` 正如我們之前指定的，將對象作為`System.out.println()`的參數將調用其`toString()`方法。這次，我們隱式調用了該方法。 ```java $ java com.zetcode.ThetoStringMethod java.lang.Object@125ee71 This is Being class This is Being class ``` 這是我們運行示例時得到的。 ## Java 中的繼承繼承是一種使用已經定義的類形成新類的方法。新形成的類稱為派生的類，我們從中衍生的類稱為基類。繼承的重要好處是代碼重用和降低程序的復雜性。派生類（后代）將覆蓋或擴展基類（祖先）的功能。 `Inheritance.java` ```java package com.zetcode; class Being { public Being() { System.out.println("Being is created"); } } class Human extends Being { public Human() { System.out.println("Human is created"); } } public class Inheritance { @SuppressWarnings("ResultOfObjectAllocationIgnored") public static void main(String[] args) { new Human(); } } ``` 在此程序中，我們有兩個類：基礎`Being`類和派生的`Human`類。派生類繼承自基類。 ```java class Human extends Being { ``` 在 Java 中，我們使用`extends`關鍵字創建繼承關系。 ```java new Human(); ``` 我們實例化派生的`Human`類。 ```java $ java com.zetcode.Inheritance Being is created Human is created ``` 我們可以看到兩個構造器都被調用了。首先，調用基類的構造器，然后調用派生類的構造器。接下來是一個更復雜的示例。 `Inheritance2.java` ```java package com.zetcode; class Being { static int count = 0; public Being() { count++; System.out.println("Being is created"); } public void getCount() { System.out.format("There are %d Beings%n", count); } } class Human extends Being { public Human() { System.out.println("Human is created"); } } class Animal extends Being { public Animal() { System.out.println("Animal is created"); } } class Dog extends Animal { public Dog() { System.out.println("Dog is created"); } } public class Inheritance2 { @SuppressWarnings("ResultOfObjectAllocationIgnored") public static void main(String[] args) { new Human(); Dog dog = new Dog(); dog.getCount(); } } ``` 對于四個類，繼承層次結構更加復雜。 `Human`和`Animal`類繼承自`Being`類，`Dog`類直接繼承自`Animal`類，間接繼承自`Being`類。 ```java static int count = 0; ``` 我們定義一個`static`變量。靜態成員由類的所有實例共享。 ```java public Being() { count++; System.out.println("Being is created"); } ``` 每次實例化`Being`類時，我們將`count`變量增加一。這樣，我們就可以跟蹤創建的實例數。 ```java class Animal extends Being { ... class Dog extends Animal { ... ``` `Animal`繼承自`Being`，`Dog`繼承自`Animal`。 `Dog`也間接繼承自`Being`。 ```java new Human(); Dog dog = new Dog(); dog.getCount(); ``` 我們從`Human`和`Dog`類創建實例。我們稱為`Dog`對象的`getCount()`方法。 ```java $ java com.zetcode.Inheritance2 Being is created Human is created Being is created Animal is created Dog is created There are 2 Beings ``` `Human`對象調用兩個構造器。 `Dog`對象調用三個構造器。有兩個實例化的`Beings`。 ## `final`類，`private`構造器帶有`final`修飾符的類不能被子類化。帶有帶有`private`修飾符的構造器的類無法實例化。 `FinalClass.java` ```java package com.zetcode; final class MyMath { public static final double PI = 3.14159265358979323846; // other static members and methods } public class FinalClass { public static void main(String[] args) { System.out.println(MyMath.PI); } } ``` 我們有一個`MyMath`類。此類具有一些靜態成員和方法。我們不希望任何人從我們的類繼承；因此，我們將其聲明為`final`。此外，我們也不想允許從我們的類中創建實例。我們決定僅在靜態上下文中使用它。聲明一個私有構造器，該類無法實例化。 `MyMath.java` ```java package com.zetcode; final class MyMath { private MyMath() {} public static final double PI = 3.14159265358979323846; // other static members and methods } public class PrivateConstructor { public static void main(String[] args) { System.out.println(MyMath.PI); } } ``` 我們的`MyMath`類無法實例化，也不能被子類化。這就是`java.lang.Math`用 Java 語言設計的方式。這是 Java 中 OOP 描述的第一部分。