Java学习（第七周）---反射

类的对象

基于某个类 new 出来的对象，也称为实例对象

类对象

类加载的产物，封装了一个类的所有信息（类名、父类、接口、 属性、方法、构造方法）

获取类对象

1.通过类的对象，获取类对象
Student s = new Student();
Class c = s.getClass();
2.通过类名获取类对象
Class c = 类名.class;
3.通过静态方法获取类对象
Class c=Class.forName(“包名.类名”);

常用方法

public String getName()
public Package getPackage()
public Class<? super T> getSuperclass()
public Class<?>[] getInterfaces()
public Field[] getFields()
public Method[] getMethods()
public Constructor<?>[] getConstructors()
public T newInstance()

工厂设计模式

开发中有一个非常重要的原则“开闭原则”，对拓展开放、对修改关闭。
工厂模式主要负责对象创建的问题。
可通过反射进行工厂模式的设计，完成动态的对象创建。

工厂模板：
try {

Class c=Class.forName(className);//包名 . 类名

return c.newInstance();

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

完整例子：

public class TestInvokeAnything2 {



public static void main(String[] args) throws Exception {

//invokeAny()---->执行方法

//Object--对象，String---方法名称，Class---形参，Object---实参

//方法1：调用其他类的creatObject工厂

invokeAny(new Student(),"exam",new Class[] {int.class,double.class,String.class},3,126.8,"李四");

invokeAny(new Student(),"study",new Class[] {int.class},3);



//方法2：调用本类的creatObject工厂

Object o=creatObject("Student");

invokeAny(o,"exam",new Class[] {int.class,double.class,String.class},3,126.8,"李四");

invokeAny(o,"study",new Class[] {int.class},3);

invokeAny(o,"study",null);

invokeAny(o,"study",null,null);

}

public static void invokeAny(Object obj,String methodNme,Class[] types,Object...args) throws Exception {

//使用反射技术执行任何方法

//类对象

Class c=obj.getClass();

//获得方法的对象Method

Method m=c.getDeclaredMethod(methodNme, types);

//执行方法

m.invoke(obj, args);

}

public static Object creatObject(String className) {

try {

Class c=Class.forName(className);//包名 . 类名

return c.newInstance();

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

} 

单例模式

概念：单例（Singleton）只允许创建一个该类的对象
方式1： 饿汉式（类加载时创建，天生线程安全）

//饿汉式

//类加载时创建,天生线程安全,无锁状态，不用的时候被迫创建，占用资源

//只创建一次

public class TestSingleton1 {



public static void main(String[] args) {

Singleton1 s1= Singleton1.getInstance();

Singleton1 s2= Singleton1.getInstance();

Singleton1 s3= Singleton1.getInstance();

Singleton1 s4= Singleton1.getInstance();



//Singleton1.instance=null; //不能通过调用成员变量创建对象



System.out.println(s1);

System.out.println(s2);

System.out.println(s3);

System.out.println(s4);

}



}

class Singleton1 {

private static final Singleton1 instance=new Singleton1();

private Singleton1() {}

public static Singleton1 getInstance() {

return instance;

}
}

方式2： 懒汉式（使用时创建，线程不安全，加同步）

//饿汉式

//类加载时创建,天生线程安全,无锁状态，不用的时候被迫创建，占用资源

//只创建一次

public class TestSingleton1 {



public static void main(String[] args) {

Singleton1 s1= Singleton1.getInstance();

Singleton1 s2= Singleton1.getInstance();

Singleton1 s3= Singleton1.getInstance();

Singleton1 s4= Singleton1.getInstance();



//Singleton1.instance=null; //不能通过调用成员变量创建对象



System.out.println(s1);

System.out.println(s2);

System.out.println(s3);

System.out.println(s4);

}



}

class Singleton1 {

private static final Singleton1 instance=new Singleton1();

private Singleton1() {}

public static Singleton1 getInstance() {

return instance;

}

}

方式3： 懒汉式（使用时创建，线程安全）

//懒汉式

//使用时创建，线程安全，不占内存

public class TestSingleton3 {



public static void main(String[] args) {

Singleton3 s1= Singleton3.getInstance();

Singleton3 s2= Singleton3.getInstance();

Singleton3 s3= Singleton3.getInstance();

Singleton3 s4= Singleton3.getInstance();



System.out.println(s1);

System.out.println(s2);

System.out.println(s3);

System.out.println(s4);

}

}

class Singleton3 {

private Singleton3() {}

public static class Holder{//静态私有内部类

private static final Singleton3 instance=new Singleton3();

}

public static Singleton3 getInstance() {

return Holder.instance;

}
}