Day10 enumeration class and annotation

1. Enumeration class

1. Custom enumeration class

1. Member variables cannot be changed private final

2. Private constructor private

3. example public static final

4.get Method

5.toString Method

package com.zkx.enumtest;

/**
 * @author zkx
 * @create 2022-02-14 13:05
 */

public class EnumTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        System.out.println(spring);//Season{SEASONNAME='spring', SEASONDESC=' spring '}
        System.out.println(spring.getSEASONNAME()+","+spring.getSEASONDESC());//spring, spring 
    }


}

// Create an enumeration class 
class Season{
    //1. First, the member variables cannot be changed  private final
    private final String SEASONNAME;// Season name 
    private final String SEASONDESC;// Seasonal description 

    //2. Constructor privatization  private
    private Season(String name , String desc){
        this.SEASONNAME=name;
        this.SEASONDESC=desc;
    }

    //3. The instance is declared as public static final
    public static final Season SPRING = new Season("spring"," spring ");
    public static final Season SUMMER = new Season("summer"," summer ");
    public static final Season AUTUMN = new Season("autumn"," autumn ");
    public static final Season WINTER = new Season("winter"," winter ");

    //4.get Method , Because it is a private and unchangeable member variable , So there was no set Method 
    public String getSEASONNAME() {
        return SEASONNAME;
    }

    public String getSEASONDESC() {
        return SEASONDESC;
    }

    //5. rewrite toString Method 
    @Override
    public String toString() {
        return "Season{" +
                "SEASONNAME='" + SEASONNAME + '\'' +
                ", SEASONDESC='" + SEASONDESC + '\'' +
                '}';
    }
}

 2. Use enum Define an enumeration class

1. The first line must be an example , And public static final Automatic addition , Comma split , End of semicolon

2. The member variable is private final

3. Constructor must private

4.get Method

5. rewrite toString Method

Method ：

1.values（） Returns all instances of the enumeration class

2.valueOf（String str） Convert the string to the corresponding enumeration class , A string is the name of an enumerated class object , Otherwise, the report will be wrong

3.toString（） Returns the name of the current enumeration class object

package com.zkx.enumtest;

/**
 * @author zkx
 * @create 2022-02-14 17:26
 */
public class EnumTest1 {
    public static void main(String[] args) {
        Season1 spring = Season1.SPRING;
        System.out.println(spring);//Season1{seasonName='spring', seasonDesc=' spring '}
        System.out.println("*************************");

        //values() Method : Returns all instances of an enumerated class 
        Season1 [] values = Season1.values();
        for (int i = 0; i < values.length; i++) {
            System.out.println(values[i]);
        }
        System.out.println("*************************");

        //valueOf(String str): Convert the string to the corresponding enumeration class , A string is the name of an enumerated class object 
        Season1 summer = Season1.valueOf("SUMMER");
        System.out.println(summer);

    }
}

// Use enum Define an enumeration class 
enum Season1{// Cannot inherit other classes 

    //1. The instance must be on the first line , comma , Division , A semicolon ; ending , Instances are automatically added public static final
    SPRING("spring"," spring "),
    SUMMER("summer"," summer "),
    AUTUMN("autumn"," autumn "),
    WINTER("winter"," winter ");

    //2. Member variables private final
    private final String seasonName;
    private final String seasonDesc;

    //3. Constructor must private
    private Season1(String seasonName,String seasonDesc){
       this.seasonName=seasonName;
       this.seasonDesc=seasonDesc;
    }

    //4.get Method 
    public String getSeasonName() {
        return seasonName;
    }

    public String getSeasonDesc() {
        return seasonDesc;
    }

    //5. rewrite toString Method 
    @Override
    public String toString() {
        return "Season1{" +
                "seasonName='" + seasonName + '\'' +
                ", seasonDesc='" + seasonDesc + '\'' +
                '}';
    }
}

3. Use enum Define enumeration classes to implement interfaces

1. Enumeration class can implement interface

2. If all objects implement the same abstract methods of interfaces , You can override it once in the enumeration class

3. If all objects implement different abstract methods of interfaces , Override the interface abstract method in each instance of the enumerated class object

package com.zkx.enumtest;

/**
 * @author zkx
 * @create 2022-02-14 22:24
 */
public class EnumTest2 {
    public static void main(String[] args) {
        Time time1 = Time.AFTERNOON;
        time1.show();

    }
}

// Enumeration class implements the interface 
interface Info{
    void show();
}
// Enumeration class 
enum Time implements Info{

    //1. Examples must be written on the first line 
    MORNING("morning"," morning "){
        @Override
        public void show() {
            System.out.println("zzz");
        }
    },
    AFTERNOON("afternoon"," Afternoon "){
        @Override
        public void show() {
            System.out.println("xxx");
        },
    },
    EVENING("evening"," evening "){
        @Override
        public void show() {
            System.out.println("www");
        }
    };


    //2. Member variables private final
    private final String timeName;
    private final String timeDesc;

    //3. Constructors private
    private Time(String timeName,String timeDesc){
        this.timeName = timeName;
        this.timeDesc = timeDesc;
    }

    //4.get Method 
    public String getTimeName() {
        return timeName;
    }

    public String getTimeDesc() {
        return timeDesc;
    }

    //5.toString Method 
    @Override
    public String toString() {
        return "Time{" +
                "timeName='" + timeName + '\'' +
                ", timeDesc='" + timeDesc + '\'' +
                '}';
    }


}

---

2. annotation Annotation

 Example 1 ： Generate documentation related annotations

@author Indicate the author who developed the module , Use... Between multiple authors , Division

@version Indicate the version of the module

@see Refer to steering , That is, related topics

@since From which version to add

@param Description of a parameter in the method , You can't write without parameters

@return Description of the return value of the method , If the return value type of the method is void Can't write

@exception Describe the exceptions that may be thrown by the method , If the method doesn't work throws An exception thrown explicitly cannot be written

among

@param @return and @exception All three tags are method only .

@param The format of ：@param The name of the parameter parameter types Parameter description

@return The format of ：@return return type Return value description

@exception The format of ：@exception Exception types Exception description

@param and @exception You can have more than one side by side

 Example 2 ： Format check at compile time (JDK Built in three basic annotations )

@Override: Qualify override parent method , This annotation can only be used for methods

@Deprecated: Used to represent the decorated element ( class , Such method ) Deprecated . Usually because

The modified structure is dangerous or there is a better choice

@SuppressWarnings: Suppress compiler warnings

 Example 3 ： Trace code dependencies , Implement alternative profile functions

2.1 Custom annotation

https://blog.csdn.net/PorkBird/article/details/113696306

2.2 Yuan notes

An annotation that modifies an annotation ,4 A meta note

1. @Retention: Can only be used to decorate one Annotation Definition , Used to specify the Annotation The life of

cycle

RetentionPolicy.SOURCE: Valid in source file （ That is, source file retention ）, The compiler simply discards comments for this strategy

RetentionPolicy.CLASS: stay class Valid in file （ namely class Retain ） , When running Java The program , JVM Comments will not be retained . This is the default

RetentionPolicy.RUNTIME: Valid at run time （ That is, keep it at run time ）, When running Java The program , JVM Meeting Keep the comments . The program can get this comment through reflection .

 

2.@Target: Used to modify Annotation Definition , Used to specify decorated Annotation Which program elements can be used to decorate . @Target It also contains a name called value Member variables of .

3.@Documented: Used to specify the Annotation Embellished Annotation Class will be javadoc Tool extraction as file . By default ,javadoc It doesn't include comments .

 Defined as Documented The annotation for must be set Retention The value is RUNTIME.

4.@Inherited: Decorated with it Annotation Will have inheritance . If a class uses the @Inherited Embellished Annotation, The subclass will automatically have the annotation .

 such as ： If you mark it with @Inherited Custom annotations for annotations are annotated at the class level , Subclasses can Inherit comments at the parent class level

 Practical application , Use less

Other annotation knowledge ：

https://blog.csdn.net/PorkBird/article/details/113696306