???

(先记录在这篇博文中，然后与第一篇博文集成)

???

6.格式输出(参考链接:Java如何格式化输出？

• 一般方式：System.out.println("x = " x ", y = " y);
• printf()方式：System.out.printf("x = %d, y = %f\n", x, y);
• format()方式：System.out.format("x = %d, y = %f\n", x, y);

format与printf是等价的 %d表示整数类型，%f表示浮点数类型。%.2f小数点保留后的两位

7.类有 5 大成分：成员变量、构造器、方法、代码块、内部类别

8.子类是对象地址，但内部分为两个空间：父类空间super、子类空间this

9.继承

• Java所有类都是Object的子类
• 访问成员(成员变量，成员方法)在子类方法中满足:就近原则，使用关键字super.、this.指定访问父子成员

10.权限修饰符的作用范围:从小打大:private -> 缺省 -> protected ->public

11.类前使用的一些特殊关键词：final、abstract、interface

• final 与 abstract互斥关系。final定义的类别不能继承；相反abstract定义的类必须继承；final不能重写定义方法，abstract重写定义的方法笔记
• 继承：public 子类名 extends 父类名(只能单独继承)
• 实现：public interface 子类名 implement 父类名1，父类名2…(可多实现)
• 如果一个子类又要继承又要实现，则要先继承后实现，例如：class Cat extends Animal implements Food{ }
• 接口不能实例化，对象不能创建

12.时间毫秒值：指从1970年1月1日 00:00:00走到这一刻的总毫秒。1s=1000ms（1970年1月1日 算C语言生日，在P119）

11.直接打印集合类，显示的结果是内；直接打印数组显示的是地址，可用集合类转为字符串Arrays.toString(arr);

12.一个.java文件中可以写多个class，但是只能有一个类的前面加有修饰词public

这张图是精髓，注释也要仔细看！

• 同一个类中访问静态成员变量可以省略类名，即通常访问格式为User.onLineNum，但是可省略写成onLineNum。
• 静态成员变量：有static，属于类，加载一次，可以被共享访问
• 实例成员变量：无static，属于每个对象

static访问注意事项：

• 静态方法只能访问静态的成员，不可以直接访问实例成员（因为实例成员必须由对象触发）
• 实例方法可以访问静态的成员，也可以访问实例成员
• 静态方法中是不可以出现 this 关键字的（this 关键字指明的是当前对象的地址）
• 静态成员只能由类触发；实例成员可由类、对象触发。

工具类是什么？

类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用的。

使用工具类的好处： 调用方便，提高了代码复用（一次编写，处处可用）

TestDemo.java

package d3_static_test;

public class TestDemo { 
        
    public static void main(String[] args) { 
        
        int[] a = null;
        int[] b = { 
        };
        int[] arr = { 
        10, 20, 30, 40, 50};
        System.out.println(ArrayUtils.toString(arr));
        System.out.println(ArrayUtils.toString(a));
        System.out.println(ArrayUtils.toString(b));

        System.out.println("------------------------");
        double[] arr2 = { 
        10, 20.5, 30.2, 40.9, 6, 2};
        System.out.printf("average = %.2f\n", ArrayUtils.getAverage(arr2));
        System.out.println("average = " + ArrayUtils.getAverage(null));

    }

}

ArrayUtils.java

package d3_static_test;

public class ArrayUtils { 
        

    // 定义一个私有的构造器，表明不能将此类实例化成对象
    private ArrayUtils() { 
        

    }

    // 将整数一维数组转为String类型，格式为[x1, x2, ...]
    public static String toString(int[] arr){ 
        
        if (arr == null){ 
        
            System.out.println("Array is NULL.");
            return null;
        }

        String s = "[";
        for (int i = 0; i < arr.length; i++) { 
        
            s += i == arr.length - 1 ? arr[i] : arr[i] + ", ";
        }
        return s + "]";
    }

    // 返回将浮点数类型一维数组的平均值（出去最高、最低值）
    public static double getAverage(double[] arr){ 
        
        if (arr == null){ 
        
            System.out.println("Array is NULL.");
            return -1;
        }

        double max = arr[0], min = arr[0], sum = arr[0];
        for (int i = 1; i < arr.length; i++) { 
        
            if (arr[i] > max){ 
        
                max = arr[i];
            }
            if (arr[i] < min){ 
        
                min = arr[i];
            }
            sum += arr[i];
        }
        return (sum - max - min) / (arr.length - 2);
    }
}

• {}构造代码块（也称实例代码块），用的比较少，还是static {}静态代码块用得比较多，都是执行构造函数之前。
• 顺序： 静态代码块 > 构造代码块 > 构造函数，且静态代码块只会在首次调用类的被触发一次，构造代码块会在构造新对象时触发
• 注意： 此代码块中只能写语句，不能写方法
• 静态代码块的特点：如果要在启动系统时对静态资源进行初始化，则建议使用静态代码块完成数据的初始化操作。

package d3_static_test;

public class StaticTestDemo3 { 
        
    // 成员变量
    private String name;
    private static int age = 10;

    // 构造函数
    StaticTestDemo3(String name){ 
        
        this.name = name;
        System.out.println("========构造函数construct=============");
    }

    // 构造代码块，执行于构造函数之前
    { 
        
        String name2 = "long";
        System.out.println(name2);
    }

    // 静态代码块 > 构造代码块 > 构造函数，只调用一次
    static { 
        
        age++;
        System.out.println("age =" + age);
    }

    // 方法
    public void print(){ 
        
        System.out.println(name + "的年龄是" + age);
    }


    public static void main(String[] args) { 
        
        StaticTestDemo3 test = new StaticTestDemo3("wu");
        StaticTestDemo3 test2 = new StaticTestDemo3("dan");

        test.print();
        test2.print();

        test.print();
    }
}

//age =11
//long
//========构造函数construct=============
//long
//========构造函数construct=============
//wu的年龄是11
//dan的年龄是11
//wu的年龄是11

package d3_static_test;

import java.util.ArrayList;

public class CardTest { 
        
    // 1.定义一个静态成员变量，一般使用public共享访问
    public static ArrayList<String> cards = new ArrayList<>();

    // 2.使用静态代码块，构造56张牌
    static { 
        
        // 点数
        String[] sizes = { 
        "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        String[] colors = { 
        "♥", "♠", "♦", "♣"};
        for (int i = 0; i < sizes.length; i++) { 
        
            for (int j = 0; j < colors.length; j++) { 
        
                cards.add(sizes[i] + colors[j]);
            }
        }
        cards.add("小🃏");
        cards.add("大🃏");
    }

    public static void main(String[] args) { 
        
        System.out.println("新牌为：" + cards); // 在同一个类中，可直接使用静态成员变量
        System.out.println("新牌张数为：" + cards.size());
    }
}

// 新牌为：[3♥, 3♠, 3♦, 3♣, 4♥, 4♠, 4♦, 4♣, 5♥, 5♠, 5♦, 5♣, 6♥, 6♠, 6♦, 6♣, 7♥, 7♠, 7♦, 7♣, 8♥, 8♠, 8♦, 8♣, 9♥, 9♠, 9♦, 9♣, 10♥, 10♠, 10♦, 10♣, J♥, J♠, J♦, J♣, Q♥, Q♠, Q♦, Q♣, K♥, K♠, K♦, K♣, A♥, A♠, A♦, A♣, 2♥, 2♠, 2♦, 2♣, 小🃏, 大🃏]
// 新牌张数为：54

• 单例：就表示只能拿到一个类、构造器私有、需要内部创建一个静态实例共外部调用（根据实例的构造先后，依次分为饿汉、懒汉单例）

饿汉单例模式

懒汉单例模式

子类对外是一个对象，但是内部是分为了两个空间：父类空间super、子类空间this

方法重写：

• 子类重写父类方法时，建议对该方法的【声明不变，重新实现】，即方法修饰符、方法名、形参列表等全部都与父类一致，只是在函数体写明新的逻辑代码
• 在需要重写的方法上一行，加上@Override注解，可以帮助校验重写方法的格式是否正确 + 提高代码的可读性

子类构造器访问父类无参构造器：

• 调用父类无参构造器代码：super();
• 调用父类有参构造器代码：super(name, age,...);

如果子类的构造器中没有调用super(name, age,...);，则默认都会自动调用super();。一旦有代码调用了super(name, age,...);，则不会再调用super();

this 和 super

第3栏的【同一个包中其他类】表示：同一个包中的所有类（无关类or子类）

• public static final修饰的也常称为常量了

• 用枚举做信息标志和分类的代码可读性号，入参约束严谨，是最好的信息分类技术
• 但是在实际应用中，可能是因为常量使用比较简单，使用常量的概率会高一些

final和abstract是互斥关系

多态侧重于行为（即方法）

多态的定义： 同类型的对象，执行同一个行为，会表现出不同的特征

类型转换问题

TestMain.java

我的代码跟老师的不一样，老师还定义了一个电脑类，然后使用的installUSB，而我是直接定义在这个主代码里面了，emmm~

package d3_interface;

public class TestMain { 
        
    public static void main(String[] args) { 
        
        // 使用多态
        USB usb1 = new Mouse("罗技");
        USB usb2 = new Keyboard("联想");

        System.out.println("----------连接USB设备---------");
        usb1.on();
        usb2.on();

        System.out.println("\n----------使用USB设备---------");
        // 先判断数据类型，然后进行强制数据类型转换，并使用实现类的独有功能
        useUSB(usb1);
        useUSB(usb2);

        System.out.println("\n----------断开USB设备---------");
        usb1.off();
        usb2.off();
    }

    public static void useUSB(USB usb){ 
        
        if (usb instanceof Mouse){ 
        
            Mouse M_usb = (Mouse) usb;
            M_usb.click();
        }else if(usb instanceof Keyboard){ 
        
            Keyboard K_usb = (Keyboard) usb;
            K_usb.typewriter();
        }else{ 
        
            System.out.println("暂不处理~~");
        }
    }
}

内部类的分类：

• 静态内部类 [了解]
• 成员内部类（非静态内部类） [了解，有点重要]
• 局部内部类 [鸡肋，了解即可]
• 匿名内部类（重点）

(1) 静态内部类

(2) 成员内部类

(2) 局部内部类

• 匿名内部类的作用：简化代码编写
• 一般的表现形式：作为方法的实参传输

• 这两种方法都可以直接用IDEA的快捷键Alt+Insert生成

Objects

• Objects.equals(a, b) 对象进行内容比较时，建议使用。因为会更安全、准确
• Objects.isNull(a) 源码是 return a == null;

• 特点 （先实例化一个对象StringBuilder sb = new StringBuilder();）
  • 支持链式编程：sb.append("abc").append("123").append(3);
  • 反转 + 链式：sb.reverse().append("love");
• 注意
  • StringBuilder只是拼接、操作字符串的手段：效率好
  • 但是最终还是要恢复成String类型进行后续操作：String s = sb.toString();

package StringBuilder;

public class TestMain { 
        
    public static void main(String[] args) { 
        
        int[] arr = null;
        int[] arr2 = { 
        };
        int[] arr3 = { 
        1, 2, 3, 4, 5};

        System.out.println(toString(arr));
        System.out.println(toString(arr2));
        System.out.println(toString(arr3));
    }

    public static String toString(int[] arr) { 
        
        if (arr == null) { 
        
            return null;
        } else { 
        
            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();
        }
    }

}
// null
// []
// [1, 2, 3, 4, 5]

（1）Math类

（2）System类

（3）BigDecimal

• 作用：解决浮点数运算失真的问题
• 注意：（一定要采用调用方法valueOf()去封装成BigDecimal对象）
  • 手段：封装浮点型数据为大数据对象 BigDecimal a1 = BigDecimal.valueOf(a);
  • 目的：转为double继续操作 double rs = a1.doubleValue();
  • BigDecimal是一定要精度运算的（因为有时候会遇到除不尽的情况，所以一定要指明精度）

❀❀❀❀❀❀❀❀❀❀❀❀❀

❀❀❀❀❀❀❀❀❀❀❀❀❀

不使用float和double进行精确数值计算（参考自👉代码规范：BigDecimal、int或者long进行精确数值计算）

float和double只能进行较为精确的快速近似的计算，并不能提供完全精确的结果，尤其不适用于货币计算，因为它们不能精确地表示0.1或者10的任何其它负次方。

要进行精确计算就使用BigDecimal、int或者long。

package StringBuilder;

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

public class TestMain2 { 
        
    public static void main(String[] args) { 
        
        System.out.println("-----------BigDecimal-----------");
        BigDecimal a = BigDecimal.valueOf(0.1);
        BigDecimal b = BigDecimal.valueOf(0.2);

        System.out.println( a + " + " + b + " = " + a.add(b));
        System.out.println( a + " - " + b + " = " + a.subtract(b));
        System.out.println( a + " * " + b + " =