更新注释

Author: mthli

Part4/CalendarTest.java

@@ -2,7 +2,8 @@
 import java.util.*;
 
 
-/* 这里需要提醒一下：
+/* 
+ * 这里需要提醒一下：
  * 在一个Java源文件里面，
  * 只能有一个公有类，
  * 但是可以有任意数目的非公有类（非公有类!=私有类）

Part4/ConstructorTest.java

@@ -1,6 +1,7 @@
 import java.util.*;
 
-/* 调用构造器的具体处理步骤：
+/* 
+ * 调用构造器的具体处理步骤：
  * 1. 所有的数据域被初始化为默认值（0、false或者null）
  * 2. 按照在类声明中出现的次序，依次执行所有的域初始化语句和初始化块
  * 3. 如果构造器第一行调用了第二个构造器（详细见《Core Java Volumn I》第129页），则执行第二个构造器主体
@@ -11,7 +12,8 @@ public class ConstructorTest {
  public static void main(String[] args) {
  Emplogee[] staff = new Emplogee[3];
 
- /* 这里利用到了Java中的“重载”进行初始化，
+ /* 
+ * 这里利用到了Java中的“重载”进行初始化，
  * 当然在这里就不能像C++中叫“函数重载”了，
  * 在Java中，应该叫做“方法重载”
  */
@@ -36,7 +38,8 @@ class Emplogee {
  private String name = "";
  private double salary;
 
- /* 下面的代码块用到的是“静态初始化块”
+ /* 
+ * 下面的代码块用到的是“静态初始化块”
  * 当对类的静态域进行初始化的代码比较复杂的时候，
  * 可以考虑使用“静态初始化块”进行初始化
  */
@@ -61,7 +64,8 @@ public Emplogee(double s) {
  this("Emplogee #" + nextId, s);
  }
 
- /* 这是“无参数构造器”，
+ /* 
+ * 这是“无参数构造器”，
  * 对象由无参数构造器构造时，其状态会被设置为适当的默认值。
  * 值得注意的是：
  * 仅当在编写一个类没有提供构造器时候，

Part4/EmployeeTest.java

@@ -21,7 +21,8 @@ public static void main(String[] args) {
  }
 }
 
-/* 如前CalendarTest.java开头的注释所述，
+/* 
+ * 如前CalendarTest.java开头的注释所述，
  * 这里的Employee就是一个非公有类，
  * 但它不是一个私有类
  */
@@ -30,7 +31,8 @@ class Employee {
  private double salary;
  private Date hireDay;
 
- /* 下面这段代码块是一个构造器，
+ /* 
+ * 下面这段代码块是一个构造器，
  * 顾名思义，构造器是用来构造一个新的对象实例的，
  * 需要注意的是：
  * 构造器的名字应该与所属类的名字相同
@@ -42,7 +44,8 @@ public Employee(String n, double s, int year, int month, int day) {
  hireDay = calendar.getTime();
  }
 
- /* 以下的几处代码块是一些访问器和更改器，
+ /* 
+ * 以下的几处代码块是一些访问器和更改器，
  * 通常的习惯是，
  * 在访问器方法名前面加上前缀get，
  * 而在更改器方法前面加上前缀set
@@ -59,7 +62,8 @@ public Date getHireDay() {
  return hireDay;
  }
 
- /* 如果愿意的话，可以使用下面这段代码来书写raiseSalary：
+ /* 
+ * 如果愿意的话，可以使用下面这段代码来书写raiseSalary：
  * public void raiseSalary(double byPercent) {
  * double raise = this.salary * byPercent / 100;
  * this.salary += raise;

Part4/ParamTest.java

@@ -1,4 +1,5 @@
-/* 在这里需要对Java的传递机制进行了解：
+/* 
+ * 在这里需要对Java的传递机制进行了解：
  * Java总是采用“按值传递”
  *
  * 一些概念：
@@ -8,7 +9,8 @@
 
 public class ParamTest {
  public static void main(String[] args) {
- /* 第一个测试，
+ /* 
+ * 第一个测试，
  * 调用的tripleValue方法不能够修改原先的数值
  */
  System.out.println("Testing tripleValue:");
@@ -17,7 +19,8 @@ public static void main(String[] args) {
  tripleValue(percent);
  System.out.println("After: percent = " + percent);
 
- /* 第二个测试，
+ /* 
+ * 第二个测试，
  * 调用的tripleSalary方法成功的改变了对象。
  * 你可能会奇怪了：
  * Java明明是按值传递，为什么能够改变原来的对象呢？
@@ -42,7 +45,8 @@ public static void main(String[] args) {
  tripleSalary(harry);
  System.out.println("After: salary = " + harry.getSalary());
 
- /* 第三个测试，
+ /* 
+ * 第三个测试，
  * 调用的swap方法并不能交换两个对象：
  * 因为swap内部交换的是其拷贝过来的临时的对象，
  * 而不是实际的对象
@@ -98,4 +102,3 @@ public void raiseSalary(double byPercent) {
  salary += raise;
  }
 }
-

Part4/StaticTest.java

@@ -45,7 +45,8 @@ public int getID() {
  return id;
  }
 
- /* 在这里我们可以看到，
+ /* 
+ * 在这里我们可以看到，
  * 实际上被定义成static变量的nextId也是可以被修改的，
  * 因为静态变量也是变量；
  * 如果不想被修改的话，

Part5/abstractClasses/Employee.java

@@ -3,7 +3,8 @@
 import java.util.Date;
 import java.util.GregorianCalendar;
 
-/* 因为Employee类中实现了Person抽象类中的所有抽象方法，
+/* 
+ * 因为Employee类中实现了Person抽象类中的所有抽象方法，
  * 所以不需要使用abstract关键字进行修饰
  */
 public class Employee extends Person {

Part5/abstractClasses/Person.java

@@ -1,6 +1,7 @@
 package abstractClasses;
 
-/* 下面的Person类使用了abstract关键字进行修饰，
+/* 
+ * 下面的Person类使用了abstract关键字进行修饰，
  * 表示这是一个“抽象类”；
  * 下面具体说说abstract的一些用法：
  * 1. 修饰类：

Part5/abstractClasses/PersonTest.java

@@ -7,7 +7,8 @@ public static void main(String[] args) {
  people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
  people[1] = new Student("Maria Morris", "computer science");
 
- /* 在这里也是直接用到了“多态”和“动态绑定”；
+ /* 
+ * 在这里也是直接用到了“多态”和“动态绑定”；
  * 在这里需要注意的是，
  * 虽然p是Person类的实例，
  * 但是由于不能构造抽象类Person的对象，

Part5/abstractClasses/Student.java

@@ -1,6 +1,7 @@
 package abstractClasses;
 
-/* 因为Employee类中实现了Person抽象类中的所有抽象方法，
+/* 
+ * 因为Employee类中实现了Person抽象类中的所有抽象方法，
  * 所以不需要使用abstract关键字进行修饰
  */
 public class Student extends Person {

Part5/inheritance/Manager.java

@@ -1,6 +1,7 @@
 package inheritance;
 
-/* Java中使用extends关键字来表示“继承”的概念，
+/* 
+ * Java中使用extends关键字来表示“继承”的概念，
  * extends关键字表明正在构造的新类派生于一个已经存在的类；
  * 需要注意的是：
  * 在Java中，所有的继承都是公用继承，
@@ -15,7 +16,8 @@
 public class Manager extends Employee {
  private double bonus;
 
- /* 下面这段代码块使用了super来调用其父类（超类）的构造器，
+ /* 
+ * 下面这段代码块使用了super来调用其父类（超类）的构造器，
  * super是一个指示编译器调用超类方法的特殊关键字；
  * 注意super并不是一个对象的引用，不能将super赋给另一个变量对象
  */
@@ -24,7 +26,8 @@ public Manager(String n, double s, int year, int month, int day) {
  bonus = 0;
  }
 
- /* 在这里对其超类（Employee）中的getSalary方法进行了重写（override）；
+ /* 
+ * 在这里对其超类（Employee）中的getSalary方法进行了重写（override）；
  * 由于在Manager类中也提供了getSalary方法，
  * 相当于将Employee类中的getSalary方法进行了覆盖，
  * 当直接调用getSalary类的时候，实际上是调用Manager类中的getSalary，