Java日记📒

Java 基础知识

super 关键字

在 Java 中，super 是一个关键字，用于访问父类的属性和方法。使用 super 关键字可以在子类中访问和调用父类中的方法、构造函数和变量。
访问父类的属性和方法：使用 super 关键字可以访问父类的属性和方法。

1
2
3
4
5
6
7
8
9
10
class Person {
    protected String name;
    protected int age;
}

class Student extends Person {
    public String hello() {
        return "Hello, " + super.name; 
    }
}

调用父类的构造函数：使用 super 关键字还可以调用父类的构造函数。当子类中没有显式调用父类的构造函数时，Java 编译器会自动调用父类的无参构造函数。如果父类没有无参构造函数，则要使用 super 关键字调用父类的带参数构造函数。 

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Animal {
    protected int age;
    public Animal(int age) {
        this.age = age;
    }
}

public class Dog extends Animal {
    public Dog(int age, String name) {
        super(age); // 调用父类中带参数的构造函数
        this.name = name;
    }
}

多态

针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。

抽象类

如果一个 class 定义了方法，但没有具体执行代码，这个方法就是抽象方法，抽象方法用** abstract 修饰。因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class**）。无法实例化一个抽象类。

1
2
3
4
5
6
7
8
9
10
abstract class Person {
    public abstract void run();
}

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

接口

如果一个抽象类没有字段，所有方法全部都是抽象方法，就可以把该抽象类改写为接口：interface。

1
2
3
4
interface Person {
    void run();
    String getName();
}

interface，就是比抽象类还要抽象的纯抽象接口，因为它连字段都不能有。因为接口定义的所有方法默认都是public abstract的，所以这两个修饰符不需要写出来（写不写效果都一样）。
当一个具体的 class 去实现一个 **interface **时，需要使用 implements 关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Student implements Person {
    private String name;

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

    @Override
    public void run() {
        System.out.println(this.name + " run");
    }

    @Override
    public String getName() {
        return this.name;
    }
}

在 Java 中，一个类只能继承自另一个类，不能从多个类继承。但是，一个类可以实现多个 interface。
image.png
一个 interface 可以继承自另一个 interface。interface 继承自 interface 使用 extends ，它相当于扩展了接口的方法。

1
2
3
4
5
6
7
8
interface Hello {
    void hello();
}

interface Person extends Hello {
    void run();
    String getName();
}

在接口中，可以定义** default 方法。default 方法的目的是，当我们需要给接口新增一个方法时，会涉及到修改全部子类。如果新增的是 default **方法，那么子类就不必全部修改，只需要在需要覆写的地方去覆写新增方法。

Java 核心类

字符串 String

String 是一个引用类型，它本身也是一个 class。但是，Java 编译器对String 有特殊处理，即可以直接用”…”来表示一个字符串。
想比较字符串的内容是否相同。必须使用 equals() 方法而不能用 == 。要忽略大小写比较，使用equalsIgnoreCase()方法。
toLowerCase()将字符串转变为小写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//判断字符串是否相等
String s1 = "hello";
String s2 = "hello";
s1.equals(s2);// true
//提取字串
"Hello".indexOf("l"); // 2
"Hello".lastIndexOf("l"); // 3
"Hello".startsWith("He"); // true
"Hello".endsWith("lo"); // true
"Hello".substring(2); // "llo"
"Hello".substring(2, 4); "ll"
//去除首尾空白字符
"  \tHello\r\n ".trim(); // "Hello"	去除首尾空白字符
//判断是否是空字符串
"".isEmpty(); // true，因为字符串长度为0，判断是否是空字符串
"  ".isEmpty(); // false，因为字符串长度不为0
"  \n".isBlank(); // true，因为只包含空白字符，判断是否是空白字符串
" Hello ".isBlank(); // false，因为包含非空白字符
//替换字串
String s = "hello";
s.replace('l', 'w'); // "hewwo"，所有字符'l'被替换为'w'
s.replace("ll", "~~"); // "he~~o"，所有子串"ll"被替换为"~~"
//分割字符串
String s = "A,B,C,D";
String[] ss = s.split("\\,"); // {"A", "B", "C", "D"}
//拼接字符串
String[] arr = {"A", "B", "C"};
String s = String.join("***", arr); // "A***B***C"

要把任意基本类型或引用类型转换为字符串，可以使用静态方法valueOf()：

1
2
3
4
String.valueOf(123); // "123"
String.valueOf(45.67); // "45.67"
String.valueOf(true); // "true"
String.valueOf(new Object()); // 类似java.lang.Object@636be97c

把字符串转换为int类型：

1
2
int n1 = Integer.parseInt("123"); // 123
int n2 = Integer.parseInt("ff", 16); // 按十六进制转换，255

把字符串转换为boolean类型：

1
2
boolean b1 = Boolean.parseBoolean("true"); // true
boolean b2 = Boolean.parseBoolean("FALSE"); // false

Java编译器对String做了特殊处理，使得我们可以直接用+拼接字符串。

包装类型

  • 基本类型：byte，short，int，long，boolean，float，double，char
  • 引用类型：所有class和interface类型
  • 引用类型可以赋值为null，表示空，但基本类型不能赋值为null

Java核心库为每种基本类型都提供了对应的包装类型，我们可以直接使用，并不需要自己去定义：

基本类型 对应的引用类型
boolean java.lang.Boolean
byte java.lang.Byte
short java.lang.Short
int java.lang.Integer
long java.lang.Long
float java.lang.Float
double java.lang.Double
char java.lang.Character