什么是泛型?
泛型(Generic type 或者 generics)是对 Java 语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样。
运行时的强制转换不安全,在编译时引入泛型是为了安全
编译结束后不存在泛型,可以用javap -c 类名 反编译来验证。
package com.generics.lesson;
import java.util.ArrayList;
import java.util.List;
/*
* 泛型
*/
public class Test {
public static void main(String[] args) {
My<String> my = new My<String>();
my.print("213");
System.out.println(my.show(123));
List<Shape> list = new ArrayList<Shape>();
list.add(new Shape("1"));
list.add(new Shape("2"));
List<Shape> list2 = new ArrayList<Shape>();
list2.add(new Circle("a"));
list2.add(new Circle("b"));
my.print(list);
my.print(list2);
Shape c1 = new Circle("1");
Circle c2 = new Circle("1");
Shape c3 = new Shape("3");
System.out.println(c1 == c2);
System.out.println(c1.equals(c2));
System.out.println(c1.getClass()==c3.getClass());
System.out.println(c1.getClass().equals(c3.getClass()));
System.out.println(c1 instanceof Circle);
}
}
/* 泛型类 */
class My<T> {
public void print(T t) {
System.out.println(t);
}
// 通配符
public void print(List<? extends Shape> shapes) {
for (Shape shape : shapes) {
shape.print();
}
}
// 动态返回类型
public <T> T show(T t) {
return t;
}
}
class Shape {
protected String name;
public Shape() {
}
public Shape(String name) {
this.name = name;
}
public void print() {
System.out.println("shape:" + name);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
class Circle extends Shape {
@Override
public String getName() {
return super.getName();
}
@Override
public void setName(String name) {
super.setName(name);
}
public Circle() {
}
public Circle(String name) {
this.name = name;
}
@Override
public void print() {
System.out.println("circle:" + name);
}
// 覆盖Object类的equals方法
@Override
public boolean equals(Object obj) {
if (this == obj)
return super.equals(obj);
if (obj instanceof Shape) {
if (((Shape) obj).getName() == this.getName())
return true;
}
return false;
}
}
package com.generics.test;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 得到要调用类的class
* 得到要调用的类中的方法(Method)
* 方法调用(invoke)
*
*/
public class Main {
public static void main(String[] args) throws Exception {
Class cls = Class.forName("com.generics.test.Student");
@SuppressWarnings("unchecked")
Method m = cls.getDeclaredMethod("hi",new Class[]{int.class,String.class});
m.invoke(cls.newInstance(), 20,"prs");
//方法调用中的参数类型 int 不可更改为INteger
@SuppressWarnings("unchecked")
Method setMethod = cls.getDeclaredMethod("setAge", int.class);
setMethod.invoke(cls.newInstance(), 14);
//static方法的反射调用
@SuppressWarnings("unchecked")
Method staticMethod = cls.getDeclaredMethod("hi", int.class,String.class);
staticMethod.invoke(cls, 20,"qq"); //这里不需要newInstance()
//private 的成员变量赋值
Object student = cls.newInstance();
Field field = cls.getDeclaredField("age");
field.setAccessible(true);//直接访问不行必须设置访问许可
field.set(student, 10);
System.out.println(field.get(student));
}
}