java--泛型

泛型

  泛型可以说是一种虚拟类型，它不明确是那种类型，任意类型都可以替代它，当我们不确定类型时，可以用到它，而且要注意的是这个类型是引用数据类型。

泛型类

  泛型类也就是把泛型运用在类上,当然泛型类里面的方法和变量也可以写上具体的类型，但是这个确定好类型的变量是不能赋给不确定类型的变量的，不确定返回值类型的方法也不能返回确定类型的值。

格式:		public class 类名<数据类型 , ....> {}
	如：
	//这里的T可以是任意字母
		public class ObjectTools<T> {
			
			private T t ;//泛型变量的格式

			public T get() {
				return t;
			}

			public void set(T t) {
				this.t = t;
			}
		}

泛型方法

  泛型方法也就是把泛型用上的方法。

格式：

      //无返回值，且有参数，定义的格式
		修饰符 <E> void 方法名(E e){
				方法体;
			}
			
	 //无返回值，且无参数，定义的格式
		修饰符 <E> void 方法名(){
				方法体;
			}		
			
	//有返回值定义的格式
		修饰符 <E> 方法名(E e){
				方法体;
			}	
			
	//有返回值，且无参数，定义的格式
		修饰符 <E> 方法名(){
				方法体;
			}	

泛型接口

  泛型接口就是在接口处用上泛型。

定义格式:		public interface 接口名<泛型类型>{}
		如：
			public interface SShow<T> {
	
					public abstract void show(T t) ;

			}

  泛型接口的子类有两种情况，一种是在实现接口时发现不知道要定义什么类型，这时候也把这个子类写为泛型类，第二种情况是直接定义类型。

情况一

public class Text implements SShow<T> {
			@Override
			public void show(T t) {
						System.out.println(t);
			}
}

情况二

public class InterImpl implements SShow<String> {
			@Override
			public void show(String t) {
						System.out.println(t);
			}
}

泛型通配符

通配符
<?>	任意类型，如果没有明确，那么就是Object以及任意的Java类了
<? extends E>	向下限定，E及其子类，也就是说明确的类型只能是E及其子类
<? super E>	向上限定，E及其父类，也就是说明确的类型只能是E及其父类

		//泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致，也可以省略右边只写左边
		Collection<Object> col1 = new ArrayList<Object>() ;
		Collection<Object> col2 = new ArrayList<Animal>() ;//报错

		// ? 表示任意的数据类型
		Collection<?> col5 = new ArrayList<Object>() ;
		Collection<?> col6 = new ArrayList<Animal>() ;

		// <? extends E >：向下限定	, ? 表示的是E或者E的子类
//		Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
		Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
		Collection<? extends Animal> col11 = new ArrayList<Dog>() ;

		// <? super E>：向上限定 , ? 表示的是E或者E的父类
		Collection<? super Animal> col13 = new ArrayList<Object>() ;
		Collection<? super Animal> col14 = new ArrayList<Animal>() ;
//		Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错

代码演示

1、定义一个泛型类，输出不同类型的数据
泛型类

//调用一个泛型类
public class Show<T> {
//定义一个泛型方法
    public void show(T t){
        System.out.println(t);
    }
    //也可以定义不是泛型的方法
    public void show1(){
        System.out.println("我不是泛型方法");
    }
}

测试类

public class Text {
    public static void main(String[] args) {
    
   		 //把泛型明确为String类型，当两边都是同一类型时可以只写左边
        Show<String> stringShow = new Show<>();
        stringShow.show("你好呀");
        stringShow.show1();
        
        //把泛型明确为Integer类型，这个是int类型的封装类，是引用数据类型
        Show<Integer> integerShow = new Show<>();
        integerShow.show(100);
        integerShow.show1();
        
        //把泛型明确为Double类型，这个是double类型的封装类，是引用数据类型
        Show<Double> doubleShow = new Show<>();
        doubleShow.show(3.14);
        doubleShow.show1();
    }
}

结果

你好呀
我不是泛型方法
100
我不是泛型方法
3.14
我不是泛型方法

2、泛型接口的演示

泛型接口

//泛型接口，定义两个不明确的类型，你也可以写一个，写多少个都行，
//不过明确类型时，你要全都明确
public interface SShow<T,E> {
    public abstract void show(T t) ;
    public abstract void show1(E t) ;
}

子类

//明确接口的类型，有几个泛型类型，明确几个类型
public class Show implements SShow<String,Integer>{

//重写接口泛型方法，里面的返回值也要跟接口类型一致
    @Override
    public void show(String s) {
        System.out.println(s);
        
    //重写接口泛型方法，里面的返回值也要跟接口类型一致，而且不能少写你明确的类型
    //定义了就要用否则会报错
     @Override
    public void show1(Integer t) {
        System.out.println(t);
    }   
    }
}

测试类

public class Text {
    public static void main(String[] args) {
    
    	//不需要写明确的类型了，子类中已经明确好了，写了会报错
        Show show = new Show();
        
        //只能输入String类型，不然会报错
        show.show("你好呀");
                
    }
}

结果

你好呀
100