[huayang]

变量和数据类型

在 Java 中，变量必须先定义后使用，在定义变量的时候，可以给它一个初始值

注意到第一次定义变量 x 的时候，需要指定变量类型 int，因此使用语句 int x = 100;。而第二次重新赋值的时候，变量 x 已经存在了，不能再重复定义，因此不能指定变量类型 int，必须使用语句 x = 200;

基本数据类型整数类型：byte，short，int，long浮点数类型：float，double （double与float的区别取值范围和字节数 Double更大）字符类型：char布尔类型：boolean

注意 char 类型使用单引号'，且仅有一个字符，要和双引号 " 的字符串类型区分开

常量在定义时进行初始化后就不可再次赋值，再次赋值会导致编译错误。

使用 var 定义变量，仅仅是少写了变量类型而已

定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，不要重复使用变量名

整数运算

特别注意：整数的除法对于除数为 0 时运行时将报错，但编译不会报错。

移位运算

在计算机中，整数总是以二进制的形式表示

比如：

<< 表示向左位移一位  

>> 表示向右位移一位

还有一种无符号的右移运算，使用 >>>，它的特点是不管符号位，右移后高位总是补 0

int n = -536870912;int a = n >> 1;  // 11110000 00000000 00000000 00000000 = -268435456int b = n >> 2;  // 11111000 00000000 00000000 00000000 = -134217728int c = n >> 28; // 11111111 11111111 11111111 11111110 = -2int d = n >> 29; // 11111111 11111111 11111111 11111111 = -1

位运算

与运算，符号为｜，1｜1 为 1 反之都为 0

或运算，符号为 &，0&0 为 0 反之都为 1

异或运算，符号为 ^，同为 0 异为 1

在Java的计算表达式中，运算优先级从高到低依次是：()! ~ ++ --* / %+ -<< >> >>>&|+= -= *= /=记不住也没关系，只需要加括号就可以保证运算的优先级正确。

在运算过程中，如果参与运算的两个数类型不一致，那么计算结果为较大类型的整型

要注意，超出范围的强制转型会得到错误的结果，原因是转型时，int 的两个高位字节直接被扔掉，仅保留了低位的两个字节

因此，强制转型的结果很可能是错的。

浮点数运算

浮点数运算和整数运算相比，只能进行加减乘除这些数值计算，不能做位运算和移位运算。

在计算机中，浮点数虽然表示的范围大，但是，浮点数有个非常重要的特点，就是浮点数常常无法精确表示。

可以将浮点数强制转型为整数。在转型时，浮点数的小数部分会被丢掉。如果转型后超过了整型能表示的最大范围，将返回整型的最大值

布尔运算

布尔运算是一种关系运算，包括以下几类：

• 比较运算符：>，>=，<，<=，==，!=
• 与运算 &&
• 或运算 ||
• 非运算 !

关系运算符的优先级从高到低依次是：

• !
• >，>=，<，<=
• ==，!=
• &&
• ||

短路运算

布尔运算的一个重要特点是短路运算。如果一个布尔运算的表达式能提前确定结果，则后续的计算不再执行，直接返回结果。

三元运算符

int n = -100;        int x = n >= 0 ? n : -n;//n=100

字符和字符串

在 Java 中，字符和字符串是两个不同的类型。

Java 在内存中总是使用 Unicode 表示字符

转义字符 \

字符串连接

使用 + 连接任意字符串和其他数据类型

如果用 + 连接字符串和其他数据类型，会将其他数据类型先自动转型为字符串

从 Java 13 开始，字符串可以用 """...""" 表示多行字符串（Text Blocks）了

不可变特性

数组类型

 // 5位同学的成绩:        int[] ns = new int[5];        ns[0] = 68;        ns[1] = 79;        ns[2] = 91;        ns[3] = 85;        ns[4] = 62;

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

  // 5位同学的成绩:        int[] ns = new int[5];        System.out.println(ns.length); // 5

也可以在定义数组时直接指定初始化的元素，这样就不必写出数组大小

int[] ns = new int[] { 68, 79, 91, 85, 62 };

还可以进一步简写为：

int[] ns = { 68, 79, 91, 85, 62 };

输入和输出

println 是 print line 的缩写，表示输出并换行。因此，如果输出后不想换行，可以用 print()

 占位符	说明%d	格式化输出整数%x	格式化输出十六进制整数%f	格式化输出浮点数%e	格式化输出科学计数法表示的浮点数%s	格式化字符串

由于 % 表示占位符，因此，连续两个 %% 表示一个 % 字符本身。

if 判断

引用类型判断内容相等要使用 equals()

switch 多重选择

如果 option 的值没有匹配到任何 case，这时，可以给 switch 语句加一个 default，当没有匹配到任何 case 时，执行 default

public class Main {    public static void main(String[] args) {        int option = 99;        switch (option) {        case 1:            System.out.println("Selected 1");            break;        case 2:            System.out.println("Selected 2");            break;        case 3:            System.out.println("Selected 3");            break;        default:            System.out.println("Not selected");            break;        }    }}

使用 switch 时，注意 case 语句并没有花括号 {}，而且，case 语句具有 “穿透性”，漏写 break 将导致意想不到的结果

如果有几个 case 语句执行的是同一组语句块，可以这么写：

public class Main {    public static void main(String[] args) {        int option = 2;        switch (option) {        case 1:            System.out.println("Selected 1");            break;        case 2:        case 3:            System.out.println("Selected 2, 3");            break;        default:            System.out.println("Not selected");            break;        }    }}

switch 语句还可以匹配字符串

switch 表达式

从 Java 12 开始，switch 语句升级为更简洁的表达式语法，使用类似模式匹配（Pattern Matching）的方法，保证只有一种路径会被执行，并且不需要 break 语句

public class Main {    public static void main(String[] args) {        String fruit = "apple";        int opt = switch (fruit) {            case "apple" -> 1;            case "pear", "mango" -> 2;            default -> 0;        }; // 注意赋值语句要以;结束        System.out.println("opt = " + opt);    }}

注意新语法使用 ->，如果有多条语句，需要用 {} 括起来。不要写 break 语句，因为新语法只会执行匹配的语句，没有穿透效应。

yield

返回

while 循环

while (条件表达式) {    循环语句}// 继续执行后续代码

注意到 while 循环是先判断循环条件，再循环，因此，有可能一次循环都不做

do while 循环

do while 循环则是先执行循环，再判断条件，条件满足时继续循环，条件不满足时退出。它的用法是：

do {    执行循环语句} while (条件表达式);

for 循环

使用 for 循环时，计数器变量 i 要尽量定义在 for 循环中

for each 循环

        int[] ns = { 1, 4, 9, 16, 25 };        for (int n : ns) {            System.out.println(n);        }

break 和 continue

break

在循环过程中，可以使用 break 语句跳出当前循环

要特别注意，break 语句总是跳出自己所在的那一层循环

continue

continue 则是提前结束本次循环，直接继续执行下次循环

遍历数组

打印数组内容

Java 标准库提供了 Arrays.toString()，可以快速打印数组内容

import java.util.Arrays;public class Main {    public static void main(String[] args) {        int[] ns = { 1, 1, 2, 3, 5, 8 };        System.out.println(Arrays.toString(ns));    }}

数组排序

实际上，Java 的标准库已经内置了排序功能，我们只需要调用 JDK 提供的 Arrays.sort() 就可以排

import java.util.Arrays;public class Main {    public static void main(String[] args) {        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };        Arrays.sort(ns);        System.out.println(Arrays.toString(ns));    }}

多维数组

二维数组

二维数组就是数组的数组。定义一个二维数组如下：

public class Main {    public static void main(String[] args) {        int[][] ns = {            { 1, 2, 3, 4 },            { 5, 6, 7, 8 },            { 9, 10, 11, 12 }        };        System.out.println(ns.length); // 3    }}

打印一个二维数组使用 Java 标准库的 Arrays.deepToString()：

import java.util.Arrays;public class Main {    public static void main(String[] args) {        int[][] ns = {            { 1, 2, 3, 4 },            { 5, 6, 7, 8 },            { 9, 10, 11, 12 }        };        System.out.println(Arrays.deepToString(ns));    }}

三维数组

三维数组就是二维数组的数组。可以这么定义一个三维数组：

int[][][] ns = {    {        {1, 2, 3},        {4, 5, 6},        {7, 8, 9}    },    {        {10, 11},        {12, 13}    },    {        {14, 15, 16},        {17, 18}    }};

面向对象基础

定义 class

在 Java 中，创建一个类，例如，给这个类命名为 Person，就是定义一个 class：

class Person {    public String name;    public int age;}

一个 class 可以包含多个字段（field），字段用来描述一个类的特征。上面的 Person 类，我们定义了两个字段，一个是 String 类型的字段，命名为 name，一个是 int 类型的字段，命名为 age。因此，通过 class，把一组数据汇集到一个对象上，实现了数据封装。

public 是用来修饰字段的，它表示这个字段可以被外部访问

在 OOP 中，class 和 instance 是 “模版” 和 “实例” 的关系；

定义 class 就是定义了一种数据类型，对应的 instance 是这种数据类型的实例；

class 定义的 field，在每个 instance 都会拥有各自的 field，且互不干扰；

通过 new 操作符创建新的 instance，然后用变量指向它，即可通过变量来引用这个 instance；

指向 instance 的变量都是引用变量。

访问实例变量可以用变量.字段

Person ming = new Person();ming.name = "Xiao Ming"; // 对字段name赋值ming.age = 12; // 对字段age赋值System.out.println(ming.name); // 访问字段namePerson hong = new Person();hong.name = "Xiao Hong";hong.age = 15;

方法

为了避免外部代码直接去访问 field，我们可以用 private 修饰 field，拒绝外部访问

把 field 从 public 改成 private，外部代码不能访问这些 field

我们需要使用方法（method）来让外部代码可以间接修改 field

• 方法内部遇到 return 时返回，void 表示不返回任何值（注意和返回 null 不同）；
• 外部代码通过 public 方法操作实例，内部代码可以调用 private 方法；
• 理解方法的参数绑定。

this 变量

它始终指向当前实例。因此，通过 this.field 就可以访问当前实例的字段

如果没有命名冲突，可以省略 this

构造方法

public class Main {    public static void main(String[] args) {        // TODO: 给Person增加构造方法:        Person ming = new Person("小明", 12);/** 等同于Person ming = new Person(); ming.setName("小明"); ming.setAge(12);**/        System.out.println(ming.getName());        System.out.println(ming.getAge());    }}class Person {    private String name;    private int age;    public Person(String n,int a){    name = n;    age = a;    }    public String getName() {        return name;    }    public int getAge() {        return age;    }}

没有定义构造方法时，编译器会自动创建一个默认的无参数构造方法；

可以定义多个构造方法，编译器根据参数自动判断；

可以在一个构造方法内部调用另一个构造方法，便于代码复用。

方法重载

多个相同名称的方法如果想在同一个类中共存，那么这些同名的方法一定是参数的个数或者参数的数据类型不一样，这种同名的方法就叫做重载（Overload）

方法重载的目的是，功能类似的方法使用同一名字，更容易记住，因此，调用起来更简单。

继承

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

class Person {    private String name;    private int age;    public String getName() {...}    public void setName(String name) {...}    public int getAge() {...}    public void setAge(int age) {...}}class Student extends Person {    // 不要重复name和age字段/方法,    // 只需要定义新增score字段/方法:    private int score;    public int getScore() { … }    public void setScore(int score) { … }}

多态

若编译时的类型和运行时的类型不一样就会出现多态

在继承关系中，子类如果定义了一个与父类方法签名完全相同的方法，被称为覆写（Override）。

在子类Student中，覆写这个run()方法：class Student extends Person {    @Override    public void run() {        System.out.println("Student.run");    }}

注意：方法名相同，方法参数相同，但方法返回值不同，也是不同的方法。在 Java 程序中，出现这种情况，编译器会报错。

小结

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

抽象类

由于多态的存在，每个子类都可以覆写父类的方法

抽象类中有一个抽象方法就必须是抽象类，抽象方法用ABSTRACT修饰。

因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。

使用 abstract 修饰的类就是抽象类。我们无法实例化一个抽象类：

abstract class Person {    public abstract void run();}

Person p = new Person(); // 编译错误

定义了抽象的方法要实现类的时候就必须要复写

• 如果不实现抽象方法，则该子类仍是一个抽象类；

面向抽象编程

面向抽象编程的本质就是：

• 上层代码只定义规范（例如：abstract class Person）；
• 不需要子类就可以实现业务逻辑（正常编译）；
• 具体的业务逻辑由不同的子类实现，调用者并不关心。

接口

如果一个抽象类没有字段，所有方法全部都是抽象方法：

abstract class Person {    public abstract void run();    public abstract String getName();}

就可以把该抽象类改写为接口：interface。

在 Java 中，使用 interface 可以声明一个接口：

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

接口定义的所有方法默认都是 public abstract 的，所以这两个修饰符不需要写出来（写不写效果都一样）

当一个具体的 class 去实现一个 interface 时，需要使用 implements 关键字。

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

一个类可以实现多个 interface，多个接口用，分隔

如果类没有实现接口所有方法，那么这个类就要定义抽象类

接口继承

一个 interface 可以继承自另一个 interface。interface 继承自 interface 使用 extends，它相当于扩展了接口的方法。

先写继承后写实现

静态字段和静态方法

在一个 class 中定义的字段，我们称之为实例字段。实例字段的特点是，每个实例都有独立的字段，各个实例的同名字段互不影响。

还有一种字段，是用 static 修饰的字段，称为静态字段：static field

class Person {    public String name;    public int age;    // 定义静态字段number:    public static int number;}

对于静态字段，无论修改哪个实例的静态字段，效果都是一样的

静态方法

有静态字段，就有静态方法。用 static 修饰的方法称为静态方法

包

在 Java 中，我们使用 package 来解决名字冲突。

package ming; // 申明包名mingpublic class Person {}

import

在一个 class 中，我们总会引用其他的 class

第一种，直接写出完整类名，例如：

// Person.javapackage ming;public class Person {    public void run() {        mr.jun.Arrays arrays = new mr.jun.Arrays();    }}

第二种写法是用 import 语句，导入小军的 Arrays，然后写简单类名：

// Person.javapackage ming;// 导入完整类名:import mr.jun.Arrays;public class Person {    public void run() {        Arrays arrays = new Arrays();    }}

在写 import 的时候，可以使用 *，表示把这个包下面的所有 class 都导入进来（但不包括子包的 class）：

作用域

我们经常看到 public、protected、private 这些修饰符。在 Java 中，这些修饰符可以用来限定访问作用域。

public

定义为 public 的 class、interface 可以被其他任何类访问

private

定义为 private 的 field、method 无法被其他类访问

protected

protected 作用于继承关系。定义为 protected 的字段和方法可以被子类访问，以及子类的子类

上面的 protected 方法可以被继承的类访问

package xyz;class Main extends Hello {    void foo() {        // 可以访问protected方法:        hi();    }}

package

包作用域是指一个类允许访问同一个 package 的没有 public、private 修饰的 class，以及没有 public、protected、private 修饰的字段和方法

package abc;// package权限的类:class Hello {    // package权限的方法:    void hi() {    }}

只要在同一个包，就可以访问 package 权限的 class、field 和 method：

package abc;class Main {    void foo() {        // 可以访问package权限的类:        Hello h = new Hello();        // 可以调用package权限的方法:        h.hi();    }}

局部变量

在方法内部定义的变量称为局部变量，局部变量作用域从变量声明处开始到对应的块结束

final

用 final 修饰 class 可以阻止被继承

package abc;// 无法被继承:public final class Hello {    private int n = 0;    protected void hi(int t) {        long i = t;    }}

用 final 修饰 method 可以阻止被子类覆写

package abc;public class Hello {    // 无法被覆写:    protected final void hi() {    }}

用 final 修饰 field 可以阻止被重新赋值

package abc;public class Hello {    private final int n = 0;    protected void hi() {        this.n = 1; // error!    }}

用 final 修饰局部变量可以阻止被重新赋值：

package abc;public class Hello {    protected void hi(final int t) {        t = 1; // error!    }}

最佳实践

如果不确定是否需要 public，就不声明为 public，即尽可能少地暴露对外的字段和方法。

把方法定义为 package 权限有助于测试，因为测试类和被测试类只要位于同一个 package，测试代码就可以访问被测试类的 package 权限方法。

一个.java 文件只能包含一个 public 类，但可以包含多个非 public 类。如果有 public 类，文件名必须和 public 类的名字相同。

内部类（Inner Class）

如果一个类定义在另一个类的内部，这个类就是 Inner Class：

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

上述定义的 Outer 是一个普通类，而 Inner 是一个 Inner Class，它与普通类有个最大的不同，就是 Inner Class 的实例不能单独存在，必须依附于一个 Outer Class 的实例。示例代码如下：

public class Main {    public static void main(String[] args) {        Outer outer = new Outer("Nested"); // 实例化一个Outer        Outer.Inner inner = outer.new Inner(); // 实例化一个Inner        inner.hello();    }}class Outer {    private String name;    Outer(String name) {        this.name = name;    }    class Inner {        void hello() {            System.out.println("Hello, " + Outer.this.name);        }    }}

[/huayang]

FROM：浅浅淡淡[hellohy]