尚硅谷JAVA基础（下）i. 涛哥【反射_注解】

模块24重点回顾:
  1.Lambda表达式
    a.格式:
      () -> {}
    b.使用条件:必须有函数式接口作为方法参数传递(有且只有一个抽象方法的接口叫做函数式接口,带@FunctionalInterface)
  2.新手怎么入门:
    a.观察是否是函数式接口作为方法参数传递
    b.如果是,考虑使用Lambda表达式
    c.调用方法,以匿名内部类形式传递实参
    d.从new接口开始到重写方法的方法名结束,选中,删除,别忘记删除右半个大括号
    e.在重写方法的参数后面以及方法体之间加->
  3.省略规则:
    a.重写方法的参数类型可以干掉
    b.如果重写方法只有一个参数,所在的小括号可以干掉
    c.如果方法体只有一句话,那么所在的大括号以及分号可以干掉
    d.如果方法体中只有一句话并且带return,那么所在的大括号,return,分号都干掉
        
        
  4.Stream流:流水线的流
    a.获取1:调用Collection中的方法stream() -> 针对集合
    b.获取2:调用Stream接口中的of(可变参数)  -> 针对数组
  
  5.方法:
    forEach:遍历  count:统计  filter:过滤  limit:获取前n个  skip:跳过前n个
    concat:流合并  collect:流转集合  distinct:去重复  map:转换流中的数据类型
        
  6.方法引用:
    a.被引用的方法要写在重写的方法里面
    b.被引用的方法从参数上,返回值上要和所在重写方法一致,而且引用的方法最好操作重写方法的参数
    c.干掉重写方法的参数,干掉->,干掉被引用方法的参数,将.改成::

模块25重点:
  1.会使用Junit单元测试
  2.知道反射是干啥的
  3.会使用反射中的API去操作class对象(构造,方法,属性)
  4.通过涛哥设计的案例,体会反射代码写出来的好处->多用于框架中
  5.会使用注解    
     

第一章 Junit单元测试

1.Junit介绍

1.概述:Junit是一个单元测试框架,可以代替main方法去执行其他的方法
2.作用:可以单独执行一个方法,测试该方法是否能跑通
3.注意:Junit是第三方工具,所以使用之前需要导入jar包    

2.Junit的基本使用(重点)

1.导入Junit的jar包
2.定义一个方法,在方法上写注解: @Test
3.执行方法:
  a.点击该方法左边的绿色按钮,点击run执行 -> 单独执行一个指定的方法
  b.如果想要执行所有带@Test的方法,点击类名左边绿色按钮,点击run执行 -> 执行当前类中所有带@Test的方法   

public class Demo01Junit {
    @Test
    public void add(){
        System.out.println("我是@Test执行的add方法");
    }

    @Test
    public void delete(){
        System.out.println("我是@Test执行的delete方法");
    }
}

 

3.Junit的注意事项

1.@Test不能修饰static方法
2.@Test不能修饰带参数的方法
3.@Test不能修饰带返回值的方法    

4.Junit相关注解

@Before:在@Test之前执行,有多少个@Test执行,@Before就执行多少次->都是用作初始化一些数据
@After:在@Test之后执行,有多少个@Test执行,@After就执行多少次-> 都是用作释放资源使用

public class Demo02Junit {
    @Test
    public void add(){

        System.out.println("我是@Test执行的add方法");
    }

    @Test
    public void delete(){

        System.out.println("我是@Test执行的delete方法");
    }


    @Before
    public void methodBefore(){
        System.out.println("我是@Before执行的方法");
    }

    @After
    public void methodAfter(){
        System.out.println("我是@After执行的方法");
    }

}

5.@Test以后怎么使用

public class Demo03Junit {
   /* public static void main(String[] args) {
        CategoryController cc = new CategoryController();
        int result = cc.add("蔬菜");
        System.out.println("result = " + result);

        List<String> list = cc.findAllCategory();
        System.out.println(list);
    }*/

    /**
     * 此方法专门测添加功能
     */
    @Test
    public void add(){
        CategoryController cc = new CategoryController();
        int result = cc.add("蔬菜");
        System.out.println("result = " + result);
    }

    /**
     * 此方法专门测查询所有功能
     */
    @Test
    public void findAllCategory(){
        CategoryController cc = new CategoryController();
        List<String> list = cc.findAllCategory();
        System.out.println(list);
    }
}

public class CategoryController {
    /**
     * 添加功能
     */
    public int add(String categoryName){
        ArrayList<String> list = new ArrayList<>();
        list.add(categoryName);
        return 1;//如果返回一个1,证明添加成功了
    }

    /**
     * 查询功能
     */
    public List<String> findAllCategory(){
        ArrayList<String> list = new ArrayList<>();
        list.add("蔬菜");
        list.add("水果");
        list.add("服装");
        list.add("电器");
        list.add("玩具");
        return list;
    }
}

其他注解

@BeforeClass:在@Test之前执行,只执行一次,可以修饰静态方法
@AfterClass:@Test之后执行,只执行一次,可以修饰静态方法

public class Demo04Junit {
    @Test
    public void add(){

        System.out.println("我是@Test执行的add方法");
    }

    @Test
    public void delete(){

        System.out.println("我是@Test执行的delete方法");
    }


    @BeforeClass
    public static void methodBefore(){
        System.out.println("我是@Before执行的方法");
    }

    @AfterClass
    public static void methodAfter(){
        System.out.println("我是@After执行的方法");
    }

}

第二章.类的加载时机

1.new对象
2.new子类对象(new子类对象先初始化父类)
3.执行main方法
4.调用静态成员
5.反射,创建Class对象

1.类加载器(了解)_ClassLoader

类加载器咱们基于jdk8讲解

1.概述:
   在jvm中,负责将本地上的class文件加载到内存的对象_ClassLoader
2.分类:
   BootStrapClassLoader:根类加载器->C语言写的,我们是获取不到的
                        也称之为引导类加载器,负责Java的核心类加载的
                        比如:System,String等
                        jre/lib/rt.jar下的类都是核心类
   ExtClassLoader:扩展类加载器
                  负责jre的扩展目录中的jar包的加载
                  在jdk中jre的lib目录下的ext目录
   AppClassLoader:系统类加载器
                  负责在jvm启动时加载来自java命令的class文件(自定义类),以及classPath环境变量所指定的jar包(第三方jar包)
        
    不同的类加载器负责加载不同的类
       
3.三者的关系(从类加载机制层面):AppClassLoader的父类加载器是ExtClassLoader
            ExtClassLoader的父类加载器是BootStrapClassLoader
 
  但是:他们从代码级别上来看,没有子父类继承关系->他们都有一个共同的父类->ClassLoader

4.获取类加载器对象:getClassLoader()是Class对象中的方法
  类名.class.getClassLoader()
  
5.获取类加载器对象对应的父类加载器
  ClassLoader类中的方法:ClassLoader  	
  getParent()->没啥用
      
6.双亲委派(全盘负责委托机制)

   a.Person类中有一个String
     Person本身是AppClassLoader加载
     String是BootStrapClassLoader加载
   b.加载顺序:
     Person本身是App加载,按道理来说String也是App加载
     但是App加载String的时候,先问一问Ext,说:Ext你加载这个String吗?
     Ext说:我不加载,我负责加载的是扩展类,但是app你别着急,我问问我爹去->boot
     Ext说:boot,你加载String吗?
     boot说:正好我加载核心类,行吧,我加载吧!
         
7.类加载器的cache(缓存)机制(扩展):一个类加载到内存之后,缓存中也会保存一份儿,后面如果再使用此类,如果缓存中保存了这个类,就直接返回他,如果没有才加载这个类.下一次如果有其他类在使用的时候就不会重新加载了,直接去缓存中拿,保证了类在内存中的唯一性
     
8.所以:类加载器的双亲委派和缓存机制共同造就了加载类的特点:保证了类在内存中的唯一性    

public class Demo01ClassLoader {
    public static void main(String[] args) {
        app();
        //ext();
        //boot();
    }

    /**
     * 负责加载核心类
     * rt.jar包中的类
     *
     * BootStrapClassLoader是C语言编写,我们获取不到
     */
    private static void boot() {
        ClassLoader classLoader = String.class.getClassLoader();