Java学习笔记18（一文带你了解泛型）

复习一下

Java学习笔记05（渐悟出对象）

Java学习笔记16（集合！HashSet, ArrayList, HashMap）
Java学习笔记10（零压力理解继承多态权限修饰符）

泛型

List list = new ArrayList();
这里就是泛型，指明list 是字符串类型的，不能为其他类型的。

		List<String> list = new ArrayList<String>();
		list.add("v");

		list.add("v2");
		list.add("v");//列表可重复
		list.add("b");
		list.add("a");

为什么要有泛型？

Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

Java中的泛型，只在编译阶段有效。

在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

泛型类

class Cc<E>{
	
	private E e;//带有泛型的类，泛型为E
}

泛型接口

interface IB<T>{
	T test (T t);
	
}

/**
 * 泛型继承接口
 * @author jkjkjk
 *
 * @param <T>
 */
class B1<T> implements IB<T>{
	@Override
	public T test(T t) {
		// TODO Auto-generated method stub
		return t;
	}
}

/**
 * 传入了实参，泛型具体了，那么这个类实现接口，类里面的数据类型和泛型一样
 * @author jkjkjk
 *
 */
class B2 implements IB<String>{
	@Override
	public String test(String t) {
		// TODO Auto-generated method stub
		return null;
	}
}

上面两种的区别是：
B1实例化时候要加
B2实例化时候不要加

public class Test2 {
	public static void main(String[] args) {
		B1<Object> b1 = new B1<Object>();//要写泛型
		B2 b2 = new B2();//不要写泛型
	}

}

泛型方法

改成泛型，在public后面加，然后把数据类型的地方改为这个T.

无返回值的方法

class Cc{
	
	//无返回值的方法，定义泛型
	public void test(String t) {
		String a = " "; //t是变量
	}

	
	public<T> void test(T t1) {
		T t = t1;//无参时候的泛型，t是变量
	}
}

有返回值的方法

//有返回值的方法，定义泛型
	public String test1(String s) {
		return s;
	}
	
	//有返回值的方法，定义泛型
	public<T> T test1(T s) {
		return s;
	}	

可变参数的方法

//可变参数的方法
	public void test2(String... strs) {
		for(String str: strs) {
			System.out.println(str);
		}
	}
	
	//可变参数的方法，改成泛型，在public·后面加<T>，然后把数据类型的地方改为这个T,
	public<T> void test2(T... strs) {
		for(T str: strs) {
			System.out.println(str);
		}
	}

在类上定义的泛型，可以在普通方法中调用。
在静态的方法中（static）不可以在普通方法中调用。

class Cc<E>{
	
	private E e;//带有泛型的类
	
	//无返回值的方法，定义泛型
	public void test(String t) {
		String a = " "; //t是变量
		System.out.println(this.e);
	}
}

学霸笔记：
泛型方法在调用之前没有固定类型
调用时，传入什么类型就会把泛型改为什么类型

public class Test2 {
	public static void main(String[] args) {
		Cc<Object> c1 = new Cc<Object>();
		c1.test1(11);
		c1.test1( "xxx");
		c1.test1(0.0001);
	}
}

以上内容全部代码：

public class Test2 {
	public static void main(String[] args) {
		B1<Object> b1 = new B1<Object>();//要写泛型
		B2 b2 = new B2();//不要写泛型
		
		Cc<Object> c1 = new Cc<Object>();
		c1.test1(11);
		c1.test1( "xxx");
		c1.test(0.0001);
		
		
	}

}

interface IB<T>{
	T test (T t);
	
}

/**
 * 泛型继承接口
 * @author jkjkjk
 *
 * @param <T>
 */
class B1<T> implements IB<T>{
	@Override
	public T test(T t) {
		// TODO Auto-generated method stub
		return t;
	}
}

/**
 * 传入了实参，泛型具体了，那么这个类实现接口，类里面的数据类型和泛型一样
 * @author jkjkjk
 *
 */
class B2 implements IB<String>{
	@Override
	public String test(String t) {
		// TODO Auto-generated method stub
		return null;
	}
}


class Cc<E>{
	
	private E e;//带有泛型的类
	
	public static void test() {
//		System.out.println(this.e);
	}
	
	//无返回值的方法，定义泛型
//	public void test(String t) {
//		String a = " "; //t是变量
//		System.out.println(this.e);
//	}

	
	public<T> void test(T t1) {
		T t = t1;//无参时候的泛型，t是变量
	}
	
	//有返回值的方法，定义泛型
//	public String test1(String s) {
//		return s;
//	}
	
	//有返回值的方法，定义泛型
	public<T> T test1(T s) {
		return s;
	}	
	
	//可变参数的方法
//	public void test2(String... strs) {
//		for(String str: strs) {
//			System.out.println(str);
//		}
//	}
	
	//可变参数的方法，改成泛型，在public·后面加<T>，然后把数据类型的地方改为这个T,
	public<T> void test2(T... strs) {
		for(T str: strs) {
			System.out.println(str);
		}
	}
	
	
}

泛型通配符

/**

• 不确定集合中的元素具体的数据类型
• 使用?表示所有类型
• @param list
  */
  public void test(List<?> list){
  System.out.println(list);
  }

1. <? extends Person> (无穷小 , Person]

只允许泛型为Person及Person子类的引用调用

2. <? super Person > [Person , 无穷大)

只允许泛型为Person及Person父类的引用调用

3. <? extends Comparable>

只允许泛型为实现Comparable接口的实现类的引用调用

每天进步一点点！