Explore Java's static nested classes and inner classes

Starting with JDK 1.1, Java provided the ability to create nested classes. A nested class is defined inside another class. There are two types of nested classes: static nested classes and inner classes.

A static nested class is declared inside another class with the static keyword or within a static context of that class. A static class has no access to instance-specific data.

An inner class is a nonstatic class declared inside another class. It has access to all of its enclosing class's instance data, including private fields and methods. Inner classes may access static data but may not declare static members unless those members are compile time constants.

Deciding which type of nested class to use depends on the data type your nested class needs to access. If you need access to instance data, you'll need an inner class. If you don't need access to instance data, a static nested class will suffice.

The most common use of inner classes is as event handlers for GUI-based applications. These classes are usually declared anonymously and as needed for each component that requires an event handler. The advantage of using an inner class for event handling is that you can avoid large If/else statements to decide which component is being handled. Each component gets its own event handler, so each event handler knows implicitly the component for which it's working.

The snippet below creates an anonymous inner class to handle the events created by an application's OK button.

The advantage of a static nested class is that it doesn't need an instance of the containing class to work. This can help you reduce the number of objects your application creates at runtime.

The semantics for creating instances of nested classes can be confusing. Below is a simple class that defines a static nested class and an inner class. Pay special attention to the main method, where an instance of each instance class is created.

Nested classes can be confusing, but once you understand their purpose and get used to the semantics, there isn't a lot to them. If you'd like to learn more about the details of nested classes, check out the Java Language Specification.

Only add the mapping files you need!

If you are running some few JUnit tests for a 400++ classes project you probably don't hit every class in those tests and thus do not need to add all those hbm.xml's to the Configuration. Go look at Hibernate's test suite on how you could let your TestCase decide what classes should be defined in the mapping.

Use serialized XML documents when configuring Configuration

When building the configuration 40-60% of the time is used by the XML parsers and Dom4j to read up the XML document. Significant performance increases can be done by serializing the Document object's to disc once, and afterwards just add them to the configuration by deserializing them first.

In the current cvs we have an experimental Configuration.addCachableFile() method that can be used as inspiration for previous Hibernate versions.

public Configuration addCachableFile(String xmlFile) throws MappingException {        
        try {
            File file = new File(xmlFile);
            File lazyfile = new File(xmlFile + ".bin");
            org.dom4j.Document doc = null; 
            List errors = new ArrayList();
            if(file.exists() && lazyfile.exists() && file.lastModified()<lazyfile.lastModified()) {
                log.info("Mapping lazy file: " + lazyfile.getPath());
                ObjectInputStream oip = null;
                oip = new ObjectInputStream(new FileInputStream(lazyfile));
                doc = (org.dom4j.Document) oip.readObject();
                oip.close(); 
            } else {
                doc = xmlHelper.createSAXReader(xmlFile, errors, entityResolver).read( file );
                log.info("Writing lazy file to " + lazyfile);
                ObjectOutputStream oup = new ObjectOutputStream(new FileOutputStream(lazyfile));
                oup.writeObject(doc);
                oup.flush();
                oup.close();
            }
            
            if ( errors.size()!=0 ) throw new MappingException( "invalid mapping", (Throwable) errors.get(0) );
            add(doc);
            return this;
        }
        catch (Exception e) {
            log.error("Could not configure datastore from file: " + xmlFile, e);
            throw new MappingException(e);
        }
    }

Disable Hibernates usage of cglib reflection optimizer

Put the following line in hibernate.properties:

hibernate.cglib.use_reflection_optimizer=false

It will make Hibernate start faster since it does not try to build cglib-enhanced objects to access getter/setters.

Note: It will have in impact on overall runtime performance since Hibernate will be forced to use standard JDK reflection for access. So it is most useful during development. (You will also get better error messages in some situations when the optimizer is disabled ;)

Another approach would be to serialize the whole Configuration 
object. What do you think about this? I have submitted a patch to  
the Jira to make the Configuration Serializable (see bugs 492 and 
147).

I can't fine addLazyFile() in CVS.  Is it still supposed to be there?

Try the Hibernate3 module (or just the alpha release)

The information on this page does not seem to be correct any
more. With Hibernate 3.0rc1, there is no Configuration.addLazyFile()
any more, but addCacheableFile(). How should it be used?

If you have terrible problems with startup time and
do NOT need certain features like:

* proxy objects
* lazy loading

or if you are using the stateless session,
then you can disable lazyness on class level like:

<class name="myClass" table="myTable" lazy="false">

The default is true and forces byte code generation of
some proxy class which takes a lot of time.
Perhaps some hibernate guru can tell us, which other
features will be disabled by this.

The Hibernate Configuration module implement is very bad.
I write a module to realize the dynamic loading mapping files.
But other function I can't resolve...

Hibernate Dynamic Module
This project is only a module of Hibernate http://www.hibernate.org Read
mapping file until insert/update/delete/select the persistent class in
Hibernate.
http://sourceforge.net/projects/hbn-dyn-mod/

        try {
            FileInputStream fis = new FileInputStream("serial");
            ObjectInputStream ois = new ObjectInputStream(fis);
            configuration = (Configuration) ois.readObject();
            ois.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        catch (IOException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        catch (ClassNotFoundException e) {
            e.printStackTrace();  //To change body of catch statement use File | Settings | File Templates.
        }
        if(configuration!=null)
        {
        SessionFactory sessionFactory = configuration.configure().buildSessionFactory();
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        callBack.doing(session);
        transaction.commit();
        }
    }
when will Configuration serialize and why it's some field seted transient?the example will be error because some field transient is null after serialize.

importjava.text.CollationKey;

import java.text.Collator;

import java.util.Comparator;

/**

 *@author www.inspiresky.com

 *

 */

publicclass CollatorComparator implements Comparator {

Collator collator = Collator.getInstance();

publicint compare(Object element1, Object element2) {

    CollationKey key1 = collator.getCollationKey(element1.toString());

    CollationKey key2 = collator.getCollationKey(element2.toString());

    return key1.compareTo(key2);

}

}

import java.util.Date; 

public class DateExample1 { 
    public static void main(String［］ args) { //自己替换［］
    // Get the system date/time 
    Date date = new Date(); 

    System.out.println(date.getTime()); 
    } 
} 

import java.text.SimpleDateFormat; 
import java.util.Date; 

public class DateExample2 { 

    public static void main(String［］ args) { //自己替换［］

        SimpleDateFormat bartDateFormat = 
        new SimpleDateFormat("EEEE-MMMM-dd-yyyy"); 

        Date date = new Date(); 

        System.out.println(bartDateFormat.format(date)); 
    } 
}

import java.text.SimpleDateFormat; 
import java.util.Date; 

public class DateExample3 { 

    public static void main(String［］args) { //自己替换［］
        // Create a date formatter that can parse dates of 
        // the form MM-dd-yyyy. 
        SimpleDateFormat bartDateFormat = 
        new SimpleDateFormat("MM-dd-yyyy"); 

        // Create a string containing a text date to be parsed. 
        String dateStringToParse = "9-29-2001"; 

        try { 
            // Parse the text version of the date. 
            // We have to perform the parse method in a 
            // try-catch construct in case dateStringToParse 
            // does not contain a date in the format we are expecting. 
            Date date = bartDateFormat.parse(dateStringToParse); 

            // Now send the parsed date as a long value 
            // to the system output. 
            System.out.println(date.getTime()); 
        } 
        catch (Exception ex) { 
            System.out.println(ex.getMessage()); 
        } 
    } 
} 

import java.text.DateFormat; 
import java.util.Date; 

public class DateExample4 { 

    public static void main(String［］ args) { //自己替换［］
        Date date = new Date(); 

        DateFormat shortDateFormat = 
        DateFormat.getDateTimeInstance( 
        DateFormat.SHORT, 
        DateFormat.SHORT); 

        DateFormat mediumDateFormat = 
        DateFormat.getDateTimeInstance( 
        DateFormat.MEDIUM, 
        DateFormat.MEDIUM); 

        DateFormat longDateFormat = 
        DateFormat.getDateTimeInstance( 
        DateFormat.LONG, 
        DateFormat.LONG); 

        DateFormat fullDateFormat = 
        DateFormat.getDateTimeInstance( 
        DateFormat.FULL, 
        DateFormat.FULL); 

        System.out.println(shortDateFormat.format(date)); 
        System.out.println(mediumDateFormat.format(date)); 
        System.out.println(longDateFormat.format(date)); 
        System.out.println(fullDateFormat.format(date)); 
    } 
} 

The DATE data type stores date and time information. For each DATE value, Oracle stores the following information: year, month, day, hour, minute, and second.

The date value can be specified as an ANSI date literal, an Oracle date literal or can be converted from a character or numeric value with the TO_DATE function. The ANSI date literal contains no time portion, and must be specified in the format 'YYYY-MM-DD'. The default date format for an Oracle date literal can be changed by the initialization parameter NLS_DATE_FORMAT.

Date data can range from January 1, 4712 BC to December 31, 9999.

If a date value is specified without a time component, then the default time is 12:00:00 AM. If a date value is specified without a date, then the default date is the first day of the current month.

---------------------------------------------------------------------------------------------------------------------------------------------------

TIMESTAMP[(fractional_seconds_precision)]

The TIMESTAMP data type is an extension of the DATE data type. For each TIMESTAMP value, Oracle stores the following information: year, month, day, hour, minute, second and fraction of second.

fractional_seconds_precision optionally specifies the number of digits in the fractional part of second and can be a number in the range 0 to 9. The default is 6.

The TIMESTAMP data type is available in Oracle 9i Release 1 (9.0.1) or later.

　　ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是thread local variable（线程局部变量）。也许把它命名为ThreadLocalVar更加合适。线程局部变量（ThreadLocal）其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。线程局部变量并不是Java的新发明，在其它的一些语言编译器实现（如IBM XL FORTRAN）中，它在语言的层次提供了直接的支持。因为Java中没有提供在语言层次的直接支持，而是提供了一个ThreadLocal的类来提供支持，所以，在Java中编写线程局部变量的代码相对比较笨拙，这也许是线程局部变量没有在Java中得到很好的普及的一个原因吧。

　　二、ThreadLocal的设计

　　首先看看ThreadLocal的接口：

Object get() ;

// 返回当前线程的线程局部变量副本 protected Object initialValue(); // 返回该线程局部变量的当前线程的初始值

void set(Object value);

// 设置当前线程的线程局部变量副本的值

　　ThreadLocal有3个方法，其中值得注意的是initialValue()，该方法是一个protected的方法，显然是为了子类重写而特意实现的。该方法返回当前线程在该线程局部变量的初始值，这个方法是一个延迟调用方法，在一个线程第1次调用get()或者set(Object)时才执行，并且仅执行1次。ThreadLocal中的确实实现直接返回一个null：

protected Object initialValue() { return null; }

　　ThreadLocal是如何做到为每一个线程维护变量的副本的呢？其实实现的思路很简单，在ThreadLocal类中有一个Map，用于存储每一个线程的变量的副本。比如下面的示例实现：

public class ThreadLocal

{

private Map values = Collections.synchronizedMap(new HashMap());

public Object get()

{

Thread curThread = Thread.currentThread();

Object o = values.get(curThread);

if (o == null && !values.containsKey(curThread))

{

o = initialValue();

values.put(curThread, o);

}

return o;

}

public void set(Object newValue)

{

values.put(Thread.currentThread(), newValue);

}

public Object initialValue()

{

return null;

}

}

当然，这并不是一个工业强度的实现，但JDK中的ThreadLocal的实现总体思路也类似于此。

　　三、ThreadLocal的使用

　　如果希望线程局部变量初始化其它值，那么需要自己实现ThreadLocal的子类并重写该方法，通常使用一个内部匿名类对ThreadLocal进行子类化，比如下面的例子，SerialNum类为每一个类分配一个序号：

public class SerialNum

{

// The next serial number to be assigned

private static int nextSerialNum = 0;

private static ThreadLocal serialNum = new ThreadLocal()

{

protected synchronized Object initialValue()

{

return new Integer(nextSerialNum++);

}

};

public static int get()

{

return ((Integer) (serialNum.get())).intValue();

}

}

　　SerialNum类的使用将非常地简单，因为get()方法是static的，所以在需要获取当前线程的序号时，简单地调用：

int serial = SerialNum.get();

即可。

　　在线程是活动的并且ThreadLocal对象是可访问的时，该线程就持有一个到该线程局部变量副本的隐含引用，当该线程运行结束后，该线程拥有的所以线程局部变量的副本都将失效，并等待垃圾收集器收集。

四、ThreadLocal与其它同步机制的比较

　　ThreadLocal和其它同步机制相比有什么优势呢？ThreadLocal和其它所有的同步机制都是为了解决多线程中的对同一变量的访问冲突，在普通的同步机制中，是通过对象加锁来实现多个线程对同一变量的安全访问的。这时该变量是多个线程共享的，使用这种同步机制需要很细致地分析在什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放该对象的锁等等很多。所有这些都是因为多个线程共享了资源造成的。ThreadLocal就从另一个角度来解决多线程的并发访问，ThreadLocal会为每一个线程维护一个和该线程绑定的变量的副本，从而隔离了多个线程的数据，每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的整个变量封装进ThreadLocal，或者把该对象的特定于线程的状态封装进ThreadLocal。

　　由于ThreadLocal中可以持有任何类型的对象，所以使用ThreadLocal get当前线程的值是需要进行强制类型转换。但随着新的Java版本（1.5）将模版的引入，新的支持模版参数的ThreadLocal类将从中受益。也可以减少强制类型转换，并将一些错误检查提前到了编译期，将一定程度地简化ThreadLocal的使用。

　　五、总结

　　当然ThreadLocal并不能替代同步机制，两者面向的问题领域不同。同步机制是为了同步多个线程对相同资源的并发访问，是为了多个线程之间进行通信的有效方式；而ThreadLocal是隔离多个线程的数据共享，从根本上就不在多个线程之间共享资源（变量），这样当然不需要对多个线程进行同步了。所以，如果你需要进行多个线程之间进行通信，则使用同步机制；如果需要隔离多个线程之间的共享冲突，可以使用ThreadLocal，这将极大地简化你的程序，使程序更加易读、简洁。

class BadArithmetic {
  
    static byte addOneAndOne() {
        byte a = 1;
        byte b = 1;
        byte c = (a + b);
        return c;
    }
}

当遇到上述代码时，javac会给出如下提示：

type.java:6: possible loss of precision
found   : int
required: byte
                        byte c = (a + b);
                                    ^
1 error

为了对这种情况进行补救，必须把a + b所获得的int类型结果显式转换为byte类型。代码如下：

class GoodArithmetic {
  
    static byte addOneAndOne() {
        byte a = 1;
        byte b = 1;
        byte c = (byte)(a + b);
        return c;
    }
}

该操作能够通过javac的编译，并产生GoodArithmetic.class文件。

char ccc=98;
System.err.println( ccc);//out put is b

  没有泛型的日子

     所有的java类都源自java.lang.Object,这意味着所有的JAVA对象能转换成Object。因此，在之前的JDK的版本中，很多Collections framework的函数接受一个Object参数。所以，collections是一个能持有任何对象的多用途工具，但带来了不良的后果。
     举个简单的例子，在JDK 5.0的之前版本中，类List的函数add接受一个Object参数：

 public boolean add(java.lang.Object element)

 所以你能传递任何类型给add。这是故意这么设计的。否则，它只能传递某种特定的对象，这样就会出现各种List类型，如，StringList, EmployeeList, AddressList等。
     add通过Object传递能带来好处,现在我们考虑get函数(返回List中的一个元素).如下是JDK 5之前版本的定义：
 
public java.lang.Object get(int index) throws IndexOutOfBoundsException

 
get返回一个Object.不幸的事情从此开始了.假如你储存了两个String对象在一个List中:

List stringList1 = new ArrayList();
stringList1.add("Java 5");
stringList1.add("with generics");

当你想从stringList1取得一个元素时,你得到了一个Object.为了操作原来的类型元素,你不得不把它转换String。

String s1 = (String) stringList1.get(0);

但是,假如你曾经把一个non-String对象加入stringList1中,上面的代码会抛出一个ClassCastException.
   有了泛型,你能创建一个单一用途的List实例.比如,你能创建一个只接受String对象的List实例,另外一个实例只能接受Employee对象.这同样适用于Collections framework中的其他类型.

泛型入门

   像一个函数能接受参数一样,一个泛型类也能接受参数.这就是一个泛型类经常被称为一个parameterized type的原因.但是不像函数用()传递参数,泛型类是用<>传递参数的.声明一个泛型类和声明一个普通类没有什么区别,只不过你把泛型的变量放在<>中.
   比如,在JDK 5中,你可以这样声明一个java.util.List :  List<E> myList;E 称为type variable.意味着一个变量将被一个类型替代.替代type variable的值将被当作参数或返回类型.对于List接口来说,当一个实例被创建以后,E 将被当作一个add或别的函数的参数.E 也会使get或别的参数的返回值.下面是add和get的定义:

boolean add<E o>
E get(int index)

NOTE:一个泛型在声明或例示时允许你传递特定的type variable: E.除此之外,如果E是个类，你可以传递子类；如果E是个接口，你可以传递实现接口的类；

-----------------------------译者添加--------------------
 List<Number> numberList= new ArrayList<Number>();
   numberList.add(2.0);
   numberList.add(2);
-----------------------------译者添加--------------------

如果你传递一个String给一个List，比如：

List<String> myList;

那么mylist的add函数将接受一个String作为他的参数，而get函数将返回一个String.因为返回了一个特定的类型，所以不用类型转化了。

NOTE：根据惯例，我们使用一个唯一的大写字目表示一个type variable。为了创建一个泛型类，你需在声明时传递同样的参数列表。比如，你要想创建一个ArrayList来操作String ，你必须把String放在<>
中。如：

List<String> myList = new ArrayList<String>();

再比如，java.util.Map 是这么定义的：

public interface Map<K,V>

K用来声明map密钥(KEY)的类型而V用来表示值(VALUE)的类型。put和values是这么定义的：

V put(K key, V value)
Collection<V> values()

NOTE:一个泛型类不准直接的或间接的是java.lang.Throwable的子类。因为异常是在run time抛出的,所以它不可能预言什么类型的异常将在compile time抛出.

列表1的例子将比较List在JDK 1.4 和JDK1.5的不同

在列表1中，stringList2是个泛型类。声明List<String>告诉编译器List的实例能接受一个String对象。当然，在另外的情况中，你能新建能接受各种对象的List实例。注意，当从List实例中返回成员元素时，不需要对象转化，因为他返回的了你想要的类型，也就是String.

NOTE:泛型的类型检查(type checking)是在compile time完成的.

      最让人感兴趣的事情是，一个泛型类型是个类型并且能被当作一个type variable。比如，你想你的List储存lists of Strings,你能通过把List<String>作为他的type variable来声明List。比如：

List<List<String>> myListOfListsOfStrings;

要从myList中的第一个List重新取得String，你可以这么用：

String s = myListOfListsOfStrings.get(0).get(0);

下一个列表中的ListOfListsTest类示范了一个List（命名为listOfLists）接受一个String List作为参数。
package com.brainysoftware.jdk5.app16;

import java.util.ArrayList;

import java.util.List;

public class ListOfListsTest {

  public static void main(String[] args) {

    List<String> listOfStrings = new ArrayList<String>();

    listOfStrings.add("Hello again");

    List<List<String>> listOfLists = new ArrayList<List<String>>();

    listOfLists.add(listOfStrings);

    String s = listOfLists.get(0).get(0);

    System.out.println(s); // prints "Hello again"

  }

}

另外，一个泛型类型接受一个或多个type variable。比如，java.util.Map有两个type variables。第一个定义了密钥（key）的类型，第二个定义了值（value)的类型。下面的例子讲教我们如何使用个一个泛型Map.
package com.brainysoftware.jdk5.app16;

import java.util.HashMap;

import java.util.Map;

public class MapTest {

  public static void main(String[] args) {

    Map<String, String> map = new HashMap<String, String>();

    map.put("key1", "value1");

    map.put("key2", "value2");

    String value1 = map.get("key1");

  }

}
在这个例子中，重新得到一个key1代表的String值，我们不需要任何类型转换。

没有参数的情况下使用泛型

    既然在J2SE 5.0中收集类型已经泛型化，那么，原来的使用这些类型的代码将如何呢？很幸运，他们在JAVA 5中将继续工作，因为你能使用没有参数的泛型类型。比如，你能继续像原来一样使用List接口，正如下面的例子一样。

List stringList1 = new ArrayList();
stringList1.add("Java 1.0 - 5.0");
stringList1.add("without generics");
String s1 = (String) stringList1.get(0);

一个没有任何参数的泛型类型被称为raw type。它意味着这些为JDK1.4或更早的版本而写的代码将继续在java 5中工作。

尽管如此，一个需要注意的事情是，JDK５编译器希望你使用带参数的泛型类型。否则，编译器将提示警告，因为他认为你可能忘了定义type variables。比如，编译上面的代码的时候你会看到下面这些警告，因为第一个List被认为是 raw type。

Note: com/brainysoftware/jdk5/app16/GenericListTest.java
        uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

当你使用raw type时，如果你不想看到这些警告，你有几个选择来达到目的：

1.编译时带上参数-source 1.4
2.使用@SupressWarnings("unchecked")注释
3.更新你的代码，使用List<Object>. List<Object>的实例能接受任何类型的对象，就像是一个raw type List。然而，编译器不会发脾气。

使用 ？ 通配符

   前面提过，如果你声明了一个List<aType>, 那么这个List对aType起作用，所以你能储存下面这些类型的对象：
1.一个aType的实例
2.它的子类的实例(如果aType是个类)
3.实现aType接口的类实例(如果aType是个接口)

但是，请注意，一个泛型本身是个JAVA类型，就像java.lang.String或java.io.File一样。传递不同的type variable给泛型可以创建不同的JAVA类型。比如，下面例子中list1和list2引用了不同的类型对象。

List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();

list1指向了一个type variables为java.lang.Objects 的List而list2指向了一个type variables为String 的List。所以传递一个List<String>给一个参数为List<Object>的函数将导致compile time错误。下面列表可以说明：

package com.brainysoftware.jdk5.app16;
import java.util.ArrayList;
import java.util.List;
 
public class AllowedTypeTest {
  public static void doIt(List<Object> l) {
  }
  public static void main(String[] args) {
    List<String> myList = new ArrayList<String>();
    // 这里将产生一个错误
    doIt(myList);
  }
}
上面的代码无法编译，因为你试图传递一个错误的类型给函数doIt。doIt的参数是List<Object>二你传递的参数是List<String>。

可以使用 ？ 通配符解决这个难题。List<?> 意味着一个对任何对象起作用的List。所以，doIt可以改为：
 
public static void doIt(List<?> l) {}

    在某些情况下你会考虑使用 ? 通配符。比如，你有一个printList函数，这个函数打印一个List的所有成员，你想让这个函数对任何类型的List起作用时。否则，你只能累死累活的写很多printList的重载函数。下面的列表引用了使用 ? 通配符的printList函数。

package com.brainysoftware.jdk5.app16;
import java.util.ArrayList;
import java.util.List;
 
public class WildCardTest {
 
  public static void printList(List<?> list) {
    for (Object element : list) {
      System.out.println(element);
    }
  }
  public static void main(String[] args) {
    List<String> list1 = new ArrayList<String>();
    list1.add("Hello");
    list1.add("World");
    printList(list1);
 
    List<Integer> list2 = new ArrayList<Integer>();
    list2.add(100);
    list2.add(200);
    printList(list2);
  }
}
这些代码说明了在printList函数中，List<?>表示各种类型的List对象。然而，请注意，在声明的时候使用 ? 通配符是不合法的，像这样：

List<?> myList = new ArrayList<?>(); // 不合法

如果你想创建一个接收任何类型对象的List，你可以使用Object作为type variable，就像这样：

List<Object> myList = new ArrayList<Object>();

在函数中使用界限通配符

在之前的章节中，你学会了通过传递不同的type variables来创建不同JAVA类型的泛型，但并不考虑type variables之间的继承关系。在很多情况下，你想一个函数有不同的List参数。比如，你有一个函数getAverage，他返回了一个List中成员的平均值。然而，如果你把List<Number>作为etAverage的参数，你就没法传递List<Integer> 或List<Double>参数，因为List<Number>和List<Integer> 和List<Double>不是同样的类型。你能使用raw type 或使用通配符，但这样无法在compile time进行安全类型检查，因为你能传递任何任何类型的List，比如List<String>的实例。你可以使用List<Number>作为参数，但是你就只能传递List<Number>给函数。但这样就使你的函数功能减少，因为你可能更多的时候要操作List<Integer>或List<Long>，而不是List<Number>。

J2SE5.0增加了一个规则来解决了这种约束，这个规则就是允许你定义一个上界(upper bound) type variable.在这种方式中，你能传递一个类型或它的子类。在上面getAverage函数的例子中，你能传递一个List<Number>或它的子类的实例，比如List<Integer> or List<Float>。

使用上界规则的语法这么定义的：GenericType<? extends upperBoundType>. 比如，对getAverage函数的参数，你可以这么写List<? extends Number>. 下面例子说明了如何使用这种规则。

package com.brainysoftware.jdk5.app16;
import java.util.ArrayList;
import java.util.List;
public class BoundedWildcardTest {
  public static double getAverage(List<? extends Number> numberList)
  {
    double total = 0.0;
    for (Number number : numberList)
      total += number.doubleValue();
    return total/numberList.size();
  }
 
  public static void main(String[] args) {
    List<Integer> integerList = new ArrayList<Integer>();
    integerList.add(3);
    integerList.add(30);
    integerList.add(300);
    System.out.println(getAverage(integerList)); // 111.0
    List<Double> doubleList = new ArrayList<Double>();
    doubleList.add(3.0);
    doubleList.add(33.0);
    System.out.println(getAverage(doubleList)); // 18.0
  }
}
由于有了上界规则，上面例子中的getAverage函数允许你传递一个List<Number> 或一个type variable是任何java.lang.Number子类的List。

下界规则

关键字extends定义了一个type variable的上界。通过使用super关键字，我们可以定义一个type variable的下界，尽管通用的情况不多。比如，如果一个函数的参数是List<? super Integer>，那么意味着你可以传递一个List<Integer>的实例或者任何java.lang.Integer的超类(superclass)。

创建泛型类

前面的章节主要说明了如何使使用泛型类，特别是Collections framework中的类。现在我们开始学习如何写自己的泛型类。

基本上，除了声明一些你想要使用的type variables外，一个泛型类和别的类没有什么区别。这些type variables位于类型后面的<>中。比如，下面的Point就是个泛型类。一个Point对象代表了一个系统中的点，它有横坐标和纵坐标。通过使Point泛型化，你能定义一个点实例的精确程度。比如，一个Point对象需要非常精确，你能把Double作为type variable。否则，Integer 就够了。

package com.brainysoftware.jdk5.app16;
public class Point<T> {
  T x;
  T y;
  public Point(T x, T y) {
    this.x = x;
    this.y = y;
  }
  public T getX() {
    return x;
  }
  public T getY() {
    return y;
  }
  public void setX(T x) {
    this.x = x;
  }
  public void setY(T y) {
    this.y = y;
  }
}

在这个例子中，T是Point的type variable 。T是getX和getY的返回值类型，也是setX和setY的参数类型。此外，构造函数结合两个T参数。

使用point类就像使用别的类一样。比如，下面的例子创建了两个Point对象：ponint1和point2。前者把Integer作为type variable，而后者把Double作为type variable。

Point<Integer> point1 = new Point<Integer>(4, 2);
point1.setX(7);
Point<Double> point2 = new Point<Double>(1.3, 2.6);
point2.setX(109.91);

总结

泛型使代码在compile time有了更严格的类型检查。特别是在Collections framework中，泛型有两个作用。第一，他们增加了对收集类型(collection types）在compile time的类型检查，所以收集类所能持有的类型对传递给它的参数类型起了限制作用。比如你创建了一个持有strings的java.util.List实例，那么他就将不能接受Integers或别的类型。其次，当你从一个收集中取得一个元素时，泛型消除了类型转换的必要。

泛型能够在没有type variable的情况下使用，比如，作为raw types。这些措施让Java 5之前的代码能够运行在JRE 5中。但是，对新的应用程序，你最好不要使用raw types，因为以后Java可能不支持他们。

你已经知道通过传递不同类型的type variable给泛型类可以产生不同的JAVA类型。就是说List<String>和List<Object>的类型是不同的。尽管String是java.lang.Object。但是传递一个List<String>给一个参数是List<Object>的函数会参数会产生编译错误（compile error）。函数能用 ? 通配符使其接受任何类型的参数。List<?> 意味着任何类型的对象。

最后，你已经看到了写一个泛型类和别的一般JAVA类没有什么区别。你只需要在类型名称后面的<>中声明一系列的type variables就行了。这些type variables就是返回值类型或者参数类型。根据惯例，一个
type variable用一个大写字母表示。

public class test {

 //static Logger logger = Logger.getLogger(test.class);

 private static ClassLoader getTCL() throws IllegalAccessException,
   InvocationTargetException {

  // Are we running on a JDK 1.2 or later system?
  Method method = null;
  try {
   method = Thread.class.getMethod("getContextClassLoader", null);
  } catch (NoSuchMethodException e) {
   // We are running on JDK 1.1
   return null;
  }

  return (ClassLoader) method.invoke(Thread.currentThread(), null);
 }

 static public URL getResource(String resource) {
  ClassLoader classLoader = null;
  URL url = null;

  try {
   classLoader = getTCL();
  } catch (IllegalAccessException e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  } catch (InvocationTargetException e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  }

  url = classLoader.getResource(resource);

  return url;

 }

 public static void main(String argv[]) {
  //  BasicConfigurator.configure();
  //  logger.debug("Hello world.");
  //  logger.info("What a beatiful day.");
  
  Properties props = new Properties();
  java.net.URL configURL;
  try {
   configURL = getResource("b.txt");
   props.load(configURL.openStream());
   String value = props.getProperty("a");
   System.out.print(value);
  } catch (MalformedURLException e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  } catch (IOException e1) {
   // TODO 自动生成 catch 块
   e1.printStackTrace();
  }
 }
}

in properties file,# is remark