韩顺平Java学习笔记（五）自用

已于 2024-04-17 17:59:09 修改
阅读量1k 收藏 17
点赞数 28
分类专栏： Java基础知识 文章标签： java 笔记
于 2024-04-17 17:58:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45900156/article/details/137826470
版权

内部类

如果定义类在局部位置（方法中/代码块）：（1）局部内部类 （2）匿名内部类 

定义类在成员位置：（1）成员内部类  （2）静态内部类

基本介绍

        一个类的内部又完整嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。是类的第五大成员【属性、方法、构造器、代码块、内部类】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类之间的包含关系。

基本语法

class Outer{//外部类

        class Inner{//内部类

        }

}

class Other{//外部其他类

}

内部类的分类

  • 定义在外部类局部位置上（比如方法内）：
    • 局部内部类（有类名）
    • 匿名内部类（没有类名，重点！！！）
  • 定义在外部类的成员位置上：
    • 成员内部类（没用static修饰）
    • 静态内部类（使用static修饰）

局部内部类的使用

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

  • 可以直接访问外部类的所有成员，包括私有的
  • 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的，但是可以使用final修饰，因为局部变量也可以使用fianl
  • 作用域：仅仅在定义它的方法或代码块中
  • 局部内部类---访问--->外部类的成员【访问方式：直接访问】
  • 外部类---访问--->局部内部类的成员【访问方式：创建对象，再访问（注意：必须在作用域内）】

注意：

  1. 局部内部类定义在方法/代码块中
  2. 作用域在方法体或者代码块中
  3. 本质仍然是一个类
  • 外部其他类---不能访问--->局部内部类（因为局部内部类地位是一个局部变量）
  • 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问  比如：System.out.println("外部类的n=" + 外部类名.this.n);
public class LocalInnerClass {//
    public static void main(String[] args) {
        //演示一遍
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println("outer02 的 hashcode=" + outer02);
    }
}

class Outer02 {//外部类
    private int n1 = 100;
    private void m2() {
        System.out.println("Outer02 m2()");
    }//私有方法
    public void m1() {//方法
        //1.局部内部类是定义在外部类的局部位置,通常在方法
        //3.不能添加访问修饰符,但是可以使用 final 修饰
        //4.作用域 : 仅仅在定义它的方法或代码块中
        final class Inner02 {//局部内部类(本质仍然是一个类)
            //2.可以直接访问外部类的所有成员，包含私有的
            private int n1 = 800;
            public void f1() {
                //5. 局部内部类可以直接访问外部类的成员，比如下面 外部类 n1 和 m2()
                //7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
                // 使用 （外部类名.this.成员）去访问
                // Outer02.this 本质就是外部类的对象, 即哪个对象调用了 m1, Outer02.this 就是哪个对象
                System.out.println("n1=" + n1 + " 外部类的 n1=" + Outer02.this.n1);
                System.out.println("Outer02.this hashcode=" + Outer02.this);
                m2();
            }
        }
        //6. 外部类在方法中，可以创建 Inner02 对象，然后调用方法即可
        Inner02 inner02 = new Inner02();
        inner02.f1();
    }
}

匿名内部类的使用（重要！！！）

（1）本质还是类  （2）内部类  （3）该类没有名字  （4）同时还是一个对象

说明：匿名内部类定义在外部类的局部位置，比如方法中，并且没有类名

  • 基本语法

        new 类或接口(参数列表){

                类体

        };

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer04 outer04 = new Outer04();
        outer04.method();
    }
}


class Outer04 { //外部类
    private int n1 = 10;//属性
    public void method() {//方法
    //基于接口的匿名内部类
    //1.需求： 想使用 IA 接口,并创建对象
    //2.传统方式，是写一个类，实现该接口，并创建对象
    //3.老韩需求是 Tiger/Dog 类只是使用一次，后面再不使用
    //4. 可以使用匿名内部类来简化开发
    //5. tiger 的编译类型 ? IA
    //6. tiger 的运行类型 ? 就是匿名内部类 Outer04$1
    /*
        我们看底层 会分配 类名 Outer04$1
        class Outer04$1 implements IA {
            @Override
            public void cry() {
                System.out.println("老虎叫唤...");
            }
        }
    */
    //7. jdk 底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址
    // 返回给 tiger
    //8. 匿名内部类使用一次，就不能再使用
    IA tiger = new IA() {
        @Override
        public void cry() {
            System.out.println("老虎叫唤...");
        }
    };
    System.out.println("tiger 的运行类型=" + tiger.getClass());
    tiger.cry();
    tiger.cry();
    tiger.cry();

    //演示基于类的匿名内部类
    //分析
    //1. father 编译类型 Father
    //2. father 运行类型 Outer04$2
    //3. 底层会创建匿名内部类
    /*
        class Outer04$2 extends Father{
            @Override
            public void test() {
                System.out.println("匿名内部类重写了 test 方法");
            }
        }
    */
    //4. 同时也直接返回了 匿名内部类 Outer04$2 的对象
    //5. 注意("jack") 参数列表会传递给 构造器
    Father father = new Father("jack"){
        @Override
        public void test() {
            System.out.println("匿名内部类重写了 test 方法");
        }
    };
    System.out.println("father 对象的运行类型=" + father.getClass());//Outer04$2
    father.test();

    //基于抽象类的匿名内部类
    Animal animal = new Animal(){
        @Override
        void eat() {
            System.out.println("小狗吃骨头...");
        }
    };
    animal.eat();
    }
}

interface IA {//接口
    public void cry();
}
//class Tiger implements IA {
//     @Override
//     public void cry() {
//         System.out.println("老虎叫唤...");
//     }
//}
//class Dog implements IA{
//     @Override
//     public void cry() {
//         System.out.println("小狗汪汪...");
//     }
//}

class Father {//类
    public Father(String name) {//构造器
        System.out.println("接收到 name=" + name);
    }
    public void test() {//方法
    }
}

abstract class Animal { //抽象类
    abstract void eat();
}
  • 匿名内部类的语法比较奇特，因为匿名内部类既是一个类的定义，同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，因此可以调用匿名内部类方法
  • 可以直接访问外部类的所有成员，包含私有的
  • 不能添加访问修饰符，因为它的地位就是一个局部变量
  • 作用域：仅仅在定义它的方法或代码块中
  • 匿名内部类---访问--->外部成员类【访问方式：直接访问】
  • 外部其他类---不能访问--->匿名内部类（因为匿名内部类的地位就是一个局部变量）
  • 如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问
public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.f1();
        //外部其他类---不能访问----->匿名内部类
        System.out.println("main outer05 hashcode=" + outer05);
    }
}

class Outer05 {
    private int n1 = 99;
    public void f1() {
        //创建一个基于类的匿名内部类
        //不能添加访问修饰符,因为它的地位就是一个局部变量
        //作用域 : 仅仅在定义它的方法或代码块中
        Person p = new Person(){
            private int n1 = 88;
            @Override
            public void hi() {
                //可以直接访问外部类的所有成员，包含私有的
                //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
                //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
                System.out.println("匿名内部类重写了 hi 方法 n1=" + n1 +
                " 外部内的 n1=" + Outer05.this.n1 );
                //Outer05.this 就是调用 f1 的 对象
                System.out.println("Outer05.this hashcode=" + Outer05.this);
            }
        };
        p.hi();//动态绑定, 运行类型是 Outer05$1

        //也可以直接调用, 匿名内部类本身也是返回对象
        // class 匿名内部类 extends Person {}
        // new Person(){
        //     @Override
        //     public void hi() {
        //         System.out.println("匿名内部类重写了 hi 方法,哈哈...");
        //     }
        //     @Override
        //     public void ok(String str) {
        //         super.ok(str);
        //     }
        // }.ok("jack");
    }
}

class Person {//类
    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok(String str) {
        System.out.println("Person ok() " + str);
    }
}

匿名内部类的最佳实践

当做实参直接传递，简单高效

package com.hspedu.innerclass;
import com.hspedu.abstract_.AA;

public class InnerClassExercise01 {
    public static void main(String[] args) {
        //当做实参直接传递，简洁高效
        f1(new IL() {
            @Override
            public void show() {
                System.out.println("这是一副名画~~...");
            }
        });
        //传统方法
        f1(new Picture());
    }

    //静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}

//接口
interface IL {
    void show();
}

//类->实现 IL => 编程领域 (硬编码)
class Picture implements IL {
    @Override
    public void show() {
        System.out.println("这是一副名画 XX...");
    }
}

成员内部类的使用

说明：成员内部类定义在外部类的成员位置，并且没有static修饰

  • 可以直接访问外部类的所有成员，包含私有的
class Outer01{//
    private int n1 = 10;
    public String name = "张三";
    class Inner01{
        public void say(){
            System.out.println("Outer的n1=" + n1 + "outer01的name=" + name);
        }
    }
}
  • 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员
  • 作用域和外部类的其他成员一样，为整个类体。在外部类的成员方法中创建成员内部类对象，再调用方法
  • 成员内部类---访问--->外部类成员（比如：属性）【访问方式：直接访问】
  • 外部类---访问--->成员内部类【访问方式：创建对象，再访问】
  • 外部其他类---访问--->成员内部类
  • 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如郭襄访问外部类的成员，则可以使用（外部类名.this.成员）去访问
public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.t1();
        //外部其他类，使用成员内部类的三种方式
        // 第一种方式
        // outer08.new Inner08(); 相当于把 new Inner08()当做是 outer08 成员
        // 这就是一个语法，不要特别的纠结. Outer08.Inner08 inner08 = outer08.new Inner08();
        inner08.say();
        // 第二方式 在外部类中，编写一个方法，可以返回 Inner08 对象
        Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
        inner08Instance.say();
    }
}

class Outer08 { //外部类
    private int n1 = 10;
    public String name = "张三";
    private void hi() {
        System.out.println("hi()方法...");
    }
    //1.注意: 成员内部类，是定义在外部内的成员位置上
    //2.可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    public class Inner08 {//成员内部类
        private double sal = 99.8;
        private int n1 = 66;
        public void say() {
            //可以直接访问外部类的所有成员，包含私有的
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则. //，可以通过 外部类名.this.属性 来访问外部类的成员
            System.out.println("n1 = " + n1 + " name = " + name + " 外部类的 n1=" + Outer08.this.n1);
            hi();
        }
    }

    //方法，返回一个 Inner08 实例
    public Inner08 getInner08Instance(){
        return new Inner08();
    }

    //写方法
    public void t1() {
        //使用成员内部类
        //创建成员内部类的对象，然后使用相关的方法
        Inner08 inner08 = new Inner08();
        inner08.say();
        System.out.println(inner08.sal);
    }
}

静态内部类的使用

说明：静态内部类定义在外部类的成员位置，并且有static修饰

  • 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
  • 可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员
  • 作用域：同其他成员，为整个类体
  • 静态内部类---访问--->外部类（比如：静态属性）【访问方式：直接访问所有静态成员】
  • 外部类---访问--->静态内部类【访问方式：创建对象，再访问】
  • 外部其他类---访问--->静态内部类
  • 如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问
public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.m1();
        //外部其他类 使用静态内部类
        //方式 1
        //因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        //方式 2
        //编写一个方法，可以返回静态内部类的对象实例. Outer10.Inner10 inner101 = outer10.getInner10();
        System.out.println("============");
        inner101.say();
        Outer10.Inner10 inner10_ = Outer10.getInner10_();
        System.out.println("************");
        inner10_.say();
    }
}

class Outer10 { //外部类
    private int n1 = 10;
    private static String name = "张三";
    private static void cry() {}
    //Inner10 就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用 static 修饰
    //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner10 {
        private static String name = "韩顺平教育";
        public void say() {
            //如果外部类和静态内部类的成员重名时，静态内部类访问的时，
            //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.成员）
            System.out.println(name + " 外部类 name= " + Outer10.name);
            cry();
        }
    }

    public void m1() { //外部类---访问------>静态内部类 访问方式：创建对象，再访问
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public Inner10 getInner10() {
        return new Inner10();
    }

    public static Inner10 getInner10_() {
        return new Inner10();
    }
}

枚举

枚举是一组常量的集合。

可以这样理解：枚举属于一种特殊的类，里面只包含一组有限的特定对象

实现方式

  1. 自定义类实现枚举
  2. 使用enum关键字实现枚举

自定义类实现枚举

  1. 不需要提供setXxx方法，因为枚举对象值通常为只读
  2. 对枚举对象/属性使用final+static共同修饰，实现底层优化
  3. 枚举对象名通常使用全部大写，常量的命名规范
  4. 枚举对象根据需要，也可以有多个属性
public class Enumeration02 {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
        System.out.println(Season.SPRING);
    }
}

//演示字定义枚举实现
class Season {//类
    private String name;
    private String desc;//描述
    //定义了四个对象, 固定. 
    public static final Season SPRING = new Season("春天", "温暖");
    public static final Season WINTER = new Season("冬天", "寒冷");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    public static final Season SUMMER = new Season("夏天", "炎热");
    //1. 将构造器私有化,目的防止 直接 new
    //2. 去掉 setXxx 方法, 防止属性被修改
    //3. 在 Season 内部，直接创建固定的对象
    //4. 优化，可以加入 final 修饰符
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    @Override
    public String toString() {
        return "Season{" +
        "name='" + name + '\'' +
        ", desc='" + desc + '\'' +
        '}';
    }
}

小结：特点

  1. 构造器私有化
  2. 本类内部创建一组对象【四个 春夏秋冬】
  3. 对外暴露对象（通过为对象添加public final static修饰符）
  4. 可以提供get方法，但是不要提供set

关键字实现枚举

public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.SUMMER);
    }
}
//演示使用 enum 关键字来实现枚举类
enum Season2 {//类
    //定义了四个对象, 固定. // public static final Season SPRING = new Season("春天", "温暖");
    // public static final Season WINTER = new Season("冬天", "寒冷");
    // public static final Season AUTUMN = new Season("秋天", "凉爽");
    // public static final Season SUMMER = new Season("夏天", "炎热");
    //如果使用了 enum 来实现枚举类
    //1. 使用关键字 enum 替代 class
    //2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
    // SPRING("春天", "温暖") 解读 常量名(实参列表)
    //3. 如果有多个常量(对象)， 使用 ,号间隔即可
    //4. 如果使用 enum 来实现枚举，要求将定义常量对象，写在前面
    //5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"), SUMMER("夏天", "炎热")/*, What()*/;
    private String name;
    private String desc;//描述
    private Season2() {//无参构造器
    }
    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    @Override
    public String toString() {
        return "Season{" +
        "name='" + name + '\'' +
        ", desc='" + desc + '\'' +
        '}';
    }
}

注意事项：

  1. 当使用enum关键字开发一个枚举类时，默认会继承Enum类，而且是一个final类
  2. 传统的public static final Season2 SPRING = new Season2("春天","温暖");简化成SPRING("春天","温暖")，这里必须知道，它调用的是哪个构造器
  3. 如果使用无参构造器创建枚举对象，则实参列表和小括号都可以省略
  4. 当有多个枚举对象时，使用,间隔，最后有一个分号结尾
  5. 枚举对象必须放在枚举类的行首

常用方法说明

使用关键字enum时，会隐式继承Enum类，这样就可以使用Enum类的相关方法

public abstract class Enum<E extends Enum<E>>
        implements Comparable<E>, Serializable {
}

常用方法应用实例

  1. toString:Enum 类已经重写过了，返回的是当前对象名,子类可以重写该方法，用于返回对象的属性信息
  2. name：返回当前对象名（常量名），子类中不能重写
  3. ordinal：返回当前对象的位置号，默认从 0 开始
  4. values：返回当前枚举类中所有的常量
  5. valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！
  6. compareTo：比较两个枚举常量，比较的就是编号！
  7. 代码
public class EnumMethod {
    public static void main(String[] args) {
        //使用 Season2 枚举类，来演示各种方法
        Season2 autumn = Season2.AUTUMN;
        //输出枚举对象的名字
        System.out.println(autumn.name());
        //ordinal() 输出的是该枚举对象的次序/编号，从 0 开始编号
        //AUTUMN 枚举对象是第三个，因此输出 2
        System.out.println(autumn.ordinal());
        //从反编译可以看出 values 方法，返回 Season2[]
        //含有定义的所有枚举对象
        Season2[] values = Season2.values();
        System.out.println("===遍历取出枚举对象(增强 for)====");
        for (Season2 season: values) {//增强 for 循环
        System.out.println(season);
    }
    //valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常
    //执行流程
    //1. 根据你输入的 "AUTUMN" 到 Season2 的枚举对象去查找
    //2. 如果找到了，就返回，如果没有找到，就报错
    Season2 autumn1 = Season2.valueOf("AUTUMN");
    System.out.println("autumn1=" + autumn1);
    System.out.println(autumn == autumn1);
    //compareTo：比较两个枚举常量，比较的就是编号
    //1. 就是把 Season2.AUTUMN 枚举对象的编号 和 Season2.SUMMER 枚举对象的编号比较
    //2. 看看结果
    /*
    public final int compareTo(E o) {
        return self.ordinal - other.ordinal;
    }
    Season2.AUTUMN 的编号[2] - Season2.SUMMER 的编号[3]
    */
    System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));
    //补充了一个增强 for
    // int[] nums = {1, 2, 9};
    // //普通的 for 循环
    // System.out.println("=====普通的 for=====");
    // for (int i = 0; i < nums.length; i++) {
    //     System.out.println(nums[i]);
    // }
    // System.out.println("=====增强的 for=====");
    // //执行流程是 依次从 nums 数组中取出数据，赋给 i, 如果取出完毕，则退出 for
    // for(int i : nums) {
    //     System.out.println("i=" + i);
    // }
    }
}

enum实现接口

  1. 使用 enum 关键字后，就不能再继承其它类了，因为 enum 会隐式继承 Enum ，而 Java 是单继承机制。
  2. 枚举类和普通类一样，可以实现接口，如下形式。
    enum 类名 implements 接口 1 ，接口 2{}
  3. 代码 
public class EnumDetail {
    public static void main(String[] args) {
        Music.CLASSICMUSIC.playing();
    }
}

class A {

}

//1.使用 enum 关键字后，就不能再继承其它类了，因为 enum 会隐式继承 Enum，而 Java 是单继承机制
//enum Season3 extends A {
//
//}
//2.enum 实现的枚举类，仍然是一个类，所以还是可以实现接口的. 
interface IPlaying {
    public void playing();
}

enum Music implements IPlaying {
    CLASSICMUSIC;
    @Override
    public void playing() {
        System.out.println("播放好听的音乐...");
    }
}

注解

注解的理解

  1. 注解（Annotation）也被称为元数据（Metadata），用于修饰解释 包、类、方法、属性、构造器、局部变量等数据信息
  2. 和注释一样，注解不影响程序逻辑，但注解可以被编译或运行，相当于嵌入在代码中的补充信息
  3. 再JavaSE中，注解的使用目的比较简单，例如标记过时的功能，忽略警告等。在JavaSE中注解占据了更重要的角色，例如用来配置应用程序的任何切面，代替JavaEE旧版本中所遗留的繁冗代码和XML配置等

基本的Annotation介绍

使用 Annotation 时要在其前面增加 @ 符号 , 并把该 Annotation 当成一个修饰符使用，用于修饰它支持的程序元素。
三个基本的 Annotation:
  1. @Override: 限定某个方法，是重写父类方法, 该注解只能用于方法
  2. @Deprecated: 用于表示某个程序元素(类, 方法等)已过时
  3. @SuppressWarnings: 抑制编译器警告

应用案例

@Override注解的案例

@Override：限定某个方法，是重写父类的方法，该注解只能用于方法

class Father{

        public void fly(){

                System.out.println("Father fly...");

        }

}

class Son extends Father{

        @Override//说明 

        public void fly(){

                System.out.println("Son fly...");

        }

}

补充说明：@interface的说明

@interface不是interface，是注解类，是jdk5.0以后加入的

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

class Father{//父类
    public void fly(){
        System.out.println("Father fly...");
    }
    public void say(){}
}

class Son extends Father {//子类
    //1. @Override 注解放在 fly 方法上，表示子类的 fly 方法时重写了父类的 fly
    //2. 这里如果没有写 @Override 还是重写了父类 fly
    //3. 如果你写了@Override 注解，编译器就会去检查该方法是否真的重写了父类的
    // 方法，如果的确重写了，则编译通过，如果没有构成重写，则编译错误
    //4. 看看 @Override 的定义
    // 解读： 如果发现 @interface 表示一个 注解类
    /*
    @Target(ElementType.METHOD)
    @Retention(RetentionPolicy.SOURCE)
    public @interface Override {
    }
    */
    @Override //说明
    public void fly() {
        System.out.println("Son fly....");
    }
    @Override
    public void say() {}
}

说明：

  1. @Override表示指定重写父类的方法（从编译层面验证），如果父类没有fly方法，则会报错
  2. 如果不写@Override注解，而父类仍有public void fly(){}，仍然构成重写
  3. @Override只能修饰方法，不能修饰其他类、包、属性等等
  4. 查看@Override注解源码为@Target(ElementType.METHOD），说明只能修饰方法
  5. @Target是修饰注解的注解，称为元注解

@Deprecated 注解的案例

@Deprecated：用于表示某个程序元素（类、方法等）已过时

public class Deprecated_ {
    public static void main(String[] args) {
        A a = new A();
        a.hi();
        System.out.println(a.n1);
    }
}

//1. @Deprecated 修饰某个元素, 表示该元素已经过时
//2. 即不在推荐使用，但是仍然可以使用
//3. 查看 @Deprecated 注解类的源码
//4. 可以修饰方法，类，字段, 包, 参数 等等
//5. @Deprecated 可以做版本升级过渡使用
/*
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
*/

@Deprecated
class A {
    @Deprecated
    public int n1 = 10;
        @Deprecated
        public void hi(){
    }
}

说明：

  1. 用于表示某个程序元素（类、方法等）已过时
  2. 可以修饰方法，类，字段，包，参数 等等
  3. @Target(value={CONSTRUCTOR,FIELD,LOCAL_VARIABLE,METHOD,PACKAGE,TYPE})
  4. Deprecated 的作用可以做到新旧版本的兼容和过渡

@SuppressWarnings 注解的案例

@SuppressWarnings: 抑制编译器警告 
@SuppressWarnings({"rawtypes", "unchecked", "unused"})
public class SuppressWarnings_ {

    //1. 当我们不希望看到这些警告的时候，可以使用 SuppressWarnings 注解来抑制警告信息
    //2. 在{""} 中，可以写入你希望抑制(不显示)警告信息
    //3. 可以指定的警告类型有
    // all，抑制所有警告
    // boxing，抑制与封装/拆装作业相关的警告
    // //cast，抑制与强制转型作业相关的警告
    // //dep-ann，抑制与淘汰注释相关的警告
    // //deprecation，抑制与淘汰的相关警告
    // //fallthrough，抑制与 switch 陈述式中遗漏 break 相关的警告
    // //finally，抑制与未传回 finally 区块相关的警告
    // //hiding，抑制与隐藏变数的区域变数相关的警告
    // //incomplete-switch，抑制与 switch 陈述式(enum case)中遗漏项目相关的警告
    // //javadoc，抑制与 javadoc 相关的警告
    // //nls，抑制与非 nls 字串文字相关的警告
    // //null，抑制与空值分析相关的警告
    // //rawtypes，抑制与使用 raw 类型相关的警告
    // //resource，抑制与使用 Closeable 类型的资源相关的警告
    // //restriction，抑制与使用不建议或禁止参照相关的警告
    // //serial，抑制与可序列化的类别遗漏 serialVersionUID 栏位相关的警告
    // //static-access，抑制与静态存取不正确相关的警告
    // //static-method，抑制与可能宣告为 static 的方法相关的警告
    // //super，抑制与置换方法相关但不含 super 呼叫的警告
    // //synthetic-access，抑制与内部类别的存取未最佳化相关的警告
    // //sync-override，抑制因为置换同步方法而遗漏同步化的警告
    // //unchecked，抑制与未检查的作业相关的警告
    // //unqualified-field-access，抑制与栏位存取不合格相关的警告
    // //unused，抑制与未用的程式码及停用的程式码相关的警告
    //4. 关于 SuppressWarnings 作用范围是和你放置的位置相关
    // 比如 @SuppressWarnings 放置在 main 方法，那么抑制警告的范围就是 main
    // 通常我们可以放置具体的语句, 方法, 类. //5. 看看 @SuppressWarnings 源码
    //(1) 放置的位置就是 TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE
    //(2) 该注解类有数组 String[] values() 设置一个数组比如 {"rawtypes", "unchecked", "unused"}
    /*
    @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    @Retention(RetentionPolicy.SOURCE)
    public @interface SuppressWarnings {
        String[] value();
    }
    */
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        int i;
        System.out.println(list.get(1));
    }
    public void f1() {
        // @SuppressWarnings({"rawtypes"})
        List list = new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        // @SuppressWarnings({"unused"})
        int i;
        System.out.println(list.get(1));
    }
}

说明各种值：

  1. unchecked是忽略没有检查的警告
  2. rawtypes是忽略没有指定泛型的警告（传参时没有指定泛型的警告错误）
  3. unused是忽略没有使用某个变量的警告错误
  4. @SuppressWarnings可以修饰的程序元素为，查看@Target
  5. 生成@SuppressWarnings时，不用背，直接点击左侧的黄色提示，就可以选择（注意可以指定生成的位置）

JDK的元注解

基本介绍

JDK的元Annotation用于修饰其他Annotation

元注解的种类

  1. Retention //指定注解的作用范围，三种 SOURCE,CLASS,RUNTIME
  2. Target // 指定注解可以在哪些地方使用
  3. Documented //指定该注解是否会在 javadoc 体现
  4. Inherited //子类会继承父类注解
StudyHard、
关注
  • 28
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
韩顺平编写的java学习笔记(全)
10-20
韩顺平编写的java学习笔记(全) 包含各种java的基本语法,以及3大项目的详细设计解释以及代码
韩顺平Java笔记（自用）
08-01
韩顺平Java笔记（自用）
韩顺平java笔记完整版.zip（无笔记，只是代码）
10-10
韩顺平java笔记完整版 这是韩顺平老师java教学视频的全部笔记，所有代码都有的！（无笔记，只是代码）
韩顺平Java学习资料【笔记+代码】
05-12
内容概要：这份学习资料汇总了韩顺平老师的Java学习笔记和相关代码，旨在帮助学习者系统学习Java编程语言。笔记内容涵盖了Java语言基础、面向对象编程、数据结构与算法、网络编程、GUI编程等多个方面，通过清晰的...
jar包增量更新分析
junlaiyan的专栏
05-16 261
借助jdeps分析出jar包的增量文件
SpringBoot接入Knife4j接口文档
博主是个二次元死肥宅~
05-18 678
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
java实现拼图小游戏
monkey108的博客
05-16 621
本文主要提供用java实现的拼图小游戏源代码。
命令执行漏洞（二）
XLbb的博客
05-15 905
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 913
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
java数据结构与算法(验证二叉搜索树)
磐门的博客
05-17 248
节点返回空为ture,节点的值不在对应数据大小范围内返回false。将验证二叉搜索树计算同样可以转换为相同子问题，所以比较适合用递归。node为root的左节点时，max更新为root.val。node为root的右节点时，min更新为root.val。
C++ 11
qq_65112813的博客
05-17 654
对于类类型，如果定义了接受。
Kubernetes 审计日志采集与分析最佳实践
观测云的博客
05-17 1024
​Kubernetes 在 1.7 版本中发布了审计（Audit）日志功能，通过审计日志，我们能够非常清晰的知道 K8S 集群到底发生了什么事情。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 253
java导出excel动态加载多sheet多复杂表头
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
shijialeya
05-18 382
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器进行数据格式化。
Android Model引入其他aar包 导致无法打包成aar
qq_27400335的博客
05-16 343
Android Model引入其他aar包 导致无法打包成aar
SpringBoot事件发布与监听，观察者模式使用
小哇
05-16 217
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。
Solon 的 InjectGather 在 AppContext 里起到了什么作用？
最新发布
Itmastergo的博客
05-20 567
Solon是一款轻量级的Java开发框架，其设计理念简单且易于使用，主要应用于微服务和现代化的Java应用开发。Solon框架的核心目标是提供一个高效且简洁的开发环境，使开发者能够快速构建和部署应用程序。在Solon框架中，AppContext是核心上下文，它管理着整个应用程序的生命周期，包括bean的注册、依赖注入、事件管理等。AppContext是一个应用程序的核心容器，类似于Spring中的。Bean管理：负责注册和管理应用程序中的所有bean。依赖注入：提供自动化的依赖注入机制。事件管理。
Java基础——字符串
Kenard的博客
05-17 937
基本数据类型、包装类 转成字符串，调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换。下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。
初识Spring Cloud
u011627218的专栏
05-20 537
一、介绍。
韩顺平java学习资料
09-03
- *1* *2* *3* [韩顺平JAVA学习笔记(入门自用)](https://blog.csdn.net/m0_62366961/article/details/125382532)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值