String的特殊之处

String是Java编程中很常见的一个类,这个类的实例是不可变的(immutable ).为了提高效率,JVM内部对其操作进行了一些特殊处理,本文就旨在于帮助大家辨析这些特殊的地方.
在进入正文之前,你需要澄清这些概念:
1) 堆与栈
2) 相同与相等,==与equals
3) =的真实意义.

栈与堆

1. 栈(stack)与堆(heap)都是Java用来在内存中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。每个函数都有自己的栈,而一个程序只有一个堆.
2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 3. Java中的数据类型有两种。 　　一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。 　　另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义 　　int a = 3;  　　int b = 3； 　　编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。 　　特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与 b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。 　　另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。

相同与相等,==与equals

在Java中,相同指的是两个变量指向的地址相同,地址相同的变量自然值相同;而相等是指两个变量值相等,地址可以不同.
相同的比较使用==,而相等的比较使用equals.
对于字符串变量的值比较来说,我们一定要使用equals而不是==.

=的真实意义

=即赋值操作,这里没有问题,关键是这个值有时是真正的值,有的是地址,具体来说会根据等号右边的部分而变化.
如果是基本类型(八种),则赋值传递的是确定的值,即把右边变量的值传递给左边的变量.
如果是类类型,则赋值传递的是变量的地址,即把等号左边的变量地址指向等号右边的变量地址.

指出下列代码的输出

String andy="andy";
String bill="andy";

if(andy==bill){
  System.out.println("andy和bill地址相同");
}
else{
  System.out.println("andy和bill地址不同");
}

String str=“andy”的机制分析

上页代码的输出是andy和bill地址相同.
当通过String str=“andy”;的方式定义一个字符串时,JVM先在栈中寻找是否有值为“andy”的字符串,如果有则将str指向栈中原有字符串的地址;如果没有则创建一个,再将str的地址指向它. String andy=“andy”这句代码走的是第二步,而String bill=“andy”走的是第一步,因此andy和bill指向了同一地址,故而andy==bill,andy和bill地址相等,所以输出是andy和bill地址相同.
这样做能节省空间—少创建一个字符串;也能节省时间—定向总比创建要省时.

指出下列代码的输出

String andy="andy";
String bill="andy";
bill="bill";

if(andy==bill){
  System.out.println("andy和bill地址相同");
}
else{
  System.out.println("andy和bill地址不同");
}

输出及解释

上页代码的输出是:andy和bill地址不同
当执行bill=“bill”一句时,外界看来好像是给bill变换了一个新值bill,但JVM的内部操作是把栈变量bill的地址重新指向了栈中一块值为bill的新地址,这是因为字符串的值是不可变的,要换值(赋值操作)只有将变量地址重新转向. 这样andy和bill的地址在执行bill=“bill”一句后就不一样了,因此输出是andy和bill地址不同.

指出下列代码的输出

String andy=new String("andy");
String bill=new String("andy");

// 地址比较
if(andy==bill){
  System.out.println("andy和bill地址相同");
}
else{
  System.out.println("andy和bill地址不同");
}

// 值比较
if(andy.equals(bill)){
  System.out.println("andy和bill值相等");
}
else{
  System.out.println("andy和bill值不等");
}

输出及机制分析

andy和bill地址不同
andy和bill值相等
我们知道new操作新建出来的变量一定处于堆中,字符串也是一样.
只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的,即每个字符串都有自己的值,自然地址就不会相同.因此输出了andy和bill地址不同.
equals操作比较的是值而不是地址,地址不同的变量值可能相同,因此输出了andy和bill值相等.

指出下列代码的输出

String andy=new String("andy");
String bill=new String(andy);

// 地址比较
if(andy==bill){
  System.out.println("andy和bill地址相同");
}
else{
  System.out.println("andy和bill地址不同");
}

// 值比较
if(andy.equals(bill)){
  System.out.println("andy和bill值相等");
}
else{
  System.out.println("andy和bill值不等");
}

输出

andy和bill地址不同
andy和bill值相等

道理仍和第八页相同.只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的,即每个字符串都有自己的值,自然地址就不会相同.

指出下列代码的输出

String andy="andy";
String bill=new String(“Bill");
bill=andy;

// 地址比较
if(andy==bill){
  System.out.println("andy和bill地址相同");
}
else{
  System.out.println("andy和bill地址不同");
}

// 值比较
if(andy.equals(bill)){
  System.out.println("andy和bill值相等");
}
else{
  System.out.println("andy和bill值不等");
}

输出及解析

andy和bill地址相同
andy和bill值相等
String bill=new String(“Bill”)一句在栈中创建变量bill,指向堆中创建的”Bill”,这时andy和bill地址和值都不相同;而执行bill=andy;一句后,栈中变量bill的地址就指向了andy,这时bill和andy的地址和值都相同了.而堆中的”Bill”则没有指向它的指针,此后这块内存将等待被垃圾收集.

指出下列代码的输出

String andy="andy";
String bill=new String("bill");
andy=bill;

// 地址比较
if(andy==bill){
  System.out.println("andy和bill地址相同");
}
else{
  System.out.println("andy和bill地址不同");
}

// 值比较
if(andy.equals(bill)){
  System.out.println("andy和bill值相等");
}
else{
  System.out.println("andy和bill值不等");
}

输出

andy和bill地址相同
andy和bill值相等

道理同第十二页

结论

使用诸如String str = “abc”；的语句在栈中创建字符串时时，str指向的字符串不一定会被创建！唯一可以肯定的是，引用str本身被创建了。至于这个引用到底是否指向了一个新的对象，必须根据上下文来考虑，如果栈中已有这个字符串则str指向它,否则创建一个再指向新创建出来的字符串. 清醒地认识到这一点对排除程序中难以发现的bug是很有帮助的。
使用String str = “abc”；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String(“abc”)；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。
如果使用new()来新建字符串的，都会在堆中创建字符串，而且其字符串是单独存值的,即每个字符串都有自己的值,且其地址绝不会相同
当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==。
由于String类的immutable性质，当String变量需要经常变换其值如SQL语句拼接,HTML文本输出时，应该考虑使用StringBuffer类，以提高程序效率。

Java集合类中最基础的接口是Collection，它定义了两个基本方法：
Public interface Collection<E>{
    boolean add(E element);
    Iterator<E> iterator();
}
add是向Collection中添加一个元素，当添加的内容确实对Collection发生了有效变更的话add方法返回真，否则返回假，比如你向一个Set添加重复的元素时，Set内容不会变化，add方法会返回假。
iterator方法返回实现了Iterator接口的对象，你可以借此对Collection中的内容进行挨个遍历。

2.Iterator接口

Iterator有三个方法：
Public interface Iterator<E>{
   E next();
   boolean hasNext();
   void remove();
}
通过重复调用next方法，你可以挨个遍历Collection中的元素。然而，当遍历到Collection末端时，此方法会抛出一个NoSuchElementException异常，因此在遍历时你就需要hasNext方法和next方法配合使用。 hasNext方法在当前遍历位置后仍有元素时会返回真。配合例子如下：
Collection<String> c=….;
Iterator<String> iterator=c.iterator();
While(iterator.hasNext()){
       String str=iterator.next();
      …….
}
remove方法能删除上一次调用next时指向的元素,注意不能连续两次调用remove方法,否则会抛出IllegalStateException.

3.Collection接口的其它方法

int size():返回当前存储的元素个数
boolean isEmpty():当集合中没有元素时返回真
boolean contains(Object obj):当集合中有元素和obj值相等时返回真.
boolean containsAll(Collection<?> other):当集合包含另一集合的全部元素时返回真.
bBoolean addAll (Collection<? extends E> other):把其它集合中的元素添加到集合中来,当此集合确实发生变化时返回真.
boolean remove(Object obj):删除一个和obj值相等的元素,当吻合的元素被删除时返回真.
boolean removeAll(Collection<?> other) :从本集合中删除和另一集合中相等的元素,当本集合确实发生变化时返回真.(差集)
void clear():清除集合中的所有元素
boolean retainAll(Collection<?> other) :从本集合中删除和另一集合中不相等的元素,当本集合确实发生变化时返回真.(交集)
Object[] toArray()
返回由集合中元素组成的数组

4.实现了Collection接口的具体类

ArrayList:带下标的队列,增加和收缩时都是动态的.
LinkedList:有序队列,在任意位置插入和删除都是高效的.
HashSet:不存在重复的非排序集合.
TreeSet:自动排序的不存在重复的集合.
LinkedHashSet:保持了插入时顺序的哈希表
PriorityQueue:优先级队列,能有效的删除最小元素.

5.没有重复元素存在的集合HashSet

HashSet通过哈希码来查找一个元素,这比链表的整体查找要迅速得多,但是由此带来的缺陷时它不能保持插入时的顺序.
由于HashSet靠hash码来识别元素,因此它不能包含重复元素,当集合中已经存在值相等的元素时,再次添加同样的元素HashSet不会发生变化.

Set<String> hashSet=new HashSet<String>();
hashSet.add("Andy");
hashSet.add("Andy");
hashSet.add("Bill");
hashSet.add("Cindy");
hashSet.add("Bill");
hashSet.add("Cindy");

Iterator<String> iter=hashSet.iterator();

while(iter.hasNext()){
        System.out.println(iter.next());
}
输出:
Cindy
Andy
Bill

6.自动排序的集合 TreeSet

TreeSet和HashSet类似但它值得一提的一点是无论你以何顺序插入元素,元素都能保持正确的排序位置,这时因为TreeSet是以红黑树的形式存储数据,在插入时就能找到正确的位置.注意插入TreeSet的元素都要实现Comparable接口.
例:
SortedSet<String> treeSet=new TreeSet<String>();
treeSet.add("Andy");
treeSet.add("Andy");
treeSet.add("Bill");
treeSet.add("Cindy");
treeSet.add("Bill");
treeSet.add("Cindy");

Iterator<String> iter=treeSet.iterator();

while(iter.hasNext()){
       System.out.println(iter.next());
}

输出:
Andy
Bill
Cindy

7.优先级队列PriorityQueue

PriorityQueue使用一种名为堆的二叉树高效的存储数据,它检索数据是按排序的顺序而插入则随意,当你调用remove方法时,你总能得到最小的元素.但PriorityQueue并不按序排列它的元素,当你遍历时它是不会排序的,这也没有必要. 在制作一个按优先级执行日程安排或事务安排时你应该首先想到PriorityQueue。
例:
PriorityQueue<String> pq=new PriorityQueue<String>();
pq.add("Cindy");
pq.add("Felix");
pq.add("Andy");
pq.add("Bill");

Iterator<String> iter=pq.iterator();

while(iter.hasNext()){
      System.out.println(iter.next());
}

while(!pq.isEmpty()){
      System.out.println(pq.remove());
}

8.保持插入顺序的哈希表LinkedHashMap

从1.4起Java集合类中多了一个LinkedHashMap,它在HashMap的基础上增加了一个双向链表,由此LinkedHashMap既能以哈希表的形式存储数据,又能保持查询时的顺序.
Map<String,String> members=new LinkedHashMap<String,String>();

members.put("001", "Andy");
members.put("002", "Bill");
members.put("003", "Cindy");
members.put("004", "Dell");

Iterator<String> iter=members.keySet().iterator();

while(iter.hasNext()){
      System.out.println(iter.next());
}

Iterator<String> iter2=members.values().iterator();

while(iter2.hasNext()){
      System.out.println(iter2.next());
}

9.自动按键进行排序的哈希表TreeMap

Map<String,String> members=new TreeMap<String,String>();

members.put("001", "Andy");
members.put("006", "Bill");
members.put("003", "Cindy");
members.put("002", "Dell");
members.put("004", "Felex");

for(Map.Entry<String,String> entry:members.entrySet()){
      System.out.println("Key="+entry.getKey()+"                      Value="+entry.getValue());
}

10.1 集合工具类Collections的方法unmodifiable

此方法构建一个不可更改的集合视图，当使用其修改方法时会抛出一个UnsupportedOperationException
static Collection<E> unmodifiableCollection(Collection<E> c)
static List<E> unmodifiableList (List<E> c)
static Set<E> unmodifiableSet (Set<E> c)
static SortedSet<E> unmodifiableSortedSet (SortedSet<E> c)
static Map<K，V> unmodifiableMap (Map<K，V>  c)
static SortedMap<K，V> unmodifiableSortedMap (SortedMap<K，V> c)

10.2 集合工具类Collections的方法synchronized

此方法会返回一个线程安全的集合视图
static Collection<E> synchronizedCollection(Collection<E> c)
static List<E> synchronizedList (List<E> c)
static Set<E> synchronizedSet (Set<E> c)
static SortedSet<E> synchronizedSortedSet (SortedSet<E> c)
static Map<K，V>  synchronizedMap (Map<K，V>  c)
static SortedMap<K，V>  synchronizedSortedMap (SortedMap<K，V>  c)

集合类静态类图

泛型类是C++模版(Template)类思想在java新版本(1.5)中的应用体现.当对类型相同的对象操作时泛型是很有用的,但其中对象的具体类型直到对类实例化时才能知道.这种方式非常适合于包含关联项目的集合或设计查找的类.

泛型类的使用示例一

/**
 * 泛型类示例一,成员变量为链表,T可以指代任意类类型.
 * @author sitinspring
 *
 * @date 2007-12-28
 */
public class Service<T>{
  // 元素为T的链表
  private List<T> elements;
 
  /**
   * 构造函数,这里无须指定类型
   *
   */
  public Service(){
    elements=new ArrayList<T>();
  }
 
  /**
   * 向链表中添加类型为T的元素
   * @param element
   */
  public void add(T element){
    elements.add(element);
  }
/**
   * 打印链表中元素
   *
   */
  public void printElements(){
    for(T t:elements){
      System.out.println(t);
    }
  }
 
/**
   * 使用示例
   * @param args
   */
  public static void main(String[] args){
    // 创建Service类的示例memberService
    Service<Member> memberService=new Service<Member>();
   
    // 向memberService中添加元素
    memberService.add(new Member("Andy",25));
    memberService.add(new Member("Bill",24));
    memberService.add(new Member("Cindy",55));
    memberService.add(new Member("Felex",35));
   
    // 打印memberService中诸元素
    memberService.printElements();
  }
}

泛型类的使用示例二

/**
 * 泛型类示例二,成员变量为哈希表,k,v可以指代任意类类型.
 * @author sitinspring
 *
 * @date 2007-12-28
 */
public class ServiceHt<K,V>{
  private Map<K,V> elements;
 
  /**
   * 向elements中添加元素
   * @param k
   * @param v
   */
  public void add(K k,V v){
    // 如果elements为空则创建元素
    if(elements==null){
      elements=new Hashtable<K,V>();
    }
   
    // 向elements中添加键值对
    elements.put(k, v);
  }
 /**
   * 打印哈希表中的元素
   *
   */
  public void printElements(){
    Iterator it=elements.keySet().iterator();
   
    while(it.hasNext()){
      K k=(K)it.next();
      V v=elements.get(k);
     
      System.out.println("键="+k+" 值="+v);
    }
  }

  /**
   * 使用示例
   * @param args
   */
  public static void main(String[] args){
    // 创建Service类的示例memberService
    ServiceHt<String,Member> memberService=new ServiceHt<String,Member>();
   
    // 向memberService中添加元素
    memberService.add("Andy",new Member("Andy",25));
    memberService.add("Bill",new Member("Bill",24));
    memberService.add("Cindy",new Member("Cindy",55));
    memberService.add("Felex",new Member("Felex",35));
   
    // 打印memberService中诸元素
    memberService.printElements();
  }
}

字符串比较是java程序常遇到的问题,新手常用==进行两个字符串比较,实际上这时进行的地址比较,不一定会返回正确结果.在java中,正确的进行字符串比较的函数String类的equals()函数,这才是真正的值比较.

==的真正意义

Java中,==用来比较两个引用是否指向同一个内存对象.对于String的实例,运行时JVM会尽可能的确保任何两个具有相同字符串信息的String实例指向同一个内部对象,此过程称为”驻留”(interning),但它不助于每个String实例的比较.一个原因是垃圾收集器删除了驻留值,另一个原因是String所在的位置可能被别的String实例所取代.这样的话,==将不会返回预想的结果.
下页的示例说明了这个问题:

==和equals比较的示例

String str1,str2,str3;

str1="Andy";

str2=str1;

if(str1==str2){
System.out.println("str1,str2地址相等");
}
if(str1.equals(str2)){
System.out.println("str1,str2值相等");
}

str2=“Andy”;
if(str1==str2){
System.out.println("str1,str2通常地址相等");
}
if(str1.equals(str2)){
System.out.println("str1,str2值一定相等");
}

str3=new String("Andy");
if(str1==str3){
System.out.println("str1,str3地址相等");
}
else{
System.out.println("str1,str3地址不相等");
}

if(str1.equals(str3)){
System.out.println("str1,str3值一定相等");
}

结论

从上面的例子可以看出,==比较的是地址,在驻留机制的作用下,也许返回正确的结果,但并不可靠,这种不确定性会隐藏在阴暗的角落里,在你以为万事大吉时给你致命一击.
而equal始终进行值比较,它一定会返回正确的结果,无论在什么情况下.

我们应该记住:为了保证程序的正确,进行字符串比较时一定要使用equals,而一定不能使用==.

异常的体系结构

毫无疑问,在java中异常是对象,它必定继承Throwable及其子类.Throwable中含有一个用于描述异常的字符串.Exception是Throwable的一个最常用子类,另一个子类是Error.而RuntimeException继承自Exception.

异常的种类

非检查型异常(Unchecked Exception):
非检查型异常反映了程序中的逻辑错误,不能从运行中合理恢复.
标准的运行时异常和错误构成非检查型异常,它们继承自RuntimeException和Error.
非检查型异常不用显示进行捕获.

检查型异常(Checked Exception):
这种异常描述了这种情况,虽然是异常的,但被认为是可以合理发生的,如果这种异常真的发生了,必须调用某种方法处理.
Java异常大多是检查型异常,继承自Exception类,你自己定义的异常必须是继承Exception的检查型异常.
检查型异常必须进行显示捕获.

自定义异常

继承Exception即可定义自己的异常,以下是一种常见写法
public class DBXmlFileReadException extends Exception{
  public DBXmlFileReadException(String   msg){
    super(msg);
  }
}

抛出异常

在Java语句中,可以用throw语句抛出异常,如throw new NoSuchElementException();
抛出的对象必须是Throwable类的子类型.

抛出异常的策略:
1) 如果抛出后不可能得到处理,可以抛出Error.
2) 如果你想让其它类自由选择是否处理这个异常,就可以抛出RuntimeException.
3) 如果你要求类的用户必须处理这个异常,则可以抛出Exception.

异常抛出后的控制权转移

一旦发生异常,异常发生点后的动作将不会发生.此后将要发生的操作不是在catch块和finally块.

当异常抛出时,导致异常发生的语句和表达式就被称为突然完成.语句的突然完成将导致调用链逐渐展开,直到该异常被捕获.

如果该异常没有捕获,执行线程将中止.

Try,catch和finally

异常由包含在try块中的语句捕获:
    try{
      正常执行语句
    }
    catch(XException e){
      异常执行语句一
    }
    catch(XXException e){
      异常执行语句二
    }
    catch(XXXException e){
      异常执行语句三
    }
    finally{
      中止语句
    }

Try中的语句体要么顺利完成,要么执行到抛出异常.
如果抛出异常,就要找出对应于异常类或其父类的catch子句,如果未能找到合适的catch子句,异常就从try语句中扩散出来,进入到外层可能对它进行处理的try语句.
Catch子句可以有多个,只要这些子句捕获的异常类型不同.
如果在try中有finally子句,其代码在try把所有其它处理完成之后执行.
无论是正常完成或是出现异常,甚至是通过return或者break这样的控制语句结束,finally子句总是被执行.
Catch子句和finally子句在try语句之后至少有一个,不要求全部出现.

More…

在catch语句中捕获通用的异常Exception通常不是最佳策略,因为它会将所有异常进行等同处理.
不能把基类异常的catch语句放到子类异常的catch语句之前,编译器会在运行之前就检查出这样的错误.
Try…catch对每个catch语句都从头到尾检查,如果找到处理同类异常的catch子句,此catch块中的语句将得以执行,而不再处理同层次的其它catch块.
如果catch或finally抛出另一个异常,程序将不会再去检查try的catch子句.
Try...catch语句可以嵌套,内层抛出的异常可被外层处理.

Throws子句

函数能抛出的检查型异常用throws声明,它后面可以是带用逗号隔开的一系列异常类型.仅仅那些在方法中不被捕获的异常必须列出.

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // Read in size
        int size = s.readInt();

        // Initialize header
        header = new Entry<E>(null, null, null);
        header.next = header.previous = header;

        // Read in all elements in the proper order.
        for (int i=0; i<size; i++)
             addBefore((E)s.readObject(), header);
        }
}

More…

Throws子句的约定是严格强制性的,只能抛出throws子句中声明的异常类型,抛出其它类型的异常是非法的,不管是直接利用throw,还是调用别的方法间接的抛出.
RuntimeException和Error是仅有的不必由throws子句列出的异常.
调用函数的函数要么处理对声明的异常进行处理,要么也声明同样的异常,将收到的异常抛向上层.

对检查型异常通常进行的几种处理

1) 用e.printStackTrace()输出异常信息.
2) 将异常记录到日志中以备查,如logger.error(e.getMessage()).
3) 试图进行异常恢复.
4) 告知维护者和用户发生的情况.

内部类的出现
当进行Java开发时,有时需要实现一个仅包含1-2个方法的接口.在AWT和Swing开发中经常出现这种情况,例如当一个display组件需要一个事件回调方法如一个按钮的ActionListener时. 如果使用普通的类来实现此操作,最终会得到很多仅在单个位置上使用的小型类.
内部类用于处理这种情况,java允许定义内部类,而且可在Gui外使用内部类.

内部类的定义和实现

内部类是指在另一个类内部定义的一个类.可以将内部类定义为一个类的成员.
public class Linker{
  public class LinkedNode{
    private LinkedNode prev;
    private LinkedNode next;
    private String content;
   
    public LinkedNode(String content){
      this.content=content;
    }
  }
 
  public Linker(){
    LinkedNode first=new LinkedNode("First");
    LinkedNode second=new LinkedNode("Second");
   
    first.next=second;
    second.prev=first;
  }
}

定义在一个类方法中的内部类

public class Hapiness{
  interface Smiler{
    public void smile();
  }
 
  public static void main(String[] args){
    class Happy implements Smiler{
      public void smile(){
        System.out.println(":-}");
      }
    }
   
    Happy happy=new Happy();
    happy.smile();
  }
}

匿名类

对很多情况而言,定义在方法内部的类名意义不大,它可以保持为匿名的,程序员关心的只是它的实例名.
如:
Runnable runner=new Runnable(){
     public void  run(){
          // Run statememnt
     }
}

理解匿名类

匿名类并不难理解,它只是把类的定义过程和实例的创建过程混合而已,上页的语句实际上相当于如下语句:
// 定义类
Public class Runner implements Runnable{
     public void run(){
         // do sth
      }
}

// 创建实例
Runner runner=new Runner();

使用匿名类的筛选解耦过程

需求:从公司的职员列表中,找出男性且年龄大于22的成员.

传统写法:

   List allmembers=company.getMembers();// 取得所有成员
    List results=new ArrayList();// 结果列表
   
    for(Iterator it=allmembers.iterator();it.hasNext();){
     Member member=(Member)it.next();
    
     if(member.getAge()>22 && member.isMale()){  // 筛选,这里是把查询条件和遴选过程融合在一起,条件一变立即就得加个分支.
      results.add(member);
     }
   }

传统方法的缺陷

这种写法没有错,但是不是面向对象的写法,它有以下缺陷:
1.查询条件和筛选过程没有分离.
2.这样写的后果使Company变成了一个失血模型而不是领域模型.
3.换查询条件的话,上面除了"筛选"一句有变化外其它都是模板代码,重复性很高.

使用匿名类实现的OO化查询

真正符合OO的查询应该是这样:

   MemberFilter filter1=new MemberFilter(){
    public boolean accept(Member member) {
         return member.isMale() && member.getAge()>22;
    }
   };
  
   List ls=company.listMembers(filter1);
 

这段代码成功的把查询条件作为一个接口分离了出去,接口代码如下:

public interface MemberFilter{
  public boolean accept(Member member);
}

查询函数的变化

而类Company增加了这样一个函数:

public List searchMembers(MemberFilter memberFilter){
   List retval=new ArrayList();
   
    for(Iterator it=members.iterator();it.hasNext();){
     Member member=(Member)it.next();
    
     if(memberFilter.accept(member)){
      retval.add(member);
    }
   } 
  
   return retval;
}
这就把模板代码归结到了类内部,外面不会重复书写了.Company也同时拥有了数据和行为,而不是原来的数据容器了.

匿名类的例子二

用匿名类处理分类汇总的方法 分类汇总是统计中常用,举例来说如统计学生成绩,及格不及格的归类,分优良中差等级归类等,每个单项代码很好写,但是如果分类汇总的项目多了,能一种汇总写一个函数吗? 比如说有些科目60分才算及格,有些科目50分就算;有些老师喜欢分优良中差四等,有些老师却喜欢分ABCD;不一而足,如果每个都写一个函数无疑是个编写和维护恶梦. 如果我们用匿名类把分类汇总的规则和分类汇总的过程分别抽象出来,代码就清晰灵活多了,以下代码讲述了这个过程.

基本类Student

public class Student{
    private String name;
    private int score;
   
    public Student(String name,int score){
        this.name=name;
        this.score=score;
    }
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }   
}

用于分类汇总的类

它强制子类实现getKey和getvalue两个方法:
public abstract class ClassifyRule {
    public Student student;
   
    public ClassifyRule(){       
    }   

    public void setStudent(Student student) {
        this.student = student;
    }
   
    abstract public String getKey();
    abstract public int getValue();
}

对Student进行统计处理的StudentService类

注意getSum方法,它保留了筛选过程,筛选规则则不在其中:
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

public class StudentService {
    private List<Student> students;

    public StudentService() {
        students = new ArrayList<Student>();
    }

    public void add(Student student) {
        students.add(student);
    }

    public Hashtable<String, Integer> getSum(ClassifyRule rule) {
        Hashtable<String, Integer> ht = new Hashtable<String, Integer>();

        for (Student student : students) {
            rule.setStudent(student);
            String key = rule.getKey();
            int value = rule.getValue();

            if (ht.containsKey(key)) {
                Integer oldValue = ht.remove(key);
                oldValue += value;
                ht.put(key, oldValue);
            } else {
                ht.put(key, value);
            }
        }

        return ht;
    }
}

测试代码,注意其中筛选规则的创建

public class Test {
    public static void main(String[] args) {
        // 初始化
        StudentService service = new StudentService();
        service.add(new Student("Andy", 90));
        service.add(new Student("Bill", 95));
        service.add(new Student("Cindy", 70));
        service.add(new Student("Dural", 85));
        service.add(new Student("Edin", 60));
        service.add(new Student("Felix", 55));
        service.add(new Student("Green", 15));

        // 60分及格筛选
        ClassifyRule rule60 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 60 ? "及格" : "不及格";
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("60分及格筛选");
        printHt(service.getSum(rule60));

        // 50分及格筛选
        ClassifyRule rule50 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 50 ? "及格" : "不及格";
            }

            public int getValue() {
                return 1;
            }
        };
        System.out.println("\n50分及格筛选");
        printHt(service.getSum(rule50));

        // 分"优良中差"等级
        ClassifyRule ruleCn = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "优";
                } else if (score >= 80) {
                    retval = "良";
                } else if (score >= 60) {
                    retval = "中";
                } else if (score > 0) {
                    retval = "差";
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

测试代码

System.out.println("\n分优良中差等级筛选");
        printHt(service.getSum(ruleCn));

        // 分"ABCD"等级
        ClassifyRule ruleWest = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "A";
                } else if (score >= 80) {
                    retval = "B";
                } else if (score >= 60) {
                    retval = "C";
                } else if (score > 0) {
                    retval = "D";
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("\n分ABCD等级筛选");
        printHt(service.getSum(ruleWest));
    }

    private static void printHt(Hashtable ht) {
        for (Iterator it = ht.keySet().iterator(); it.hasNext();) {
            String key = (String) it.next();
            Integer value = (Integer) ht.get(key);
            System.out.println("Key=" + key + " Value=" + value);
        }
    }
}

测试结果如下:

60分及格筛选
Key=及格 Value=5
Key=不及格 Value=2

50分及格筛选
Key=及格 Value=6
Key=不及格 Value=1

分优良中差等级筛选
Key=优 Value=2
Key=良 Value=1
Key=中 Value=2
Key=差 Value=2

分ABCD等级筛选
Key=A Value=2
Key=D Value=2
Key=C Value=2
Key=B Value=1

后记

内部类也叫嵌套类,一般不提倡书写,但它在java核心类中都存在,如接口Map中的Entry,我们应该了解并能解读这种方法.

匿名类相对而言有用得多,在解耦合和事件回调注册中很常见,大家应该对它的运用融会贯通.

Socket概述
Socket的重要API
一个Socket通信的例子

Socket是什么？

Socket通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过“套接字”向网络发出请求或者应答网络请求。
在java中，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。
对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。

Socket的直观描述

Socket的英文原义是“孔”或“插座”。在这里作为进程通信机制，取后一种意义。socket非常类似于电话插座。以一个国家级电话网为例。电话的通话双方相当于相互通信的2个进程，区号是它的网络地址；区内一个单位的交换机相当于一台主机，主机分配给每个用户的局内号码相当于socket号。任何用户在通话之前，首先要占有一部电话机，相当于申请一个socket；同时要知道对方的号码，相当于对方有一个固定的socket。然后向对方拨号呼叫，相当于发出连接请求(假如对方不在同一区内，还要拨对方区号，相当于给出网络地址)。对方假如在场并空闲(相当于通信的另一主机开机且可以接受连接请求)，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭socket，撤消连接。
在电话系统中，一般用户只能感受到本地电话机和对方电话号码的存在，建立通话的过程，话音传输的过程以及整个电话系统的技术细节对他都是透明的，这也与socket机制非常相似。socket利用网间网通信设施实现进程通信，但它对通信设施的细节毫不关心，只要通信设施能提供足够的通信能力，它就满足了。
 至此，我们对socket进行了直观的描述。抽象出来，socket实质上提供了进程通信的端点。进程通信之前，双方首先必须各自创建一个端点，否则是没有办法建立联系并相互通信的。正如打电话之前，双方必须各自拥有一台电话机一样。

socket 是面向客户/服务器模型而设计的

socket 是面向客户/服务器模型而设计的，针对客户和服务器程序提供不同的socket 系统调用。客户随机申请一个socket (相当于一个想打电话的人可以在任何一台入网电话上拨号呼叫)，系统为之分配一个socket号；服务器拥有全局公认的 socket ，任何客户都可以向它发出连接请求和信息请求(相当于一个被呼叫的电话拥有一个呼叫方知道的电话号码)。
socket利用客户/服务器模式巧妙地解决了进程之间建立通信连接的问题。服务器socket为全局所公认非常重要。读者不妨考虑一下，两个完全随机的用户进程之间如何建立通信？假如通信双方没有任何一方的socket 固定，就好比打电话的双方彼此不知道对方的电话号码，要通话是不可能的。

Socket的应用

Socket 接口是访问 Internet 使用得最广泛的方法。 如果你有一台刚配好TCP/IP协议的主机，其IP地址是202.120.127.201， 此时在另一台主机或同一台主机上执行ftp 202.120.127.201，显然无法建立连接。因"202.120.127.201" 这台主机没有运行FTP服务软件。同样， 在另一台或同一台主机上运行浏览软件 如Netscape，输入"http://202.120.127.201"，也无法建立连接。现在，如果在这台主机上运行一个FTP服务软件（该软件将打开一个Socket， 并将其绑定到21端口），再在这台主机上运行一个Web 服务软件（该软件将打开另一个Socket，并将其绑定到80端口）。这样，在另一台主机或同一台主机上执行ftp 202.120.127.201，FTP客户软件将通过21端口来呼叫主机上由FTP 服务软件提供的Socket，与其建立连接并对话。而在netscape中输入"http://202.120.127.201"时，将通过80端口来呼叫主机上由Web服务软件提供的Socket，与其建 立连接并对话。 在Internet上有很多这样的主机，这些主机一般运行了多个服务软件，同时提供几种服务。每种服务都打开一个Socket，并绑定到一个端口上，不同的端口对应于不同的服务。Socket正如其英文原意那样，象一个多孔插座。一台主机犹如布满各种插座的房间，每个插座有一个编号，有的插座提供220伏交流电， 有的提供110伏交流电，有的则提供有线电视节目。 客户软件将插头插到不同编号的插座，就可以得到不同的服务。

重要的Socket API

accept方法用于产生“阻塞”，直到接受到一个连接，并且返回一个客户端的Socket对象实例。“阻塞”是一个术语，它使程序运行暂时“停留”在这个地方，直到一个会话产生，然后程序继续；通常“阻塞”是由循环产生的。
getInputStream方法获得网络连接输入，同时返回一个IutputStream对象实例。
getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。 注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

一个Server-Client模型的程序的开发原理

服务器，使用ServerSocket监听指定的端口，端口可以随意指定（由于1024以下的端口通常属于保留端口，在一些操作系统中不可以随意使用，所以建议使用大于1024的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。
客户端，使用Socket对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个1024以上的端口。

服务器端代码

public class ResponseThread implements Runnable {
  private static Logger logger = Logger.getLogger(ResponseThread.class);
 
  // 用于与客户端通信的Socket
  private Socket incomingSocket;

  /**
   * 构造函数,用以将incomingSocket传入
   * @param incomingSocket
   */
  public ResponseThread(Socket incomingSocket) {
    this.incomingSocket = incomingSocket;
  }

  public void run() {
    try {
      try {
        // 输入流
        InputStream inStream = incomingSocket.getInputStream();
       
        // 输出流
        OutputStream outStream = incomingSocket.getOutputStream();

        // 文本扫描器
        Scanner in = new Scanner(inStream);
       
        // 输出流打印器
        PrintWriter out = new PrintWriter(outStream,true);
       
        while (in.hasNextLine()) {
          String line = in.nextLine();
          logger.info("从客户端获得文字:"+line);
         
          String responseLine=line+" 门朝大海 三河合水万年流";
          out.println(responseLine);
          logger.info("向客户端送出文字:"+responseLine);
        }
      } finally {
        incomingSocket.close();
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }
 public static void main(String[] args) {
    try {
      // 建立一个对2009端口进行监听的ServerSocket并开始监听
      ServerSocket socket=new ServerSocket(2009);
      logger.info("开始监听");
     
      while(true){
        // 产生阻塞,直到客户端连接过来才会往下执行
        logger.info("阻塞中,等待来自客户端的连接请求");
        Socket incomingSocket=socket.accept();       
       
        // 执行到这里客户端已经连接过来了,incomingSocket就是创建出来和远程客户端Socket进行通信的Socket
        logger.info("获得来自"+incomingSocket.getInetAddress()+"的请求."); 
       
        // 开辟一个线程,并把incomingSocket传进去,在这个线程中服务器和客户机开始通信
        ResponseThread responseThread=new ResponseThread(incomingSocket);
       
        // 启动线程
        Thread thread=new Thread(responseThread);
        thread.start();
      }
     
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

客户端代码

/**
 * Socket客户端类
 * @author sitinspring
 *
 * @date 2008-2-26
 */
public class SocketClient{
  private static Logger logger = Logger.getLogger(ResponseThread.class);
 
  public static void main(String[] args){
    try {
      // 建立一个Socket,试图连接到位于127.0.0.1的主机的2009端口,如果服务器已经在监听则会接收到这个请求,accept方法产生一个和这边通信的Socket
      Socket socket=new Socket("127.0.0.1",2009);
      logger.info("客户端向服务器发起请求.");
     
      try {
        // 输入流
        InputStream inStream = socket.getInputStream();
       
        // 输出流
        OutputStream outStream = socket.getOutputStream();

        /**
         * 向服务器发送文字
         */
        // 输出流打印器
        PrintWriter out = new PrintWriter(outStream);
        out.println("地震高岗 一派溪山千古秀");
        out.flush();
       
        /**
         * 接收服务器发送过来的文字
         */
        // 文本扫描器
        Scanner in = new Scanner(inStream);
        while (in.hasNextLine()) {
          String line = in.nextLine();
          logger.info("客户端获得响应文字="+ line);
        }
      } finally {
        // 关闭Socket
        socket.close();
      }
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

1.将Date转化为常见的日期时间字符串
这里我们需要用到java.text.SimpleDateFormat类的format方法，其中可以指定年月日时分秒的模式字符串格式。
Date date = new Date();
Format formatter = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
System.out.println("转化的时间等于="+formatter.format(date));
其中
yyyy表示四位数的年份
MM表示两位数的月份
dd表示两位数的日期
HH表示两位数的小时
mm表示两位数的分钟
ss表示两位数的秒钟

2.将文本日期转化为Date以方便比较
文本日期的优势在于便于记忆，容易处理，但缺点是不方便比较，这时我们需要借助SimpleDateFormat的parse方法得到Date对象再进行比较，实例如下：
String strDate1="2004年8月9日";
String strDate2="2004年10月5日";

SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy年MM月dd日");
java.util.Date date1 = myFormatter.parse(strDate1);

java.util.Date date2 = myFormatter.parse(strDate2);

// Date比较能得出正确结果
if(date2.compareTo(date1)>0){
      System.out.println(strDate2+">"+strDate1);
}

// 字符串比较得不出正确结果
if(strDate2.compareTo(strDate1)>0){
      System.out.println(strDate2+">"+strDate1);
}

3.将文本日期转化为Date以方便计算
文本日期的另一个大问题是不方便计算，比如计算2008年1月9日的100天后是那一天就不容易，此时我们还是需要把文本日期转化为Date进行计算，再把结果转化为文本日期：
SimpleDateFormat myFormatter = new SimpleDateFormat("yyyy年MM月dd日");
java.util.Date date = myFormatter.parse("2008年1月9日");
date.setDate(date.getDate()+100);

Format formatter = new SimpleDateFormat("yyyy年MM月dd日");

// 得到2008年04月18日
System.out.println("100天后为"+formatter.format(date));

在运行过程中,应用程序可能遭遇各种严重程度不同的问题.异常提供了一种在不弄乱程序的情况下检查错误的巧妙方式.它也提供了一种直接报告错误的机制,而不必检查标志或者具有此作用的域.异常把方法能够报告的错误作为方法约定的一个显式部分.
异常能够被程序员看到,由编译器检查,并且由重载方法的子类保留.
如果遇到意外的错误将抛出异常,然后异常被方法调用栈上的子句捕获.如果异常未被捕获,将导致执行线程的终止.

异常的体系结构

毫无疑问,在java中异常是对象,它必定继承Throwable及其子类.Throwable中含有一个用于描述异常的字符串.Exception是Throwable的一个最常用子类,另一个子类是Error.而RuntimeException继承自Exception.

异常的种类

非检查型异常(Unchecked Exception):
非检查型异常反映了程序中的逻辑错误,不能从运行中合理恢复.
标准的运行时异常和错误构成非检查型异常,它们继承自RuntimeException和Error.
非检查型异常不用显示进行捕获.

检查型异常(Checked Exception):
这种异常描述了这种情况,虽然是异常的,但被认为是可以合理发生的,如果这种异常真的发生了,必须调用某种方法处理.
Java异常大多是检查型异常,继承自Exception类,你自己定义的异常必须是继承Exception的检查型异常.
检查型异常必须进行显示捕获.

自定义异常

继承Exception即可定义自己的异常,以下是一种常见写法
public class DBXmlFileReadException extends Exception{
  public DBXmlFileReadException(String   msg){
    super(msg);
  }
}

抛出异常

在Java语句中,可以用throw语句抛出异常,如throw new NoSuchElementException();
抛出的对象必须是Throwable类的子类型.

抛出异常的策略:
1) 如果抛出后不可能得到处理,可以抛出Error.
2) 如果你想让其它类自由选择是否处理这个异常,就可以抛出RuntimeException.
3) 如果你要求类的用户必须处理这个异常,则可以抛出Exception.

异常抛出后的控制权转移

一旦发生异常,异常发生点后的动作将不会发生.此后将要发生的操作不是在catch块和finally块.

当异常抛出时,导致异常发生的语句和表达式就被称为突然完成.语句的突然完成将导致调用链逐渐展开,直到该异常被捕获.

如果该异常没有捕获,执行线程将中止.

Try,catch和finally

异常由包含在try块中的语句捕获:
    try{
      正常执行语句
    }
    catch(XException e){
      异常执行语句一
    }
    catch(XXException e){
      异常执行语句二
    }
    catch(XXXException e){
      异常执行语句三
    }
    finally{
      中止语句
    }

Try中的语句体要么顺利完成,要么执行到抛出异常.
如果抛出异常,就要找出对应于异常类或其父类的catch子句,如果未能找到合适的catch子句,异常就从try语句中扩散出来,进入到外层可能对它进行处理的try语句.
Catch子句可以有多个,只要这些子句捕获的异常类型不同.
如果在try中有finally子句,其代码在try把所有其它处理完成之后执行.
无论是正常完成或是出现异常,甚至是通过return或者break这样的控制语句结束,finally子句总是被执行.
Catch子句和finally子句在try语句之后至少有一个,不要求全部出现.

More…

在catch语句中捕获通用的异常Exception通常不是最佳策略,因为它会将所有异常进行等同处理.
不能把基类异常的catch语句放到子类异常的catch语句之前,编译器会在运行之前就检查出这样的错误.
Try…catch对每个catch语句都从头到尾检查,如果找到处理同类异常的catch子句,此catch块中的语句将得以执行,而不再处理同层次的其它catch块.
如果catch或finally抛出另一个异常,程序将不会再去检查try的catch子句.
Try...catch语句可以嵌套,内层抛出的异常可被外层处理.

Throws子句

函数能抛出的检查型异常用throws声明,它后面可以是带用逗号隔开的一系列异常类型.仅仅那些在方法中不被捕获的异常必须列出.

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // Read in any hidden serialization magic
        s.defaultReadObject();

        // Read in size
        int size = s.readInt();

        // Initialize header
        header = new Entry<E>(null, null, null);
        header.next = header.previous = header;

        // Read in all elements in the proper order.
        for (int i=0; i<size; i++)
             addBefore((E)s.readObject(), header);
        }
}

More…

Throws子句的约定是严格强制性的,只能抛出throws子句中声明的异常类型,抛出其它类型的异常是非法的,不管是直接利用throw,还是调用别的方法间接的抛出.
RuntimeException和Error是仅有的不必由throws子句列出的异常.
调用函数的函数要么处理对声明的异常进行处理,要么也声明同样的异常,将收到的异常抛向上层.

对检查型异常通常进行的几种处理
1) 用e.printStackTrace()输出异常信息.
2) 将异常记录到日志中以备查,如logger.error(e.getMessage()).
3) 试图进行异常恢复.
4) 告知维护者和用户发生的情况.

当进行Java开发时,有时需要实现一个仅包含1-2个方法的接口.在AWT和Swing开发中经常出现这种情况,例如当一个display组件需要一个事件回调方法如一个按钮的ActionListener时. 如果使用普通的类来实现此操作,最终会得到很多仅在单个位置上使用的小型类.
内部类用于处理这种情况,java允许定义内部类,而且可在Gui外使用内部类.

内部类的定义和实现

内部类是指在另一个类内部定义的一个类.可以将内部类定义为一个类的成员.
public class Linker{
  public class LinkedNode{
    private LinkedNode prev;
    private LinkedNode next;
    private String content;
   
    public LinkedNode(String content){
      this.content=content;
    }
  }
 
  public Linker(){
    LinkedNode first=new LinkedNode("First");
    LinkedNode second=new LinkedNode("Second");
   
    first.next=second;
    second.prev=first;
  }
}

定义在一个类方法中的内部类

public class Hapiness{
  interface Smiler{
    public void smile();
  }
 
  public static void main(String[] args){
    class Happy implements Smiler{
      public void smile(){
        System.out.println(":-}");
      }
    }
   
    Happy happy=new Happy();
    happy.smile();
  }
}

匿名类

对很多情况而言,定义在方法内部的类名意义不大,它可以保持为匿名的,程序员关心的只是它的实例名.
如:
Runnable runner=new Runnable(){
     public void  run(){
          // Run statememnt
     }
}

理解匿名类

匿名类并不难理解,它只是把类的定义过程和实例的创建过程混合而已,上页的语句实际上相当于如下语句:
// 定义类
Public class Runner implements Runnable{
     public void run(){
         // do sth
      }
}

// 创建实例
Runner runner=new Runner();

使用匿名类的筛选解耦过程

需求:从公司的职员列表中,找出男性且年龄大于22的成员.

传统写法:

   List allmembers=company.getMembers();// 取得所有成员
    List results=new ArrayList();// 结果列表
   
    for(Iterator it=allmembers.iterator();it.hasNext();){
     Member member=(Member)it.next();
    
     if(member.getAge()>22 && member.isMale()){  // 筛选,这里是把查询条件和遴选过程融合在一起,条件一变立即就得加个分支.
      results.add(member);
     }
   }
传统方法的缺陷

这种写法没有错,但是不是面向对象的写法,它有以下缺陷:
1.查询条件和筛选过程没有分离.
2.这样写的后果使Company变成了一个失血模型而不是领域模型.
3.换查询条件的话,上面除了"筛选"一句有变化外其它都是模板代码,重复性很高.

使用匿名类实现的OO化查询

真正符合OO的查询应该是这样:

   MemberFilter filter1=new MemberFilter(){
    public boolean accept(Member member) {
         return member.isMale() && member.getAge()>22;
    }
   };
  
   List ls=company.listMembers(filter1);
 

这段代码成功的把查询条件作为一个接口分离了出去,接口代码如下:

public interface MemberFilter{
  public boolean accept(Member member);
}

查询函数的变化

而类Company增加了这样一个函数:

public List searchMembers(MemberFilter memberFilter){
   List retval=new ArrayList();
   
    for(Iterator it=members.iterator();it.hasNext();){
     Member member=(Member)it.next();
    
     if(memberFilter.accept(member)){
      retval.add(member);
    }
   } 
  
   return retval;
}
这就把模板代码归结到了类内部,外面不会重复书写了.Company也同时拥有了数据和行为,而不是原来的数据容器了.

匿名类的例子二

用匿名类处理分类汇总的方法 分类汇总是统计中常用,举例来说如统计学生成绩,及格不及格的归类,分优良中差等级归类等,每个单项代码很好写,但是如果分类汇总的项目多了,能一种汇总写一个函数吗? 比如说有些科目60分才算及格,有些科目50分就算;有些老师喜欢分优良中差四等,有些老师却喜欢分ABCD;不一而足,如果每个都写一个函数无疑是个编写和维护恶梦. 如果我们用匿名类把分类汇总的规则和分类汇总的过程分别抽象出来,代码就清晰灵活多了,以下代码讲述了这个过程.

基本类Student

public class Student{
    private String name;
    private int score;
   
    public Student(String name,int score){
        this.name=name;
        this.score=score;
    }
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }   
}

用于分类汇总的类

它强制子类实现getKey和getvalue两个方法:
public abstract class ClassifyRule {
    public Student student;
   
    public ClassifyRule(){       
    }   

    public void setStudent(Student student) {
        this.student = student;
    }
   
    abstract public String getKey();
    abstract public int getValue();
}

对Student进行统计处理的StudentService类

注意getSum方法,它保留了筛选过程,筛选规则则不在其中:
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;

public class StudentService {
    private List<Student> students;

    public StudentService() {
        students = new ArrayList<Student>();
    }

    public void add(Student student) {
        students.add(student);
    }

    public Hashtable<String, Integer> getSum(ClassifyRule rule) {
        Hashtable<String, Integer> ht = new Hashtable<String, Integer>();

        for (Student student : students) {
            rule.setStudent(student);
            String key = rule.getKey();
            int value = rule.getValue();

            if (ht.containsKey(key)) {
                Integer oldValue = ht.remove(key);
                oldValue += value;
                ht.put(key, oldValue);
            } else {
                ht.put(key, value);
            }
        }

        return ht;
    }
}

测试代码,注意其中筛选规则的创建

public class Test {
    public static void main(String[] args) {
        // 初始化
        StudentService service = new StudentService();
        service.add(new Student("Andy", 90));
        service.add(new Student("Bill", 95));
        service.add(new Student("Cindy", 70));
        service.add(new Student("Dural", 85));
        service.add(new Student("Edin", 60));
        service.add(new Student("Felix", 55));
        service.add(new Student("Green", 15));

        // 60分及格筛选
        ClassifyRule rule60 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 60 ? "及格" : "不及格";
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("60分及格筛选");
        printHt(service.getSum(rule60));

        // 50分及格筛选
        ClassifyRule rule50 = new ClassifyRule() {
            public String getKey() {
                return student.getScore() >= 50 ? "及格" : "不及格";
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("\n50分及格筛选");
        printHt(service.getSum(rule50));

        // 分"优良中差"等级
        ClassifyRule ruleCn = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "优";
                } else if (score >= 80) {
                    retval = "良";
                } else if (score >= 60) {
                    retval = "中";
                } else if (score > 0) {
                    retval = "差";
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

测试代码

 System.out.println("\n分优良中差等级筛选");
        printHt(service.getSum(ruleCn));

        // 分"ABCD"等级
        ClassifyRule ruleWest = new ClassifyRule() {
            public String getKey() {
                String retval = "";

                int score = student.getScore();
                if (score >= 90) {
                    retval = "A";
                } else if (score >= 80) {
                    retval = "B";
                } else if (score >= 60) {
                    retval = "C";
                } else if (score > 0) {
                    retval = "D";
                }

                return retval;
            }

            public int getValue() {
                return 1;
            }
        };

        System.out.println("\n分ABCD等级筛选");
        printHt(service.getSum(ruleWest));
    }

    private static void printHt(Hashtable ht) {
        for (Iterator it = ht.keySet().iterator(); it.hasNext();) {
            String key = (String) it.next();
            Integer value = (Integer) ht.get(key);
            System.out.println("Key=" + key + " Value=" + value);
        }
    }
}

测试结果如下:

60分及格筛选
Key=及格 Value=5
Key=不及格 Value=2

50分及格筛选
Key=及格 Value=6
Key=不及格 Value=1

分优良中差等级筛选
Key=优 Value=2
Key=良 Value=1
Key=中 Value=2
Key=差 Value=2

分ABCD等级筛选
Key=A Value=2
Key=D Value=2
Key=C Value=2
Key=B Value=1

小结

内部类也叫嵌套类,一般不提倡书写,但它在java核心类中都存在,如接口Map中的Entry,我们应该了解并能解读这种方法.

匿名类相对而言有用得多,在解耦合和事件回调注册中很常见,大家应该对它的运用融会贯通.

Boolean function:布尔函数
Bytecode:字节码

Casting:类型强制转换
Channel:频道
ClassCastException:当一个对象引用强制转换程一个不兼容的类型时出现的异常.
Collection:一个表示对象组或集合的接口
CSV(Comma-separated values):一种用于存储表格数据的文件形式
Complier:编译器
Compose:合成
Composite function:复合函数,通过多个函数创建的一个函数

Decimal:十进制
Deep:深度
DOM(Document Object Model):文档对象模型,一种采用树形表示来处理XML数据的API.
Database:数据库

Edge:边
Element:元素,XML文档中的一个节点.
Encapsulation:封装
End tag:结束标签
Enum:枚举
Escaping:转义

Function:函数
Fuzzy search:模糊搜索

Generic:泛型
Graph:图
GUI:用户图形界面
Grid computing:网格计算
Group:组

HashMap:一个将键值映射到值的查找对象
Heap memory:堆内存
HTML(Hyper Text Markup Language):超文本标记语言
HTTP(HyperText Tranfer Protocol):超文本传输协议

Inheritance:继承
Inner class:内部类
Iterator:允许迭代到任何Collection类的一个接口

JDBC(Java Database Connectivity):java数据库连接,一种属于Java核心库的用于操作关系数据库的API.
JDK(Java Development Kit):java开发工具包
JRE(Java Runtime Environment):java运行时环境
JSP(Java Server Page):java服务页
JVM(Java Virtual machine):Java虚拟机
JavaDoc:属于JDK的一种文档生成工具
JavaScript:运行于客户端,用于HTML处理的一种轻量级教本语言,语法部分类似于Java.

Layout:布局
Lexical analysis:词法分析
Linked List:链表

Matcher:一个用于正则表达式模式匹配的Java类
Metadata:元数据
Millisecond:微妙

Namespace:命名空间
Neural network:神经网络
Node:节点

Object-oriented programmming:面向对象编程
Object pool:可以从中获得对象的一个实例池
Origin:原点
Override:子类覆写父类的方法

Parser:分析器
Patch:补丁
Pattern:模式
Polymorphism:多态性
Port:端口
Predicate:谓词
Prefix:前缀
Procedural language:过程式语言,如C
Property:属性

Real time:实时
Recursive:递归
Reference:引用
Reflection:反射
Regular expression:正则表达式
Relative:相对
Resource:资源
Runnable:多线程编程使用的一个接口.

Syntax:语法
Screen scraping:屏幕抓取
Split:分割
State:状态
Static:静态
Sequence:序列
Swing:构建在AWT上更高级的图形用户界面
Synchronized:同步,用于线程安全协作的技术

Tag:标签
Thread:进程
Tiger : Sun给Java1.5的代号
Token:标记
Translation:平移
Triple:三元组
Type:类型

Unicode:统一字符界面
Unit testing:单元测试

Visitor pattern:访问者模式

WAR(Web Application Archive):Web应用程序归档
Web Service:Web服务
Weight:权
Well-formed:格式良好的
Whitespace:空白符

XML(Extensible Markup Language):一种描述分级数据结构的文本标记语言

Java2中包含了6个集合接口,这些接口的通用目的实现类,以及一个集合实用类Collections,共同组成了集合框架的核心.
6个集合接口如下:
Collection及其以下的List,Set,以及Set下的SortedSet
Map及其以下的SortedMap

链表的通用实现

ArrayList:线程不安全的动态数组类,批量查询速度快,单个查找速度慢.
Vector:线程安全的动态数组类,效率比ArrayList低下.
LinkedList:动态链表类,适于在队列首尾频繁增删成员的场合.

链表的创建

List<Member> ls=new ArrayList<Member>();// 1.5版本及以上

List ls=new ArrayList();// 1.5版本以下

之所以将ls类型指定为List<Member>而不是ArrayList<Member>是因为 如果情况变化, ArrayList需要修改成Vector或LinkedList时无须修改其它代码,仅修改实例类型即可.

向List中添加元素

添加单个元素
ls.add(new Member("Andy",21));

从别的链表中添加多个元素
List<Member> ls2=new ArrayList<Member>();
ls2.add(new Member("Felex",21));
ls2.add(new Member("Gates",23));
ls.addAll(ls2);

注意:
1.5及其以上版本中,添加的元素必须和定义时一致,如ls的类型是List<Member>,那么向其中添加的元素必须是Member或其子类.
1.5以下版本中,对添加的元素不作检查,只要是Object即可,如果是基本类型则需装箱成类类型.如ls.add(new Integer(8));

删除链表中元素

ls.remove(member); // 直接删除对象,member=new Member("Edin",28)
ls.remove(2);           // 删除第三个元素
ls.clear();                // 将已有数据全部清除

对链表进行遍历

1) 1.5中独有的遍历方法,代码最短,使用最方便
for(Member member:ls){
     // member就是依次取出的每个元素
}

2) 常规方法,多用于需要取得下标的场合,各版本均适用
for(int i=0;i<ls.size();i++){
    Member member=ls.get(i);// member就是依次取出的每个元素, 1.5及其以上版本适用, ls.size()为链表长度
    Member member=(Member)ls.get(i);// 1.5以下版本适用
}

3) 使用Iterator对链表进行遍历的方法,各版本均适用
for(Iterator it=ls.iterator();it.hasNext();){
    Member member=(Member)it.next();
}

链表的其它常用的方法

ls.contains(Object o);// 返回链表中是否包含某元素
ls.indexOf(Object o);// 返回对象o是链表中的第几号元素
isEmpty();// 返回链表中是否有元素

对链表进行排序
1）让List中元素必须已经实现Comparable接口:
public class Member implements Comparable {
  private String name;

  private int age;

  public Member(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public int compareTo(Object obj) {
    Member another = (Member) obj;
    return this.name.compareTo(another.name);// 按名称排序,如果是this.age-another.age则按年龄排序
  }
 
  public String toString(){
    return "Member name="+name+" age="+age;
  }
}

2）排序过程
List<Member> ls=new ArrayList<Member>();

ls.add(new Member("Felex",21));
ls.add(new Member("Gates",23));
ls.add(new Member("Andy",21));
ls.add(new Member("Bill",23));
ls.add(new Member("Cindy",24));
ls.add(new Member("Dell",27));

Collections.sort(ls);

for(Member member:ls){
      System.out.println(member);
}

输出:
Member name=Andy age=21
Member name=Bill age=23
Member name=Cindy age=24
Member name=Dell age=27
Member name=Felex age=21
Member name=Gates age=23

// 如果需要逆序可以使用Collections.reverse(ls);

链表与数组之间的转换

1) List转换成数组
List<String> ls=new ArrayList<String>();

ls.add("Felex");
ls.add("Gates");
ls.add("Andy");
ls.add("Bill");
ls.add("Cindy");
ls.add("Dell");

Object[] arr=ls.toArray();
for(Object obj:arr){
      System.out.println((Object)obj);
}

输出为:
Felex
Gates
Andy
Bill
Cindy
Dell

2) 数组转换成List
String[] arr={"Andy","Bill","Cindy","Dell"};
List<String> ls=Arrays.asList(arr);
for(String str:ls){
     System.out.println(str);
}

输出:
Andy
Bill
Cindy
Dell

以哈希表的形式存储数据,数据的形式是键值对.
特点:
查找速度快,遍历相对慢
键值不能有空指针和重复数据

创建
Hashtable<Integer,String> ht=new Hashtable<Integer,String>();

添值

ht.put(1,"Andy");
ht.put(2,"Bill");
ht.put(3,"Cindy");
ht.put(4,"Dell");
ht.put(5,"Felex");
ht.put(6,"Edinburg");
ht.put(7,"Green");

取值

String str=ht.get(1);
System.out.println(str);// Andy

对键进行遍历

Iterator it = ht.keySet().iterator();

while (it.hasNext()) {
    Integer key = (Integer)it.next();
    System.out.println(key);
}

对值进行遍历

Iterator it = ht.values().iterator();

while (it.hasNext()) {
    String value =(String) it.next();
    System.out.println(value);
}

取Hashtable记录数

Hashtable<Integer,String> ht=new Hashtable<Integer,String>();

ht.put(1,"Andy");
ht.put(2,"Bill");
ht.put(3,"Cindy");
ht.put(4,"Dell");
ht.put(5,"Felex");
ht.put(6,"Edinburg");
ht.put(7,"Green");

int i=ht.size();// 7

删除元素

Hashtable<Integer,String> ht=new Hashtable<Integer,String>();

ht.put(1,"Andy");
ht.put(2,"Bill");
ht.put(3,"Cindy");
ht.put(4,"Dell");
ht.put(5,"Felex");
ht.put(6,"Edinburg");
ht.put(7,"Green");

ht.remove(1);
ht.remove(2);
ht.remove(3);
ht.remove(4);

System.out.println(ht.size());// 3

Iterator it = ht.values().iterator();

while (it.hasNext()) {
        // Get value
    String value =(String) it.next();
    System.out.println(value);
}

输出:
3
Green
Edinburg
Felex

类,抽象类与接口都是Java中实现继承和多态的手段.
类强调的是继承
接口强调的是规范
抽象类兼而有之

什么是接口

接口是一种特殊的类,它只有方法定义而没有实现,实现的任务完全交给子类完成.
接口以interface标志.
继承接口用implements关键字实现.
接口可以继承接口.
接口可以有成员,但成员全是public static final类型的.
接口没有构造函数.
接口给Java提供了多继承机制

接口例子—Knockable

public interface Knockable{
        public static final String Sound="Bang!";
        public void knock();
}

接口例子-实现接口

public class Hammer implements Knockable{
    public void knock(){
           System.out.println(Sound);
    }
}

接口例子-实现多个接口

public interface Knockable{
    public static final String Sound="Bang!";
    public void knock();
}

public interface Clampable {
    public void clamp();
}

public class Pliers implements Knockable,Clampable{
   public void clamp(){
         // do sth
   }

   public void knock(){
        System.out.println(Sound);
   }
}

接口继承接口例子

public interface Knockable{
      public static final String Sound="Bang!";
      public void knock();
}

public interface Hitable extends Knockable{
      public void hit();
}

public class Stick implements Hitable{
      public void knock(){
          //  do sth
      }

      public void hit(){
          // do sth
      }
}

什么叫抽象类

类中具有抽象方法的类为抽象类.抽象方法以abstract在函数前修饰,只有定义没有实现,这一点和接口一致.
抽象类在类名前需加上abstract修饰符以标识.
抽象类不能生成实例.
抽象类的继承性和类一致.

抽象类的实现

public abstract class Gun{
  protected String cannon;
  protected List<Bullet> bullets;
   
  public abstract void shoot();
 
  public void addBullet(Bullet bullet){
    if(bullets==null){
      bullets=new LinkedList<Bullet>();
    }
   
    bullets.add(bullet);
  }
}

继承抽象类

public class Rifle extends Gun{
  public void shoot(){
    // Shoot Sth
  }
 
  public void reload(){
    if(bullets!=null){
      bullets.clear();
    }
   
    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
    addBullet(new Bullet());
  }
}

继承抽象类并实现接口

public abstract class Gun{
  protected String cannon;
  protected List<Bullet> bullets;
   
  public abstract void shoot();
 
  public void addBullet(Bullet bullet){
    if(bullets==null){
      bullets=new LinkedList<Bullet>();
    }
   
    bullets.add(bullet);
  }
}

public interface Thornable{
  public void thorn();
}

public class SpringFieldRifle extends Gun implements Thornable{
  public void thorn(){
    // thorn sth
  }
 
  public void shoot(){
    // shoot sth
  }
}

抽象类继承抽象类实现接口的例子

public abstract class Gun{
  protected String cannon;
  protected List<Bullet> bullets;
   
  public abstract void shoot();
 
  public void addBullet(Bullet bullet){
    if(bullets==null){
      bullets=new LinkedList<Bullet>();
    }
   
    bullets.add(bullet);
  }
}

public interface Handable{
  public void hold();
}

public abstract class HandGun extends Gun implements Handable{

}

public class BlackStar extends HandGun{
  public void hold(){
    // Hold the gun
  }
 
  public void shoot(){
    // Shoot Sth
  }
}

抽象类,接口,类的区别

继承好比家学渊源,所谓"忠厚传家久,诗书继世长",家长总会潜移默化的影响下一代,下一代也会在不经意中学习前辈的特点,但因为年少分辨能力不高加上世易时移有些优点已经不再是有点甚至会变成缺点,下一代会把前辈的优缺点不分良莠的继承下来.这也是日后出现问题的根源.

接口好比拜师学艺,"入了这个门,就得说这行话",比如相声界说学逗唱四门是必须要学的,但是"师傅领进门,修行在个人",学得怎么样还全看自己,指望不费力的继承什么是不可能的,具体功夫还得个人来过. 因为是自己来,具体实现成什么样自由度也很大,比如四门功课中的"唱",原指唱太平歌词,但因为爱听的少,现在相声演员已经不要求这个了,改为唱歌唱戏的唱,其实严格界定的话是"学"的一种.这也无所谓对错,郭德刚坚持唱太平歌词也行,笑林唱流行歌曲也不错,总之实现了就可以,实现得怎么样则留给实践来检验.一个类可以同时实现多个接口,就和艺人拜几个师傅是没有问题的,郭德刚就同时实现了大鼓和相声两个接口.

抽象类则介于继承和接口之间,既可不费力的从上一代继承,也可强制实现某接口,有如某大师收自己的孩子为徒,当然相声界不让这么干,其它曲艺行业还是可以的,比如京剧界的梅兰芳和其子梅葆玖,既有言传身教,也有强制实现,综合了继承和接口的特点.

抽象类,接口,类的详细区别

	接口	抽象类	类
可以继承自	接口	抽象类,类	抽象类,类
可以实现自	无	一个或多个接口	一个或多个接口
有否成员	只有static final成员	均可	均可
是否有构造函数	无	有	有
可否实例化	不可	不可	可
意图	规范行为	继承成员+规范行为	继承成员

抽象类,接口和类在继承体系中的位置

抽象类,接口一般来说都是从一般类总结归纳出来的抽象共性的东西,类则是实际具体的东西.
一般来说,应该把合理抽象出的抽象类,接口放在类继承体系的上层,子类依靠类来实现.