Java基础-第二天

一、枚举

在实际编程中，往往存在着这样的“数据集”，它们的数值在程序中是稳定的，而且“数据集”中的元素是有限的。例如星期一到星期日七个数据元素组成了一周的“数据集”，春夏秋冬四个数据元素组成了四季的“数据集”。在java中如何更好的使用这些“数据集”呢？因此枚举便派上了用场，以下代码详细介绍了枚举的用法。

示例1：

package com.ljq.test;

/**
 * 枚举用法详解
 * 
 * @author jiqinlin
 * 
 */
public class TestEnum {
    /**
     * 普通枚举
     * 
     * @author jiqinlin
     *
     */
    public enum ColorEnum {
        red, green, yellow, blue;
    }
    
    /**
     * 枚举像普通的类一样可以添加属性和方法，可以为它添加静态和非静态的属性或方法
     * 
     * @author jiqinlin
     *
     */
    public enum SeasonEnum {
        //注：枚举写在最前面，否则编译出错
        spring, summer, autumn, winter;

        private final static String position = "test";

        public static SeasonEnum getSeason() {
            if ("test".equals(position))
                return spring;
            else
                return winter;
        }
    }
    
    /**
     * 性别
     * 
     * 实现带有构造器的枚举
     * 
     * @author jiqinlin
     *
     */
    public enum Gender{
        //通过括号赋值,而且必须带有一个参构造器和一个属性跟方法，否则编译出错
        //赋值必须都赋值或都不赋值，不能一部分赋值一部分不赋值；如果不赋值则不能写构造器，赋值编译也出错
        MAN("MAN"), WOMEN("WOMEN");
        
        private final String value;

        //构造器默认也只能是private, 从而保证构造函数只能在内部使用
        Gender(String value) {
            this.value = value;
        }
        
        public String getValue() {
            return value;
        }
    }
    
   /**
    * 订单状态
    * 
    * 实现带有抽象方法的枚举
    * 
    * @author jiqinlin
    *
    */
    public enum OrderState {
        /** 已取消 */
        CANCEL {public String getName(){return "已取消";}},
        /** 待审核 */
        WAITCONFIRM {public String getName(){return "待审核";}},
        /** 等待付款 */
        WAITPAYMENT {public String getName(){return "等待付款";}},
        /** 正在配货 */
        ADMEASUREPRODUCT {public String getName(){return "正在配货";}},
        /** 等待发货 */
        WAITDELIVER {public String getName(){return "等待发货";}},
        /** 已发货 */
        DELIVERED {public String getName(){return "已发货";}},
        /** 已收货 */
        RECEIVED {public String getName(){return "已收货";}};
        
        public abstract String getName();
    }
    
    public static void main(String[] args) {
        //枚举是一种类型，用于定义变量，以限制变量的赋值；赋值时通过“枚举名.值”取得枚举中的值
        ColorEnum colorEnum = ColorEnum.blue;
        switch (colorEnum) {
        case red:
            System.out.println("color is red");
            break;
        case green:
            System.out.println("color is green");
            break;
        case yellow:
            System.out.println("color is yellow");
            break;
        case blue:
            System.out.println("color is blue");
            break;
        }
        
        //遍历枚举
        System.out.println("遍历ColorEnum枚举中的值");
        for(ColorEnum color : ColorEnum.values()){
            System.out.println(color);
        }
        
        //获取枚举的个数
        System.out.println("ColorEnum枚举中的值有"+ColorEnum.values().length+"个");
        
        //获取枚举的索引位置，默认从0开始
        System.out.println(ColorEnum.red.ordinal());//0
        System.out.println(ColorEnum.green.ordinal());//1
        System.out.println(ColorEnum.yellow.ordinal());//2
        System.out.println(ColorEnum.blue.ordinal());//3
        
        //枚举默认实现了java.lang.Comparable接口
        System.out.println(ColorEnum.red.compareTo(ColorEnum.green));//-1
        
        //--------------------------
        System.out.println("===========");
        System.err.println("季节为" + SeasonEnum.getSeason());
        
        
        //--------------
        System.out.println("===========");
        for(Gender gender : Gender.values()){
            System.out.println(gender.value);
        }
       
        //--------------
        System.out.println("===========");
        for(OrderState order : OrderState.values()){
            System.out.println(order.getName());
        }
    }
    
}

示例2：

public class TestEnum {
    /*最普通的枚举*/
    public enum ColorSelect {
        red, green, yellow, blue;    
    }

    /* 枚举也可以象一般的类一样添加方法和属性,你可以为它添加静态和非静态的属性或方法,这一切都象你在一般的类中做的那样. */
    public enum Season {
        // 枚举列表必须写在最前面，否则编译出错
        winter, spring, summer, fall;

        private final static String location = "Phoenix";        

        public static Season getBest() {
            if (location.equals("Phoenix"))
                return winter;
            else
                return summer;
        }
    }
    /*还可以有构造方法*/
    public enum Temp {
        /*通过括号赋值,而且必须有带参构造器和一属性跟方法，否则编译出错
         * 赋值必须是都赋值或都不赋值，不能一部分赋值一部分不赋值
         * 如果不赋值则不能写构造器，赋值编译也出错*/
        absoluteZero(-459), freezing(32),boiling(212), paperBurns(451);
        
        private final int value;
        public int getValue() {
            return value;
        }
        //构造器默认也只能是private, 从而保证构造函数只能在内部使用
        Temp(int value) {
            this.value = value;
        }
    }

    public static void main(String[] args) {
        /*
         * 枚举类型是一种类型，用于定义变量，以限制变量的赋值 赋值时通过"枚举名.值"来取得相关枚举中的值
         */
        ColorSelect m = ColorSelect.blue;
        switch (m) {
        /*注意:枚举重写了ToString(),说以枚举变量的值是不带前缀的
          *所以为blue而非ColorSelect.blue
          */
　　 case red:
            System.out.println("color is red");
            break;
        case green:
            System.out.println("color is green");
            break;
        case yellow:
            System.out.println("color is yellow");
            break;
        case blue:
            System.out.println("color is blue");
            break;
        }
        System.out.println("遍历ColorSelect中的值");
        /*通过values()获得枚举值的数组*/
        for (ColorSelect c : ColorSelect.values()) {
            System.out.println(c);
        }　  
　　 System.out.println("枚举ColorSelect中的值有："+ColorSelect.values().length+"个");
 　　/*ordinal()返回枚举值在枚举中的索引位置，从0开始*/
　　System.out.println(ColorSelect.red.ordinal());//0
　　System.out.println(ColorSelect.green.ordinal());//1
　　System.out.println(ColorSelect.yellow.ordinal());//2
　　System.out.println(ColorSelect.blue.ordinal());//3

　　/*枚举默认实现了java.lang.Comparable接口*/ 
　　System.out.println(ColorSelect.red.compareTo(ColorSelect.green));

　　System.out.println(Season.getBest());
        
        for(Temp t:Temp.values()){
            /*通过getValue()取得相关枚举的值*/
            System.out.println(t+"的值是"+t.getValue());
        }

    }
}

二、反射技术

什么是反射？反射就是将字节码中的各种成分映射到相应的java类中来,java反射技术自JDK1.1以来就出现了，目前大多数流行的框架都采用了这种技术，可见其重要性，这篇文章将详细介绍我对java反射技术的一些研究.

代表字节码对象的Class

java中所有的类都有自己特有的一份字节码，当程序调用该类时，JVM便会将这份字节码装载到内存中来。在java中主要有三种方法来得到相应的字节码对象。

通过类的实例的getClass()方法获取,如 Class clazz=new Date().getClass()得到了Date类的字节码对象。
通过类的class属性获取。如Class clazz=String.class或者Class clazz=System.class.值得注意的是，java中八个主类型（byte,char,short,int,long,float,double,boolean）和一个返回类型void都有class属性，并且都返回自己的字节码对象。如int.class,boolean.class,float.class等。其中他们的包装类的TYPE属性也分别返回它们主类型的那份字节码，如int.class==Integer.TYPE为true,void.class==Void.TYPE为true;
通过Class类的forName()方法获取，如Class clazz=Class.forName("java.lang.Math");

java中可以通过Class类的isPrimitive()方法判断当前的字节码是否为主类型，isEnum()判断字节码是否为枚举类。isArray()判断字节码是否为数组类型。某个类和它所组成的数组分别持有的字节码也不相同，例如int.class==int[].class这种写法在编译期就会被编译器阻止，因为编译器发现两边参与比较的对象不在一个继承树分支上。只有相同类型和相同维度的数组才会共用一个字节码对象，如int
a1[]=new int[1], a2[]=new int[5];int a3[][]=new int[2][5];a1.getClass()==a2.getClass()为true,a2.getClass()==a3.getClass()为false;

代表构建器的Constructor

java中用getConstructor()和getConstructors()方法返回某一个public的构建器和所有public访问级别的构建器,而getDeclaredConstructor()和getDeclaredConstructors()返回所有构建器中的某一个构建器和所有的构建器。Constructor可以通过newInstance()方法创建一个该类的实例。如下例所示
Class clazz=String.class;
Constructor cs=clazz.getConstructor(StringBuffer.class);
String s=(String)cs.newInstance(new StringBuffer("abc"));
上面的代码相当于
String s=new String(new StringBuffer("abc"));
又如下例所示
String obj=String.class.getConstructor().newInstance();
上面的代码相当于
String obj=new String();
如果要得到所有的构建器可以按下面的方法做。
Constructor[] allCons=String.class.getDeclaredConstructors();
for(Construcotr con:allCons)
System.out.println(con.getName());
除了Constructor类中提供了newInstance()方法，Class类中也有一个类似的newInstance()方法，因为我们可以直接在得到字节码对象时便可生成该字节码的对象了。
ArrayList al=(ArrayList)ArrayList.class.newInstance();事实上得到构建器对象的那一步已经被封装在Class的newInstance()方法中。
public Object newInstance()
{
this.getConstructor().newInstance();
}

代表字段的Field

Class类中提供了getField()和getFields()得到public级别的字段中的某一个和所有public级别的字段，getDeclaredField()和getDeclaredFields()得到所有字段中的某一个和所有的字段。
如果某个字段是数组类型的，那么要对它进行反射还需要借助java.lang.reflect.Array来进行操作。有些时候得到的字段为private访问级别的，如果这个时候想要读取和设值该字段一般情况下会报运行期异常，但是java反射技术也并不是对此无能为力，运用反射可以绕过编译器的某些限制，来进行“暴力反射”。此时只需设置Field的setAccessible()为true就可以了。

package net.csdn.blog;

public class ReflectClass {
	public int data[]=new int[]{1,3,5,7,9};//数组类型的字段
	private String name="字段一";//private级别的字段
	float f=2.6f;
}

下面对ReflectClass类中的字段进行反射操作

package net.csdn.blog;

import java.lang.reflect.Array;
import java.lang.reflect.Field;

public class ReflectClassTest {

	public static void main(String[] args) {

		ReflectClass rc=new ReflectClass();
		try {
			HandleReflect(rc);
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}
	
	private static void HandleReflect(Object obj) throws IllegalArgumentException, IllegalAccessException{
		Class clazz=obj.getClass();
		Field fields[]=clazz.getDeclaredFields();
		for(Field field:fields){
			if(!field.isAccessible())
				field.setAccessible(true);
			Object fieldObj=field.get(obj);//得到字段的值
			if(field.getType().isArray()){//处理字段为数组时候的情况
				int len=Array.getLength(fieldObj);//得到数组的长度
				for(int i=0;i<len;i++){
					System.out.println(Array.get(fieldObj, i));//打印出数组中的每个元素
				}
			}else{
				if(field.getType()==float.class)
					field.set(obj, 5.2f);//设值字段的值
				Object o=field.get(obj);
				System.out.println(o);
			}
		}
	}

}

代表成员方法的Method

Class类中同样提供了getMethod(),getMethods()用来得到得到public级别的方法和所有public的方法，以及getDeclaredMethod()和getDeclaredMethods()方法用来得到任何访问级别的某一个方法和所有任何访问级别的方法.

package net.csdn.blog;

public class ReflectMethod {

	public void sayHello(){
		System.out.println("hello world");
	}
	
	public void printArray(Object obj[]){
		for(Object o:obj)
			System.out.println(o);
	}
	
	public String getReverseMsg(String msg){
		return new StringBuffer(msg).reverse().toString();
	}
}

对ReflectMethod类进行反射

package net.csdn.blog;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectMethodTest {

	public static void main(String argsp[]){
		ReflectMethod rm=new ReflectMethod();
		try {
			reflectMethod(rm);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	private static void reflectMethod(Object obj) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException{
		Class clazz=obj.getClass();
		Method method=clazz.getDeclaredMethod("sayHello",null);//得到sayHello()方法
		method.invoke(obj, null);//执行这个方法
		method=clazz.getDeclaredMethod("printArray", Object[].class);
		method.invoke(obj, (Object)new Object[]{"this is a joke","csdn blog"});//此处应该作转型，以告诉编绎器不按JDK1.4的作法解析
		method=clazz.getDeclaredMethod("getReverseMsg", String.class);
		String msg=(String)method.invoke(obj, "abcdefg");
		System.out.println(msg);
	}
}

对内部类的反射

网上的资料对于如何运用反射将内部类映射出来的资料非常之少，为此我特意花了一个多小时研究了一会儿，下面把研究的结果写到下面。
Class类本身还提供对于获取内部类字节码的方法，分别为getClasses和getDeclaredClasses()，其中getClasses()只能得到访问级别为public的内部类，而getDeclaredClasses()则能得到所有声明了的内部类。
由于内部类可以分为实例内部类，静态内部类，匿名内部类，前面提到的getClasses()和getDeclaredClasses()目前还都只能得到实例内部类和静态内部类，对于后面两种情况却无能为力，为此还需要采取一些特殊的手段才能针对匿名内部类进行反射操作。

package net.csdn.blog;

public class ReflectInnerClass {

	
	public Runnable ta=new Runnable(){
		public void run(){
			System.out.println("匿名内部类中的方法被执行了");
		}
	};

	
	private class Inner2{
		public Inner2(){
			System.out.println("Inner2类被实例化了");
		}
	}
	
	class Inner3{
		public Inner3(){
			System.out.println("Inner2类被实例化了");
		}
	}	
	public class Inner1{
		public Inner1(){
			System.out.println("Inner1类被实例化了");
		}
	}
}

下面对内部类进行反射

package net.csdn.blog;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Modifier;

public class ReflectInnerClassTest {

	public static void main(String args[]){
		ReflectInnerClass ric=new ReflectInnerClass();
		try {
			reflectInnerClass(ric);
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}

	private static void reflectInnerClass(ReflectInnerClass ric) throws InstantiationException, IllegalAccessException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException, ClassNotFoundException, NoSuchFieldException {
		Class clazz=ric.getClass();
		Class classes[]=clazz.getDeclaredClasses();
		for(Class c:classes){//对成员内部类进行反射
			int i=c.getModifiers();
			String s=Modifier.toString(i);
			if(s.contains("static"))//静态内部类的处理
				 c.getConstructor().newInstance();
			else//实例内部类的处理
                 c.getConstructor(ric.getClass()).newInstance(ric);
		}
		//由于匿名内部类没有构建器，因此无法创建实例，也无法直接访问其中的方法，但可以通过下面的方式巧秒的执行其中的方法或成员变量。
		Runnable r=(Runnable)(clazz.getField("ta").get(ric));
	    r.run();
		
	}
}

三、泛型

1.普通泛型

class Point<T>{		// 此处可以随便写标识符号，T是type的简称
	private T var ;	// var的类型由T指定，即：由外部指定
	public T getVar(){	// 返回值的类型由外部决定
		return var ;
	}
	public void setVar(T var){	// 设置的类型也由外部决定
		this.var = var ;
	}
};
public class GenericsDemo06{
	public static void main(String args[]){
		Point<String> p = new Point<String>() ;	// 里面的var类型为String类型
		p.setVar("it") ;		// 设置字符串
		System.out.println(p.getVar().length()) ;	// 取得字符串的长度
	}
};
----------------------------------------------------------
class Notepad<K,V>{		// 此处指定了两个泛型类型
	private K key ;		// 此变量的类型由外部决定
	private V value ;	// 此变量的类型由外部决定
	public K getKey(){
		return this.key ;
	}
	public V getValue(){
		return this.value ;
	}
	public void setKey(K key){
		this.key = key ;
	}
	public void setValue(V value){
		this.value = value ;
	}
};
public class GenericsDemo09{
	public static void main(String args[]){
		Notepad<String,Integer> t = null ;		// 定义两个泛型类型的对象
		t = new Notepad<String,Integer>() ;		// 里面的key为String，value为Integer
		t.setKey("汤姆") ;		// 设置第一个内容
		t.setValue(20) ;			// 设置第二个内容
		System.out.print("姓名；" + t.getKey()) ;		// 取得信息
		System.out.print("，年龄；" + t.getValue()) ;		// 取得信息

	}
};

2. 通配符

class Info<T>{
	private T var ;		// 定义泛型变量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
};
public class GenericsDemo14{
	public static void main(String args[]){
		Info<String> i = new Info<String>() ;		// 使用String为泛型类型
		i.setVar("it") ;							// 设置内容
		fun(i) ;
	}
	public static void fun(Info<?> temp){		// 可以接收任意的泛型对象
		System.out.println("内容：" + temp) ;
	}
};

3.受限泛型

class Info<T>{
	private T var ;		// 定义泛型变量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
};
public class GenericsDemo17{
	public static void main(String args[]){
		Info<Integer> i1 = new Info<Integer>() ;		// 声明Integer的泛型对象
		Info<Float> i2 = new Info<Float>() ;			// 声明Float的泛型对象
		i1.setVar(30) ;									// 设置整数，自动装箱
		i2.setVar(30.1f) ;								// 设置小数，自动装箱
		fun(i1) ;
		fun(i2) ;
	}
	public static void fun(Info<? extends Number> temp){	// 只能接收Number及其Number的子类
		System.out.print(temp + "、") ;
	}
};
----------------------------------------------------------
class Info<T>{
	private T var ;		// 定义泛型变量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
};
public class GenericsDemo21{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;		// 声明String的泛型对象
		Info<Object> i2 = new Info<Object>() ;		// 声明Object的泛型对象
		i1.setVar("hello") ;
		i2.setVar(new Object()) ;
		fun(i1) ;
		fun(i2) ;
	}
	public static void fun(Info<? super String> temp){	// 只能接收String或Object类型的泛型
		System.out.print(temp + "、") ;
	}
};

4.泛型无法向上转型

class Info<T>{
	private T var ;		// 定义泛型变量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
};
public class GenericsDemo23{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;		// 泛型类型为String
		Info<Object> i2 = null ;
		i2 = i1 ;								//这句会出错 incompatible types
	}
};

5.泛型接口

interface Info<T>{		// 在接口上定义泛型
	public T getVar() ;	// 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl<T> implements Info<T>{	// 定义泛型接口的子类
	private T var ;				// 定义属性
	public InfoImpl(T var){		// 通过构造方法设置属性内容
		this.setVar(var) ;	
	}
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
};
public class GenericsDemo24{
	public static void main(String arsg[]){
		Info<String> i = null;		// 声明接口对象
		i = new InfoImpl<String>("汤姆") ;	// 通过子类实例化对象
		System.out.println("内容：" + i.getVar()) ;
	}
};
----------------------------------------------------------
interface Info<T>{		// 在接口上定义泛型
	public T getVar() ;	// 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl implements Info<String>{	// 定义泛型接口的子类
	private String var ;				// 定义属性
	public InfoImpl(String var){		// 通过构造方法设置属性内容
		this.setVar(var) ;	
	}
	public void setVar(String var){
		this.var = var ;
	}
	public String getVar(){
		return this.var ;
	}
};
public class GenericsDemo25{
	public static void main(String arsg[]){
		Info i = null;		// 声明接口对象
		i = new InfoImpl("汤姆") ;	// 通过子类实例化对象
		System.out.println("内容：" + i.getVar()) ;
	}
};

6.泛型方法

class Demo{
	public <T> T fun(T t){			// 可以接收任意类型的数据
		return t ;					// 直接把参数返回
	}
};
public class GenericsDemo26{
	public static void main(String args[]){
		Demo d = new Demo()	;	// 实例化Demo对象
		String str = d.fun("汤姆") ; //	传递字符串
		int i = d.fun(30) ;		// 传递数字，自动装箱
		System.out.println(str) ;	// 输出内容
		System.out.println(i) ;		// 输出内容
	}
};

7.通过泛型方法返回泛型类型实例

class Info<T extends Number>{	// 指定上限，只能是数字类型
	private T var ;		// 此类型由外部决定
	public T getVar(){
		return this.var ;	
	}
	public void setVar(T var){
		this.var = var ;
	}
	public String toString(){		// 覆写Object类中的toString()方法
		return this.var.toString() ;	
	}
};
public class GenericsDemo27{
	public static void main(String args[]){
		Info<Integer> i = fun(30) ;
		System.out.println(i.getVar()) ;
	}
	public static <T extends Number> Info<T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
		Info<T> temp = new Info<T>() ;		// 根据传入的数据类型实例化Info
		temp.setVar(param) ;		// 将传递的内容设置到Info对象的var属性之中
		return temp ;	// 返回实例化对象
	}
};

8.使用泛型统一传入的参数类型

class Info<T>{	// 指定上限，只能是数字类型
	private T var ;		// 此类型由外部决定
	public T getVar(){
		return this.var ;	
	}
	public void setVar(T var){
		this.var = var ;
	}
	public String toString(){		// 覆写Object类中的toString()方法
		return this.var.toString() ;	
	}
};
public class GenericsDemo28{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;
		Info<String> i2 = new Info<String>() ;
		i1.setVar("HELLO") ;		// 设置内容
		i2.setVar("汤姆") ;		// 设置内容
		add(i1,i2) ;
	}
	public static <T> void add(Info<T> i1,Info<T> i2){
		System.out.println(i1.getVar() + " " + i2.getVar()) ;
	}
};

9.泛型数组

public class GenericsDemo30{
	public static void main(String args[]){
		Integer i[] = fun1(1,2,3,4,5,6) ;	// 返回泛型数组
		fun2(i) ;
	}
	public static <T> T[] fun1(T...arg){	// 接收可变参数
		return arg ;			// 返回泛型数组
	}
	public static <T> void fun2(T param[]){	// 输出
		System.out.print("接收泛型数组：") ;
		for(T t:param){
			System.out.print(t + "、") ;
		}
	}
};

10.泛型的嵌套设置

class Info<T,V>{		// 接收两个泛型类型
	private T var ;
	private V value ;
	public Info(T var,V value){
		this.setVar(var) ;
		this.setValue(value) ;
	}
	public void setVar(T var){
		this.var = var ;
	}
	public void setValue(V value){
		this.value = value ;
	}
	public T getVar(){
		return this.var ;
	}
	public V getValue(){
		return this.value ;
	}
};
class Demo<S>{
	private S info ;
	public Demo(S info){
		this.setInfo(info) ;
	}
	public void setInfo(S info){
		this.info = info ;
	}
	public S getInfo(){
		return this.info ;
	}
};
public class GenericsDemo31{
	public static void main(String args[]){
		Demo<Info<String,Integer>> d = null ;		// 将Info作为Demo的泛型类型
		Info<String,Integer> i = null ;	// Info指定两个泛型类型
		i = new Info<String,Integer>("汤姆",30) ;	 // 实例化Info对象
		d = new Demo<Info<String,Integer>>(i) ;	// 在Demo类中设置Info类的对象
		System.out.println("内容一：" + d.getInfo().getVar()) ;
		System.out.println("内容二：" + d.getInfo().getValue()) ;
	}
};

泛型方法不一定要通过参数来确定泛型准确类型，可以只通过返回值，比如：

public static <E> ArrayList<E> newArrayList() {

return new ArrayList<E>();

}



public List<PrepaidHistory> queryHistories(Long skyid,PrepaidHistoryType type, Date from, Date end) {

　　　　。。。

return Lists.newArrayList();

}



这样Lists.newArrayList();

智能的知道返回类型为PrepaidHistory

转1：http://www.cnblogs.com/linjiqin/archive/2011/02/11/1951632.html

转2：http://www.cnblogs.com/Fskjb/archive/2009/08/03/1537917.html

转3：http://blog.csdn.net/helloapps/article/details/5716604

转4：http://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html