Annotation入门

最新推荐文章于 2021-07-17 15:08:37 发布
最新推荐文章于 2021-07-17 15:08:37 发布
阅读量120 收藏
点赞数
分类专栏： 转载文章 文章标签： Java J2SE SUN HTML Blog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bb413953949/article/details/83555420
版权

版权声明：本文可以自由转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
作者:cleverpig(作者的Blog:http://blog.matrix.org.cn/page/cleverpig)
原文:[http://www.matrix.org.cn/resource/article/44/44048_Java+Annotation.html]http://www.matrix.org.cn/resource/article/44/44048_Java+Annotation.html[/url]
关键字:Java,annotation,标注


摘要：
本文针对java初学者或者annotation初次使用者全面地说明了annotation的使用方法、定义方式、分类。初学者可以通过以上的说明制作简单的annotation程序，但是对于一些高级的annotation应用（例如
使用自定义annotation生成javabean映射xml文件）还需要进一步的研究和探讨。涉及到深入annotation的内容，作者将在后文《Java Annotation高级应用》中谈到。

同时，annotation运行存在两种方式：运行时、编译时。上文中讨论的都是在运行时的annotation应用，但在编译时的annotation应用还没有涉及，

一、为什么使用Annotation：

在JAVA应用中，我们常遇到一些需要使用模版代码。例如，为了编写一个JAX-RPC web service，我们必须提供一对接口和实现作为模版代码。如果使用annotation对远程访问的方法代码进行修饰的话，这个模版就能够使用工具自动生成。
另外，一些API需要使用与程序代码同时维护的附属文件。例如，JavaBeans需要一个BeanInfo Class与一个Bean同时使用/维护，而EJB则同样需要一个部署描述符。此时在程序中使用annotation来维护这些附属文件的信息将十分便利而且减少了错误。

二、Annotation工作方式：

在5.0 版之前的Java平台已经具有了一些ad hoc annotation机制。比如，使用transient修饰符来标识一个成员变量在序列化子系统中应被忽略。而@deprecated这个 javadoc tag也是一个ad hoc annotation用来说明一个方法已过时。从Java5.0版发布以来，5.0平台提供了一个正式的annotation功能：允许开发者定义、使用自己的annoatation类型。此功能由一个定义annotation类型的语法和一个描述annotation声明的语法，读取annotaion 的API，一个使用annotation修饰的class文件，一个annotation处理工具（apt）组成。
annotation并不直接影响代码语义，但是它能够工作的方式被看作类似程序的工具或者类库，它会反过来对正在运行的程序语义有所影响。annotation可以从源文件、class文件或者以在运行时反射的多种方式被读取。
当然annotation在某种程度上使javadoc tag更加完整。一般情况下，如果这个标记对java文档产生影响或者用于生成java文档的话，它应该作为一个javadoc tag；否则将作为一个annotation。

三、Annotation使用方法：

1。类型声明方式：
通常，应用程序并不是必须定义annotation类型，但是定义annotation类型并非难事。Annotation类型声明于一般的接口声明极为类似，区别只在于它在interface关键字前面使用“@”符号。
annotation 类型的每个方法声明定义了一个annotation类型成员，但方法声明不必有参数或者异常声明；方法返回值的类型被限制在以下的范围： primitives、String、Class、enums、annotation和前面类型的数组；方法可以有默认值。

下面是一个简单的annotation类型声明：
清单1:

 

Java代码 复制代码
  1.      
  2. /** * Describes the Request-For-Enhancement(RFE) that led      
  3.     * to the presence of the annotated API element.     */      
  4. public @interface RequestForEnhancement {        
  5.   int    id();         
  6.   String synopsis();           
  7.   String engineer() default "[unassigned]";            
  8.   String date();    default "[unimplemented]";        
  9. }  
  
/** * Describes the Request-For-Enhancement(RFE) that led    
    * to the presence of the annotated API element.     */   
public @interface RequestForEnhancement {     
  int    id();      
  String synopsis();        
  String engineer() default "[unassigned]";         
  String date();    default "[unimplemented]";     
}


代码中只定义了一个annotation类型RequestForEnhancement。

2。修饰方法的annotation声明方式：
annotation 是一种修饰符，能够如其它修饰符（如public、static、final）一般使用。习惯用法是annotaions用在其它的修饰符前面。 annotations由“@+annotation类型+带有括号的成员-值列表”组成。这些成员的值必须是编译时常量（即在运行时不变）。

A：下面是一个使用了RequestForEnhancement annotation的方法声明：
清单2:

Java代码 复制代码
  1. @RequestForEnhancement(           
  2. id       = 2868724,         
  3. synopsis = "Enable time-travel",         
  4. engineer = "Mr. Peabody",        
  5.  date     = "4/1/3007"      
  6.      
  7. public static void travelThroughTime(Date destination) { ... }   
  @RequestForEnhancement(        
  id       = 2868724,      
  synopsis = "Enable time-travel",      
  engineer = "Mr. Peabody",     
   date     = "4/1/3007"   
 )  
  public static void travelThroughTime(Date destination) { ... }


B：当声明一个没有成员的annotation类型声明时，可使用以下方式：
清单3:

  

Java代码 复制代码
  1.     
  2. /**      
  3.  * Indicates that the specification of the annotated API element     * is preliminary and subject to change.     */      
  4.  public @interface Preliminary { }   
 
/**    
 * Indicates that the specification of the annotated API element     * is preliminary and subject to change.     */   
 public @interface Preliminary { }


作为上面没有成员的annotation类型声明的简写方式：
清单4:

Java代码 复制代码
  1. @Preliminary public class TimeTravel { ... }  
   @Preliminary public class TimeTravel { ... }



C：如果在annotations中只有唯一一个成员，则该成员应命名为value：
清单5:

Java代码 复制代码
  1. /**       
  2.   * Associates a copyright notice with the annotated API element.     */       
  3. public @interface Copyright {        String value();    }   
/**     
  * Associates a copyright notice with the annotated API element.     */    
public @interface Copyright {        String value();    }



更为方便的是对于具有唯一成员且成员名为value的annotation（如上文），在其使用时可以忽略掉成员名和赋值号（=）：
清单6:

 

Java代码 复制代码
  1.      
  2. @Copyright("2002 Yoyodyne Propulsion Systems")       
  3. public class OscillationOverthruster { ... }   
  
@Copyright("2002 Yoyodyne Propulsion Systems")    
public class OscillationOverthruster { ... }


3。一个使用实例：
结合上面所讲的，我们在这里建立一个简单的基于annotation测试框架。首先我们需要一个annotation类型来表示某个方法是一个应该被测试工具运行的测试方法。
清单7:

Java代码 复制代码
  1. import java.lang.annotation.*;    
  2. /*** Indicates that the annotated method is a test method.    
  3.    * This annotation should be used only on parameterless static methods.     */    
  4.  @Retention(RetentionPolicy.RUNTIME)      
  5.  @Target(ElementType.METHOD)      
  6.  public @interface Test { }   
import java.lang.annotation.*; 
/*** Indicates that the annotated method is a test method.  
   * This annotation should be used only on parameterless static methods.     */ 
 @Retention(RetentionPolicy.RUNTIME)   
 @Target(ElementType.METHOD)   
 public @interface Test { }


值得注意的是annotaion类型声明是可以标注自己的，这样的annotation被称为“meta-annotations”。

在上面的代码中，@Retention(RetentionPolicy.RUNTIME)这个meta-annotation表示了此类型的 annotation将被虚拟机保留使其能够在运行时通过反射被读取。而@Target(ElementType.METHOD)表示此类型的 annotation只能用于修饰方法声明。

下面是一个简单的程序，其中部分方法被上面的annotation所标注：
清单8:

Java代码 复制代码
  1. public class Foo {           
  2. @Test public static void m1() { }         
  3.   public static void m2() { }        
  4.    @Test public static void m3() {           
  5.     throw new RuntimeException("Boom");          
  6.  }         
  7.   public static void m4() { }         
  8.   @Test public static void m5() { }      
  9.      public static void m6() { }        
  10.    @Test public static void m7() {           
  11.     throw new RuntimeException("Crash");        }      
  12.      public static void m8() { }    }   
public class Foo {        
@Test public static void m1() { }      
  public static void m2() { }     
   @Test public static void m3() {        
    throw new RuntimeException("Boom");       
 }      
  public static void m4() { }      
  @Test public static void m5() { }   
     public static void m6() { }     
   @Test public static void m7() {        
    throw new RuntimeException("Crash");        }   
     public static void m8() { }    }




Here is the testing tool:

Java代码 复制代码
  1. import java.lang.reflect.*;    
  2.    public class RunTests {         
  3.  public static void main(String[] args) throws Exception {          int passed = 0, failed = 0;           
  4.   for (Method m : Class.forName(args[0]).getMethods()) {     
  5.            if (m.isAnnotationPresent(Test.class)) {                try {           
  6.            m.invoke(null);                   
  7.            passed++;                  
  8.  } catch (Throwable ex) {   
  9. System.out.printf("Test %s failed: %s %n", m, ex.getCause());                    
  10.   
  11.   failed++;                  
  12.  }               
  13.    }           
  14.   }            
  15.  System.out.printf("Passed: %d, Failed %d%n", passed, failed);   
  16.   
  17.     }      
import java.lang.reflect.*; 
   public class RunTests {      
 public static void main(String[] args) throws Exception {          int passed = 0, failed = 0;        
  for (Method m : Class.forName(args[0]).getMethods()) {  
           if (m.isAnnotationPresent(Test.class)) {                try {        
           m.invoke(null);                
           passed++;               
 } catch (Throwable ex) {
System.out.printf("Test %s failed: %s %n", m, ex.getCause());                 

  failed++;               
 }            
   }        
  }         
 System.out.printf("Passed: %d, Failed %d%n", passed, failed);

    }



这个程序从命令行参数中取出类名，并且遍历此类的所有方法，尝试调用其中被上面的测试annotation类型标注过的方法。在此过程中为了找出哪些方法被 annotation类型标注过，需要使用反射的方式执行此查询。如果在调用方法时抛出异常，此方法被认为已经失败，并打印一个失败报告。最后，打印运行通过/失败的方法数量。
下面文字表示了如何运行这个基于annotation的测试工具：

清单9:

 

Java代码 复制代码
  1.   $ java RunTests Foo    
  2.    Test public static void Foo.m3() failed:    
  3. java.lang.RuntimeException: Boom      
  4.   Test public static void Foo.m7() failed: java.lang.RuntimeException: Crash     
  5.    Passed: 2, Failed 2   
  $ java RunTests Foo 
   Test public static void Foo.m3() failed: 
java.lang.RuntimeException: Boom   
  Test public static void Foo.m7() failed: java.lang.RuntimeException: Crash  
   Passed: 2, Failed 2


四、Annotation分类：

根据annotation的使用方法和用途主要分为以下几类：

1。内建Annotation——Java5.0版在java语法中经常用到的内建Annotation：
@Deprecated用于修饰已经过时的方法；
@Override用于修饰此方法覆盖了父类的方法（而非重载）；
@SuppressWarnings用于通知java编译器禁止特定的编译警告。

下面代码展示了内建Annotation类型的用法：
清单10:

Java代码 复制代码
  1. package com.bjinfotech.practice.annotation;/** * 演示如何使用java5内建的annotation * 参考资料： * http://java.sun.com/docs/books/tutorial/java/javaOO/annotations.html * http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html * http://mindprod.com/jgloss/annotations.html * @author cleverpig * */import java.util.List;public class UsingBuiltInAnnotation {           
  2.   
  3. //食物类         
  4.   class Food{}          
  5.  //干草类          
  6.  class Hay extends Food{}          
  7.  //动物类          
  8.  class Animal{                  
  9.  Food getFood(){                         
  10.   return null;                
  11.    }                  
  12.  //使用Annotation声明Deprecated方法                @Deprecated                
  13.    void deprecatedMethod(){             
  14.       }         
  15.   }          
  16.  //马类-继承动物类          
  17.  class Horse extends Animal{             
  18.       //使用Annotation声明覆盖方法         
  19.           @Override                  
  20.  Hay getFood(){                         
  21.   return new Hay();                 
  22.   }                
  23.    //使用Annotation声明禁止警告               
  24.     @SuppressWarnings({"deprecation","unchecked"})       
  25.  void callDeprecatedMethod(List horseGroup)   
  26.   
  27. {               Animal an=new Animal();       
  28.                     an.deprecatedMethod();     
  29.                       horseGroup.add(an);               
  30.     }        }}  
package com.bjinfotech.practice.annotation;/** * 演示如何使用java5内建的annotation * 参考资料： * http://java.sun.com/docs/books/tutorial/java/javaOO/annotations.html * http://java.sun.com/j2se/1.5.0/docs/guide/language/annotations.html * http://mindprod.com/jgloss/annotations.html * @author cleverpig * */import java.util.List;public class UsingBuiltInAnnotation {        

//食物类      
  class Food{}       
 //干草类       
 class Hay extends Food{}       
 //动物类       
 class Animal{               
 Food getFood(){                      
  return null;             
   }               
 //使用Annotation声明Deprecated方法                @Deprecated             
   void deprecatedMethod(){          
      }      
  }       
 //马类-继承动物类       
 class Horse extends Animal{          
      //使用Annotation声明覆盖方法      
          @Override               
 Hay getFood(){                      
  return new Hay();              
  }             
   //使用Annotation声明禁止警告            
    @SuppressWarnings({"deprecation","unchecked"})    
 void callDeprecatedMethod(List horseGroup)

{               Animal an=new Animal();    
                    an.deprecatedMethod();  
                      horseGroup.add(an);            
    }        }}



2。开发者自定义Annotation：由开发者自定义Annotation类型。
下面是一个使用annotation进行方法测试的sample：

AnnotationDefineForTestFunction类型定义如下：
清单11:

Java代码 复制代码
  1. package com.bjinfotech.practice.annotation;import java.lang.annotation.*;/** * 定义annotation * @author cleverpig * *///加载在VM中，在运行时进行映射@Retention(RetentionPolicy.RUNTIME)//限定此annotation只能标示方法@Target(ElementType.METHOD)public @interface AnnotationDefineForTestFunction{}  
package com.bjinfotech.practice.annotation;import java.lang.annotation.*;/** * 定义annotation * @author cleverpig * *///加载在VM中，在运行时进行映射@Retention(RetentionPolicy.RUNTIME)//限定此annotation只能标示方法@Target(ElementType.METHOD)public @interface AnnotationDefineForTestFunction{}


测试annotation的代码如下：

清单12:

Java代码 复制代码
  1. package com.bjinfotech.practice.annotation;import java.lang.reflect.*;/** * 一个实例程序应用前面定义的Annotation：AnnotationDefineForTestFunction * @author cleverpig * */public class UsingAnnotation {        @AnnotationDefineForTestFunction public static void method01(){}                public static void method02(){}                @AnnotationDefineForTestFunction public static void method03(){                throw new RuntimeException("method03");        }                public static void method04(){                throw new RuntimeException("method04");        }                public static void main(String[] argv) throws Exception{                int passed = 0, failed = 0;                //被检测的类名                String className="com.bjinfotech.practice.annotation.UsingAnnotation";                //逐个检查此类的方法，当其方法使用annotation声明时调用此方法            for (Method m : Class.forName(className).getMethods()) {               if (m.isAnnotationPresent(AnnotationDefineForTestFunction.class)) {                  try {                     m.invoke(null);                     passed++;                  } catch (Throwable ex) {                     System.out.printf("测试 %s 失败: %s %n", m, ex.getCause());                     failed++;                  }               }            }            System.out.printf("测试结果： 通过: %d, 失败： %d%n", passed, failed);        }}  
package com.bjinfotech.practice.annotation;import java.lang.reflect.*;/** * 一个实例程序应用前面定义的Annotation：AnnotationDefineForTestFunction * @author cleverpig * */public class UsingAnnotation {        @AnnotationDefineForTestFunction public static void method01(){}                public static void method02(){}                @AnnotationDefineForTestFunction public static void method03(){                throw new RuntimeException("method03");        }                public static void method04(){                throw new RuntimeException("method04");        }                public static void main(String[] argv) throws Exception{                int passed = 0, failed = 0;                //被检测的类名                String className="com.bjinfotech.practice.annotation.UsingAnnotation";                //逐个检查此类的方法，当其方法使用annotation声明时调用此方法            for (Method m : Class.forName(className).getMethods()) {               if (m.isAnnotationPresent(AnnotationDefineForTestFunction.class)) {                  try {                     m.invoke(null);                     passed++;                  } catch (Throwable ex) {                     System.out.printf("测试 %s 失败: %s %n", m, ex.getCause());                     failed++;                  }               }            }            System.out.printf("测试结果： 通过: %d, 失败： %d%n", passed, failed);        }}


3。使用第三方开发的Annotation类型
这也是开发人员所常常用到的一种方式。比如我们在使用Hibernate3.0时就可以利用Annotation生成数据表映射配置文件，而不必使用Xdoclet。

五、总结：

1。前面的文字说明了annotation的使用方法、定义方式、分类。初学者可以通过以上的说明制作简单的annotation程序，但是对于一些高级的 annotation应用（例如使用自定义annotation生成javabean映射xml文件）还需要进一步的研究和探讨。

2。同时，annotation运行存在两种方式：运行时、编译时。上文中讨论的都是在运行时的annotation应用，但在编译时的annotation应用还没有涉及，因为编译时的annotation要使用annotation processing tool。

涉及以上2方面的深入内容，作者将在后文《Java Annotation高级应用》中谈到。

六、参考资源：
·Matrix-Java开发者社区:http://www.matrix.org.cn
·http://java.sun.com/docs/books/tutorial/java/javaOO/annotations.html
·http://java.sun.com/j2se/1.5.0/docs/guide/apt/GettingStarted.html
·http://java.sun.com/j2se/1.5.0/docs/guide/apt/GettingStarted.html
·http://java.sun.com/j2se/1.5.0/docs/guide/apt/GettingStarted.html
·作者的Blog:http://blog.matrix.org.cn/page/cleverpig

bb413953949
关注
专栏目录
Java Annotation入门
贝高林的Blog
08-28 2651
     在开发Java代码的时候，我们总是习惯于利用注释来表达代码中无法放置的一些东西，其中一些内容被JavaDoc用来产生帮助文档。只有帮助文档还是不够的，在越来越多的情况下，注释中的标记用来表达更多的含义。例如，在使用了xDoclet工具的项目中，特殊用途的各种xDoclet标记用于生成新的代码和对应的配置文件， Hibernate也是借助于@hibernate开头的xDocle来生成代码和
Annotation：基础介绍
wang609128516的专栏
03-19 239
在5.0版之前的Java平台已经具有了一些ad hoc annotation机制。比如，使用transient修饰符来标 识一个成员变量在序列化子系统中应被忽略。而@deprecated这个javadoc tag也是一个ad hoc annotation用来说明一个方法已过时。从Java5.0版发布以来，5.0平台提供了一个正式的annotation功 能：允许开发者定义、使用自己...
效率与质量齐飞，标注工具全面横评
热门推荐
迷若烟雨的专栏
09-04 2万+
人工智能的发展过程中，数据、算力、算法缺一不可。目前，深度学习是AI的主流算法，训练数据在深度学习训练中起到重要作用。很多情况下，“大量数据+普通模型”比“小量数据+高级模型”的准确度要高。
Hibernate Annotation入门
04-09
这就是一个基本的Hibernate Annotation入门示例。通过这种方式，我们可以更方便地管理数据库操作，减少与数据库相关的代码量。同时，由于注解是类型安全的，因此可以降低因配置错误导致的问题。 在实际开发中，你还...
JAVA annotation入门基础
09-05
Java 注解（Annotation）是 Java 语言中的一个重要特性，它允许程序员在源代码中嵌入元数据（metadata）。元数据是关于数据的数据，不直接影响程序的运行，但可以被编译器或运行时环境用来生成代码、执行验证、实现...
Java Annotation入门.doc
05-09
Java 注解（Annotation）是 Java 语言中的一个重要特性，它为元编程提供了强大的支持。注解在 Java 5.0 版本引入，允许开发者定义、使用自定义的注解类型，增强了代码的可读性和可维护性。本文将详细介绍 Java 注解...
Java+Annotation入门[定义].pdf
10-11
Java注解(Annotation)是Java语言的一个重要特性，它为元数据提供了强大的支持。元数据是关于数据的数据，可以用来提供额外的信息，如代码的解释、编译时或运行时的处理指令等。注解在Java中扮演着代码文档、编译器...
spring annotation 入门
02-12
### Spring Annotation 入门 #### 一、Spring 注解概述 Spring 框架自2.0 版本起引入了一系列注解支持，这极大简化了配置管理，并为开发提供了更为简洁灵活的方式。通过注解，可以将业务逻辑与配置分离，减少XML...
Java 注解(Annotation)的基础知识
WWWzq_的博客
12-08 761
Java 注解 Annotaions 简述 Annotaions 简述 官方文档里注解(Annotation)的描述: Annotations, a form of metadata, provide data about a program that is not part of the program itself. Annotations have no direct effect on the operation of the code they annotate. 即: 注解是一种元数据
深入理解Java：注解（Annotation）基本概念
life is wonderful
11-29 2594
原文：http://www.cnblogs.com/peida/archive/2013/04/23/3036035.html        什么是注解（Annotation）： 　　Annotation（注解）就是Java提供了一种元程序中的元素关联任何信息和着任何元数据（metadata）的途径和 方法。Annotion(注解)是一个接口，程序可以通过反射来获取指
深入理解注解
shenyang1991的专栏
05-21 795
什么是注解（Annotation）： 　　Annotation（注解）就是Java提供了一种元程序中的元素关联任何信息和着任何元数据（metadata）的途径和方法。Annotion(注解)是一个接口，程序可以通过反射来获取指定程序元素的Annotion对象，然后通过Annotion对象来获取注解里面的元数据。 　　Annotation(注解)是JDK5.0及以后版本引入的。它可以用于
java注解Annotation，的基本作用和用法的简明介绍
oMangGuoBuDing1的专栏
01-09 732
注解的定义 import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(RetentionPolicy.R
Annotation,注解
qq_37203178的博客
07-17 2296
1、注解，或者叫做 注释，英语单词：annotation 2、注解annotation是一种引用数据类型。编译之后也是生成xxx.class文件 3、怎么自定义注解呢？语法格式？ [修饰符列表] @interface 注解类姓名{ } 4、注解怎么使用，用在什么地方？ - 第一，注解使用时的语法格式是： @注解类型名 - 第二，注解可以出现在类上、属性上、方法上、变量上等.... ...
MiniGui业务开发基础培训-htk
最新发布
11-11
MiniGui业务开发基础培训-htk
com.harmonyos.exception.DiskReadWriteException(解决方案).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
网络分析-Wireshark数据包筛选技巧详解及应用实例
11-11
内容概要：本文档详细介绍了Wireshark软件中各种数据包筛选规则，主要包括协议、IP地址、端口号、包长以及MAC地址等多个维度的具体筛选方法。同时提供了大量实用案例供读者学习，涵盖HTTP协议相关命令和逻辑条件的综合使用方式。 适合人群：对网络安全或数据分析有一定兴趣的研究者，熟悉基本网络概念和技术的专业人士。 使用场景及目标：适用于需要快速准确捕获特定类型网络流量的情况；如网络安全检测、性能优化分析、教学演示等多种实际应用场景。 阅读建议：本资料侧重于实操技能提升，在学习时最好配合实际操作练习效果更佳。注意掌握不同类型条件组合的高级用法，增强问题解决能力。
Java Annotation入门与高级应用详解
Java注解（Annotation）是Java语言自Java 5.0版本引入的一种元数据表示形式，用于向源代码添加额外的信息而不改变其实际行为。对于Java初学者和刚接触annotation的人来说，理解注解的基本概念、用法和分类至关重要。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值