9.1面向物件程式設計的基本概念

1、面向物件程式設計（Object-oriented programming, OOP) 是以物件為基本單位來搭建程式的程式設計方法。術語物件（object）指的是實體（entity），例如學生，桌子，圓，按鈕。

2、物件具有唯一的標識，狀態和行為。物件狀態由一組資料域data fields（或屬性properties）構成，物件的行為behavior則是由一組方法構成。

3、類建立物件，物件的資料域和方法由類定義

9.2類

1、Java用class來定義物件的概念，是同類型物件的總稱。它本身不是實體，只是一個籠統的概念。例如學生這個概念，只有具體到某一個學生上，才能稱為實體。

2、Java使用成員變數來定義物件的資料域，使用成員方法來定義物件的行為。

3、此外，Java的類還提供了一些特殊的方法，稱為構造方法，用來建立具體的物件實體。

9.3圓物件的Java程式設計實現

 

9.4用Unified Modeling Language (UML)表示Circle類

UML是一種面向物件的建模語言，它運用統一的、標準化的標記和定義實現對軟體系統進行面向物件的描述和建模。

 

9.5 Example: Defining Classes and Creating Objects

學習目標：如何建立一個物件，訪問物件的資料，使用物件的方法。

LISTING 9.1

TestSimpleCircle.java

 public class TestSimpleCircle {
	 /** Main method */
	 public static void main(String[] args) {
		 // Create a circle with radius 1
		 SimpleCircle circle1 = new SimpleCircle();
		 System.out.println("The area of the circle of radius "
			 + circle1.radius + " is " + circle1.getArea());

		 // Create a circle with radius 25
		 SimpleCircle circle2 = new SimpleCircle(25);
		 System.out.println("The area of the circle of radius "
			 + circle2.radius + " is " + circle2.getArea());

		 // Create a circle with radius 125
		 SimpleCircle circle3 = new SimpleCircle(125);
		 System.out.println("The area of the circle of radius "
			 + circle3.radius + " is " + circle3.getArea());

		 // Modify circle radius
		 circle2.radius = 100; // or circle2.setRadius(100)
		 System.out.println("The area of the circle of radius "
			 + circle2.radius + " is " + circle2.getArea());
	 }
}

 // Define the circle class with two constructors
 class SimpleCircle {
	 double radius;

	 /** Construct a circle with radius 1 */
	 SimpleCircle() {
		 radius = 1;
	 }

	 /** Construct a circle with a specified radius */
	 SimpleCircle(double newRadius) {
		 radius = newRadius;
	 }

	 /** Return the area of this circle */
	 double getArea() {
		 return radius * radius * Math.PI;
	 }

	 /** Return the perimeter of this circle */
	 double getPerimeter() {
		 return 2 * radius * Math.PI;
	 }

	 /** Set a new radius for this circle */
	 void setRadius(double newRadius) {
		 radius = newRadius;
	 }
}
 

程式編譯後的結果是：

 

程式的執行結果是：

 

幾點說明：

1、Java可以在一個原始檔中放置多個類，例如上述例子就有兩個類。但是隻能有一個類是public修飾的，這個類叫主類，main函式總是被放在這個類中。

2、TestSimpleCircle類是一個測試類，它的的功能是用於測試SimpleCircle類，所以它本身除了main函式之外，沒有再定義自己的成員變數和方法。

3、其實一個類也可以自己帶一個main函式來測試自己，例如改寫上一個例子為：

LISTING 9.2 SimpleCircle.java

 public class SimpleCircle {
	 /** Main method */
	 public static void main(String[] args) {
		 // Create a circle with radius 1
		 SimpleCircle circle1 = new SimpleCircle();
		 System.out.println("The area of the circle of radius "
			 + circle1.radius + " is " + circle1.getArea());

		 // Create a circle with radius 25
		 SimpleCircle circle2 = new SimpleCircle(25);
		 System.out.println("The area of the circle of radius "
			 + circle2.radius + " is " + circle2.getArea());

		 // Create a circle with radius 125
		 SimpleCircle circle3 = new SimpleCircle(125);
		 System.out.println("The area of the circle of radius "
			 + circle3.radius + " is " + circle3.getArea());

		 // Modify circle radius
		 circle2.radius = 100;
		 System.out.println("The area of the circle of radius "
			 + circle2.radius + " is " + circle2.getArea());
	 }

	 double radius;

	 /** Construct a circle with radius 1 */
	 SimpleCircle() {
		 radius = 1;
	 }

	 /** Construct a circle with a specified radius */
	 SimpleCircle(double newRadius) {
		 radius = newRadius;
	 }

	 /** Return the area of this circle */
	 double getArea() {
		 return radius * radius * Math.PI;
	 }

	 /** Return the perimeter of this circle */
	 double getPerimeter() {
		 return 2 * radius * Math.PI;
	 }

	 /** Set a new radius for this circle */
	 void setRadius(double newRadius) {
		 radius = newRadius;
	 }
}

9.6 幾個要點複習

1、建立一個物件，用new關鍵字，例如：

SimpleCircle circle1 = new SimpleCircle();

SimpleCircle circle2 = new SimpleCircle(25);

2、建立物件之後，可以使用.訪問物件成員和物件方法，例如：

circle1.radius

circle2.getArea()

3、物件必須先建立後使用，沒有經過new的物件是空物件null，無法使用。

9.7 再來個例子鞏固一下

下面是一個電視類的UML圖： +表示為public型

 

LISTING 9.3 TV.java

 public class TV {
	 int channel = 1; // Default channel is 1
	 int volumeLevel = 1; // Default volume level is 1
	 boolean on = false; // TV is off

	 public TV() {
	 }

	 public void turnOn() {
		 on = true;
	 }

	 public void turnOff() {
		 on = false;
	 }

	 public void setChannel(int newChannel) {
		 if (on && newChannel >= 1 && newChannel <= 120)
			 channel = newChannel;
	 }

	 public void setVolume(int newVolumeLevel) {
		 if (on && newVolumeLevel >= 1 && newVolumeLevel <= 7)
			 volumeLevel = newVolumeLevel;
	 }

	 public void channelUp() {
		 if (on && channel < 120)
			 channel++;
	 }

	 public void channelDown() {
		 if (on && channel > 1)
			 channel—–;
	 }

	 public void volumeUp() {
		 if (on && volumeLevel < 7)
			 volumeLevel++;
	 }

	 public void volumeDown() {
		 if (on && volumeLevel > 1)
			 volumeLevel—–;
	 }
}

 public class TestTV {
	 public static void main(String[] args) {
		 TV tv1 = new TV();
		 tv1.turnOn();
		 tv1.setChannel(30);
		 tv1.setVolume(3);

		 TV tv2 = new TV();
		 tv2.turnOn();
		 tv2.channelUp();
		 tv2.channelUp();
		 tv2.volumeUp();

		 System.out.println("tv1's channel is " + tv1.channel + " and volume level is " + tv1.volumeLevel);
		 System.out.println("tv2's channel is " + tv2.channel + " and volume level is " + tv2.volumeLevel);
	 }
}

9.8 構造方法

構造方法是一種特殊的方法，當物件被建立的時候，構造方法會被自動呼叫。

Circle() {

}

Circle(double newRadius) {  

  radius = newRadius;

}

9.8.1 構造方法的寫法

1、構造方法的名字必須和類的名字完全相同，包括大小寫。

2、構造方法不能有返回型別，甚至連void都不能寫，所以不可能出現return語句。

3、構造方法會在new的時候被自動呼叫，所以它特別適合用來做物件初始化之類的工作。

4、構造方法經常被過載，所以new的時候可以利用傳入的引數，呼叫不同的構造方法。

5、利用構造方法建立物件new ClassName();

例如：

new Circle();

new Circle(5.0);

9.8.2 預設構造方法

如果一個類沒有顯式定義任何構造方法，Java會隱含定義一個沒有形參，方法體為空的構造方法。這個方法稱為預設構造方法。例如下面這個類，框出來的部分，如果你不寫，Java也會預設偷偷補上（當然不會改動到原始碼）：

class Circle {

  Circle() {

  }

}

9.9 物件引用的變數宣告

為了引用一個物件，必須將物件賦值給一個引用變數。宣告一個物件的引用很簡單，語法如下：

ClassName objectRefVar;

例如：Circle myCircle;

這個用法其實和以前的變數宣告沒有區別，例如以前是這樣宣告一個整型變數：int i;

只不過當變數型別變為物件之後，我們把這樣的變數叫做引用變數，以和普通變數相區別。

9.10 宣告並建立物件

ClassName objectRefVar = new ClassName();

 

9.10.1 訪問物件

訪問物件的資料：

        objectRefVar.data例如：myCircle.radius

呼叫物件的方法：

       objectRefVar.methodName(arguments)例如：myCircle.getArea()

9.10.2 注意

我們一直都是這樣呼叫數學庫的方法：

Math.methodName(arguments) (如, Math.pow(3, 2.5))

那麼，能否直接使用Circle1.getArea() 來呼叫 getArea() 方法？

答案是：不行。原因在於，在本章之前，我們定義的所有方法，前面都有一個修飾詞static，這就是所謂的靜態方法。顯然這裡的 getArea() 是一個非靜態的方法，所以只能通過物件的引用來呼叫：          objectRefVar.methodName(arguments) (如, myCircle.getArea())

9.11 資料域

1、資料域也可以是引用型別，例如，下面這個Student 類就包含一個name 的成員，它是String 型別。

2、String其實是一個類，所以name在這裡的確切表述，是一個引用變數，當然你簡單把它看成變數也行。

3、所以，可以看出類的成員是沒什麼限制的，可以是普通變數，也可以是某個類的引用，甚至是它自己的引用。

 

9.11.1 資料域的預設值

資料域都有預設值，引用型別的預設值是null，數值型別的預設值為0，布林型別預設值為false，字元型別預設值為'\u0000'。

作為對比，Java對於區域性變數或者臨時變數都沒有預設值，所以這些變數在被賦值之前都是隨機值，關鍵是不能用。

9.12.1 基本資料型別的變數和引用型別的變數

9.12.2 基本資料型別的變數和引用型別的變數，執行=時的行為不同

9.13 垃圾回收

執行c1 = c2 之後, c1 和c2指向（或者說引用）了同一個物件。這個操作導致原先c1指向的那個物件沒有被引用（即，再沒有變數指向它），這時候這個物件已經無法使用，成為垃圾（ garbage ）。這些垃圾會佔用掉一定的記憶體，不過它們會被JVM自動回收，所以不需要你做額外的處理。

小提示:如果你確定不再需要一個物件，並且想要清掉這個物件所佔用的記憶體空間，你可以簡單的用null給引用這個物件的變數賦值，這樣JVM就知道這個物件需要被回收。

9.14 日期類Date

Java提供了一個處理日期和時間的日期類java.util.Date 。下面是這個類的UML圖。

一個例子:

要列印當前時間，可以用下面的程式碼：

java.util.Date date = new java.util.Date();

System.out.println(date.toString());

輸出的格式類似這樣：
Mon May 27 17:55:46 CST 2016

9.15 隨機數類Random

除了Math.random()，Java還提供了一個隨機數生成類java.util.Random 。下面是這個類的UML圖。

 

9.15.1 相同的種子點，將會生成相同的隨機序列

Random random1 = new Random(3);

System.out.print("From random1: ");

for (int i = 0; i < 10; i++)

  System.out.print(random1.nextInt(1000) + " ");

Random random2 = new Random(3);

System.out.print("\nFrom random2: ");

for (int i = 0; i < 10; i++)

  System.out.print(random2.nextInt(1000) + " ");

 

9.16 2D座標類Point2D

javafx.geometry.Point2D類，用來表示平面上的一個點(x, y) 。下面是這個類的UML圖。

 

LISTING 9.5 TestPoint2D.java

 import java.util.Scanner;
 import javafx.geometry.Point2D;

 public class TestPoint2D {
	 public static void main(String[] args) {
		 Scanner input = new Scanner(System.in);

		 System.out.print("Enter point1's x-, y-coordinates: ");
		 double x1 = input.nextDouble();
		 double y1 = input.nextDouble();
		 System.out.print("Enter point2's x-, y-coordinates: ");
		 double x2 = input.nextDouble();
		 double y2 = input.nextDouble();

		 Point2D p1 = new Point2D(x1, y1);
		 Point2D p2 = new Point2D(x2, y2);
		 System.out.println("p1 is " + p1.toString());
		 System.out.println("p2 is " + p2.toString());
		 System.out.println("The distance between p1 and p2 is " +
		 p1.distance(p2));
	 }
}

9.17 例項變數和方法

1、例項變數屬於某個特定的例項。不同例項的例項變數毫無關聯。例如：

Circle c1 = new Circle(); Circle c2 = new Circle(5);

2、這兩個圓的radius是例項變數，因此各自的半徑是獨立的。c1和c2的半徑毫無關聯。3、例項方法需要藉助某個類的例項才能被呼叫。

4、什麼是例項變數和例項方法？答案很簡單，類的成員中，凡是沒有用static修飾的都算。

9.17.1 靜態變數，常量和方法

1、靜態變數和靜態常量，是所有同一個類的例項共享的。2、靜態方法沒有繫結在某個特定物件上。也就是說，它也是所有例項共享的。

3、如何區分成員是否是靜態的？答案是，用static修飾的就是。

靜態變數，常量和方法圖示

UML圖例說明：有下劃線的成員表示靜態成員。可以看出， numberOfObjects是多個例項共享的，radius是獨立的。

9.17.2 例項變數的例子

public class CircleWithStaticMembers {
  double radius;
  static int numberOfObjects = 0;

  CircleWithStaticMembers() {
    radius = 1;
    numberOfObjects++;
  }
  CircleWithStaticMembers(double newRadius) {
    radius = newRadius;
    numberOfObjects++;
  }

  static int getNumberOfObjects() {
    return numberOfObjects;
  }
  double getArea() {
    return radius * radius * Math.PI;
  }
}
public class TestCircleWithStaticMembers {
	public static void main(String[] args) {
		System.out.println("Before creating objects");
		System.out.println("The number of Circle objects is " +CircleWithStaticMembers.numberOfObjects);
		ircleWithStaticMembers c1 = new CircleWithStaticMembers();
		System.out.println("\nAfter creating c1");
		System.out.println("c1: radius (" + c1.radius +") and number of Circle objects (" +c1.numberOfObjects+ ")");
		CircleWithStaticMembers c2 = new CircleWithStaticMembers(5);
		c1.radius = 9;
		System.out.println("\nAfter creating c2 and modifying c1");
		System.out.println("c1: radius (" + c1.radius +") and number of Circle objects (" +c1.numberOfObjects + ")");
		System.out.println("c2: radius (" + c2.radius +") and number of Circle objects (" +c2.numberOfObjects+ ")");
	}
}

執行結果：

 

上述程式的結果說明，靜態成員是共享的，其餘成員則是獨立的。

9.18 包（package）

1、包的作用類似於C的函式庫，但是C的函式庫很容易出現重名的問題，包在一定程度上解決了這個問題。

2、一個包通常包含很多個功能相近的類。

9.18.1建立自己的包

package 包名;//此句必須是原始檔的第一條語句

例如：

package com.example.graphics;

package oop;

一個Java原始檔必定屬於某個包。如果你沒有使用package語句，這個原始檔的所有類，會被自動歸入一個匿名包。

9.18.2包的目錄對映

1、包名和目錄名有一個對映規則，所以原始碼必須存放在指定位置才行。假設Rectangle.java程式碼第一行是：

package com.example.graphics;

2、那麼Rectangle.java的存放目錄必須是：

....\com\example\graphics\Rectangle.java

3、前面….可以是任意目錄，因為package只規定了相對目錄，因此只要保持\com\example\graphics\結構就行。

9.18.3包的編譯、執行

1、假設原始碼Test.java的第一行是：package oop; 此時，Test.java必須存放在oop目錄下。

2、編譯這個檔案，可以在oop的同一級目錄執行：

javac oop/Test.java

3、順利的話，oop目錄下會有Test.class生成。當然，也可以在oop目錄下執行javac Test.java

執行這個程式，一定要在oop的同一級目錄執行（否則會出現錯誤: 找不到或無法載入主類）：

java oop.Test

4、友情提醒：使用IDE開發，不需要考慮上述問題

9.18.4包的命名

1、Java建議包的名字取成域名的逆序，例如cn.edu.xmu，這是為了避免命名重複。

2、包之間沒有巢狀關係，例如java.awt和java.awt.geom是兩個完全獨立的包。

3、其實上面已經提到，包名中的.最後會被對映成檔案目錄。因此，包java.awt是由java/awt下的java檔案編譯而來，包java.awt.geom則是由java/awt/geom下的檔案編譯而來，這是兩個不同的資料夾，所以原始檔之間不存在包含關係。

9.18.5包的使用

1、匯入包有兩種格式

import 包名.類名; //匯入這個包的特定類

import 包名.*;       //匯入這個包的所有類

2、假設你想使用java.awt.event包中的ActionEvent類，可以選擇以下兩種方式匯入：

import java.awt.event.ActionEvent;

import java.awt.event.*;

3、匯入後，可以這樣使用ActionEvent類：

ActionEvent myEvent = new ActionEvent();

4、其實不匯入一個類也是可以用的，就是寫起來麻煩：

     java.awt.event.ActionEvent myEvent = new java.awt.event.ActionEvent();

9.19可見性修飾符

預設情況下，類的變數和方法，可以被在同一個包（package）中的任意類訪問。

public

類的成員能被任意包的任意類訪問。

private 

類的成員僅能被類自身內部的方法所訪問。如果一個屬性被private修飾，外部的類想要訪問這個屬性，就只能通過get和set方法（如果這個類有提供的話）

private修飾符將訪問範圍限制到類自身內部；預設的（沒有加任何修飾符的）情況下，訪問範圍是同一個包；如果是public，則訪問範圍不再侷限於包（相當於沒有任何限制）。

為什麼需要將資料域設定為 private?

1、可以保護資料。

2、可以讓類容易維護。

這就是面向物件的重要特性：封裝性

9.20傳遞物件到方法中

1、對基本資料型別而言，傳遞的是值(執行形參=實參的操作)

2、對引用型別而言，傳遞的是物件的引用 (執行形參=實參的操作)

也就是說，其實Java引數傳遞只有一種，就是值傳遞（形參=實參）。只不過在上面兩種情況下，對=的處理有所不同。

LISTING 9.10 TestPassObject.java

 public class TestPassObject {
	 /** Main method */
	 public static void main(String[] args) {
		 // Create a Circle object with radius 1
		 CircleWithPrivateDataFields myCircle =
		 new CircleWithPrivateDataFields(1);

		 // Print areas for radius 1, 2, 3, 4, and 5.
		 int n = 5;
		 printAreas(myCircle, n);

		 // See myCircle.radius and times
		 System.out.println("\n" + "Radius is " + myCircle.getRadius());
		 System.out.println("n is " + n);
	 }

	 /** Print a table of areas for radius */
	 public static void printAreas(
		 CircleWithPrivateDataFields c, int times) {
		 System.out.println("Radius \t\tArea");
		 while (times >= 1) {
			 System.out.println(c.getRadius() + "\t\t" + c.getArea());
			 c.setRadius(c.getRadius() + 1);
			 times——;
		 }
	 }
}

傳遞物件到方法中

9.21物件陣列

 Circle[] circleArray = new Circle[10];

 物件陣列的實質，是一堆引用變數構成的。例如，呼叫circleArray[1].getArea()，實際上通過引用操作了兩次物件， 一次是下標，表示取到陣列物件的第二個元素，該元素是個Circle的引用，然後通過這個引用，再呼叫getArea方法。

9.21.1物件陣列圖示

   Circle[] circleArray = new Circle[10];

  注意這行程式碼執行後， circleArray[0]… circleArray[9]這10個元素都是null，因為它們還沒有指向某個物件。

LISTING 9.11 TotalArea.java

 public class TotalArea {
	 /** Main method */
	 public static void main(String[] args) {
		 // Declare circleArray
		 CircleWithPrivateDataFields[] circleArray;

		 // Create circleArray
		 circleArray = createCircleArray();

		 // Print circleArray and total areas of the circles
		 printCircleArray(circleArray);
	 }

	 /** Create an array of Circle objects */
	 public static CircleWithPrivateDataFields[] createCircleArray() {
		 CircleWithPrivateDataFields[] circleArray =
			 new CircleWithPrivateDataFields[5];

	 for (int i = 0; i < circleArray.length; i++) {
		 circleArray[i] =
		 new CircleWithPrivateDataFields(Math.random() * 100);
	 }

	 // Return Circle array
	 return circleArray;
	}

	 /** Print an array of circles and their total area */
	 public static void printCircleArray(
		 CircleWithPrivateDataFields[] circleArray) {
		 System.out.printf("%-30s%-15s\n", "Radius", "Area");
		 for (int i = 0; i < circleArray.length; i++) {
			 System.out.printf("%-30f%-15f\n", circleArray[i].getRadius(),
				 circleArray[i].getArea());
		 }
		 System.out.println("—————————————————————————————————————————-");

		 // Compute and display the result
		 System.out.printf("%-30s%-15f\n", "The total area of circles is",
			 sum(circleArray) );
	 }

	 /** Add circle areas */
	 public static double sum(CircleWithPrivateDataFields[] circleArray) {
		 // Initialize sum
		 double sum = 0;

		 // Add areas to sum
	 for (int i = 0; i < circleArray.length; i++)
 			sum += circleArray[i].getArea();

		 return sum;
	 }
}

9.22不可修改的物件和類

如果希望物件的所有成員都是不可修改的，例如：

 

然而按照這個寫法，dateCreated有可能被外部類黑掉。

例如：下面這段程式碼可以把dateCreated成員黑掉。

 

所以，對需要保護的成員，忠告是：

1、所有成員都需要設定為private；

2、不對外提供能夠修改成員的方法；

3、所有對外的方法，都不能返回成員的引用。

9.23變數作用域

例項變數和靜態變數的作用範圍都是整個類，無論它們在類內部的何處宣告。當然為了可讀性，一般統一放在類的最前或者最後；

區域性變數的作用範圍，是從宣告的地方開始，到包含它的最近的右括號}為止。區域性變數在使用前，必須顯式初始化，否則會導致編譯錯誤。

9.24 this關鍵字

1、this關鍵字表示一個引用，這個引用指向任何物件自己。this最常用的地方在於通過它訪問一個類的隱藏資料域（hidden data fields）。

2、this的另外一個常用之處，是在一個類的某個構造方法中，通過它來呼叫同一個類的另外一個構造方法。

9.24.1訪問隱藏資料域

9.24.2呼叫過載的另一個構造方法

CHAPTER 9SUMMARY

1. Aclass is a template forobjects. It defines theproperties of objects and provides

constructors for creating objects and methods for manipulating them.

2. A class is also a data type. You can use it to declare objectreference variables. Anobject reference variable that appears to hold an object actually contains a reference tothat object. Strictly speaking, an object reference variable and an object are different,but most of the time the distinction can be ignored.

3. An object is aninstance of a class. You use thenew operator to create an object, and thedot operator(.) to access members of that object through its reference variable.

4. Aninstance variable ormethod belongs to an instance of a class. Its use is associatedwith individual instances. Astatic variable is a variable shared by all instances of thesame class. Astatic method is a method that can be invoked without using instances.

5. Every instance of a class can access the class’s static variables and methods. For clarity,

however, it is better to invoke static variables and methods usingClassName.variableandClassName.method.

6. Visibility modifiers specify how the class, method, and data are accessed. Apublicclass, method, or data is accessible to all clients. Aprivate method or data is accessibleonly inside the class.

7. You can provide a getter (accessor) method or a setter (mutator) method to enableclients to see or modify the data.

8. A getter method has the signaturepublic returnType getPropertyName().If thereturnType isboolean, theget method should be defined aspublicboolean isPropertyName(). A setter method has the signaturepublic voidsetPropertyName(dataType propertyValue).

9. All parameters are passed to methods using pass-by-value. For a parameter of a primitive

type, the actual value is passed; for a parameter of areference type, the referencefor the object is passed.

10. A Java array is an object that can contain primitive type values or object type values.When an array of objects is created, its elements are assigned the default value of null.

11. Once it is created, animmutable object cannot be modified. To prevent users frommodifying an object, you can defineimmutable classes.

12. The scope of instance and static variables is the entire class, regardless of where thevariables are declared. Instance and static variables can be declared anywhere in theclass. For consistency, they are declared at the beginning of the class in this book.

13. The keywordthis can be used to refer to the calling object. It can also be used insidea constructor to invoke another constructor of the same class.