JAVA高级--java泛型

类型的参数化

• 泛型类可以同时设置多个参数
• 泛型类可以继承泛型类
• 泛型类可以实现泛型接口

示例--泛型类

package com.date;

public class GenericDemo {
  public static void main(String[] args) {
	  GenClass<String> genClass=new GenClass<String>("tanlei");
	  System.out.println(genClass.getData());
	  GenClass<Integer> genClass2=new GenClass<Integer>(100);
	  System.out.println(genClass2.getData());
}
}

//创建一个泛型类
class GenClass<T>{
	private T data;

	public GenClass(T data) {
		this.data = data;
	}

	public T getData() {
		return data;
	}

	public void setData(T data) {
		this.data = data;
	}

}

• 泛型类可以同时设置多个参数

package com.date;

public class GenericDemo {
  public static void main(String[] args) {

	Genclass2<String,Integer> genclass2=new Genclass2("tanlei", 100);
	System.out.println(genclass2.getData1());
	System.out.println(genclass2.getData2());

}
}

class Genclass2<T1,T2>{
	private T1 data1;
	private T2 data2;
	public Genclass2(T1 data1, T2 data2) {
		this.data1 = data1;
		this.data2 = data2;
	}
	public T1 getData1() {
		return data1;
	}
	public void setData1(T1 data1) {
		this.data1 = data1;
	}
	public T2 getData2() {
		return data2;
	}
	public void setData2(T2 data2) {
		this.data2 = data2;
	}

}

• 泛型类可以继承泛型类

package com.date;

public class Grneric {
  public static void main(String[] args) {
	subClass<String,Integer> subClass=new subClass("xiaotan", 22);
	System.out.println(subClass.Show1());
	subClass.show2(22);
}
}

interface Iinfo<T2>{
	public  void show2(T2 var2) ;
}

class superClass<T1>{
	private T1 var1;

	public superClass(T1 var1) {
		this.var1 = var1;
	}

	public T1 Show1() {
		return var1;
	}
}

class subClass<T1,T2> extends superClass<T1> implements Iinfo<T2>{
	private T2 var2;
	public subClass(T1 var1,T2 var2) {
		super(var1);
		this.var2=var2;
	}

	public T1 Show1() {
		return super.Show1();

	}

	public  void show2(T2 var3) {
		System.out.println(var3);
		System.out.println(var2);
	}

}

　　

　限制泛型可用类型

　　可以在定义类型时,使用extends关键字指定这个类型必须继承某个类,或者实现某个接口　

package com.date;

public class Extends_InterfaceDemo {
   public static void main(String[] args) {
	GenericClass<Dog> dogclass=new GenericClass<Dog>();
	dogclass.setObj(new Dog());
	dogclass.getObj().eat();
	GenericClass<Cat> catclass=new GenericClass<Cat>();
	catclass.setObj(new Cat());
	catclass.getObj().eat();

}
}

//只能接受Animal类型或者Animal类的子类类型
class GenericClass<T extends Animal>{
	private T obj;

	public T getObj() {
		return obj;
	}

	public void setObj(T obj) {
		this.obj = obj;
	}

}

abstract class Animal{
	public abstract void eat();
}

class  Dog extends Animal{

	@Override
	public void eat() {
		System.out.println("狗啃骨头");

	}

}

class  Cat extends Animal{

	@Override
	public void eat() {
		System.out.println("猫吃鱼");

	}

}

类型通配声明

泛型通配的方式

"?"代表任意一个类型

　

泛型方法

访问修饰符 <泛型列表> 返回类型 方法名(参数列表){
               实现代码
}　　

什么时候用到泛型方法,而不是泛型类呢?

添加类型约束只作用于一个方法的多个参数之间,而不涉及到类中的其他方法

public class Extends_InterfaceDemo {
   public static void main(String[] args) {
	 GenericClass gen=new  GenericClass();
	 gen.println("ABC");
	 gen.println(true);
	 gen.println(10);
	 gen.println(10.8);
	 gen.println(new Dog());
	 GenericClass.print("haha");
}
}

class GenericClass{
  //泛型方法
  public<T> void  println(T content) {
	  System.out.println(content);
  }
  //泛型方法的重载
  public<T extends Animal> void  println(T animal) {
	  animal.eat();
  }

  public static  <T> void  print(T content) {
	  System.out.println(content);
  }
}

　

案例讲解

自定义一个存放指定数据的容器

　

package com.day1;

import java.util.Arrays;

public class ArrayListDemo {
     public static void main(String[] args) {
        IContainer<String> list=new Container<String>();
        for (int i = 0; i < 12; i++) {
            list.add("data:"+(i+1));
        }

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

interface IContainer<T>{
    public void  add(T obj);//给容器添加数据
    public T get(int index);//根据下标 获取指定位置的元素内容
    public int size();//返回容器中元素的个数

}

class Container<T> implements IContainer<T>{
    // private T[] data=new T[10];//错误,不能参加泛型数组,无法知道数据类型
    private  Object [] data=null;
    private int size=0;//记录容器元素的个数
    public Container() {
        data=new Object[10];//初始大小为10
    }
    public Container(int capacity) {
        data=new Object[capacity];//
    }

    @Override
    public void add(T obj) {
        //判断元素的个数是否超过容器的大小,超过了对容器进行扩容
        ensureCapacity(size+1);
        data[size++]=obj;//添加元素

    }

    private void ensureCapacity(int i) {
        if(i>data.length) {
            int oldi=data.length;
            int newi=oldi+(oldi>>1);//扩容为原有容量的1.5倍
            data=Arrays.copyOf(data, newi);//将原有数组中的数据拷贝到新创建的数组中
        }

    }
    @Override
    public T get(int index) {

        return (T)data[index];
    }

    @Override
    public int size() {

        return size;
    }

}

　@SuppressWarnings("unchecked")   去掉黄色警告