Java学习笔记

---

SE

---

$\qquad \qquad \qquad \qquad\qquad \qquad\qquad \qquad\qquad \qquad\qquad \qquad \qquad \qquad \qquad$软件1705 唐麒 17301138

---

---

Chapter 1 Getting Start

---

1.1 About the Java Technology

Java programming language is unusual in that a program is both compiled and interpreted.

Java bytecodes help make "write once, run anywhere" possible

The Java Platform
A platform is the hardware or software environment in which a program runs

The Java platform differs from most other platforms in that it's a software-only platform that runs on top of other hardware-based platforms. The Java platform has two components:

The Java Virtual Machine (Java VM)
The Java Application Programming Interface (Java API)

The Java Virtual Machine
• Provides hardware platform specifications
• Reads compiled byte codes that are platform independent
• Is implemented in a Java technology development tool or a Web browser
• The majority of type checking is done when the code is compiled.

Garbage Collection
• Allocated memory that is no longer needed should be
Deallocated, In other languages, deallocation is the programmer’s Responsibility

• The Java programming language provides a systemlevel
thread to track memory allocation

• Garbage collection:

Checks for and frees memory no longer needed
Is done automatically

---

Chapter 2 Class and Object

---

2.1 What Is a Class and Object?

Definition:* A class is a blueprint, or prototype, that defines the variables and the methods common to all objects of a certain kind. *

In software, a class is a description of an object:

• A class describes the data that each object includes
• A class describes the behaviors that each object exhibits

---

2.2 Constructor

All Java classes have constructors that are used to initialize a new object of that type.

Basic syntax of a constructor:
< modifier> <class_name> ([< argument_list>]) {
    [< statements>]
}

Writing Our Own Explicit Constructors

• A constructor’s name must be exactly the same as the name of the class
• Can have A parameter list in an constructor header
• We cannot specify a return type for a constructor;

The Default Constructor
• There is always at least one constructor in every class.
• If the writer does not supply any constructors, the default constructor is present automatically:

The default constructor takes no arguments
The default constructor has no body

• Enables you to create object instances with new Xxx() without having to write a constructor.

if we declare any of our own constructors for a class, with any argument signature, then the default parameterless constructor is not automatically provided.

Constructing and Initializing Objects
Calling new Xxx() to allocate space for the new object results in:

• Memory allocation: Space for the new object is allocated and instance variables are initialized to their default values (for example, 0, false, null,and so on)
• Explicit attribute initialization is performed
• A constructor is executed

---

2.3 Object

Memory Allocation and Layout
• A declaration allocates storage only for a reference:

    MyDate my_birth

Use the new operator to allocate space for MyDate:

MyDate my_birth = new MyDate(22, 7, 1964);

---

2.4 The Power of Encapsulation Plus Information Hiding

By restricting access to an object’s private attributes through public accessors, we derive three important benefits:

• Preventing unauthorized access to encapsulated data
  Simply by making the attribute private, and intentionally omitting a public “get” method

• Helping to ensure data integrity
  when an accessor method is used to change the value of a private attribute,value checking can be built into the “set” method to ensure that the attribute value won’t be set to an “improper” value.

• Limiting “ripple effects” that can otherwise occur throughout an application when the private implementation details of a class must change
  the most dramatic benefit of encapsulation combined with information hiding,therefore, is that the hidden implementation details of a class

---

2.5 Packages

Definition: A package is a collection of related classes and interfaces providing access protection and namespace management.

programmers bundle groups of related classes and interfaces into packages.

java.net  
java.io  
java.lang 
java.applet   
javax.swing

You should bundle these classes and the interface in a package for several reasons:

• You and other programmers can easily determine that these classes and interfaces are related.
• You and other programmers know where to find classes and interfaces that provide related functions.

Using Package Members
To use a public package member from outside its package, you must do one or more of the following:

Refer to the member by its long (qualified) name
Import the package member
Import the members entire package

Using Package Members
1、Referring to a Package Member by Name

graphics.Rectangle myRect = new graphics.Rectangle();

2、Importing a Package Member

import graphics.Circle;
Circle myCircle = new Circle();

3 . Importing an Entire Package

import graphics.*;
Circle myCircle = new Circle();
Rectangle myRectangle = new Rectangle();

---

2.6 Access

---

Chapter 3 Identifiers,Keywords and Types

---

3.1 Reference Types

Passing Information into a Method
primitive data types: such as doubles, floats and integers. the method cannot change its value

reference data types :such as objects and arrays. the method cannot change the object reference, but can invoke the object's methods and modify the accessible variables within the object.

---

3.2 This reference

You can use this in the method body to refer to members in the current object.


you can use this in the method body to refer to members in the current object.
Using the “this”Keyword to Facilitate Constructor Reuse.

---

Chapter 4 Expressions and Flow Control

---

4.1 Variables and Scope

The Java programming language defines the following kinds of variables:
Instance Variables (Non-Static Fields) Technically speaking, objects store their individual states in "non-static fields", that is, fields declared without the static keyword. Non-static fields are also known as instance variables because their values are unique to each instance of a class (to each object, in other words); the currentSpeed of one bicycle is independent from the currentSpeed of another.

Class Variables (Static Fields) A class variable is any field declared with the static modifier; this tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated. A field defining the number of gears for a particular kind of bicycle could be marked as static since conceptually the same number of gears will apply to all instances. The code static int numGears = 6; would create such a static field. Additionally, the keyword final could be added to indicate that the number of gears will never change.

Local Variables Similar to how an object stores its state in fields, a method will often store its temporary state in local variables. The syntax for declaring a local variable is similar to declaring a field (for example, int count = 0;). There is no special keyword designating a variable as local; that determination comes entirely from the location in which the variable is declared — which is between the opening and closing braces of a method. As such, local variables are only visible to the methods in which they are declared; they are not accessible from the rest of the class.

Parameters You've already seen examples of parameters, both in the Bicycle class and in the main method of the "Hello World!" application. Recall that the signature for the main method is public static void main(String[] args). Here, the args variable is the parameter to this method. The important thing to remember is that parameters are always classified as "variables" not "fields". This applies to other parameter-accepting constructs as well (such as constructors and exception handlers) that you'll learn about later in the tutorial.

A variable's scope is the region of a program within which the variable can be referred to by its simple name.Scope also determines when the system creates and destroys memory for the variable.

Four categories:

• member variable
• local variable
• method parameter
• exception-handler parameter

Naming
Every programming language has its own set of rules and conventions for the kinds of names that you're allowed to use, and the Java programming language is no different. The rules and conventions for naming your variables can be summarized as follows:

• Variable names are case-sensitive. A variable's name can be any legal identifier — an unlimited-length sequence of Unicode letters and digits, beginning with a letter, the dollar sign "$", or the underscore character "_". The convention, however, is to always begin your variable names with a letter, not "$" or "". Additionally, the dollar sign character, by convention, is never used at all. You may find some situations where auto-generated names will contain the dollar sign, but your variable names should always avoid using it. A similar convention exists for the underscore character; while it's technically legal to begin your variable's name with "", this practice is discouraged. White space is not permitted.
• Subsequent characters may be letters, digits, dollar signs, or underscore characters. Conventions (and common sense) apply to this rule as well. When choosing a name for your variables, use full words instead of cryptic abbreviations. Doing so will make your code easier to read and understand. In many cases it will also make your code self-documenting; fields named cadence, speed, and gear, for example, are much more intuitive than abbreviated versions, such as s, c, and g. Also keep in mind that the name you choose must not be a keyword or reserved word.
• If the name you choose consists of only one word, spell that word in all lowercase letters. If it consists of more than one word, capitalize the first letter of each subsequent word. The names gearRatio and currentGear are prime examples of this convention. If your variable stores a constant value, such as static final int NUM_GEARS = 6, the convention changes slightly, capitalizing every letter and separating subsequent words with the underscore character. By convention, the underscore character is never used elsewhere.

---

4.2 StringBuffer

java.long.String class provides for strings whose value will not change

int length(). Obtains the number of characters in the String. 
char charAt(int index). Returns the character at the specified index. 
boolean equals(Object anObject). Returns true if the specified Object represents a String with the same sequence of characters. 
int indexOf(int ch). Returns the index of the first occurrence of the character. 
int indexOf(String str). Returns the index of the first occurrence of the String. 
boolean startsWith(String prefix). Checks if the String has the specified prefix. 
String substring(int beginIndex, int endIndex). Returns a substring. 

The StringBuffer class provides for strings that will be modified typically use string buffers for constructing character data dynamically

Constructors:

StringBuffer()
StringBuffer(int capacity)
StringBuffer(String initialString)

Modification operations: append, insert, reverse,setCharAt, and setLength.

---

Chapter 5 Array

---

5.1 Arrays

An array is a structure that holds multiple values of the same type.

An array can contain :
a set of primitives
a set of object references

An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed. You have seen an example of arrays already, in the main method of the "Hello World!" application. This section discusses arrays in greater detail.

Each item in an array is called an element, and each element is accessed by its numerical index. As shown in the preceding illustration, numbering begins with 0. The 9th element, for example, would therefore be accessed at index 8.

---

5.2 Declaring Arrays

Declare arrays of primitive or class types:

char[] s;
Point[] p;

the declaration for an array variable does not allocate any memory to contain the array elements.

---

5.3 Creating Arrays

Because Java arrays are objects, they must be instantiated using the new operator.

int[] MyIntArray;
MyIntArray =new int[10]
Point[] myIntArray;
myIntArray =new Point[10];

The first element in an array has an index of 0

For example, a primitive (char) array:

public char[] createArray(){
    char[] s;
    s = new char[ 26];
   for ( int i= 0; i< 26; i++ ) {
        s[ i] = (char) (‘A’+ i);
   }
   return s;
 }

Another example, an object array:

public Point[] createArray(){
   Point[] p;
   p = new Point[ 10];
   for ( int i= 0; i< 10; i++ ) {
        p[ i] = new Point( i, i+ 1);
   }
   return p;
 }

---

5.4 Initializing Arrays

That is, the following won’t compile:

String[] names = new String[4];
// This next line won't compile.
names = {"Mike", "Cheryl", "Mickey", "Will" };

Initialize an array element
• Create an array with initial values:

String names[];
names = new String[3];
names[0] = "Georgianna";
names[1] = "Jen";
names[2] = "Simon";
String names[] = {
"Georgianna",
"Jen",
"Simon"
};

---

5.5 Manipulating Arrays

Arrays are typically traversed in sequential order using for-loops.
The for-each loop provides a simple way to iterate through the elements of an array

String[] words = {"Arrays", " and ", "for-each"}
String result = "";
for (String element : words) {
    result += element; 
}
System.out.println(result);

---

5.6 Array Resizing

• Cannot resize an array
• Can use the same reference variable to refer to an entirely new array:

int myArray[] = new int[6];
myArray = new int[10];

---

5.7 Coping Arrays

The System’s arraycopy method requires five arguments:

public static void arraycopy(
                          Object source, int srcIndex, Object dest, int destIndex, int length) 

---

5.8 Arrays of Arrays

• Arrays of arrays:

int [][] twoDim = new int [4][];
twoDim[0] = new int[5];
twoDim[1] = new int[5];

• Non-rectangular arrays of arrays:

twoDim[0] = new int[2];
twoDim[1] = new int[4];
twoDim[2] = new int[6];
twoDim[3] = new int[8];

• Array of four arrays of five integers each:

int [][] twoDim = new int[4][21];
int [][] twoDim = new int [][22]; //illegal
int [][] a = {{2,3}, {1,5}, {3,4}};

---

Chapter 6 Inheritence

---

6.1 Inheritence

Definition: A subclass is a class that extends another class. A subclass inherits state and behavior from all of its ancestors. The term "superclass" refers to a class's direct ancestor as well as to all of its ascendant classes。

< modifier> class < name> [extends < superclass>] {< declarations>*}

Excepting Object, which has no superclass, every class has one and only one direct superclass (single inheritance). In the absence of any other explicit superclass, every class is implicitly a subclass of Object.

Classes can be derived from classes that are derived from classes that are derived from classes, and so on, and ultimately derived from the topmost class, Object. Such a class is said to be descended from all the classes in the inheritance chain stretching back to Object.

The idea of inheritance is simple but powerful: When you want to create a new class and there is already a class that includes some of the code that you want, you can derive your new class from the existing class. In doing this, you can reuse the fields and methods of the existing class without having to write (and debug!) them yourself.

A subclass inherits all the members (fields, methods, and nested classes) from its superclass. Constructors are not members, so they are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass.

The Benefits of Inheritance
We dramatically reduce code redundancy,Subclasses are much more succinct than they would be without inheritance.

Through inheritance, we can reuse and extend code that has already been thoroughly tested without modifying it.

Best of all, we can derive a new class from an existing class even if we don’t own the source code for the latter!

Rules for Deriving Classes:
We may extend the superclass by adding features.
We also may specialize the way that a subclass performs one or more of the services inherited from its superclass.

What Members Does a Subclass Inherit?

• A subclass inherits all of the members in its superclass that are accessible to that subclass unless the subclass explicitly hides a member variable or overrides a method.
• Note that constructors are not members and are not inherited by subclasses.
• Subclasses inherit those superclass members declared as public or protected.
• Subclasses inherit those superclass members declared with no access specifier as long as the subclass is in the same package as the superclass.
• Subclasses don't inherit a superclass's member if the subclass declares a member with the same name.

Override
A subclass can modify behavior inherited from a parent class.

• A subclass can create a method with different functionality than the parent's method but with the same:

Name
Return type
Argument list

可以变宽不能变窄

Instance Methods
An instance method in a subclass with the same signature (name, plus the number and the type of its parameters) and return type as an instance method in the superclass overrides the superclass's method.

The ability of a subclass to override a method allows a class to inherit from a superclass whose behavior is "close enough" and then to modify behavior as needed. The overriding method has the same name, number and type of parameters, and return type as the method that it overrides. An overriding method can also return a subtype of the type returned by the overridden method. This subtype is called a covariant return type.

When overriding a method, you might want to use the @Override annotation that instructs the compiler that you intend to override a method in the superclass. If, for some reason, the compiler detects that the method does not exist in one of the superclasses, then it will generate an error. For more information on @Override, see Annotations.

Static Methods
If a subclass defines a static method with the same signature as a static method in the superclass, then the method in the subclass hides the one in the superclass.
The distinction between hiding a static method and overriding an instance method has important implications:

The version of the overridden instance method that gets invoked is the one in the subclass.
The version of the hidden static method that gets invoked depends on whether it is invoked from the superclass or the subclass.

Consider an example that contains two classes. The first is Animal, which contains one instance method and one static method:

public class Animal {
    public static void testClassMethod() {
        System.out.println("The static method in Animal"); 
    } 
    public void testInstanceMethod() { 
    System.out.println("The instance method in Animal"); 
    }
}

The second class, a subclass of Animal, is called Cat:

public class Cat extends Animal { 
    public static void testClassMethod() { 
        System.out.println("The static method in Cat"); 
    } 
    public void testInstanceMethod() { 
    System.out.println("The instance method in Cat"); 
    } 
    public static void main(String[] args) { 
    Cat myCat = new Cat(); 
    Animal myAnimal = myCat; 
    Animal.testClassMethod(); 
    myAnimal.testInstanceMethod(); 
    }
}

The Cat class overrides the instance method in Animal and hides the static method in Animal. The main method in this class creates an instance of Cat and invokes testClassMethod() on the class and testInstanceMethod() on the instance.

The output from this program is as follows:

The static method in Animal
The instance method in Cat

As promised, the version of the hidden static method that gets invoked is the one in the superclass, and the version of the overridden instance method that gets invoked is the one in the subclass.

Static methods in interfaces are never inherited.

Summary
The following table summarizes what happens when you define a method with the same signature as a method in a superclass.
Defining a Method with the Same Signature as a Superclass's Method

$\quad$	Superclass Instance Method	Superclass Static Method
Subclass Instance Method	Overrides	Generates a compile-time error
Subclass Static Method	Generates a compile-time error	Hides

---

6.2 Super keyword

Reusing Superclass Behaviors: The “super”Keyword.
• super is used in a class to refer to its superclass.
• super is used to refer to the members of superclass,both data attributes and methods.

Accessing Superclass Members
If your method overrides one of its superclass's methods, you can invoke the overridden method through the use of the keyword super. You can also use super to refer to a hidden field (although hiding fields is discouraged). Consider this class, Superclass:

public class Superclass { 
    public void printMethod() { 
        System.out.println("Printed in Superclass.");
    }
}

Here is a subclass, called Subclass, that overrides printMethod():

public class Subclass extends Superclass {
    // overrides printMethod in Superclass 
    public void printMethod() { 
        super.printMethod(); 
        System.out.println("Printed in Subclass"); 
    } 
    public static void main(String[] args) { 
        Subclass s = new Subclass(); 
        s.printMethod(); 
    }
}

Within Subclass, the simple name printMethod() refers to the one declared in Subclass, which overrides the one in Superclass. So, to refer to printMethod() inherited from Superclass, Subclass must use a qualified name, using super as shown. Compiling and executing Subclass prints the following:

Printed in Superclass.
Printed in Subclass

Subclass Constructors
The following example illustrates how to use the super keyword to invoke a superclass's constructor. Recall from the Bicycle example that MountainBike is a subclass of Bicycle. Here is the MountainBike (subclass) constructor that calls the superclass constructor and then adds initialization code of its own:

public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) {
    super(startCadence, startSpeed, startGear); 
    seatHeight = startHeight;
} 

Invocation of a superclass constructor must be the first line in the subclass constructor.
The syntax for calling a superclass constructor is

super(); 

or:

super(parameter list);

With super(), the superclass no-argument constructor is called. With super(parameter list), the superclass constructor with a matching parameter list is called.

Note: If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem.

If a subclass constructor invokes a constructor of its superclass, either explicitly or implicitly, you might think that there will be a whole chain of constructors called, all the way back to the constructor of Object. In fact, this is the case. It is called constructor chaining, and you need to be aware of it when there is a long line of class descent.

Inheritance and Constructors
the super(...) syntax, the call must be the first statement in the subclass constructor.If we write a constructor without an explicit call to super(args),the parameterless constructor for the superclass is called automatically. If there no parameterless constructor in superclass ,then error occur

---

6.3 Multiple Inheritance

there are many complications inherent in multiple inheritance—so many, in fact, that the Java language designers chose not to support multiple inheritance.

---

6.4 Instanceof operator

test whether a given object reference belongs to a particular class is via the instanceof operator.

object instanceof ClassX 

For example:

public class Employee extends Object
public class Manager extends Employee
public class Engineer extends Employee
--------------------------------------- -
public void doSomething( Employee e) {
    if (e instanceof Manager) {
        // Process a Manager
    } else if (e instanceof Engineer) {
        // Process an Engineer
    } else {
        // Process any other type of Employee
    }
}

---

6.5 Casting Objects

Although it is always legal to cast a subclass reference to a superclass reference, the reverse is not always legal.

Person person = new Employee("Joe Smith", "100 Main Ave", 3000.0);
String name = person.getName();         // legal
String address = person.getAddress();   // legal  
Employee employee = (Employee) person;
double salary = employee.getSalary(); 
// or 
double salary = ((Employee) person).getSalary(); 
---------------------------------------------------------------------------------
Person person = new Person ("Joe Smith", "100 Main Ave");
// illegal 
double salary = ((Employee) person).getSalary();

---

6.6 The Object Class

The Object class, in the java.lang package, sits at the top of the class hierarchy tree. Every class is a descendant, direct or indirect, of the Object class. Every class you use or write inherits the instance methods of Object. You need not use any of these methods, but, if you choose to do so, you may need to override them with code that is specific to your class. The methods inherited from Object that are discussed in this section are:

protected Object clone() throws CloneNotSupportedException
      Creates and returns a copy of this object.
public boolean equals(Object obj)
      Indicates whether some other object is "equal to" this one.
protected void finalize() throws Throwable
      Called by the garbage collector on an object when garbage
      collection determines that there are no more references to the object
public final Class getClass()
      Returns the runtime class of an object.
public int hashCode()
      Returns a hash code value for the object.
public String toString()
      Returns a string representation of the object.

The notify, notifyAll, and wait methods of Object all play a part in synchronizing the activities of independently running threads in a program, which is discussed in a later lessonand won't be covered here. There are five of these methods:

public final void notify()
public final void notifyAll()
public final void wait()
public final void wait(long timeout)
public final void wait(long timeout, int nanos)

The equals() Method
The equals() method compares two objects for equality and returns true if they are equal. The equals() method provided in the Object class uses the identity operator (==) to determine whether two objects are equal. For primitive data types, this gives the correct result. For objects, however, it does not. The equals() method provided by Object tests whether the object references are equal—that is, if the objects compared are the exact same object.

To test whether two objects are equal in the sense of equivalency (containing the same information), you must override the equals() method.

You should always override the equals() method if the identity operator is not appropriate for your class.

Note: If you override equals(), you must override hashCode() as well.

The == operator determines if two references are identical to each other (that is, refer to the same object).

The equals method determines if objects are “equal” but not necessarily identical.

The Object implementation of the equals method uses the == operator.

User classes can override the equals method to implement a specific test for equality.

The getClass() Method

You cannot override getClass.
The getClass() method returns a Class object, which has methods you can use to get information about the class, such as its name (getSimpleName()), its superclass (getSuperclass()), and the interfaces it implements (getInterfaces()). For example, the following method gets and displays the class name of an object:

void printClassName(Object obj) { 
    System.out.println("The object's" + " class is " + obj.getClass().getSimpleName());
}

The Class class, in the java.lang package, has a large number of methods (more than 50). For example, you can test to see if the class is an annotation (isAnnotation()), an interface (isInterface()), or an enumeration (isEnum()). You can see what the object's fields are (getFields()) or what its methods are (getMethods()), and so on.

One handy use of a Class object is to create a new instance of a class without knowing what the class is at compile time.

Object createNewInstanceOf(Object obj) {
    return obj.getClass().newInstance();
}

The toString() Method
You should always consider overriding the toString() method in your classes.
The Object's toString() method returns a String representation of the object, which is very useful for debugging. The String representation for an object depends entirely on the object, which is why you need to override toString() in your classes.

You can use toString() along with System.out.println() to display a text representation of an object.

---

6.7 Overloading Method

In some circumstances, you might want to write several methods in the same class that do basically the same job with different arguments

---

6.8 Wrapper Classes

The Java programming language provides wrapper classes to manipulate primitive data elements as objects.( in java.lang package)

---

6.9 Polymorphism

The dictionary definition of polymorphism refers to a principle in biology in which an organism or species can have many different forms or stages. This principle can also be applied to object-oriented programming and languages like the Java language. Subclasses of a class can define their own unique behaviors and yet share some of the same functionality of the parent class.

The term polymorphism refers to the ability of two or more objects belonging to different classes to respond to exactly the same message (method call) in different class-specific ways.

class A{
    void callme( ){
        System.out.println("Inside A's callme( ) method");
    }
}
　
class B extends A{
    void callme( ){
        System.out.println("Inside B's callme( ) method");
    }
}
　
public class Dispatch{
    public static void main( String args[ ] ){
        A a = new B( );
        a.callme( );
    }
}

Outcome is: Inside B's callme( ) method

Polymorphism can be demonstrated with a minor modification to the Bicycle class. For example, a printDescription method could be added to the class that displays all the data currently stored in an instance.

public void printDescription(){ 
    System.out.println("\nBike is " + "in gear " + this.gear + " with a cadence of " + this.cadence + " and travelling at a speed of " + this.speed + ". ");
}

To demonstrate polymorphic features in the Java language, extend the Bicycle class with a MountainBike and a RoadBike class. For MountainBike, add a field for suspension, which is a String value that indicates if the bike has a front shock absorber, Front. Or, the bike has a front and back shock absorber, Dual.

Here is the updated class:

public class MountainBike extends Bicycle { 
    private String suspension; 
    public MountainBike( int startCadence, int startSpeed, int startGear, String suspensionType){         super(startCadence, startSpeed, startGear); 
        this.setSuspension(suspensionType); 
    } 
    public String getSuspension(){ 
        return this.suspension; 
    } 
    public void setSuspension(String suspensionType) { 
        this.suspension = suspensionType; 
    } 
    public void printDescription() { 
        super.printDescription(); 
        System.out.println("The " + "MountainBike has a" + getSuspension() + " suspension.");
    }
} 

Note the overridden printDescription method. In addition to the information provided before, additional data about the suspension is included to the output.

Next, create the RoadBike class. Because road or racing bikes have skinny tires, add an attribute to track the tire width. Here is the RoadBike class:

public class RoadBike extends Bicycle{ 
    // In millimeters (mm) 
    private int tireWidth;
    public RoadBike(int startCadence, int startSpeed, int startGear, int newTireWidth){
        super(startCadence, startSpeed, startGear); 
        this.setTireWidth(newTireWidth); 
    } 
    public int getTireWidth(){ 
        return this.tireWidth; 
    } 
    public void setTireWidth(int newTireWidth){ 
        this.tireWidth = newTireWidth; 
    } 
    public void printDescription(){ 
        super.printDescription(); 
        System.out.println("The RoadBike" + " has " + getTireWidth() + " MM tires.");
    }
}

Note that once again, the printDescription method has been overridden. This time, information about the tire width is displayed.

To summarize, there are three classes: Bicycle, MountainBike, and RoadBike. The two subclasses override the printDescription method and print unique information.

Here is a test program that creates three Bicycle variables. Each variable is assigned to one of the three bicycle classes. Each variable is then printed.

public class TestBikes { 
    public static void main(String[] args){ 
        Bicycle bike01, bike02, bike03; 
        bike01 = new Bicycle(20, 10, 1); 
        bike02 = new MountainBike(20, 10, 5, "Dual"); 
        bike03 = new RoadBike(40, 20, 8, 23); 
        bike01.printDescription(); 
        bike02.printDescription(); 
        bike03.printDescription();
    }
}

The following is the output from the test program:
Bike is in gear 1 with a cadence of 20 and travelling at a speed of 10.
Bike is in gear 5 with a cadence of 20 and travelling at a speed of 10.
The MountainBike has a Dual suspension.
Bike is in gear 8 with a cadence of 40 and travelling at a speed of 20.
The RoadBike has 23 MM tires.

---

Chapter 7 Advanced Class Features

---

7.1 Static

The static keyword is used as a modifier on variables,methods.
• The static keyword declares the attribute or method is associated with the class as a whole rather than any particular instance of that class.
• Thus static members are often called “class members,” such as “class attributes” or “class methods.”

Instance variable/method	Class Variable/method
Whenever an instance of that class is created, memory is allocated for the instance variable; each instance of the class will have its own copy of the instance variable.	Only one copy of a class variable will ever exist. That copy is shared by all instances of the class. Class variable can be accessed from outside the class if marked as public without an instance of the class.
instance method can access both instance and class variables.	A class method is a method that can access only class variables.Since class variables and class methods are not associated with any particular object, they can be used even when no objects of the class exist!class methods can be invoked on the class, you don't need an instance to call a class method.

Class variables are often used with final to define constants; this is more memory efficient than final instance variables because constants can't change, so you really only need one copy

protected static final String DISABLE = "disable";

Initializing Instance and Class Members
You can use static initializers and instance initializers to provide initial values for class and instance members when you declare them in a class:

class BedAndBreakfast { 
    static final int MAX_CAPACITY = 10; boolean full = false; 
} 

This works well for members of primitive data type. Sometimes, it even works when creating arrays and objects. But this form of initialization has limitations, as follows:

• Initializers can perform only initializations that can be expressed in an assignment statement.
• Initializers cannot call any method that can throw a checked exception.
• If the initializer calls a method that throws a runtime exception, then it cannot do error recovery.

To initialize an instance variable and cannot do it in the variable declaration for the reasons cited previously, then put the initialization in the constructor(s) for the class.

Using Static Initialization Blocks
A static initialization block is a normal block of code enclosed in braces, { }, and preceded by the static keyword. Here is an example:

static { // whatever code is needed for initialization goes here}

A class can have any number of static initialization blocks, and they can appear anywhere in the class body. The runtime system guarantees that static initialization blocks are called in the order that they appear in the source code.
• A class can contain code in a static block that does not exist within a method body.
• Static block code executes only once, when the class is loaded.
• A static block is usually used to initialize static (class) attributes

---

7.2 final

• You cannot subclass a final class.
• You cannot override a final method.
• A final variable is a constant.

Final variable
A final variable is a variable that can be assigned a value only once in a program; after that first assignment,
the variable’s value cannot be changed.

Public Static Final Variables and Interfaces
Interfaces are allowed to declare public static final variables to serve as global constants—that is, constant values that are in scope and hence accessible throughout an entire application.

Final class
You can declare that your class is final, that is, that your class cannot be subclassed. There are (at least) two reasons why you might want to do this:

• to increase system security by preventing system subversion
• One mechanism that hackers use to subvert systems is to create a subclass of a class and then substitute their class for the original.
• and for reasons of good object-oriented design.
  You may think that your class is "perfect" or that, conceptually, your class should have no subclasses.final class ChessAlgorithm { . . . }

Final Methods
You might wish to make a method final if it has an implementation that should not be changed and it is critical to the consistent state of the object

final returnType finalMethod ( [paramlist] ){
    ……
}

---

7.3 Abstract class

An abstract class is a class that is declared abstract—it may or may not include abstract methods. Abstract classes cannot be instantiated, but they can be subclassed.

An abstract method is a method that is declared without an implementation (without braces, and followed by a semicolon), like this:

abstract void moveTo(double deltaX, double deltaY);

If a class includes abstract methods, then the class itself must be declared abstract, as in:

public abstract class GraphicObject { 
// declare fields 
// declare nonabstract methods 
    abstract void draw();
}

When an abstract class is subclassed, the subclass usually provides implementations for all of the abstract methods in its parent class. However, if it does not, then the subclass must also be declared abstract.

Note: Methods in an interface (see the Interfaces section) that are not declared as default or static are implicitly abstract, so the abstract modifier is not used with interface methods. (It can be used, but it is unnecessary.)

1. Whenever a class contains one or more abstract methods, then we must declare the class abstract
2. Note that it isn’t necessary for all of the methods in an abstract class to be abstract;
3. An abstract class does not have to have abstract methods
4. An abstract method must be declared in an abstract class
5. No instance of an abstract class can be created.
6. If a subclass of an abstract class does not implement all abstract methods inherited from its parent, the subclass must also be defined as abstract.
7. An abstract class has one purpose: to act as the superclass of a class hierarchy.

---

7.4 Interface

In the Java programming language, an interface is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Method bodies exist only for default methods and static methods. Interfaces cannot be instantiated—they can only be implemented by classes or extended by other interfaces.

Defining an interface is similar to creating a new class:

public interface OperateCar { 
// constant declarations, if any
// method signatures 
// An enum with values RIGHT, LEFT 
    int turn(Direction direction, double radius, double startSpeed, double endSpeed); 
    int changeLanes(Direction direction, double startSpeed, double endSpeed); 
    int signalTurn(Direction direction, boolean signalOn); 
    int getRadarFront(double distanceToCar, double speedOfCar); 
    int getRadarRear(double distanceToCar, double speedOfCar); 
    ...... 
    // more method signatures
}

Note that the method signatures have no braces and are terminated with a semicolon.

To use an interface, you write a class that implements the interface. When an instantiable class implements an interface, it provides a method body for each of the methods declared in the interface. For example,

public class OperateBMW760i implements OperateCar { 
// the OperateCar method signatures, with implementation -- 
// for example: 
    int signalTurn(Direction direction, boolean signalOn) { 
    // code to turn BMW's LEFT turn indicator lights on 
    // code to turn BMW's LEFT turn indicator lights off 
    // code to turn BMW's RIGHT turn indicator lights on 
    // code to turn BMW's RIGHT turn indicator lights off 
    } 
    // other members, as needed -- for example, helper classes not 
    // visible to clients of the interface
}

In Java interfaces:
All methods in an interface are implicitly public and abstract. As a matter of style, the modifiers public and abstract are not used in an interface definition.

All data fields in an interface are implicitly public, static, and final. As a matter of style, the modifiers public, static, and final are not used in an interface definition.

An interface can extend another interface.

public interface MyInterface extends InterfaceOne {
    void aMethod();
}

class can only extend one class. In contrast, an interface can extend any number of interfaces:

public interface MyInterface extends Interface1, Interface2 {
    void aMethod();
}

If our intention is to declare a set of abstract method headers to a certain role within an application without imposing either data structure or concrete behavior on the subclasses, then the preferred way is interface.

An interface is more abstract than an abstract class.

Uses of Interfaces
• Simulating multiple inheritance by declaring a class that implements several interfaces
• Declaring methods that one or more classes are expected to implement
• Capturing similarities between unrelated classes without forcing a class relationship
• Determining an object’s programming interface without revealing the actual body of the class

Implementing Interfaces
When a class implements an interface, it agrees to implement all methods in the interface. If the class does not implement all the methods, the class must be defined as abstract.

Using an Interface as a Type
When you define a new interface, you are defining a new reference data type. You can use interface names anywhere you can use any other data type name.Only an instance of a class that implements the interface can be assigned to a reference variable whose type is an interface name.
Abstract Classes Compared to Interfaces
Abstract classes are similar to interfaces. You cannot instantiate them, and they may contain a mix of methods declared with or without an implementation. However, with abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods. With interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public. In addition, you can extend only one class, whether or not it is abstract, whereas you can implement any number of interfaces.

Which should you use, abstract classes or interfaces?
Consider using abstract classes if any of these statements apply to your situation:
You want to share code among several closely related classes.
You expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private).
You want to declare non-static or non-final fields. This enables you to define methods that can access and modify the state of the object to which they belong.
Consider using interfaces if any of these statements apply to your situation:
You expect that unrelated classes would implement your interface. For example, the interfacesComparable andCloneable are implemented by many unrelated classes.
You want to specify the behavior of a particular data type, but not concerned about who implements its behavior.
You want to take advantage of multiple inheritance of type.
An example of an abstract class in the JDK isAbstractMap, which is part of the Collections Framework. Its subclasses (which include HashMap, TreeMap, and ConcurrentHashMap) share many methods (including get, put, isEmpty, containsKey, and containsValue) that AbstractMap defines.
An example of a class in the JDK that implements several interfaces is HashMap, which implements the interfaces Serializable, Cloneable, and Map. By reading this list of interfaces, you can infer that an instance of HashMap (regardless of the developer or company who implemented the class) can be cloned, is serializable (which means that it can be converted into a byte stream; see the sectionSerializable Objects), and has the functionality of a map. In addition, the Map interface has been enhanced with many default methods such as merge and forEach that older classes that have implemented this interface do not have to define.
Note that many software libraries use both abstract classes and interfaces; the HashMap class implements several interfaces and also extends the abstract class AbstractMap.

Comparing Abstract Classes and Interfaces

• There are significant differences between abstract classes and interfaces:
• An abstract class can define instance variables, whereas an interface cannot.
• An abstract class can implement methods, whereas an interface cannot.
• Interfaces do not contain constructors.
• If a class extends an abstract class, it cannot extend another class; if a class implements an interface, it is free to extend another class and implement many other interfaces.
• An abstract class should be used when some implementation details, like variables and method definitions, are common to all classes in a hierarchy. In such a case, the abstract class would be the root of the class hierarchy.
• An interface should be used to define a behavior that must be implemented by classes in different hierarchies. Interfaces are the means by which unrelated classes tap the power of polymorphism because an interface—like a class—defines a type. This makes it possible for classes belonging to different hierarchies to be treated as instances of the same type.

---

7.5 Design Patterns

Design patterns describe practical solutions to common design problems that occur repeatedly in software development. A design pattern description consists of:

• A name that identifies the pattern
• A description of the problem that the pattern addresses
• A description of the solution that includes the class structures that solve the problem
• A discussion of the consequences of using the pattern

Design patterns document good design solutions that can be used for similar problems and form a shared vocabulary for problem-solving discussions.

Singleton Pattern

Description：

The singleton pattern ensures that only one instance of a class is created and provides a method to access that one instance.

Every object that uses an instance of a singleton class uses the same instance.
For example, an operating system should have only one system clock and a company should have only one accounting system.

Structure

In this pattern:

The static attribute instance contains the single instance of the class.

The constructor is defined as private so that other classes cannot create instances.

The static method getSingletonInstance returns the single instance of the class. The first time this method is called, it creates the single instance.

Consequences

The singleton pattern has the following benefits:

A singleton class can control how client code accesses the single instance. Client code does not have the freedom to use the new operator to create an instance of the singleton class. Instead, it must call a static method that returns a reference to the single instance.

A singleton class can be easily modified if requirements change and the application needs to limit the number of instances to a number other than one.

Strategy Pattern
In the strategy pattern,

each algorithm is encapsulated in its own class.

An interface that declares a method for executing an algorithm is created, and all the algorithm classes implement the interface.

Consequently, each algorithm class has its own version of the method.

When the need for a particular algorithm arises, the version of the method associated with that algorithm is invoked.

---

Chapter 8 Exception

---

8.1 What's an Exception?

*Definition: An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. *

When an error occurs within a method, the method creates an object and hands it off to the runtime system. The object, called an exception object, contains information about the error, including its type and the state of the program when the error occurred. Creating an exception object and handing it to the runtime system is called throwing an exception.

After a method throws an exception, the runtime system attempts to find something to handle it. The set of possible "somethings" to handle the exception is the ordered list of methods that had been called to get to the method where the error occurred. The list of methods is known as the call stack (see the next figure).

The runtime system searches the call stack for a method that contains a block of code that can handle the exception. This block of code is called an exception handler. The search begins with the method in which the error occurred and proceeds through the call stack in the reverse order in which the methods were called. When an appropriate handler is found, the runtime system passes the exception to the handler. An exception handler is considered appropriate if the type of the exception object thrown matches the type that can be handled by the handler.

The exception handler chosen is said to catch the exception. If the runtime system exhaustively searches all the methods on the call stack without finding an appropriate exception handler, as shown in the next figure, the runtime system (and, consequently, the program) terminates.

Robust code handles failures gracefully: continuing execution despite the problem or terminating execution after displaying an error message.

Exception handling is a mechanism that allows failures to be handled outside the normal flow of the code. The resulting code is clear, easy to read, and easy to maintain.

Error Class
When a dynamic linking failure or other hard failure in the Java virtual machine occurs, the virtual machine throws an Error. Simple programs typically do not catch or throw Errors.

Exception Class
Most programs throw and catch objects that derive from the Exception class. An Exception indicates that a problem occurred, but it is not a serious system problem. Most programs you write will throw and catch Exceptions as opposed to Errors.

The Java platform defines the many descendants of the Exception class. These descendants indicate various types of exceptions that can occur. For example, IllegalAccessException signals that a particular method could not be found, and NegativeArraySizeException indicates that a program attempted to create an array with a negative size.

One Exception subclass, RuntimeException, is reserved for exceptions that indicate incorrect use of an API. An example of a runtime exception is NullPointerException, which occurs when a method tries to access a member of an object through a null reference. The section Unchecked Exceptions — The Controversy discusses why most applications shouldn't throw runtime exceptions or subclass RuntimeException.

---

8.2 How to handle Exception?

---

8.3 The Catch or Specify Requirement

Valid Java programming language code must honor the Catch or Specify Requirement. This means that code that might throw certain exceptions must be enclosed by either of the following:

A try statement that catches the exception. The try must provide a handler for the exception, as described in Catching and Handling Exceptions.
A method that specifies that it can throw the exception. The method must provide a throws clause that lists the exception, as described in Specifying the Exceptions Thrown by a Method.

Not all exceptions are subject to the Catch or Specify Requirement. To understand why, we need to look at the three basic categories of exceptions, only one of which is subject to the Requirement.

In Java, an exception is an object that describes an abnormal situation. An exception object contains the following information:

The kind of exception

A call stack which indicates where the exception occurred
A string with additional information about the exception

Exception objects are instances of classes that descend from class Throwable. Throwable has two subclasses: Error and Exception.

Exception objects are instances of classes that descend from class Throwable. Throwable has two subclasses: Error and Exception.

Java divides exceptions in two categories: checked exceptions and unchecked exceptions.

RuntimeException, Error and their subclasses are unchecked exceptions. All other exception classes are checked exceptions.

The Three Kinds of Exceptions
The first kind of exception is the checked exception. These are exceptional conditions that a well-written application should anticipate and recover from. For example, suppose an application prompts a user for an input file name, then opens the file by passing the name to the constructor for java.io.FileReader. Normally, the user provides the name of an existing, readable file, so the construction of the FileReader object succeeds, and the execution of the application proceeds normally. But sometimes the user supplies the name of a nonexistent file, and the constructor throws java.io.FileNotFoundException. A well-written program will catch this exception and notify the user of the mistake, possibly prompting for a corrected file name.

Checked exceptions are subject to the Catch or Specify Requirement. All exceptions are checked exceptions, except for those indicated by Error, RuntimeException, and their subclasses.

The second kind of exception is the error. These are exceptional conditions that are external to the application, and that the application usually cannot anticipate or recover from. For example, suppose that an application successfully opens a file for input, but is unable to read the file because of a hardware or system malfunction. The unsuccessful read will throw java.io.IOError. An application might choose to catch this exception, in order to notify the user of the problem — but it also might make sense for the program to print a stack trace and exit.

Errors are not subject to the Catch or Specify Requirement. Errors are those exceptions indicated by Error and its subclasses.

The third kind of exception is the runtime exception. These are exceptional conditions that are internal to the application, and that the application usually cannot anticipate or recover from. These usually indicate programming bugs, such as logic errors or improper use of an API. For example, consider the application described previously that passes a file name to the constructor for FileReader. If a logic error causes a null to be passed to the constructor, the constructor will throw NullPointerException. The application can catch this exception, but it probably makes more sense to eliminate the bug that caused the exception to occur.

Runtime exceptions are not subject to the Catch or Specify Requirement. Runtime exceptions are those indicated by RuntimeException and its subclasses.

Errors and runtime exceptions are collectively known as unchecked exceptions.

Bypassing Catch or Specify
Some programmers consider the Catch or Specify Requirement a serious flaw in the exception mechanism and bypass it by using unchecked exceptions in place of checked exceptions. In general, this is not recommended. The section Unchecked Exceptions — The Controversy talks about when it is appropriate to use unchecked exceptions.

---

8.4 The try-catch-finally block

The try block
The first step in constructing an exception handler is to enclose the code that might throw an exception within a try block. In general, a try block looks like the following:

try {
    code
}
catch and finally blocks . . .

The segment in the example labeled code contains one or more legal lines of code that could throw an exception. (The catch and finally blocks are explained in the next two subsections.)

If an exception occurs within the try block, that exception is handled by an exception handler associated with it. To associate an exception handler with a try block, you must put a catch block after it; the next section, The catch Blocks, shows you how.

The catch block
You associate exception handlers with a try block by providing one or more catch blocks directly after the try block. No code can be between the end of the try block and the beginning of the first catch block.

try {
} catch (ExceptionType name) {
} catch (ExceptionType name) {
}

Each catch block is an exception handler that handles the type of exception indicated by its argument. The argument type, ExceptionType, declares the type of exception that the handler can handle and must be the name of a class that inherits from the Throwable class. The handler can refer to the exception with name.

The catch block contains code that is executed if and when the exception handler is invoked. The runtime system invokes the exception handler when the handler is the first one in the call stack whose ExceptionType matches the type of the exception thrown. The system considers it a match if the thrown object can legally be assigned to the exception handler's argument.

Exception handlers can do more than just print error messages or halt the program. They can do error recovery, prompt the user to make a decision, or propagate the error up to a higher-level handler using chained exceptions, as described in the Chained Exceptions section.

Catching More Than One Type of Exception with One Exception Handler
In Java SE 7 and later, a single catch block can handle more than one type of exception. This feature can reduce code duplication and lessen the temptation to catch an overly broad exception.
In the catch clause, specify the types of exceptions that block can handle, and separate each exception type with a vertical bar (|):

catch (IOException|SQLException ex) {
    logger.log(ex);
    throw ex;
}

Note: If a catch block handles more than one exception type, then the catch parameter is implicitly final. In this example, the catch parameter ex is final and therefore you cannot assign any values to it within the catch block.

try block must be immediately followed by at least one catch or finally block.

As long as the code in the try block executes without error, all of the catch blocks are bypassed, and execution of our program continues after the end of the last catch block

If, on the other hand, an exception is thrown by the JVM while executing the try block, execution of the try block abruptly terminates as of the line on which the exception occurred.

The finally block
The finally block always executes when the try block exits. This ensures that the finally block is executed even if an unexpected exception occurs. But finally is useful for more than just exception handling — it allows the programmer to avoid having cleanup code accidentally bypassed by a return, continue, or break. Putting cleanup code in a finally block is always a good practice, even when no exceptions are anticipated.

Note: If the JVM exits while the try or catch code is being executed, then the finally block may not execute. Likewise, if the thread executing the try or catch code is interrupted or killed, the finally block may not execute even though the application as a whole continues.

The try block of the writeList method that you've been working with here opens a PrintWriter. The program should close that stream before exiting the writeList method. This poses a somewhat complicated problem because writeList's try block can exit in one of three ways.

Important: The finally block is a key tool for preventing resource leaks. When closing a file or otherwise recovering resources, place the code in a finally block to ensure that resource is always recovered.

Consider using the try-with-resources statement in these situations, which automatically releases system resources when no longer needed. The The try-with-resources Statement section has more information.

A try block may optionally have a finally block associated with it.

The code within a finally block is guaranteed to execute no matter what happens in the try/catch code that precedes :

The try block executes to completion without throwing any exceptions whatsoever.

The try block throws an exception that is handled by one of the catch blocks.

The try block throws an exception that is not handled by any of the catch blocks

---

8.5 The throws-clause

If a checked exception might occur in a method and the method does not have catch block to handle the checked exception, then the checked exception must be declared in the method header using a throws-clause,returnType methodName([paramlist]) throws exceptionList

Before you can catch an exception, some Java code somewhere must throw one.

Any Java code can throw an exception:

• your code
• code from a package written by someone else (such as the packages that come with the Java development environment),
• or the Java runtime system.

throw　new ThrowableObject；

Example :

    public Object pop() throws EmptyStackException {
        Object obj;
        if (size == 0)
        throw new EmptyStackException();
        obj = objectAt(size - 1);
        setObjectAt(size - 1, null);
        size--;
        return obj;
    }

---

8.6 Method overriding and Exception

---

8.7 Creating your own Exception classes

When faced with choosing the type of exception to throw, you have two choices:
- Use one written by someone else. The Java development environment provides a lot of exception classes that you could use.
- Write one of your own.

---

8.8 Conclusion

By using exceptions to manage errors, Java programs have the following advantages over traditional error management techniques:

• Advantage 1: Separating Error Handling Code from "Regular" Code
• Advantage 2: Propagating Errors Up the Call Stack
• Advantage 3: Grouping Error Types and Error Differentiation

---

Chapter 9 Collections and Generics Framework

---

9.1 What is Collection?

A collection — sometimes called a container — is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve, manipulate, and communicate aggregate data.

Collections Organize References to Other Objects
The objects being organized by a collection live physically outside of the collection in the JVM’s memory; only their handles reside inside of the collection.

Collections Are Encapsulated
All collections provide, at a minimum, methods for

• Adding objects
• Removing objects
• Retrieving specific individual objects
• Iterating through the objects in some predetermined order
• Getting a count of the number of objects presently referenced by the collection
• Answering a true/false question as to whether a particular object’s reference is in the collection or not

---

9.2 What Is a Collections Framework?

A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain the following:

Interfaces: These are abstract data types that represent collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages, interfaces generally form a hierarchy.

Implementations: These are the concrete implementations of the collection interfaces. In essence, they are reusable data structures.

Algorithms: These are the methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. The algorithms are said to be polymorphic: that is, the same method can be used on many different implementations of the appropriate collection interface. In essence, algorithms are reusable functionality.

The core collections interfaces are shown below:

A Set is a special kind of Collection, a SortedSet is a special kind of Set, and so forth.A Set is a Collection that cannot contain duplicate elements.Note also that the hierarchy consists of two distinct trees — a Map is not a true Collection.

Note that all the core collection interfaces are generic. For example, this is the declaration of the Collection interface.

public interface Collection...
The syntax tells you that the interface is generic. When you declare a Collection instance you can and should specify the type of object contained in the collection. Specifying the type allows the compiler to verify (at compile-time) that the type of object you put into the collection is correct, thus reducing errors at runtime. For information on generic types, see the Generics (Updated) lesson.

To keep the number of core collection interfaces manageable, the Java platform doesn't provide separate interfaces for each variant of each collection type. (Such variants might include immutable, fixed-size, and append-only.) Instead, the modification operations in each interface are designated optional — a given implementation may elect not to support all operations. If an unsupported operation is invoked, a collection throws an UnsupportedOperationException.

Implementations are responsible for documenting which of the optional operations they support. All of the Java platform's general-purpose implementations support all of the optional operations.

The following list describes the core collection interfaces:

Collection — the root of the collection hierarchy. A collection represents a group of objects known as its elements. The Collection interface is the least common denominator that all collections implement and is used to pass collections around and to manipulate them when maximum generality is desired. Some types of collections allow duplicate elements, and others do not. Some are ordered and others are unordered. The Java platform doesn't provide any direct implementations of this interface but provides implementations of more specific subinterfaces, such as Set and List.

Set — An unordered collection; no duplicates are permitted(a collection that cannot contain duplicate elements). This interface models the mathematical set abstraction and is used to represent sets, such as the cards comprising a poker hand, the courses making up a student's schedule, or the processes running on a machine.

List — an ordered collection (sometimes called a sequence). Lists can contain duplicate elements. The user of a List generally has precise control over where in the list each element is inserted and can access elements by their integer index (position). If you've used Vector, you're familiar with the general flavor of List. Also see The List Interface section.

Queue — a collection used to hold multiple elements prior to processing. Besides basic Collection operations, a Queue provides additional insertion, extraction, and inspection operations.

Queues typically, but do not necessarily, order elements in a FIFO (first-in, first-out) manner. Among the exceptions are priority queues, which order elements according to a supplied comparator or the elements' natural ordering. Whatever the ordering used, the head of the queue is the element that would be removed by a call to remove or poll. In a FIFO queue, all new elements are inserted at the tail of the queue. Other kinds of queues may use different placement rules. Every Queue implementation must specify its ordering properties.

Deque — a collection used to hold multiple elements prior to processing. Besides basic Collection operations, a Deque provides additional insertion, extraction, and inspection operations.

Deques can be used both as FIFO (first-in, first-out) and LIFO (last-in, first-out). In a deque all new elements can be inserted, retrieved and removed at both ends. Also see The Deque Interface section.

Map — an object that maps keys to values. A Map cannot contain duplicate keys; each key can map to at most one value. If you've used Hashtable, you're already familiar with the basics of Map. Also see The Map Interface section.

The last two core collection interfaces are merely sorted versions of Set and Map:
SortedSet — a Set that maintains its elements in ascending order. Several additional operations are provided to take advantage of the ordering. Sorted sets are used for naturally ordered sets, such as word lists and membership rolls. Also see The SortedSet Interface section.

SortedMap — a Map that maintains its mappings in ascending key order. This is the Map analog of SortedSet. Sorted maps are used for naturally ordered collections of key/value pairs, such as dictionaries and telephone directories. Also see The SortedMap Interface section.

---

9.3 The Collection Interface

The Collection interface contains methods that perform basic operations, such as int size(), boolean isEmpty(), boolean contains(Object element), boolean add(E element), boolean remove(Object element), and Iterator iterator().

It also contains methods that operate on entire collections, such as boolean containsAll(Collection c), boolean addAll(Collection c), boolean removeAll(Collection c), boolean retainAll(Collection c), and void clear().

Additional methods for array operations (such as Object[] toArray() and T[] toArray(T[] a) exist as well.

The Collection interface does about what you'd expect given that a Collection represents a group of objects. It has methods that tell you how many elements are in the collection (size, isEmpty), methods that check whether a given object is in the collection (contains), methods that add and remove an element from the collection (add, remove), and methods that provide an iterator over the collection (iterator).

The add method is defined generally enough so that it makes sense for collections that allow duplicates as well as those that don't. It guarantees that the Collection will contain the specified element after the call completes, and returns true if the Collection changes as a result of the call. Similarly, the remove method is designed to remove a single instance of the specified element from the Collection, assuming that it contains the element to start with, and to return true if the Collection was modified as a result.

Traversing Collections

There are three ways to traverse collections: (1) using aggregate operations (2) with the for-each construct and (3) by using Iterators.

Aggregate Operations
In JDK 8 and later, the preferred method of iterating over a collection is to obtain a stream and perform aggregate operations on it. Aggregate operations are often used in conjunction with lambda expressions to make programming more expressive, using less lines of code. The following code sequentially iterates through a collection of shapes and prints out the red objects:

myShapesCollection.stream()
.filter(e -> e.getColor() == Color.RED)
.forEach(e -> System.out.println(e.getName()));

Likewise, you could easily request a parallel stream, which might make sense if the collection is large enough and your computer has enough cores:

myShapesCollection.parallelStream()
.filter(e -> e.getColor() == Color.RED)
.forEach(e -> System.out.println(e.getName()));

There are many different ways to collect data with this API. For example, you might want to convert the elements of a Collection to String objects, then join them, separated by commas:

    String joined = elements.stream()
    .map(Object::toString)
    .collect(Collectors.joining(", "));

Or perhaps sum the salaries of all employees:

int total = employees.stream()
.collect(Collectors.summingInt(Employee::getSalary)));

These are but a few examples of what you can do with streams and aggregate operations.

The Collections framework has always provided a number of so-called "bulk operations" as part of its API. These include methods that operate on entire collections, such as containsAll, addAll, removeAll, etc. Do not confuse those methods with the aggregate operations that were introduced in JDK 8. The key difference between the new aggregate operations and the existing bulk operations (containsAll, addAll, etc.) is that the old versions are all mutative, meaning that they all modify the underlying collection. In contrast, the new aggregate operations do not modify the underlying collection. When using the new aggregate operations and lambda expressions, you must take care to avoid mutation so as not to introduce problems in the future, should your code be run later from a parallel stream.

for-each Construct
The for-each construct allows you to concisely traverse a collection or array using a for loop — see The for Statement. The following code uses the for-each construct to print out each element of a collection on a separate line.

for (Object o : collection)
    System.out.println(o);

Iterators
An Iterator is an object that enables you to traverse through a collection and to remove elements from the collection selectively, if desired. You get an Iterator for a collection by calling its iterator method. The following is the Iterator interface.

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove(); //optional
}

The hasNext method returns true if the iteration has more elements, and the next method returns the next element in the iteration. The remove method removes the last element that was returned by next from the underlying Collection. The remove method may be called only once per call to next and throws an exception if this rule is violated.

Note that Iterator.remove is the only safe way to modify a collection during iteration; the behavior is unspecified if the underlying collection is modified in any other way while the iteration is in progress.

Use Iterator instead of the for-each construct when you need to:

• Remove the current element. The for-each construct hides the iterator, so you cannot call remove. Therefore, the for-each construct is not usable for filtering.
• Iterate over multiple collections in parallel.

The following method shows you how to use an Iterator to filter an arbitrary Collection — that is, traverse the collection removing specific elements.

static void filter(Collection<?> c) {
    for (Iterator<?> it = c.iterator(); it.hasNext(); )
        if (!cond(it.next()))
            it.remove();
}

This simple piece of code is polymorphic, which means that it works for any Collection regardless of implementation. This example demonstrates how easy it is to write a polymorphic algorithm using the Java Collections Framework.

Collection Interface Bulk Operations
Bulk(主体) operations perform an operation on an entire Collection. You could implement these shorthand operations using the basic operations, though in most cases such implementations would be less efficient. The following are the bulk operations:

• containsAll — returns true if the target Collection contains all of the elements in the specified Collection.
• addAll — adds all of the elements in the specified Collection to the target Collection.
• removeAll — removes from the target Collection all of its elements that are also contained in the specified Collection.
• retainAll — removes from the target Collection all its elements that are not also contained in the specified Collection. That is, it retains only those elements in the target Collection that are also contained in the specified Collection.
• clear — removes all elements from the Collection.

The addAll, removeAll, and retainAll methods all return true if the target Collection was modified in the process of executing the operation.

As a simple example of the power of bulk operations, consider the following idiom to remove all instances of a specified element, e, from a Collection, c.

c.removeAll(Collections.singleton(e));

More specifically, suppose you want to remove all of the null elements from a Collection.

c.removeAll(Collections.singleton(null));

This idiom uses Collections.singleton, which is a static factory method that returns an immutable Set containing only the specified element.

Collection Interface Array Operations
The toArray methods are provided as a bridge between collections and older APIs that expect arrays on input. The array operations allow the contents of a Collection to be translated into an array. The simple form with no arguments creates a new array of Object. The more complex form allows the caller to provide an array or to choose the runtime type of the output array.

For example, suppose that c is a Collection. The following snippet dumps the contents of c into a newly allocated array of Object whose length is identical to the number of elements in c.

Object[] a = c.toArray();

Suppose that c is known to contain only strings (perhaps because c is of type Collection). The following snippet dumps the contents of c into a newly allocated array of String whose length is identical to the number of elements in c.

String[] a = c.toArray(new String[0]);

---

9.4 The Set Interface

A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction. The Set interface contains only methods inherited from Collection and adds the restriction that duplicate elements are prohibited. Set also adds a stronger contract on the behavior of the equals and hashCode operations, allowing Set instances to be compared meaningfully even if their implementation types differ. Two Set instances are equal if they contain the same elements.

The Java platform contains three general-purpose Set implementations: HashSet, TreeSet, and LinkedHashSet. HashSet, which stores its elements in a hash table, is the best-performing implementation; however it makes no guarantees concerning the order of iteration. TreeSet, which stores its elements in a red-black tree, orders its elements based on their values; it is substantially slower than HashSet. LinkedHashSet, which is implemented as a hash table with a linked list running through it, orders its elements based on the order in which they were inserted into the set (insertion-order). LinkedHashSet spares its clients from the unspecified, generally chaotic ordering provided by HashSet at a cost that is only slightly higher.

---

9.5 The List Interface

A List is an ordered Collection (sometimes called a sequence). Lists may contain duplicate elements. In addition to the operations inherited from Collection, the List interface includes operations for the following:

• Positional access — manipulates elements based on their numerical position in the list. This includes methods such as get, set, add, addAll, and remove.
• Search — searches for a specified object in the list and returns its numerical position. Search methods include indexOf and lastIndexOf.
• Iteration — extends Iterator semantics to take advantage of the list's sequential nature. The listIterator methods provide this behavior.
• Range-view — The sublist method performs arbitrary range operations on the list.

The Java platform contains two general-purpose List implementations. ArrayList, which is usually the better-performing implementation, and LinkedList which offers better performance under certain circumstances.

Iterators
As you'd expect, the Iterator returned by List's iterator operation returns the elements of the list in proper sequence. List also provides a richer iterator, called a ListIterator, which allows you to traverse the list in either direction, modify the list during iteration, and obtain the current position of the iterator.

The three methods that ListIterator inherits from Iterator (hasNext, next, and remove) do exactly the same thing in both interfaces. The hasPrevious and the previous operations are exact analogues of hasNext and next. The former operations refer to the element before the (implicit) cursor, whereas the latter refer to the element after the cursor. The previous operation moves the cursor backward, whereas next moves it forward.
Here's the standard idiom for iterating backward through a list.

for (ListIterator<Type> it = list.listIterator(list.size()); it.hasPrevious(); ) {
    Type t = it.previous();
    ...
}

Note the argument to listIterator in the preceding idiom. The List interface has two forms of the listIterator method. The form with no arguments returns a ListIterator positioned at the beginning of the list; the form with an int argument returns a ListIterator positioned at the specified index. The index refers to the element that would be returned by an initial call to next. An initial call to previous would return the element whose index was index-1. In a list of length n, there are n+1 valid values for index, from 0 to n, inclusive.
Intuitively speaking, the cursor is always between two elements — the one that would be returned by a call to previous and the one that would be returned by a call to next. The n+1 valid index values correspond to the n+1 gaps between elements, from the gap before the first element to the gap after the last one. The following figure shows the five possible cursor positions in a list containing four elements.

The five possible cursor positions.

Calls to next and previous can be intermixed, but you have to be a bit careful. The first call to previous returns the same element as the last call to next. Similarly, the first call to next after a sequence of calls to previous returns the same element as the last call to previous.

Scanner 实现了所有的Iterator接口

---

9.6 The Map Interface

A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value.

It models the mathematical function abstraction. The Map interface includes methods for basic operations (such as put, get, remove, containsKey, containsValue, size, and empty), bulk operations (such as putAll and clear), and collection views (such as keySet, entrySet, and values).

The Java platform contains three general-purpose Map implementations: HashMap, TreeMap, and LinkedHashMap. Their behavior and performance are precisely analogous to HashSet, TreeSet, and LinkedHashSet, as described in The Set Interface section.

• TreeMaps are very similar to HashMaps，with one notable difference:
• TreeMap：objects are automatically retrieved from the collection in ascending key (sorted) order.
• HashMap：there’s no guarantee the order

---

9.7 Generics

Generics are described as follows:

• Provides compile-time type safety
• Eliminate the need for cast
• Provide the ability to create compiler-checked homogeneous collections

---

9.8 The comparable and comparator interfaces

A List l may be sorted as follows.

Collections.sort(l);

If the List consists of String elements, it will be sorted into alphabetical order. If it consists of Date elements, it will be sorted into chronological order. How does this happen? String and Date both implement the Comparable interface. Comparable implementations provide a natural ordering for a class, which allows objects of that class to be sorted automatically. The following table summarizes some of the more important Java platform classes that implement Comparable.

If you try to sort a list, the elements of which do not implement Comparable, Collections.sort(list) will throw a ClassCastException. Similarly, Collections.sort(list, comparator) will throw a ClassCastException if you try to sort a list whose elements cannot be compared to one another using the comparator. Elements that can be compared to one another are called mutually comparable. Although elements of different types may be mutually comparable, none of the classes listed here permit interclass comparison.

This is all you really need to know about the Comparable interface if you just want to sort lists of comparable elements or to create sorted collections of them. The next section will be of interest to you if you want to implement your own Comparable type.

The Comparable interface supports one method: compareTo.

method compares this object to the element parameter.
If this is a "less than" element, then a negative value is returned;
if this is a "greater than" element, then a positive value is returned;
otherwise zero is

Writing Your Own Comparable Types
The Comparable interface consists of the following method.

public interface Comparable<T> {
    public int compareTo(T o);
}

The compareTo method compares the receiving object with the specified object and returns a negative integer, 0, or a positive integer depending on whether the receiving object is less than, equal to, or greater than the specified object. If the specified object cannot be compared to the receiving object, the method throws a ClassCastException.
The following class representing a person's name implements Comparable.

import java.util.*;
public class Name implements Comparable<Name> {
    private final String firstName, lastName;
    public Name(String firstName, String lastName) {
        if (firstName == null || lastName == null)
            throw new NullPointerException();
        this.firstName = firstName;
        this.lastName = lastName;
    }
    public String firstName() { return firstName; }
    public String lastName()  { return lastName;  }
    public boolean equals(Object o) {
        if (!(o instanceof Name))
            return false;
        Name n = (Name) o;
        return n.firstName.equals(firstName) && n.lastName.equals(lastName);
    }
    public int hashCode() {
        return 31*firstName.hashCode() + lastName.hashCode();
    }
    public String toString() {
    return firstName + " " + lastName;
    }
    public int compareTo(Name n) {
        int lastCmp = lastName.compareTo(n.lastName);
        return (lastCmp != 0 ? lastCmp : firstName.compareTo(n.firstName));
    }
}

Since this section is about element ordering, let's talk a bit more about Name's compareTo method. It implements the standard name-ordering algorithm, where last names take precedence over first names. This is exactly what you want in a natural ordering. It would be very confusing indeed if the natural ordering were unnatural!

Take a look at how compareTo is implemented, because it's quite typical. First, you compare the most significant part of the object (in this case, the last name). Often, you can just use the natural ordering of the part's type. In this case, the part is a String and the natural (lexicographic) ordering is exactly what's called for. If the comparison results in anything other than zero, which represents equality, you're done: You just return the result. If the most significant parts are equal, you go on to compare the next most-significant parts. In this case, there are only two parts — first name and last name. If there were more parts, you'd proceed in the obvious fashion, comparing parts until you found two that weren't equal or you were comparing the least-significant parts, at which point you'd return the result of the comparison.
Just to show that it all works, here's a program that builds a list of names and sorts them.

import java.util.*;
public class NameSort {
    public static void main(String[] args) {
        Name nameArray[] = {
            new Name("John", "Smith"),
            new Name("Karl", "Ng"),
            new Name("Jeff", "Smith"),
            new Name("Tom", "Rich")
        };
        List<Name> names = Arrays.asList(nameArray);
        Collections.sort(names);
        System.out.println(names);
    }
}

If you run this program, here's what it prints.
[Karl Ng, Tom Rich, Jeff Smith, John Smith]

Comparators
What if you want to sort some objects in an order other than their natural ordering? Or what if you want to sort some objects that don't implement Comparable? To do either of these things, you'll need to provide a Comparator — an object that encapsulates an ordering. Like the Comparable interface, the Comparator interface consists of a single method.

public interface Comparator<T> {
    int compare(T o1, T o2);
}

The compare method compares its two arguments, returning a negative integer, 0, or a positive integer depending on whether the first argument is less than, equal to, or greater than the second. If either of the arguments has an inappropriate type for the Comparator, the compare method throws a ClassCastException.

Much of what was said about Comparable applies to Comparator as well. Writing a compare method is nearly identical to writing a compareTo method, except that the former gets both objects passed in as arguments. The compare method has to obey the same four technical restrictions as Comparable's compareTo method for the same reason — a Comparator must induce a total order on the objects it compares.

Suppose you have a class called Employee, as follows.

public class Employee implements Comparable<Employee> {
    public Name name()     { ... }
    public int number()    { ... }
    public Date hireDate() { ... }
       ...
}

Let's assume that the natural ordering of Employee instances is Name ordering (as defined in the previous example) on employee name. Unfortunately, the boss has asked for a list of employees in order of seniority. This means we have to do some work, but not much. The following program will produce the required list.

import java.util.*;
public class EmpSort {
    static final Comparator<Employee> SENIORITY_ORDER = 
                                        new Comparator<Employee>() {
            public int compare(Employee e1, Employee e2) {
                return e2.hireDate().compareTo(e1.hireDate());
            }
    };
    // Employee database
    static final Collection<Employee> employees = ... ;
    public static void main(String[] args) {
        List<Employee> e = new ArrayList<Employee>(employees);
        Collections.sort(e, SENIORITY_ORDER);
        System.out.println(e);
    }
}

The Comparator in the program is reasonably straightforward. It relies on the natural ordering of Date applied to the values returned by the hireDate accessor method. Note that the Comparator passes the hire date of its second argument to its first rather than vice versa. The reason is that the employee who was hired most recently is the least senior; sorting in the order of hire date would put the list in reverse seniority order. Another technique people sometimes use to achieve this effect is to maintain the argument order but to negate the result of the comparison.

// Don't do this!!
return -r1.hireDate().compareTo(r2.hireDate());

You should always use the former technique in favor of the latter because the latter is not guaranteed to work. The reason for this is that the compareTo method can return any negative int if its argument is less than the object on which it is invoked. There is one negative int that remains negative when negated, strange as it may seem.

-Integer.MIN_VALUE == Integer.MIN_VALUE
The Comparator in the preceding program works fine for sorting a List, but it does have one deficiency: It cannot be used to order a sorted collection, such as TreeSet, because it generates an ordering that is not compatible with equals. This means that this Comparator equates objects that the equals method does not. In particular, any two employees who were hired on the same date will compare as equal. When you're sorting a List, this doesn't matter; but when you're using the Comparator to order a sorted collection, it's fatal. If you use this Comparator to insert multiple employees hired on the same date into a TreeSet, only the first one will be added to the set; the second will be seen as a duplicate element and will be ignored.

To fix this problem, simply tweak the Comparator so that it produces an ordering that is compatible with equals. In other words, tweak it so that the only elements seen as equal when using compare are those that are also seen as equal when compared using equals. The way to do this is to perform a two-part comparison (as for Name), where the first part is the one we're interested in — in this case, the hire date — and the second part is an attribute that uniquely identifies the object. Here the employee number is the obvious attribute. This is the Comparator that results.

static final Comparator<Employee> SENIORITY_ORDER = 
                                        new Comparator<Employee>() {
    public int compare(Employee e1, Employee e2) {
        int dateCmp = e2.hireDate().compareTo(e1.hireDate());
        if (dateCmp != 0)
            return dateCmp;
        return (e1.number() < e2.number() ? -1 :
               (e1.number() == e2.number() ? 0 : 1));
    }
};

One last note: You might be tempted to replace the final return statement in the Comparator with the simpler:
return e1.number() - e2.number();

Don't do it unless you're absolutely sure no one will ever have a negative employee number! This trick does not work in general because the signed integer type is not big enough to represent the difference of two arbitrary signed integers. If i is a large positive integer and j is a large negative integer, i - j will overflow and will return a negative integer. The resulting comparator violates one of the four technical restrictions we keep talking about (transitivity) and produces horrible, subtle bugs. This is not a purely theoretical concern; people get burned by it.

---

Chapter 10 I/O:Reading and Writing

---

10.1 Overview of I/O Streams

To bring in information, a program opens a stream on an information source (a file, memory, a socket) and reads the information sequentially, as shown here:

Similarly, a program can send information to an external destination by opening a stream to a destination and writing the information out sequentially, like this:
![图片2.png-7.2kB]

No matter where the data is coming from or going to and no matter what its type, the algorithms for sequentially reading and writing data are basically the same:

The java.io package contains a collection of stream classes that support these algorithms for reading and writing.

The stream classes are divided into two class hierarchies, based on the data type (either characters or bytes) on which they operate.

Reader and Writer are the abstract superclasses for 16-bit character streams in java.io.

InputStream and OutputStream are the abstract superclasses for 8-bit byte streams in java.io.

These streams are typically used to read and write binary data such as images and sounds

---

10.2 Understanding the I/O Superclasses

Reader and InputStream define similar APIs but for different data types.
Reader contains these methods for reading characters and arrays of characters:

InputStream defines the same methods but for reading bytes and arrays of bytes:

---

10.3 Node streams and Process streams

Types of Node Streams

A processing stream performs some sort of conversion on another
stream. Processing streams are also known as filter streams.

This allows you to convert the raw data into a more usable form for your application.

---

10.4 File Stream I/O

• File input:
  Use the FileReader class to read characters
  Use the BufferedReader class to use the readLine method

• File output:
  Use the FileWriter class to write characters
  Use the PrintWriter class to use the print and println methods

BufferedReader fileIn =
    new BufferedReader(new FileReader(filename));
PrintWriter fileOut =
    new PrintWriter(new FileWriter(filename));

---

10.5 Scanner Class

---

10.6 RandomAccessFile

RandomAccessFile is used for both reading and writing files and it doesn't inherit from the InputStream or OutputStream.

RandomAccessFile supports the notion of a file pointer. The file pointer indicates the current location in the file. When the file is first created, the file pointer is set to 0, indicating the beginning of the file.Calls to the read and write methods adjust the file pointer by the number of bytes read or written.

Create a randomaccessfile
myRAFile = new RandomAccessFile(String name, String mode);
myRAFile = new RandomAccessFile(File file, String mode);

example：

new RandomAccessFile("farrago.txt", "r"); 
new RandomAccessFile("farrago.txt", "rw"); 

int skipBytes(int)--Moves the file pointer forward the specified number of bytes
void seek(long)--Positions the file pointer just before the specified byte
long getFilePointer()--Returns the current byte location of the file pointer

---

10.7 Serialization

---

Chapter 11 Swing

---

11.1 Top-Level Containers

Swing provides three generally useful top-level container classes: JFrame, JDialog, and JApplet.

When using these classes, you should keep these facts in mind:
To appear onscreen, every GUI component must be part of a containment hierarchy（层次结构）. A containment hierarchy is a tree of components that has a top-level container as its root. We'll show you one in a bit.

Each GUI component can be contained only once. If a component is already in a container and you try to add it to another container, the component will be removed from the first container and then added to the second.

Each top-level container has a content pane that, generally speaking, contains (directly or indirectly) the visible components in that top-level container's GUI.

You can optionally add a menu bar to a top-level container. The menu bar is by convention positioned within the top-level container, but outside the content pane. Some look and feels, such as the Mac OS look and feel, give you the option of placing the menu bar in another place more appropriate for the look and feel, such as at the top of the screen.

Top-Level Containers and Containment Hierarchies
Each program that uses Swing components has at least one top-level container. This top-level container is the root of a containment hierarchy — the hierarchy that contains all of the Swing components that appear inside the top-level container.
As a rule, a standalone application with a Swing-based GUI has at least one containment hierarchy with a JFrame as its root. For example, if an application has one main window and two dialogs, then the application has three containment hierarchies, and thus three top-level containers. One containment hierarchy has a JFrame as its root, and each of the other two has a JDialog object as its root.

Adding Components to the Content Pane
Here's the code that the preceding example uses to get a frame's content pane and add the yellow label to it:

frame.getContentPane().add(yellowLabel, BorderLayout.CENTER);

As the code shows, you find the content pane of a top-level container by calling the getContentPane method. The default content pane is a simple intermediate(中间) container that inherits from JComponent, and that uses a BorderLayout as its layout manager.

It's easy to customize（自定义）the content pane — setting the layout manager or adding a border, for example. However, there is one tiny gotcha（疑难杂症）. The getContentPane method returns a Container object, not a JComponent object. This means that if you want to take advantage of the content pane's JComponent features, you need to either typecast the return value or create your own component to be the content pane. Our examples generally take the second approach, since it's a little cleaner. Another approach we sometimes take is to simply add a customized component to the content pane, covering the content pane completely.

Note that the default layout manager for JPanel is FlowLayout; you'll probably want to change it.

Adding a Menu Bar
To add a menu bar to a top-level container, create a JMenuBar object, populate it with menus, and then call setJMenuBar. The TopLevelDemo adds a menu bar to its frame with this code:

frame.setJMenuBar(greenMenuBar);

A menu provides a space-saving way to let the user choose one of several options. Other components with which the user can make a one-of-many choice include combo boxes, lists, radio buttons, spinners, and tool bars. If any of your menu items performs an action that is duplicated by another menu item or by a tool-bar button.

Menus are unique in that, by convention, they aren't placed with the other components in the UI. Instead, a menu usually appears either in a menu bar or as a popup menu. A menu bar contains one or more menus and has a customary, platform-dependent location — usually along the top of a window. A popup menu is a menu that is invisible until the user makes a platform-specific mouse action, such as pressing the right mouse button, over a popup-enabled component. The popup menu then appears under the cursor.

The following figure shows many menu-related components: a menu bar, menus, menu items, radio button menu items, check box menu items, and separators. As you can see, a menu item can have either an image or text, or both. You can also specify other properties, such as font and color.

The Menu Component Hierarchy
Here is a picture of the inheritance hierarchy for the menu-related classes:

As the figure shows, menu items (including menus) are simply buttons.

The following code creates the menus shown near the beginning of this menu section.

//Where the GUI is created:
JMenuBar menuBar;
JMenu menu, submenu;
JMenuItem menuItem;
JRadioButtonMenuItem rbMenuItem;
JCheckBoxMenuItem cbMenuItem;
//Create the menu bar.
menuBar = new JMenuBar();
//Build the first menu.
menu = new JMenu("A Menu");
menu.setMnemonic(KeyEvent.VK_A);//设置热键
menu.getAccessibleContext().setAccessibleDescription(
        "The only menu in this program that has menu items");
menuBar.add(menu);
//a group of JMenuItems
menuItem = new JMenuItem("A text-only menu item",
                         KeyEvent.VK_T);
menuItem.setAccelerator(KeyStroke.getKeyStroke(
        KeyEvent.VK_1, ActionEvent.ALT_MASK));
menuItem.getAccessibleContext().setAccessibleDescription(
        "This doesn't really do anything");
menu.add(menuItem);
menuItem = new JMenuItem("Both text and icon",
                         new ImageIcon("images/middle.gif"));
menuItem.setMnemonic(KeyEvent.VK_B);
menu.add(menuItem);
menuItem = new JMenuItem(new ImageIcon("images/middle.gif"));
menuItem.setMnemonic(KeyEvent.VK_D);
menu.add(menuItem);
//a group of radio button menu items
单选框要添加到group
但group是一个抽象集合
要单独添加到jMenu
menu.addSeparator();
ButtonGroup group = new ButtonGroup();
rbMenuItem = new JRadioButtonMenuItem("A radio button menu item");
rbMenuItem.setSelected(true);
rbMenuItem.setMnemonic(KeyEvent.VK_R);
group.add(rbMenuItem);
menu.add(rbMenuItem);
rbMenuItem = new JRadioButtonMenuItem("Another one");
rbMenuItem.setMnemonic(KeyEvent.VK_O);
group.add(rbMenuItem);
menu.add(rbMenuItem);
//a group of check box menu items
menu.addSeparator();
cbMenuItem = new JCheckBoxMenuItem("A check box menu item");
cbMenuItem.setMnemonic(KeyEvent.VK_C);
menu.add(cbMenuItem);
cbMenuItem = new JCheckBoxMenuItem("Another one");
cbMenuItem.setMnemonic(KeyEvent.VK_H);
menu.add(cbMenuItem);
//a submenu
menu.addSeparator();
submenu = new JMenu("A submenu");
submenu.setMnemonic(KeyEvent.VK_S);
menuItem = new JMenuItem("An item in the submenu");
menuItem.setAccelerator(KeyStroke.getKeyStroke(
        KeyEvent.VK_2, ActionEvent.ALT_MASK));
submenu.add(menuItem);
menuItem = new JMenuItem("Another item");
submenu.add(menuItem);
menu.add(submenu);
//Build second menu in the menu bar.
menu = new JMenu("Another Menu");
menu.setMnemonic(KeyEvent.VK_N);
menu.getAccessibleContext().setAccessibleDescription(
        "This menu does nothing");
menuBar.add(menu);
...
frame.setJMenuBar(theJMenuBar);

As the code shows, to set the menu bar for a JFrame, you use the setJMenuBar method. To add a JMenu to a JMenuBar, you use the add(JMenu) method. To add menu items and submenus to a JMenu, you use the add(JMenuItem) method.

1. Create a JMenuBar object, and set it into a menu container, such as a JFrame.
2. Create one or more JMenu objects, and add them to the menu bar object.
3. Create one or more JMenuItem objects, and add them to the menu object.

The Root Pane
Each top-level container relies on a reclusive intermediate container called the root pane. The root pane manages the content pane and the menu bar, along with a couple of other containers. You generally don't need to know about root panes to use Swing components. However, if you ever need to intercept mouse clicks or paint over multiple components, you should get acquainted with root panes.

We've already told you about the content pane and the optional menu bar. The two other components that a root pane adds are a layered pane and a glass pane. The layered pane contains the menu bar and content pane, and enables Z-ordering of other components. The glass pane is often used to intercept input events occuring over the top-level container, and can also be used to paint over multiple components.

---

11.2 The JComponent Class

With the exception of top-level containers, all Swing components whose names begin with "J" descend from the JComponent class. For example, JPanel, JScrollPane, JButton, and JTable all inherit from JComponent. However, JFrame and JDialog don't because they implement top-level containers.

The JComponent class extends the Container class, which itself extends Component. The Component class includes everything from providing layout hints to supporting painting and events. The Container class has support for adding components to the container and laying them out. This section's API tables summarize the most often used methods of Component and Container, as well as of JComponent.

---

11.3 Component

---

1、JPanel

---

Constructor Summary

Constructor	Description
JPanel()	Creates a new JPanel with a double buffer and a flow layout.
JPanel​(boolean isDoubleBuffered)	Creates a new JPanel with FlowLayout and the specified buffering strategy.
JPanel​(LayoutManager layout)	Create a new buffered JPanel with the specified layout manager
JPanel​(LayoutManager layout, boolean isDoubleBuffered)	Creates a new JPanel with the specified layout manager and buffering strategy.

---

2、JButton

---

Constructor Summary

Constructor	Description
JButton()	Creates a button with no set text or icon.
JButton​(String text)	Creates a button with text.
JButton​(String text, Icon icon)	Creates a button with initial text and an icon.
JButton​(Action a)	Creates a button where properties are taken from the Action supplied.
JButton​(Icon icon)	Creates a button with an icon.

---

3、JTextArea

---

A JTextArea is a multi-line area that displays plain text. Alternative multi-line text classes with more capabilities are JTextPane and JEditorPane.

The java.awt.TextArea internally handles scrolling. JTextArea is different in that it doesn't manage scrolling, but implements the swing Scrollable interface. This allows it to be placed inside a JScrollPane if scrolling behavior is desired, and used directly if scrolling is not desired.

Constructor Summary

Constructor	Description
JTextArea()	Constructs a new TextArea.
JTextArea​(int rows, int columns)	Constructs a new empty TextArea with the specified number of rows and columns.
JTextArea​(String text)	Constructs a new TextArea with the specified text displayed.
JTextArea​(String text, int rows, int columns)	Constructs a new TextArea with the specified text and number of rows and columns.
JTextArea​(Document doc)	Constructs a new JTextArea with the given document model, and defaults for all of the other arguments (null, 0, 0).
JTextArea​(Document doc, String text, int rows, int columns)	Constructs a new JTextArea with the specified number of rows and columns, and the given model.

---

4、JTextField

JTextField is a lightweight component that allows the editing of a single line of text.

The horizontal alignment of JTextField can be set to be left justified, leading justified, centered, right justified or trailing justified. Right/trailing justification is useful if the required size of the field text is smaller than the size allocated to it. This is determined by the setHorizontalAlignment and getHorizontalAlignment methods. The default is to be leading justified.

Constructor Summary

Constructor	Description
JTextField()	Constructs a new TextField.
JTextField​(int columns)	Constructs a new empty TextField with the specified number of columns.
JTextField​(String text)	Constructs a new TextField initialized with the specified text.
JTextField​(String text, int columns)	Constructs a new TextField initialized with the specified text and columns.
JTextField​(Document doc, String text, int columns)	Constructs a new JTextField that uses the given text storage model and the given number of columns.

---

5、JScrollPanel

Provides a scrollable view of a lightweight component. A JScrollPane manages a viewport, optional vertical and horizontal scroll bars, and optional row and column heading viewports.

Constructor Summary

Constructor	Description
JScrollPane()	Creates an empty (no viewport view) JScrollPane where both horizontal and vertical scrollbars appear when needed.
JScrollPane​(int vsbPolicy, int hsbPolicy)	Creates an empty (no viewport view) JScrollPane with specified scrollbar policies.
JScrollPane​(Component view)	Creates a JScrollPane that displays the contents of the specified component, where both horizontal and vertical scrollbars appear whenever the component's contents are larger than the view.
JScrollPane​(Component view, int vsbPolicy, int hsbPolicy)	Creates a JScrollPane that displays the view component in a viewport whose view position can be controlled with a pair of scrollbars.

Fields declared in interface javax.swing.ScrollPaneConstants

• HORIZONTAL_SCROLLBAR
  HORIZONTAL_SCROLLBAR_ALWAYS
  HORIZONTAL_SCROLLBAR_AS_NEEDED
  HORIZONTAL_SCROLLBAR_NEVER
  $\quad$
• VERTICAL_SCROLLBAR
  VERTICAL_SCROLLBAR_ALWAYS
  VERTICAL_SCROLLBAR_AS_NEEDED
  VERTICAL_SCROLLBAR_NEVER

---

6、 Radio Buttons

Radio buttons are groups of buttons in which, by convention, only one button at a time can be selected. The Swing release supports radio buttons with the JRadioButton and ButtonGroup classes. To put a radio button in a menu, use the JRadioButtonMenuItem class. Other ways of displaying one-of-many choices are combo boxes and lists. Radio buttons look similar to check boxes, but, by convention, check boxes place no limits on how many items can be selected at a time.

Because JRadioButton inherits from AbstractButton, Swing radio buttons have all the usual button characteristics, as discussed earlier in this section. For example, you can specify the image displayed in a radio button.

Here is a picture of an application that uses five radio buttons to let you choose which kind of pet is displayed:

Each time the user clicks a radio button (even if it was already selected), the button fires an action event. One or two item events also occur — one from the button that was just selected, and another from the button that lost the selection (if any). Usually, you handle radio button clicks using an action listener.
Below is the code from RadioButtonDemo.java that creates the radio buttons in the previous example and reacts to clicks.

//In initialization code:
    //Create the radio buttons.
    JRadioButton birdButton = new JRadioButton(birdString);
    birdButton.setMnemonic(KeyEvent.VK_B);
    birdButton.setActionCommand(birdString);
    birdButton.setSelected(true);
    JRadioButton catButton = new JRadioButton(catString);
    catButton.setMnemonic(KeyEvent.VK_C);
    catButton.setActionCommand(catString);
    JRadioButton dogButton = new JRadioButton(dogString);
    dogButton.setMnemonic(KeyEvent.VK_D);
    dogButton.setActionCommand(dogString);
    JRadioButton rabbitButton = new JRadioButton(rabbitString);
    rabbitButton.setMnemonic(KeyEvent.VK_R);
    rabbitButton.setActionCommand(rabbitString);
    JRadioButton pigButton = new JRadioButton(pigString);
    pigButton.setMnemonic(KeyEvent.VK_P);
    pigButton.setActionCommand(pigString);
    //Group the radio buttons.
    ButtonGroup group = new ButtonGroup();
    group.add(birdButton);
    group.add(catButton);
    group.add(dogButton);
    group.add(rabbitButton);
    group.add(pigButton);
    //Register a listener for the radio buttons.
    birdButton.addActionListener(this);
    catButton.addActionListener(this);
    dogButton.addActionListener(this);
    rabbitButton.addActionListener(this);
    pigButton.addActionListener(this);
...
public void actionPerformed(ActionEvent e) {
    picture.setIcon(new ImageIcon("images/" 
                                  + e.getActionCommand() 
                                  + ".gif"));
}

For each group of radio buttons, you need to create a ButtonGroup instance and add each radio button to it. The ButtonGroup takes care of unselecting the previously selected button when the user selects another button in the group.

You should generally initialize a group of radio buttons so that one is selected. However, the API doesn't enforce this rule — a group of radio buttons can have no initial selection. Once the user has made a selection, exactly one button is selected from then on.

---

7、Check Boxes

The JCheckBox class provides support for check box buttons. You can also put check boxes in menus, using the JCheckBoxMenuItem class. Because JCheckBox and JCheckBoxMenuItem inherit from AbstractButton, Swing check boxes have all the usual button characteristics, as discussed earlier in this section. For example, you can specify images to be used in check boxes.

Check boxes are similar to radio buttons but their selection model is different, by convention. Any number of check boxes in a group — none, some, or all — can be selected. A group of radio buttons, on the other hand, can have only one button selected.

Here is a picture of an application that uses four check boxes to customize a cartoon:

A check box generates one item event and one action event per click. Usually, you listen only for item events, since they let you determine whether the click selected or deselected the check box. Below is the code from CheckBoxDemo.java that creates the check boxes in the previous example and reacts to clicks.

//In initialization code:
    chinButton = new JCheckBox("Chin");
    chinButton.setMnemonic(KeyEvent.VK_C); 
    chinButton.setSelected(true);
    glassesButton = new JCheckBox("Glasses");
    glassesButton.setMnemonic(KeyEvent.VK_G); 
    glassesButton.setSelected(true);
    hairButton = new JCheckBox("Hair");
    hairButton.setMnemonic(KeyEvent.VK_H); 
    hairButton.setSelected(true);
    teethButton = new JCheckBox("Teeth");
    teethButton.setMnemonic(KeyEvent.VK_T); 
    teethButton.setSelected(true);
    //Register a listener for the check boxes.
    chinButton.addItemListener(this);
    glassesButton.addItemListener(this);
    hairButton.addItemListener(this);
    teethButton.addItemListener(this);
...
public void itemStateChanged(ItemEvent e) {
    ...
    Object source = e.getItemSelectable();
    if (source == chinButton) {
        //...make a note of it...
    } else if (source == glassesButton) {
        //...make a note of it...
    } else if (source == hairButton) {
        //...make a note of it...
    } else if (source == teethButton) {
        //...make a note of it...
    }
    if (e.getStateChange() == ItemEvent.DESELECTED)
        //...make a note of it...
    ...
    updatePicture();
}

---

8、Combo Boxes

A JComboBox, which lets the user choose one of several choices, can have two very different forms. The default form is the uneditable combo box, which features a button and a drop-down list of values. The second form, called the editable combo box, features a text field with a small button abutting it. The user can type a value in the text field or click the button to display a drop-down list. Here's what the two forms of combo boxes look like in the Java look and feel:

Combo boxes require little screen space, and their editable (text field) form is useful for letting the user quickly choose a value without limiting the user to the displayed values. Other components that can display one-of-many choices are groups of radio buttons and lists. Groups of radio buttons are generally the easiest for users to understand, but combo boxes can be more appropriate when space is limited or more than a few choices are available. Lists are not terribly attractive, but they're more appropriate than combo boxes when the number of items is large (say, over 20) or when selecting multiple items might be valid.

The following code, taken from ComboBoxDemo.java, creates an uneditable combo box and sets it up:

String[] petStrings = { "Bird", "Cat", "Dog", "Rabbit", "Pig" };
//Create the combo box, select item at index 4.
//Indices start at 0, so 4 specifies the pig.
JComboBox petList = new JComboBox(petStrings);
petList.setSelectedIndex(4);
petList.addActionListener(this);

This combo box contains an array of strings, but you could just as easily use icons instead. To put anything else into a combo box or to customize how the items in a combo box look, you need to write a custom renderer. An editable combo box would also need a custom editor. Refer to Providing a Custom Renderer for information and an example.
The preceding code registers an action listener on the combo box. To see the action listener implementation and learn about other types of listeners supported by combo box, refer to Handling Events on a Combo Box.
No matter which constructor you use, a combo box uses a combo box model to contain and manage the items in its menu. When you initialize a combo box with an array or a vector, the combo box creates a default model object for you. As with other Swing components, you can customize a combo box in part by implementing a custom model — an object that implements the ComboBoxModel interface.

---

11.4 Layout

---

1、BoxLayout

A layout manager that allows multiple components to be laid out either vertically or horizontally. The components will not wrap so, for example, a vertical arrangement of components will stay vertically arranged when the frame is resized.
Example:

The BoxLayout manager is constructed with an axis parameter that specifies the type of layout that will be done.

X_AXIS- Components are laid out horizontally from left to right.
Y_AXIS - Components are laid out vertically from top to bottom.g
默认左对齐

For all directions, components are arranged in the same order as they were added to the container.

Instead of using BoxLayout directly, many programs use the Box class. The Box class is a lightweight container that uses a BoxLayout. It also provides handy methods to help you use BoxLayout well. Adding components to multiple nested boxes is a powerful way to get the arrangement you want.

Constructor Summary

Constructor	Description
BoxLayout​(Container target, int axis)	Creates a layout manager that will lay out components along the given axis.

Method Summary

Modifier and Type	Method	Description
int	getAxis()	Returns the axis that was used to lay out components.
float	getLayoutAlignmentX​(Container target)	Returns the alignment along the X axis for the container.
float	getLayoutAlignmentY​(Container target)	Returns the alignment along the Y axis for the container.
Container	getTarget()	Returns the container that uses this layout manager.
void	invalidateLayout​(Container target)	Indicates that a child has changed its layout related information, and thus any cached calculations should be flushed.
void	layoutContainer​(Container target)	Called by the AWT when the specified container needs to be laid out.
Dimension	maximumLayoutSize​(Container target)	Returns the maximum dimensions the target container can use to lay out the components it contains.
Dimension	minimumLayoutSize​(Container target)	Returns the minimum dimensions needed to lay out the components contained in the specified target container.
Dimension	preferredLayoutSize​(Container target)	Returns the preferred dimensions for this layout, given the components in the specified target container.

---

Box

A lightweight container that uses a BoxLayout object as its layout manager. Box provides several class methods that are useful for containers using BoxLayout -- even non-Box containers.

The Box class can create several kinds of invisible components that affect layout: glue, struts, and rigid areas. If all the components your Box contains have a fixed size, you might want to use a glue component (returned by createGlue) to control the components' positions. If you need a fixed amount of space between two components, try using a strut (createHorizontalStrut or createVerticalStrut). If you need an invisible component that always takes up the same amount of space, get it by invoking createRigidArea.

Constructor Summary

Constructor	Description
Box​(int axis)	Creates a Box that displays its components along the specified axis.

Method Summary

Modifier and Type	Method	Description
static Component	createGlue()	Creates an invisible "glue" component that can be useful in a Box whose visible components have a maximum width (for a horizontal box) or height (for a vertical box).
static Box	createHorizontalBox()	Creates a Box that displays its components from left to right.
static Component	createHorizontalGlue()	Creates a horizontal glue component.
static Component	createHorizontalStrut​(int width)	Creates an invisible, fixed-width component.
static Component	createRigidArea​(Dimension d)	Creates an invisible component that's always the specified size.
static Box	createVerticalBox()	Creates a Box that displays its components from top to bottom.
static Component	createVerticalGlue()	Creates a vertical glue component.
static Component	createVerticalStrut​(int height)	Creates an invisible, fixed-height component.
AccessibleContext	getAccessibleContext()	Gets the AccessibleContext associated with this Box.
protected void	paintComponent​(Graphics g)	Paints this Box.
void	setLayout​(LayoutManager l)	Throws an AWTError, since a Box can use only a BoxLayout.

---

2、FlowLayout

A flow layout arranges components in a directional flow, much like lines of text in a paragraph. The flow direction is determined by the container's componentOrientation property and may be one of two values:
ComponentOrientation.LEFT_TO_RIGHT
ComponentOrientation.RIGHT_TO_LEFT
Flow layouts are typically used to arrange buttons in a panel. It arranges buttons horizontally until no more buttons fit on the same line. The line alignment is determined by the align property. The possible values are:

• LEFT
• RIGHT
• CENTER
• LEADING
• TRAILING
  默认居中（JPanel）

For example, the following picture shows an applet using the flow layout manager (its default layout manager) to position three buttons:

Here is the code for this applet:

 import java.awt.*;
 import java.applet.Applet;
 public class myButtons extends Applet {
     Button button1, button2, button3;
     public void init() {
         button1 = new Button("Ok");
         button2 = new Button("Open");
         button3 = new Button("Close");
         add(button1);
         add(button2);
         add(button3);
     }
 }

A flow layout lets each component assume its natural (preferred) size.

Constructor Summary

Constructor	$\qquad \qquad \qquad \qquad \qquad \qquad$ Description
FlowLayout()	Constructs a new FlowLayout with a centered alignment and a default 5-unit horizontal and vertical gap.
FlowLayout​(int align)	Constructs a new FlowLayout with the specified alignment and a default 5-unit horizontal and vertical gap.
FlowLayout​(int align, int hgap, int vgap)	Creates a new flow layout manager with the indicated alignment and the indicated horizontal and vertical gaps.

Method Summary

Modifier and Type	Method	Description
void	addLayoutComponent​(String name, Component comp)	Adds the specified component to the layout.
int	getAlignment()	Gets the alignment for this layout.
boolean	getAlignOnBaseline()	Returns true if components are to be vertically aligned along their baseline.
int	getHgap()	Gets the horizontal gap between components and between the components and the borders of the Container
int	getVgap()	Gets the vertical gap between components and between the components and the borders of the Container.
void	layoutContainer​(Container target)	Lays out the container.
Dimension	minimumLayoutSize​(Container target)	Returns the minimum dimensions needed to layout the visible components contained in the specified target container.
Dimension	preferredLayoutSize​(Container target)	Returns the preferred dimensions for this layout given the visible components in the specified target container.
void	removeLayoutComponent​(Component comp)	Removes the specified component from the layout.
void	setAlignment​(int align)	Sets the alignment for this layout.
void	setAlignOnBaseline​(boolean alignOnBaseline)	Sets whether or not components should be vertically aligned along their baseline.
void	setHgap​(int hgap)	Sets the horizontal gap between components and between the components and the borders of the Container.
void	setVgap​(int vgap)	Sets the vertical gap between components and between the components and the borders of the Container.

---

Field Detail

---

LEFT

This value indicates that each row of components should be left-justified.

---

CENTER

This value indicates that each row of components should be centered.

---

RIGHT

This value indicates that each row of components should be right-justified.

---

LEADING

This value indicates that each row of components should be justified to the leading edge of the container's orientation, for example, to the left in left-to-right orientations.

---

TRAILING

This value indicates that each row of components should be justified to the trailing edge of the container's orientation, for example, to the right in left-to-right orientations.

---

Constructor Detail

---

public FlowLayout()

Constructs a new FlowLayout with a centered alignment and a default 5-unit horizontal and vertical gap.

---

public FlowLayout​(int align)

Constructs a new FlowLayout with the specified alignment and a default 5-unit horizontal and vertical gap. The value of the alignment argument must be one of FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER, FlowLayout.LEADING, or FlowLayout.TRAILING.
Parameters:
align - the alignment value

---

public FlowLayout​(int align,int hgap,int vgap)

Creates a new flow layout manager with the indicated alignment and the indicated horizontal and vertical gaps.
The value of the alignment argument must be one of FlowLayout.LEFT, FlowLayout.RIGHT, FlowLayout.CENTER, FlowLayout.LEADING, or FlowLayout.TRAILING.
Parameters:
align - the alignment value
hgap - the horizontal gap between components and between the components and the borders of the Container
vgap - the vertical gap between components and between the components and the borders of the Container

---

3、GridLayout

The GridLayout class is a layout manager that lays out a container's components in a rectangular grid. The container is divided into equal-sized rectangles, and one component is placed in each rectangle. For example, the following is an applet that lays out six buttons into three rows and two columns:

 import java.awt.*;
 import java.applet.Applet;
 public class ButtonGrid extends Applet {
     public void init() {
         setLayout(new GridLayout(3,2));
         add(new Button("1"));
         add(new Button("2"));
         add(new Button("3"));
         add(new Button("4"));
         add(new Button("5"));
         add(new Button("6"));
     }
}

If the container's ComponentOrientation property is horizontal and left-to-right, the above example produces the output shown in Figure 1. If the container's ComponentOrientation property is horizontal and right-to-left, the example produces the output shown in Figure 2.
$\qquad \qquad \qquad\qquad$ $\qquad\qquad\qquad\qquad \qquad \qquad$

$$Figure 1: Horizontal, Left-to-Right \qquad Figure 2: Horizontal, Right-to-Left$$
When both the number of rows and the number of columns have been set to non-zero values, either by a constructor or by the setRows and setColumns methods, the number of columns specified is ignored. Instead, the number of columns is determined from the specified number of rows and the total number of components in the layout. So, for example, if three rows and two columns have been specified and nine components are added to the layout, they will be displayed as three rows of three columns. Specifying the number of columns affects the layout only when the number of rows is set to zero.

Constructor Summary

Constructor	Description
GridLayout()	Creates a grid layout with a default of one column per component, in a single row.
GridLayout​(int rows, int cols)	Creates a grid layout with the specified number of rows and columns.
GridLayout​(int rows, int cols, int hgap, int vgap)	Creates a grid layout with the specified number of rows and columns.

Method Summary

Modifier and Type	Method	Description
void	addLayoutComponent​(String name, Component comp)	Adds the specified component with the specified name to the layout.
int	getColumns()	Gets the number of columns in this layout.
int	getHgap()	Gets the horizontal gap between components.
int	getRows()	Gets the number of rows in this layout.
int	getVgap()	Gets the vertical gap between components.
void	layoutContainer​(Container parent)	Lays out the specified container using this layout.
Dimension	minimumLayoutSize​(Container parent)	Determines the minimum size of the container argument using this grid layout.
Dimension	preferredLayoutSize​(Container parent)	Determines the preferred size of the container argument using this grid layout.
void	removeLayoutComponent​(Component comp)	Removes the specified component from the layout
void	setColumns​(int cols)	Sets the number of columns in this layout to the specified value.
void	setHgap​(int hgap)	Sets the horizontal gap between components to the specified value.
void	setRows​(int rows)	Sets the number of rows in this layout to the specified value.
void	setVgap​(int vgap)	Sets the vertical gap between components to the specified value.
String	toString()	Returns the string representation of this grid layout's values.

---

Constructor Detail

---

public GridLayout()

Creates a grid layout with a default of one column per component, in a single row.

---

public GridLayout​(int rows,int cols)

Creates a grid layout with the specified number of rows and columns. All components in the layout are given equal size.
One, but not both, of rows and cols can be zero, which means that any number of objects can be placed in a row or in a column.
Parameters:
rows - the rows, with the value zero meaning any number of rows.
cols - the columns, with the value zero meaning any number of columns.

---

public GridLayout​(int rows,int cols,int hgap,int vgap)

Creates a grid layout with the specified number of rows and columns. All components in the layout are given equal size.
In addition, the horizontal and vertical gaps are set to the specified values. Horizontal gaps are placed between each of the columns. Vertical gaps are placed between each of the rows.
One, but not both, of rows and cols can be zero, which means that any number of objects can be placed in a row or in a column.
All GridLayout constructors defer to this one.
Parameters:
rows - the rows, with the value zero meaning any number of rows
cols - the columns, with the value zero meaning any number of columns
hgap - the horizontal gap
vgap - the vertical gap
Throws:
IllegalArgumentException - if the value of both rows and cols is set to zero

---

---

Chapter 12 Threads

---

12.1 What Is a Thread?

A thread is an object.Sometimes it is called an execution context or a lightweight process--is a single sequential flow of control within a program.

执行上下文（Excute Context）；
一个线程是一个程序内部的顺序控制流。

1. 进程：每个进程都有独立的代码和数据空间（进程上下文） ，进程切换的开销大。
2. 线程：轻量的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器，线程切换的开销小。
3. 多进程：在操作系统中，能同时运行多个任务程序。
4. 多线程：在同一应用程序中，有多个顺序流同时执行。

A program always has at least one thread: the one created when the program begins execution.

• In a normal Java application program, this thread starts at the beginning of main().
• With an applet, the browser is the main thread.

---

12.2 Sigle thread and Multiple thread

• single thread also has a beginning, a sequence, and an end and at any given time during the runtime of the thread
  

• in a single program, running at the same time and performing different tasks
  

There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread. This subclass should override the run method of class Thread. An instance of the subclass can then be allocated and started. For example, a thread that computes primes larger than a stated value could be written as follows:

class PrimeThread extends Thread {
         long minPrime;
         PrimeThread(long minPrime) {
             this.minPrime = minPrime;
         }
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     } 

The following code would then create a thread and start it running:

     PrimeThread p = new PrimeThread(143);
     p.start();

The other way to create a thread is to declare a class that implements the Runnable interface. That class then implements the run method. An instance of the class can then be allocated, passed as an argument when creating Thread, and started. The same example in this other style looks like the following:

class PrimeRun implements Runnable {
         long minPrime;
         PrimeRun(long minPrime) {
             this.minPrime = minPrime;
         }
         public void run() {
             // compute primes larger than minPrime
              . . .
         }
     }

The following code would then create a thread and start it running:

     PrimeRun p = new PrimeRun(143);
     new Thread(p).start();
     /*Thread t = new Thread(p);
       p.start();
     */

---

12.3 The Life Cycle of a Thread

• New
• Runnable
• Blocked
• Waiting
• Timed waiting
• Terminated

1、 New
When a thread is a New Thread, it is merely an empty Thread object; no system resources have
been allocated for it yet. you can only start the thread. Calling any method besides start when a
thread is in this state makes no sense and causes an IllegalThreadStateException.

2、 Runnable
The start method creates the system resources necessary to run the thread, schedules the thread
to run, and calls the thread's run method .The code that executes in a new thread is always a
method called run(), which is public, accepts no arguments, and doesn’t return a value. thread that has been started is actually in the Runnable state.The Java runtime system must implement a scheduling scheme that shares the processor between all "running" threads.
Once a thread starts running, it can be interrupted to give other threads a chance to run. The operating system gives each runnable thread a time slice to perform tasks. When the time slice runs out, the operating system will deny the thread the right to run and give another thread a chance to run ( considering the priority of the thread ).

A thread becomes Not Runnable when one of these events occurs:

• Its sleep method is invoked.
  If a thread has been put to sleep, then the specified number of milliseconds must elapse.
• The thread calls the wait method to wait for a specific condition to be satisifed.
  If a thread is waiting for a condition, then another object must notify the waiting thread of a change in condition by calling notify or notifyAll.
• The thread is blocking on I/O.
  If a thread is blocked on I/O, then the I/O must complete.

3、 Terminate
A thread arranges for its own death by having a run method that terminates naturally
Accidental death due to an abnormal termination of the run method without inactivity

4、 Blocked and Waiting
When a thread attempts to acquire an internal object lock and the lock is held by other threads, the thread enters a blocking state, and when all other threads release the lock and the thread scheduler allows the thread to hold it, the thread becomes a non-blocking state.
When a thread waits for another thread to notify the scheduler of a condition, it enters the waiting state itself.

---

12.4 Thread Priority

The Java runtime supports a very simple, deterministic scheduling algorithm known as fixed priority scheduling.
When a Java thread is created, it inherits its priority from the thread that created it.
You can also modify a thread's priority at any time after its creation using the setPriority method. Thread priorities are integers ranging between MIN_PRIORITY and MAX_PRIORITY（ 1-10 ）. The higher the integer, the higher the priority.

1 - MIN_PRIORITY
10 – MAX_PRIORITY
5- NORM_PRIORITY

when multiple threads are ready to be executed,the runtime system chooses the runnable thread with the highest priority for execution.Only when that thread stops, yields, or becomes not runnable for some reason will a lower priority thread start executing. If two threads of the same priority are waiting for the CPU, the scheduler chooses one of them to run in a round-robin fashion.
The chosen thread will run until one of the following conditions is true:

• A higher priority thread becomes runnable.
  If at any time a thread with a higher priority than all other runnable threads becomes runnable, the runtime system chooses the new higher priority thread for execution.

• It yields, or its run method exits.

• On systems that support time-slicing, its time allotment has expired.
  Time-slicing comes into play when there are multiple "Runnable" threads of equal priority and those threads are the highest priority threads competing for the CPU.

  1、time-sliced system divides the CPU into time slots and iteratively gives each of the equal-and-highest priority threads a time slot in which to run.
  2、The time-sliced system iterates through the equal-and-highest priority threads, allowing each one a bit of time to run, until one or more of them finishes or until a higher priority thread preempts them.
  3、Notice that time-slicing makes no guarantees as to how often or in what order threads are scheduled to run.

At any given time, the highest priority thread is running. However, this is not guaranteed. The thread scheduler may choose to run a lower priority thread to avoid starvation. For this reason, use priority only to affect scheduling policy for efficiency purposes. Do not rely on thread priority for algorithm correctness.

---

12.5 Basic Control of Thread

Constructor Summary

Constructor	Description
Thread()	Allocates a new Thread object.This constructor has the same effect as Thread (null, null, gname), where gname is a newly generated name.
Thread​(Runnable target)	Allocates a new Thread object.
Thread​(Runnable target, String name)	Allocates a new Thread object.
Thread​(String name)	Allocates a new Thread object.
Thread​(ThreadGroup group, Runnable target)	Allocates a new Thread object.
Thread​(ThreadGroup group, Runnable target, String name)	Allocates a new Thread object so that it has target as its run object, has the specified name as its name, and belongs to the thread group referred to by group.
Thread​(ThreadGroup group, Runnable target, String name, long stackSize)	Allocates a new Thread object so that it has target as its run object, has the specified name as its name, and belongs to the thread group referred to by group, and has the specified stack size.
Thread​(ThreadGroup group, Runnable target, String name, long stackSize, boolean inheritThreadLocals)	Allocates a new Thread object so that it has target as its run object, has the specified name as its name, belongs to the thread group referred to by group, has the specified stackSize, and inherits initial values for inheritable thread-local variables if inheritThreadLocals is true.
Thread​(ThreadGroup group, String name)	Allocates a new Thread object.

Method Summary

Modifier and Type	Method	Description
int	getPriority()	Returns this thread's priority.
void	interrupt()	Interrupts this thread.
static boolean	interrupted()	Tests whether the current thread has been interrupted.
boolean	isAlive()	Tests if this thread is alive.
boolean	isInterrupted()	Tests whether this thread has been interrupted.
void	join()	Waits for this thread to die.
void	join​(long millis)	Waits at most millis milliseconds for this thread to die.
void	run()	If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.
void	setPriority​(int newPriority)	Changes the priority of this thread.
static void	sleep​(long millis)	Causes the currently executing thread to sleep (temporarily cease execution) for the specified number of milliseconds, subject to the precision and accuracy of system timers and schedulers.
void	start()	Causes this thread to begin execution; the Java Virtual Machine calls the run method of this thread.
static void	yield()	A hint to the scheduler that the current thread is willing to yield its current use of a processor.

Note

1. Thread.sleep() // static method
   Thread.yield()
2. void join()
   等待该线程终止。
   void join(long millis)
   等待该线程终止的时间最长为 millis 毫秒。
   void join(long millis, int nanos)
   等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
3. sleep():end any priority thread
   yeild():end the same priority thread

---

12.6 Synchronizing Threads

Multithreaded programming has these characteristics:
• Multiple threads are from one Runnable instance.
• Threads share the same data and code.

The code segments within a program that access the same object from separate, concurrent threads are called critical sections. A critical section can be a block or a method and are identified with the synchronized keyword. The Java platform then associates a lock with every object that has synchronized code.

To ensure that when several threads want access to a single resource,only one thread can access it at any given time.
❑ You can manage code at the method level—synchronizing methods.
❑ You can manage code at the block level— synchronizing blocks.

Every object has a flag that is a type of lock flag.The synchronized enables interaction with the lock flag.

To make a method synchronized, simply add the synchronized keyword to its declaration:

public class SynchronizedCounter {
    private int c = 0;
//method-level locked
    public synchronized void increment() {
        c++;
    }
    public synchronized void decrement() {
        c--;
    }
    public synchronized int value() {
        return c;
    }
}

If count is an instance of SynchronizedCounter, then making these methods synchronized has two effects:
First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object.
Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.
Note that constructors cannot be synchronized — using the synchronized keyword with a constructor is a syntax error. Synchronizing constructors doesn't make sense, because only the thread that creates an object should have access to it while it is being constructed.

Warning: When constructing an object that will be shared between threads, be very careful that a reference to the object does not "leak" prematurely. For example, suppose you want to maintain a List called instances containing every instance of class. You might be tempted to add the following line to your constructor:

instances.add(this);

But then other threads can use instances to access the object before construction of the object is complete.

Synchronized methods enable a simple strategy for preventing thread interference and memory consistency errors: if an object is visible to more than one thread, all reads or writes to that object's variables are done through synchronized methods. (An important exception: final fields, which cannot be modified after the object is constructed, can be safely read through non-synchronized methods, once the object is constructed)

Synchronization is built around an internal entity known as the intrinsic lock or monitor lock. (The API specification often refers to this entity simply as a "monitor.") Intrinsic locks play a role in both aspects of synchronization: enforcing exclusive access to an object's state and establishing happens-before relationships that are essential to visibility.

Every object has an intrinsic lock associated with it. By convention, a thread that needs exclusive and consistent access to an object's fields has to acquire the object's intrinsic lock before accessing them, and then release the intrinsic lock when it's done with them. A thread is said to own the intrinsic lock between the time it has acquired the lock and released the lock. As long as a thread owns an intrinsic lock, no other thread can acquire the same lock. The other thread will block when it attempts to acquire the lock.

When a thread releases an intrinsic lock, a happens-before relationship is established between that action and any subsequent acquisition of the same lock.

Locks In Synchronized Methods
When a thread invokes a synchronized method, it automatically acquires the intrinsic lock for that method's object and releases it when the method returns. The lock release occurs even if the return was caused by an uncaught exception.

Synchronized Statements
Another way to create synchronized code is with synchronized statements. Unlike synchronized methods, synchronized statements must specify the object that provides the intrinsic lock:

public void addName(String name) {
    synchronized(this) {
        lastName = name;
        nameCount++;
    }
    nameList.add(name);
}

Synchronized statements are also useful for improving concurrency with fine-grained synchronization. Suppose, for example, class MsLunch has two instance fields, c1 and c2, that are never used together. All updates of these fields must be synchronized, but there's no reason to prevent an update of c1 from being interleaved with an update of c2 — and doing so reduces concurrency by creating unnecessary blocking. Instead of using synchronized methods or otherwise using the lock associated with this, we create two objects solely to provide locks.

public class MsLunch {
    private long c1 = 0;
    private long c2 = 0;
    private Object lock1 = new Object();
    private Object lock2 = new Object();
    public void inc1() {
        synchronized(lock1) {
            c1++;
        }
    }
    public void inc2() {
        synchronized(lock2) {
            c2++;
        }
    }
}

Use this idiom with extreme care. You must be absolutely sure that it really is safe to interleave access of the affected fields.

To avoid polling, Java includes an elegant interprocess communication mechanism via the wait( ),
notify( ), and notifyAll( ) methods

– All three methods can be called only from within a synchronized context

• wait( ) tells the calling thread to give up the monitor and go to sleep until some other thread enters the same monitor and calls notify( ).
• notify() wakes up the first thread that called wait() on the same object.
• notifyAll() wakes up all the threads that called wait( ) on

Releasing the Lock Flag:
The lock flag is released in the following events:
• Released when the thread passes the end of the synchronized code block
• Released automatically when a break, return, or exception is thrown by the synchronized code block

---

12.7 Deadlock

Deadlock occurs when two or more threads are waiting on a condition that cannot be satisfied.
Deadlock most often occurs when two (or more) threads are each waiting for the other(s) to do something.
A deadlock has the following characteristics:

• It is two threads, each waiting for a lock from the other.
• It is not detected or avoided.
• Deadlock can be avoided by:
  
  • Deciding on the order to obtain locks
  • Adhering to this order throughout
  • Releasing locks in reverse order
    

---

12.8 Grouping Treads

Every Java thread is a member of a thread group.Thread groups provide a mechanism for collecting multiple threads into a single object and manipulating those threads all at once, rather than individually.
The runtime system puts a thread into a thread group during thread construction. When create a thread, you can either allow the runtime system to put the new thread in some reasonable default group or you can explicitly set the new thread's group.The thread is a permanent member of whatever thread group it joins upon its creation--you cannot move a thread to a new group after the thread has been created.
If you create a new Thread without specifying its group in the constructor, the runtime system automatically places the new thread in the same group as the thread that created it
When a Java application first starts up, the Java runtime system creates a ThreadGroup named main.
When you operate a group,you will operate the whole thread in the group.

---

Chapter 13 Network

---

Question:
1、something about the new port created by server when the acceptance is well ?
2、printwriter and printstream?

---

13.1 Networking Basics

Computers running on the Internet communicate to each other using either the Transmission Control Protocol (TCP) or the User Datagram Protocol(UDP)

TCP & UDP

• TCP (Transmission Control Protocol)
  TCP is a connection‐based protocol that provides a reliable flow of data between two computers.
  When two applications want to communicate to each other reliably, they establish a connection and send data back and forth over that connection. This is analogous to making a telephone call. If you want to speak to Aunt Beatrice in Kentucky, a connection is established when you dial her phone number and she answers. You send data back and forth over the connection by speaking to one another over the phone lines. Like the phone company, TCP guarantees that data sent from one end of the connection actually gets to the other end and in the same order it was sent. Otherwise, an error is reported.
  TCP provides a point-to-point channel for applications that require reliable communications. The Hypertext Transfer Protocol (HTTP), File Transfer Protocol (FTP), and Telnet are all examples of applications that require a reliable communication channel. The order in which the data is sent and received over the network is critical to the success of these applications. When HTTP is used to read from a URL, the data must be received in the order in which it was sent. Otherwise, you end up with a jumbled HTML file, a corrupt zip file, or some other invalid information.

• UDP (User Datagram Protocol)**
  UDP is a protocol that sends independent packets of data, called datagrams, from one computer to another with no guarantees about arrival. UDP is not connection-based like TCP.
  The UDP protocol provides for communication that is not guaranteed between two applications on the network. UDP is not connection-based like TCP. Rather, it sends independent packets of data, called datagrams, from one application to another. Sending datagrams is much like sending a letter through the postal service: The order of delivery is not important and is not guaranteed, and each message is independent of any other.

---

13.2 Networking With Java Technology

• Java programs ‐ at the application layer– can use the classes in the java.net package.
When you write Java programs that communicate over the network, you are programming at the application layer.

To address the connection, include the following:
• The address or name of remote machine
• A port(端口) number to identify the purpose at the server
• Port numbers range from 0–65535

Through the classes in java.net, Java programs can use TCP or UDP to communicate over the Internet.
The URL, URLConnection, Socket, and ServerSocket classes all use TCP to communicate over the network.
The DatagramPacket, DatagramSocket, and MulticastSocket classes are for use with UDP.

---

13.3 Port

The TCP and UDP protocols use ports to map incoming data to a particular process running on a computer.
In connection-based communication such as TCP, a server application binds a socket to a specific port number.
This has the effect of registering the server with the system to receive all data destined for that port. A client can then rendezvous（约会） with the server at the server's port, as illustrated here:

Generally speaking, a computer has a single physical connection to the network. All data destined for a particular computer arrives through that connection. However, the data may be intended for different applications running on the computer. So how does the computer know to which application to forward the data? Through the use of ports.
Data transmitted over the Internet is accompanied by addressing information that identifies the computer and the port for which it is destined. The computer is identified by its 32-bit IP address, which IP uses to deliver data to the right computer on the network. Ports are identified by a 16-bit number, which TCP and UDP use to deliver the data to the right application.
In connection-based communication such as TCP, a server application binds a socket to a specific port number. This has the effect of registering the server with the system to receive all data destined for that port.
In datagram-based communication such as UDP, the datagram packet contains the port number of its destination and UDP routes the packet to the appropriate application.

Port numbers range from 0 to 65,535 because ports are represented by 16-bit numbers. The port numbers ranging from 0 - 1023 are restricted; they are reserved for use by well-known services such as HTTP and FTP and other system services. These ports are called well-known ports. Your applications should not attempt to bind to them.

---

13.4 Socket

A socket is one end-point of a two-way communication link between two programs running on the network. A socket is bound to a port number so that the TCP layer can identify the application that data is destined to be sent to.

Normally, a server runs on a specific computer and has a socket that is bound to a specific port number. The server just waits, listening to the socket for a client to make a connection request.
On the client-side:The client knows the hostname of the machine on which the server is running and the port number to which the server is connected. To make a connection request, the client tries to rendezvous with the server on the server's machine and port.

If everything goes well, the server accepts the connection. Upon acceptance, the server gets a new socket bound to a different port.

On the client side, if the connection is accepted, a socket is successfully created and the client can use the socket to communicate with the server.The client and server can now communicate by writing to or reading from their sockets.

The java.net package provides two classes--Socket and ServerSocket--that implement the client side of the connection and the server side of the connection, respectively.

Sockets hold two streams: an input streamand an output stream.Each end of the socket has a pair of streams.Set up of a network connection is similar to a telephone system: One end must dial the other end, which must be listening.

---

13.5 Reading from and Writing to a Socket

Let's look at a simple example that illustrates how a program can establish a connection to a server program using the Socket class and then, how the client can send data to and receive data from the server through the socket.

String hostName = args[0];
int portNumber = Integer.parseInt(args[1]);
try (
    Socket echoSocket = new Socket(hostName, portNumber);
    PrintWriter out =
        new PrintWriter(echoSocket.getOutputStream(), true);
    BufferedReader in =
        new BufferedReader(
            new InputStreamReader(echoSocket.getInputStream()));
    BufferedReader stdIn =
        new BufferedReader(
            new InputStreamReader(System.in))
)

The example program implements a client, EchoClient, that connects to an echo server. The echo server receives data from its client and echoes it back. The example EchoServer implements an echo server. (Alternatively, the client can connect to any host that supports the Echo Protocol.)

The EchoClient example creates a socket, thereby getting a connection to the echo server. It reads input from the user on the standard input stream, and then forwards that text to the echo server by writing the text to the socket. The server echoes the input back through the socket to the client. The client program reads and displays the data passed back to it from the server.

Note that the EchoClient example both writes to and reads from its socket, thereby sending data to and receiving data from the echo server.

/**
*server
*/
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class EchoServer {
    public static void main(String[] args) {
        File file = new File("multiLines.txt");
        System.out.println("Wait for client request");
        try {
            ServerSocket serverSocket = new ServerSocket(27015);
            Socket socket = serverSocket.accept();
            Scanner scanner = new Scanner(socket.getInputStream());
            PrintStream printStream = new PrintStream(socket.getOutputStream());
            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
            while (true) {
                String message = "";
                int num = scanner.nextInt();
                for (int i = 1; i <= num; i++) {
                    String messageTemp = bufferedReader.readLine();
                    if(messageTemp != null && !messageTemp.equals("")){
                        String messageCur = message;
                        message = messageTemp + "##";
                        message = messageCur + message;
                    }
                    else{
                        message=message+"No more sentences##";
                        break;
                    }
                }
                printStream.println(message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
*client 
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class EchoClient {
    private JFrame frame;
    private JLabel label;
    private JButton button;
    private JTextField textField;
    private JTextArea textArea;
    private Socket socket;
    private Scanner in;
    private PrintStream out;
    public EchoClient() {
        frame = new JFrame("Product System");
        label = new JLabel("Please input the number of the string lines to get from server:");
        button = new JButton("send to server");
        textArea = new JTextArea();
        textField = new JTextField();
        try {
            socket = new Socket("127.0.0.1", 27015);
            out = new PrintStream(socket.getOutputStream());
            in = new Scanner(socket.getInputStream());
            ButtonActionListener r = new ButtonActionListener();
            Thread t = new Thread(r);
            t.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void lunchFrame() {
        frame.setLayout(new BorderLayout());
        Dimension frameDimension = new Dimension(600, 300);
        frame.setPreferredSize(frameDimension);
        JPanel panel = new JPanel(new BorderLayout());
        Dimension panelDimension = new Dimension(600, 40);
        panel.setPreferredSize(panelDimension);
        JPanel panelEast = new JPanel();
        panelEast.setLayout(new FlowLayout());
        Dimension textDimension = new Dimension(100, 20);
        textField.setPreferredSize(textDimension);
        panelEast.add(textField);
        panelEast.add(button);
        button.addActionListener(new ButtonActionListener());
        panel.add(label, BorderLayout.CENTER);
        panel.add(panelEast, BorderLayout.EAST);
        textArea.setEditable(false);
        textArea.setSize(100, 50);
        frame.add(panel, BorderLayout.NORTH);
        frame.add(textArea, BorderLayout.CENTER);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
    private class ButtonActionListener implements ActionListener, Runnable {
        @Override
        public void actionPerformed(ActionEvent e) {
            int number = 0;
            String num = textField.getText();
            if (!num.equals("")) {
                number = Integer.parseInt(num);
            }
            textField.setText("");
            textArea.append("get " + number + " lines from server\n");
            out.println(number);
        }
        @Override
        public void run() {
            while (true) {
                String message = in.nextLine();
                String subMessage = "No more sentences";
                if (!message.equals("")) {
                    if (message.indexOf(subMessage) != -1) {
                        textArea.append(message + "\n");
                        textArea.append("can not take sentences anymore\n");
                    } else {
                        textArea.append(message + "\n");
                    }
                }
            }
        }
    }
    public static void main(String[] args){
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                EchoClient echoClient =new EchoClient();
                echoClient.lunchFrame();
            }
        });
    }
}

The while loop then terminates, and the Java runtime automatically closes the readers and writers connected to the socket and to the standard input stream, and it closes the socket connection to the server. The Java runtime closes these resources automatically because they were created in the try-with-resources statement. The Java runtime closes these resources in reverse order that they were created. (This is good because streams connected to a socket should be closed before the socket itself is closed.)

The basics are much the same as they are in this program:
1. Open a socket.
2. Open an input stream and output stream to the socket.
3. Read from and write to the stream according to the server's protocol.
4. Close the streams.
5. Close the socket.
6.
Only step 3 differs from client to client, depending on the server. The other steps remain largely the same.

---

13.6 Supporting Multiple Clients

multiple client requests can come into the same port and, consequently, into the same ServerSocket. Client connection requests are queued at the port, so the server must accept the connections sequentially. However, the server can service them simultaneously through the use of threads - one thread per each client connection.

while (true) {
    accept a connection ;
    create a thread to deal with the client ;
}

---

13.7 Datagram

A datagram is an independent, self-contained message sent over the network whose arrival, arrival time, and content are not guaranteed.
Clients and servers that communicate via a reliable channel, such as a TCP socket, have a dedicated point-to-point channel between themselves, or at least the illusion(错误的观念) of one. To communicate, they establish a connection, transmit the data, and then close the connection. All data sent over the channel is received in the same order in which it was sent. This is guaranteed by the channel.

In contrast, applications that communicate via datagrams send and receive completely independent packets of information. These clients and servers do not have and do not need a dedicated point-to-point channel. The delivery of datagrams to their destinations is not guaranteed. Nor is the order of their arrival.

The java.net package contains three classes to help you write Java programs that use datagrams to send and receive packets over the network: DatagramSocket, DatagramPacket, and MulticastSocketAn application can send and receive DatagramPackets through a DatagramSocket. In addition, DatagramPackets can be broadcast to multiple recipients all listening to a MulticastSocket.

DatagramSocket
用于UDP通信的套接字，发送端不指定端口；接受端需要指定端口。
DatagramSocket使用send(packet)发送数据、使用receive(packet)接收数据
DatagramPacket
发送：在构造发送的数据报文包时指定接受者的端口和IP地址
接收：接受到的DatagramPacket对象可以使用getAddress()和getPort()获取发送者的IP和端口，从而可以构造发送包交互通信

---

13.8 Writing a Datagram Client and Server

The example featured in this section consists of two applications: a client and a server. The server continuously receives datagram packets over a datagram socket. Each datagram packet received by the server indicates a client request for a quotation. When the server receives a datagram, it replies by sending a datagram packet that contains a one-line "quote of the moment" back to the client.

The client application in this example is fairly simple. It sends a single datagram packet to the server indicating that the client would like to receive a quote of the moment. The client then waits for the server to send a datagram packet in response.

Two classes implement the server application: QuoteServer and QuoteServerThread. A single class implements the client application: QuoteClient.

Let's investigate these classes, starting with the class that contains the main method for the server application. Working With a Server-Side Application contains an applet version of the QuoteClient class.

The QuoteServer Class
The QuoteServer class, shown here in its entirety, contains a single method: the main method for the quote server application. The main method simply creates a new QuoteServerThread object and starts it:

import java.io.*;
public class QuoteServer {
    public static void main(String[] args) throws IOException {
        new QuoteServerThread().start();
    }
}

The QuoteServerThread class implements the main logic of the quote server.

The QuoteServerThread Class
When created, the QuoteServerThread creates a DatagramSocket on port 4445 (arbitrarily chosen). This is the DatagramSocket through which the server communicates with all of its clients.

public QuoteServerThread() throws IOException {
    this("QuoteServer");
}
public QuoteServerThread(String name) throws IOException {
    super(name);
    socket = new DatagramSocket(4445);
    try {
        in = new BufferedReader(new FileReader("one-liners.txt"));
    }   
    catch (FileNotFoundException e){
        System.err.println("Couldn't open quote file.  Serving time instead.");
    }
}  

Remember that certain ports are dedicated to well-known services and you cannot use them. If you specify a port that is in use, the creation of the DatagramSocket will fail.

The constructor also opens a BufferedReader on a file named one-liners.txt which contains a list of quotes. Each quote in the file is on a line by itself.

Now for the interesting part of the QuoteServerThread: its run method. The run method overrides run in the Thread class and provides the implementation for the thread. For information about threads, see Defining and Starting a Thread.

The run method contains a while loop that continues as long as there are more quotes in the file. During each iteration of the loop, the thread waits for a DatagramPacket to arrive over the DatagramSocket. The packet indicates a request from a client. In response to the client's request, the QuoteServerThread gets a quote from the file, puts it in a DatagramPacket and sends it over the DatagramSocket to the client that asked for it.

Let's look first at the section that receives the requests from clients:

byte[] buf = new byte[256];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);

The first statement creates an array of bytes which is then used to create a DatagramPacket. The DatagramPacket will be used to receive a datagram from the socket because of the constructor used to create it. This constructor requires only two arguments: a byte array that contains client-specific data and the length of the byte array. When constructing a DatagramPacket to send over the DatagramSocket, you also must supply the Internet address and port number of the packet's destination. You'll see this later when we discuss how the server responds to a client request.

The last statement in the previous code snippet receives a datagram from the socket (the information received from the client gets copied into the packet). The receive method waits forever until a packet is received. If no packet is received, the server makes no further progress and just waits.

Now assume that, the server has received a request from a client for a quote. Now the server must respond. This section of code in the run method constructs the response:

String dString = null;
if (in == null)
    dString = new Date().toString();
else
    dString = getNextQuote();
buf = dString.getBytes();

If the quote file did not get opened for some reason, then in equals null. If this is the case, the quote server serves up the time of day instead. Otherwise, the quote server gets the next quote from the already opened file. Finally, the code converts the string to an array of bytes.
Now, the run method sends the response to the client over the DatagramSocket with this code:

InetAddress address = packet.getAddress();
int port = packet.getPort();
packet = new DatagramPacket(buf, buf.length, address, port);
socket.send(packet);

The first two statements in this code segment get the Internet address and the port number, respectively, from the datagram packet received from the client. The Internet address and port number indicate where the datagram packet came from. This is where the server must send its response. In this example, the byte array of the datagram packet contains no relevant information. The arrival of the packet itself indicates a request from a client that can be found at the Internet address and port number indicated in the datagram packet.

The third statement creates a new DatagramPacket object intended for sending a datagram message over the datagram socket. You can tell that the new DatagramPacket is intended to send data over the socket because of the constructor used to create it. This constructor requires four arguments. The first two arguments are the same required by the constructor used to create receiving datagrams: a byte array containing the message from the sender to the receiver and the length of this array. The next two arguments are different: an Internet address and a port number. These two arguments are the complete address of the destination of the datagram packet and must be supplied by the sender of the datagram. The last line of code sends the DatagramPacket on its way.

When the server has read all the quotes from the quote file, the while loop terminates and the run method cleans up:

socket.close();

The QuoteClient Class
The QuoteClient class implements a client application for the QuoteServer. This application sends a request to the QuoteServer, waits for the response, and, when the response is received, displays it to the standard output. Let's look at the code in detail.

The QuoteClient class contains one method, the main method for the client application. The top of the main method declares several local variables for its use:

int port;
InetAddress address;
DatagramSocket socket = null;
DatagramPacket packet;
byte[] sendBuf = new byte[256];

First, the main method processes the command-line arguments used to invoke the QuoteClient application:

if (args.length != 1) {
    System.out.println("Usage: java QuoteClient <hostname>");
    return;
}

The QuoteClient application requires one command-line arguments: the name of the machine on which the QuoteServer is running.

Next, the main method creates a DatagramSocket:

DatagramSocket socket = new DatagramSocket();

The client uses a constructor that does not require a port number. This constructor just binds the DatagramSocket to any available local port. It doesn't matter what port the client is bound to because the DatagramPackets contain the addressing information. The server gets the port number from the DatagramPackets and send its response to that port.

Next, the QuoteClient program sends a request to the server:

byte[] buf = new byte[256];
InetAddress address = InetAddress.getByName(args[0]);
DatagramPacket packet = new DatagramPacket(buf, buf.length, address, 4445);
socket.send(packet);

The code segment gets the Internet address for the host named on the command line (presumably the name of the machine on which the server is running). This InetAddress and the port number 4445 (the port number that the server used to create its DatagramSocket) are then used to create DatagramPacket destined for that Internet address and port number. Therefore the DatagramPacket will be delivered to the quote server.

Note that the code creates a DatagramPacket with an empty byte array. The byte array is empty because this datagram packet is simply a request to the server for information. All the server needs to know to send a response--the address and port number to which reply--is automatically part of the packet.

Next, the client gets a response from the server and displays it:

packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
String received = new String(packet.getData(), 0, packet.getLength());
System.out.println("Quote of the Moment: " + received);

To get a response from the server, the client creates a "receive" packet and uses the DatagramSocket receive method to receive the reply from the server. The receive method waits until a datagram packet destined for the client comes through the socket. Note that if the server's reply is somehow lost, the client will wait forever because of the no-guarantee policy of the datagram model. Normally, a client sets a timer so that it doesn't wait forever for a reply; if no reply arrives, the timer goes off and the client retransmits.

When the client receives a reply from the server, the client uses the getData method to retrieve that data from the packet. The client then converts the data to a string and displays it.
Running the Server and Client

After you've successfully compiled the server and the client programs, you run them. You have to run the server program first. Just use the Java interpreter and specify the QuoteServer class name.

Once the server has started, you can run the client program. Remember to run the client program with one command-line argument: the name of the host on which the QuoteServer is running.

After the client sends a request and receives a response from the server, you should see output similar to this:

Quote of the Moment:
Good programming is 99% sweat and 1% coffee.
The whole code is as following:

/*
*QuoteClient
*/
import java.io.*;
import java.net.*;
import java.util.*;
import java.io.*;
public class QuoteClient {
    public static void main(String[] args) throws IOException {
        if (args.length != 1) {
             System.out.println("Usage: java QuoteClient <hostname>");
             return;
        }
    // get a datagram socket
        DatagramSocket socket = new DatagramSocket();
    // send request
    byte[] buf = new byte[256];
    InetAddress address = InetAddress.getByName(args[0]);
    for (int i = 0; i < 5; i++) {
    DatagramPacket packet = new DatagramPacket(buf, buf.length, address, 4445);
    socket.send(packet);
    // get response
    packet = new DatagramPacket(buf, buf.length);
    socket.receive(packet);
    // display response
    String received = new String(packet.getData());
    System.out.println("Quote of the Moment: " + received);
       }
    socket.close();
    }
}

/*
*QuoteServer
*/
import java.io.*;
import java.net.*;
import java.util.*;
public class QuoteServerThread extends Thread {
    protected DatagramSocket socket = null;
    protected BufferedReader in = null;
    protected boolean moreQuotes = true;
    public QuoteServerThread() throws IOException {
    this("QuoteServerThread");
    }
    public QuoteServerThread(String name) throws IOException {
        super(name);
        socket = new DatagramSocket(4445);
        try {
            in = new BufferedReader(new FileReader("one-liners.txt"));
        } catch (FileNotFoundException e) {
            System.err.println("Could not open quote file. Serving time instead.");
        }
    }
    public void run() {
        while (moreQuotes) {
            try {
                byte[] buf = new byte[256];
                    // receive request
                DatagramPacket packet = new DatagramPacket(buf, buf.length);
                socket.receive(packet);
                    // figure out response
                String dString = null;
                if (in == null)
                    dString = new Date().toString();
                else
                    dString = getNextQuote();
                buf = dString.getBytes();
            // send the response to the client at "address" and "port"
                InetAddress address = packet.getAddress();
                int port = packet.getPort();
                packet = new DatagramPacket(buf, buf.length, address, port);
                socket.send(packet);
            } catch (IOException e) {
                e.printStackTrace();
        moreQuotes = false;
            }
        }
        socket.close();
    }
    protected String getNextQuote() {
        String returnValue = null;
        try {
            if ((returnValue = in.readLine()) == null) {
                in.close();
        moreQuotes = false;
                returnValue = "No more quotes. Goodbye.";
            }
        } catch (IOException e) {
            returnValue = "IOException occurred in server.";
        }
        return returnValue;
    }
}
import java.io.*;
public class QuoteServer {
    public static void main(String[] args) throws IOException {
        new QuoteServerThread().start();
    }
}

---

13.9 Broadcasting to Multiple Recipients

In addition to DatagramSocket, which lets programs send packets to one another, java.net includes a class called MulticastSocket. This kind of socket is used on the client-side to listen for packets that the server broadcasts to multiple clients.The InetAddress and port used to construct the DatagramPacket.

Let's rewrite the quote server so that it broadcasts DatagramPackets to multiple recipients.

Instead of sending quotes to a specific client that makes a request, the new server now needs to broadcast quotes at a regular interval. The client needs to be modified so that it passively listens for quotes and does so on a MulticastSocket.

This example is comprised of three classes which are modifications of the three classes from the previous example: MulticastServer, MulticastServerThread, and MulticastClient. This discussion highlights the interesting parts of these classes.

Here is the new version of the server's main program. The differences between this code and the previous version, QuoteServer, are shown in bold:

import java.io.*;
public class MulticastServer {
    public static void main(String[] args) throws IOException {
        new MulticastServerThread().start();
    }
}

Basically, the server got a new name and creates a MulticastServerThread instead of a QuoteServerThread. Now let's look at the MulticastServerThread which contains the heart of the server. Here's its class declaration:

public class MulticastServerThread extends QuoteServerThread {
    // ...
}

We've made this class a subclass of QuoteServerThread so that it can use the constructor, and inherit some member variable and the getNextQuote method. Recall that QuoteServerThread creates a DatagramSocket bound to port 4445 and opens the quote file. The DatagramSocket's port number doesn't actually matter in this example because the client never send anything to the server.
The only method explicitly implemented in MulticastServerThread is its run method. The differences between this run method and the one in QuoteServerThread are shown in bold:

public void run() {
    while (moreQuotes) {
        try {
            byte[] buf = new byte[256];
            // don't wait for request...just send a quote
            String dString = null;
            if (in == null)
                dString = new Date().toString();
            else
                dString = getNextQuote();
            buf = dString.getBytes();
            InetAddress group = InetAddress.getByName("203.0.113.0");
            DatagramPacket packet;
            packet = new DatagramPacket(buf, buf.length, group, 4446);
            socket.send(packet);
            try {
                sleep((long)Math.random() * FIVE_SECONDS);
            } 
            catch (InterruptedException e) { }
        }
        catch (IOException e) {
            e.printStackTrace();
            moreQuotes = false;
        }
    }
    socket.close();
}

The interesting change is how the DatagramPacket is constructed, in particular, the InetAddress and port used to construct the DatagramPacket. Recall that the previous example retrieved the InetAddress and port number from the packet sent to the server from the client. This was because the server needed to reply directly to the client. Now, the server needs to address multiple clients. So this time both the InetAddress and the port number are hard-coded.

The hard-coded port number is 4446 (the client must have a MulticastSocket bound to this port). The hard-coded InetAddress of the DatagramPacket is "203.0.113.0" and is a group identifier (rather than the Internet address of the machine on which a single client is running). This particular address was arbitrarily chosen from the reserved for this purpose.

Created in this way, the DatagramPacket is destined for all clients listening to port number 4446 who are member of the "203.0.113.0" group.

To listen to port number 4446, the new client program just created its MulticastSocket with that port number. To become a member of the "203.0.113.0" group, the client calls the MulticastSocket's joinGroup method with the InetAddress that identifies the group. Now, the client is set up to receive DatagramPackets destined for the port and group specified. Here's the relevant code from the new client program (which was also rewritten to passively receive quotes rather than actively request them). The bold statements are the ones that interact with the MulticastSocket:

MulticastSocket socket = new MulticastSocket(4446);
InetAddress group = InetAddress.getByName("203.0.113.0");
socket.joinGroup(group);
DatagramPacket packet;
for (int i = 0; i < 5; i++) {
    byte[] buf = new byte[256];
    packet = new DatagramPacket(buf, buf.length);
    socket.receive(packet);
    String received = new String(packet.getData());
    System.out.println("Quote of the Moment: " + received);
}
socket.leaveGroup(group);
socket.close();

Notice that the server uses a DatagramSocket to broadcast packet received by the client over a MulticastSocket. Alternatively, it could have used a MulticastSocket. The socket used by the server to send the DatagramPacket is not important. What's important when broadcasting packets is the addressing information contained in the DatagramPacket, and the socket used by the client to listen for it

The whole code is as following:

import java.io.*;
import java.net.*;
import java.util.*;
public class MulticastClient {
    public static void main(String[] args) throws IOException {
        MulticastSocket socket = new MulticastSocket(2020);
        InetAddress group = InetAddress.getByName("230.0.0.1");
        //socket.setTimeToLive(100);
        socket.joinGroup(group);
        DatagramPacket packet;
        for (int i = 0; i < 5; i++) {
            //接收多播数据
            byte[] buf = new byte[256];
            packet = new DatagramPacket(buf, buf.length);
            socket.receive(packet);
            //显示接收结果
            String received = new String(packet.getData(), 0, packet.getLength());
            System.out.println("接收： " + received);
        }
        //离开多播组，关闭套接字
        socket.leaveGroup(group);
        socket.close();
    }
}

import java.io.*;
import java.net.*;
import java.util.*;
import java.text.DateFormat;
public class MulticastServer1 extends Thread{
    protected MulticastSocket socket = null;
    private InetAddress group;
    static int count = 0;
    int port = 2020;
    String groupIP ="230.0.0.1";
    public MulticastServer1() throws IOException {
        //创建绑定到指定地址的多播套接字对象
        //InetSocketAddress ina = new InetSocketAddress("localhost", port);
        //socket = new MulticastSocket(ina);
        socket = new MulticastSocket(port);
        //创建组播组地址
        group = InetAddress.getByName(groupIP);
    }
    public void run() {
        byte[] buf = new byte[256];
        System.out.println("多播服务器启动... ");
        while (true){
            count++;
            String str = "Hello "  + ":" + count;
            System.out.println("广播信息: " + str);
            buf = str.getBytes();
            try {
                //使用多播套接字发送多播数据包
                DatagramPacket packet = new DatagramPacket(buf, buf.length, 
                                group, port);
                socket.send(packet);
                //间隔3秒
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //socket.close();
    }
    public static void main(String[] args) throws Exception {
        new MulticastServer().start();
    }
}

---

13.10 URL

URL is an acronym for Uniform Resource Locator and is a reference (an address) to a resource on the Internet.
As in the previous diagram, a URL has two main components:
Protocol identifier ： HTTP，FTP，Gopher，File and News
Resource name :Host Name , Filename , Port Number , Reference

• Creating a URL
  The URL object can created an absolute URL. You can also create URL objects from a relative URL address.

• Reading Directly from a URL
  After you've successfully created a URL, you can call the URL's openStream() method to get a stream from which you can read the contents of the URL.

• Connecting to a URL
  you can call the URL object‘s openConnection method to connect to it .
• Reading from a URLConnection
  you can use the URLConnection object to perform actions such as reading from or writing to the connection.

  URLConnection yc = yahoo.openConnection();
  BufferedReader in = new BufferedReader(new InputStreamReader(yc.getInputStream()));

---

Appendix

---

ATM src:

package admin;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
public class AdminLogIn {
    private JFrame frame;
    private JPanel northPanel;
    private JLabel titleLabel;
    private JPanel centerPanel;
    private JPanel leftPanel;
    private JPanel rightPanel;
    private JLabel nameLabel;
    private JLabel passwordLabel;
    private JTextField accountTextField;
    private JPasswordField passwordTextField;
    private JPanel buttonPanel;
    private JButton logInButton;
    private JButton signUpButton;
    private JPanel mainPanel;
    private AdminLogIn() {
        frame = new JFrame("ATM Server");
        northPanel = new JPanel();
        titleLabel = new JLabel("Welcome to ATM server");
        centerPanel = new JPanel();
        leftPanel = new JPanel(new GridLayout(2, 1, 10, 10));
        rightPanel = new JPanel(new GridLayout(2, 1, 10, 10));
        nameLabel = new JLabel("Name:");
        passwordLabel = new JLabel("Password:");
        accountTextField = new JTextField();
        passwordTextField = new JPasswordField();
        buttonPanel = new JPanel();
        logInButton = new JButton("Log In");
        signUpButton = new JButton("Sign Up");
        mainPanel = new JPanel();
    }
    private void lunchFrame() {
        frame.setPreferredSize(new Dimension(700, 400));
        mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));
        northPanel.setLayout(new BoxLayout(northPanel, BoxLayout.Y_AXIS));
        northPanel.add(titleLabel);
        titleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
        mainPanel.add(northPanel);
        leftPanel.setPreferredSize(new Dimension(20, 70));
        leftPanel.add(nameLabel);
        leftPanel.add(passwordLabel);
        rightPanel.setPreferredSize(new Dimension(200, 70));
        rightPanel.add(accountTextField);
        rightPanel.add(passwordTextField);
        centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.X_AXIS));
        centerPanel.add(Box.createHorizontalGlue());
        centerPanel.add(leftPanel);
        centerPanel.add(rightPanel);
        centerPanel.add(Box.createHorizontalGlue());
        buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
        JLabel unLabel = new JLabel();
        unLabel.setPreferredSize(new Dimension(80,30));
        buttonPanel.add(unLabel);
        buttonPanel.add(Box.createRigidArea(new Dimension(100,30)));
        buttonPanel.add(logInButton);
        logInButton.addActionListener(new LogInAction());
        buttonPanel.add(Box.createRigidArea(new Dimension(200,30)));
        buttonPanel.add(signUpButton);
        signUpButton.addActionListener(new SignUpAction());
        buttonPanel.add(Box.createHorizontalGlue());
        buttonPanel.add(Box.createHorizontalGlue());
        mainPanel.add(Box.createRigidArea(new Dimension(700, 50)));
        mainPanel.add(centerPanel);
        mainPanel.add(Box.createRigidArea(new Dimension(700, 50)));
        mainPanel.add(buttonPanel);
        mainPanel.add(Box.createRigidArea(new Dimension(700, 200)));
        frame.add(mainPanel);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
    private class LogInAction implements ActionListener {
        JDialog logInDialog;
        JTextField nameTextField;
        JPasswordField firstPasswordField;
        JPasswordField secondPasswordField;
        @Override
        public void actionPerformed(ActionEvent e) {
            logInDialog = new JDialog(frame, "Log In", false);
            logInDialog.setPreferredSize(new Dimension(700, 400));
            logInDialog.setLayout(new BorderLayout());
            JPanel dialogPanel = new JPanel();
            dialogPanel.setLayout(new BorderLayout());
            JPanel northPanel = new JPanel();
            northPanel.setPreferredSize(new Dimension(700, 100));
            JPanel southPanel = new JPanel();
            southPanel.setPreferredSize(new Dimension(700, 100));
            JPanel westPanel = new JPanel();
            westPanel.setPreferredSize(new Dimension(30, 400));
            JPanel eastPanel = new JPanel();
            eastPanel.setPreferredSize(new Dimension(30, 400));
            JPanel diaLeftPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JPanel diaRightPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JLabel nameLabel = new JLabel("Name");
            JLabel dialogPasswordLabel = new JLabel("Password");
            JLabel againLabel = new JLabel("Again");
            JLabel nullLabel = new JLabel();
            diaLeftPanel.add(nameLabel);
            diaLeftPanel.add(dialogPasswordLabel);
            diaLeftPanel.add(againLabel);
            diaLeftPanel.add(nullLabel);
            nameTextField = new JTextField();
            firstPasswordField = new JPasswordField();
            secondPasswordField = new JPasswordField();
            JLabel noneLabel = new JLabel();
            diaRightPanel.add(nameTextField);
            diaRightPanel.add(firstPasswordField);
            diaRightPanel.add(secondPasswordField);
            diaRightPanel.add(noneLabel);
            dialogPanel.add(diaLeftPanel, BorderLayout.WEST);
            dialogPanel.add(diaRightPanel, BorderLayout.CENTER);
            JButton OKButton = new JButton("OK");
            OKButton.addActionListener(new PassErrorAction());
            JPanel buttonPanel = new JPanel();
            buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.Y_AXIS));
            OKButton.setAlignmentX(Component.CENTER_ALIGNMENT);
            buttonPanel.add(OKButton);
            dialogPanel.add(buttonPanel, BorderLayout.SOUTH);
            logInDialog.add(dialogPanel, BorderLayout.CENTER);
            logInDialog.add(northPanel, BorderLayout.NORTH);
            logInDialog.add(southPanel, BorderLayout.SOUTH);
            logInDialog.add(westPanel, BorderLayout.WEST);
            logInDialog.add(eastPanel, BorderLayout.EAST);
            logInDialog.pack();
            logInDialog.setLocationRelativeTo(null);
            logInDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            logInDialog.setVisible(true);
        }
        private class PassErrorAction implements ActionListener {
            @Override
            public void actionPerformed(ActionEvent e) {
                String name = nameTextField.getText();
                String firstPassword = String.valueOf(firstPasswordField.getPassword());
                String secondPassword = String.valueOf(secondPasswordField.getPassword());
                int result = 0;
                if (firstPassword.length() != secondPassword.length()) {
                    result = 2;
                }
                if (!firstPassword.equals(secondPassword)) {
                    result = 1;
                }
                switch (result) {
                    case 0:
                        String logInMessage = "0" + "-" + 0 + "-" + name + "-" + firstPassword;
                        AdminNet net = AdminNet.getAdminNet();
                        PrintWriter out = net.getPrintWriter();
                        out.println(logInMessage);
                        logInDialog.setVisible(false);
                        break;
                    case 1:
                        LogInError error1 = new LogInError();
                        error1.lunch();
                        break;
                    case 2:
                        LogInError error2 = new LogInError();
                        error2.lunch();
                        break;
                }
            }
        }
    }
    private class LogInError {
        void lunch() {
            JDialog error = new JDialog(frame, "ERROR", false);
            error.setPreferredSize(new Dimension(300, 150));
            JLabel errorMessage = new JLabel("The Passwords are different.", JLabel.CENTER);
            error.add(errorMessage);
            error.pack();
            error.setLocationRelativeTo(null);
            error.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            error.setVisible(true);
        }
    }
    private class SignUpAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            boolean mark = false;
            String account = accountTextField.getText();
            String password = String.valueOf(passwordTextField.getPassword());
            AdminNet adminNet = AdminNet.getAdminNet();
            BufferedReader inBufferedReader = adminNet.getBufferedReader();
            PrintWriter outPrintWriter = adminNet.getPrintWriter();
            String result = "0";
            try {
                outPrintWriter.println("0" + "-" + 1 + "-" + account + "-" + password);
                result = inBufferedReader.readLine();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            JDialog errorDialog = new JDialog(frame, "Error", false);
            JLabel labelError = new JLabel("", JLabel.CENTER);
            switch (result) {
                case "0":
                    labelError.setText("The Account Doesn't Exist.");
                    errorDialog.add(labelError);
                    break;
                case "1":
                    labelError.setText("Account Is Empty.");
                    errorDialog.add(labelError);
                    break;
                case "2":
                    labelError.setText("Password Is Empty.");
                    errorDialog.add(labelError);
                    break;
                case "3":
                    mark = true;
                    frame.setVisible(false);
                    AdminMainWindow mainWindow = new AdminMainWindow();
                    mainWindow.lunchFrame();
                    break;
                case "4":
                    labelError.setText("Password Is Wrong.");
                    errorDialog.add(labelError);
                    break;
            }
            if (!mark) {
                errorDialog.setPreferredSize(new Dimension(300, 150));
                errorDialog.setLocationRelativeTo(null);
                errorDialog.pack();
                errorDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
                errorDialog.setVisible(true);
            }
        }
    }
    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(() -> {
            new AdminLogIn().lunchFrame();
        });
    }
}

package admin;
import bank.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.StringTokenizer;
public class AdminMainWindow {
    /* Stander error stream */
    static private PrintWriter stdErr = new PrintWriter(System.err, true);
    private JFrame frame;
    private JButton addModifyButton;
    private JButton removeButton;
    private JLabel noLabel;
    private JButton displayButton;
    private JTextArea statusTextArea;
    private JPanel centerPanel;
    private JButton searchButton;
    private JTextField searchTextField;
    private JPanel searchPanel;
    private JPanel northPanel;
    private JPanel westPanel;
    private JPanel eastPanel;
    private JPanel southPanel;
    private JPanel southNorthPanel;
    private JPanel southEastPanel;
    private JPanel southSouthPanel;
    private JPanel southCenterPanel;
    private JPanel centerCenterPanel;
    private JScrollPane textPane;
    private JPanel leftPanel;
    private JPanel rightPanel;
    private JLabel label1;
    private JLabel label2;
    private JLabel label3;
    private JLabel label4;
    private JTextField textField1;
    private JTextField textField2;
    private JTextField textField3;
    private JTextField textField4;
    private JLabel noneLabel;
    private JPanel buttonGroup;
    //TODO what this?
    private boolean logIn = false;
    AdminMainWindow() {
        frame = new JFrame("ATM Server");
        addModifyButton = new JButton("Add");
        removeButton = new JButton("Remove");
        noLabel = new JLabel();
        displayButton = new JButton("Exit");
        statusTextArea = new JTextArea();
        centerPanel = new JPanel(new BorderLayout());
        searchButton = new JButton("Search");
        searchTextField = new JTextField();
        searchPanel = new JPanel();
        northPanel = new JPanel();
        westPanel = new JPanel();
        eastPanel = new JPanel();
        southPanel = new JPanel(new BorderLayout());
        southNorthPanel = new JPanel();
        southEastPanel = new JPanel();
        southSouthPanel = new JPanel();
        southCenterPanel = new JPanel();
        centerCenterPanel = new JPanel(new BorderLayout());
        buttonGroup = new JPanel(new GridLayout(4, 1, 10, 10));
        textPane = new JScrollPane(statusTextArea, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED, JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        leftPanel = new JPanel(new GridLayout(4, 1, 10, 10));
        rightPanel = new JPanel(new GridLayout(4, 1, 10, 10));
        label1 = new JLabel("Name");
        label2 = new JLabel("Card ID");
        label3 = new JLabel("Telephone");
        label4 = new JLabel("Balance");
        textField1 = new JTextField();
        textField2 = new JTextField();
        textField3 = new JTextField();
        textField4 = new JTextField();
        noneLabel = new JLabel();
        AdminNet adminNet = AdminNet.getAdminNet();
    }
    void lunchFrame() {
        frame.setLayout(new BorderLayout());
        searchPanel.setLayout(new BoxLayout(searchPanel, BoxLayout.X_AXIS));
        searchPanel.add(Box.createHorizontalGlue());
        searchTextField.setPreferredSize(new Dimension(50, 20));
        searchPanel.add(searchTextField);
        searchPanel.add(Box.createRigidArea(new Dimension(50, 20)));
        searchPanel.add(searchButton);
        searchButton.addActionListener(new SearchAction());
        searchPanel.add(Box.createHorizontalGlue());
        statusTextArea.setEditable(false);
        buttonGroup.add(noneLabel);
        buttonGroup.add(addModifyButton);
        addModifyButton.addActionListener(new AddAction());
        buttonGroup.add(removeButton);
        removeButton.addActionListener(new RemoveAction());
        buttonGroup.add(noLabel);
        centerCenterPanel.add(buttonGroup, BorderLayout.EAST);
        JPanel centerWestPanel = new JPanel();
        centerWestPanel.setPreferredSize(new Dimension(30, 100));
        JPanel centerNorthPanel = new JPanel();
        centerNorthPanel.setPreferredSize(new Dimension(700, 10));
        JPanel centerSouthPanel = new JPanel();
        centerSouthPanel.setPreferredSize(new Dimension(700, 10));
        centerCenterPanel.add(centerNorthPanel, BorderLayout.NORTH);
        centerCenterPanel.add(centerSouthPanel, BorderLayout.SOUTH);
        textField2.setEditable(false);
        textField4.setEditable(false);
        leftPanel.add(label1);
        leftPanel.add(label2);
        leftPanel.add(label3);
        leftPanel.add(label4);
        rightPanel.add(textField1);
        rightPanel.add(textField2);
        rightPanel.add(textField3);
        rightPanel.add(textField4);
        centerCenterPanel.add(leftPanel, BorderLayout.WEST);
        centerCenterPanel.add(rightPanel, BorderLayout.CENTER);
        textPane.setPreferredSize(new Dimension(500, 200));
        centerPanel.add(searchPanel, BorderLayout.NORTH);
        centerPanel.add(textPane, BorderLayout.SOUTH);
        centerPanel.add(centerCenterPanel, BorderLayout.CENTER);
        southCenterPanel.setLayout(new BoxLayout(southCenterPanel, BoxLayout.Y_AXIS));
        displayButton.setAlignmentX(Component.RIGHT_ALIGNMENT);
        southCenterPanel.add(displayButton);
        displayButton.addActionListener(new ExitAction());
        southSouthPanel.setPreferredSize(new Dimension(700, 10));
        southNorthPanel.setPreferredSize(new Dimension(700, 10));
        southEastPanel.setPreferredSize(new Dimension(10, 30));
        southPanel.add(southNorthPanel, BorderLayout.NORTH);
        southPanel.add(southSouthPanel, BorderLayout.SOUTH);
        southPanel.add(southCenterPanel, BorderLayout.CENTER);
        southPanel.add(southEastPanel, BorderLayout.EAST);
        frame.add(northPanel, BorderLayout.NORTH);
        frame.add(centerPanel, BorderLayout.CENTER);
        frame.add(eastPanel, BorderLayout.EAST);
        frame.add(westPanel, BorderLayout.WEST);
        frame.add(southPanel, BorderLayout.SOUTH);
        frame.pack();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        /* Window width in pixels */
        int WIDTH = 620;
        /* Window height in pixels */
        int HEIGHT = 530;
        frame.setSize(WIDTH, HEIGHT);
        frame.setLocationRelativeTo(null);
        frame.setResizable(true);
        frame.setVisible(true);
    }
    private class AddAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            AdminNet adminNet = AdminNet.getAdminNet();
            PrintWriter adminWriter = adminNet.getPrintWriter();
            String name = textField1.getText();
            String telephone = textField3.getText();
            String addInfo = "1" + "-" + 0 + "-" + name + "-" + "00000000-" + telephone;
            adminWriter.println(addInfo);
            BufferedReader logInRead = adminNet.getBufferedReader();
            String id = "";
            try {
                id = logInRead.readLine();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            textField2.setText(id);
            textField4.setText("0.0");
        }
    }
    private class RemoveAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            String id = searchTextField.getText();
            String cardInfo = "1-7-YCL-" + id + "-123456";
            AdminNet adminNet = AdminNet.getAdminNet();
            PrintWriter adminPrint = adminNet.getPrintWriter();
            adminPrint.println(cardInfo);
            statusTextArea.setText("The card" + id + " has been removed");
        }
    }
    private class ExitAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.exit(0);
        }
    }
    private class SearchAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            String id = searchTextField.getText();
            String cardInfo = "1-6-YCL-" + id + "-123456";
            AdminNet adminNet = AdminNet.getAdminNet();
            PrintWriter adminPrint = adminNet.getPrintWriter();
            BufferedReader adminBuffered = adminNet.getBufferedReader();
            adminPrint.println(cardInfo);
            String cardInformation = "";
            try {
                cardInformation = adminBuffered.readLine();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            if (cardInformation.equals("error")) {
                statusTextArea.setText("The ID doesn't exist");
            } else {
                StringTokenizer info = new StringTokenizer(cardInformation, "-", false);
                String side = info.nextToken();
                String name = info.nextToken();
                String telephone = info.nextToken();
                String balance = info.nextToken();
                textField1.setText(name);
                textField2.setText(id);
                textField3.setText(telephone);
                textField4.setText(balance);
            }
        }
    }
}

package admin;
import java.io.*;
import java.net.Socket;
public class AdminNet {
    private BufferedReader bufferedReader;
    private PrintWriter printWriter;
    private static AdminNet adminNet;
    private AdminNet() {
        try {
            //TODO why only local net?
            Socket socket = new Socket("127.0.0.1", 4448);
            bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            printWriter = new PrintWriter(socket.getOutputStream(), true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    static AdminNet getAdminNet() {
        if (adminNet == null) {
            adminNet = new AdminNet();
        }
        return adminNet;
    }
    BufferedReader getBufferedReader() {
        return bufferedReader;
    }
    PrintWriter getPrintWriter() {
        return printWriter;
    }
    //TODO NEVER USE
    public void operation() {
        try {
            bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package admin;
import java.io.*;
import java.util.StringTokenizer;
public class AdminAccountManage {
    private BufferedReader in;
    private PrintWriter out;
    public AdminAccountManage() {
        File accountRecord = new File("Admin.txt");
        try {
            in = new BufferedReader(new FileReader(accountRecord));
            out = new PrintWriter(new FileWriter(accountRecord, true), true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public int accountManage(String account, String password, String operation) {
        switch (operation) {
            case "0":
                String newAdmin = account + "-" + password;
                out.println(newAdmin);
                break;
            case "1":
                if (account == null || account.equals("")) {
                    return 1;
                }
                if (password == null || password.equals("")) {
                    return 2;
                }
                try {
                    String message = in.readLine();
                    while (message != null && !message.equals("")) {
                        StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                        String name = stringTokenizer.nextToken();
                        String pass = stringTokenizer.nextToken();
                        if (name.equals(account)) {
                            if (pass.equals(password)) {
                                return 3;
                            } else {
                                return 4;
                            }
                        }
                        message = in.readLine();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                break;
        }
        return 0;
    }
}

package client;
import bank.ATMBank;
import bank.Card;
import bank.Customer;
import javax.swing.*;
import javax.swing.plaf.basic.DefaultMenuLayout;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class ATMLogIn {
    private JFrame frame;
    private JPanel northPanel;
    private JLabel titleLabel;
    private JPanel centerPanel;
    private JPanel leftPanel;
    private JPanel rightPanel;
    private JLabel nameLabel;
    private JLabel passwordLabel;
    private JTextField accountTextField;
    private JPasswordField passwordTextField;
    private JPanel buttonPanel;
    private JButton logInButton;
    private JButton signUpButton;
    private JButton findPasswordButton;
    private JPanel mainPanel;
    public ATMLogIn() {
        frame = new JFrame("ATM");
        northPanel = new JPanel();
        titleLabel = new JLabel("Welcome to ATM");
        centerPanel = new JPanel();
        leftPanel = new JPanel(new GridLayout(2, 1, 10, 10));
        rightPanel = new JPanel(new GridLayout(2, 1, 10, 10));
        nameLabel = new JLabel("Card ID:");
        passwordLabel = new JLabel("Password:");
        accountTextField = new JTextField();
        passwordTextField = new JPasswordField();
        buttonPanel = new JPanel();
        logInButton = new JButton("Log In");
        signUpButton = new JButton("Sign Up");
        findPasswordButton = new JButton("Forget password");
        mainPanel = new JPanel();
    }
    public void lunchFrame() {
        frame.setPreferredSize(new Dimension(700, 400));
        mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));
        northPanel.setLayout(new BoxLayout(northPanel, BoxLayout.Y_AXIS));
        northPanel.add(titleLabel);
        titleLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
        mainPanel.add(northPanel);
        leftPanel.setPreferredSize(new Dimension(20, 70));
        leftPanel.add(nameLabel);
        leftPanel.add(passwordLabel);
        rightPanel.setPreferredSize(new Dimension(200, 70));
        rightPanel.add(accountTextField);
        rightPanel.add(passwordTextField);
        centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.X_AXIS));
        centerPanel.add(Box.createHorizontalGlue());
        centerPanel.add(leftPanel);
        centerPanel.add(rightPanel);
        centerPanel.add(Box.createHorizontalGlue());
        // frame.add(centerPanel,BorderLayout.CENTER);
        buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
        buttonPanel.add(Box.createHorizontalGlue());
        buttonPanel.add(logInButton);
        logInButton.addActionListener(new LogInAction());
        buttonPanel.add(Box.createHorizontalGlue());
        buttonPanel.add(signUpButton);
        signUpButton.addActionListener(new SignUpAction());
        buttonPanel.add(Box.createHorizontalGlue());
        buttonPanel.add(findPasswordButton);
        findPasswordButton.addActionListener(new FindPasswordAction());
        buttonPanel.add(Box.createHorizontalGlue());
        //frame.add(new JPanel(),BorderLayout.SOUTH);
        mainPanel.add(Box.createRigidArea(new Dimension(700, 50)));
        mainPanel.add(centerPanel);
        mainPanel.add(Box.createRigidArea(new Dimension(700, 50)));
        mainPanel.add(buttonPanel);
        mainPanel.add(Box.createRigidArea(new Dimension(700, 200)));
        frame.add(mainPanel);
        frame.setResizable(false);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
    private class LogInAction implements ActionListener {
        JDialog logInDialog;
        JTextField nameTextField;
        JPasswordField firstPasswordField;
        JPasswordField secondPasswordField;
        @Override
        public void actionPerformed(ActionEvent e) {
            logInDialog = new JDialog(frame, "Log In", false);
            logInDialog.setPreferredSize(new Dimension(700, 400));
            logInDialog.setLayout(new BorderLayout());
            JPanel dialogPanel = new JPanel();
            dialogPanel.setLayout(new BorderLayout());
            JPanel northPanel = new JPanel();
            northPanel.setPreferredSize(new Dimension(700, 100));
            JPanel southPanel = new JPanel();
            southPanel.setPreferredSize(new Dimension(700, 100));
            JPanel westPanel = new JPanel();
            westPanel.setPreferredSize(new Dimension(30, 400));
            JPanel eastPanel = new JPanel();
            eastPanel.setPreferredSize(new Dimension(30, 400));
            JPanel diaLeftPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JPanel diaRightPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JLabel nameLabel = new JLabel("Name");
            JLabel dialogPasswordLabel = new JLabel("Telephone");
            JLabel againLabel = new JLabel("Again");
            JLabel nullLabel = new JLabel();
            diaLeftPanel.add(nameLabel);
            diaLeftPanel.add(dialogPasswordLabel);
            diaLeftPanel.add(againLabel);
            diaLeftPanel.add(nullLabel);
            nameTextField = new JTextField();
            firstPasswordField = new JPasswordField();
            secondPasswordField = new JPasswordField();
            JLabel noneLabel = new JLabel();
            diaRightPanel.add(nameTextField);
            diaRightPanel.add(firstPasswordField);
            diaRightPanel.add(secondPasswordField);
            diaRightPanel.add(noneLabel);
            dialogPanel.add(diaLeftPanel, BorderLayout.WEST);
            dialogPanel.add(diaRightPanel, BorderLayout.CENTER);
            JButton OKButton = new JButton("OK");
            JButton finishButton = new JButton("Finish");
            OKButton.addActionListener(new PassErrorAction());
            finishButton.addActionListener(new FinishAction());
            JPanel buttonPanel = new JPanel();
            buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
            JLabel unUseLabel = new JLabel();
            unUseLabel.setPreferredSize(new Dimension(150, 30));
            buttonPanel.add(unUseLabel);
            buttonPanel.add(Box.createRigidArea(new Dimension(220, 30)));
            buttonPanel.add(OKButton);
            buttonPanel.add(Box.createRigidArea(new Dimension(100, 30)));
            buttonPanel.add(finishButton);
            dialogPanel.add(buttonPanel, BorderLayout.SOUTH);
            logInDialog.add(dialogPanel, BorderLayout.CENTER);
            logInDialog.add(northPanel, BorderLayout.NORTH);
            logInDialog.add(southPanel, BorderLayout.SOUTH);
            logInDialog.add(westPanel, BorderLayout.WEST);
            logInDialog.add(eastPanel, BorderLayout.EAST);
            logInDialog.pack();
            logInDialog.setLocationRelativeTo(null);
            logInDialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
            logInDialog.setVisible(true);
        }
        private class FinishAction implements ActionListener {
            @Override
            public void actionPerformed(ActionEvent e) {
                logInDialog.setVisible(false);
            }
        }
        private class PassErrorAction implements ActionListener {
            @Override
            public void actionPerformed(ActionEvent e) {
                String name = nameTextField.getText();
                char[] firstTelephone = firstPasswordField.getPassword();
                char[] secondTelephone = secondPasswordField.getPassword();
                int result = 0;
                if (name.equals("") || name == null) {
                    result = -1;
                } else if (firstTelephone.length == secondTelephone.length) {
                    for (int i = 0; i < firstTelephone.length; i++) {
                        if (firstTelephone[i] == secondTelephone[i]) {
                            result = 0;
                        } else {
                            result = 1;
                            break;
                        }
                    }
                } else {
                    result = 2;
                }
                switch (result) {
                    case -1: {
                        LogInError error1 = new LogInError();
                        error1.lunch(-1);
                        break;
                    }
                    case 0: {
                        String logInPassword = "";
                        for (int i = 0; i < firstTelephone.length; i++) {
                            logInPassword += firstTelephone[i];
                        }
                        String logInMessage = "1" + "-" + 0 + "-" + name + "-" + "00000000-" + logInPassword;
                        ATMNet net = ATMNet.getAtmNet();
                        PrintWriter out = net.getPrintWriter();
                        out.println(logInMessage);
                        BufferedReader logInRead = net.getBufferedReader();
                        String id = "";
                        try {
                            id = logInRead.readLine();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                        JDialog dialog = new JDialog(logInDialog, "Message", false);
                        JLabel label1 = new JLabel("", JLabel.CENTER);
                        JLabel label2 = new JLabel("", JLabel.CENTER);
                        JPanel panel = new JPanel(new BorderLayout());
                        JPanel northPanel = new JPanel();
                        northPanel.setPreferredSize(new Dimension(300, 30));
                        JPanel southPanel = new JPanel();
                        southPanel.setPreferredSize(new Dimension(300, 30));
                        JPanel centerPanel = new JPanel();
                        centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.X_AXIS));
                        dialog.setPreferredSize(new Dimension(300, 150));
                        String information = "ID:" + id;
                        String info = "Password:123456";
                        label2.setText(info);
                        label1.setText(information);
                        JLabel unLabel = new JLabel();
                        unLabel.setPreferredSize(new Dimension(30,30));
                        centerPanel.add(unLabel);
                        centerPanel.add(Box.createRigidArea(new Dimension(80,30)));
                        centerPanel.add(label1);
                        centerPanel.add(Box.createRigidArea(new Dimension(20, 30)));
                        centerPanel.add(label2);
                        panel.add(northPanel, BorderLayout.NORTH);
                        panel.add(southPanel, BorderLayout.SOUTH);
                        panel.add(centerPanel, BorderLayout.CENTER);
                        dialog.add(panel);
                        dialog.pack();
                        dialog.setLocationRelativeTo(null);
                        dialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
                        dialog.setVisible(true);
                        break;
                    }
                    case 1: {
                        LogInError error1 = new LogInError();
                        error1.lunch(1);
                        break;
                    }
                    case 2: {
                        LogInError error2 = new LogInError();
                        error2.lunch(2);
                        break;
                    }
                }
            }
        }
    }
    private class LogInError {
        public void lunch(int result) {
            JDialog error = new JDialog(frame, "ERROR", false);
            error.setPreferredSize(new Dimension(300, 150));
            JLabel errorMessage = new JLabel("", JLabel.CENTER);
            if (result == -1) {
                errorMessage.setText("The Name Is Empty.");
            } else {
                errorMessage.setText("The Passwords are different.");
            }
            error.add(errorMessage);
            error.pack();
            error.setLocationRelativeTo(null);
            error.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
            error.setVisible(true);
        }
    }
    private class SignUpAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            boolean mark = false;
            String account = accountTextField.getText();
            char[] passwordTemp = passwordTextField.getPassword();
            String password = "";
            for (int i = 0; i < passwordTemp.length; i++) {
                password += passwordTemp[i];
            }
            ATMNet atmNet = ATMNet.getAtmNet();
            BufferedReader inBufferedReader = atmNet.getBufferedReader();
            PrintWriter outPrintWriter = atmNet.getPrintWriter();
            String result = "0";
            try {
                outPrintWriter.println("1" + "-" + 1 + "-" + "YCL" + "-" + account + "-" + password);
                result = inBufferedReader.readLine();
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            StringTokenizer stringTokenizer = new StringTokenizer(result, "-", false);
            String num = stringTokenizer.nextToken();
            String balance = stringTokenizer.nextToken();
            JDialog errorDialog = new JDialog(frame, "Error", false);
            JLabel labelError = new JLabel("", JLabel.CENTER);
            switch (num) {
                case "0": {
                    labelError.setText("The Account Doesn't Exist.");
                    errorDialog.add(labelError);
                    break;
                }
                case "1": {
                    labelError.setText("Account Is Empty.");
                    errorDialog.add(labelError);
                    break;
                }
                case "2": {
                    labelError.setText("Password Is Empty.");
                    errorDialog.add(labelError);
                    break;
                }
                case "3": {
                    mark = true;
                    frame.setVisible(false);
                    Card card = new Card(account);
                    card.setBalance(balance, 1);
                    ATMMainWindow mainWindow = new ATMMainWindow(card);
                    mainWindow.lunchFrame();
                    break;
                }
                case "4": {
                    labelError.setText("Password Is Wrong.");
                    errorDialog.add(labelError);
                    break;
                }
                case "5":{
                    labelError.setText("The client has logged.");
                    errorDialog.add(labelError);
                    break;
                }
            }
            if (mark == false) {
                errorDialog.setPreferredSize(new Dimension(300, 150));
                errorDialog.pack();
                errorDialog.setLocationRelativeTo(null);
                errorDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
                errorDialog.setVisible(true);
            }
        }
    }
    private class FindPasswordAction implements ActionListener {
        JDialog logInDialog;
        JTextField nameTextField;
        JPasswordField firstPasswordField;
        JPasswordField secondPasswordField;
        @Override
        public void actionPerformed(ActionEvent e) {
            logInDialog = new JDialog(frame, "Forget Password", false);
            logInDialog.setPreferredSize(new Dimension(700, 400));
            logInDialog.setLayout(new BorderLayout());
            JPanel dialogPanel = new JPanel();
            dialogPanel.setLayout(new BorderLayout());
            JPanel northPanel = new JPanel();
            northPanel.setPreferredSize(new Dimension(700, 100));
            JPanel southPanel = new JPanel();
            southPanel.setPreferredSize(new Dimension(700, 100));
            JPanel westPanel = new JPanel();
            westPanel.setPreferredSize(new Dimension(30, 400));
            JPanel eastPanel = new JPanel();
            eastPanel.setPreferredSize(new Dimension(30, 400));
            JPanel diaLeftPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JPanel diaRightPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JLabel nameLabel = new JLabel("ID");
            JLabel dialogPasswordLabel = new JLabel("Telephone");
            JLabel againLabel = new JLabel("Again");
            JLabel nullLabel = new JLabel();
            diaLeftPanel.add(nameLabel);
            diaLeftPanel.add(dialogPasswordLabel);
            diaLeftPanel.add(againLabel);
            diaLeftPanel.add(nullLabel);
            nameTextField = new JTextField();
            firstPasswordField = new JPasswordField();
            secondPasswordField = new JPasswordField();
            JLabel noneLabel = new JLabel();
            diaRightPanel.add(nameTextField);
            diaRightPanel.add(firstPasswordField);
            diaRightPanel.add(secondPasswordField);
            diaRightPanel.add(noneLabel);
            dialogPanel.add(diaLeftPanel, BorderLayout.WEST);
            dialogPanel.add(diaRightPanel, BorderLayout.CENTER);
            JButton OKButton = new JButton("OK");
            JButton finishButton = new JButton("Finish");
            OKButton.addActionListener(new TeleErrorAction());
            finishButton.addActionListener(new FinishAction());
            JPanel buttonPanel = new JPanel();
            buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.X_AXIS));
            JLabel unUseLabel = new JLabel();
            unUseLabel.setPreferredSize(new Dimension(150, 30));
            buttonPanel.add(unUseLabel);
            buttonPanel.add(Box.createRigidArea(new Dimension(220, 30)));
            buttonPanel.add(OKButton);
            buttonPanel.add(Box.createRigidArea(new Dimension(100, 30)));
            buttonPanel.add(finishButton);
            dialogPanel.add(buttonPanel, BorderLayout.SOUTH);
            logInDialog.add(dialogPanel, BorderLayout.CENTER);
            logInDialog.add(northPanel, BorderLayout.NORTH);
            logInDialog.add(southPanel, BorderLayout.SOUTH);
            logInDialog.add(westPanel, BorderLayout.WEST);
            logInDialog.add(eastPanel, BorderLayout.EAST);
            logInDialog.pack();
            logInDialog.setLocationRelativeTo(null);
            logInDialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
            logInDialog.setVisible(true);
        }
        private class FinishAction implements ActionListener {
            @Override
            public void actionPerformed(ActionEvent e) {
                logInDialog.setVisible(false);
            }
        }
        private class TeleErrorAction implements ActionListener {
            @Override
            public void actionPerformed(ActionEvent e) {
                String name = nameTextField.getText();
                char[] firstTelephone = firstPasswordField.getPassword();
                char[] secondTelephone = secondPasswordField.getPassword();
                int result = 0;
                if (name.equals("") || name == null) {
                    result = -1;
                } else if (firstTelephone.length == secondTelephone.length) {
                    for (int i = 0; i < firstTelephone.length; i++) {
                        if (firstTelephone[i] == secondTelephone[i]) {
                            result = 0;
                        } else {
                            result = 1;
                            break;
                        }
                    }
                } else {
                    result = 2;
                }
                switch (result) {
                    case -1: {
                        FindError error1 = new FindError();
                        error1.lunch(-1);
                        break;
                    }
                    case 0: {
                        String logInPassword = "";
                        for (int i = 0; i < firstTelephone.length; i++) {
                            logInPassword += firstTelephone[i];
                        }
                        String logInMessage = "1" + "-" + 9 + "-" + name + "-" + "00000000-" + logInPassword;
                        ATMNet net = ATMNet.getAtmNet();
                        PrintWriter out = net.getPrintWriter();
                        out.println(logInMessage);
                        BufferedReader logInRead = net.getBufferedReader();
                        String id = "";
                        try {
                            id = logInRead.readLine();
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        }
                        switch (id) {
                            case "0": {
                                JDialog dialog = new JDialog(logInDialog, "Message", false);
                                JLabel label1 = new JLabel("", JLabel.CENTER);
                                JLabel label2 = new JLabel("", JLabel.CENTER);
                                JPanel panel = new JPanel(new BorderLayout());
                                JPanel northPanel = new JPanel();
                                northPanel.setPreferredSize(new Dimension(300, 30));
                                JPanel southPanel = new JPanel();
                                southPanel.setPreferredSize(new Dimension(300, 30));
                                JPanel centerPanel = new JPanel();
                                centerPanel.setLayout(new BoxLayout(centerPanel, BoxLayout.X_AXIS));
                                dialog.setPreferredSize(new Dimension(300, 150));
                                label1.setPreferredSize(new Dimension(30,30));
                                String info = "Password:123456";
                                label2.setText(info);
                                centerPanel.add(label1);
                                centerPanel.add(Box.createRigidArea(new Dimension(100, 30)));
                                centerPanel.add(label2);
                                panel.add(northPanel, BorderLayout.NORTH);
                                panel.add(southPanel, BorderLayout.SOUTH);
                                panel.add(centerPanel, BorderLayout.CENTER);
                                dialog.add(panel);
                                dialog.pack();
                                dialog.setLocationRelativeTo(null);
                                dialog.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
                                dialog.setVisible(true);
                                break;
                            }
                            case "0-0":{
                                FindError error0 = new FindError();
                                error0.lunch(99);
                            }
                        }
                        break;
                    }
                    case 1: {
                        FindError error1 = new FindError();
                        error1.lunch(1);
                        break;
                    }
                    case 2: {
                        FindError error2 = new FindError();
                        error2.lunch(2);
                        break;
                    }
                }
            }
        }
    }
    private class FindError {
        public void lunch(int result) {
            JDialog error = new JDialog(frame, "ERROR", false);
            error.setPreferredSize(new Dimension(300, 150));
            JLabel errorMessage = new JLabel("", JLabel.CENTER);
            if (result == -1) {
                errorMessage.setText("The Name Is Empty.");
            }else if(result==99){
                errorMessage.setText("The Account Doesn't Exist.");
            }
            else {
                errorMessage.setText("The Telephone are different.");
            }
            error.add(errorMessage);
            error.pack();
            error.setLocationRelativeTo(null);
            error.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);
            error.setVisible(true);
        }
    }
    public static void main(String[] args) {
        javax.swing.SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                ATMLogIn atmLog = new ATMLogIn();
                atmLog.lunchFrame();
            }
        });
    }
}

package client;
import bank.Card;
import bank.Customer;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.PrintWriter;
import java.text.NumberFormat;
public class ATMMainWindow {
    private JFrame frame;
    private JLabel nameLabel;
    private JPanel northPanel;
    private JPanel westPanel;
    private JPanel eastPanel;
    private JButton displayButton;
    private JButton withdrawButton;
    private JButton depositButton;
    private JButton transferButton;
    private JButton modifyButton;
    private JButton exitButton;
    private JTextField messageArea;
    private JPanel southPanel;
    private Operation operation;
    private Customer ATMCustomer;
    private Card ATMCard;
    NumberFormat currency_format = NumberFormat.getCurrencyInstance();
    public ATMMainWindow(Card card) {
        ATMCustomer = card.getCustomer(card);
        ATMCard = card;
        frame = new JFrame("ATM");
        nameLabel = new JLabel("Welcome， " + "" + ATMCustomer.getName());
        northPanel = new JPanel();
        westPanel = new JPanel();
        eastPanel = new JPanel();
        displayButton = new JButton("Display");
        withdrawButton = new JButton("WithDraw");
        depositButton = new JButton("Deposit");
        transferButton = new JButton("Transfer");
        modifyButton = new JButton("Modify");
        exitButton = new JButton("Exit");
        messageArea = new JTextField();
        messageArea.setHorizontalAlignment(JTextField.CENTER);
        messageArea.setBackground(Color.WHITE);;
        southPanel = new JPanel();
        operation = new Operation(card);
    }
    public void lunchFrame() {
        frame.setPreferredSize(new Dimension(700, 400));
        frame.setLayout(new BorderLayout());
        northPanel.add(nameLabel);
        frame.add(northPanel, BorderLayout.NORTH);
        westPanel.setLayout(new GridLayout(3, 1, 80, 80));
        westPanel.add(displayButton);
        westPanel.add(modifyButton);
        westPanel.add(exitButton);
        eastPanel.setLayout(new GridLayout(3, 1, 80, 80));
        eastPanel.add(depositButton);
        eastPanel.add(withdrawButton);
        eastPanel.add(transferButton);
        displayButton.addActionListener(new DisplayAction());
        modifyButton.addActionListener(new ModifyAction());
        exitButton.addActionListener(new ExitAction());
        depositButton.addActionListener(new Deposit());
        withdrawButton.addActionListener(new Withdraw());
        transferButton.addActionListener(new Transfer());
        messageArea.setEditable(false);
        southPanel.setPreferredSize(new Dimension(700, 30));
        frame.add(messageArea, BorderLayout.CENTER);
        frame.add(westPanel, BorderLayout.WEST);
        frame.add(eastPanel, BorderLayout.EAST);
        frame.add(southPanel, BorderLayout.SOUTH);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
    private class DisplayAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            String message = operation.display();
            messageArea.setText(message);
        }
    }
    private class ExitAction implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            System.exit(0);
        }
    }
    private class ModifyAction implements ActionListener {
        JDialog ModifyDialog;
        JTextField nameTextField;
        JPasswordField firstPasswordField;
        JPasswordField secondPasswordField;
        @Override
        public void actionPerformed(ActionEvent e) {
            ModifyDialog = new JDialog(frame, "Modify Password", false);
            ModifyDialog.setPreferredSize(new Dimension(700, 400));
            ModifyDialog.setLayout(new BorderLayout());
            JPanel dialogPanel = new JPanel();
            dialogPanel.setLayout(new BorderLayout());
            JPanel northPanel = new JPanel();
            northPanel.setPreferredSize(new Dimension(700, 100));
            JPanel southPanel = new JPanel();
            southPanel.setPreferredSize(new Dimension(700, 100));
            JPanel westPanel = new JPanel();
            westPanel.setPreferredSize(new Dimension(30, 400));
            JPanel eastPanel = new JPanel();
            eastPanel.setPreferredSize(new Dimension(30, 400));
            JPanel diaLeftPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JPanel diaRightPanel = new JPanel(new GridLayout(4, 1, 10, 10));
            JLabel nameLabel = new JLabel("Name");
            JLabel dialogPasswordLabel = new JLabel("Password");
            JLabel againLabel = new JLabel("Again");
            JLabel nullLabel = new JLabel();
            diaLeftPanel.add(nameLabel);
            diaLeftPanel.add(dialogPasswordLabel);
            diaLeftPanel.add(againLabel);
            diaLeftPanel.add(nullLabel);
            nameTextField = new JTextField();
            firstPasswordField = new JPasswordField();
            secondPasswordField = new JPasswordField();
            JLabel noneLabel = new JLabel();
            diaRightPanel.add(nameTextField);
            diaRightPanel.add(firstPasswordField);
            diaRightPanel.add(secondPasswordField);
            diaRightPanel.add(noneLabel);
            dialogPanel.add(diaLeftPanel, BorderLayout.WEST);
            dialogPanel.add(diaRightPanel, BorderLayout.CENTER);
            JButton OKButton = new JButton("OK");
            OKButton.addActionListener(new PassErrorAction());
            JPanel buttonPanel = new JPanel();
            buttonPanel.setLayout(new BoxLayout(buttonPanel, BoxLayout.Y_AXIS));
            OKButton.setAlignmentX(Component.CENTER_ALIGNMENT);
            buttonPanel.add(OKButton);
            dialogPanel.add(buttonPanel, BorderLayout.SOUTH);
            ModifyDialog.add(dialogPanel, BorderLayout.CENTER);
            ModifyDialog.add(northPanel, BorderLayout.NORTH);
            ModifyDialog.add(southPanel, BorderLayout.SOUTH);
            ModifyDialog.add(westPanel, BorderLayout.WEST);
            ModifyDialog.add(eastPanel, BorderLayout.EAST);
            ModifyDialog.pack();
            ModifyDialog.setLocationRelativeTo(null);
            ModifyDialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            ModifyDialog.setVisible(true);
        }
        private class PassErrorAction implements ActionListener {
            @Override
            public void actionPerformed(ActionEvent e) {
                String name = nameTextField.getText();
                char[] firstPassword = firstPasswordField.getPassword();
                char[] secondPassword = secondPasswordField.getPassword();
                String password = "";
                int result = 0;
                if (firstPassword.length == secondPassword.length) {
                    for (int i = 0; i < firstPassword.length; i++) {
                        if (firstPassword[i] == secondPassword[i]) {
                            password += firstPassword[i];
                            result = 0;
                        } else {
                            result = 1;
                            break;
                        }
                    }
                } else {
                    result = 2;
                }
                switch (result) {
                    case 0: {
                        ATMNet atmNet = ATMNet.getAtmNet();
                        BufferedReader bufferedReader = atmNet.getBufferedReader();
                        PrintWriter printWriter = atmNet.getPrintWriter();
                        printWriter.println(1 + "-" + 4 + "-" + name + "-" + ATMCard.getID() + "-" + password);
                        ModifyDialog.setVisible(false);
                        messageArea.setText("Password has been modified successfully...");
                        break;
                    }
                    case 1: {
                        ModifyError error1 = new ModifyError();
                        error1.lunch();
                        break;
                    }
                    case 2: {
                        ModifyError error2 = new ModifyError();
                        error2.lunch();
                        break;
                    }
                }
            }
        }
    }
    private class ModifyError {
        public void lunch() {
            JDialog error = new JDialog(frame, "ERROR", false);
            error.setPreferredSize(new Dimension(300, 150));
            JLabel errorMessage = new JLabel("", JLabel.CENTER);
            errorMessage.setText("The Passwords are different.");
            error.add(errorMessage);
            error.pack();
            error.setLocationRelativeTo(null);
            error.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            error.setVisible(true);
        }
    }
    private class InputMoney {
        JDialog inputMoney;
        JTextField inputMoneyText;
        JTextField IDTextField;
        public void lunch(String op) {
            inputMoney = new JDialog(frame, "InputMoney", false);
            JPanel northPanel = new JPanel();
            northPanel.setPreferredSize(new Dimension(300, 10));
            JPanel southPanel = new JPanel();
            southPanel.setPreferredSize(new Dimension(300, 10));
            JPanel inputPanel = new JPanel(new FlowLayout());
            JLabel inputMoneyLabel = new JLabel("Money");
            inputMoneyText = new JTextField();
            JButton inputButton = new JButton("OK");
            if (op == "10") {
                JPanel labelPanel = new JPanel(new GridLayout(2, 1, 5, 5));
                JPanel textPanel = new JPanel(new GridLayout(2, 1, 5, 5));
                JLabel IDLabel = new JLabel("ID");
                IDTextField = new JTextField();
                IDTextField.setPreferredSize(new Dimension(150, 20));
                labelPanel.add(IDLabel);
                labelPanel.add(inputMoneyLabel);
                textPanel.add(IDTextField);
                textPanel.add(inputMoneyText);
                inputPanel.add(labelPanel);
                inputPanel.add(textPanel);
                inputPanel.add(inputButton);
            } else {
                inputMoneyText.setPreferredSize(new Dimension(150, 20));
                inputPanel.setLayout(new FlowLayout());
                inputPanel.add(inputMoneyLabel);
                inputPanel.add(inputMoneyText);
                inputPanel.add(inputButton);
            }
            inputMoney.setLayout(new BorderLayout());
            inputMoney.add(inputPanel, BorderLayout.CENTER);
            inputMoney.add(northPanel, BorderLayout.NORTH);
            inputMoney.add(southPanel, BorderLayout.SOUTH);
            inputButton.addActionListener(new InputActionListener(op));
            inputMoney.pack();
            inputMoney.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            inputMoney.setLocationRelativeTo(null);
            inputMoney.setVisible(true);
            //return money[0];
        }
        private class InputActionListener implements ActionListener {
            private String operationInput;
            private String money;
            private String transferID;
            public InputActionListener(String op) {
                operationInput = op;
            }
            @Override
            public void actionPerformed(ActionEvent e) {
                money = inputMoneyText.getText();
                float displayMessage =Float.parseFloat(money);
                if (operationInput == "00") {
                    operation.deposit(money);
                    messageArea.setText(currency_format.format(displayMessage) + " has been deposited...");
                } else if (operationInput == "01") {
                    boolean result = operation.withdraw(money);
                    if (result) {
                        messageArea.setText(currency_format.format(displayMessage) + " has been withdrew...");
                    } else {
                        messageArea.setText(currency_format.format(displayMessage) + " is withdrew unsuccessful...");
                    }
                } else if (operationInput == "10") {
                    transferID = IDTextField.getText();
                    boolean result = operation.transfer(money, transferID);
                    if (result) {
                        messageArea.setText(currency_format.format(displayMessage) + " has been transferred...");
                    } else {
                        messageArea.setText(currency_format.format(displayMessage) + " is transferred unsuccessful...");
                    }
                }
                inputMoney.setVisible(false);
            }
        }
    }
    private class Deposit implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            InputMoney inputMoney = new InputMoney();
            inputMoney.lunch("00");
        }
    }
    private class Withdraw implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            InputMoney inputMoney = new InputMoney();
            inputMoney.lunch("01");
        }
    }
    private class Transfer implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            InputMoney inputMoney = new InputMoney();
            inputMoney.lunch("10");
        }
    }
}

package client;
import java.io.*;
import java.net.Socket;
public class ATMNet {
    private Socket socket;
    private BufferedReader bufferedReader;
    private PrintWriter printWriter;
    private static ATMNet atmNet;
    private ATMNet() {
        try {
            socket = new Socket("127.0.0.1", 4448);
            bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            printWriter = new PrintWriter(socket.getOutputStream(), true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public BufferedReader getBufferedReader() {
        return bufferedReader;
    }
    public PrintWriter getPrintWriter() {
        return printWriter;
    }
    public static ATMNet getAtmNet() {
        if (atmNet == null) {
            atmNet = new ATMNet();
        }
        return atmNet;
    }
}

package client;
import bank.ATMBank;
import bank.Card;
import bank.Customer;
import server.CardIDGenerate;
import server.MyObjectOutputStream;
import java.io.*;
import java.text.NumberFormat;
import java.util.Iterator;
import java.util.StringTokenizer;
public class ClientManager {
    private ObjectOutputStream out;
    private File accountRecord;
    private ATMBank bank;
    public ClientManager() {
        accountRecord = new File("Client.ser");
        try {
            bank = ATMBank.getATMBank();
            if (!accountRecord.exists()) {
                accountRecord.createNewFile();
            }
            if (accountRecord.length() == 0) {
                out = new ObjectOutputStream(new FileOutputStream(accountRecord, true));
            } else {
                out = new MyObjectOutputStream(new FileOutputStream(accountRecord, true));
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public String clientManage(String name, String password, String operation) {
        switch (operation) {
            case "0": {
                String id = "";
                try {
                    Customer customer = new Customer(name, password);
                    CardIDGenerate cardIDGenerate = CardIDGenerate.getCardIDGenerate();
                    id = cardIDGenerate.generateID();
                    Card card = new Card(id);
                    customer.addCards(card);
                    bank.addCustomer(customer);
                    out.writeObject(customer);
                    out.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return id;
            }
            case "1": {
                ObjectInputStream in = null;
                FileInputStream newFileInput = null;
                try {
                    newFileInput = new FileInputStream(accountRecord);
                    in = new ObjectInputStream(newFileInput);
                    if (name == null || name.equals("")) {
                        return "1-0";
                    } else {
                        if (password == null || password.equals("")) {
                            return "2-0";
                        } else {
                            Customer curCustomer = (Customer) in.readObject();
                            while (curCustomer != null) {
                                Iterator<Card> iterator = curCustomer.cardIterator();
                                while (iterator.hasNext()) {
                                    Card curCard = iterator.next();
                                    String message = curCard.getID() + "-" + curCard.getPassword();
                                    if (message != null && !message.equals("")) {
                                        StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                                        String ID = stringTokenizer.nextToken();
                                        String pass = stringTokenizer.nextToken();
                                        if (ID.equals(name)) {
                                            if (pass.equals(password)) {
                                                float balance = curCard.getBalance();
                                                if (curCard.getNormal() == true) {
                                                    return "3-" + balance;
                                                }
                                                else {
                                                    return "0-0";
                                                }
                                            } else {
                                                return "4-0";
                                            }
                                        }
                                    }
                                }
                                curCustomer = (Customer) in.readObject();
                            }
                        }
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                break;
            }
            case "2": {
                Customer curCustomer = null;
                FileInputStream fileInputStream = null;
                try {
                    Iterator<Customer> temp = bank.getCustomers();
                    while (temp.hasNext()) {
                        temp.next();
                        temp.remove();
                    }
                    fileInputStream = new FileInputStream(accountRecord);
                    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                    curCustomer = (Customer) objectInputStream.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID() + "-" + curCard.getPassword();
                            if (message != null && !message.equals("")) {
                                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                                String ID = stringTokenizer.nextToken();
                                if (ID.equals(name)) {
                                    curCard.setBalance(password, 1);
                                    bank.addCustomer(curCustomer);
                                    break;
                                } else {
                                    bank.addCustomer(curCustomer);
                                }
                            }
                        }
                        curCustomer = (Customer) objectInputStream.readObject();
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream((accountRecord)));
                        Iterator<Customer> iteratorOfPrint = bank.getCustomers();
                        while (iteratorOfPrint.hasNext()) {
                            curCustomer = iteratorOfPrint.next();
                            objectOutputStream.writeObject(curCustomer);
                        }
                        objectOutputStream.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                break;
            }
            case "3": {
                Customer curCustomer = null;
                FileInputStream fileInputStream = null;
                try {
                    Iterator<Customer> temp = bank.getCustomers();
                    while (temp.hasNext()) {
                        temp.next();
                        temp.remove();
                    }
                    fileInputStream = new FileInputStream(accountRecord);
                    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                    curCustomer = (Customer) objectInputStream.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID() + "-" + curCard.getPassword();
                            if (message != null && !message.equals("")) {
                                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                                String ID = stringTokenizer.nextToken();
                                ObjectOutputStream objectOutputStream = null;
                                if (ID.equals(name)) {
                                    curCard.setBalance(password, 2);
                                    bank.addCustomer(curCustomer);
                                    break;
                                } else {
                                    bank.addCustomer(curCustomer);
                                }
                            }
                        }
                        curCustomer = (Customer) objectInputStream.readObject();
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream((accountRecord)));
                        Iterator<Customer> iteratorOfPrint = bank.getCustomers();
                        while (iteratorOfPrint.hasNext()) {
                            curCustomer = iteratorOfPrint.next();
                            objectOutputStream.writeObject(curCustomer);
                        }
                        objectOutputStream.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                break;
            }
            case "4": {
                FileInputStream fileInputStream = null;
                Customer curCustomer = null;
                try {
                    Iterator<Customer> temp = bank.getCustomers();
                    while (temp.hasNext()) {
                        temp.next();
                        temp.remove();
                    }
                    fileInputStream = new FileInputStream(accountRecord);
                    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                    curCustomer = (Customer) objectInputStream.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID() + "-" + curCard.getPassword();
                            if (message != null && !message.equals("")) {
                                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                                String ID = stringTokenizer.nextToken();
                                if (ID.equals(name)) {
                                    curCard.setPassword(password);
                                    bank.addCustomer(curCustomer);
                                } else {
                                    bank.addCustomer(curCustomer);
                                }
                            }
                        }
                        curCustomer = (Customer) objectInputStream.readObject();
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    ObjectOutputStream objectOutputStream = null;
                    try {
                        objectOutputStream = new ObjectOutputStream(new FileOutputStream((accountRecord)));
                        Iterator<Customer> iteratorOfPrint = bank.getCustomers();
                        while (iteratorOfPrint.hasNext()) {
                            curCustomer = iteratorOfPrint.next();
                            objectOutputStream.writeObject(curCustomer);
                        }
                        objectOutputStream.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                break;
            }
            case "5": {
                boolean from=false;
                boolean to =false;
                StringTokenizer stringTokenizer = new StringTokenizer(name, "-", false);
                String IDFrom = stringTokenizer.nextToken();
                String IDTo = stringTokenizer.nextToken();
                Customer curCustomer = null;
                FileInputStream fileInputStream = null;
                try {
                    Iterator<Customer> temp = bank.getCustomers();
                    while (temp.hasNext()) {
                        temp.next();
                        temp.remove();
                    }
                    fileInputStream = new FileInputStream(accountRecord);
                    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                    curCustomer = (Customer) objectInputStream.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID();
                            if (message != null && !message.equals("")) {
                                if (message.equals(IDFrom)) {
                                    curCard.setBalance(password, 3);
                                    bank.addCustomer(curCustomer);
                                    from=true;
                                } else if (message.equals(IDTo)) {
                                    if(curCard.getNormal()==false){
                                        return "0-0";
                                    }
                                    curCard.setBalance(password, 1);
                                    bank.addCustomer(curCustomer);
                                    to=true;
                                } else {
                                    bank.addCustomer(curCustomer);
                                }
                            }
                        }
                        curCustomer = (Customer) objectInputStream.readObject();
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        if(from==true && to==true) {
                            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream((accountRecord)));
                            Iterator<Customer> iteratorOfPrint = bank.getCustomers();
                            while (iteratorOfPrint.hasNext()) {
                                curCustomer = iteratorOfPrint.next();
                                objectOutputStream.writeObject(curCustomer);
                            }
                            objectOutputStream.flush();
                            return "0";
                        }
                        else {
                            return "0-0";
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                break;
            }
            case "6": {
                boolean sign = false;
                Customer curCustomer = null;
                FileInputStream fileInputStream = null;
                try {
                    fileInputStream = new FileInputStream(accountRecord);
                    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                    curCustomer = (Customer) objectInputStream.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID() + "-" + curCard.getPassword();
                            if (message != null && !message.equals("")) {
                                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                                String ID = stringTokenizer.nextToken();
                                float balance = curCard.getBalance();
                                String telephone = curCustomer.getTelephone();
                                String nameOfSearch = curCustomer.getName();
                                String searchInformation = "1-" + nameOfSearch + "-" + telephone + "-" + balance;
                                if (ID.equals(name)) {
                                    return searchInformation;
                                }
                            }
                        }
                        curCustomer = (Customer) objectInputStream.readObject();
                    }
                } catch (IOException e) {
                    return "error";
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                break;
            }
            case "7": {
                // int index =0;
                boolean mark = false;
                boolean first = true;
                FileInputStream fileInputStream = null;
                Customer curCustomer = null;
                try {
                    Iterator<Customer> temp = bank.getCustomers();
                    while (temp.hasNext()) {
                        temp.next();
                        temp.remove();
                    }
                    fileInputStream = new FileInputStream(accountRecord);
                    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                    curCustomer = (Customer) objectInputStream.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID() + "-" + curCard.getPassword();
                            if (message != null && !message.equals("")) {
                                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                                String ID = stringTokenizer.nextToken();
                                if (ID.equals(name)) {
                                    curCard.setNormal();
                                    bank.addCustomer(curCustomer);
                                    mark = true;
                                    break;
                                } else {
                                    bank.addCustomer(curCustomer);
                                }
                            }
                        }
                        curCustomer = (Customer) objectInputStream.readObject();
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream((accountRecord)));
                        Iterator<Customer> iteratorOfPrint = bank.getCustomers();
                        while (iteratorOfPrint.hasNext()) {
                            curCustomer = iteratorOfPrint.next();
                            objectOutputStream.writeObject(curCustomer);
                        }
                        objectOutputStream.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                break;
            }
            case "8": {
                ObjectInputStream in = null;
                FileInputStream newFileInput = null;
                try {
                    Iterator<Customer> temp = bank.getCustomers();
                    while (temp.hasNext()) {
                        temp.next();
                        temp.remove();
                    }
                    newFileInput = new FileInputStream(accountRecord);
                    in = new ObjectInputStream(newFileInput);
                    Customer curCustomer = (Customer) in.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID();
                            if (message.equals(password)) {
                                float balance = curCard.getBalance();
                                NumberFormat currency_format = NumberFormat.getCurrencyInstance();
                                String cash = "" + currency_format.format(balance);
                                in.close();
                                return cash;
                            }
                        }
                        curCustomer = (Customer) in.readObject();
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
                break;
            }
            case "9": {
                ObjectInputStream in = null;
                FileInputStream newFileInput = null;
                Customer curCustomer = null;
                try {
                    Iterator<Customer> temp = bank.getCustomers();
                    while (temp.hasNext()) {
                        temp.next();
                        temp.remove();
                    }
                    newFileInput = new FileInputStream(accountRecord);
                    in = new ObjectInputStream(newFileInput);
                    curCustomer = (Customer) in.readObject();
                    while (curCustomer != null) {
                        Iterator<Card> iterator = curCustomer.cardIterator();
                        while (iterator.hasNext()) {
                            Card curCard = iterator.next();
                            String message = curCard.getID() + "-" + curCard.getPassword();
                            if (message != null && !message.equals("")) {
                                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                                String ID = stringTokenizer.nextToken();
                                String pass = stringTokenizer.nextToken();
                                if (ID.equals(name)) {
                                    if (curCard.getNormal() == true) {
                                        curCard.setPassword("123456");
                                        bank.addCustomer(curCustomer);
                                    }
                                } else {
                                    bank.addCustomer(curCustomer);
                                }
                            }
                        }
                        curCustomer = (Customer) in.readObject();
                    }
                } catch (IOException e) {
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } finally {
                    try {
                        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream((accountRecord)));
                        Iterator<Customer> iteratorOfPrint = bank.getCustomers();
                        while (iteratorOfPrint.hasNext()) {
                            curCustomer = iteratorOfPrint.next();
                            objectOutputStream.writeObject(curCustomer);
                        }
                        objectOutputStream.flush();
                        return "0";
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                break;
            }
        }
        return "0-0";
    }
}

package client;
import bank.ATMBank;
import bank.Card;
import bank.Customer;
import java.io.*;
import java.text.NumberFormat;
import java.util.Iterator;
public class Operation {
    ATMBank bank;
    Customer customer;
    Card card;
    public Operation(Card card) {
        bank = ATMBank.getATMBank();
        Iterator<Customer> customers = bank.getCustomers();
        while (customers.hasNext()) {
            Customer curCustomer = customers.next();
            Iterator<Card> cardIterator = curCustomer.cardIterator();
            while (cardIterator.hasNext()) {
                Card curCard = cardIterator.next();
                if (card.equals(curCard)) {
                    customer = curCustomer;
                }
            }
        }
        this.card = card;
    }
    public void deposit(String money) {
        card.setBalance(money, 1);
        ATMNet atmNet = ATMNet.getAtmNet();
        PrintWriter printWriter = atmNet.getPrintWriter();
        printWriter.println("1-2-" + card.getCustomer(card).getName() + "-" + card.getID() + "-" + money);
    }
    public boolean withdraw(String money) {
        float cash = card.getBalance();
        float balance = Float.parseFloat(money);
        if (cash > balance) {
            card.setBalance(money, 2);
            ATMNet atmNet = ATMNet.getAtmNet();
            PrintWriter printWriter = atmNet.getPrintWriter();
            printWriter.println("1-3-" + card.getCustomer(card).getName() + "-" + card.getID() + "-" + money);
            return true;
        }
        return false;
    }
    public boolean transfer(String money, String id) {
        float cash = card.getBalance();
        float balance = Float.parseFloat(money);
        if (cash > balance) {
            card.setBalance(money, 3);
            ATMNet atmNet = ATMNet.getAtmNet();
            PrintWriter printWriter = atmNet.getPrintWriter();
            printWriter.println("1-5-" + id + "-" + card.getID() + "-" + money);
            BufferedReader bufferedReader = atmNet.getBufferedReader();
            String result = "";
            try {
                result = bufferedReader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (result.equals("0")) {
                return true;
            }
        }
        return false;
    }
    public String display() {
        String ID = card.getID();
        String balance = "";
        ATMNet atMnet = ATMNet.getAtmNet();
        PrintWriter printWriter = atMnet.getPrintWriter();
        printWriter.println("1-8-00000000-123456-" + ID);
        BufferedReader bufferedReader = atMnet.getBufferedReader();
        try {
            balance = bufferedReader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return balance;
    }
}

package server;
import admin.AdminAccountManage;
import bank.ATMBank;
import client.ClientManager;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.StringTokenizer;
public class ServerNet {
    private BufferedReader bufferedReader;
    private PrintWriter printWriter;
    private BufferedReader inOfClient;
    private PrintWriter outOfClient;
    private PrintWriter outOfAdmin;
    private ServerSocket serverSocketOfAdmin;
    private ServerSocket serverSocketOfClient;
    private Socket socketOfAdmin;
    private Socket socketOfClient;
    private ATMBank bank;
    private AdminAccountManage adminAccountManage;
    private ClientManager clientManager;
    private BufferedReader aBuffered;
    private PrintWriter aPrinter;
    private static ArrayList<String> onlineClient;
    public ServerNet(Socket socket) {
        try {
            // inOfClient = new BufferedReader(new InputStreamReader(socketOfClient.getInputStream()));
            adminAccountManage = new AdminAccountManage();
            clientManager = new ClientManager();
            outOfAdmin = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()), true);
            onlineClient =OnlineClient.getOnlineClient();
            bank = ATMBank.getATMBank();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void adminOperation(StringTokenizer stringTokenizer) {
        String condition = null;
        String account = null;
        String password = null;
        condition = stringTokenizer.nextToken();
        account = stringTokenizer.nextToken();
        password = stringTokenizer.nextToken();
        switch (condition) {
            case "0": {
                String result = "" + adminAccountManage.accountManage(account, password, "0");
                break;
            }
            case "1": {
                String result = "" + adminAccountManage.accountManage(account, password, "1");
                outOfAdmin.println(result);
                break;
            }
        }
    }
    public void clientOperation(StringTokenizer stringTokenizer) {
        String operation = "";
        String name = "";
        String ID = "";
        String password = "";
        operation = stringTokenizer.nextToken();
        name = stringTokenizer.nextToken();
        ID = stringTokenizer.nextToken();
        password = stringTokenizer.nextToken();
        switch (operation) {
            case "0": {
                String result = clientManager.clientManage(name, password, "0");
                outOfAdmin.println(result);
                break;
            }
            case "1": {
                // Customer customer = new Customer(name,ID);
                String result = "" + clientManager.clientManage(ID, password, "1");
                boolean online = false;
                if (!result.equals("1-0") && !result.equals("2-0") && !result.equals("4-0") && !result.equals("0-0")) {
                    Iterator<String> iterator = onlineClient.iterator();
                    while (iterator.hasNext()) {
                        String curOnlineClient = iterator.next();
                        if (curOnlineClient.equals(ID)) {
                            outOfAdmin.println("5-0");
                            online = true;
                        }
                    }
                    if (online == false) {
                        onlineClient.add(ID);
                        outOfAdmin.println(result);
                    }
                }
                else {
                    outOfAdmin.println(result);
                }
                break;
            }
            case "2": {
                clientManager.clientManage(ID, password, "2");
                break;
            }
            case "3": {
                clientManager.clientManage(ID, password, "3");
                break;
            }
            case "4": {
                String result = "" + clientManager.clientManage(ID, password, "4");
                outOfAdmin.println(result);
                break;
            }
            case "5": {
                String result = clientManager.clientManage(ID + "-" + name, password, "5");
                outOfAdmin.println(result);
                break;
            }
            case "6": {
                String informationOfAdmin = clientManager.clientManage(ID, password, "6");
                outOfAdmin.println(informationOfAdmin);
                break;
            }
            case "7": {
                clientManager.clientManage(ID, password, "7");
                break;
            }
            case "8": {
                String result = clientManager.clientManage(ID, password, "8");
                outOfAdmin.println(result);
                break;
            }
            case "9": {
                String result = clientManager.clientManage(name, password, "9");
                outOfAdmin.println(result);
                break;
            }
        }
    }
   /* public static void main(String[] args) {
        ServerSocket serverSocketOfAdmin = null;
        Socket socketOfAdmin = null;
        BufferedReader bufferedReader = null;
        String message = null;
        boolean firstRead = false;
        //  boolean content = false;
        try {
            serverSocketOfAdmin = new ServerSocket(4448);
            socketOfAdmin = serverSocketOfAdmin.accept();
            bufferedReader = new BufferedReader(new InputStreamReader(socketOfAdmin.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
        ServerNet serverNet = new ServerNet(socketOfAdmin);
        while (true) {
            try {
                message = bufferedReader.readLine();
            } catch (IOException e) {
            }
            if (!message.equals("") && message != null) {
                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                String side = stringTokenizer.nextToken();
                if (side.equals("0")) {
                    serverNet.adminOperation(stringTokenizer);
                } else {
                    serverNet.clientOperation(stringTokenizer);
                }
            }
        }
    }*/
}

package server;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
public class MyObjectOutputStream extends ObjectOutputStream {
    protected MyObjectOutputStream() throws IOException, SecurityException {
        super();
    }
    @Override
    protected void writeStreamHeader() throws IOException {
    }
    public MyObjectOutputStream(OutputStream o) throws IOException {
        super(o);
    }
}

package server;
import java.io.*;
public class CardIDGenerate {
    private static String cardID;
    private static CardIDGenerate cardIDGenerate;
    private File file;
    private CardIDGenerate() {
        file = new File("ID.txt");
        String id = "";
        try {
            BufferedReader bufferedReader = new BufferedReader(new FileReader(file));
            id = bufferedReader.readLine();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        cardID = id;
    }
    public static CardIDGenerate getCardIDGenerate() {
        if (cardIDGenerate == null) {
            cardIDGenerate = new CardIDGenerate();
        }
        return cardIDGenerate;
    }
    public String generateID() {
        String newID;
        int ID = Integer.parseInt(cardID);
        newID = ID + 1 + "";
        try {
            PrintWriter printWriter = new PrintWriter(new FileWriter(file), true);
            printWriter.println(newID);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return newID;
    }
}

package server;
import java.util.ArrayList;
import java.util.Iterator;
public class OnlineClient {
    private static ArrayList<String> onlineClient;
    private static  OnlineClient onlineClientInstance;
    private OnlineClient(){
        onlineClient = new ArrayList<String>();
    }
    public static ArrayList<String> getOnlineClient(){
        if(onlineClientInstance==null){
            onlineClientInstance = new OnlineClient();
        }
        return onlineClient;
    }
}

package server;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.*;
import java.util.StringTokenizer;
public class ServerThread extends Thread {
    Socket socketOfAdmin = null;
    BufferedReader bufferedReader = null;
    String message = null;
    public ServerThread(Socket socket) {
        try {
            socketOfAdmin = socket;
            bufferedReader = new BufferedReader(new InputStreamReader(socketOfAdmin.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void run() {
        ServerNet serverNet = new ServerNet(socketOfAdmin);
        while (true) {
            try {
                message = bufferedReader.readLine();
            } catch (IOException e) {
            }
            if (!message.equals("") && message != null) {
                StringTokenizer stringTokenizer = new StringTokenizer(message, "-", false);
                String side = stringTokenizer.nextToken();
                if (side.equals("0")) {
                    serverNet.adminOperation(stringTokenizer);
                } else {
                    serverNet.clientOperation(stringTokenizer);
                }
            }
        }
    }
}

package server;
import java.io.IOException;
import java.net.ServerSocket;
public class TestServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        boolean listening = true;
        try {
            serverSocket = new ServerSocket(4448);
        } catch (IOException e) {
            System.exit(-1);
        }
        while (listening) {
            try {
                ServerThread serverThread = new ServerThread(serverSocket.accept());
                serverThread.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}