什麼是列舉類？

列舉類是優化定義固定物件的一種特殊的類。

換句話說，在需要類的例項為一個或者多個並且相對固定的時候，使用列舉類。（列舉類可擴充套件）

類的例項相對來說固定的有日期，客觀不變的一些數字等等。

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




    }
}

相關推薦