特殊类 - 简书

来自拉钩教育-JAVA就业集训营

内部类的基本概念

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

内部类的实际作用

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

内部类的分类

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

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

访问修饰符 class 外部类的类名 {
访问修饰符 class 内部类的类名 {
内部类的类体;
}
}

package com.lagou.task10;

/**
 * 编程实现普通内部类的定义和使用  -- 文档注释
 */
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.lagou.task10;

public class NormalOuterTest {

    public static void main(String[] args) {

        // 1.声明NormalOuter类型的引用指向该类型的对象
        NormalOuter no = new NormalOuter();
        // 2.声明NormalOuter类中的内部类的引用指向内部类的对象
        NormalOuter.NormalInner ni = no.new NormalInner();
        // 调用内部类中的show方法
        ni.show();
    }
}

普通内部类的使用方法

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

静态内部类的格式

访问修饰符 class 外部类的类名 {
访问修饰符 static class 内部类的类名 {
内部类的类体;
}
}

静态内部类的使用方式

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

局部（方法）内部类的格式

访问修饰符 class 外部类的类名 {
        访问修饰符 返回值类型 成员方法名 （形参列表） {
            class 内部类的类名 {
                内部类的类体;
            }
        }
}

package com.lagou.task10;

/**
 * 编程实现局部内部类的定义和使用
 */
public class AreaOuter {
    private int cnt = 1;

    public void show() {
        // 定义局部内部类，只在当前方法体的内部好使
        class  AreaInner {
            private int ia = 1;

            public AreaInner() {
                System.out.println("局部内部类的构造方法！");
            }

            public void test() {
                System.out.println("ia = " + ia);
                System.out.println("cnt = " + cnt);
            }
        }

        // 声明局部内部类的引用指向局部内部类的对象
        AreaInner ai = new AreaInner();
        ai.test();
    }
}

package com.lagou.task10;

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

局部内部类的使用方式

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

回调模式的概念

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

package com.lagou.task10;

public interface AnonymousInterface {
    // 自定义抽象方法
    public abstract void show();
}

package com.lagou.task10;

public class AnonymousInterfaceImpl implements AnonymousInterface {
    @Override
    public void show() {
        System.out.println("这里是接口的实现类");
    }
}

package com.lagou.task10;

public class AnonymousInterfaceTest {

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

    public static void main(String[] args) {

        // AnonymousInterfaceTest.test(new AnonymousInterface()); // Error：接口不能实例化
        AnonymousInterfaceTest.test(new AnonymousInterfaceImpl());

    }
}

匿名内部类开发经验分享

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

匿名内部类的语法格式

接口/ 父类类型引用变量名 = new 接口/父类类型() {方法的重写};

AnonymousInterface ait = new AnonymousInterface() {
    @Override
    public void show() {
        System.out.println("匿名内部类就是这么玩的，虽然你很抽象！");
    }
};
AnonymousInterfaceTest.test(ait);

枚举的基本概念

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

package com.lagou.task10;

/**
 * 编程实现所有方向的枚举，所有的方向：向上、向下、向左、向右
 */
public class Direction {
    private final String desc; // 用于描述方向字符串的成员变量

    // 2.声明本类类型的引用指向本类类型的对象
    public final static Direction UP = new Direction("向上");
    public final static Direction DOWN = new Direction("向下");
    public final static Direction LEFT = new Direction("向左");
    public final static Direction RIGHT = new Direction("向右");

    // 通过构造方法实现字符串的初始化，更加灵活
    // 1.私有化构造方法，此时该构造方法只能在本类的内部使用
    private Direction(String desc) {
        this.desc = desc;
    }

    // 通过公有的get方法可以在本类的外部访问该类成员变量的数值
    public String getDesc() {
        return desc;
    }
}

package com.lagou.task10;

public class DirectionTest {

    public static void main(String[] args) {

        /*
        // 1.声明 覅热餐厅类型的引用指向该类型的对象并打印特征
        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()); // 向右

        System.out.println("-----------------------------------");

        Direction d5 = new Direction("向前");
        System.out.println("获取到的字符串是：" + d5.getDesc()); // 向前
        */

//        Direction d2 = null;
//        Direction.UP = d2;
        Direction d1 = Direction.DOWN;
        System.out.println(d1.getDesc());
    }
}

枚举的定义

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

package com.lagou.task10;

/**
 * 编程实现所有方向的枚举，所有的方向：向上、向下、向左、向右
 * 枚举类型要求所有枚举值必须放在枚举类型的最前面
 */
public enum DirectionEnum {
    // 2.声明本类类型的引用指向本类类型的对象
    UP("向上"),DOWN("向下"),LEFT("向左"),RIGHT("向右");

    private final String desc; // 用于描述方向字符串的成员变量

    // 通过构造方法实现字符串的初始化，更加灵活
    // 1.私有化构造方法，此时该构造方法只能在本类的内部使用
    private DirectionEnum(String desc) {
        this.desc = desc;
    }

    // 通过公有的get方法可以在本类的外部访问该类成员变量的数值
    public String getDesc() {
        return desc;
    }
}

package com.lagou.task10;

public class DirectionTest {
    public static void main(String[] args) {
        // 使用 java 5开始的枚举类型
        DirectionEnum de = DirectionEnum.DOWN;
        System.out.println(de.getDesc());
    }
}

Enum类的概念和方法

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

package com.lagou.task10;

/**
 * 编程实现方向枚举类的测试
 */
public class DirectionEnumTest {
    public static void main(String[] args) {
        // 1.获取DirectionEnum类型中所有的枚举对象
        DirectionEnum[] arr = DirectionEnum.values();
        // 2.打印每个枚举对象类在枚举类型中的名称和索引位置
        for (int i = 0; i < arr.length; i++){
            System.out.println("获取到的枚举对象名称时：" + arr[i].toString());
            System.out.println("获取到的枚举对象对应的碎银位置是：" + arr[i].ordinal()); // 和数组一样下标重0开始
        }

        System.out.println("-----------------------------------------------------------------");

        // 3.根据参数指定的字符串得到枚举类型的对象，也就是将字符串转换为对象
//        DirectionEnum de = DirectionEnum.valueOf("向下"); // 编译ok，运行发生IllegalArgumentException非法参数异常
        DirectionEnum de = DirectionEnum.valueOf("DOWN");
//        DirectionEnum de = DirectionEnum.valueOf("UP LEFT"); // 要求字符串名称必须在枚举对象中存在
//        System.out.println("转换出来的枚举对象名称时：" + de.toString());
        System.out.println("转换出来的枚举对象名称时：" + de); // 当打印引用变量时，会自动调用toString方法

        // 4.使用获取到的枚举对象与枚举类中已有的对象比较先后顺序
        System.out.println("-----------------------------------------------------------------");
        for (int i = 0; i < arr.length; i++){
            // 当调用对象在参数对象之后时，获取到的比较结果为 正数
            // 当调用对象在参数对象相同位置是，则获取到的比较结果为 零
            // 当调用对象在参数对象之前时，则获取到的比较结果为 负数
            System.out.println("调用对象与数组中对象比较先后顺序结果是：" + de.compareTo(arr[i]));
        }
    }
}

枚举类实现接口的方式

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

注解的基本概念

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

注解的语法格式

访问修饰符 @interface 注解名称 {
    注解成员;
}

自定义注解自动继承 java.lang.annotion.Annotation接口。
通过@注解名称的方式可以修饰包、类、成员方法、成员变量、构造方法、参数、局部变量的声明等。

注解的使用方式

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

package com.lagou.task10;

// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {
//    public Direction value(); // 声明一个String 类型的成员变量，名字为value  类型有要求
    public String value() default "123"; // 声明一个String 类型的成员变量，名字为value
    public String value2();
}

package com.lagou.task10;

// 表示将标签 MyAnnotation贴在Person类的的代码中，使用注解时采用 成员参数名 = 成员参数值，……
//@MyAnnotation(value = "hello", value2 = "world")
@MyAnnotation(value2 = "world")
public class Person {
    private  String name;
    private int age;
}

元注解的概念

元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其他的注解上面。
元注解主要有 @Retention、@Documented、@Target、@Inherited、@Repeatable。
@Retention 注解的有效范围，或者叫生命周期
@Documented 描述这个注解是否在文档注释中体现
@Target 目标的意思，这个注解到底可以修饰那些内容
@Inherited 表示注解是否可以被继承到所标记的这个类的子类
@Repeatable 是否可以重复。

元注解@Retention

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

package com.lagou.task10;

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

//@Retention(RetentionPolicy.SOURCE) // 表示下面的注解在源代码中有效
//@Retention(RetentionPolicy.CLASS) // 表示下面的注解在字节码文件中有效，默认方式
@Retention(RetentionPolicy.RUNTIME) // 表示下面的注解在运行时有效
// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {
    public String value() default "123"; // 声明一个String 类型的成员变量，名字为value
    public String value2();
}

元注解@Documented

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

package com.lagou.task10;

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

//@Retention(RetentionPolicy.SOURCE) // 表示下面的注解在源代码中有效
//@Retention(RetentionPolicy.CLASS) // 表示下面的注解在字节码文件中有效，默认方式
@Retention(RetentionPolicy.RUNTIME) // 表示下面的注解在运行时有效
@Documented                         // 表示下面的注解可以被javadoc工具提取到API文档中，很少使用
// 若一个注解中没有任何的成员，则这样的注解叫做标记注解/标识注解
public @interface MyAnnotation {
//    public Direction value(); // 声明一个String 类型的成员变量，名字为value  类型有要求
    public String value() default "123"; // 声明一个String 类型的成员变量，名字为value
    public String value2();
}

元注解@Target

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

// 表示下面的注解信息可以用于类型、构造方法、成员变量、成员方法 的修饰
@Target({/*ElementType.TYPE, */ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER})

元注解@Inherited

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

@Inherited // 表示下面的注解所修饰的类中的注解使用可以被子类继承

元注解@Repeatable

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

package com.lagou.task10;

import java.lang.annotation.Repeatable;

/**
 * 自定义注解用于描述人物的角色
 */
@Repeatable(value = ManTypes.class)
public @interface ManType {
    String value() default "";
}

package com.lagou.task10;

/**
 * 自定义注解里面可以描述多种角色
 */
public @interface ManTypes {
    ManType[] value();
}

package com.lagou.task10;

@ManType(value = "职工")
@ManType(value = "超人")
//@ManTypes({@ManType(value = "职工"), @ManType(value = "超人")}) // 在java8以前处理多个注解的方式
public class Man {
}

常见的预制注解

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