public class TestArrayTools {
public static void main(String[] args) {
Integer[] arr1 = {102,27,43,88};
ArrayTools at1 = new ArrayTools();
at1.printArray(arr1);
System.out.println(at1.getClass());
String[] arr2 = {“蓝鸥”,“科技”,“牛best”};
ArrayTools at2 = new ArrayTools();
at2.printArray(arr2);
System.out.println(at2.getClass());
Person[] persons = {
new Person(“谢**”,“男”),
new Person(“娄**”,“男”),
new Person(“杨**”,“女”),
new Person(“张*”,“男”),
};
ArrayTools at3 = new ArrayTools();
at3.printArray(persons);
System.out.println(at3.getClass());
/*
* 泛型：也叫参数化类型。
* 最核心的功能就是可以将类型当参数对待。
*
* 这里的T相当于一个占位符。
* 使用的时候会替换成具体的类型。
*
* T只能替换对象类型，不能替换基本数据类型
* 如果想替换基本数据类型，请使用基本数据类型对应的类类型。
* int改成Integer
* double改成Double
* char改成Charactor
* …
*
*
* 泛型是编译期的功能。
* 在你的源码转换为class字节码文件的时候，会进行替换。
* 而不是运行的时候才替换。
*
* 泛型（Generics）可以作用于类、接口、方法。
* 泛型类
* 泛型接口
* 泛型方法
*
* */
}
}
<类型占位符>
//类型占位符在命名上与变量命名类似。
//通常我们使用单个大写字符做类型占位符。
//系统常见是:
//T (type) E (element) K(key) V (value)
//从规范角度上讲，我们尽可能使用上述字符。
//声明泛型类的语法格式是 :
//在类名后面加上 <占位符>
//声明完 泛型类之后，就可以用 占位符 去定义属性、方法、变量等。
//下述代码中的 T，作用域是整个Generics类。
//在整个Generics类中都能使用T。
public class Generics {
private String name;//普通属性
private T a;//用泛型定义的属性。
//a是声明类型取决于使用时传递进来的类型是什么
//普通方法
public void method(String str) {
System.out.println(str);
}
//使用泛型定义的方法。t的类型取决于使用时传递进来的类型是什么
public void method2(T t) {
System.out.println(t);
}
//不仅参数可以用泛型，返回值也可以用泛型
public T method() {
return a;
}
//定义有参数的构造方法，给成员属性初始化值。
public Generics(String str,T t) {
this.name = str;
this.a = t;
//局部变量也可以定义为泛型
T tt = t;
System.out.println(tt);
}
}
//总结一句话：
// 普通类中 可以出现类型的地方，都可以换成泛型。
// 比如：属性、方法的参数、方法的返回值，局部变量。
public class TestGenerics {
public static void main(String[] args) {
//泛型类的使用。
//使用泛型类时，需要指定泛型的真实类型。
//泛型类的使用与普通类的使用相同。
//唯独增加了 为泛型指定明确类型的环节。
//在类名的后面 通过<真实类型> 来指定明确类型。
Generics g1 = new Generics(“张三”,“helloworld”);
g1.method(“今天星期四”);
g1.method2(“这是泛型参数”);
String str = g1.method();//获取泛型返回值
System.out.println(str);
Generics g2 = new Generics(“李四”,100);
g2.method(“3月28日”);
g2.method2(200);
int num = g2.method();
System.out.println(num);
//使用泛型类的好处
//1、能够优化代码。可以将具有相同功能的方法合成1个，
// 减少代码冗余
//2、编译器会做类型检查，提前帮你发现问题。
//例如：你指定泛型的真实类型是String但是 传的参数不是String
//编译器就会报错，帮你提前发现问题。
}
}
//泛型接口：
//接口可以看成是 所有方法都是抽象方法的 抽象类。
//因此接口也可以使用泛型。
//使用泛型的接口称为 泛型接口
//泛型接口的语法格式与泛型类的语法格式一样
//语法格式:
//在接口名后面加上<类型占位符>
public interface GenericsInterface {
//参数为泛型
public abstract void method1(T t);
//返回值为泛型
public abstract T method2();
}
//泛型接口的实现类。GI1实现了泛型接口GenericsInterface
//实现类有2种方式实现泛型接口
//第一种方式：实现泛型接口的时候，明确泛型的真实类型。
//即将 T 换成真实的类型。
public class GI1 implements GenericsInterface {
@Override
public void method1(String t) {
System.out.println(t);
}
@Override
public String method2() {
return “中国共产党万岁！”;
}
}
//泛型接口的实现类。GI3实现了泛型接口GenericsInterface
//实现类有2种方式实现泛型接口
//第二种方式：实现泛型接口的时候， 不 明确泛型的真实类型。
//即将 T 不做任何替换。
//如果使用第二种方式，必须在 类名后面加上泛型。也就是说你必须把
//这个类定义成泛型类
public class GI3 implements GenericsInterface {
@Override
public void method1(T t) {
System.out.println(t);
}
@Override
public T method2() {
return null;
}
}
//如果你定义一个类为泛型类，那么这个类中无论属性、方法还是局部变量
//都可以使用泛型。
//但是如果你没有定义泛型类，又想让方法中的参数或返回值是泛型。
//这个时候可以使用泛型方法。
//定义泛型方法的语法格式：
//方法的返回值前面 加上 <类型占位符>
public class GenericsMethod {
public void method1(T t) {
System.out.println(t);
}
public T method2(T t) {
return t;
}
}
public class TestGI {
public static void main(String[] args) {
GI1 gi1 = new GI1();
gi1.method1(“hello kugoo”);
String str = gi1.method2();
System.out.println(str);
GI2 gi2 = new GI2();
ArrayList list= new ArrayList();
list.add(“hehe”);
list.add(“haha”);
gi2.method1(list);
System.out.println(gi2.method2());
//泛型接口的第二种实现
GI3 gi3 = new GI3();
gi3.method1(“我想***”);
System.out.println(gi3.method2());
GI3 gi33 = new GI3();
gi33.method1(100);
System.out.println(gi33.method2());
//泛型方法
//泛型方法如何指定真实类型。
//在.之后，方法名之前加上<真实类型>
GenericsMethod gm = new GenericsMethod();
gm.method1(“hello world”);
gm.method1(3.14);
int a = gm.method2(100);
System.out.println(a);
}
}
public static void main(String[] args) {
Fruit f1 = new Fruit(“苹果”);
Fruit f2 = new Fruit(32);
Object o = new Object();
Fruit f3 = new Fruit(o);
//类的继承关系里可以使用多态。
//父类引用保存子类对象。
//在泛型关系里，泛型是不能继承的！！
show(f1);
// show(f2);
// show(f3);
//?是通配符，可以代指任何类型
show1(f1);
show1(f2);
show1(f3);
//设上限
show2(f1);
show2(f2);
show2(f3);
//设下限
show3(f1);
//show3(f2);
show3(f3);
}
public static void show(Fruit f) {
System.out.println(f);
}
public static void show1(Fruit<?> f) {
System.out.println(f);
}
//Object及子类
public static void show2(Fruit<? extends Object> f) {
System.out.println(f);
}
//String及父类
public static void show3(Fruit<? super String> f) {
System.out.println(f);
}
}