注解和反射Stream 流以及四大函数式接口及Lambda表达式

一，注解

1,Annotation

可以被人读也可以被程序读

@Override//重写的注解
    public String toString() {
   
        return super.toString();
    }

2，内置注解

 @Override//重写的注解
    public String toString() {
   
        return super.toString();
    }
    @Deprecated//Deprecated不推荐使用，但是可以使用，或者存在更好的方式
    public static void test(){
   
        System.out.println("Deprecated");
    }
    @SuppressWarnings("all")//抑制警告信息
    public void test1(){
   
        List list=new ArrayList();
    }

3，元注解

//测试元注解
@MyAnnotation
public class Test {
   
    public static void main(String[] args) {
   

    }
}

//Target表示我们的注解可以用在哪些地方
@Target(value = {
   ElementType.METHOD, ElementType.TYPE})

//@Retention在什么地方有效
//RUNTIME>CLASS>SOURCES
@Retention(value = RetentionPolicy.RUNTIME)

//@Documented 表示是否将我们的注解生成在Javadoc文档中
@Documented

//@Inherited 子类可以继承父类的注解
@Inherited
//定义一个注解
@interface MyAnnotation{
   

}

4，自定义注解

   //注解可以显示赋值，如果没有赋值，我们必须给注解赋值
    @MyAnnotation2(age = 18,name = "某某")
    public void test(){
   
    }
    @MyAnnotation3("某某某")
    public void test2(){
   }//如果只有一个参数成员，一般参数名为value
    public static void main(String[] args) {
   
    }
}
@Target({
   ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation2{
   
    //注解的参数： 参数类型+参数名();
    String name() default"";
    int age();
    int id() default -1;//如果默认值为-1，代表不存在
    String[] school() default{
   "大学","大大学"};
}
@Target({
   ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation3{
   
    String value();
}

二，反射机制

1，Reflection机制概述

java静态语言，有了反射机制，使得java成为动态语言

1.1静态 & 动态语言

动态语言JavaScript

function f() {
   
    var x="var a=3;var b=5;alert(a+b)";
    eval(x);
}

1.2反射机制概念

1.3Java反射机制提供的功能

1.4反射的优缺点以及反射相关的主要API

1.5反射测试

//什么叫反射
public class ReflectionTest {
   
    public static void main(String[] args) throws ClassNotFoundException {
   
        //通过反射获取类的class对象
        Class aClass1=Class.forName("com.company.User");
        System.out.println(aClass1);
        Class aClass2=Class.forName("com.company.User");
        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(aClass1.hashCode());
        System.out.println(aClass2.hashCode());
    }
}
//实体类 pojo entity
class User{
   
    private String name;
    private int id;
    private int age;
    public User() {
   
    }
    public User(String name,int id,int age){
   
        this.name=name;
        this.id=id;
        this.age=age;
    }

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public int getId() {
   
        return id;
    }

    public void setId(int id) {
   
        this.id = id;
    }

    public int getAge() {
   
        return age;
    }

    public void setAge(int age) {
   
        this.age = age;
    }

    @Override
    public String toString() {
   
        return "User{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

2，理解Class类并获取Class实例

2.1Class类

2.2Class类的常用方法

2.3获取Class类的实例

1，若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高.

Class clazz = Person.class;

2，已知某个类的实例,调用该实例的getClass()方法获取Class对象

Class clazz = person.getClass();

3，已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出空指针异常

Class clazz = class.forName("demo01.Student");

4，内置基本数据类型可以直接用类名.TYPE
测试Class类的创建方式有哪些代码：

//测试Class类的创建方式有哪些
public class ClassCreateTest {
   
    public static void main(String[] args) throws ClassNotFoundException {
   
        Person person=new Student();
        System.out.println("这个人是："+person.name);
        //方式一：通过对象获得
        Class aClass1=person.getClass();
        System.out.println(aClass1.hashCode());
        //方式二：forname获得
        Class aClass2=Class.forName("com.company.Student");
        System.out.println(aClass2.hashCode());
        //方式三：通过类名.class获得
        Class aClass3=Student.class;
        System.out.println(aClass3.hashCode());
        //方式四：基本内置类型的包装类都有一个type属性
        Class aClass4=Integer.TYPE;
        System.out.println(aClass4);
        //获得父类类型
        Class aClass5=aClass1.getSuperclass();
        System.out.println(aClass5);
    }
}
class Person{
   
    public String name;
    public Person()<