day20-java(改)

内部类

静态内部类

package com.itheima.demo01innerclass.staticinnerclass;

/**
 * 外部类
 */
public class Person {
    private static String name;
    public int age;

    public static String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public void show(){
        System.out.println(name+"今年"+age+"岁");
    }


    /**
     * 内部类：使用static修饰,属于外部类
     * 成分、特点和使用都与普通类一样，只是位置在其他类中
     * 可以直接访问外部类静态成员，不能直接访问外部类实例成员
     * 注意：开发中实际运用较少
     */
    public static class Heart{
        private String size;
        public int xinLv;

        public void pulse(){
            //访问外部类静态成员
            System.out.println(name+"的心脏在跳动");
//            System.out.println(age);报错，无法访问外部类实例成员
        }
        public Heart() {
        }

        public Heart(String size, int xinlv) {
            this.size = size;
            this.xinLv = xinlv;
        }

        public String getSize() {
            return size;
        }

        public void setSize(String size) {
            this.size = size;
        }

        public int getXinlv() {
            return xinLv;
        }

        public void setXinlv(int xinlv) {
            this.xinLv = xinlv;
        }
    }
}

测试类

package com.itheima.demo01innerclass.staticinnerclass;

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Person shifan = new Person();
        Person.setName("shifan");
        //定义静态内部类对象
        Person.Heart heart = new Person.Heart();
        heart.pulse();
    }
}

内部类

package com.itheima.demo01innerclass.innerclass;

/**
 * 外部类
 */
public class Outer {
    private String num;
    private String name;
    private int a = 30;
    public static int b;

    public Outer() {
    }

    public Outer(String name) {
        this.name = name;
    }

    public String getNum() {
        return num;
    }

    public void setNum(String num) {
        this.num = num;
    }

    /**
     * 成员内部类：
     * 没有static修饰，属于外部类对象
     * 可以直接访问外部类静态成员、实例成员
     */
    public class Inner{
        //JDK16开始成员内部类中支持定义静态成员，之前不支持
        //public static String name;
        private int a = 20;
        public void show(){
            //访问外部类静态成员
            System.out.println(b);
            //访问外部类实例成员
            System.out.println(name);
            int a = 10;
            System.out.println("局部变量："+a);
            System.out.println("内部类变量："+this.a);
            System.out.println("外部类变量："+Outer.this.a);
        }
    }
}

测试类

package com.itheima.demo01innerclass.innerclass;

/**
 * 测试类
 * 成员内部类创建对象格式：
 * 外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器
 * 访问内部类静态成员格式：
 * 外部类名.内部类名.静态成员名
 */
public class Test {
    public static void main(String[] args) {
        Outer.b = 5;
        //注意这里调用外部类有参构造器时赋值，
        // 内部类访问外部类实例成员时才不是默认初始化值
        Outer.Inner inner = new Outer("时帆").new Inner();
        inner.show();
    }
}

局部内部类

package com.itheima.demo01innerclass.partinnerclass;

/**
 * 局部内部类：（鸡肋）
 * 定义在方法、代码块、构造方法等执行体中
 * 局部内部类的类文件名为：外部类$N内部类.class
 */
public class Test {
    static {
        class B{

        }
        abstract class C{

        }

    }
    public static void main(String[] args) {
        //方法内局部内部类
        class A{
            private String name;

            public A() {

            }

            public String getName() {
                return name;
            }

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

            public A(String name) {
                this.name = name;
            }
        }
        A a = new A();
        a.setName("aa");
        System.out.println(a.getName());
        System.out.println(a.name);
    }
}

匿名内部类

概述

package com.itheima.demo01innerclass.anonymousclass.demo01;

/**
 * 匿名内部类：
 * 本质上是一个没有名字的局部内部类，定义在方法、代码块等中
 * 作用：方便创建子类对象，简化代码编写
 * 格式：new 类名|抽象类名|接口名（）{
 *     重写方法；
 * }
 * 例如:Person p = new Person(){
 *     public void run(){}
 * }
 * p.run();
 * 特点：1.匿名内部类是一个没有名字的内部类
 *       2.匿名内部类写出来就会创建一个匿名内部类的对象
 *       3.匿名内部类对象的类型相当于当前new的那个类型的子类
 */
public class Test1 {
    public static void main(String[] args) {
        //创建一个匿名内部类对象，其类型相当于Animal的子类
        Animal dog = new Animal() {
            //重写Animal类的方法
            @Override
            public void run(){
                System.out.println("狗跑得很快");
            }
        };
        dog.run();
        dog.eat();
    }
}

使用形式

package com.itheima.demo01innerclass.anonymousclass.demo02;

/**
 * 匿名内部类的使用形式（语法）
 */
public class Test {
    public static void main(String[] args) {
        Swim teacher = new Swim() {
            @Override
            public void swim() {
                System.out.println("老师游不动");
            }
        };
        swimming(teacher);
        Swim student = new Swim() {
            @Override
            public void swim() {
                System.out.println("学生游得很快");
            }
        };
        swimming(student);

        swimming(new Swim() {

            @Override
            public void swim() {
                System.out.println("运动员游得飞快");
            }
        });
    }
    public static void swimming(Swim swim){
        System.out.println("开始游泳‍");
        swim.swim();
        System.out.println("======================================");
    }
}

真实应用

package com.itheima.demo01innerclass.anonymousclass.demo03;

import javax.swing.*;

/**
 匿名内部类的真实使用场景
 什么时候使用匿名内部类由具体场景决定
 */
public class Test {
    public static void main(String[] args) {
        //定义一个窗口
        JFrame frm = new JFrame("窗口界面");

        //定义一块桌布
        JPanel pnl = new JPanel();

        //将桌布添加到窗口中去
        frm.add(pnl);

        //定义一个按钮
        JButton btn = new JButton("点我弹出消息提示");

        //给按钮绑定一个监听器
//        btn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JOptionPane.showMessageDialog(frm,"消息弹窗就是我");
            }
        });
        //使用匿名内部类简化代码后：
        btn.addActionListener(e ->{ JOptionPane.showMessageDialog(frm,"消息弹窗就是我"); });

        //将按钮添加到桌布上,按钮添加到窗口里会占满整个窗口
        pnl.add(btn);

        //展示窗口
        frm.setSize(300,300);
        frm.setLocationRelativeTo(null);
        frm.setVisible(true);
    }
}

API

Object类下的toString()和equals()

toString方法

测试类

package com.itheima.demo02api.demo01tostring;

/**
 * 测试类
 * toString方法属于Object类，所有类都直接或间接继承了Object类
 * 该方法默认返回对象的地址值
 * 其作用为让子类重写实现返回对象的内容
 */
public class Test {
    public static void main(String[] args) {
        Student s = new Student("时帆",20);
        //重写toString方法后输出对象的内容
        System.out.println(s.toString());
        //直接输出对象变量，默认可以省略toString调用
        System.out.println(s);
    }
}

学生类

package com.itheima.demo02api.demo01tostring;

/**
 * 学生类，类中重写了toString方法
 */
public class Student {
    private String name;
    private int age;

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

//    @Override
//    public String toString(){
//        return "Student {"+"name='"+name +"'"+",age="+age+"}";
//    }


    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

    public Student() {
    }
}

equals方法

测试类

package com.itheima.demo02api.demo02equals;

/**
 * 测试类
 * equals方法属于Object类，它默认比较两个对象的地址是否相同
 * 其作用为让子类重写它，实现比较对象内容的功能
 */
public class Test {
    public static void main(String[] args) {
        Teacher t1 = new Teacher("时帆",1000);
        Teacher t2 = new Teacher("时帆",1000);
        System.out.println(t1.equals(t2));
    }
}

老师类

package com.itheima.demo02api.demo02equals;

import java.util.Objects;

public class Teacher {
    private String name;
    private int salay;
//    重写equals方法，实现比较对象内容
//    @Override
//    public boolean equals(Object o){
//        if (o instanceof Teacher){
//            Teacher t = (Teacher) o;
//            return name.equals(t.name)&&salay == t.salay;
//        }else {
//            return false;
//        }
//    }

    @Override
    public boolean equals(Object o) {
        //判断是否为同一个对象
        if (this == o) {return true;}
        //判断对象o是否为null以及o和调用对象的类型是否相同
        if (o == null || getClass() != o.getClass()) {return false;}
        Teacher teacher = (Teacher) o;
        return salay == teacher.salay &&
                //Objects中的equals方法做了非空校验，不会报空指针异常
                Objects.equals(name, teacher.name);
    }


    public String getName() {
        return name;
    }

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

    public int getSalay() {
        return salay;
    }

    public void setSalay(int salay) {
        this.salay = salay;
    }

    public Teacher(String name, int salay) {
        this.name = name;
        this.salay = salay;
    }

    public Teacher() {
    }
}

Objects类下的equals方法和isNull方法

package com.itheima.demo02api.demo03objectsapi;

import com.itheima.demo02api.demo01tostring.Student;

import java.util.Objects;

/**
 * 测试类
 * Objects类中的equals方法和isNull方法
 */
public class Test {
    public static void main(String[] args) {
        Student s1 = null;
        Student s2 = new Student("shifan",39);
        //报空指针异常
        System.out.println(s1.equals(s2));
        //使用Objects类中的equals方法可解决该问题
/*        public static boolean equals(Object a, Object b) {
            //如果传入的类型重写了equals方法比较内容，则该方法也是比较内容
            return (a == b) || (a != null && a.equals(b));
        }
*/
        //输出false
        System.out.println(Objects.equals(s1, s2));
        //输出true，相当于==
        System.out.println(Objects.isNull(s1));
        s2 = null;
        //true
        System.out.println(s1 == s2);
    }
}

Math类API

package com.itheima.demo02api.demo04math;

/**
 * Math类的常用方法
 */
public class Test {
    public static void main(String[] args) {
        //取绝对值
        //10
        System.out.println(Math.abs(10));
        //10.4
        System.out.println(Math.abs(-10.4));

        //向上取整
        //4.0
        System.out.println(Math.ceil(3.1));
        //向下取整
        //2.0
        System.out.println(Math.floor(2.9));

        //求指数次方
        //1024.0
        System.out.println(Math.pow(2, 10));

        //四舍五入
        //3
        System.out.println(Math.round(3.499999));
        //5
        System.out.println(Math.round(4.500001));

        //随机数[0.0,0.1)
        System.out.println(Math.random());

        //拓展：产生[3,8]之间随机整数
        System.out.println((int) (Math.random() * 6) + 3);
    }
}

System类API

package com.itheima.demo02api.demo05system;

import java.util.Arrays;

/**
 * System类中的常用方法
 */
public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始了");

        //结束Java虚拟机，0表示正常结束
        //System.exit(0);

        //获取当前时间毫秒值，从1970.1.1.0:00:00开始到现在
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            System.out.println(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("运行时间:"+((endTime - startTime)/1000.0)+"s");

/*
        数组拷贝：
            public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
            第一个参数：被拷贝的数组
            第二个参数：开始位置索引
            第三个参数：目标数组
            第四个参数：粘贴位置索引
            第五个参数：拷贝长度
*/
        int[] arr1 = {1,2,5,3,6};
        int[] arr2 = new int[5];
        //将arr1中的5和3拷贝到arr2中的相同索引位置
        System.arraycopy(arr1,2,arr2,2,2);
        System.out.println(Arrays.toString(arr2));
        System.out.println("程序结束了");
    }
}

BigDecimal类API

package com.itheima.demo02api.demo06bigdecimal;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * BigDecimal类的方法及使用
 */
public class Test {
    public static void main(String[] args) {
        //double类型存在丢失精度问题
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        //0.30000000000000004
        System.out.println(c);

        //使用BigDecimal类解决
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        //BigDecimal类加法
        //BigDecimal c1 = a1.add(b1);
        //BigDecimal类减法
        //BigDecimal c1 = a1.subtract(b1);
        //BigDecimal类乘法
        //BigDecimal c1 = a1.multiply(b1);
        //BigDecimal类除法
        BigDecimal c1 = a1.divide(b1);
        System.out.println(c1);

        //目的：double
        double cc1 = c1.doubleValue();
        System.out.println(cc1);

        //注意事项：BigDecimal是一定要精度运算的
        BigDecimal x1 = BigDecimal.valueOf(10.0);
        BigDecimal x2 = BigDecimal.valueOf(3.0);
        //报错
        //BigDecimal x3 = x1.divide(x2);

        /*
        解决BigDecimal无法实现精度运算问题
        public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
        第一个参数：被除数
        第二个参数：保留小数位数
        第三个参数：舍入模式
    */

        BigDecimal x3 = x1.divide(x2,3, RoundingMode.HALF_UP);
		//3.333
        System.out.println(x3);
    }
}

练习

题目1

package com.itheima.exercises.exercise1;

public class Demo1 {
    public static void main(String[] args) {
        // 请补齐代码，使得编译通过，并在控制台输出(吃饭)
        Demo1 d = new Demo1();
        d.eat();
    }

    public void eat(){
        System.out.println("吃饭!");
    }

题目2

package com.itheima.exercises.exercise2;

//Person类
class Person{
public static void eat(){
        System.out.println("吃饭!");
        }
}
//测试类
public class Test{
    public static void main(String[] args){
        // 请补齐代码，调用method方法,使得method方法运行
        method();
    }

    //定义静态方法
    public static void method(){
        // 请补齐代码，调用Person类中的eat方法
        Person.eat();
    }
}

题目3

package com.itheima.exercises.exercise3;

/**
 * 请完善下列代码，在main方法中调用Inner的method方法,输出30
 */
public class Demo3 {
    public static void main(String[] args) {
        // 请在此处调用Inner类中的method方法
        Outer.Inner inner = new Outer().new Inner();
        inner.method();
    }
}

class Outer {
    class Inner {
        public void method(){
            int num = 30;
            System.out.println(num);
        }
    }
}

题目4

package com.itheima.exercises.exercise4;

/**
 * 今日,金燕龙110教室为学生的自习室,自习室中今天只来了大郎和金莲两个同学
 * 由于老师开会,需要占用教室,所以大郎和金莲两位学生需要更换到金燕龙111教室
 * 设计程序,完成需求.
 */
public class Test {
    public static void main(String[] args) {
        Student.classRoom = "金燕龙110教室";
        Student stu1 = new Student("大郎", 123);
        Student stu2 = new Student("金莲", 111);
        System.out.println("学号为:"+stu1.getNum()+"的"+stu1.getName()+"在"+Student.getClassRoom()+"自习!");
        System.out.println("学号为:"+stu2.getNum()+"的"+stu2.getName()+"在"+Student.getClassRoom()+"自习!");
        Student.classRoom = "金燕龙111教室";
        System.out.println("更换教室之后:");
        System.out.println("学号为:"+stu1.getNum()+"的"+stu1.getName()+"在"+Student.getClassRoom()+"自习!");
        System.out.println("学号为:"+stu2.getNum()+"的"+stu2.getName()+"在"+Student.getClassRoom()+"自习!");

    }
}

学生类

package com.itheima.exercises.exercise4;

public class Student {
    private String name;
    private int num;
    public static String classRoom;

    public static String getClassRoom() {
        return classRoom;
    }

    public static void setClassRoom(String classRoom) {
        Student.classRoom = classRoom;
    }

    public String getName() {
        return name;
    }

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

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

    public Student() {
    }
}

题目5

package com.itheima.exercises.exercise5;

/**
 * 如图所示,我们电脑上都有USB接口,当我们的鼠标和键盘插上去之后才可以使用,拔出来就关闭使用.
 * 其实具体是什么USB设备，笔记本并不关心，只要符合USB规格的设备都可以。
 * 鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，
 * 不然鼠标和键盘的生产出来无法使用;根据描述设计程序,完成键盘和鼠标插在电脑上就开启,
 * 拔出来就关闭的需求.
 */
public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //连接鼠标
        computer.install(new USB() {

            @Override
            public void connect() {
                System.out.println("鼠标已连接");
            }

            @Override
            public void unconnect() {
                System.out.println("鼠标已断开");
            }
        });

        //断开鼠标
        computer.uninstall(new USB() {

            @Override
            public void connect() {
                System.out.println("鼠标已连接");
            }

            @Override
            public void unconnect() {
                System.out.println("鼠标已断开");
            }
        });
        //连接键盘
        computer.install(new USB() {

            @Override
            public void connect() {
                System.out.println("键盘已连接");
            }

            @Override
            public void unconnect() {
                System.out.println("键盘已断开");
            }
        });
        //断开键盘
        computer.uninstall(new USB() {

            @Override
            public void connect() {
                System.out.println("键盘已连接");
            }

            @Override
            public void unconnect() {
                System.out.println("键盘已断开");
            }
        });
    }
}

电脑类

package com.itheima.exercises.exercise5;

public class Computer {
    //安装USB设备方法
    
    public void install(USB usb){
        usb.connect();
    }
    //卸载USB设备方法
    
    public void uninstall(USB usb){
        usb.unconnect();
    }
}

USB接口

package com.itheima.exercises.exercise5;

public interface USB {
    void connect();
    void unconnect();
}