Day_14 反射

Day 16 反射

类对象

类的对象	类对象
基于某个类new出来的对象，也称为实例对象	类加载的产物，封装了一个类的所有信息（类名、父类、接口、属性、方法、构造方法）

获取类对象

通过类的对象，获取类对象

Student s = new Student();
Class c = s.getClass();

通过类名获取类对象

Class c = 类名.class;

通过静态方法获取类对象

Class c = Class.forName("包名.类名");

常用操作

public class TestClass{
    Class c = Class.forName("com.baizhi.test.Student");
    System.out.println(c.getName);//获取类名
    System.out.println(c.getPackage().getName());//获取包名
    System.out.println(c.getSuperClass().getName());//获取父类名
    Class[] inters = c.getInterfaces();//获取所实现的接口
    for(Class inter : inters){
        System.out.println(inter.getName());
    }
}

常用方法

public class TestClass{
    public static void main(String[] args)throw Exception{
        Class c=class.froName("com.baizhi.test.Student");
        Object o = c.newInstance();
        //默认调用无参的构造方法创建对象
        Method[] methods = c.getMethods();
        //获取类中所有的公开方法，包括父类中的方法
        for(Method method : methods){
            System.out.println(method.getName());
        }
        Method[] dMethods = c.getDeclaredMethods();
        //获取本类中所有方法，包括非公开的
        for(Method method:dMethods){
            System.out.println(method.getName);
        }
        Method method=c.getMethod("print",String.class);
        //获取某一个方法：getMethod(String name,Class...type) 第一个参数：方法名  第二个参数：参数的数据类型
        method.invoke(o,"zhangsan");
    }
}

工厂设计模式

开闭原则：软件产品应该对修改关闭，对拓展开放。

工厂模式：主要解决的是对象创建的问题，工厂的职责在于创建一个对象。

public static Light createLight(){
    FileInputStream fis=null;
    try{
        fis=new FileInputStream("className.txt");
        Properties pro=new Properties();
        pro.load(fis);
        String className=pro.getProperty("className");
        //通过键取值
        Class c=Class.forName(className);
        Light light=(Light)c.newInstance();
        return light;
    }catch(Exception e){
        e.printStackTrace();
        return null;
    }finally{
        try{
            fis.close();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

单例设计模式

单例模式：是一种常见的设计模式，在java应用中，单例对象必须保证一个JVM中，该对象只有一个实例存在。

实现方式一：（饿汉式）

class Singleton1{
    private static final Singleton1 s1 = new Singleton1();
    private Singleton1();
    public static Singleton1 getInstance(){
        return s1;
    }
}
//优点：并发效率高
//缺点：空间利用率低

实现方式二：（懒汉式）

class Singleton2{
    private static Singleton2 s2;
    private Singleton2(){};
    public synchronized static Singleton2 getInstance(){
        if(s2==null){
            s2=new Singleton2();
        }
        return s2;
    }
}
//优点：空间利用率高
//缺点：并发效率低，必须加synchronized

实现方式三：

class Singleton3{
    private static class Inner{
        static Singleton3 instance=new Singleton3();
    }
    public static Singleton3 newInstance(){
        return Inner.instance;
    }
    private Singleton3(){}
}