CGB2107 day11 2021.8.13 笔记

最新推荐文章于 2024-10-16 10:13:45 发布

利威尔兵短

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量189

点赞数

分类专栏：笔记文章标签： java

本文链接：https://blog.csdn.net/weixin_55740233/article/details/119667620

版权

笔记专栏收录该内容

26 篇文章 0 订阅

订阅专栏

复习：

1.String类自己已经重写了继承自Object的toString() ，所以可以直接打印String的对象，打印出来的是具体内容

2.String类自己已经重写了继承自Object的equals() ，所以比较的不是地址值，不论创建方式，比较的是两个串的具体内容，只要内容一致，就返回true

3.哈希码值作用：主要是为了区分不同的对象

3.String的常用方法

4.包装类

1.BigDecimal（）

作用：解决浮点数运算不精确的问题

1.最好不要使用double作为构造函数的参数，不然还会有不精确的现象，有坑！

2.最好使用重载的构造函数：参数为String的构造函数，double转String，直接拼一个空串就可以,double与 " " 拼接后就转为String类型

加法：add

减法：subtract

乘法：multiply

除法：divide(m,n,o)

m代表要除以哪个对象，n代表除不尽时保留几位数，o代表舍入方式（例如四舍五入）

package cn.tedu.number;

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

//本类用于解决浮点数运算不精确的问题
public class TestBigDecimal {
    public static void main(String[] args) {
//        f1();//使用普通四则运算计算浮点数据
        f2();//使用BigDecimal运算解决浮点数运算不精确的问题
    }

    private static void f2() {
        System.out.println("请输入两个小数：");
        double a=new Scanner(System.in).nextDouble();
        double b=new Scanner(System.in).nextDouble();
        //创建工具类对象
        BigDecimal bd1=new BigDecimal(a+"");
        BigDecimal bd2=new BigDecimal(b+"");
        BigDecimal a1=new BigDecimal(a+"");
        //运算
        //定义一个变量保存结果
        /*1.最好不要使用double作为构造函数的参数，不然还会有不精确的现象，有坑！
        *2.最好使用重载的构造函数：参数为String的构造函数
        * double转String，直接拼一个空串就可以,double与""拼接后就转为String类型*/
        BigDecimal bd3;
        //加法运算 add
        bd3=bd1.add(bd2);
        System.out.println(bd3);
        //减法 subtract
        bd3=bd1.subtract(bd2);
        System.out.println(bd3);
        //乘法运算multiply
        bd3=bd1.multiply(bd2);
        System.out.println(bd3);
        //除法运算
        //方案一：除不尽时会报错
//        bd3=bd1.divide(bd2);
        //方案二：提前指定除不尽时的保留位数
        /*divide(m,n,o)--m代表要除以哪个对象，
        n代表除不尽时保留几位数，o代表舍入方式（例如四舍五入）*/
        bd3=bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
        System.out.println("除法结果"+bd3);

    }

    private static void f1() {
        System.out.println("请输入两个小数：");
        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);



    }
}

2.单元测试方法

单元测试方法：是java测试的最小单位，使用灵活*****

语法要求：@Test+ public + void + 没有参数

注意：junit是个单元测试工具，使用前需要导包

Add Junit 4 library to the build path:import org.junit.Test

package cn.tedu.junit2107;

import org.junit.Test;

//本类用于学习单元测试方法
public class TestJunit {
    /*单元测试方法：是java测试的最小单位，使用灵活*****
    * 语法要求：@Test + void + 没有参数 + public
    * 注意：junit是个单元测试工具，使用前需要导包
    * Add Junit 4 library to the build path:import org.junit.Test
    * */
    @Test
    public void testFor(){
        for (int i = 0; i < 10; i++) {
            System.out.println("循环"+i);
        }
    }
}

3.内部类

类里有类

根据内部类所处位置的不同，可以把内部类分为：成员内部类（类里方法外）、局部内部类（方法里）

匿名对象就是没有名字的对象，匿名对象只能使用一次

特点：

1）外部类对象不能直接使用内部类资源，需要先创建内部类的对象，通过内部类对象来调用内部类资源

2）内部类可以直接使用外部类的资源，私有成员也可以

3）成员内部类位置为类里方法外

4）局部内部类位置为方法里

5）被privte修饰的内部类为私有内部类，在外部类内对外提供公共的方法，在方法内部创建私有内部类的对象，调用它的方法

练习1：内部类入门案例

package cn.tedu.innerclass;
//本来用于内部类入门案例
public class TestInner1 {
    public static void main(String[] args) {


        //创建外部类对象测试
        Outer o=new Outer();
        o.find();
        System.out.println(o.name);
        //创建外部类的匿名对象
        new Outer().find();
        new Outer().find();/*这是第二个匿名对象*/
        /*匿名对象就是没有名字的对象，匿名对象只能使用一次*/
        //创建内部类对象
        Outer.Inner oi=new Outer().new Inner();
        oi.delete();//需要创建内部类对象来使用内部类的方法
//        o.delete(); 会报错，外部类对象无法直接使用内部类的资源
        System.out.println(oi.sum);//内部类对象调用内部类属性
    }

}

//1.创建外部类
class Outer{
//    1.1创建外部类的成员变量
    String name;
    private int age;
    public void find(){
        class f{
            int a=1;
            public void eat(){
                System.out.println();
            }
        }


        System.out.println("我是外部类的find()");
        //4.测试外部类如何使用内部类的资源
//        delete();//会报错 不能直接使用内部类的资源
//        System.out.println(sum);同上
        /*外部类如果想要使用内部类的资源，需要先创建内部类的对象
        * 通过内部类对象来调用内部类资源*/
        Inner in=new Inner();
        in.delete();
        System.out.println(in.sum);
    }
    //2.创建成员内部类
    /*根据内部类所处位置的不同，可以把内部类分为：
    * 成员内部类（类里方法外）  局部内部类（方法里）*/
    class Inner{
        //2.1创建成员内部类的成员变量
        int sum=10;
        //2.2创建成员内部类的成员方法
        public void delete(){
            System.out.println("我是成员内部类的delete()");
            /*内部类可以直接使用外部类的资源，私有成员也可以！*/
            /*注意：此处的代码测试完毕需要注释掉否则来回调用会抛出异常
            * StackOverFlowError 栈溢出异常*/
//            find();
            System.out.println(name);
            System.out.println(age);
        }
    }
}

练习2：测试成员内部类被private修饰

成员内部类被Private修饰以后,无法被外界直接创建创建对象使用

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

package cn.tedu.innerclass;
//本类用于测试成员内部类被private修饰
public class TeatInner2 {
    public static void main(String[] args) {
        /*如果Inner2成员内部类被private修饰，无法直接创建对象该怎么办？↓5.*/
        //使用内部类的eat()
//        Outer2.Inner2 oi=new Outer2().new Inner2();
//        oi.eat();
        //6.创建外部类对象
        new Outer2();
    }
}
//1.创建外部类
class Outer2{
    //5.对外提供公共的方法，在方法内部创建私有内部类Inner2的对象，调用它的方法
    public void getInner2Eat(){
        //5.1创建私有内部类对象
        Inner2 in=new Inner2();
        //5.2调用私有内部类方法
        in.eat();
    }
    /*成员内类的位置在类里方法外*/
    //2.创建私有成员内部类
    private class Inner2{
        //3.创建私有成员内部类的普通方法
        public void eat(){
            System.out.println("我是私有成员内部类的普通方法eat()");
        }
    }


}

练习3：成员内部类被static修饰

内部类作为外部类的一个特殊成员，需要设置成静态，才能在静态内部类中添加静态方法

当内部类被static修饰时，无需创建外部类对象，可以通过类名找到内部类，直接创建静态内部类的对象即可

链式加载：调用静态内部类的静态方法

package cn.tedu.innerclass;
//本类用于测试成员内部类被static修饰
public class TestInner3 {
    public static void main(String[] args) {
        /*现象：当内部类被static修饰时，new Outer3()会报错
         * 所以我们无需创建外部类对象，可以通过类名找到内部类
         * 直接创建静态内部类的对象即可*/
        //创建内部类对象调用方法
//    Outer3.Inner3 oi=new Outer3().new Inner3();
        Outer3.Inner3 oi=new Outer3.Inner3();
        new Outer3.Inner3().show();
        oi.show();
        //访问静态内部类的静态方法--链式加载
        new Outer3.Inner3().fly();

    }

}
class Outer3{
    static class Inner3{
        public void show(){
            System.out.println("我是成员内部类Inner3的普通方法show()");
        }
        /*内部类作为外部类的一个特殊成员，需要设置成静态，才能在静态内部类中添加静态方法*/
        public static void fly(){
            System.out.println("我是成员内部类Inner3的静态方法fly()");
        }
    }
    //创建成员内部类的静态方法




}

练习4：局部内部类

位置：方法里

如何使用内部类的资源呢？

直接创建外部类对象调用方法是无法触发内部类的功能的，需要在外部类中创建内部类对象，并且调用内部类的功能才能触发

package cn.tedu.innerclass;
//本类用于测试局部内部类
public class TestInner4 {
    public static void main(String[] args) {
        //创建外部类对象并调用方法
        new Outer4().show();
        /*如何使用内部类的资源呢？
        * 直接创建外部类对象调用show()是无法触发内部类的功能的
        * 需要在外部类中创建内部类对象，并且调用内部类的功能才能触发*/

    }
}
class Outer4{
    public void show(){
        System.out.println("我是外部类的普通方法show()");
        /*局部内部类位置：方法里*/
        //创建局部内部类
        class Inner4{
            //创建局部内部类的属性方法
            String name;
            int age;
            public void eat(){
                System.out.println("我是局部内部类的普通方法eat()");
            }


        }
        /*如何使用局部内部类的功能呢？*/
        //在show()创建对象并调用功能
        Inner4 i=new Inner4();
        i.eat();

    }
}

练习5：匿名内部类

所以我们现在相当于3合1

1）new Inter1();--创建对象

2）{方法的实现}--接口的实现类

3）.save()--表示匿名对象调用实现后的方法

注意：匿名内部类通常与匿名对象结合在一起使用

匿名对象只能使用一次，一次只能调用一个方法

package cn.tedu.innerclass;
//本类用于测试匿名内部类
public class TestInner5 {
    public static void main(String[] args) {
        /*接口可以创建对象吗？不可以！！！*/
//        new Inter1();会报错
                /*所以我们现在相当于3合1
                * 1）new Inter1();--创建对象
                * 2）{方法的实现}--接口的实现类
                * 3）.save()--表示匿名对象调用实现后的方法
                * 注意：匿名内部类通常与匿名对象结合在一起使用
                * 匿名对象只能使用一次，一次只能调用一个方法*/
        //3.创建匿名内部类并调用方法
        new Inter1(){
            @Override
            public void save() {
                System.out.println("正在保存");
            }

            @Override
            public void get() {

            }
        }.save();

        new Inter2(){
            @Override
            public void dance() {
                System.out.println("一起来跳舞");
            }
        }.dance();
        new Inter3().find2();


    }
}
//1.创建接口
interface Inter1{
    //2.定义接口中抽象方法
    void save();
    void get();
}
//4.创建抽象类
abstract class Inter2{
    public void play(){
        System.out.println("普通方法Inter2");
    }
    abstract  public  void dance();
}
class Inter3{
    public void find(){
        System.out.println("查询1");
    }
    public void find2(){
        System.out.println("查询2");
    }
}