反射以及实例

类对象

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

获取类对象

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

工厂设计模式

• 开发中有一个非常重要的原则” ” 开闭原则 “, 所谓” ” 开闭原则” ” 指的是一个软件
产品，应该对修改关闭，对拓展开放。
• 工厂模式：主要解决的是对象创建的问题, , 工厂的职责在于创建一个对象。

单例设计模式

• 单例模式 (Singleton) ：是一种常见的设计模式，在 Java 应用中，单例对象
必须保证一个 JVM中,该对象只有一个实例存在.

反射实例

常用方法:

package reflect;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestGetClassInfo {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
        //1.通过类的对象,获取类对象
        Student s1 = new Student(); //类的对象
        Class studentClass = s1.getClass(); //获取该对象的真实Class类型(真实类型)
        System.out.println(studentClass.getName()); //获取父类的名字
        Class superClass = studentClass.getSuperclass(); //获取父类的对象
        System.out.println(superClass.getName());
        superClass.getInterfaces();
        Field[] fields = studentClass.getDeclaredFields(); //获得所有属性

        for (Field field : fields) {
            System.out.println(field.getName());
        }

        Method[] methods = studentClass.getDeclaredMethods();

        Method m2 = studentClass.getDeclaredMethod("m2", null);


        try {
            m2.invoke(new Student(), null);
        } catch (IllegalAccessException | IllegalArgumentException
                | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

class Student implements Serializable,Comparable<Student>{
    public int a;
    public int b;
    @Override
    public int compareTo(Student o) {
        return 0;
    }
    public void m2(){
        System.out.println("-------");
    }
}

工厂设计模式

package reflect;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 通用编程
 * @author WDreamIn
 *
 */
public class TestObjectFactory {

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

        InputStream is = new FileInputStream("bin\\application.properties"); //key-value

        Properties prop = new Properties();

        prop.load(is);
        String className = prop.getProperty("className");
        USB usb = (USB) USBFactory.getOject(className);
        usb.service();
    }
}

//通用编程
class USBFactory{
    public static Object getOject(String className) throws Exception{
        return  Class.forName(className).newInstance();
    }
}

interface USB{
    public void service();
}

class Fan implements USB{
    @Override
    public void service() {
        System.out.println("通电---旋转");
    }
}

class Lamp implements USB{
    @Override
    public void service() {
        System.out.println("通电---照明");
    }
}

调用任何一个对象的实例方法

package reflect;

import java.lang.reflect.Method;

public class TestCommons {

    public static void main(String[] args) throws Exception {
        method(new Students(),"sayHi",new Class[]{int.class},20);
    }
    //调用任何一个对象的实例方法
    private static void method(Object obj,String methodName,Class[] params,Object... values) throws Exception {
        //获取类对象
        Class c = obj.getClass();

        //获取Method对象
        Method m = c.getMethod(methodName, params);

        //调用invoke()
        m.invoke(obj, values);
    }

}

class Students {
    public void sayHi() {

    }

    public void sayHi(int n) {
        System.out.println("Hello");
    }

    public void sayHi(int n, int x) {

    }
}

单例模式三种实现方式

package reflect;

public class TestSingleton {

    public static void main(String[] args) throws ClassNotFoundException {
        Class c = Class.forName("reflect.Singleton");

        Singleton ins1 = Singleton.getInstance();
        Singleton ins2 = Singleton.getInstance();

        System.out.println(ins1 + "\t" + ins2);
        //10 个小时不需要(占用资源)
    }
}
//饿汉式
//class Singleton{
//  //可能浪费资源
//  private static final Singleton instance = new Singleton();
//  static{
//      System.out.println("Singleton static block");
//  }
//  //私有构造
//  private Singleton(){}
//  
//  //返回一个本类的对象
//  public static Singleton getInstance(){
//      return instance;
//  }
//}

//懒汉式
//class Singleton{
//  private static Singleton instance = null; 
//  
//  private Singleton(){}
//  //为保证线程安全,需要加锁
//  public static synchronized Singleton getInstance(){
//      if(instance == null){
//          instance = new Singleton(); //new 一次
//      }
//      return instance;
//  }
//}
//智汉式
class Singleton{
    //以静态内部类形式 不算浪费资源 线程安全
    private static class Inner{
        static Singleton instance = new Singleton();
    }
    public static Singleton getInstance(){
        return Inner.instance;
    }
    private Singleton() {}
}