Java——基础内容

总览

知识图解

总目录

GUI界面

JavaSE

第1章_Java语言概述

语言特点

JDK、JRE、JVM

环境变量

javac

练习题

1.System.out.println()和System.out.print()区别

2.垃圾回收机制

第2章_基本语法

关键字

命名规范

Java项目结构

Java项目结构概述-CSDN博客

变量

byte、short、int、long

float、double

转义字符 \n \t

UTF-8

进制

short s，s+=1

s+2强转为short则正确

（++n）则后面的n也会立马变，而（n++）后面的n未变

int b = (++n) + (++n) + (++n);                //36

运算符，短路&

位运算

break—label

return

第3章_数组

数组初始化

默认初始化值

堆、栈

---

多维数组

Arrays

其中方法是静态的，直接用类名.方法名调用

int index= Arrays.binarySearch(a,2);

数组题目

在 Java 中，当你想要初始化一个数组并在声明时为其赋值时，你应该省略数组的大小。

但是，你不能在 new 关键字后面的方括号中指定值。这是 Java 语法规定的。

第4章_面向对象编程(上)

面向对象VS过程

对象 == 实例

类——属性、行为

类的构成——代码块、内部类

类与对象

类——访问机制

对象——存放在堆、栈的位置

对象的生命周期——对象引用

        ListNode listNode1 = new ListNode();
        ListNode listNode2 = new ListNode();
        listNode1.next = listNode2;

        listNode1.setVal(1);
        listNode2.setVal(2);

        // 与下效果同： ListNode listNode11 = listNode1;
        ListNode listNode11 = new ListNode();
        listNode11 = listNode1;
        listNode1 = listNode1.next;

        // listNode1移动并没有带动listNode11移动
        // 因为listNode11本质上指向的是原来的ListNode()对象位置，
        // 而不是指向listNode1
        System.out.println(listNode1.getVal());     //2
        System.out.println(listNode11.getVal());    //1

堆、栈——详解

内存解析

匿名对象

成员变量 VS 局部变量

初始化是指，全局变量不初始化直接输出其值，获得的是默认值

而局部变量不初始化直接输出其值，会报错

对象属性的默认初始化赋值

方 法(method)

对象数组

方法重载（Overload）

重写（Override）

可变个数的形参 ...

Java只有——值传递（形参 VS 实参）

引用数据类型——参数传递

递归

封装和隐藏（高内聚、低耦合）

getter、setter

使用getter方法的优势包括：

• 符合封装原则：通过将属性的访问封装在getter方法中，可以更好地控制对属性的访问，避免外部代码直接操作属性。
• 更好的可读性：getter方法使用了更易读的方式来获取属性值，使代码更容易理解。
• 可扩展性：如果需要在获取属性值之前进行额外的逻辑或处理，可以在getter方法中添加相应的代码，而不影响外部代码的使用。
• 更好的代码维护性：当属性的名称或访问方式需要更改时，只需要修改getter方法，而不需要修改所有直接访问属性的代码。

综上所述，虽然直接获取属性值在某些情况下可能更简单，但使用getter方法更符合 Java 的编程规范，并且提供了更好的代码可读性、可扩展性和维护性。因此，推荐在大多数情况下使用getter方法来获取属性值。

public、protected、(缺省)、private

构造器

JavaBean

UML类图

this

this调用其他构造方法 

在 Java 中，this()调用构造器必须放在第一句的原因是Java语法规定，在构造方法内调用父类或子类的构造方法时，必须在该构造方法的第一句写。即使不写，也会默认调用构造方法内头一句默认加上super()即父类的无参构造方法。

这么设计是为了在创建子类的同时，会调用父类的无参构造方法，以便在子类中使用父类的属性和方法。如果在子类的构造函数中没有调用this()，那么就默认会在第一行执行super()，这样可以在子对象的构造函数中先生成父类的属性和方法，再执行剩余的构造函数步骤以生成子对象独有的属性和方法。

变量初始化 、构造器—执行顺序

当前对象

package

源文件布局

包（package）的作用

MVC设计模式

JDK中主要的包介绍

import

习题

垃圾回收机制

System.gc();或Runtime.getRuntime().gc();

第5章_面向对象编程(中)

继承

重写(override/overwrite)

重写——多态

super

调用父类的构造器

 例子：

class Father{
    public Father(){
        System.out.println("1");
    }
}

class Son extends Father{
    public Son(){
        System.out.println("2");
    }
}

public class Main {
    public static void main(String[] args) {
       Son son=new Son();	// 1 2
    }
}

class Base {
    Base() {
        method(100);
    }

    public void method(int i) {
        System.out.println("base : " + i);
    }
}

class Sub extends Base {
    Sub() {
        super.method(70);
    }

    public void method(int j) {
        System.out.println("sub : " + j);
    }
}

public class Main {
    public static void main(String[] args) {
        Base b1 = new Base();
        Base b2 = new Sub();
    }
}

this VS super

子类对象的实例化流程图

多态

编译时类型和运行时类型

多态是运行时行为

子类 VS 父类

虚拟方法——动态绑定

多态小结

instanceof——检验x是否为类A的对象

        B b = new B();
        System.out.println(b instanceof A);     //true
        System.out.println(b instanceof B);     //true
        System.out.println(b instanceof C);     //false

        B b = new C();
        System.out.println(b instanceof A);     //true
        System.out.println(b instanceof B);     //true
        System.out.println(b instanceof C);     //true

对象类型转换——强转

父类Object可以强转为String

但Integer不可强转为String，因为二者不是父子关系

强转对比

强转（String）与toString()区别

继承成员变量和继承方法的区别

Object类

== 与 equals

二者区别

 x、y都指向常量池中的同一个“string”

详见Java高级——String类——内存展示

针对上面：x == z为false的解释（与Integer类型不同之处）：

针对上面：x.equals(z)，原理解释：

源码中：

1.首先判断指向的对象是否相同，这里结果是不同，那么继续

2.将z强转为String类型，然后与x进行比较，判断是否相同

字符串对象直接输出

String x = "string";
System.out.println(x); // System.out.println(x.toString());

本质上是调用toString()方法

toString()

        char[] arr = new char[]{'a', 'b', 'c'};
        System.out.println(arr);                //abc
        int[] arr1 = new int[]{1, 2, 3};
        System.out.println(arr1.toString());    //地址
        double[] arr2 = new double[]{1.1, 2.2, 3.3};
        System.out.println(arr2);               //地址
        System.out.println(Arrays.toString(arr2));  //[1.1, 2.2, 3.3]

包装类

int——Integer

装箱与拆箱

字符串 VS 基本数据类型

总结：基本类型、包装类与String类间的转换

使用包装类的原因

面试题

答案：

Object o1 = true ? new Integer(1) : new Double(2.0)；-CSDN博客

题目：

答案：

 

        // 一
        Integer a1 = new Integer(128);
        Integer a2 = new Integer(127);
        Integer b1 = 128;
        Integer b2 = 127;
        int c1 = 128;
        int c2 = 127;

        System.out.println(a1 == b1);   // false   --图1解释
        System.out.println(a1 == c1);   // true    --图2解释
        System.out.println(a2 == b2);   // false
        System.out.println(a2 == c2);   // true

        System.out.println(b1 == c1);   // true
        System.out.println(b2 == c2);   // true

        // 二
        Integer d1 = new Integer(128);
        Integer d2 = new Integer(127);
        System.out.println(a1 == d1);   // false
        System.out.println(a2 == d2);   // false

        // 三
        Integer b11 = 128;
        Integer b22 = 127;
        System.out.println(b1 == b11);  // false
        System.out.println(b2 == b22);  // true

图1：

 图2：

-128—127——缓存问题

        Integer e = 1;
        Integer f = 1;
        Double c = 2.0;
        Double d = 2.0;
        System.out.println(e == f);    //true
        System.out.println(c == d);    //false

Java中缓存机制

第6章_面向对象编程(下)

static

实例变量

类方法、类属性

范围、特点

代码举例

内存解析

类方法

无this、super，且不能被重写

单例模式

理解main方法的语法

代码块

静态代码块 VS 非静态代码块

代码块执行顺序

final

构造器中给final修饰的“变量”赋值

抽象类（abstract）

代码举例

思考题

问题1：

​​问题2：

抽象类中——可写内容

private——abstract

模板方法

接口（interface）

接口中变量和方法的默认修饰符

接口中——可写内容

接口格式

实例化实现接口的类

接口多态

实现父类及组父类的接口方法

代理模式

Java8中接口改进

interface Abc{
    public static void say(){
        System.out.println("Abc.say");
    };
}

public class scratch {
    public static void main(String[] args) {
        Abc.say();
    }
}

接口中默认方法没有被重写，子类也可以不加abstract修饰符

实现多个接口，方法同名冲突

接口、类——相互继承问题

接口不能继承类

接口 不能 实现接口

接口 可以 继承接口

抽象类 VS 接口

内部类

特性

内部类代码例子

匿名内部类

内部类实例化

面向对象导图总结

第7章_异常处理

Error VS Exception

异常——模块结构图

编译时异常 VS 运行时异常

常见异常

try-catch-finally

异常处理过程

catch中e

catch中精确写 VS 粗略写Exception e

getMessage()与printStackTrace()

finally

加return后执行顺序问题

不捕获异常时的情况

throws

抛多个异常用，分隔

按父类声明的异常处理

throw

throw VS throws

用户自定义异常类

异常关键字总结

练习题

题1

题2

throws是否要加问题

题3

题4