@ -404,17 +404,209 @@ public class CircleWithPrivateDataFields {
## 6. 对象作为函数参数
值传递和引用传递
如果是基本类型的变量， ， （ ， ） ， ，
```java
class CircleWithPrivateDataFields {
/** The radius of the circle */
private double radius = 1;
/** The number of the objects created */
private static int numberOfObjects = 0;
/** Construct a circle with radius 1 */
CircleWithPrivateDataFields() {
numberOfObjects++;
}
/** Construct a circle with a specified radius */
public CircleWithPrivateDataFields(double newRadius) {
radius = newRadius;
numberOfObjects++;
}
// get radius
public double getRadius() {
return radius;
}
// set radius
public void setRadius(double radius) {
this.radius = radius;
}
/** Return numberOfObjects */
public static int getNumberOfObjects() {
return numberOfObjects;
}
/** Return the area of this circle */
public double getArea() {
return radius * radius * Math.PI;
}
}
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--;
}
}
}
```
`printAreas` 函数接受两个参数，第一个参数是`CircleWithPrivateDataFields`类型的引用变量，第二个参数是循环的次数；主函数先生成一个`CircleWithPrivateDataFields`对象，然后使用`printAreas`函数；在`printAreas`函数内部， ， ； ， （ ， ）
这个例子证明， ， ； ， ； ，
如果我么在`printAreas`函数执行完成后， （ ） ， ；
## 7. 对象数组
## 8. Immutable 类与对象
上一章我们学了数组，不过数组中元素的类型是基本类型。其实数组也是一个特殊的类（其变量也是引用变量），那么我们也可以在函数内部改变数组元素的值，无论数组内部是基本类型还是引用类型。
数组元素是基本类型：
```java
public class Test {
public static void main(String[] args) {
int a[] = { 1, 2, 3, 4, 5 };
System.out.printf("Before run changeArray, a[0] is %d\n", a[0]);
changeArray(a);
System.out.printf("After run changeArray, a[0] is %d\n", a[0]);
}
static void changeArray(int a[]) {
a[0] = 1000;
}
}
```
运行后， ，
下面看看数组中的元素是引用类型的情况，借用上个例子的`CircleWithPrivateDataFields`类型。
```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 areas 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;
}
}
```
1. 数组可以作为函数的返回值，例如`createCircleArray`函数， ，
2. `CircleWithPrivateDataFields` 和`sum`函数都是数组作为参数。
你可以在函数中改变数组中引用对象内部成员的值，如同**对象作为函数参数**中一样。
## 8. Immutable 类与对象（了解）
If the contents of an object cannot be changed once the object is created, the object is called an immutable（ ）
这个概念需要了解， ，
## 9. 变量作用域
The scope of instance and static variables is the entire class. They can be declared anywhere inside a class.
The scope of a local variable starts from its declaration and continues to the end of the block that contains the variable. A local variable must be initialized explicitly before it can be used.
## 10. This关键字
### 10.1. 构造函数重载
The this keyword is the name of a reference that refers to an object itself. One common use of the this keyword is reference a class’
```java
public class Circle {
public double radius;
public Circle() {
this(1.0);
}
public Circle(double radius) {
this.radius = radius;
}
}
```
上个例子有两个构造函数，
不带参数的构造函数`public Circle()`可以调用其他构造函数，
## 11. 本章重点
