day23

最新推荐文章于 2022-05-10 19:08:32 发布

一个胖小白

最新推荐文章于 2022-05-10 19:08:32 发布

阅读量114

点赞数

分类专栏：自己笔记文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_46002359/article/details/123411805

版权

笔记同时被 2 个专栏收录

75 篇文章 0 订阅

订阅专栏

自己

42 篇文章 0 订阅

订阅专栏

day23

一、Junit

1.使用来做局部测试，可以快速寻找bug
2.测试分为：黑盒测试(功能测试)和白盒测试（侧开）
3.黑盒测试：功能测试(按照需求文档来进行测试)与接口测试  
4.白盒测试：测开(测试开发工程师)编写自动化脚本的代码（java与python）
5.Junit使用步骤：
	A.定义一个方法
		1.方法的访问修饰符 public  
		2.返回值只能使用void
6.一些架包下载地址：https://mvnrepository.com/

二、反射

2.1 反射基础

1.反射是所有框架的灵魂 ，所有的框架都需要使用反射
2.反射使用场景：A.框架 B.热修复
3.反射的机制：是将类的各个部分组成一个新的对象（Class 对象）这就反射机制

反射的图解：

在这里插入图片描述

2.2 反射获取Class对象

第一种方法：通过对象名.getClass()  （使用比较少）
第二种方式：通过类名.Class()来进行获取
第三次方法：Class.forName("完整的包名+类名")  （比较常用）

测试：Student没有什么东西

package com.lt.demo05;

import org.junit.Test;

public class Test01 {

    @Test
    public  void showInfo() throws ClassNotFoundException {
        Student stu = new Student();

        //第一种方法：
        Class aClass = stu.getClass();
        System.out.println(aClass);

        //第二种方法
        Class studentClass = Student.class;
        System.out.println(studentClass);

        //第三种方法
        Class aClass1 = Class.forName("com.lt.demo05.Student");
        System.out.println(aClass1);
    }
}

2.3 获取构造方法

A.public Constructor<?>[] getConstructors()
	获取所有的公有的构造方法
B.public Constructor<?>[] getDeclaredConstructors()
	获取所有的构造方法(包括私有的)
C.public Constructor getConstructor(Class<?>...parameterTypes)
 	获取单个公有的构造方法
 D.public Constructor getDeclaredConstructor(Class<?>...parameterTypes)
 	获取单个私有的构造方法

测试类：

package com.lt.demo06;

import org.junit.Test;

import java.lang.reflect.Constructor;

public class Test01 {

    @Test
    public void showInfo01() throws ClassNotFoundException {
        //获取Class对象
        Class aClass = Class.forName("com.lt.demo06.Student");
        /**
         * 获取所有的公有的构造方法
         */
        Constructor[] cons = aClass.getConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
    }


    @Test
    public void showInfo02() throws ClassNotFoundException {
        //获取Class对象
        Class aClass = Class.forName("com.lt.demo06.Student");
        /**
         * 获取所有的的构造方法（包括私有的）
         */
        Constructor[] cons = aClass.getDeclaredConstructors();
        for (Constructor con : cons) {
            System.out.println(con);
        }
    }

    @Test
    public void showInfo03() throws ClassNotFoundException, NoSuchMethodException {
        //获取Class对象
        Class aClass = Class.forName("com.lt.demo06.Student");
        /**
         * 获取单个的公有的构造方法
         */
        Constructor con = aClass.getConstructor();
        System.out.println(con);
    }

    @Test
    public void showInfo04() throws ClassNotFoundException, NoSuchMethodException {
        //获取Class对象
        Class aClass = Class.forName("com.lt.demo06.Student");
        /**
         * 获取一个的公有的构造方法
         */
        Constructor con = aClass.getDeclaredConstructor();
        System.out.println(con);

    }
}

学生类：

package com.lt.demo06;

public class Student {
    private String name;
    private int age;

    public Student(){

    }

    private Student(String s){
        this.name=s;
    }

    public void showInfo(){
        System.out.println("公有的方法");

    }

    private void show(String s){
        System.out.println(s);
    }
}

2.4 获取成员方法

A.public Method[] getMethods()
		获取所有的公有的方法(包括父类公有的方法)
B.public Method[] getDeclaredMethods()
		获取所有的方法(包括私有)
C.public Method getMethod(String name, Class<?>...parameterTypes)
		获取单个公有的方法
D.public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
		获取单个私有的方法

测试类：

package com.lt.demo07;

import org.junit.Test;

import java.lang.reflect.Method;

public class Test01 {

    @Test
    public void showInfo01() throws ClassNotFoundException {
        //获取Class对象
        Class<?> aClass = Class.forName("com.lt.demo07.Student");
        //使用方法
        /**
         * 获取所有的公有的方法(包含父类的方法)
         */
        Method[] m1 = aClass.getMethods();
        for (Method method : m1) {
            System.out.println(method);
        }

    }


    @Test
    public void showInfo02() throws ClassNotFoundException {
        //获取Class对象
        Class<?> aClass = Class.forName("com.lt.demo07.Student");
        //使用方法
        /**
         * 获取所有的方法(包含私有的方法)
         */
        Method[] m1 = aClass.getDeclaredMethods();
        for (Method method : m1) {
            System.out.println(method);
        }
    }

    @Test
    public void showInfo03() throws ClassNotFoundException, NoSuchMethodException {
        //获取Class对象
        Class<?> aClass = Class.forName("com.lt.demo07.Student");
        //使用方法
        /**
         * 获取单个的公有的方法
         */
        Method m1 = aClass.getMethod("showInfo");
        System.out.println(m1);

    }


    @Test
    public void showInfo04() throws ClassNotFoundException, NoSuchMethodException {
        //获取Class对象
        Class<?> aClass = Class.forName("com.lt.demo07.Student");
        //使用方法
        /**
         * 获取单个的私有的方法
         */
        Method m1 = aClass.getDeclaredMethod("show", String.class);
        System.out.println(m1);

    }
}

Student类：

package com.lt.demo07;

public class Student {
    private String name;
    private int age;

    public Student(){

    }

    private Student(String s){
        this.name=s;
    }

    public void showInfo(){
        System.out.println("公有的方法");

    }

    private void show(String s){
        System.out.println(s);
    }

}

2.5 案例-利用反射来忽略集合泛型

分析：

1.List<String> li = new ArrayList<>()
2.调用集合的方法 add() ===>只能存String类型的数据
3.利用反射来获取add方法
	public Method getMethod("就是方法的名称",Object.class)
4.调用方法进行赋值

package com.lt.demo08;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class Test01 {

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //实例化集合
        List<String> li = new ArrayList<>();
        li.add("kad");

        //获取当前li对象的Class
        Class<? extends List> aClass = li.getClass();
        //后去方法
        Method add = aClass.getMethod("add", Object.class);
        //调用方法来进行赋值
        add.invoke(li,10);
        //遍历集合  注意li的类型是Object
        for (Object s : li) {
            System.out.println(s);
        }

    }
    
}

2.6 案例-不懂java代码，调用类中的任意方法

三、jdk1.8和jdk1.9的新特性

1.在jdk1.8之后，接口之中不仅有抽象方法，还有其他的方法
2.增加的方法：
	jdk1.8：默认的方法和静态的方法
	jdk1.9：私有的方法
3.影响：接口中有其他的方法，缩小了接口与抽象类的差距，接口可以多实现，多继承，普遍使用是常态
4.默认的方法：
	A.使用default来进行修饰的方法
	B.语法：
		访问修饰符 default 返回值类型方法名（参数列表）{
			方法体；
			return 返回值；
		}
	C.特点：1.接口中的默认的方法只能够通过实例化来进行调用
			2.接口中的默认的方法 实现类不能够重写
			3.实现类的其他方法可以调用接口中的默认方法
				语法：接口的名称.super.方法名()
5.静态的方法：
	A.使用static来修饰的方法
	B.语法：
		访问修饰符 static 返回值类型方法名（参数列表）{
			方法体；
			return 返回值；
		}
	C.特点：
		1.中的静态方法可以通过类名来进行调用
		2.接口的实现类不能够来重写接口的静态方法
6.私有的方法：
	A.使用private来修饰的方法，在jdk1.9之后才有的方法
	B.语法：
		private 返回值类型 方法名（参数列表）{
			方法体；
			return 返回值；
		}
	C.特点：
		1.私有的方法可以使用默认的方法来进行调用
		2.私有的静态的方法只能够是默认的和静态的方法来进行调用

四、Lambda表达式

1.本质：一个匿名的接口
2.前提：必须是函数型接口 接口里面只有以一个抽象方法 可以有其他方法 
3.作用：简化匿名内部类的写法
4.语法：(参数)->{方法体}
5.解释：
	(参数)==>接口中抽象方法的参数
	->指向符
	{方法体}==> 执行方法的操作
6.Lambda表达式简化的方法：
	A.如果方法只有一个参数，小括号和数据类型可以省略
	B.如果方法体只有一句话，这句话是return的话，就可以省略大括号、return与分号
	C.如果方法没有返回值，只有一句方法体，可以省略大括号与分号

4.1 简单使用

package com.lt.demo09;

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

        //没有使用Lambda表达式
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        }).start();


        //使用Lambda表达式
        new Thread(()->{
            System.out.println(Thread.currentThread().getName());
        }).start();
    }
}

4.2 没有返回值没有函数是接口

接口：

package com.lt.demo10;

public interface Inner {
    public void show();
}

测试类：

package com.lt.demo10;

public class Test {
    public static void main(String[] args) {
        showImfo(()->{
            System.out.println("我是在主函数里面方法");
        });

        //进行简化：
        showImfo(()->System.out.println("我是简化后的方法"));

    }

    //使用带接口参数的方法来调用接口中的方法
    public static void showImfo(Inner inner){
        inner.show();
    }
}

4.3 带返回值的接口

接口：

package com.lt.demo11;

public interface Inner {
    int getSum(int num1,int num2);
}

测试类：

package com.lt.demo11;

public class Test {
    public static void main(String[] args) {
        /*System.out.println(getSum(10, 20, new Inner() {
            @Override
            public int getSum(int num1, int num2) {
                return num1+num2;
            }
        }));*/


        //使用Lambda表达式

        System.out.println(getSum(10,30,(int num1,int num2)->{
            return num1+num2;
        }));
    }

    public static int getSum(int num1,int num2, Inner inner){
        return inner.getSum(num1,num2);
    }
}

4.4 一个参数有返回值的接口

接口：

package com.lt.demo12;

public interface Inner {
    int getSum(int num1);
}

测试类：

package com.lt.demo12;

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

        System.out.println(getSum(10,num1 -> {
            return num1;
        }));

        //使用Lambda表达式
        System.out.println(getSum(20,num1 -> num1));

    }

    public static int getSum(int num1, Inner inner){
        return inner.getSum(num1);
    }
}