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);
  }
}

猜你喜欢