Java13-注解+反射和内部类

1 注解

1.1 分类

• l JDK自带注解
• l 元注解
• l 自定义注解

1.2 JDK注解

l @Override
l @Deprecated标记就表明这个方法已经过时了，但我就要用，别提示我过期
l @SuppressWarnings(“deprecation”) 忽略警告
l @SafeVarargs jdk1.7出现，堆污染，不常用
l @FunctionallInterface jdk1.8出现，配合函数式编程拉姆达表达式，不常用

1.3 元注解

l @Target 注解用在哪里：类上、方法上、属性上
l @Retention 注解的生命周期：源文件中、class文件中、运行中
l @Inherited 允许子注解继承
l @Documented 生成javadoc时会包含注解，不常用
l @Repeatable注解为可重复类型注解，可以在同一个地方多次使用，不常用

1.3.1 @Target ElementType.class

描述注解的使用范围：

l  ElementType.ANNOTATION_TYPE        应用于注释类型
l  ElementType.CONSTRUCTOR         应用于构造函数
l  ElementType.FIELD                   应用于字段或属性
l  ElementType.LOCAL_VARIABLE      应用于局部变量
l  ElementType.METHOD              应用于方法级
l  ElementType.PACKAGE             应用于包声明
l  ElementType.PARAMETER           应用于方法的参数
l  ElementType.TYPE                应用于类的元素

1.3.2 @Retention RetentionPolicy.class

定义了该注解被保留的时间长短，某些注解仅出现在源代码中，而被编译器丢弃；
而另一些却被编译在class文件中； 编译在class文件中的注解可能会被虚拟机忽略，而另一些在class被装载时将被读取。
为何要分有没有呢？没有时，反射就拿不到，从而就无法去识别处理。
l SOURCE 在源文件中有效（即源文件保留）
l CLASS 在class文件中有效（即class保留）
l RUNTIME 在运行时有效（即运行时保留）

1.4 自定义注解

@Target({ElementType.METHOD , ElementType.PACKAGE})//作用范围
@Retention(RetentionPolicy.SOURCE)//生命周期
@Target({ElementType.TYPE})//作用于类上
@interface Test{
    //3，定义属性
    int age() default 0;//使用时，必须给age属性赋值，如：age=X。除非设置好默认值。

	//()不是参数，也不能写参数，只是特殊语法   
    //4，特殊属性value
    String value() default "";//使用时，必须给value属性赋值，如：X  |  value=X。除非设置好默认值
}

2 反射

2.1 概念

Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，也有称作“自省”。反射非常强大，它甚至能直接操作程序的私有属性。
反射就像一面镜子，它可以在运行时获取一个类的所有信息，可以获取到任何定义的信息（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。

2.2 反射Class类对象

Class.forName(“类的全路径”);
类名.class
对象.getClass();

Class clazz = Student.class;
Class<?> clazz2 = Class.forName("seday15.Student");
Class clazz3 = new Student().getClass();

2.3 常用方法

2.4 暴力反射

指可以将程序中的私有的属性或者方法通过反射技术，暴力的获取到资源

2.4.1 常用方法

3 内部类

3.1 概述

如果一个类存在的意义就是为指定的另一个类，可以把这个类放入另一个类的内部。就是把类定义在类的内部的情况就可以形成内部类的形式。
A类中又定义了B类，B类就是内部类。B类可以当做A类的一个成员看待

3.2 特点

1、 内部类可以直接访问外部类中的成员，包括私有成员
2、 外部类要访问内部类的成员，必须要建立内部类的对象
3、 在成员位置的内部类是成员内部类
4、 在局部位置的内部类是局部内部类

3.3 成员内部类

被private修饰

package cn.tedu.inner;
//测试内部类被private修饰
public class Test5_InnerClass2 {
    public static void main(String[] args) {
       //创建内部类对象，并执行show()
//     Outer2.Inner2 oi = new Outer2().new Inner2();//报错，Inner2已经被private了
       //3，测试被private的内部类的资源能否执行
       new Outer2().test();
    }
}
class Outer2{
    //2，如果想要访问private的内部类，可以访问外部类提供的对应方法
    public void test() {
       //访问内部类方法
       new Inner2().show();
    }

    //位置在类里方法外--成员内部类
    //1，内部类可以被private修饰，但是外界无法直接创建对象了！
    private class Inner2{
       public void show() {
           System.out.println("Inner2.show()");
       }
    }
}

被static修饰

package cn.tedu.inner;
//测试内部类被static修饰
public class Test6_InnerClass3 {
    public static void main(String[] args) {
       // 创建内部类对象测试show()
//     Outer3.Inner3 oi = new Outer3().new Inner3();//报错，原因是Inner3是静态的内部类
Outer3.Inner3 oi = new Outer3.Inner3();//Outer3.Inner3通过类名.调用类中的静态资源
       oi.show();   
       Outer3.Inner3.show2();//调用静态内部类里的静态方法
    }
}

class Outer3{
  //1，内部类被static修饰--随着类的加载而加载，会造成内存资源浪费，并不常用！
    static class Inner3{
       public void show() {
           System.out.println("Inner3.show()");
       }
       static public void show2() {
           System.out.println("Inner3.show2()");
       }
    }
}

3.4 匿名内部类

匿名内部类属于局部内部类，并且是没有名字的内部类

package cn.tedu.inner;

//测试匿名内部类
public class Test8_InnerClass5 {
    public static void main(String[] args) {
       new Hello() {// 匿名对象，本身接口不能new，这里new Hello()匿名对象，就相当于Hello接口的实现类
           // 匿名内部类
           @Override
           public void save() {
              System.out.println("save()..");
           }

           @Override
           public void update() {
              System.out.println("update()..");
           }
       }.update();// 触发指定的方法
       new Hello2() {//抽象类的匿名内部类
           @Override
           public void show() {  }
       }.show();

       new Animal() {//普通类的匿名内部类
           @Override
           public void eat() {   }
       };
    }
}

//TODO 创建匿名对象+匿名内部类测试
class Animal{
    public void eat() {}
}
abstract class Hello2 {
    abstract public void show();
    public void delete() {   }
}

// 定义接口
interface Hello {
    void save();
    void update();
}