欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

枚举类&&注解&&反射

程序员文章站 2022-06-20 23:10:31
反射机制允许程序在运行期 借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。 (flexible) ......

什么是枚举类?

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

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


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

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:

枚举类&&注解&&反射

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

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);




    }
}

枚举类&&注解&&反射