如何设计各种类

设计类Course

假设需要处理课程信息，没门课程都有一个名字以及选课的学生。要能够向/从这个课程添加/删除一个学生,可以使用一个类来对课程建模。

向构造方法Course(String name)传递一门课程的名称来创建一个Course对象。你可以使用addStudemt(String student)方法来向某门课程添加学生，使用dropStudent(String student)方案从某门课程中删掉一个学生，而使用getStudents()方法可以返回选这门课程的所有学生。假设该类是可用的。下面的程序创建一个测试类，这个测试类创建了两门课程，并向课程中加入学生。

public class TestCourse {
    public static void main(String args[]){
        Course course1 = new Course("Data Structures");
        Course course2 = new Course("Database Systems");

        course1.addStudent("Peter Jones");
        course1.addStudent("Brian Smith");
        course1.addStudent("Anne Kennedy");

        course2.addStudent("Peter Jones");
        course2.addStudent("Steve Smith");

        System.out.println（"Number of students in course1: " + course1.getNumberOfStudents());
        String[] students = course1.getStudent();
        for(int i = 0;i<course1.getNumberOfStudent()；i++)
           System.out.print(students[i] + ".");

        System.out.println();
        System.out.println("Number of students in course2: " + course2.getNumberOfStudents());  
   }

}

Course类的详细设计如下所示。它使用一个数组存储该选课的学生。为简单起见，假设选课的人数最多为100。在第三行使用new String[100]创建数组。addStudent方法（第10行）向这个数组中添加学生。只要有新的学生加入课程，numberOfStudents就增加1 （第12行）。getStudents方法返回这个数组。

public class Course {
    private String courseName;
    private String[] students = new String[100];
    private int numberOfStudents;
    public Course(String courseName) {
      this.courseName = courseName;
     } 
public void addStudent(String student) {
   students[numberOfStudent] = student;
   numberOfStudent++;
}
public String[] getStudents(){
  return students;
}
public int getNumberOfStudents() {
      return numberOfStudent;
}
public String getCourseName() {
   return courseName;
}
public void dropStudent(String student) {

} 
}

创建一个Course对象时，就创建一个数组对象。Course对象包含对数组的引用。简单的说，这个Course对象包含了这个数组。
用户可以创建一个Course，然后通过公共方法addStudent、dropStudent、getNumberOfStudents和getStudents来处理它。然而用户不需要知道这些方法是如何实现的。Course类封装了内部的实现，该例私用了一个数组存储学生。也可以使用不同的数据结构存储学生。只要公共方法的合约保持不变，那么使用Course类的程序也无需修改。

设计堆栈类

回顾一下，栈是一种以“后进先出”的方式存放数据的数据结构，如图所示。

栈有很多应用。例如：编译器使用栈来处理方法的调用。当使用某个方法时，方法的参数和局部变量都被压入栈中。当一个方法调用另一个方法时，新方法的参数和局部变量被压入栈中。当方法完成它的工作，返回它的调用者时，从栈中释放与它相关的空间。
可以定义一个类建模栈。为简单起见，假设该栈存储int数值。因此，命名这个栈类为StackOfIntegers。这个类的UML图如图所示。

public class TestStackOfIntegers {
   public static void main(String[] args) {
         StackOfIntegers stack = new StackOfIntegers();
for(int i = 0; i<10; i++){
    stack.push(i);
}
while(!stack.empty()){
  System.out.println(stack.pop + " ");
}
}
}

如何实现StackOfIntegers类呢？栈中的元素都存储在一个名为elements的数组中。创建一个栈的时候，同时也创建了这个数组。类的无参构造方法创建一个默认容量为16的数组。变量size记录了栈中元素的个数，而size-1是栈顶元素的下标，如图，对空栈来说，size为0。
StackOfIntegers类是在以下程序实现的。方法empty()、peek()、pop()、和getSize()都很容易实现。为了实现方法push(int value) , 若果size()

public class StackOfIntegers {
      private int[] elements;
      private int size;
      public static final int DEFAULT_CAPACITY = 16;

 /**  Construct a stack with the default capacity 16 */
   public StackOfInteger() {
       this(Default_CAPACITY);
}
/** Construct a stack with the specified maximum capacity */
public StackOfIntegers(int capacity) {
    elements = new int[capacity];
}

/** Push a new integer into the top of the stack */
public void push(int value) {
 if( size >= elements.length) {
   int [] temp = new int[elements.lemght * 2];
   System.out.println(elements, 0, temp, 0, elements.length);
   elements = temp;
}

elements[size++]  = value;
}

/** Return and remove the pop element from the stack */
public int pop() {
  return elements[--size];
}
/** Return the top element from the stack */
public int peek() {
return elements[size-1];
}

/** Test whether the stack is empty */
public boolean empty() {
return size ==0;
}

/** Return the number of elements in the stack */
public int getSize() {
  return size;
 }
}