java 注解默认值操作

我就废话不多说了,大家还是直接看代码吧~

package com.zejian.annotationdemo;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* Created by wuzejian on 2017/5/19.
* 数据类型使用Demo
*/

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Reference{
boolean next() default false;
}

public @interface AnnotationElementDemo {
//枚举类型
enum Status {FIXED,NORMAL};

//声明枚举
Status status() default Status.FIXED;

//布尔类型
boolean showSupport() default false;

//String类型
String name()default "";

//class类型
Class<?> testCase() default Void.class;

//注解嵌套
Reference reference() default @Reference(next=true);

//数组类型
long[] value();
}

补充:Java自定义注解中关于string[] value() default {};的理解

java自定义注解

Java注解是附加在代码中的一些元信息,用于一些工具在编译、运行时进行解析和使用,起到说明、配置的功能。

注解不会也不能影响代码的实际逻辑,仅仅起到辅助性的作用。包含在 java.lang.annotation 包中。

1、元注解

元注解是指注解的注解。包括 @Retention @Target @Document @Inherited四种。

1.1、@Retention: 定义注解的保留策略

@Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中,在class字节码文件中不包含
@Retention(RetentionPolicy.CLASS) // 默认的保留策略,注解会在class字节码文件中存在,但运行时无法获得,
@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在,在运行时可以通过反射获取到

注解类:

@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在,在运行时可以通过反射获取到
@Target({ElementType.FIELD,ElementType.METHOD})//定义注解的作用目标**作用范围字段、枚举的常量/方法
@Documented//说明该注解将被包含在javadoc中
public @interface FieldMeta {

 /**
 * 是否为序列号
 * @return
 */
 boolean id() default false;
 /**
 * 字段名称
 * @return
 */
 String name() default "";
 /**
 * 是否可编辑
 * @return
 */
 boolean editable() default true;
 /**
 * 是否在列表中显示
 * @return
 */
 boolean summary() default true;
 /**
 * 字段描述
 * @return
 */
 String description() default "";
 /**
 * 排序字段
 * @return
 */
 int order() default 0;
}

实体类:

public class Anno {

 @FieldMeta(id=true,name="序列号",order=1)
 private int id;
 @FieldMeta(name="姓名",order=3)
 private String name;
 @FieldMeta(name="年龄",order=2)
 private int age;

 @FieldMeta(description="描述",order=4)
 public String desc(){
 return "java反射获取annotation的测试";
 }

 public int getId() {
 return id;
 }
 public void setId(int id) {
 this.id = id;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getAge() {
 return age;
 }
 public void setAge(int age) {
 this.age = age;
 }

}

获取到注解的帮助类:

public class SortableField {

 public SortableField(){}

 public SortableField(FieldMeta meta, Field field) {
 super();
 this.meta = meta;
 this.field = field;
 this.name=field.getName();
 this.type=field.getType();
 }

 public SortableField(FieldMeta meta, String name, Class<?> type) {
 super();
 this.meta = meta;
 this.name = name;
 this.type = type;
 }

 private FieldMeta meta;
 private Field field;
 private String name;
 private Class<?> type;

 public FieldMeta getMeta() {
 return meta;
 }
 public void setMeta(FieldMeta meta) {
 this.meta = meta;
 }
 public Field getField() {
 return field;
 }
 public void setField(Field field) {
 this.field = field;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }

 public Class<?> getType() {
 return type;
 }

 public void setType(Class<?> type) {
 this.type = type;
 }

}

运行时获取注解,首先创建一个基类:

public class Parent<T> {

 private Class<T> entity;

 public Parent() {
 init();
 }

 @SuppressWarnings("unchecked")
 public List<SortableField> init(){
 List<SortableField> list = new ArrayList<SortableField>();
 /**getClass().getGenericSuperclass()返回表示此 Class 所表示的实体(类、接口、基本类型或 void)
 * 的直接超类的 Type(Class<T>泛型中的类型),然后将其转换ParameterizedType。。
 * getActualTypeArguments()返回表示此类型实际类型参数的 Type 对象的数组。
 * [0]就是这个数组中第一个了。。
 * 简而言之就是获得超类的泛型参数的实际类型。。*/
 entity = (Class<T>)((ParameterizedType)this.getClass().getGenericSuperclass())
 .getActualTypeArguments()[0];
// FieldMeta filed = entity.getAnnotation(FieldMeta.class);

 if(this.entity!=null){

 /**返回类中所有字段,包括公共、保护、默认(包)访问和私有字段,但不包括继承的字段
 * entity.getFields();只返回对象所表示的类或接口的所有可访问公共字段
 * 在class中getDeclared**()方法返回的都是所有访问权限的字段、方法等;
 * 可看API
 * */
 Field[] fields = entity.getDeclaredFields();
//
 for(Field f : fields){
 //获取字段中包含fieldMeta的注解
 FieldMeta meta = f.getAnnotation(FieldMeta.class);
 if(meta!=null){
 SortableField sf = new SortableField(meta, f);
 list.add(sf);
 }
 }

 //返回对象所表示的类或接口的所有可访问公共方法
 Method[] methods = entity.getMethods();

 for(Method m:methods){
 FieldMeta meta = m.getAnnotation(FieldMeta.class);
 if(meta!=null){
 SortableField sf = new SortableField(meta,m.getName(),m.getReturnType());
 list.add(sf);
 }
 }
 //这种方法是新建FieldSortCom类实现Comparator接口,来重写compare方法实现排序
// Collections.sort(list, new FieldSortCom());
 Collections.sort(list, new Comparator<SortableField>() {
 @Override
 public int compare(SortableField s1,SortableField s2) {
 return s1.getMeta().order()-s2.getMeta().order();
// return s1.getName().compareTo(s2.getName());//也可以用compare来比较
 }

 });
 }
 return list;

 }
}

创建子类继承基类:

public class Child extends Parent<Anno>{

}

测试类:

public class TestAnnotation {

 @SuppressWarnings({ "unchecked", "rawtypes" })
 public static void main(String[] args) {
 Parent c = new Child();
 List<SortableField> list = c.init();//获取泛型中类里面的注解
 //输出结果
 for(SortableField l : list){
 System.out.println("字段名称:"+l.getName()+"\t字段类型:"+l.getType()+
 "\t注解名称:"+l.getMeta().name()+"\t注解描述:"+l.getMeta().description());
 }
 }
}

1、Annotation的工作原理:

JDK5.0中提供了注解的功能,允许开发者定义和使用自己的注解类型。该功能由一个定义注解类型的语法和描述一个注解声明的语法,读取注解的API,一个使用注解修饰的class文件和一个注解处理工具组成。

Annotation并不直接影响代码的语义,但是他可以被看做是程序的工具或者类库。它会反过来对正在运行的程序语义有所影响。

Annotation可以冲源文件、class文件或者在运行时通过反射机制多种方式被读取。

2、@Override注解:

java.lang

注释类型 Override

@Target(value=METHOD)
@Retention(value=SOURCE)
public @interface Override

表示一个方法声明打算重写超类中的另一个方法声明。如果方法利用此注释类型进行注解但没有重写超类方法,则编译器会生成一条错误消息。

@Override注解表示子类要重写父类的对应方法。

Override是一个Marker annotation,用于标识的Annotation,Annotation名称本身表示了要给工具程序的信息。

下面是一个使用@Override注解的例子:

class A {
 private String id;
 A(String id){
 this.id = id;
 }
 @Override
 public String toString() {
 return id;
 }
}

3、@Deprecated注解:

java.lang

注释类型 Deprecated

@Documented
@Retention(value=RUNTIME)
public @interface Deprecated

用 @Deprecated 注释的程序元素,不鼓励程序员使用这样的元素,通常是因为它很危险或存在更好的选择。在使用不被赞成的程序元素或在不被赞成的代码中执行重写时,编译器会发出警告。

@Deprecated注解表示方法是不被建议使用的。

Deprecated是一个Marker annotation。

下面是一个使用@Deprecated注解的例子:

class A {
 private String id;
 A(String id){
 this.id = id;
 }
 @Deprecated
 public void execute(){
 System.out.println(id);
 }
 public static void main(String[] args) {
 A a = new A("a123");
 a.execute();
 }
}

4、@SuppressWarnings注解:

java.lang

注释类型 SuppressWarnings

@Target(value={TYPE,FIELD,METHOD,PARAMETER,CONSTRUCTOR,LOCAL_VARIABLE})
@Retention(value=SOURCE)
public @interface SuppressWarnings

指示应该在注释元素(以及包含在该注释元素中的所有程序元素)中取消显示指定的编译器警告。注意,在给定元素中取消显示的警告集是所有包含元素中取消显示的警告的超集。例如,如果注释一个类来取消显示某个警告,同时注释一个方法来取消显示另一个警告,那么将在此方法中同时取消显示这两个警告。

根据风格不同,程序员应该始终在最里层的嵌套元素上使用此注释,在那里使用才有效。如果要在特定的方法中取消显示某个警告,则应该注释该方法而不是注释它的类。

@SuppressWarnings注解表示抑制警告。

下面是一个使用@SuppressWarnings注解的例子:

@SuppressWarnings("unchecked")
public static void main(String[] args) {
 List list = new ArrayList();
 list.add("abc");
}

5、自定义注解:

使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口,由编译程序自动完成其他细节。在定义注解时,不能继承其他的注解或接口。

自定义最简单的注解:

public @interface MyAnnotation {
}

使用自定义注解:

public class AnnotationTest2 {
 @MyAnnotation
 public void execute(){
 System.out.println("method");
 }
}

5.1、添加变量:

public @interface MyAnnotation {
 String value1();
}

使用自定义注解:

public class AnnotationTest2 {
 @MyAnnotation(value1="abc")
 public void execute(){
 System.out.println("method");
 }
}

当注解中使用的属性名为value时,对其赋值时可以不指定属性的名称而直接写上属性值接口;除了value意外的变量名都需要使用name=value的方式赋值。

5.2、添加默认值:

public @interface MyAnnotation {
 String value1() default "abc";
}

5.3、多变量使用枚举:

public @interface MyAnnotation {
 String value1() default "abc";
 MyEnum value2() default MyEnum.Sunny;
}
enum MyEnum{
 Sunny,Rainy
}

使用自定义注解:

public class AnnotationTest2 {
 @MyAnnotation(value1="a", value2=MyEnum.Sunny)
 public void execute(){
 System.out.println("method");
 }
}

5.4、数组变量:

public @interface MyAnnotation {
 String[] value1() default "abc";
}

使用自定义注解:

public class AnnotationTest2 {
 @MyAnnotation(value1={"a","b"})
 public void execute(){
 System.out.println("method");
 }
}

6、设置注解的作用范围:

@Documented
@Retention(value=RUNTIME)
@Target(value=ANNOTATION_TYPE)
public @interface Retention

指示注释类型的注释要保留多久。如果注释类型声明中不存在 Retention 注释,则保留策略默认为 RetentionPolicy.CLASS。

只有元注释类型直接用于注释时,Target 元注释才有效。如果元注释类型用作另一种注释类型的成员,则无效。

public enum RetentionPolicy

extends Enum<RetentionPolicy>

注释保留策略。此枚举类型的常量描述保留注释的不同策略。它们与 Retention 元注释类型一起使用,以指定保留多长的注释。

CLASS

编译器将把注释记录在类文件中,但在运行时 VM 不需要保留注释。

RUNTIME

编译器将把注释记录在类文件中,在运行时 VM 将保留注释,因此可以反射性地读取。

SOURCE

编译器要丢弃的注释。

@Retention注解可以在定义注解时为编译程序提供注解的保留策略。

属于CLASS保留策略的注解有@SuppressWarnings,该注解信息不会存储于.class文件。

6.1、在自定义注解中的使用例子:

@Retention(RetentionPolicy.CLASS)
public @interface MyAnnotation {
 String[] value1() default "abc";
}

7、使用反射读取RUNTIME保留策略的Annotation信息的例子:

java.lang.reflect

接口 AnnotatedElement

所有已知实现类:

AccessibleObject, Class, Constructor, Field, Method, Package

表示目前正在此 VM 中运行的程序的一个已注释元素。该接口允许反射性地读取注释。由此接口中的方法返回的所有注释都是不可变并且可序列化的。调用者可以修改已赋值数组枚举成员的访问器返回的数组;这不会对其他调用者返回的数组产生任何影响。

如果此接口中的方法返回的注释(直接或间接地)包含一个已赋值的 Class 成员,该成员引用了一个在此 VM 中不可访问的类,则试图通过在返回的注释上调用相关的类返回的方法来读取该类,将导致一个 TypeNotPresentException。

isAnnotationPresent

boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)

如果指定类型的注释存在于此元素上,则返回 true,否则返回 false。此方法主要是为了便于访问标记注释而设计的。

参数:

annotationClass - 对应于注释类型的 Class 对象

返回:

如果指定注释类型的注释存在于此对象上,则返回 true,否则返回 false

抛出:

NullPointerException - 如果给定的注释类为 null

从以下版本开始:

1.5

getAnnotation

<T extends Annotation> T getAnnotation(Class<T> annotationClass)

如果存在该元素的指定类型的注释,则返回这些注释,否则返回 null。

参数:

annotationClass - 对应于注释类型的 Class 对象

返回:

如果该元素的指定注释类型的注释存在于此对象上,则返回这些注释,否则返回 null

抛出:

NullPointerException - 如果给定的注释类为 null

从以下版本开始:

1.5

getAnnotations

Annotation[] getAnnotations()

返回此元素上存在的所有注释。(如果此元素没有注释,则返回长度为零的数组。)该方法的调用者可以随意修改返回的数组;这不会对其他调用者返回的数组产生任何影响。

返回:

此元素上存在的所有注释

从以下版本开始:

1.5

getDeclaredAnnotations

Annotation[] getDeclaredAnnotations()

返回直接存在于此元素上的所有注释。与此接口中的其他方法不同,该方法将忽略继承的注释。(如果没有注释直接存在于此元素上,则返回长度为零的一个数组。)该方法的调用者可以随意修改返回的数组;这不会对其他调用者返回的数组产生任何影响。

返回:

直接存在于此元素上的所有注释

从以下版本开始:

1.5

下面是使用反射读取RUNTIME保留策略的Annotation信息的例子:

自定义注解:

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
 String[] value1() default "abc";
}

使用自定义注解:

public class AnnotationTest2 {
 @MyAnnotation(value1={"a","b"})
 @Deprecated
 public void execute(){
 System.out.println("method");
 }
}

读取注解中的信息:

public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
 AnnotationTest2 annotationTest2 = new AnnotationTest2();
 //获取AnnotationTest2的Class实例
 Class<AnnotationTest2> c = AnnotationTest2.class;
 //获取需要处理的方法Method实例
 Method method = c.getMethod("execute", new Class[]{});
 //判断该方法是否包含MyAnnotation注解
 if(method.isAnnotationPresent(MyAnnotation.class)){
 //获取该方法的MyAnnotation注解实例
 MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class);
 //执行该方法
 method.invoke(annotationTest2, new Object[]{});
 //获取myAnnotation
 String[] value1 = myAnnotation.value1();
 System.out.println(value1[0]);
 }
 //获取方法上的所有注解
 Annotation[] annotations = method.getAnnotations();
 for(Annotation annotation : annotations){
 System.out.println(annotation);
 }
}

8、限定注解的使用:

限定注解使用@Target。

@Documented
@Retention(value=RUNTIME)
@Target(value=ANNOTATION_TYPE)
public @interface Target

指示注释类型所适用的程序元素的种类。如果注释类型声明中不存在 Target 元注释,则声明的类型可以用在任一程序元素上。如果存在这样的元注释,则编译器强制实施指定的使用限制。 例如,此元注释指示该声明类型是其自身,即元注释类型。它只能用在注释类型声明上:

@Target(ElementType.ANNOTATION_TYPE)
 public @interface MetaAnnotationType {
 ...
 }

此元注释指示该声明类型只可作为复杂注释类型声明中的成员类型使用。它不能直接用于注释:

@Target({})
 public @interface MemberType {
 ...
 }

这是一个编译时错误,它表明一个 ElementType 常量在 Target 注释中出现了不只一次。例如,以下元注释是非法的:

@Target({ElementType.FIELD, ElementType.METHOD, ElementType.FIELD})
 public @interface Bogus {
 ...
 }
public enum ElementType
extends Enum<ElementType>

程序元素类型。此枚举类型的常量提供了 Java 程序中声明的元素的简单分类。

这些常量与 Target 元注释类型一起使用,以指定在什么情况下使用注释类型是合法的。

ANNOTATION_TYPE

注释类型声明

CONSTRUCTOR

构造方法声明

FIELD

字段声明(包括枚举常量)

LOCAL_VARIABLE

局部变量声明

METHOD

方法声明

PACKAGE

包声明

PARAMETER

参数声明

TYPE

类、接口(包括注释类型)或枚举声明

注解的使用限定的例子:

@Target(ElementType.METHOD)
public @interface MyAnnotation {
 String[] value1() default "abc";
}

9、在帮助文档中加入注解:

要想在制作JavaDoc文件的同时将注解信息加入到API文件中,可以使用java.lang.annotation.Documented。

在自定义注解中声明构建注解文档:

@Documented
public @interface MyAnnotation {
 String[] value1() default "abc";
}

使用自定义注解:

public class AnnotationTest2 {
 @MyAnnotation(value1={"a","b"})
 public void execute(){
 System.out.println("method");
 }
}

10、在注解中使用继承:

默认情况下注解并不会被继承到子类中,可以在自定义注解时加上java.lang.annotation.Inherited注解声明使用继承。

@Documented
@Retention(value=RUNTIME)
@Target(value=ANNOTATION_TYPE)
public @interface Inherited

指示注释类型被自动继承。如果在注释类型声明中存在 Inherited 元注释,并且用户在某一类声明中查询该注释类型,同时该类声明中没有此类型的注释,则将在该类的超类中自动查询该注释类型。此过程会重复进行,直到找到此类型的注释或到达了该类层次结构的顶层 (Object) 为止。如果没有超类具有该类型的注释,则查询将指示当前类没有这样的注释。

注意,如果使用注释类型注释类以外的任何事物,此元注释类型都是无效的。还要注意,此元注释仅促成从超类继承注释;对已实现接口的注释无效。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。如有错误或未考虑完全的地方,望不吝赐教。

(0)

相关推荐

  • Java如何使用JSR303校验数据与自定义校验注解

    一.自带校验注解实现数据校验 1.web项目导入依赖 <!-- 该依赖默认导入了 hibernate-validator 所以不需要再单独导入 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> 下图可以看到spring-boot

  • javax.validation自定义日期范围校验注解操作

    实际项目中经常需要对传入的日期时间进行判断,如是否为一年内,几个月之内,几天前,几天之内等等的需求. 如要求前端传入的日期是要为当前日期一年内的某个日期,基于jdk8的LocalDateTime or LocalDate等常用的做法如下: // 前端传字符串如'2020-07-13 09:09:09' springmvc接收并转换为LocalDateTime类型 @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd

  • Java Validation Api如何实现自定义注解

    背景 官方提供的注解多数可以解决现实业务场景中基本业务校验,但有些特殊场景因业务的复杂性,也还是需要在入口处对入参进行各种角度的校验,以求简化业务层的处理,降低业务处理复杂性与方法入口的强约束性. 以上背景,下面就举个简单Demo进行自定义注解校验的实现. 注解定义类 import javax.validation.Constraint; import javax.validation.Payload; import java.lang.annotation.ElementType; impor

  • 解决IDEA导入javaWeb项目注解爆红的问题

    出现此问题的原因一般都是jar包没有被扫描到: 解决办法: 1.在idea的设置里面如图: 如果有多个jar包文件夹就都给加进来 2.一般jdk版本正确的话,按照1的操作完之后,再重新编译一下就应该好了,如果还有问题,那就是jdk版本有问题了,那就更换一下jdk版本试试,如图 选择你本地的jdk路径,点击ok 修改这两个地方,然后点击apply,再点击ok.这样应该就好了. 到此这篇关于解决IDEA导入javaWeb项目注解爆红的问题的文章就介绍到这了,更多相关IDEA导入javaWeb项目注解

  • Java注解Annotation原理及自定义注解代码实例

    什么是注解? 对于很多初次接触的开发者来说应该都有这个疑问?Annontation是Java5开始引入的新特征,中文名称叫注解.它提供了一种安全的类似注释的机制,用来将任何的信息或元数据(metadata)与程序元素(类.方法.成员变量等)进行关联.为程序的元素(类.方法.成员变量)加上更直观更明了的说明,这些说明信息是与程序的业务逻辑无关,并且供指定的工具或框架使用. Annontation像一种修饰符一样,应用于包.类型.构造方法.方法.成员变量.参数及本地变量的声明语句中. Java注解是

  • Java元注解meta-annotation和依赖注入详解

    这篇文章既介绍一个技术,又记录一个逐渐探索发现的过程,以供大家参考. 缘起 注意到Java的依赖注入DI规范(起初以为是CDI规范,然后发现是DI规范)有个叫@Qualifier的注解,用于当一个interface或base class有多个实现类时,能选择其中一个实现.如不用这一注解,一般的(按类型)注入就会报错说"不知道要在多个实现中选哪一个".这一注解可以放在一个自定义注解上(例如@MyPreferredImplementation),从而将自定义注解变成一个qualifier

  • 谈谈Java中自定义注解及使用场景

    Java自定义注解一般使用场景为:自定义注解+拦截器或者AOP,使用自定义注解来自己设计框架,使得代码看起来非常优雅.本文将先从自定义注解的基础概念说起,然后开始实战,写小段代码实现自定义注解+拦截器,自定义注解+AOP. 一. 什么是注解(Annotation) Java注解是什么,以下是引用自维基百科的内容 Java注解又称Java标注,是JDK5.0版本开始支持加入源代码的特殊语法元数据. Java语言中的类.方法.变量.参数和包等都可以被标注.和Javadoc不同,Java标注可以通过反

  • java 注解默认值操作

    我就废话不多说了,大家还是直接看代码吧~ package com.zejian.annotationdemo; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; /** * Created by wuzejian on 2017

  • 动态设置django的model field的默认值操作步骤

    问题背景 django的model field需要动态设置默认值,具体案例如下: 原始代码如下,model是Application,其中字段ignore_fort的默认值设置为False class Application(TimestampedModel): name = models.CharField(max_length=255, null=True) ignore_fort = models.BooleanField(default=False) 然而现在有这样一个需求:default

  • Vue props中Object和Array设置默认值操作

    我就废话不多说,看代码吧~ seller: { type: Object, default() { return {} } } seller: { type: Object, default: function () { return {} } } 当父组件没有传这个值或者值是空时,输出的话,返回: 下面这种是错误的 seller: { type: Object, default: () => {} } 当父组件没有传这个值或者值是空时,输出的话,这时是返回underfind,在template

  • mysql查询的时候给字段赋默认值操作

    需求 查询某个字段的时候需要给一个字段同样的值. 这个值你可以写死,也可以从数据库获取 1.写死值 SELECT mfr_id AS mfrId, mfr_name AS mfrName, IFNULL(NULL, 587694978080178176) AS suppId FROM mater_prod materProd 查询结果 2.从数据库获取值 SELECT mfr_id AS mfrId, mfr_name AS mfrName, IFNULL(NULL, mfr_id) AS su

  • Java八种基本变量作为类的成员变量的默认值操作

    目录 Java类成员变量的默认值 下面我们看看我们的八种数据类型的默认值是什么样的 总结 boolean型变量的默认值问题 1.首先分析Java中的三种不同变量的区别 2.然后判断boolean型变量的类型 Java类成员变量的默认值 基本数据类型作为类的成员变量时可以不赋予初值,在方法中输出也不会报错. 下面我们看看我们的八种数据类型的默认值是什么样的 上代码 package objectandclass; import java.awt.SecondaryLoop; public class

  • Spring boot Jpa添加对象字段使用数据库默认值操作

    目录 项目搭建 代码 配置文件 spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=truespring.datasource.username=rootspring.datasource.password=rootspring.datasource.driver-class-name=com.

  • Spring boot Jpa添加对象字段使用数据库默认值操作

    目录 项目搭建 错误测试 解决问题 jpa做持久层框架,项目中数据库字段有默认值和非空约束,这样在保存对象是必须保存一个完整的对象,但在开发中我们往往只是先保存部分特殊的字段其余字段用数据库默认值,要是直接用idea生成实体类操作的话会报SQLIntegrityConstraintViolationException异常,我们需要jpa根据传入的对象存在的属性动态生成更新和添加语句需要给实体类添加@DynamicUpdate,@DynamicInsert根据对象属性生成动态update和inse

  • Go语言设置JSON的默认值操作

    给需要设置的JSON字段初试化你想设置的值就OK. 比如我想让[]string类型的字段的默认值是[],而不是nil,那我就make([]string, 0)赋值给该字段. 转成JSON输出后,就是[]. 1. 示例代码 这是没有初始化的代码.默认值是nil. package main import ( "encoding/json" "fmt" "net" "net/http" ) type JsonTest struct

  • MySQL建表设置默认值/取值范围的操作代码

    目录 MySQL建表设置默认值/取值范围 一.设置默认值 二.设置取值范围 MySQL创建表时字符串的默认值 操作: 结论: MySQL建表设置默认值/取值范围 一.设置默认值 设置默认值采用default,如代码所示: 二.设置取值范围 设置取值范围采用check,如代码所示: create table student( id int not null primary key auto_increment, name varchar(32) not null, sex varchar(8) d

  • java注解之运行时修改字段的注解值操作

    今天遇到需求:导入Excel时候列头会发生变化,客户是大爷要求你改代码, 导入Excel是用easypoi做的,识别表头是用注解@Excel(name = "xxx")通过这个name来匹配 那你表头要动,我这个注解是硬编码 所以就有动态设置这个表头 public class JavaVo{ @Excel(name = "xxx") private String userName; //省略getset方法 } ExcelImportUtil.importExcel

随机推荐