常用知识点

Objects.equals(Object,Object)

防止参数为空，2者都为空返回ture，一个为null返回false

重写一个equals的完整实例 （可以使用快捷键,快速生成,必须重新定义hashCode）

equals相同，hashCode也要相同

 @Override
    public boolean equals(Object obj) {

        if (this==obj)return  true;//代码优化，

        if (obj==null) return false;

//如果equals在每个子类中有所改变，就使用getClass检测
        if (getClass()!=obj.getClass()) return false;
     
      //如果拥有统一语义，就使用instance of
        if (!(obj instanceof CategoryBean)) return false;
        
        CategoryBean bean = (CategoryBean) obj;
        
        return id==bean.id &&Objects.equals(name,bean.name);
    }

枚举类型

public enum Size {

        SMALL,
        MEDIUM,
        LARGE,
        EXTRA_LARGE
}

//返回String
Size.SMALL.toString();
//String 转化枚举
 Size s = Enum.valueOf(Size.class, "SMALL");

        Size[] values = Size.values();//返回枚举数组

        Size.SMALL.ordinal();//枚举常量的位置，0开始

//出现在other之前，返回负数，=返回0，否则返回正数
        Size.SMALL.compareTo(Size.LARGE);

反射对象

参考地址 http://mp.weixin.qq.com/s/bDe-6KiTbazC5FhUi-Z65A
一般书上的定义是这样的:JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制，这几句解释说明了反射的作用，动态的跟类进行交互，比如获取隐藏属性，修改属性，获取对象，创建对象或者方法等等，总之就一句话:

反射是一种具有与类进行动态交互能力的一种机制 为什么要强调动态交互呢？

因为一般情况下都是动态加载，也就是在运行的时候才会加载，而不是在编译的时候，在需要的时候才进行加载获取，或者说你可以在任何时候加载一个不存在的类到内存中，然后进行各种交互,或者获取一个没有公开的类的所有信息，换句话说，开发者可以随时随意的利用反射的这种机制动态进行一些特殊的事情。

  //根据类型来创建一个对象
        try {
            Class s = Class.forName("com.zcits.highwayplatform.model.bean.ChartBean");
            Object beans =  s.newInstance();//调用默认构造器构建对象

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

因此反射的组成一般有下面几个方面组成:

1.java.lang.Class.java：类对象；
2.java.lang.reflect.Constructor.java：类的构造器对象；
3.java.lang.reflect.Method.java：类的方法对象；
4.java.lang.reflect.Field.java：类的属性对象；

实例参考

public class Student {
    private int age;//年龄
    private String name;//姓名
    private String address;//地址
    private static String sTest;
    public Student() {
        throw new IllegalAccessError("Access to default Constructor Error!");
    }
    private Student(int age, String name, String address) {
        this.age = age;
        this.name = name;
        this.address = address;
        sTest = "测试反射";
    }
    private int getAge() {
        return age;
    }
    private void setAge(int age) {
        this.age = age;
    }
    private String getName() {
        return name;
    }
    private void setName(String name) {
        this.name = name;
    }
    private String getAddress() {
        return address;
    }
    private void setAddress(String address) {
        this.address = address;
    }
    private static String getTest() {
        return sTest;
    }
}

反射运行

public static void main(String[] args) {

        try {

        Class clazz = Class.forName("ClassLoader.Student");
         //返回本地的这个构造器
        Constructor constructors=clazz.getDeclaredConstructor(int.class,String.class,String.class);
        constructors.setAccessible(true);//申请权限访问私有

        //利用构造器生成对象实例
        Object mStudent=constructors.newInstance(27,"小文","北京市海定区XX号");
        System.out.println(mStudent.toString());

        //获取隐藏的int属性
        Field mAgeField=clazz.getDeclaredField("age");
        mAgeField.setAccessible(true);//申请权限访问私有
        int age= (int) mAgeField.get(mStudent);
        System.out.println("年龄为:"+age);

        //调用隐藏的方法
        Method getAddressMethod=clazz.getDeclaredMethod("getAge");
        getAddressMethod.setAccessible(true);
        int newage= (int) getAddressMethod.invoke(mStudent);//调用实例方法一定需要一个类的实例
        System.out.println("年龄为:"+newage);

        //调用静态方法
        Method getTestMethod=clazz.getDeclaredMethod("getTest");
        getTestMethod.setAccessible(true);
        String result= (String) getTestMethod.invoke(null);//静态方法的话，那么第一个参数是为null
        System.out.println("调用静态方法:"+result);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }