学步园

1，使用系统的类

这里举了个例子，使用GregorianCalendar类和Calendar类来写日历日期方面的应用

import java.util.*;

 public class CalendarTest
{  
   public static void main(String[] args)
   {  
      // construct d as current date
       GregorianCalendar d = new GregorianCalendar();

      int today = d.get(Calendar.DAY_OF_MONTH);
      int month = d.get(Calendar.MONTH);

      // set d to start date of the month
       d.set(Calendar.DAY_OF_MONTH, 1);

      int weekday = d.get(Calendar.DAY_OF_WEEK);

      // get first day of week (Sunday in the U.S.)
       int firstDayOfWeek = d.getFirstDayOfWeek();

      // indent first line of calendar
       for (int i = firstDayOfWeek; i < weekday; i++ )
         System.out.print("    ");

      do
      {  
         // print day
          int day = d.get(Calendar.DAY_OF_MONTH);
         System.out.printf("%3d", day);

         // mark current day with *
          if (day == today)
            System.out.print("*");
         else
            System.out.print(" ");

         // advance d to the next day
          d.add(Calendar.DAY_OF_MONTH, 1);//设置日历中的下一天
          weekday = d.get(Calendar.DAY_OF_WEEK);

         // start a new line at the start of the week
          if (weekday == firstDayOfWeek)
            System.out.println();
      } while (d.get(Calendar.MONTH) == month);
      
      // the loop exits when d is day 1 of the next month

      // print final end of line if necessary
       if (weekday != firstDayOfWeek)
         System.out.println();
   }
}

 

2，编写你自己的类

1）隐式参数与显式参数

如方法：

public void raiseSalary(double byPercent)
{
   double raise = salary * byPercent / 100;
   salary += raise;
}

将调用这个方法的对象的salary实例域设置为新值，例如下面这个调用：

number007.raiseSalary(5);

实际上执行了下面的操作：

double raise = number007.salary * 5 / 100;
number007.salary += raise;

实际上，任何一个方法都有一个this的隐式参数，你也可以将上面的方法写成这样（显式的将this写出来，有些程序员偏好这样的风格，它将实例域与局部变量区分开来）：

public void raiseSalary(double byPercent)
{
double raise = this.salary * byPercent / 100;
this.salary += raise;
}

2）在讲到封装的优点的时候，举出了这样一个破坏封装性的例子：

不要编写返回引用可变对象的访问器方法，这样会破坏封装性。

下例表明了这一点：

class Employee
{
   . . .
   public Date getHireDay()
   {
      return hireDay;
   }
   . . .
   private Date hireDay;
}

public Date getHireDay访问器就是一个返回引用可变对象的访问器，它的返回值是Date类型的，Date类型的引用是可变的，即你可以不通过类中提供的方法，而通过Date类中的方法来改变Date对象的值，这显然与我们设计private Date HireDay不适应。

3）静态域和静态方法：

看个例子吧，注释写好了

//编写一个Employee类，静态域nextId测试，用static成员nexId来对id进行设置，实现id的递增
 
 public class StaticTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
       Employee[] staff = new Employee[3];

      staff[0] = new Employee("Tom", 40000);
      staff[1] = new Employee("Dick", 60000);
      staff[2] = new Employee("Harry", 65000);

      // print out information about all Employee objects
       for (Employee e : staff)
      {
         e.setId();
         System.out.println("name=" + e.getName()
            + ",id=" + e.getId()
            + ",salary=" + e.getSalary());
      }

      int n = Employee.getNextId(); // calls static method
       System.out.println("Next available id=" + n);
   }
}


 //Employee类
 
 class Employee
{
   public Employee(String n, double s)
   {
      name = n;
      salary = s;
      id = 0;
   }

   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public int getId()
   {
      return id;
   }

   public void setId()//用static成员nexId来对id进行设置，实现id的递增
    {
      id = nextId; // set id to next available id
       nextId++;
   }

   public static int getNextId()
   {
      return nextId; // returns static field
    }

   public static void main(String[] args) // unit test
    {
      Employee e = new Employee("Harry", 50000);
      System.out.println(e.getName() + " " + e.getSalary());
   }

   private String name;
   private double salary;
   private int id;
   private static int nextId = 1;
}

name=Tom,id=1,salary=40000.0
name=Dick,id=2,salary=60000.0
name=Harry,id=3,salary=65000.0
Next available id=4

4）方法参数

其实只有值传递，测试下传递的过程：

public static void tripleValue(double x) // doesn't work
    {
      x = 3 * x;
      System.out.println("End of method: x=" + x);
   }

   public static void tripleSalary(Employee x) // works
    {
      x.raiseSalary(200);
      System.out.println("End of method: salary="
         + x.getSalary());
   }

   public static void swap(Employee x, Employee y)//doesn't work
    {
      Employee temp = x;
      x = y;
      y = temp;
      System.out.println("End of method: x=" + x.getName());
      System.out.println("End of method: y=" + y.getName());
   }

5）构造器的相互调用，初始化块，静态块等

下面的代码展示了关于构造器的许多重要特性

import java.util.*;

 public class ConstructorTest
{
   public static void main(String[] args)
   {
      // fill the staff array with three Employee objects
       Employee[] staff = new Employee[3];

      staff[0] = new Employee("Harry", 40000);
      staff[1] = new Employee(60000);
      staff[2] = new Employee();

      // print out information about all Employee objects
       for (Employee e : staff)
         System.out.println("name=" + e.getName()
            + ",id=" + e.getId()
            + ",salary=" + e.getSalary());
   }
}


 class Employee
{
   // three overloaded constructors
    public Employee(String n, double s)
   {
      name = n;
      salary = s;
   }

   public Employee(double s)//在一个构造器中调用另一个构造器
    {
      // calls the Employee(String, double) constructor
       this("Employee #" + nextId, s);
   }

   // the default constructor
    public Employee()//空构造器
    {
      // name initialized to ""--see below
      // salary not explicitly set--initialized to 0
      // id initialized in initialization block
    }

   
   public String getName()
   {
      return name;
   }

   public double getSalary()
   {
      return salary;
   }

   public int getId()
   {
      return id;
   }

   private static int nextId;//静态域nextId
 
   private int id;
   private String name = ""; // instance field initialization
    private double salary;

   // static initialization block静态块，仅当第一次加载类时，进行一次初始化，这段代码只执行一次
    static
   {
      Random generator = new Random();
      // set nextId to a random number between 0 and 9999
       nextId = generator.nextInt(10000);
   }

   // object initialization block初始化快，无论使用哪个构造器构造对象，都要先运行初始化块然后运行构造器，这种方式不常见
    {
      id = nextId;
      nextId++;
   }
}

参考 ：第四章  对象与类