【廖雪峰Java】Java基础知识

学习课程：廖雪峰的官方网站：https://www.liaoxuefeng.com/

1、简介

1.1、Java之父

詹姆斯·高斯林（James Gosling）

1.2、Java三个不同版本

• Java SE：Standard Edition
• Java EE：Enterprise Edition
• Java ME：Micro Edition

这三者之间有啥关系呢？

1.3、JDK 与 JRE

• JDK：Java Development Kit
• JRE：Java Runtime Environment

1.4、如何运行Java程序

Java源码本质上是一个文本文件，我们需要先用javac把Hello.java编译成字节码文件Hello.class，然后，用java命令执行这个字节码文件：

2、基本操作

2.1、命名规范

• 包命名：com.hello.world

• 类、接口命名：HelloWorld

• 方法命名：helloWorldHelloWorld

• 变量命名：helloWorldHelloWorld

• 常量命名：HELLO_WORLD

2.2、基本数据类型

• 整数类型：byte，short，int，long
• 浮点数类型：float，double
• 字符类型：char
• 布尔类型：boolean

Java基本数据类型占用的字节数：

特别注意：同一个数的不同进制的表示是完全相同的，例如15=0xf＝0b1111。

2.3、浮点型定义

对于float类型，需要加上f后缀。

float f1 = 3.14f;
float f2 = 3.14e38f; // 科学计数法表示的3.14x10^38
float f3 = 1.0; // 错误：不带f结尾的是double类型，不能赋值给float

double d = 1.79e308;

2.4、字符

char a = 'A';

2.5、引用

引用类型最常用的就是String字符串：

String s = "hello";

C++中引用和指针的区别：https://blog.csdn.net/smartgps2008/article/details/90648015

2.6、常量

定义变量的时候，如果加上final修饰符，这个变量就变成了常量：

final double PI = 3.14; // PI是一个常量

2.7、var关键字

有些时候，类型的名字太长，写起来比较麻烦。如果想省略变量类型，可以使用var关键字，以下两者等效。

StringBuilder sb = new StringBuilder();
var sb = new StringBuilder();

2.8、运算优先级

在Java的计算表达式中，运算优先级从高到低依次是：
()
! ~ ++ –
* / %
+ -
<< >> >>>
&
|
+= -= *= /=

2.9、浮点数运算

• 浮点数常常无法精确表示，并且浮点数的运算结果可能有误差；
• 比较两个浮点数通常比较它们的差的绝对值是否小于一个特定值；
• 整型和浮点型运算时，整型会自动提升为浮点型；
• 可以将浮点型强制转为整型，但超出范围后将始终返回整型的最大值。

举个栗子：
浮点数0.1在计算机中就无法精确表示，因为十进制的0.1换算成二进制是一个无限循环小数，很显然，无论使用float还是double，都只能存储一个0.1的近似值。

double x = 1.0 / 10;
double y = 1 - 9.0 / 10;
// 观察x和y是否相等:
System.out.println(x); // x=0.1
System.out.println(y); // y=0.09999999999999998

所以要特别注意浮点数的运算，判断浮点数相等用“==”判断不靠谱，正确的方法是利用差值小于某个临界值来判断。比如：

double x = 1 - 9.0 / 10;  // x=0.09999999999999998
// 不要使用==直接判断，错误写法：if (x == 0.1) {}
// 而是使用差值小于某个临界值来判断
if (Math.abs(x - 0.1) < 0.00001) {}

2.10、char 和 String 的区别

\	char	String
定义	字符	字符串
类型	基本类型	引用类型
描述	“持有”某个数值	“指向”某个对象
符号使用	‘’	“”

2.11、Java中数组的特点

• 数组所有元素初始化为默认值，整型都是0，浮点型是0.0，布尔型是false；
• 数组一旦创建后，大小就不可改变；
• 数组元素可以是值类型（如int）或引用类型（如String），但数组本身是引用类型。

可以用数组变量.length获取数组大小：

int[] ns = new int[] { 68, 79, 91, 85, 62 };
System.out.println(ns.length); // 编译器自动推算数组大小为5

2.12、input & output

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); // 创建Scanner对象
        System.out.print("Input your name: "); // 不换行输出
        String name = scanner.nextLine(); // 读取一行输入并获取字符串
        System.out.println("Input your age: "); // 换行输出
        int age = scanner.nextInt(); // 读取一行输入并获取整数
        System.out.printf("Hi, %s, you are %d\n", name, age); // 格式化输出
    }
}

2.13、== 和 equals() 的区别

• == ：表示“引用是否相等”
• equals() ：判断引用类型的变量内容是否相等

String s1 = "hello";
String s2 = "HELLO".toLowerCase();
System.out.print(s1 == s2); // false
System.out.print(s1.equals(s2)); // true

2.14、switch

使用switch要留意需不需要使用break，注意千万不要漏写break。

2.15、for each循环

int[] ns = { 1, 4, 9, 16, 25 };
// 使用for循环
for (int i=0; i<ns.length; i++) {
    System.out.println(ns[i]);
}
// 使用for each循环
for (int n : ns) {
	System.out.println(n);
}

2.16、break & continue

• break ： 语句可以跳出当前循环；
• continue ： 语句可以提前结束本次循环；

2.17、数组操作

• 遍历数组可以使用for循环，for循环可以访问数组索引，for each循环直接迭代每个数组元素，但无法获取索引；
• 使用Arrays.toString()可以快速获取数组内容；
• 可以直接使用Java标准库提供的Arrays.sort()进行排序；
• 打印多维数组可以使用Arrays.deepToString()；

int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
// 遍历：方法一
for (int i=0; i<ns.length; i++) {
	int n = ns[i];
	System.out.println(n);
}
// 遍历：方法二
for (int n : ns) {
    System.out.println(n);
}
//直接打印，不能得到想要的结果
System.out.println(ns); // 直接打印数组变量，得到的是数组在JVM中的引用地址。类似 [I@7852e922
// 调用Java标准库
import java.util.Arrays;
System.out.println(Arrays.toString(ns));
// 其他方法
Arrays.sort(ns);

3、面向对象（OOP）

3.1、构造方法

• 实例在创建时通过new操作符会调用其对应的构造方法，构造方法用于初始化实例；
• 没有定义构造方法时，编译器会自动创建一个默认的无参数构造方法；（要特别注意的是，如果我们自定义了一个构造方法，那么，编译器就不再自动创建默认构造方法。）
• 可以定义多个构造方法，编译器根据参数自动判断；
• 可以在一个构造方法内部调用另一个构造方法，便于代码复用。

// 构造方法用于初始化实例
Person p = new Person("Xiao Ming", 15);
Person p2 = new Person("Xiao Ming"); // 自动匹配到构造方法

class Person {
    private String name;
    private int age;

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

    public Person(int age) {
        this.name = "xiaoming";
        this.age = age;
    }
    
    public Person(String name) {
        this(name, 18); // 调用另一个构造方法Person(String, int)
    }
}

3.2、方法重载

• 方法重载是指多个方法的方法名相同，但各自的参数不同；
• 重载方法应该完成类似的功能；
• 重载方法返回值类型应该相同。

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }
}

3.3、继承

Java使用extends关键字来实现继承：

class Person {
    private String name;
    private int age;
    ...
    public String getName() {...}
    public void setName(String name) {...}
    ...
}

class Student extends Person {
    // 不要重复定义name和age字段/方法,
    private int score; // 在父类基础之上新增字段和方法
    ...
    public int getScore() { … }
    public void setScore(int score) { … }
}

子类自动获得了父类的所有字段，严禁定义与父类重名的字段！
在父类与子类之间，方法名，参数列表，返回类型都相同，是被允许的。这种现象称为方法的重写。

在OOP的术语中，我们把Person称为超类（super class），父类（parent class），基类（base class），把Student称为子类（subclass），扩展类（extended class）。

继承树：

• super关键字表示父类（超类）。子类引用父类的字段时，可以用super.fieldName。
• this关键字表示本身调用的类。一般用法this.fieldName。

如果父类没有默认的构造方法，子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。(栗子)

小结：

• 继承是面向对象编程的一种强大的代码复用方式；（减小代码冗余）
• Java只允许单继承，所有类最终的根类是Object；（C++允许多继承方式）
• protected允许子类访问父类的字段和方法；
• 子类的构造方法可以通过super()调用父类的构造方法；
• 可以安全地向上转型为更抽象的类型；
• 可以强制向下转型，最好借助instanceof判断；
• 子类和父类的关系是is，has关系不能用继承。
• 在Java中，没有明确写extends的类，编译器会自动加上extends Object。所以，任何类，除了Object，都会继承自某个类。
• Java只允许一个class继承自一个类，因此，一个类有且仅有一个父类。只有Object特殊，它没有父类。但是，Java允许一个class被多个类继承。

3.4、多态

Override
子类对父类方法进行重写时，方法类型、方法名、方法参数必须都相同相同

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

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

• 子类可以覆写父类的方法（Override），覆写在子类中改变了父类方法的行为；
• Java的方法调用总是作用于运行期对象的实际类型，这种行为称为多态；
• final修饰符有多种作用：
  • final修饰的方法可以阻止被覆写；
  • final修饰的class可以阻止被继承；
  • final修饰的field必须在创建对象时初始化，随后不可修改。

3.5、抽象类

• 通过abstract定义的方法是抽象方法，它只有定义，没有实现。抽象方法定义了子类必须实现的接口规范；
• 定义了抽象方法的class必须被定义为抽象类，从抽象类继承的子类必须实现抽象方法；
• 如果不实现抽象方法，则该子类仍是一个抽象类；
• 面向抽象编程使得调用者只关心抽象方法的定义，不关心子类的具体实现。

3.6、接口

• Java的接口（interface）定义了纯抽象规范，一个类可以实现多个接口；
• 接口也是数据类型，适用于向上转型和向下转型；
• 接口的所有方法都是抽象方法，接口不能定义实例字段；
• 接口可以定义 default 方法（JDK>=1.8）。

抽象类和接口的对比如下：

\	abstract class	interface
继承	只能extends一个class	可以implements多个interface
字段	可以定义实例字段	不能定义实例字段
抽象方法	可以定义抽象方法	可以定义抽象方法
非抽象方法	可以定义非抽象方法	可以定义default方法

3.8 静态字段与静态方法

实例字段在每个实例中都有自己的一个独立“空间”，但是静态字段只有一个共享“空间”，所有实例都会共享该字段。
调用实例方法必须通过一个实例变量，而调用静态方法则不需要实例变量，通过类名就可以调用。

public class Main {
    public static void main(String[] args) {
        Person.setNumber(99);
    }
}

class Person {
    public String name;
    public int age;
    // 定义静态字段number:
    public static int number;
    // 静态方法
    public static void setAge(int value) {
        this.age = value;
    }
}

如下两实例对象：

3.8 内部类（Nested Class）

class Outer {
    class Inner {
        // 定义了一个Inner Class
    }
}