枚举类&&注解&&amp…

2019-08-26 06:46:22来源：博客园阅读 ()

枚举类&&注解&&反射

什么是枚举类？

枚举类是优化定义固定对象的一种特殊的类。

换句话说，在需要类的实例为一个或者多个并且相对固定的时候，使用枚举类。（枚举类可扩展）

类的实例相对来说固定的有日期，客观不变的一些数字等等。

enum WorkDay
{
    MONDAY, THUEDAY, WEDNESDAY , THURSDAY , FRIDAY;
}


public class Main {

    public static void main(String[] args) {
        System.out.println("Hello World!");

        WorkDay workDay;

        workDay=WorkDay.MONDAY;   //WorkDay实例化的workday值限定在周一到周五之间

//      workDay=3;     //编译报错

        WorkDay []workDays = WorkDay.values();  //返回枚举类型的对象数组

        for(int i =0;i<workDays.length;i++)
        {
            System.out.println(workDays[i]);
        }



        /**
         * 单例模式是枚举类的特例，单例模式的要求是一个类只能由一个实例对象。
         * 枚举类的使用是定义类时固定其一个或多个对象
         *
         * 枚举类的特点：
         *  - 类型安全（枚举类的定义就是固定的）
         *  - 枚举类的对象自动添加private static final
         *  - 某种程度的解耦，枚举类可以加一组常量或者对象抽离出主程序，减小类之间的耦合性。在枚举类模板的扩展上也更加容易
         */

    }
}

注解

Annotation 其实就是代码里的特殊标记, 这些标记可以在编译, 类加载, 运行时被读取, 并执行相应的处理。

注解本质是一个接口和一组键值对，通过反射和代理实现某种行为。

【框架 = 注解 + 反射 + 设计模式。】

/**
 * @author shkstart
 * @version 1.0
 *
 */
public class Main {
    /**
     * 程序的主方法，程序的入口
     * @param args String[] 命令行参数
     */

    @SuppressWarnings("unused")  //抑制编译器警告
    int a = 10;

    @Deprecated     //用于表示所修饰的元素(类, 方法等)已过时。通常是因为所修饰的结构危险或存在更好的选择
    public void print(){
        System.out.println("过时的方法");
    }
    @Override       //限定重写父类方法, 该注解只能用于方法
    public String toString() {
        return "重写的toString方法()"; }
    public static void main(String[] args) {
    }
    /**
     * 求圆面积的方法
     * @param radius double 半径值
     * @return double 圆的面积
     */
    public static double getArea(double radius){
        return Math.PI * radius * radius; }
}

反射

什么是反射？

反射机制允许程序在运行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。（最高权限）

Object类

package java.lang;

public class Object {

   private static native void registerNatives();
    static {
        registerNatives();
    }


    public final native Class<?> getClass();

    public native int hashCode();

    public boolean equals(Object obj) {
        return (this == obj);
    }

    protected native Object clone() throws CloneNotSupportedException;


    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }


    public final native void notify();


    public final native void notifyAll();


    public final native void wait(long timeout) throws InterruptedException;

 
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

    
 
    public final void wait() throws InterruptedException {
        wait(0);
    }


    protected void finalize() throws Throwable { }
}

其中有一个这样的方法

public final native Class<?> getClass();

获取Class类的实例

若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
已知某个类的实例，调用该实例的getClass()方法获取Class对象
已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
```
Class test  = String.class;


Class test01 = "Hello World!".getClass();


Class test02 = Class.forName("java.lang.String");  //抛异常
```

所有的类都继承Object，所以String.class返回类的实例。

Class类里有一个forName的方法，返回值也为Class：

1566714256892

获取类的信息，调用类的属性及方法

package test;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

class Work {
    private String name;
    private Integer age;
    private String gender;
    private String job;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Work{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", job='" + job + '\'' +
                '}';
    }
}


public class ReflectWork
{

    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException {


        Class classWork = Class.forName("test.Work");


        System.out.println(" ///获取所有方法信息"
        );


        Method []methods= classWork.getDeclaredMethods();

        for (Method m:methods) {
            System.out.println(m.toString());

        }

        System.out.println("  //获取所有成员属性信息");

        Field[] field=classWork.getDeclaredFields();
        for(Field f:field){
            System.out.println(f.toString());

            f.setAccessible(true);  //取消类的私有属性的访问权限控制

            System.out.println(f.getName().toString());
        }


        System.out.println("//通过反射初始化");
        Work reflectWork = (Work) classWork.newInstance();
        reflectWork.setAge(22);
        reflectWork.setJob("Dev");
        Work work = reflectWork;

        System.out.println(work);




    }
}

1566716123925