枚举类&&注解&&反射

coding

枚举类

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

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

<br>

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

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 是代码里的特殊标记, 这些标记可以在编译, 类加 载, 运行时被读取, 并执行相应的处理。

<br>

基本注解

  • @Override 重写注解
  • @Deprecated 过时注解
  • @SuppressWarnings 抑制编译器警告注解

反射

什么是反射?

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

<br>

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

<br>

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

}

}

反射的优缺点

反射:就是正在运行动态读取这个类的完整信息。

优点:java的反射机制就是增加程序的灵活性、

缺点:

(1)性能问题:使用反射基本上是一种解释操作,

用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用。

(2)使用反射会模糊程序内部逻辑:程序员希望在源代码中看到程序的逻辑,反射等绕过了源代码的技术,因而会带来维护问题。反射代码比相应的直接代码更复杂。

哪些地方用到了反射?

例如: jdbc、Java常用框架、jdk的动态代理、android的加载布局文件

原文出处:https://www.cnblogs.com/noneplus/p/11407922.html

以上是 枚举类&amp;&amp;注解&amp;&amp;反射 的全部内容, 来源链接: utcz.com/z/509323.html

回到顶部