再会Java

作者曾写过一段时间Java, 时间一长也就忘得差不多了. 现在重新学习一个, 故而只是提要式的记录.

Java是静态强类型语言, 运行于Java虚拟机(Java Virtual Machine, JVM)上.

若要运行Java程序需要安装Java运行环境(Java Runtime Environment, JRE). 若要编译Java源文件需要安装JDK(Java Development Kit).

• Ubuntu安装: apt-get install openjdk-8-jre-headless

• Mac安装: brew cask install java

Java使用类来组织代码, 源代码保存于.java文件中. 一个源文件可以定义多个类, 最多只能有一个public类，源文件名必须与public类一致.

使用javac [SrcFile]命令编译Java源文件, 每个类都会编译得到一个.class文件. 使用java [ClassName]将会搜索相应地类, 并执行其main()方法.

照例先写HelloWorld:

public class Main {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

编译执行:

$javac Main.java
$java Main
Hello World!

Java标识符可以由字母,数字和_组成, 不得以数字开头, 大小写敏感.

Java的语句以;结尾, 使用{}标志代码块. 语句与行无关, 可以一句几行或一行多句.

Java支持//引导的行注释符和/*, */标志的块注释符.

数据类型

Java提供了一系列内置类型及其封装类, 类型的大小与操作系统无关.

• byte: 8位二进制补码表示的带符号整数, 封装类java.lang.Byte

• short: 16位二进制补码表示的带符号整数, 封装类java.lang.Short

• int: 32位二进制补码表示的带符号整数, 封装类java.lang.Integer

• long: 64位二进制补码表示的带符号整数, 字面值加L后缀, 如233L, 封装类java.lang.Long.

• float: 32位单精度, 符合IEEE754标准的浮点数, 字面值加f或F后缀, 如1f, 封装类java.lang.Float

• double: 64位双精度浮点数, 封装类java.lang.Double

• char: 16位Unicode字符, 字面值使用单引号标志, 如1, 封装类java.lang.Character.

定义变量时初始化::

int sum = 0;

Java的boolean类型对象只能进行关系运算，只有boolean值才能进行流程控制. 其它数据类型(包括int)不能与boolean相互转换，也不能进行流程控制或关系运算.

Java使用与C几乎相同的算术, 关系和逻辑运算符如?:, %, 逻辑运算符同样具有短路特性.

Java同样支持++和--运算符以及复合赋值运算符. 赋值运算符将返回左值, 因此可以进行连续赋值:

public class Main {

    public static void main(String[] args) {
        int a = 0, b= 0;
        System.out.println(a=2);  // 2
        a = b = 3;
        System.out.println(a);  // 3
        System.out.println(b);  // 3

    }
}

引用

Java中除上述内置类型的变量外, 其它变量均为引用类型.

final关键字修饰的对象为常量, 一经初始化无法修改:

final int i = 2;

==运算符用于判断引用是否指向同一个对象, 要判断对象内容是否相同需要使用equals()方法.

流程控制

Java的流程控制语句与C基本相同, 不过做了一些很好的改进:

if

public class Main {

    public static void main(String[] args) {
        int score = 77;
        if (score > 90) {
            System.out.println("Excellent");
        }
        else if (score > 60) {
            System.out.println("Good");
        }
        else {
            System.out.println("Fail");
        }
    }
}

switch

public class Main {

    public static void main(String[] args) {
        char ch = 'a';
        switch (ch) {
            case 'a': System.out.println("Apache"); break;
            case 'b': System.out.println("Basic"); break;
            default: System.out.println("??");
        }
    }
}

while

public class Main {

    public static void main(String[] args) {
        int i = 1, sum = 0;
        while (i <= 100) {
            sum += i;
            i++;
        }
        System.out.println(sum);
    }
}

do

public class Main {

    public static void main(String[] args) {
        int i = 1, sum = 0;
        do {
            sum += i;
            i++;
        } while( i <= 100);
        System.out.println(sum);
    }
}

for

public class Main {

    public static void main(String[] args) {
        int i, sum = 0;
        for (i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

foreach

public class Main {

    public static void main(String[] args) {
        int[] arr = new int[5];
        for (int i : arr) {
            System.out.println(i);
        }

    }
}

break, continue

public class Main {

    public static void main(String[] args) {
        int i, sum = 0;
        for (i = 1; i <= 100; i++) {
            sum += i;
            if (i % 2 == 0) {
              continue;
            }
            if (i > 80) {
                break;
            }
        }
        System.out.println(sum);
    }
}

可以使用label来跳出多层循环:

public class Main {

    public static void main(String[] args) {
        int i, j;
        outer: for (i = 1; i <= 100; i++) {
            for (j = 1; j <= 100; j++) {
                if (j == 10) {
                    continue outer;
                }
                if (i > 3) {
                    break outer;
                }
                System.out.print(i);
                System.out.println(j);
            }
        }
    }
}

异常

异常类族的基类为java.lang.Throwable, 它派生出Error和Exception两个子类.

Error用来指示运行环境错误, 如JVM内存异常. 程序一般无法从Error中恢复.

Exception则是那些可以恢复的异常的基类, 其子类中包括:

• IOException: 找不到文件等造成的输入输出异常

• InterruptedException: 线程被其它线程中断造成的异常

• RuntimeException: 由程序本身造成的异常:

  • NullPointerException: 引用指向的对象不存在造成的异常

  • IndexOutofBoundException: 对容器的访问下标越界造成异常

Java使用try-catch块捕获异常:

public class Main {

    public static void main(String[] args) {
        try {
            throw new RuntimeException("nothing");
        }
        catch (RuntimeException e) {
            System.out.println(e.getMessage());
        }
        catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            ; // release something
        }
    }
}

可能抛出异常的代码在try中, 依次使用catch尝试捕获抛出的异常, 若无法捕获则向上一级方法抛出. 无论是否有异常发生还是异常是否被捕获, finally块中的代码都会被执行.

若方法不处理某个异常就把它向上抛出. 但是方法若可能向上抛出检查性(checked)异常, 必须使用throws关键字声明.

public void test() throws ClassNotFoundException {}

通过继承异常类, 程序员可以自定义异常.

包

Java通过包来管理命名空间. 包声明语句是除注释外Java源文件中的第一条语句.

package com.finley

包管理的是类而非源文件, 多个源文件可以使用同一个包名. 但是字节码.class文件所在的目录结构必须与包名吻合.

通过import语句引入某个类:

import com.finley.Test

使用*可以引入源文件中所有类:

import com.finley.*

Java默认导入java.lang.*, 使用源文件自身包中的其它类也无需引入.