JavaSE基础加强-学习黑马程序员Java基础视频教程（P93开始）

🍅🍅🍅🍅🍅🍅🍅🍅🍅

学习！！！2022黑马程序员Java学习路线图，好像跟菜鸟教程挺一致的：Java 教程 | 菜鸟教程。

领取方式：关注微信公众号：黑马程序员，回复关键词：领取资源02

在这个博客中👉黑马程序员Java基础视频教程-课程总结文档，我将徐磊老师写的xmind转为了图片方便观看。

🍀 Java入门-学习黑马程序员Java基础视频教程（到P92）

🍅🍅🍅🍅🍅🍅🍅🍅🍅

P0：写在前面的小知识

🐕🐕🐕🐕🐕🐕🐕

（先记录在这篇博文，到时候与第一篇博文整合到一起）

🐕🐕🐕🐕🐕🐕🐕

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表示保留小数点后2位

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

P93：下阶段：JavaSE基础加强简介

P95：static：修饰成员变量、内存机制

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

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

P96：static：修饰成员方法、内存机制

P97：static：访问的注意事项[拓展、面试]

static访问注意事项：

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

P98：static：应用知识-工具类

工具类是什么？

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

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

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

P99：static：应用知识-代码块

• {}构造代码块（也称实例代码块），用的比较少，还是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

P100：static：应用知识-单例模式

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

饿汉单例模式

懒汉单例模式

P101：继承：概述、案例

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

P102：继承：特点、访问特点、方法重写

方法重写：

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

P103：继承：构造器特点、this、super小结

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

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

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

this 和 super

P105：语法：包、权限修饰符

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

P106：语法：final的语法

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

P107：语法：常量、常量在开发中的作用

P108：语法：枚举、枚举作用

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

P109：抽象类：概述、案例、特点

final和abstract是互斥关系

P110：抽象类：模板方法模式

P111：接口：概述、多实现、多继承

P112：接口新增方法、注意事项（了解）

</