java 高级泛型_JAVA高级--java泛型

类型的参数化

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

泛型类可以继承泛型类

泛型类可以实现泛型接口

示例--泛型类

package com.date;

public class GenericDemo {

public static void main(String[] args) {

GenClass genClass=new GenClass("tanlei");

System.out.println(genClass.getData());

GenClass genClass2=new GenClass(100);

System.out.println(genClass2.getData());

}

}

//创建一个泛型类

class GenClass{

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 genclass2=new Genclass2("tanlei", 100);

System.out.println(genclass2.getData1());

System.out.println(genclass2.getData2());

}

}

class Genclass2{

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 subClass=new subClass("xiaotan", 22);

System.out.println(subClass.Show1());

subClass.show2(22);

}

}

interface Iinfo{

public void show2(T2 var2) ;

}

class superClass{

private T1 var1;

public superClass(T1 var1) {

this.var1 = var1;

}

public T1 Show1() {

return var1;

}

}

class subClass extends superClass implements Iinfo{

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 dogclass=new GenericClass();

dogclass.setObj(new Dog());

dogclass.getObj().eat();

GenericClass catclass=new GenericClass();

catclass.setObj(new Cat());

catclass.getObj().eat();

}

}

//只能接受Animal类型或者Animal类的子类类型

class GenericClass{

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 void println(T content) {

System.out.println(content);

}

//泛型方法的重载

public void println(T animal) {

animal.eat();

}

public static void print(T content) {

System.out.println(content);

}

}

案例讲解

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

packagecom.day1;importjava.util.Arrays;public classArrayListDemo {public static voidmain(String[] args) {

IContainer list=new Container();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{public void add(T obj);//给容器添加数据

public T get(int index);//根据下标 获取指定位置的元素内容

public int size();//返回容器中元素的个数

}class Container implements IContainer{//private T[] data=new T[10];//错误,不能参加泛型数组,无法知道数据类型

private Object [] data=null;private int size=0;//记录容器元素的个数

publicContainer() {

data=new Object[10];//初始大小为10

}public Container(intcapacity) {

data=new Object[capacity];//}

@Overridepublic voidadd(T obj) {//判断元素的个数是否超过容器的大小,超过了对容器进行扩容

ensureCapacity(size+1);

data[size++]=obj;//添加元素

}private void ensureCapacity(inti) {if(i>data.length) {int oldi=data.length;int newi=oldi+(oldi>>1);//扩容为原有容量的1.5倍

data=Arrays.copyOf(data, newi);//将原有数组中的数据拷贝到新创建的数组中

}

}

@Overridepublic T get(intindex) {return(T)data[index];

}

@Overridepublic intsize() {returnsize;

}

}

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