java泛型（泛型接口、泛型类、泛型方法）

最新推荐文章于 2024-11-03 11:01:20 发布

LiniLLLLL.

最新推荐文章于 2024-11-03 11:01:20 发布

阅读量221

点赞数

分类专栏： Java 文章标签：反射 java

原文链接：https://www.cnblogs.com/JokerShi/p/8117556.html

版权

Java 专栏收录该内容

10 篇文章 2 订阅

订阅专栏

java泛型（泛型接口、泛型类、泛型方法）

泛型接口：

定义一个泛型接口：

//定义一个泛型接口
public interface Generator<T> {
	public T text();
}

通过类去实现这个泛型接口的时候指定泛型T的具体类型。

指定具体类型为Integer：

// 指定具体类型为Integer
public class NumGenerator implements Generator<Integer>{
	
	int[] ages = {18,19,20};
	
	@Override
	public Integer text() {
		Random rand = new Random();
		//nextInt(3):生成[0,3]区间的整数
		return ages[rand.nextInt(3)];
	}
	
	public static void main(String[] args) {
		NumGenerator age = new NumGenerator();
		
		System.out.println(age.text());
	}
}

指定具体类型为String:

// 指定具体类型为String
public class ManGenerator implements Generator<String>{
	
	String[] names = {"ryan","anni","john"};
	
	@Override
	public String text() {
		Random rand = new Random();
		//nextInt(3):生成[0,3]区间的整数
		return names[rand.nextInt(3)];
	}
	
	public static void main(String[] args) {
		ManGenerator manName = new ManGenerator();
		
		System.out.println(manName.text());
	}
}

指定具体类型为一个自定义的对象：

Man类:

public class Man {
	private String name;
	private int age;
	private String sex;
	private Double weight;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public Double getWeight() {
		return weight;
	}
	public void setWeight(Double weight) {
		this.weight = weight;
	}
}

// 指定具体类型为一个自定义的对象
public class NewManGenerator implements Generator<Man>{
	
	public static void main(String[] args) {
		NewManGenerator man = new NewManGenerator();
		System.out.println(man.text().toString());
	}
	
	@Override
	public Man text() {
		Man man = new Man();
		
		man.setName("lwm");
		man.setAge(21);
		man.setSex("M");
		man.setWeight(53.53);
		
		return man;
	}
	
}

泛型类：

在编译器，是无法知道K和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。

/*
 *  泛型类：
 *  在编译器，是无法知道K和V具体是什么类型，只有在运行时才会真正根据类型来构造和分配内存。
 */
public class Container<K,V> {
	private K key;
	private V value;
	
	public Container(K k,V v) {
		key = k;
		value = v;
	}
	
	public K getKey() {
		return key;
	}

	public void setKey(K key) {
		this.key = key;
	}

	public V getValue() {
		return value;
	}

	public void setValue(V value) {
		this.value = value;
	}

	public static void main(String[] args) {
		Container<String, String> c = new Container<String, String>("name", "lwm");
		
		System.out.println(c.getKey()+":"+c.getValue());
	}
}

泛型方法：

引用其他人写的，觉得不错：

定义泛型方法时，必须在返回值前边加一个，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

Class的作用就是指明泛型的具体类型，而Class类型的变量c，可以用来创建泛型类的对象。

为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

泛型方法要求的参数是Class类型，而Class.forName()方法的返回值也是Class，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class类型的对象，因此调用泛型方法时，变量c的类型就是Class，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。

当然，泛型方法不是仅仅可以有一个参数Class，可以根据需要添加其他参数。

为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

/*
 * 泛型方法：
 * 引用其他人写的，觉得不错：
 * 定义泛型方法时，必须在返回值前边加一个<T>，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。
 * Class<T>的作用就是指明泛型的具体类型，而Class<T>类型的变量c，可以用来创建泛型类的对象。
 * 为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，
 * 因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。
 * 泛型方法要求的参数是Class<T>类型，而Class.forName()方法的返回值也是Class<T>，因此可以用Class.forName()作为参数。
 * 其中，forName()方法中的参数是何种类型，返回的Class<T>就是何种类型。在本例中，forName()方法中传入的是Man类的完整路径，
 * 因此返回的是Class<Man>类型的对象，因此调用泛型方法时，变量c的类型就是Class<Man>，
 * 因此泛型方法中的泛型T就被指明为Man，因此变量obj的类型为Man。
 * 当然，泛型方法不是仅仅可以有一个参数Class<T>，可以根据需要添加其他参数。
 * 为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；
 * 而泛型方法可以在调用的时候指明类型，更加灵活。
 */
public class Generic {
	public <T> T getObject(Class<T> c) throws InstantiationException,IllegalAccessException{
		// 创建泛型对象
		T t = c.newInstance();
		return t;
	}
	
	public static void main(String[] args) throws InstantiationException,IllegalAccessException{
		Generic gene = new Generic();
		Object obj = gene.getObject(Man.class);
		System.out.println(obj);
		
		Object objj;
		try {
			objj = gene.getObject(Class.forName("com.lwm.genericitydemo.Man"));
			System.out.println(objj);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		
	}
}