Java高级应用之泛型与反射20170627

/******************************************************************************************************************/

一、泛型

不同的数据结构可以用同样的操作就是泛型

1.类使用泛型

class Person<T> {//要使用泛型的类加上类似与通配符的<T>,中间字符可以任意

//也可以传入多个类型<T,N>

private T age;//内部类型,使用T代替

public void setAge(T age) {//内部类型,使用T代替

this.age = age;

}

public T getAge() {//内部类型,使用T代替

return this.age;

}

}

public class Generics {

public static void main(String args[]) {

Person<String> p = new Person<String>();//创建对象的时候传入类型，如果是两个则<>里面放两个类型

p.setAge("3 years old");

//System.out.println(p.getAge());

printInfo(p);

Person<Integer> p2 = new Person<Integer>();//<>内只能用类，所以不能用基础数据类型int要用Integer类代替

p2.setAge(3);

//System.out.println(p2.getAge());

printInfo(p2);

Person<?> p3;

p3 = p;//通用引用p3赋值

//p3.setAge("4 years");//不能设置(类型冲突)

p3.getAge();//但可以获取

}

public static void printInfo(Person<?> p) {//Person<?>是通配符,表示传进来可以是String类也可以是Integer类

System.out.println(p.getAge());

}

}

2.方法使用泛型

1)定义

public static <T> void printInfo2(Person<T> p) {//定义格式返回值前面，参数里都要有相应的<T>

System.out.println(p.getAge());

}

2)调用

printInfo2(p);//p为具体的对象Person<String> p = new Person<String>();

printInfo2(p2);

printInfo2(p3);

3.子类使用泛型(泛型的继承)

1)定义

class Student<T> extends Person<T> {//子类继续使用泛型

}

class Student2 extends Person<String> {//子类不再使用泛型

//子类确定类型为String,所以前面也就不需要加<T>,同时对应父类的类型也已被确定

}

2)调用

Student<Integer> s = new Student<Integer>();//创建子类对象,传入类型

s.setAge(10);//调用父类的方法

printInfo(s);//向上转换

Student2 s2 = new Student2();//已经确定类型，不需传入

s2.setAge("11 years");//对应父类的类型已被确定，调用父类方法直接传入String

printInfo(s2);

4.接口使用泛型(接口:特殊的父类)

interface Person<T> {

public void setAge(T age);

public T getAge();

}

class Student<T> implements Person<T> {//子类继续使用泛型

T age;

public void setAge(T age){

this.age = age;

}

public T getAge() {

return this.age;

}

}

class Student2 implements Person<String> {//指定对应接口的泛型类型

String age;///已经确定了类型，直接使用

public void setAge(String age){

this.age = age;

}

public String getAge() {

return this.age;

}

}

public static void main(String args[]) {

Student<Integer> s = new Student<Integer>();//创建子类对象,传入类型

s.setAge(10);

printInfo(s);//向上转换(接口:特殊的父类),子类里实现了方法，同时父类也就是接口没有实现对应的方法,所以里面调用的是子类的方法

Student2 s2 = new Student2();//已经确定类型，不需传入

s2.setAge("11 years");

printInfo(s2);

}

public static void printInfo(Person<?> p) {

System.out.println(p.getAge());

}

5.受限泛型

声明泛型的时候可以指定泛型的上限和下限

1)泛型的上限:<T extends Number> T只能是Number类或其子类

/*T只能是Number类或其子类Integer, Float 等*/

class Student<T extends Number> implements Person<T> {

T age;

public void setAge(T age)

{

this.age = age;

}

public T getAge() {

return this.age;

}

}

2)泛型的下限:<? super String> T只能是String类或其父类

super只能使用通配符,不能直接在名字里使用（即只能在使用这个泛型的时候再指定）,所以还是:

class Student<T> implements Person<T> {

T age;

public void setAge(T age)

{

this.age = age;

}

public T getAge() {

return this.age;

}

}

//使用的时候指定下限（用通配符?指定下限）

public static void printInfo(Person<? super String> p) {//传进来 只能是String类或其父类

System.out.println(p.getAge());

}

调用:

Student<String> s = new Student<String>();

s.setAge("10");

printInfo(s);

/******************************************************************************************************************/

二、反射

正常步骤我们是import"包.类"然后通过new实例化最后得到实例化对象

那么能否反过来呢

从实例化对象得到getClass方法最后得到完整的"包.类"名称

这个反过来的操作(根据实例化对象得到完整的"包.类"名称)就是所谓的反射操作(当然反射的作用不仅仅是得到完整的"包.类"名称)

注意：在反射操作中，一切的操作都使用Object完成,类，数组的引用都可以使用object进行接收

1.class对象和"类的实例化对象"

Person p=new Person();

System.out.println(p.getClass().getName());//打印"包.类"名称

JVM会加载*.Class文件(java写的类)到内存里，也就是会在内存里创建一个class object用来描述这个类，包括类的包,类名称,构造方法,方法，属性，这样就可以使用这个class object来实例化对象（在内存里对于一个class只有一个class object,这个class object是用来描述类本身的，我们可以使用这个class object来创建实例化对象）可以有三种方法获得一个类的class object:

2.获得class

1).Class<?> c=Class.forName("包.类");

Class<?> c1 = null;

try {

c1 = Class.forName("a.b.c.d.Person");

} catch (ClassNotFoundException e) {

System.out.println(e);

}

System.out.println(c1.getName());

2).Class<?> c=new X().getClass();

Person p = new Person();

Class<?> c2 = p.getClass();

System.out.println(c2.getName());

3).Class<?> c=X.class

Class<?> c3 = Person.class;

System.out.println(c3.getName());

3.对于数组或者其他数据类型，也有对应的类，对应的class object

int arr[] = {1,2,3};

int arr2[] = {1,2,3，4};

int arr3[][] = {{1,2,3,4},{1}};

Class<?> c4 = arr.getClass();

Class<?> c5 = arr2.getClass();

Class<?> c6 = arr3.getClass();

Class<?> c7 = int.class;

System.out.println(c4.getName());

System.out.println(c5.getName());

System.out.println(c6.getName());

System.out.println(c7.getName());//基本的数据类型也是一个类，里面也有class

System.out.println((c4 == c5));//同样的数组类型是一样的class

System.out.println((c4 ！= c6));//二维数组和一维数组不一样所以不一样的class

4.使用反射来获取类的实例化对象(类的属性与方法)，取代import a.b.c.d.Person;(的形式)

public static void main(String args[]) throws Exception {//Exception 是其他的异常父类，所以可以这样代替InstantiationException等其他异常

Class<?> c = null;

try {

c = Class.forName("a.b.c.d.Person");//使用名字来获得这个Person的class object

} catch (ClassNotFoundException e) {

System.out.println(e);

}

Object p = null;//然后创建它的实例化对象(Object是所有类的父类,所以可以这么写)

try {

p = c.newInstance();//然后创建它的实例化对象(Object是所有类的父类,所以可以这么写(可以向上转换)),实际是调用了那个类的无参构造方法

} catch (InstantiationException e) {

System.out.println(e);

}

//调用有参构造方法的实例化

Constructor<?> con = c.getConstructor(String.class);//获得参数是String的构造方法 的class

Object p2 = con.newInstance("123");//然后创建它的实例化对象，有参数

5.获得并调用类的方法:

Method set = c.getMethod("setName", String.class);//传入方法名称(该方法在定义的地方要有public权限)，参数类型

set.invoke(p2, "123");//调用实例化对象中的方法，要设置的实例化对象，然后才是传入的值

set.invoke(p, "abc");

//对于静态方法, invoke的第1个参数可以写为null

Method get = c.getMethod("getName");//没有传入参数

System.out.println(get.invoke(p));

System.out.println(get.invoke(p2));

6.读取或设置类的属性

1).最好是用上面的方式，通过方法来访问类的属性

2).也可以直接获取属性:

(1)Field f = c.getField(String name); // 获得公共属性, 此方法先搜本类, 再搜它实现的接口，最后在父类中搜索

(2)Field name = c.getDeclaredField("name");//可以获得类里面所有属性(包括private,public等)中名为name的属性

name.setAccessible(true);//设置为可访问，如果要访问的属性为public可以不要这句话，其实设置为可访问也就破坏了类的封装性，所以一般不使用这种方法，而是去调用那个类的设置获取方法

name.set(p, "www");//设置某个实例化对象中的name属性

name.set(p2, "123");//设置p2这个实例化对象中的name属性

System.out.println(name.get(p));//获得某个对象的name属性

System.out.println(name.get(p2));

7.使用反射的好处

增加程序灵活性，通过类的名称(放在文件里或者通过参数传递，这就不用在代码中写死，传入什么就可以实例化什么)，然后就可以实例化出不同的对象