特殊类

最新推荐文章于 2024-10-15 15:06:01 发布
最新推荐文章于 2024-10-15 15:06:01 发布
阅读量556 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38908960/article/details/113704791
版权

java
内部类的概念和分类
内部类的基本概念
  • 当一个类的定义出现在另外一个类的类体中时，那么这个类叫做内部类（Inner），而这个内部类所在的类叫做外部类（Outer）
  • 类中的内容：成员变量、成员方法、构造方法、静态成员、构造块和静态代码块、内部类
实际作用
  • 当一个类存在的价值仅仅是为某一个类单独服务时，那么就可以将这个类定义为所服务类中的内部类，这样可以隐藏该类的实现细节并且可以方便的访问外部类的私有成员而不再需要提供公有的get和set方法
内部类的分类
  • 普通内部类：直接将一个类的定义放在另外一个类的类体中
  • 静态内部类：使用static关键字修饰内部类，隶属于类层级
  • 局部内部类：直接将一个类的定义放在方法体的内部时
  • 匿名内部类：就是指没有名字的内部类
普通内部类的定义
普通（成员）内部类的格式

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

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

    ​ 内部类的类体

    ​ }

    }

NormalOuter.java

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);
        }
    }
}

NormalOuterTest.java

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 外部类的类名{

    ​ 内部类的类体

    ​ }

    }

StaticOuter.java

package com.lagou.task10;

/**
 * 实现静态内部类的定义和使用
 */
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); // 3
            System.out.println("外部类中的snt = " + snt); // 2
            //System.out.println("外部类的cnt = " + cnt);  // Error:静态上下文中不能访问非静态的成员，因为此时可能还没有创建对象
        }
    }
}

StaticOuterTest.java

package com.lagou.task10;

public class StaticOuterTest {

    public static void main(String[] args) {

        // 1.声明StaticInner类型的引用指向该类型的对象
        StaticOuter.StaticInner si = new StaticOuter.StaticInner();
        // 2.调用show方法进行测试
        si.show();
    }
}
静态内部类的使用方式
  • 静态内部类不能直接访问外部类的非静态成员
  • 静态内部类可以直接创建对象
  • 如果静态内部类访问外部类中与本类内同名的成员变量或方法时，需要使用类名.的方式访问

StaticOuter.java

package com.lagou.task10;

/**
 * 实现静态内部类的定义和使用
 */
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); // 3
            System.out.println("外部类中的snt = " + snt); // 2
            //System.out.println("外部类的cnt = " + cnt);  // Error:静态上下文中不能访问非静态的成员，因为此时可能还没有创建对象
        }
        public void show2(int snt){ //就近原则
            System.out.println("snt = " + snt);
            System.out.println("内部类中的成员snt = " + StaticInner.snt); // 4
            System.out.println("外部类中的成员snt = " + StaticOuter.snt); // 2
            //StaticOuter.show();
            new StaticOuter().show();
        }
    }
}

在这里插入图片描述

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

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

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

    ​ class 内部类的类名{

    ​ 内部类的类体;

    ​ }

    ​ }

    }

AreaOuter.java

package com.lagou.task10;
/**
 * 编程实现局部内部类的定义和使用
 */
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); // 1
                System.out.println("cnt = " + cnt); // 2
            }
        }
        // 声明局部内部类的引用指向局部内部类的对象
        AreaInner ai = new AreaInner();
        ai.test();
    }
}

AreaOuterTest.java

package com.lagou.task10;

public class AreaOuterTest {

    public static void main(String[] args) {

        // 1.声明外部类类型的引用指向外部类的对象
        AreaOuter ao = new AreaOuter();
        // 2.通过show方法调用实现局部内部类的定义和使用
        ao.show();
    }
}
局部内部类的使用方式
  • 局部内部类只能在该方法的内部可以使用
  • 局部内部类可以在方法体内部直接创建对象
  • 局部内部类不能使用访问控制符和static关键字修饰符
  • 局部内部类可以使用外部方法的局部变量，但是必须是final的，由局部内部类和局部变量的声明周期不同所致

在这里插入图片描述

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

AnonymousInterface.java

package com.lagou.task10;

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

AnonymousInterfaceTest.java

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());
    }
}

AnonymousInterfaceImpl.java

package com.lagou.task10;

public class AnonymousInterfaceImpl implements AnonymousInterface {
    @Override
    public void show() {
        System.out.println("这里是接口的实现类!");
    }
}
匿名内部类的使用
匿名内部类的语法格式（重点）
  • 接口/父类类型 引用变量名 = new 接口/父类类型(){方法的重写};
开发经验分享
  • 当接口/类类型的引用作为方法的形参时，实参的传递方式有两种：
  • 自定义类实现接口/继承类并重写方法，然后创建该类对象作为实参传递；
  • 使用上述匿名内部类的语法格式得到接口/类类型的引用即可

AnonymousInterfaceTest.java

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());

        System.out.println("---------------------------");
        // 使用匿名内部类的语法格式来得到接口类型的引用，格式为：接口/父类类型 引用变量名 = new 接口/父类类型(){方法的重写};
        AnonymousInterface ait = new AnonymousInterface() {
            @Override
            public void show() {
                System.out.println("匿名内部类就是这么玩的，虽然你很抽象!");
            }
        };
        AnonymousInterfaceTest.test(ait);

        System.out.println("---------------------------");
        // 从java8开始提出新特性lamda表达式可以简化上述代码，格式为:(参数列表 -> {方法体})
        AnonymousInterface ait2 = () -> System.out.println("lamda表达式原来是如此简单!");
        AnonymousInterfaceTest.test(ait2);
    }
}

在这里插入图片描述

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

Direction.java

package com.lagou.task10;

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

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

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

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

DirectionTest.java

package com.lagou.task10;

public class DirectionTest {
    public static void main(String[] args) {

        // 1.声明Direction类型的引用指向该类型的对象并打印特征
        /*Direction d1 = new Direction("向上");
        System.out.println("获取到的字符串是:" + d1.getDesc());  // 向上

        Direction d2 = new Direction("向下");
        System.out.println("获取到的字符串是:" + d1.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.up = 2; Error:类型不匹配
        //Direction d2 = null;
        //Direction.UP = d2; Error:final关键字修饰
        Direction d1 = Direction.UP;
        Direction d2 = Direction.DOWN;
        Direction d3 = Direction.LEFT;
        Direction d4 = Direction.RIGHT;
        System.out.println("获取到的方向是:" + d1.getDesc() + "、" + d2.getDesc() + "、" + d3.getDesc() + "、" + d4.getDesc());



    }
}

在这里插入图片描述

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

DirectionEnum.java

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;
    }
}

DirectionTest.java

        System.out.println("-----------------------------");
        // 使用一下java5开始的枚举类型
        DirectionEnum de = DirectionEnum.DOWN;
        System.out.println("获取到的方向是:" + de.getDesc()); // 向下

在这里插入图片描述

自定义类和枚举类型在switch结构的使用

DirectionUseTest.java

package com.lagou.task10;

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 test2(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());
        DirectionUseTest.test1("今天是个好日子!");

        System.out.println("-----------------------------");
        DirectionUseTest.test2(DirectionEnum.DOWN);
        //DirectionUseTest.test2("今天是个好日子!"); Error:类型不匹配 减少来出错的可能性

    }
}
Enum类的概念和常用方法
  • 所有的枚举类型都继承自java.lang.Enum类,常用方法如下:

在这里插入图片描述

前三个DirectionEnumTest.java测试

package com.lagou.task10;

/**
 * 编程实现方向枚举类的测试，调用从Enum类中继承下来的方法
 */
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("");
        }
    }
}

在这里插入图片描述

package com.lagou.task10;

/**
 * 编程实现方向枚举类的测试，调用从Enum类中继承下来的方法
 */
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("");
        }
        System.out.println("-------------------------------");
        // 3.根据参数指定的字符串得到枚举类型的对象,也就是将字符串转换为对象
        //DirectionEnum de = DirectionEnum.valueOf("向上");  // 编译ok 运行发生IllegalArgumentException非法参数异常，算数异常、数组越界异常、空指针异常、类型转换异常
        //DirectionEnum de = DirectionEnum.valueOf("UP LEFT"); 要求字符串名称必须在枚举对象中存在
        DirectionEnum de = DirectionEnum.valueOf("DOWN");
        System.out.println("转换出来的枚举对象名称是: " + de.toString());
        System.out.println("转换出来的枚举对象名称是: " + de); // 当打印引用变量时，会自动调用toString方法

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

在这里插入图片描述

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

DirectionEnum.java

package com.lagou.task10;

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

    // 2.声明本类类型的引用指向本类类型的对象
    // 匿名内部类的语法格式:接口/父类类型 引用变量名 = new 接口/父类类型(){方法的重写}
    // public static final Direction UP = new Direction("向上"){};
    UP("向上"){
        @Override
        public void show() {
            System.out.println("贪吃蛇向上移动了一下!");
        }
    },DOWN("向下") {
        @Override
        public void show() {
            System.out.println("贪吃蛇向下移动了一下!");
        }
    },LEFT("向左") {
        @Override
        public void show() {
            System.out.println("左移了一下!");
        }
    },RIGHT("向右") {
        @Override
        public void show() {
            System.out.println("右移了一下!");
        }
    };
    private final String desc; // 用于描述方向字符串的成员变量

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

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

    // 整个枚举类型只重写一次，所有对象调用同一个
    /*@Override
    public void show() {
        System.out.println("现在可以实现接口中抽象方法的重写了!");
    }*/

}

在这里插入图片描述

DirectionEnumTest.java

package com.lagou.task10;

/**
 * 编程实现方向枚举类的测试，调用从Enum类中继承下来的方法
 */
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("");
        }
        System.out.println("-------------------------------");
        // 3.根据参数指定的字符串得到枚举类型的对象,也就是将字符串转换为对象
        //DirectionEnum de = DirectionEnum.valueOf("向上");  // 编译ok 运行发生IllegalArgumentException非法参数异常，算数异常、数组越界异常、空指针异常、类型转换异常
        //DirectionEnum de = DirectionEnum.valueOf("UP LEFT"); 要求字符串名称必须在枚举对象中存在
        DirectionEnum de = DirectionEnum.valueOf("DOWN");
        System.out.println("转换出来的枚举对象名称是: " + de.toString());
        System.out.println("转换出来的枚举对象名称是: " + de); // 当打印引用变量时，会自动调用toString方法

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

在这里插入图片描述

注解的基本概念
  • 注解（Annotation）又叫标注,是从java5开始增加的一种引用数据类型
  • 注解本质上就是代码中的特殊标记，通过这些标记可以在编译、类加载、以及运行时执行指定的处理
注解的定义和使用
注解的语法格式

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

    ​ 注解成员;

    }

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

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

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

MyAnnotation.java

package com.lagou.task10;

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

    //public Direction value(); // 声明一个String类型的成员变量，名字为value  类型有要求
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
    public String value2();
}

Person.java

package com.lagou.task10;
// 表示将标签MyAnnotation帖在Person类的代码中,使用注解时采用 成员参数名 = 成员参数值,...
//@MyAnnotation(value = "hello",value2 = "world")
@MyAnnotation(value2 = "world")
public class Person {
    private String name;
    private int age;
}
元注解的概念和@Retentio的使用
元注解的概念
  • 元注解是可以注解到注解上的注解，或者说元注解是一种基本注解，但是它能够应用到其它的注解上面
  • 元注解主要有@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 Direction value(); // 声明一个String类型的成员变量，名字为value  类型有要求
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
    public String value2();
}
@Documented的使用
元注解@Documented

  • 使用javadoc工具可以从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档，而该工具抽取时默认不包括注解内容

  • @Documented用于指定被该注解将被javadoc工具提取成文档

  • 定义@Documented的注解必须设置Retention值为RUNTIME

MyAnnotation.java

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和@Inherited的使用
元注解@Target
  • @Target用于指定被修饰的注解能用于哪些元素的修饰，取值如下：

在这里插入图片描述
在这里插入图片描述

MyAnnotation.java

package com.lagou.task10;

import java.lang.annotation.*;

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

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

    //public Direction value(); // 声明一个String类型的成员变量，名字为value  类型有要求
    public String value() default "123"; // 声明一个String类型的成员变量，名字为value
    public String value2();
}

Person.java

package com.lagou.task10;
// 表示将标签MyAnnotation帖在Person类的代码中,使用注解时采用 成员参数名 = 成员参数值,...
//@MyAnnotation(value = "hello",value2 = "world")
//@MyAnnotation(value2 = "world")
public class Person {
    /**
     * name是用于描述姓名的成员变量
     */
    @MyAnnotation(value2 = "1")
    private String name;
    /**
     * age是用于描述年龄的成员变量
     */
    private int age;

    /**
     * 自定义成员方法实现无参构造方法
     */
    @MyAnnotation(value2 = "2")
    public Person() {
    }

    /**
     * 编程实现有参构造方法
     * @param name
     * @param age
     */
    public Person(@MyAnnotation(value2 = "4") String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     *自定义成员方法实现特征的获取和修改
     * @return
     */
    @MyAnnotation(value2 = "3")
    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; }
}
元注解@Inherited
  • @Inherited并不是说注解本身可以继承，而是说明如果一个超类被该注解标记过的注解进行注解时，如果子类没有被任何注解应用时，则子类就继承超类的注解

在这里插入图片描述

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

注解：ManType.java

package com.lagou.task10;

import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Target;

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

类：Man.java

package com.lagou.task10;

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

public class Man {

    public static void main(String[] args) {
        int ia = 97;
        char c1 = (@ManType char) ia;
    }
}

注解：ManTypes.java

package com.lagou.task10;

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

/**
 * 自定义注解用于描述多种角色
 */
@Target(ElementType.TYPE_USE)
public @interface ManTypes {
    ManType[] value();
}
常见的预制注解
  • 预制注解就是java语言自身提供的注解，具体如下：‘
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
总结

1、内部类

概念、普通内部类、静态内部类、局部内部类、匿名内部类、回调模式等

2、枚举类型

今天概念、自定义枚举、enum关键字、继承自Enum类、实现接口等

3、注解

概念、自定义注解、使用、元注解、预制注解等

悟空要上天
关注
Java特殊类
大象
07-22 890
内部类枚举类…
（）重力的特殊类中的三维三维类似Lifshitz的黑洞
05-06
关于三维上一类特殊的纯F（R）重力，我们通过分析获得了类似于Lifshitz的黑洞解决方案。 我们检查溶液的几何特性，例如带电的BTZ黑洞有特殊限制。 我们还研究了溶液的热力学性质，并研究了热力学第一定律和Smarr公式...
java中的特殊类
qiuyushuofeng的专栏
07-19 406
1.成员内部类 在一般类的内部定义的类，这种类可以访问外部类的所有成员。 2.静态内部类 在成员内部类的基础上再加一个条件：在前面加一个static关键字。 3.方法内部类 在成员方法中定义的类，他只能在当前方法中被使用。        ...
2.62.特殊类的总结
weixin_45471415的博客
03-12 109
特殊类的总结 **枚举 枚举就是有固定个数实例的类 枚举的父类是Enum 非公有类 最不特殊的类，可以认为就是被缺省访问控制符修饰的类。也就是说，和public class 的区别仅仅是可以被访问的范围不一样 如果一个文件只有非公有类，那么类名和文件名可以不一样。当然文件后缀必须是 java 。 内部类 内部类的特殊之处在于可见性和可以访问的数据以及方法。内部类会被认为是类本身的代码，所以外部类的...
1.1.5 一维数组,概念, 声明, 增删改查, 优缺点, 工具类, 二维数组, 概念, 声明
chengh1993的博客
09-26 356
1 内部类 基本概念 当一个类的定义出现在另一个类的类体中时,这个类叫做内部类,而所在类叫做外部类 (只为某一个类服务) 类中的内容 成员变量,成员方法,构造方法,静态成员,构造块和静态代码块,内部类 实际作用 一个类的存在价值仅仅是为某一个类单独服务时, 可以将这个类定义为内部类,隐藏细节, 方便访问外部类的私有成员而不用再提供公有的get...
java中特殊的类
sinat_37810981的博客
03-08 581
l 特殊的类 实名内部类         将一个类的定义置于另一个类中，这个类就是内部类。    内部类需要遵循以下准则： （1） 内部类的类名只用于定义它的类或语句块之内，在外部引用它是必须给出带有外部类名的完整名称。 （2） 内部类的名字不允许与外部类的名字相同。 （3） 内部类可以是抽象类或接口，若是接口，则可以由其他内部类实现。 内部类包含实名内部类（含有显式的类名）和匿名内
java自定义工具类，对字符串进行特殊处理
03-04
1.删除字符 2.去空格 3.去除所有空格和特殊字符 4.判断邮箱 5.字符串集合转字符串 6.只保留汉字 7.关键词前后是否包含英文字母 8.去除字符串中的附件 9.获取下标单个位置和所有位置
python中实现定制类的特殊方法总结
01-20
除此之外，Python的class中还有许多这样有特殊用途的函数，可以帮助我们定制类。 __str__ 我们先定义一个Student类，打印一个实例： 复制代码 代码如下: >>> class Student(object): … def __init__(self, name): ...
Python中类的初始化特殊方法
12-25
简单来说，特殊方法可以给你设计的类加上一些神奇的特性，比如可以进行python原生的切片操作，迭代、连乘操作等。在python中，特殊方法以双下划线开始，以双下划线结束。 一个大例子 数学中有一个表示数的概念叫做...
C++类中的特殊成员函数示例详解
01-21
C++类中有几个特殊的非静态成员函数，当用户未定义这些函数时，编译器将给出默认实现。C++11前有四个特殊函数，C++11引入移动语义特性，增加了两个参数为右值的特殊函数。这六个函数分别是： 1、默认构造函数 默认...
Java__三个特殊类
wzh_123_123的博客
04-14 430
一、String类1.String类的两种实例化方式    (1)直接赋值String str = "hello"; //比较常用    (2)传统方法String str = new String("hello"); //String本身是一个类，既然是类，它就存在构造方法， //这就是利用它其中一种构造方法进行赋值 //该构造方法：pub...
简述三个特殊类
mly15191882818的博客
11-06 315
一、String类 1.1实例化。     String类的实例化方法有两种：1.直接赋值，2.构造方法。     1.直接赋值法：   //这样的赋值方式只会开辟一块内存空间，并且若字符串是第一次出现则自动入池，供下次使用。   2.构造方法：   String str=new String（"hello world"）; //这样会开辟两块堆内存空间，其中一块会成为垃圾...
JavaSE之三个特殊类
近未来
10-31 722
1、java.long.String类 1.1、String类的两种实例化方式 a、直接赋值 b、传统方法（构造方法实例化） 1.2字符串子相等比较 public boolean equals(String anotherString) ：成员方法 str1.equals(anotherString) 1.3字符串常量（“ ”）是String的匿名对象 小tips：在以后开发中，如果要判断用户...
Java中的三大特殊类
wokaoshenmogui的博客
03-17 795
今天来总结一下Java中的三大特殊类：String类, Object类, 和包装类 一，String类 1. String类的两种实例化方式 ★ 直接赋值 ： String str = &amp;quot;Hello World&amp;quot; ; // str是一个对象，那么&amp;quot;Hello World&amp;quot; 就应该保存在堆内存中 System.out.println(str) ; ★ 传统方法（构造法）： String
java 特殊类_Java三大特殊类
weixin_42495504的博客
02-19 434
1.java.lang.String类1.1String类的两种实例化方式a.直接赋值，(在堆上分配空间)b.通过构造方法实例化String对象(传统方法)1.2 字符串相等比较public.boolean.equals(String anothorString) : 成员方法str1.equals(anothorString)1.3字符串常量是String的匿名对象判断用户输入字符串是否等于特...
Java：三个特殊的类（String类、Object类和包装类）
NiuPlus
07-10 4078
三个特殊的类：String Object 包装 String类： String类的两种实例化方式：直接赋值：String str1 = “hello world”;传统方法：String str2 = new String(“hello world”);字符串相等的比较：“equals”和“==”：（1）、“==”进行字符串的比较：String str1 = “hello”;String st...
java基础之java中的运算符
木直小大的博客
11-06 209
运算符的分类: 算数运算符 , 赋值运算符 , 比较运算符 , 逻辑运算符 , 三元运算符 注意: 1.整数相除,结果是整数,要得到小数,必须有小数参与运算 例: 5/3=1; 5.0/3=1.6666666666666667 2. 取余结果符号与左边符号相同 System.out.println(5 % 3); // 2 System.out.println(‐5 % 3); // -2 System.out.println(5 % ‐3); // 2 System.out.pr.
基于SSM班级事务管理系统的设计
最新发布
2401_87849773的博客
10-15 379
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Python核心编程：特殊类属性详解
在《特殊类属性-数字图像处理_第三版_中文_冈萨雷斯》一书中，章节讨论了Python编程中的特殊类属性。这些属性对于理解类（Class）的内部构造和行为至关重要。特殊类属性是Python语言中预定义的一些元属性（meta-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值