package com.mycompany.mavenproject1;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author sunnymoon
* 2010-10-16 16:07:40
*
* 泛型使用:包括�上界和下界通配符;无界通配符;泛型类;泛型方法;泛型类的具体化�
*/
public class TestGeneral {
public static void main(String[] args) {
TestGeneral.test1();
System.out.println("test1");
TestGeneral.test2();
System.out.println("test2");
TestGeneral.test3();
System.out.println("test3");
TestGeneral.test4();
System.out.println("test4");
TestGeneral.test5();
System.out.println("test5");
TestGeneral.test6();
System.out.println("test6");
}
/**
* 集合风格(Collection-like)的泛型函数
*/
public static void test1() {
Pair<Integer, Boolean> pair1 = new Pair<Integer, Boolean>(123, true);
System.out.println(pair1.first + "|" + pair1.second);
Pair<Integer, Long> pair2 = new Pair<Integer, Long>(123, 123l);
System.out.println(pair2.first + "|" + pair2.second);
}
/**
* 集合之外风格的泛型函数
*/
public static void test2() {
DBFactory facotry = new PairDBFactory();
System.out.println(facotry.createPair().first + "|" + facotry.createPair().second);
}
/**
* 上界和下界通配符
* A
* ?
* ?
* A
*/
public static void test3() {
/**
* 用面向对象继承的去思考上界只可读,下界只可写更容易
* 不可指的是不安全,会在编译,运行时报异常
*/
final ArrayList<Integer> list = new ArrayList<Integer>(1);
list.add(100);
final List<? extends Number> readList = list;
// readList.add(new Integer(2));//不保证可写
Number n = readList.get(0);
System.out.println(n);
List<? super Number> writeList = new ArrayList<Object>();
writeList.add(new Integer(5));
// System.out.println(writeList.get(0));//不保证可读
}
/**
* 通配符
* 无界通配符
*/
public static void test4() {
List<?> list = new ArrayList<Integer>();
list = new ArrayList<Object>();
}
/**
* 关于泛型方法
*/
public static void test5() {
PairMethod<Integer> pairMethod = new PairMethod<Integer>();
pairMethod.pair(new ArrayList<Long>(1));
pairMethod.pair2(3);
pairMethod.pair2_1(4);
pairMethod.pair3(4);
PairMethod.pair4(123123l);
PairMethod.pair4_1(pairMethod);
}
/**
* 关于泛型具体化
* 您可能想要构造一个数组T[], new T[]是不允许的
* 解决方案使用的是“类型令牌”
*/
public static void test6() {
ArrayExample<Double> example = new ArrayExample<Double>(Double.class);
Double[] doubles = example.getArray(10);
System.out.println(doubles.length);
}
}
/**
* 以下是测试时创建的类
*/
final class Pair<A, B> {
public final A first;
public final B second;
public Pair(A first, B second) {
this.first = first;
this.second = second;
}
}
abstract class DBFactory<T extends Pair> {
protected abstract T createPair();
public List<T> get(String constraint) {
List<T> pairs = new ArrayList<T>();
return pairs;
}
}
final class PairDBFactory extends DBFactory {
@Override
protected Pair createPair() {
return new Pair<Integer, Boolean>(123, false);
}
}
final class PairMethod<R> {
/**
* 开始的<T>为所埯的类型型
* @param <T>
* @param list
* @return
*/
public <T> List<T> pair(List<T> list) {
return list;
}
/**
* 同上
* @param <T>
* @param obj
* @return
*/
public <T> List<T> pair2(T obj) {
return null;
}
public <T> T pair2_1(T obj) {
return obj;
}
/**
* 打酱油的,实际是泛型类
* @param obj
* @return
*/
public List<R> pair3(R obj) {
return null;
}
/**
* 静态方法也可
* @param <T>
* @param obj
* @return
*/
public static <T> List<T> pair4(T obj) {
return null;
}
public static <T> T pair4_1(T obj) {
return obj;
}
}
final class ArrayExample<T> {
private Class<T> clazz;
public ArrayExample(Class<T> clazz) {
this.clazz = clazz;
}
public T[] getArray(int size) {
return (T[]) Array.newInstance(clazz, size);
}
}
Java泛型的使用
最新推荐文章于 2020-04-07 09:17:07 发布