特殊类

一、内部类

1、内部类的概念

• 当一个类定义出现在另一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部内（Outer）。
• 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码快、内部类。

2、实际作用

• 当一个类存在的价值仅仅是为摸一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法。

3、内部类的分类

• 普通内部类：直接将一个类的定义放在另一个类的类体中。
• 静态内部类：使用static关键字修饰内部类，隶属于类层级。
• 局部内部类：直接将一个类的定义方在方法体的内部时。
• 匿名内部类：就是指没有名字的内部类。

4、普通（成员）内部类

• 普通（成员）内部类的格式

  • 访问修饰符 class 外部类的类名 {

    ​ 访问修饰符 class 内部类的类名 {

    ​ 内部类的类体；

    ​ }

    }

  package com;
  
  /**
   * 
   * @author 明台见性
   *编程实现普通内部类的定义和使用   -文档注释
   *
   */
  public class NormalOuter {
  
  	private int cnt = 1;
  	
  	//定义普通内部类,隶属于外部内成员，并且是对象层级
  	public class NormalInner {
  		
  		private int ia = 2;
  		
  		public NormalInner() {
  			
  			System.out.println("普通内部类的构造方法体执行到了！");
  		}
  		
  		public void show() {
  			
  			System.out.println("外部类中变量cnt的数值为：" + cnt);
  			System.out.println("内部类中变量ia的数值为：" + ia);
  		}
  	}
  }
  
  
  
  
  package com;
  
  public class NormalOuterTest {
  
  	public static void main(String[] args) {
  		
  		//声明NormalOuter类型的引用指向该类型的对象
  		NormalOuter no = new NormalOuter();
  		//声明NormalOuter内部类的引用指向内部类的对象
  		NormalOuter.NormalInner ni = no.new NormalInner();
  		//调用内部类的show方法
  		ni.show();
  	}
  }
  /*
  输出：
  普通内部类的构造方法体执行到了！
  外部类中变量cnt的数值为：1
  内部类中变量ia的数值为：2
  
  */
  

• 普通内部类的使用方式

  • 普通内部类和普通类一样可以定义成员变量、成员方法以及构造方法等。
  • 普通内部类和普通类一样可以使用final或者abstract关键字修饰。
  • 普通内部类还可以使用private或者protected关键字进行修饰。
  • 普通内部类需要使用外部类对象来创建对象。
  • 如果内部类访问外部类中与本类内部同名的成员变量或者方法时，需要使用this关键字。

package com;

/**
 * 
 * @author 明台见性
 *编程实现普通内部类的定义和使用   -文档注释
 *
 */
public class NormalOuter {

	private int cnt = 1;
	
	//定义普通内部类,隶属于外部内成员，并且是对象层级
	/*private*/public final class NormalInner {
		
		private int ia = 2;
		private int cnt = 3;
		
		public NormalInner() {
			
			System.out.println("普通内部类的构造方法体执行到了！");
		}
		
		public void show() {
			
			System.out.println("外部类中变量cnt的数值为：" + cnt);
			System.out.println("内部类中变量ia的数值为：" + ia);
		}
		
		public void show2(int cnt) {
			
			System.out.println("形参变量cnt = " + cnt);//局部优先原则 
			System.out.println("内部类中cnt = " + this.cnt);//输出内部类的cnt
			System.out.println("外部类中cnt = " + NormalOuter.this.cnt);//输出外部类的cnt
		}
	}
}


package com;

public class NormalOuterTest {

	public static void main(String[] args) {
		
		//声明NormalOuter类型的引用指向该类型的对象
		NormalOuter no = new NormalOuter();
		//声明NormalOuter内部类的引用指向内部类的对象
		NormalOuter.NormalInner ni = no.new NormalInner();
		//调用内部类的show方法
		ni.show();
		System.out.println("---------------------------");
		ni.show2(4);
	}
}


/*
输出：
普通内部类的构造方法体执行到了！
外部类中变量cnt的数值为：3
内部类中变量ia的数值为：2
---------------------------
形参变量cnt = 4
内部类中cnt = 3
外部类中cnt = 1
*/

5、静态内部类

• 静态内部类的格式

  • 访问修饰符 class 外部类名 {

    ​ 访问修饰符 static class 内部类名 {

    ​ 内部类的类体；

    ​ }

    }

package com;

/**
 * 实现静态内部类的定义和使用
 * */
public class StaticOuter {

	private int cnt = 1;
	private static int snt = 2;
	
	/**
	 * 定义静态内部类  有static关键字修饰隶属于类层级
	 */
	
	public static class StaticInner {
		
		private int ia = 3;
		public StaticInner() {
			
			System.out.println("静态内部类的构造方法！");
		}
		
		public void show() {
			
			System.out.println("ia = " + ia);
			System.out.println("打印外部类中的是snt = " + snt);
			// Error:静态上下文中不能访问非静态的成员，因此此时可能还没有创建对象
			//System.out.println("打印外部类中的是cnt = " + cnt); 
		}
	}
}


package com;

public class StaticOuterTest {

	public static void main(String[] args) {
		
		//声明StaticInner的引用指向该类型的对象
		StaticOuter.StaticInner si = new StaticOuter.StaticInner();
		si.show();
	}
}

/*
输出：
静态内部类的构造方法！
ia = 3
打印外部类中的是snt = 2
*/

• 静态内部类的使用方式
  • 静态内部类不能直接访问外部类的非静态成员
  • 静态内部类可以直接创建对象
  • 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。

package com;

/**
 * 实现静态内部类的定义和使用
 * */
public class StaticOuter {

	private int cnt = 1;      //隶属于对象层级
	private static int snt = 2;//隶属于类层级
	
	public /*static*/ void show() {
		
		System.out.println("外部类的show方法！");
	}
	
	/**
	 * 定义静态内部类  有static关键字修饰隶属于类层级
	 */
	public static class StaticInner {
		
		private int ia = 3;
		private static int snt = 4; //隶属于内部类层级
		
		public StaticInner() {
			
			System.out.println("静态内部类的构造方法！");
		}
		
		public void show() {
			
			System.out.println("ia = " + ia);
			System.out.println("打印外部类中的是snt = " + snt);
			// Error:静态上下文中不能访问非静态的成员，因此此时可能还没有创建对象
			//System.out.println("打印外部类中的是cnt = " + cnt); 
		}
		
		public void show2(int snt) {
			
			System.out.println("snt = " + snt);
			System.out.println("打印内部类中的是snt = " + StaticInner.snt);
			System.out.println("打印外部类中的是snt = " + StaticOuter.snt);
			//如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问。
			//StaticOuter.show();
			new StaticOuter().show();
		}
	}
}


package com;

public class StaticOuterTest {

	public static void main(String[] args) {
		
		//声明StaticInner的引用指向该类型的对象  静态内部类可以直接创建对象
		StaticOuter.StaticInner si = new StaticOuter.StaticInner();
		si.show();
		System.out.println("------------------");
		si.show2(5);
	}
}

/*
输出：
静态内部类的构造方法！
ia = 3
打印外部类中的是snt = 4
------------------
snt = 5
打印内部类中的是snt = 4
打印外部类中的是snt = 2
外部类的show方法！
*/

6、局部（方法）内部类

• 局部内部类的格式

  访问修饰符 class 外部类的类名 {

  ​ 访问修饰符 返回值类型 成员方法（形参列表） {

  ​ class 内部类的类名 {

  ​ 内部类的类体；

  ​ }

  ​ }

  }

package com;

/**
 * 编程实现局部内部类的定义和使用
 * */
public class AreaOuter {

	private int cnt = 1;
	
	public void show() {
		
		//定义局部内部类，只在当前方法体的内部好使
		class AreaInner {
			
			private int ia = 2;
			
			public AreaInner() {
				
				System.out.println("局部内部类的构造方法！");
			}
			
			public void test() {
				
				System.out.println("ia = " + ia);//2
				System.out.println("cnt = " + cnt);
			}
		}
		
		//声明局部内部类的引用指向局部内部类的对象
		AreaInner ai = new AreaInner();
		ai.test();
	}
}


package com;

public class AreaOuterTest {

	public static void main(String[] args) {
		
		//声明外部类的引用指向外部类的对象
		AreaOuter ao = new AreaOuter();
		//通过show方法的调用实现局部内部类的使用
		ao.show();
	}
}

/*
输出：
局部内部类的构造方法！
ia = 2
cnt = 1
*/

• 局部内部类的使用方式
  • 局部内部类只能在该方法的内部使用。
  • 局部内部类可以在方法体内部直接创建对象。
  • 局部内部类不能直接使用访问控制符和static关键字修饰符。
  • 局部内部类可以直接使用外部方法的局部变量，但是必须是final的。有局部内部类和局部变量的声明周期不同所致。

package com;

/**
 * 编程实现局部内部类的定义和使用
 * */
public class AreaOuter {

	private int cnt = 1;
	
	public void show() {
		
		//定义一个局部变量进行测试  从Java8开始默认理解为final关键字修饰的变量
		//局部内部类可以直接使用外部方法的局部变量，但是必须是final的。有局部内部类和局部变量的声明周期不同所致。
		final int ic = 4;
		
		//定义局部内部类，只在当前方法体的内部好使
		class AreaInner {
			
			private int ia = 2;
			
			public AreaInner() {
				
				System.out.println("局部内部类的构造方法！");
			}
			
			public void test() {
				
				System.out.println("ia = " + ia);//2
				System.out.println("cnt = " + cnt);
				//ic = 5;
				System.out.println("ic = " + ic);
			}
		}
		
		//声明局部内部类的引用指向局部内部类的对象
		AreaInner ai = new AreaInner();
		ai.test();
	}
}

7、回调模式的概念

• 回调模式是指：如果一个方法的参数是接口类型，则在调用该方法时，需要创建并传递一个实现此接口类型的对象；而该方法在运行时会调用到参数对象中所实现的方法（接口中定义的）。

package com;

public interface AnonymousInterface {

	public abstract void show();
}


package com;

public class AnonymousInterfaceImpl implements AnonymousInterface{

	@Override
	public void show() {
		
		System.out.println("接口的实现类！");
	}
}


package com;

public class AnonymousInterfaceTest {

	//假设已有下面的方法，请问如何调用下面的方法
	//AnonymousInterface ai = new AnonymousInterfaceImpl();
	//接口类型的引用指向实现类型的对象，形成了多态
	public static void test(AnonymousInterface ai) {
		
		//编译阶段调用父类版本，运行阶段调用子类重写的版本
		ai.show();
	}
	public static void main(String[] args) {
		
		//AnonymousInterfaceTest.test(new AnonmousInterface());// Error：接口不能实例化
		AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());
	}
}

/*
输出：
接口的实现类！
*/

开发经验分享

• 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：
• 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递
• 使用上述匿名内部类的语法格式得到接口/类类型的引用即可。

8、匿名内部类的格式

• 接口/父类类型 引用变量名 = new接口/父类类型（）{方法重写}

package com;

public interface AnonymousInterface {

	public abstract void show();
}


package com;

public class AnonymousInterfaceTest {

	//假设已有下面的方法，请问如何调用下面的方法
	//AnonymousInterface ai = new AnonymousInterfaceImpl();
	//接口类型的引用指向实现类型的对象，形成了多态
	public static void test(AnonymousInterface ai) {
		
		//编译阶段调用父类版本，运行阶段调用子类重写的版本
		ai.show();
	}
	public static void main(String[] args) {
		
		//AnonymousInterfaceTest.test(new AnonmousInterface());// Error：接口不能实例化
		AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());
		
		System.out.println("------------------------------");
		//使用匿名内部类的语法格式得到接口类型的引用
		//格式：接口/父类类型 引用变量名 = new接口/父类类型（）{方法的重写}
		AnonymousInterface ai1 = new AnonymousInterface() {
			
			@Override
			public void show() {
				
				System.out.println("匿名内部类就是这么玩的，虽然你很抽象！");
			}
		};
		ai1.show();
		
		//从Java8开始提出新特性lamda表达式可以简化上述代码，格式：（参书列表） -> {方法体}
		AnonymousInterface ai2 = () -> System.out.println("lamda表达式原来是如此简单！");
		AnonymousInterfaceTest.test(ai1);
	}
}

/*
输出：
接口的实现类！
------------------------------
匿名内部类就是这么玩的，虽然你很抽象！
匿名内部类就是这么玩的，虽然你很抽象！
*/

二、枚举

1、枚举的基本概念

• 一年中的所有季节：春季、夏季、秋季、冬季
• 所有的性别：男、女
• 键盘上的所有方向键：向上、向下、向左、向右
• 在日常生活中这些事务的取值只有明确的几个固定值，此时描述这些事物的所有值都可以一一列举出来。而这个列举出来的类型就叫做枚举类型。

2、枚举的定义

• 使用public static final表示常量较为繁琐，使用enum关键字来定义枚举类型取代常量，枚举类型是从Java5开始增加的一种引用数据类型。
• 枚举值就是当前类的类型，也就是指向本类的对象，默认使用public static final关键字共同修饰。因此采用高枚举类型.的方式调用。
• 枚举类可以自定义构造方法，但是构造方法的修饰符必须是private，默认也是私有的。

package com;

/**
 * 编程实现所有方向的枚举，所有方向：向上、向下、向左、向右
 * 枚举类型要求所有的枚举值必须放在枚举类型的最前面
 * */
public enum DirectionEnum {

	//声明本类类型的引用指向本类类型的对象
	UP("向上"), DOWN("向下"), LEFT("向左"), RIGHT("向右");
	
	private final String desc;//用于描述方向字符串的成员变量
	
	//通过构造方法实现成员变量的初始化，更加灵活
	//私有化构造方法，此时构造方法只能在本类中使用
	private DirectionEnum(String desc) {
		
		this.desc = desc;
	}
	
	//通过公有的get方法可以在本类的外部访问该类的成员变量的数值
	public String getDesc() {
		
		return desc;
	}
}



package com;

public class DirectionTest {

	public static void main(String[] args) {
		
		//声明Direction类型的引用指向该类型的对象
		/*Direction d1 = new Direction("向上");
		System.out.println("获取到的字符串是：" + d1.getDesc());//向上
		
		Direction d2 = new Direction("向下");
		System.out.println("获取到的字符串是：" + d2.getDesc());//向下
		
		Direction d3 = new Direction("向左");
		System.out.println("获取到的字符串是：" + d3.getDesc());//向左
		
		Direction d4 = new Direction("向右");
		System.out.println("获取到的字符串是：" + d4.getDesc());//向右
		
		Direction d5 = new Direction("向前");
		System.out.println("获取到的字符串是：" + d5.getDesc());//向前*/
		//Direction.UP = 2; Error:类型不匹配
		//Direction d2 = null;
		//Direction.UP = d2;Error:final关键字修饰
		Direction d1 = Direction.UP;
		System.out.println("获取到的方向是：" + d1.getDesc());//向上
		
		System.out.println("----------------------------");
		//使用一下Java5开始的枚举类型
		DirectionEnum de = DirectionEnum.DOWN;
		System.out.println("获取到的方向是：" + de.getDesc());//向下
	}
}

自定义类和枚举类在switch中的使用

package com;

public class DirectionUseTest {

	//自定义静态方法实现根据参数指定的字符串内容来打印具体的方向信息
	public static void test1(String str) {
		
		switch(str) {
		
		case "向上" : 
			System.out.println("抬头望明月!"); break;
		case "向下" : 
			System.out.println("低头思故乡！"); break;
		case "向左" :
			System.out.println("左牵黄！"); break;
		case "向右" :
			System.out.println("右擎苍"); break;
		default:
			System.out.println("没有这样的方向");
		}
	}
	
	//自定义静态方法实现根据参数指定的枚举类型来打印具体的方向信息
		public static void test1(DirectionEnum de) {
			
			switch(de) {
			
			case UP : 
				System.out.println("抬头望明月!"); break;
			case DOWN : 
				System.out.println("低头思故乡！"); break;
			case LEFT :
				System.out.println("左牵黄！"); break;
			case RIGHT :
				System.out.println("右擎苍"); break;
			default:
				System.out.println("没有这样的方向");
			}
		}
		
	public static void main(String[] args) {
		
		DirectionUseTest.test1(Direction.UP.getDesc());
		
		System.out.println("------------------------");
		DirectionUseTest.test1(DirectionEnum.DOWN);
	}
}

3、Enum类的概念和方法

• 所有的枚举类都继承自java.lang.Enum类，常用的方法如下：

static T[] values()           返回当前枚举类中的所有对象
String toString()             返回当前枚举类对象的名称
int ordinal()                 获取枚举对象在枚举类中的索引位置
static T valueOf(String str)  将参数指定的字符串名转为当前枚举类的对象
int compareTo(E o)            比较两个枚举对象在定义时的顺序

4、枚举类实现接口的方式

• 枚举类实现接口后需要重写抽象方法，而重写方法的方式有两种：重写一个，或者每个对象重写。

三、注解

1、注解的基本概念

• 注解（Annotation）又叫标注，是从Java5开始增加的一种引用数据类型。
• 注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载以及运行时执行指定的处理。

2、注解的语法格式

• 访问修饰符 @interface 注解名称 {

  ​ 注解成员；

  }

• 自定义注解自动继承java.lang.annotation.Annotation接口。

• 通过@注解名称的方式可以修饰包、类、成员方法、成员变量、构造方法、参数、局部变量的声明等。

3、注解的使用方式

• 注解体中只有成员变量没有成员方法，而注解的成员变量以“无形参的方式”形式来声明，其方法名定义了该成员变量的名字，其返回值定义了该成员变量的类型。
• 如果注解只有一个参数成员，建议使用参数名为value，而类型只能是八种基本数据类型、String类型、Class类型、enum类型以及Annotation类型。

package com;

//若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {

	//如果注解只有一个参数成员，建议使用参数名为value，
	//而类型只能是八种基本数据类型、String类型、Class类型、enum类型以及Annotation类型。
	//声明一个String类型的成员变量，名字叫做value default 默认值。在注解时不需要再次给值
	public String value() default "123";
	public String value2(); 
}



package com;

//表示将标签MyAnnotation贴在Person类的代码中
@MyAnnotation(/*value = "hello", */value2 = "world")
public class Person {

	private String name;
	private int age;
}

四、元注解

1、元注解的概念

• 元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能应用到其他的注解上面。
• 元注解主要有：@Retention、@Documented、@Target、@Inherited、@Repeatable

2、元注解@Retention

• @Retention应用到一个注解上用于说明该注解的生命周期，取值如下：
  • RetentionPolicy.SOURCE注解只在源码阶段保留，在编译器进行编译时，它将被丢弃忽视。
  • RetentionPolicy.CLASS注解纸杯保留到编译进行的时候，它并不会被加载到JVM中，默认方式。
  • RetentionPolicy.RUNTIME注解可以保留到程序运行的时候，它会被加载到JVM中，所以在程序运行时可以获取到它们。

package com;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;


//@Retention(RetentionPolicy.SOURCE) //表示下面的注解在源代码中有效
//@Retention(RetentionPolicy.CLASS)//表示下面的注解在字节码文件中有效，默认方式
@Retention(RetentionPolicy.RUNTIME)//表示下面的注解在运行时有效

//若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {

	//如果注解只有一个参数成员，建议使用参数名为value，
	//而类型只能是八种基本数据类型、String类型、Class类型、enum类型以及Annotation类型。
	//声明一个String类型的成员变量，名字叫做value default 默认值。在注解时不需要再次给值
	public String value() default "123";
	public String value2(); 
}

3、元注解@Documented

• 使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档，而该工具抽取时默认不包括直接内容。
• @Documented用于指定被该注解将被javadoc工具提取成文档
• 定义为@Documented的注解必须设置Retention值为RUNTIME。

4、元注解@Target

• @Target用于指定被修饰的注解能用于哪些元素的修饰，取值如下：

ElementType.ANNOTATION_TYPE     可以给一个注解进行注解
ElementType.CONSTRUCTOP         可以给构造方法进行注解
ElementType.FIELD               可以给属性进行注解
ElementType.LOCAL_VARIABLE      可以给局部变量进行注解
ElementType.METHOD              可以给方法进行注解
ElementType.PACKAGE             可以给一个包进行注解
Elementtype.PARAMETER           可以给一个方法内的参数进行注解
ElementType.TYPE                可以给类型进行注解，比如类、接口、枚举

5、元注解@Inherited

• @Inherited并不是说注解本身可以继承，而是说如果一个超类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解。

package com;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


//@Retention(RetentionPolicy.SOURCE) //表示下面的注解在源代码中有效
//@Retention(RetentionPolicy.CLASS)//表示下面的注解在字节码文件中有效，默认方式
@Retention(RetentionPolicy.RUNTIME)//表示下面的注解在运行时有效
@Documented                        //表示下面的注解信息可以被javadoc工具提取到API文档中，很少使用
//表示下面的注解可以用于类型、构造方法、成员变量、成员方法、参数的修饰
@Target({ElementType.TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})
@Inherited // 表示下面的注释所修饰的类中的注解使用可以被子类继承

//若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {

	//如果注解只有一个参数成员，建议使用参数名为value，
	//而类型只能是八种基本数据类型、String类型、Class类型、enum类型以及Annotation类型。
	//声明一个String类型的成员变量，名字叫做value default 默认值。在注解时不需要再次给值
	public String value() default "123";
	public String value2(); 
}



package com;

//表示将标签MyAnnotation贴在Person类的代码中
@MyAnnotation(value2 = "world")
public class Person {

	/**
	 * name是用于描述姓名的成员变量
	 * */
	private String name;
	/**
	 * age是用于描述年龄的成员变量
	 * */
	private int age;
	
	/**
	 * 编程实现无参构造
	 */
	
	public Person() {}
	
	/**
	 * 编程实现有参构造
	 */
	public Person(String name, int age) {
		
		setName(name);
		setAge(age);
	}
	
	/**
	 * 自定义成员方法实现特征的获取和修改
	 * @return
	 */
	//提供公有的get、set方法并在方法体中进行合理值的判断
		public String getName() {
			
			return name;
		}
		
		public void setName(String name) {
			
			this.name = name;
		}
		
		public int getAge() {
			
			return age;
		}
		
		public void setAge(int age) {
			
			if(age > 0 && age < 150) {
				
				this.age = age;
			}else {
				
				System.out.println("年龄不合理！");
			}
		}
	
}

6、元注解@Repeatable

• @Repeatable表示自然可重复的含义，从Java8开始增加的新特性。
• 从Java8开始对元注解@Target的参数类型ElementType枚举值增加了两个
  • 其中ElementType.TYPE_PARAMETER表示该注解能写在类型变量的声明的语句中，如：泛型。
  • 其中ElementType.TYPE_USE表示改好租借能写在使用类型的任何语句中。

package com;

import java.lang.annotation.Repeatable;

/**
 * 自定义注解用于描述任务的角色
 * @author 明台见性
 *
 */
//Java8以后处理多注解的方式，使用@Repeatable
@Repeatable(value = ManType.class)
public @interface ManType {

	public String value() default "";
}



package com;

/**
 * 自定义注解用于描述多种角色
 * @author 明台见性
 *
 */
public @interface ManTypes {
 
	ManType[] value();
}


package com;

//Java8以后处理多注解使用@Repeatable
@ManType(value = "职工")
@ManType(value = "超人")
//Java8以前处理多注解的方式
@ManTypes({@ManType(value = "职工"), @ManType(value = "超人")})
public class ManT {

}

7、常见的预制注解

• 预制注解就是Java语言自身提供的注解，具体如下：

@author            标明开发该模块的作者，多个作者之间使用，分割
@version           标明该类模块的版本
@see               参考转向，也就是相关主题
@since             从哪个版本开始增加的
@param             对方法中某参数的说明，如果没有参数就不能写
@return            对方法返回值的说明，如果方法返回值类型是void就不能写
@exception         对方法可能抛出的异常进行说明
@Override          限定重写父类方法，该注解只能用于方法
@Deprecated        用于表示所修饰的元素（类、方法等）已过时
@SuppressWarning   抑制编译器警告

文章内容输出来源：拉勾教育Java高薪训练营