java进阶教程：2023.3.10第十二天，java面向对象进阶（多态、内部类、常用API）

前言

记录时间：2023.3.10

已坚持的第十二天

java从入门到精通

学习java时间历程记录打卡

早上6：00到 12：00

下午1：00到 6：30

完成代码练习

1.d1_polymorphic

1.认识多态的形式

package cn.vqqc.d1_polymorphic;

/**
 父类
 */
public class Animal {
    public String name = "动物名称";
    public void run(){
        System.out.println("动物可以跑");
    }
}

package cn.vqqc.d1_polymorphic;

public class Dog extends Animal{
    public String name = "狗名称";
    @Override
    public void run() {
        System.out.println("狗跑的贼溜");
    }
}

package cn.vqqc.d1_polymorphic;

public class Tortoise extends Animal{
    public String name = "乌龟名称";

    @Override
    public void run() {
        System.out.println("乌龟跑的非常慢");
    }
}

package cn.vqqc.d1_polymorphic;

public class Test {
    public static void main(String[] args) {
        // 目标：先认识多态的形式
        // 父类  对象名称 = new 子类构造器();
        Animal a = new Dog();
        a.run(); // 方法调用：编译看左，运行看右
        System.out.println(a.name); // 方法调用：编译看左，运行也看左，动物名称

        Animal a1 = new Dog();
        a1.run();
        System.out.println(a1.name); // 动物名称
    }
}

2.d2_polymorphic_advantage

1.多态的独有功能

package cn.vqqc.d2_polymorphic_advantage;

/**
 父类
 */
public class Animal {
    public String name = "动物名称";
    public void run(){
        System.out.println("动物可以跑");
    }
}

package cn.vqqc.d2_polymorphic_advantage;

public class Dog extends Animal {
    public String name = "狗名称";
    @Override
    public void run() {
        System.out.println("狗跑的贼溜");
    }

    /**
     独有功能
     */
    public void lookDoor(){
        System.out.println("狗在看门！");
    }
}

package cn.vqqc.d2_polymorphic_advantage;

public class Tortoise extends Animal {
    public String name = "乌龟名称";

    @Override
    public void run() {
        System.out.println("乌龟跑的非常慢");
    }
}

package cn.vqqc.d2_polymorphic_advantage;

public class Test {
    public static void main(String[] args) {
        Animal d = new Dog();
        go(d);
//         d.lookDoor();

        Animal t = new Tortoise();
        go(t);
    }

    /**
     希望这个方法可以接收一切子类动物对象
     * @param a
     */
    public static void go(Animal a){
        System.out.println("预备");
        a.run();
        System.out.println("结束");
    }
}

3.d3_polymorphic_convert

1.学习多态形式下的类中转换机制

package cn.vqqc.d3_polymorphic_convert;

/**
 父类
 */
public class Animal {
    public String name = "动物名称";
    public void run(){
        System.out.println("动物可以跑");
    }
}

package cn.vqqc.d3_polymorphic_convert;

public class Dog extends Animal {
    public String name = "狗名称";
    @Override
    public void run() {
        System.out.println("狗跑的贼溜");
    }

    /**
     独有功能
     */
    public void lookDoor(){
        System.out.println("狗在看门！");
    }
}

package cn.vqqc.d3_polymorphic_convert;

public class Tortoise extends Animal {
    public String name = "乌龟名称";

    @Override
    public void run() {
        System.out.println("乌龟跑的非常慢");
    }

    /**
     独有功能
     */
    public void layEggs(){
        System.out.println("乌龟在下蛋");
    }
}

package cn.vqqc.d3_polymorphic_convert;

/**
 目标：学习多态形式下的类中转换机制
 */
public class Test {
    public static void main(String[] args) {
        // 自动类型转换
        Animal a = new Dog();
        a.run();
//        a.lookDoor(); // 多态下无法调用子类独有功能

        // 强制类型转换:可以实现调用子类独有功能的
        Dog d = (Dog) a;
        d.lookDoor();

        // 注意：多态下直接强制类型转换，可能出现类型转换异常
        // 规定：有继承或者实现关系的2个类型就可以强制类型转换，运行时可能出现问题
        // Tortoise t1 = (Tortoise) a;
        // 建议强制转换前，先判断变量指向对象的真实类型，再强制类型转换
        if(a instanceof Tortoise){
            Tortoise t = (Tortoise) a;
            t.layEggs();
        }else if(a instanceof Dog){
            Dog d1 = (Dog) a;
            d1.lookDoor();
        }

        System.out.println("---------------------");
        Animal a1 = new Dog();
        go(a1);
    }

    public static void go(Animal a){
        System.out.println("预备");
        a.run();
        // 独有功能
        if(a instanceof Tortoise){
            Tortoise t = (Tortoise) a;
            t.layEggs();
        }else if(a instanceof Dog){
            Dog d1 = (Dog) a;
            d1.lookDoor();
        }
        System.out.println("结束");
    }
}

4.d4_polymorphic_test

1.USB设备模拟

package cn.vqqc.d4_polymorphic_test;

public class Computer {
    /**
     提供一个安装的入口：行为
     */
    public void installUSB(USB u){
        u.connect();

        // 独有功能
        if(u instanceof Mouse){
            Mouse m = (Mouse) u;
            m.click();
        }else if(u instanceof KeyBoard) {
            KeyBoard k = (KeyBoard) u;
            k.keyDown();
        }

        u.unconnect();
    }
}

package cn.vqqc.d4_polymorphic_test;

/**
 实现类（子类）
 */
public class KeyBoard implements USB{

    private String name;


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

    @Override
    public void connect() {
        System.out.println(name + "成功的接入了设备了");
    }

    @Override
    public void unconnect() {
        System.out.println(name + "成功的从设备弹出了");
    }

    /**
     独有功能
     */
    public void keyDown(){
        System.out.println(name + "写下了：老铁，6666，下次再来哦，老弟");
    }

    public String getName() {
        return name;
    }

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

package cn.vqqc.d4_polymorphic_test;


/**
 实现类（子类）
 */
public class Mouse implements USB{
    private String name;

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

    @Override
    public void connect() {
        System.out.println(name + "成功的接入了设备了");
    }

    @Override
    public void unconnect() {
        System.out.println(name + "成功的从设备弹出了");
    }

    /**
     独有功能
     */
    public void click(){
        System.out.println(name + "双击点亮小红心");
    }

    public String getName() {
        return name;
    }

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

package cn.vqqc.d4_polymorphic_test;

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

package cn.vqqc.d4_polymorphic_test;
/**
 目标：USB设备模拟
 1、定义USB接口：接入 拔出
 2、定义2个USB的实现类：鼠标、键盘。
 3、创建一个电脑对象，创建USB设备对象，安装启动。
 */
public class Test {
    public static void main(String[] args) {
        // a、创建电脑对象
        Computer c = new Computer();
        // b、创建USB设备对象
        USB u = new Mouse("罗技鼠标");
        c.installUSB(u);

        USB k = new KeyBoard("双飞燕键盘");
        c.installUSB(k);
    }

}

5.d5_innerclass_static

1.学习静态外部和内部类

package cn.vqqc.d5_innerclass_static;

/**
 外部类
 */
public class Outer {

    public static int a = 100;
    private String hobby;

    /**
     学习静态成员内部类
     */
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName;

        public Inner(){}

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

        public void show(){
            System.out.println("名称：" + name);
            System.out.println(a);
            // System.out.println(hobby); // 报错！
//            Outer o = new Outer();
//            System.out.println(o.hobby);
        }

        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;
        }
    }
}

package cn.vqqc.d5_innerclass_static;

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer.Inner();
        in.setName("张三");
        in.show();
    }
}

6.d6_innerclass

1.学习静态外部和内部类

package cn.vqqc.d6_innerclass;

/**
 外部类
 */
public class Outer {
    public static int num = 111;
    private String hobby;

    public Outer() {
    }

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

    /**
     成员内部类：不能加static修饰 属于外部类对象的
     */
    public class Inner{
        private String name;
        private int age;
        public static int a = 100; // JDK 16开始支持静态成员了

        public static void test(){
            System.out.println(a);
        }

        public void show(){
            System.out.println("名称：" + name);
            System.out.println("数量：" + num);
            System.out.println("爱好：" + hobby);
        }

        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;
        }
    }
}

package cn.vqqc.d6_innerclass;


public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner();
        in.setName("内部");
        in.show();
        Outer.Inner.test();

        System.out.println("------------");
        Outer.Inner in1 = new Outer("爱听课").new Inner();
        in1.show();
    }
}

package cn.vqqc.d6_innerclass;

public class Test2 {
    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
        heart.show();
    }
}

class People{
    private int heartbeat = 150;

    /**
     成员内部类
     */
    public class Heart{
        private int heartbeat = 110;

        public void show(){
            int heartbeat = 78;
            System.out.println(heartbeat); // 78
            System.out.println(this.heartbeat); // 110
            System.out.println(People.this.heartbeat); // 150
        }
    }
}

package cn.vqqc.d6_innerclass;

public class Test2 {
    public static void main(String[] args) {
        People.Heart heart = new People().new Heart();
        heart.show();
    }
}

class People{
    private int heartbeat = 150;

    /**
     成员内部类
     */
    public class Heart{
        private int heartbeat = 110;

        public void show(){
            int heartbeat = 78;
            System.out.println(heartbeat); // 78
            System.out.println(this.heartbeat); // 110
            System.out.println(People.this.heartbeat); // 150
        }
    }
}

7.d7_innerclass

1.了解局部内部类的语法

package cn.vqqc.d7_innerclass;

/**
 目标：了解局部内部类的语法
 */
public class Test {

    static {
        class Dog{

        }

        abstract class Animal{

        }

        interface SportManInter{

        }
    }

    public static void main(String[] args) {
        class Cat{
            private String name;

            public static int onLineNumber = 100;

            public String getName() {
                return name;
            }

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

        interface SportManInter{

        }

        Cat c = new Cat();
        c.setName("叮当猫");
        System.out.println(c.getName());
    }
}

8.d8_innerclass_anonymous

1.学习匿名内部类的形式和特点

package cn.vqqc.d8_innerclass_anonymous;


/**
 目标：学习匿名内部类的形式和特点
 */
public class Test {
    public static void main(String[] args) {
        Animal a = new Animal(){
            @Override
            public void run() {
                System.out.println("老虎跑的快");
            }
        };
        a.run();
    }
}

//class Tiger extends Animal{
//    @Override
//    public void run() {
//        System.out.println("老虎跑的快");
//    }
//}

abstract class Animal{
    public abstract void run();
}

2.掌握匿名内部类的使用形式

package cn.vqqc.d8_innerclass_anonymous;


/**
 目标：掌握匿名内部类的使用形式（语法）
 */
public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生快乐的自由泳‍");
            }
        };
        go(s);

        System.out.println("--------------");

        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师游泳的贼快");
            }
        };
        go(s1);

        System.out.println("--------------");

        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("运动员游的贼快啊");
            }
        });


    }

    /**
     学生 老师 运动员可以一起参加游泳比赛
     */
    public static void go(Swimming s){
        System.out.println("开始。。。");
        s.swim();
        System.out.println("结束。。。");
    }
}


interface Swimming{
    void swim();
}

9.d9_api_object

1.理解object

package cn.vqqc.d9_api_object;

import java.util.Objects;

public class Student { //extends Object{
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    /**
     定制相等规则。
     两个对象的内容一样就认为是相等的
     s1.equals(s2)
     比较者：s1 == this
     被比较者： s2 ==> o
     */
    @Override
    public boolean equals(Object o) {
        // 1、判断是否是同一个对象比较，如果是返回true。
        if (this == o) return true;
        // 2、如果o是null返回false  如果o不是学生类型返回false  ...Student !=  ..Pig
        if (o == null || this.getClass() != o.getClass()) return false;
        // 3、说明o一定是学生类型而且不为null
        Student student = (Student) o;
        return sex == student.sex && age == student.age && Objects.equals(name, student.name);
    }


    /**
     自己重写equals，自己定制相等规则。
     两个对象的内容一样就认为是相等的
     s1.equals(s2)
     比较者：s1 == this
     被比较者： s2 ==> o
     */
 /*   @Override
    public boolean equals(Object o){
        // 1、判断o是不是学生类型
        if(o instanceof Student){
            Student s2 = (Student) o;
            // 2、判断2个对象的内容是否一样。
//            if(this.name.equals(s2.name) &&
//                 this.age == s2.age && this.sex == s2.sex){
//                return true;
//            }else {
//                return false;
//            }
            return this.name.equals(s2.name) && this.age == s2.age
                    && this.sex == s2.sex ;

        }else {
            // 学生只能和学生比较，否则结果一定是false
            return false;
        }
    }*/

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

2.掌握Object类中toString方法的使用

package cn.vqqc.d9_api_object;

/**
 目标：掌握Object类中toString方法的使用
 */
public class Test1 {
    public static void main(String[] args) {
        Student s = new Student("try", '男', 19);
        // String rs = s.toString();
        // System.out.println(rs);

        // System.out.println(s.toString());

        // 直接输出对象变量，默认可以省略toString调用不写的
        System.out.println(s);
    }
}

3.掌握Object类中equals方法的使用

package cn.vqqc.d9_api_object;

import java.util.Objects;

/**
 目标：掌握Object类中equals方法的使用
 */
public class Test2 {
    public static void main(String[] args) {
        Student s1 = new Student("try", '男', 19);
        Student s2 = new Student("try", '男', 19);
        // equals默认是比较2个对象的地址是否相同，子类重写后会调用子类重写的来比较内容是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);

        System.out.println(Objects.equals(s1, s2));
    }
}

10.d10_api_objects

1.掌握objects类的常用方法:equals

package cn.vqqc.d10_api_objects;

import java.util.Objects;

/**
 目标：掌握objects类的常用方法:equals
 */
public class Test {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = new String("try栈");

        // System.out.println(s1.equals(s2));   // 留下了隐患，可能出现空指针异常

        System.out.println(Objects.equals(s1, s2)); // 更安全，结果也是对的！

        /**
         Objects：
         public static boolean equals(Object a, Object b) {
         return (a == b) || (a != null && a.equals(b));
         }
         */

        System.out.println(Objects.isNull(s1)); // true
        System.out.println(s1 == null); // true

        System.out.println(Objects.isNull(s2)); // false
        System.out.println(s2 == null); // false

    }
}

11.d11_api_stringbuilder

1.学会使用StringBuilder操作字符串

package cn.vqqc.d11_api_stringbuilder;

/**
 目标：学会使用StringBuilder操作字符串,最终还需要知道它性能好的原因
 */
public class StringBuilderDemo1 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(); // ""
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append(1);
        sb.append(false);
        sb.append(3.3);
        sb.append("abc");
        System.out.println(sb);

        StringBuilder sb1 = new StringBuilder();
        // 支持链式编程
        sb1.append("a").append("b").append("c").append("我爱你中国");
        System.out.println(sb1);

        // 反转
        sb1.reverse().append("110");
        System.out.println(sb1);

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

        // 注意：StringBuilder只是拼接字符串的手段：效率好。
        // 最终的目的还是要恢复成String类型。
        StringBuilder sb2 = new StringBuilder();
        sb2.append("123").append("456");
        // 恢复成String类型
        String rs = sb2.toString();
        check(rs);
    }

    public static void check(String data){
        System.out.println(data);
    }
}

package cn.vqqc.d11_api_stringbuilder;

public class StringBuilderTest2 {
    public static void main(String[] args) {
        int[] arr1 = null;
        System.out.println(toString(arr1));

        int[] arr2 = {10, 88, 99};
        System.out.println(toString(arr2));

        int[] arr3 = {};
        System.out.println(toString(arr3));
    }

    /**
     1、定义方法接收任意整型数组，返回数组内容格式
     */
    public static String toString(int[] arr){
        if(arr != null){
            // 2、开始拼接内容。
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i] ).append(i == arr.length - 1 ? "" : ", ");
            }
            sb.append("]");
            return sb.toString();
        }else {
            return null;
        }
    }
}

12.d12_math

1.Math类的使用

package cn.vqqc.d12_math;

/**
 目标：Math类的使用。
 Math用于做数学运算。
 Math类中的方法全部是静态方法，直接用类名调用即可。
 方法：
 方法名                                          说明
 public static int abs(int a)                   获取参数a的绝对值：
 public static double ceil(double a)            向上取整
 public static double floor(double a)           向下取整
 public static double pow(double a, double b)   获取a的b次幂
 public static long round(double a)             四舍五入取整
 小结：
 记住。
 */
public class MathDemo {
    public static void main(String[] args) {
        // 1.取绝对值:返回正数
        System.out.println(Math.abs(10)); // 10
        System.out.println(Math.abs(-10.3)); // 10.3

        // 2.向上取整: 5
        System.out.println(Math.ceil(4.00000001)); // 5.0
        System.out.println(Math.ceil(4.0)); // 4.0
        // 3.向下取整：4
        System.out.println(Math.floor(4.99999999)); // 4.0
        System.out.println(Math.floor(4.0)); // 4.0

        // 4.求指数次方
        System.out.println(Math.pow(2 , 3)); // 2^3 = 8.0
        // 5.四舍五入 10
        System.out.println(Math.round(4.49999)); // 4
        System.out.println(Math.round(4.500001)); // 5

        System.out.println(Math.random());  // 0.0 - 1.0 （包前不包后）

        // 拓展： 3 - 9 之间的随机数  （0 - 6） + 3
        //  [0 - 6] + 3
        int data =  (int)(Math.random() * 7) + 3;
        System.out.println(data);


    }
}

13.d13_system

1.System系统类的使用

package cn.vqqc.d13_system;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.Arrays;

/**
 目标：System系统类的使用
 System代表当前系统（虚拟机系统）
 静态方法：
 1.public static void exit(int status):终止JVM虚拟机，非0是异常终止。
 2.public static long currentTimeMillis():获取当前系统此刻时间毫秒值。(重点)
 3.可以做数组的拷贝。
 arraycopy(Object var0, int var1, Object var2, int var3, int var4);
 * 参数一：原数组
 * 参数二：从原数组的哪个位置开始赋值。
 * 参数三：目标数组
 * 参数四：赋值到目标数组的哪个位置
 * 参数五：赋值几个
 */
public class SystemDemo {
    public static void main(String[] args) {
        System.out.println("程序开始。。。");

        // System.exit(0); // JVM终止！

        // 2、计算机认为时间有起源：返回1970-1-1 00：00：00 走到此刻的总的毫秒值：时间毫秒值
        long time = System.currentTimeMillis();
        System.out.println(time);

        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");


        // 3、做数组拷贝（了解）
        /**
         arraycopy(Object src,  int  srcPos,
         Object dest, int destPos,
         int length)
         参数一：被拷贝的数组
         参数二：从哪个索引位置开始拷贝
         参数三：复制的目标数组
         参数四：粘贴位置
         参数五：拷贝元素的个数
         */
        int[] arr1 = {10, 20, 30, 40, 50, 60, 70};
        int[] arr2 = new int[6]; // [0, 0, 0, 0, 0, 0] ==>  [0, 0, 40, 50, 60, 0]
        System.arraycopy(arr1, 3, arr2, 2, 3);
        System.out.println(Arrays.toString(arr2));

        System.out.println("-------------------");
        double i = 10.0;
        double j = 3.0;

//
//        System.out.println(k1);

        System.out.println("程序结束。。。。");
    }
}

14.d14_bigdecimal

1.BigDecimal大数据类

package cn.vqqc.d14_bigdecimal;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;

/**
 目标：BigDecimal大数据类。

 引入：
 浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）
 BigDecimal可以解决浮点型运算数据失真的问题

 BigDicimal类：
 包：java.math.
 创建对象的方式（最好的方式：）
 public static BigDecimal valueOf(double val) :包装浮点数成为大数据对象
 方法声明
 public BigDecimal add(BigDecimal value)       加法运算
 public BigDecimal subtract(BigDecimal value)  减法运算
 public BigDecimal multiply(BigDecimal value)  乘法运算
 public BigDecimal divide(BigDecimal value)    除法运算
 public double doubleValue(): 把BigDecimal转换成double类型
 */
public class BigDecimalDemo {
    public static void main(String[] args) {
        // 浮点型运算的时候直接+  * / 可能会出现数据失真（精度问题）
        System.out.println(0.09 + 0.01);
        System.out.println(1.0 - 0.32);
        System.out.println(1.015 * 100);
        System.out.println(1.301 / 100);

        System.out.println("-------------------------");
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        System.out.println(c);
        System.out.println("--------------------------");
        // 包装浮点型数据成为大数据对象 BigDeciaml
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        BigDecimal c1 = a1.add(b1);
        // BigDecimal c1 = a1.subtract(b1);
        // BigDecimal c1 = a1.multiply(b1);
        // BigDecimal c1 = a1.divide(b1);
        System.out.println(c1);

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

        // 注意事项：BigDecimal是一定要精度运算的
        BigDecimal a11 = BigDecimal.valueOf(10.0);
        BigDecimal b11 = BigDecimal.valueOf(3.0);
        /**
         参数一：除数 参数二：保留小数位数  参数三：舍入模式
         */
        BigDecimal c11 = a11.divide(b11, 2, RoundingMode.HALF_UP); // 3.3333333333
        System.out.println(c11);


        System.out.println("-------------------");
    }
}