黑马程序员_基础加强之泛型

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

  泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中非法输入，编译器编译带类型说明的集合时会去除“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法。

  //定义一个GenericTest类

public class GenericTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		/*
		*因为ArrayList不带类型参数，所以它可以添加任意类型的数据。
		*/
		ArrayList collection1 = new ArrayList();
		collection1.add(1);
		collection1.add(1L);
		collection1.add("abc");
		//通过get(index)获得的元素，其类型是Object,可以强转，获得真实类型
		//int i = (Integer)collection1.get(1);
		
		//加了类型参数
		ArrayList<String> collection2 = new ArrayList<String>();
		//元素的类型不能是String以外
		//collection2.add(1);
		//collection2.add(1L);
		collection2.add("abc");
		//取元素时，不需要强转，就可以得到元素的实际类型
		String element = collection2.get(0);	
		
		//new String(new StringBuffer("abc"));
		//通过反射方式，获得String(StringBuffer)的Constructor对象
		Constructor<String> constructor1 = String.class.getConstructor(StringBuffer.class);
		//相当于String str2 = new String(new StringBuffer("abc"))
		//建立一个String对象
		String str2 = constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
		System.out.println(str2.charAt(2));		
		
		ArrayList<Integer> collection3 = new ArrayList<Integer>();
		//getClass()返回集合的运行时类
		System.out.println(collection3.getClass() == collection2.getClass());
		//collection3.add("abc");
		//调用add方法
		collection3.getClass().getMethod("add", Object.class).invoke(collection3, "abc");
		System.out.println(collection3.get(0));
		
		printCollection(collection3);
		
		//Class<Number> x = String.class.asSubclass(Number.class);
		//使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。
		Class<?> y;
		Class<String> x ;//Class.forName("java.lang.String");
		
		HashMap<String,Integer> maps = new HashMap<String, Integer>();
		maps.put("zxx", 28);
		maps.put("lhm", 35);
		maps.put("flx", 33);
		
		Set<Map.Entry<String,Integer>> entrySet = maps.entrySet();
		for(Map.Entry<String, Integer> entry : entrySet){
			System.out.println(entry.getKey() + ":" + entry.getValue());
		}
		
		add(3,5);
		Number x1 = add(3.5,3);
		Object x2 = add(3,"abc");
		
		GenericDao<ReflectPoint> dao = new GenericDao<ReflectPoint>();
		dao.add(new ReflectPoint(3,3));		;
		
		ParameterizedType pType = (ParameterizedType)types[0];
		System.out.println(pType.getRawType());
		System.out.println(pType.getActualTypeArguments()[0]);
	}
	
	//一个通用的方法，它可以适应各种类型
	private static <T> T add(T x,T y){
		return null;
	}
	
	public static void printCollection(Collection<?> collection){
		//collection.add(1);
		System.out.println(collection.size());
		for(Object obj : collection){
			System.out.println(obj);
		}
	}
	
	public static <T> void printCollection2(Collection<T> collection){
		//collection.add(1);
		System.out.println(collection.size());
		for(Object obj : collection){
			System.out.println(obj);
		}

	}
	
	
	public static <T> void copy1(Collection<T> dest,T[] src){
		
	}
	
	public static <T> void copy2(T[] dest,T[] src){
		
	}
}

  定义一个GenericDao类

//dao data access object--->crud
/*
*DAO调用数据库，数据库返回数据给DAO，并封装成VO（值对象，与表对应）
*/
public class GenericDao<E>  {//E是类型参数
	public void add(E x){
		
	}
	
	public E findById(int id){
		return null;
	}
	
	public void delete(E obj){
		
	}
	
	public void delete(int id){
		
	}	
	
	public void update(E obj){
		
	}
	
	public static <E> void update2(E obj){
		
	}
	
	public E findByUserName(String name){
		return null;
	}
	public Set<E> findByConditions(String where){
		return null;
	}
}

  

  泛型的好处

  java语言中引入泛型是一个较大的功能增强。这带来了很多好处：

  类型安全。 泛型的主要目标是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制，编译器可以在一个高得多的程度上验证类型假设。没有泛型，这些假设就只存在于程序员头脑中（或者如果幸运的话，还存在于代码注释中）。

  java程序中的一种流行技术是定义这样的集合，即它的元素或键是公共类型的，比如“String 列表”或者“String 到 String 的映射”。通过在变量声明中捕获这一附加的类型信息，泛型允许编译器实施这些附加的类型约束。类型错误现在就可在编译时被捕获了。在编译时进行类型检查可以使我们更容易找到错误，并可提高程序的可靠性。

  消除强制类型转换，使代码可读性更强。