[开发测试]20210813学习

#单元测试
语法要求: @Test + public + void+ 没有参数

单元测试方法

是java运行程序的最小单位
格式@Test + public + void + 没有参数
不能输入参数

浮点数据不精确解决方案

BigDecimal(String)
注意: 构造函数的参数是String,不是double,传double还有不精确有坑,传一个空串
2. 做除法运算时除不尽会报错,所以需要使用重载的除法divide(要除的对象,保留的小数,取舍范围)

内部类:

1. 能我们可以把内部类看作是外部类的一个特殊的成员
2. 内部类可以直接使用外部类的所有资源,包括私有资源
3. 外部类想要使用内部类的资源,需要创建内部类的对象才能使用
   成员内部类被private修饰以后,无法被外界直接创建创建对象时使用

所以可以创建外部类对象,通过外部类对象间接访问内部类的资源

局部内部类

位置: 类里方法外

被private修饰

被私有化的内部类在main()中无法创建其对象
可以在私有内部类所处的外部类当中,创建一个公共的方法供外界调用,这个方法就可以用来创建私有内部类的对象并且调用私有内部类的功能

被static修饰

static: 静态 ,优先于对象加载,加载可以通过类名直接调用
静态只能调用静态
静态内部类可以不创建外部类对象,直接通过外部类类名.的方式创建内部类对象
如果静态内部类中含有静态方法,那么我们可以不创建一个对象,直接通过链式加载的方式使用这个方法

局部内部类

位置: 方法里
直接通过外部类创建对象,调用局部内部类所处的这个方法时,并不会触发局部内部类的功能
所以如果想要使用局部内部类的功能,需要在局部内部类所处的方法中创建局部内部类的对象并且调用这个局部内部类的功能

匿名内部类

匿名对象:
没有名字的对象,只能使用一次,一次只能调用一个方法,如果想要调用多次,或者是多个方法,就需要创建普通对象,或是多个匿名对象才能完成.
匿名内部类通常与匿名结合在一起使用

new Inter1(){实现方法体}.play();

package cn.tedu.review;

/**
 * 本类用于包装类的复习
 * @author ZHU
 * @create 13/08/2021 10:11
 */
public class ReviewBox {
    public static void main(String[] args) {
        //1.创建方式
        Integer i1 = new Integer(100);
        Integer i2 = Integer.valueOf(100);
        Integer i3 = 100;

        Double d1 = new Double(6.6);
        Double d2 = Double.valueOf(6.6);
        Double d3 = 6.6;

        System.out.println(i1.parseInt("777") + 111);
        System.out.println(d2.parseDouble("7.7") + 1111);

        int i = i1;
        double d = d1;

    }
}

package cn.tedu.review;

import java.util.Objects;

/**
 * 本类用于顶级父类Object的复习
 * @author ZHU
 * @create 13/08/2021 09:03
 */
public class ReviewObject {
    public static void main(String[] args) {
        Student s1 = new Student(14453131,"zhu");
        Student s2 = new Student(14453131,"zhu");
        //4.通过全参构造创建学生类的对象
        System.out.println(s1.name);
        System.out.println(s1);
        System.out.println(s1.hashCode());
        System.out.println(s1.getClass());
        System.out.println(s1.toString());

        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        //7.测试equals()
        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }



}
class Student{
    int sno;
    String name;

    public Student() {
    }

    public Student(int sno, String name) {
        this.sno = sno;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return sno == student.sno && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(sno, name);
    }

    //添加重写的toString()
    //5.2 在Student类中添加了重写的toString() 后,打印Student{name = "zhu",sno =14453131}

    @Override
    public String toString() {
        return "Student{" +
                "sno=" + sno +
                ", name='" + name + '\'' +
                '}';
    }
}
//1.创建学生类
//2.提供学生类的属性 学号 姓名
//3.提供学生类的全参构造

package cn.tedu.review;

/**
 * 本类用于String的复习
 * @author ZHU
 * @create 13/08/2021 09:15
 */
public class ReviewString {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        char[] value = {'a','b','c'};
        String s3 = new String(value);
        /**
         * String类自己已经重写了继承自Object的toString(),所以可以直接String的对象s,打印出来的是串的具体内容
         */
        System.out.println(s1);

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));

        /**
         * String自己已经了继承自Object的equel()方法
         * 所以比较的不是地址值,不论创建方式,比较的都是两个串的具体内容,
         * 只要内容一致,就返回true
         */
        System.out.println(s1 == s3);
        System.out.println(s1.equals(s3));
    }
}
````

````java
package cn.tedu.review;

import java.util.Arrays;
import java.util.Locale;

/**
 * 本类用于复习常用类的常用方法
 * @author ZHU
 * @create 13/08/2021 09:41
 */
public class ReviewString2 {
    public static void main(String[] args) {
        //1.创建String类的对象
        String s1 = "abcde";
        System.out.println(s1.charAt(1));
        System.out.println(s1.concat("bbb"));
        String s2 = s1.concat("bbb");
        System.out.println(s2);
        System.out.println(s1.startsWith("a"));
        System.out.println(s2.endsWith("b"));

        String s3 = "abffff";
        System.out.println(s3.indexOf("b"));
        System.out.println(s3.lastIndexOf("f"));

        System.out.println(s3.length());

        System.out.println(s3.toUpperCase());
        System.out.println(s3.toLowerCase());

        String s4 = "ababaksdblskdblksdjfb";
        System.out.println(s4.split("b"));
        System.out.println(Arrays.toString(s4.split("b")));

        String s5 = "           kasl  dfk      ";
        System.out.println(s5.trim());

        System.out.println(String.valueOf(10) + 10);
        System.out.println(Integer.valueOf(10) + 10);

        String s6 = "sldkgskdg";
        System.out.println(s6.substring(3));
        System.out.println(s6.substring(3,7));

    }
}
````

````java
package cn.tedu.number;

import java.math.BigDecimal;
import java.util.Scanner;

/**
 * 本类用于解决浮点数不精确的问题
 * @author ZHU
 * @create 13/08/2021 10:22
 */
public class TestBigDecimal {
    public static void main(String[] args) {
      //  f1();//使用普通的四则运算计算浮点数型的数据
        f2();//使用BigDecimal来解决浮点数运算不精确的问题
    }
//使用BigDecimal计算
    private static void f2() {
        System.out.println("please input  two number");

        double a = new Scanner(System.in).nextDouble();
        double b = new Scanner(System.in).nextDouble();
        //2.create job class object
        /**
         * 最好不要使用double作为构造函数的参数,不然还会有不精确的现象,有坑
         * It is best not to use double as the parameter of the constructor, otherwise there will be inaccuracy and pits.
         * 最好使用重载的构造函数:  参数为String的构造函数
         * It's better to use overloaded constructor: constructor with String parameter
         * double转String  直接拼一个空串就可以,double与""拼接后就转为了String类型
         * Double to String can directly spell an empty string, double and "" will be converted to String type after concatenation
         */
        BigDecimal bd1 = new BigDecimal(a + "");
        BigDecimal bd2 = new BigDecimal(b + "");
        //3.使用工具类对象进行运算  Use tool objects to perform operations
        //3.1 定义一个变量用来保存结果  Define a variable to save the result
        BigDecimal bd3;
        //3.2 进行加法运算
        bd3 = bd1.add(bd2);
        System.out.println("add result: " + bd3);



        //substract
        bd3 = bd1.subtract(bd2);
        System.out.println("substract:" + bd3);

        //multiply
        bd3 = bd1.multiply((bd2));
        System.out.println("multiply: " + bd3);

        /**
         * divide(m,n,o)  -- m  代表的是除以哪个对象, n代表的是除不尽时保留的几位数,o代表的是舍入方式(比如四舍五入)
         */
        //divide
        bd3 = bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
        System.out.println("divide: "+bd3);

    }
//使用普通的四则运算
    private static void f1() {
        //1.提示并接受用户输入的两个小数
        System.out.println("please input  two number");

        double a = new Scanner(System.in).nextDouble();
        double b = new Scanner(System.in).nextDouble();

        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
    }
}

````

````java
package cn.tedu.junit2107;

import org.junit.Test;

import java.util.Scanner;

/**
 * 本类用于学习单元测试方法
 * @author ZHU
 * @create 13/08/2021 11:36
 */
public class TestJunit {
    /**
     * 单元测试方法,是java测试的最小单位,使用灵活,推荐指数:※※※※※
     * 语法要求:@Test  注解
     *          返回值类型为空
     *          没有参数
     *          public
     * 注意: junit是一个单元测试工具,使用前必须导包
     * Add Junit 4 library to the build path: import org.junit.Test
     */

    /**
     * 单元测试方法运行的方式: 选择方法名左侧的运行小三角,选择run   方法名即可
     */
    @Test
    public void TestFor(){
        for(int i =0 ; i < 10; i++){
            System.out.println(i);
        }

    }

    @Test
    public void TestFor2(){
       /* int n = new Scanner(System.in).nextInt();*/
        /**
         * 没有参数,我们需要设置可以直接使用的值
         */
        int n = 2;
        if(n == 1){
            System.out.println("今天中午吃麻辣烫");
        }else{
            System.out.println("今天中午吃板面");
        }
    }
}

package cn.tedu.innerclass;

/**
 * 本类用作内部类入门内部案例
 * @author ZHU
 * @create 13/08/2021 14:09
 */
public class TestInner1 {
    public static void main(String[] args) {
        //3.1外部类的对象,进行测试
        Outer o = new Outer();
        o.find();
        //3.2 创建外部类的匿名对象
        /**
         * 匿名对象就是没有名字的对象,匿名对象只能使用一次,
         */
        new Outer().find();
        new Outer().find();/**这是第二个匿名对象*/
        System.out.println(o.name);
        //匿名对象
        //3.2创建内部类的对象,进行测试

        //3.3创建内部类的对象,进行测试
        Outer.Inner oi = new Outer().new Inner();
        oi.delete();//需要创建内部类对象来使用内部类的方法
    }
}
//1.创建外部类
class Outer{
    //1.创建外部类的成员变量
    String name;
    private int age;
    public void find(){
        System.out.println("我是外部类的find()...");

        //4.测试外部类如何使用内部类的资源
        new Inner().delete();   //不能直接使用内部类的资源
        System.out.println(Inner.class);
    }

    //创建内部类
    /**
     * 根据内部类所处位置的不同,我们可以把内部类分为:
     * 成员内部类(类里方法外)
     * 局部内部类(方法里)
     */


    /**
     * 外部类如果想要使用内部类的资源,需要先创建内部类的对象
     * 通过内部类对象来调用内部类的资源
     */
    class Inner{
        int sum = 10;
        //2.2创建成员内部类
        public void delete(){
            System.out.println("我是成员内部类Inner的delete()....");

            //5.测试外部类是否可以使用外部属性
            /**
             * 内部类可以直接使用外部类的资源,私有成员也可以
             */
            System.out.println(age);
            System.out.println(name);
        }
    }


}

package cn.tedu.innerclass;

/**
 * 本类用于测试成员内部类被private修饰
 * @author ZHU
 * @create 13/08/2021 15:14
 */
public class TestInner2 {
    public static void main(String[] args) {
        //4.使用内部类的eat()方法
        //Outer2.Inner2 oi = new Outer2().new Inner2();
        //oi.eat();
        //6.创建外部类对象
        new Outer2().getInner2Eat();
        /**
         * 如果Inner2成员内部类被private修饰,无法直接创建对象该怎么办
         *
         */

    }
}

//1.创建外部类 Outer2
class Outer2{
    //5.我们对外提供公共的方法,在方法内部创建私有内部Inner2的对象,调用它的方法
    //5.1 创建私有内部类的对象
    public void getInner2Eat(){

        Inner2 in = new Inner2();
        in.eat();
    }

    /**
     * 成员内部类的位置在类里方法外
     */
    //2.创建私有的成员内部类
    private class Inner2{
        //3.创建内部类的普通方法
        public void eat(){
            System.out.println("我是私有成员内部类的普通方法eat()...");
        }
    }

}

package cn.tedu.innerclass;

/**
 * 本类用于测试成员内部类被static修饰
 * @author ZHU
 * @create 13/08/2021 15:36
 */
public class TestInner3 {
    public static void main(String[] args) {
        //4.创建内部类对象,调用方法
        Outer3.Inner3 oi = new Outer3.Inner3();
        oi.show();
        /***
         * 现象: 当内部类被Static修饰时, new Outer3() 会报错
         * 所以我们无需创建外部类对象,可以通过类名找到内部类
         * 直接创建静态内部类的对象即可
         */
        new Outer3.Inner3().show();

        //6.访问静态内部类的静态方法 --- 链式加载
        Outer3.Inner3.fly();
    }
}


//1.创建外部类
class Outer3{
    //2.创建内部类
    //静态内部类很不常用!!!!
   static class Inner3{
        //3.创建成员内部类的普通方法
        public void show(){
            System.out.println("我是成员内部类Inner3" +
                    "的普通方法show(),,,");
        }

        /**
         * 内部类作为外部类的特殊成员需要设置成静态,才能在静态类中添加静态方法
         */
        public  static  void fly(){
            System.out.println("我是成员内部类Inner3" +
                    "的静态方法fly()...");
        }
    }
}

package cn.tedu.innerclass;

import java.util.SortedMap;

/**
 * 本类用于测试局部内部类
 * @author ZHU
 * @create 13/08/2021 16:12
 */
public class TestInner4 {
    public static void main(String[] args) {
        //5.创建外部类对象并调用show()
        new Outer4().show();
        /**
         * 如何使用内部类的资源呢???
         * 注意:  直接创建外部类对象调用show()是无法触发内部类的功能的
         * 需要在外部类中创建内部类对象并且调用内部类的功能,才能触发
         */
    }
}

//1.创建外部类
class Outer4{
    //2.创建外部类成员方法
    public void show(){
        System.out.println("我是外部类的普通方法show()...");
        //3.创建局部内部类
        /**
         * 局部内部类: 位置: 方法里
         *
         */
        class Inner4{
            //4.创建局部内部类的属性和方法
            String name;
            int age;
            public void eat(){
                System.out.println("我是局部内部类的普通方法eat()...");
            }
        }
        /**
         * 6. 如何来使用局部内部类的功能呢?
         *
         */
        //6.在show() 中创建内部类对象并调用功能
        Inner4 i = new Inner4();
        i.eat();
        System.out.println(i.age);
        System.out.println(i.name);

    }
}

package cn.tedu.innerclass;

/**
 * 本类用于测试匿名内部类
 * @author ZHU
 * @create 13/08/2021 16:32
 */
public class TestInner5 {
    public static void main(String[] args) {
        /**
         * 接口可以创建对象吗? 不可以!!!
         *
         */
        //new Inter1(); 会报错
        /**
         * 所以我们现在相当于是3合1
         * 1) : new Inter1() ; -- 创建匿名对象
         * {方法的实现} - - 接口的实现类
         * .save() -- 表示匿名对象调用实现后的方法
         * 注意: 匿名内部类通常与匿名对象结合在一起使用
         * 匿名对象只能使用一次,一次只能调用一次方法
         */



        new Inter1(){

            @Override
            public void save() {
                System.out.println("saving");
            }

            @Override
            public void get() {
                System.out.println("geting");
            }

        }.save();

        new Inter2(){

            @Override
            public void dance() {

            }
        }.play();

        new Inter3().find();
        new Inter3().find2();
    }

}
interface Inter1{
    void save();
    void get();
//1.创建接口
    //2.定义接口中的抽象方法
}
//4.创建一个抽象类
abstract class Inter2{
    //5.创建抽象类中的普通方法和抽象方法
    public void play(){
        System.out.println("the normal method ...Inter2");
    }
    abstract public  void dance();
}

class Inter3{
    public void find(){
        System.out.println("finding");
    }
    public void find2(){
        System.out.println("finding2");
    }
}