【JavaSE】Java基础·疑难点汇集

Java基础·疑难点

---

2019-08-03  19:51:39  by冲冲

1. 部分Java关键字

instanceof：用来测试一个对象是否是指定类型的实例。

native：用来声明一个方法是由与计算机相关的语言（C/C++/FORTRAN语言）实现的。

（1）break、continue

break：①switch判断语句中，用于跳出switch语句体。②一个循环体中，用于跳出该循环体。

注意：当循环体中包含switch语句，若break在switch语句中，则用于结束switch语句；若想用于结束该循环体，则在switch体外设置break。

continue：仅结束本次循环，然后开始下一次循环。（跳过本次循环体中余下未执行的语句，立即进行下一次循环条件的判定）

（2）final、finally

final：声明为最终，表明一个final类不能派生子类、或者一个final方法不能被覆盖，或者一个final成员的不能改变值。（String类就是一个final类）

finally：用于在处理异时，声明一个肯定会被执行到的语句块。fianlly块不被执行的情况

注意

① final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

② 当你不希望该方法在子类中被覆盖时声明其为final。父类的final方法不能被子类重写，但是可以被重载。需要注意的是，因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法其访问控制权限为private，将会导致子类中不能直接继承到此方法，因此可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的同名方法，该方法属于子类本身的方法。（注：类的private方法会隐式地被指定为final方法。）

③ final成员变量表示常量，只能被赋值一次，赋值后值不再改变。当final修饰一个基本数据类型时，表示该基本数据类型的值一旦在初始化后便不能发生变化；如果final修饰一个引用类型时，则在对其初始化之后便不能再让其指向其他对象了，但该引用所指向的对象的内容是可以发生变化的。本质上是一回事，因为引用的值是一个地址，final要求值，即地址的值不发生变化。

④ final修饰一个成员变量（属性），必须要显示初始化。这里有两种初始化方式，一种是在变量声明的时候初始化；第二种方法是在声明变量的时候不赋初值，但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。当参数的类型声明为final时，说明该参数是只读型的。即你可以读取使用该参数，但是无法改变该参数的值。

浅谈Java中的final关键字　　

（3）super、this

super：表示当前对象的父类型引用，或者父类型的构造方法。
this：表示当前对象的引用，或者当前对象的构造方法。

注意

① 如果通过this关键字调用其他构造方法时，this()语句必须是该构造方法的第一个子句，否则编译器会报错。也就是说，在构造方法中只能调用一次this([参数])，第二个子句不能再使用this。

② 如果该构造方法没有显式地通过this调用其他构造方法，那么编译器不会自动为它添加默认的this()方法调用，但是会自动为它加上一个默认的super()方法调用！

③ 如果该构造方法没有显式地调用父类的构造方法，那么编译器会自动为它加上一个默认的super()方法调用。如果父类没有默认的无参构造方法，编译器就会报错，super()语句必须是该构造方法的第一个子句。每个子类构造方法的第一条语句，都是隐含地调用super()，如果该子类构造器的第一句是this([参数n])，那么该this([参数n])方法的第一句就得显式或隐式调用super()。如果还是this([参数n])的第一句还是this([参数m])，那么该this([参数m])方法的第一句就得显式或隐式调用super()，依次类推...

④ this()和super()表示的都是对象，所以都不能在static环境中使用。包括：static变量、static方法、static语句块。

class Creature {
    public Creature(){
        // 这里会自动调用最终父类的默认构造器 Object()
        System.out.println("初始化一个生物");
    }
}

class Animal extends Creature {
    public Animal(){
        // 这里会自动调用父类Creature的默认构造器 super()
        System.out.println("初始化一个动物");
    }

    public Animal(int head){
        this();
        this.head = head;
        System.out.println("该动物有"+head+"个头");
    }

    public Animal(int head, int nose){
        //this(); this只能调用一个
        this(head);
        this.nose = nose;
        System.out.println("该动物有"+head+"个头和"+nose+"个鼻子");
    }
}

（4）throw、throws

throw：出现在函数体内，表示抛出一个异常。
throws：出现在函数头，用于声明在当前方法中所有需要抛出的异常。

通常情况，当程序的语句出现异常时，系统会被动地自动抛出异常。

1 public static void main(String[] args) {
2     int a = 5, b =0;
3     System.out.println(5/b);
4 }
5 /**************
6 系统会自动抛出ArithmeticException异常，程序意外中止
7 ***************/

① throw表示主动抛出一个异常，通常发生在代码块的内部，当程序出现某种逻辑错误时由程序员主动抛出某种特定类型的异常。

 1 public static void main(String[] args) {
 2     String s = "abc";
 3     if(s.equals("abc")) {
 4       throw new NumberFormatException();
 5     } else {
 6       System.out.println(s);
 7     }
 8 }
 9 /************
10 控制台显示：
11 Exception in thread "main" java.lang.NumberFormatException at......
12 *************/

② throws用于声明方法可能抛出的异常。

public void function() throws Exception{......}

当某个方法可能会抛出某种异常时用throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理。

 1 public class testThrows {
 2
 3     public static void function() throws NumberFormatException {
 4         String s = "abc";
 5         System.out.println(Double.parseDouble(s));
 6     }
 7
 8     public static void main(String[] args) {
 9         try {
10             function();
11         } catch (NumberFormatException e) {
12             System.err.println("非数据类型不能强制类型转换。");
13             //e.printStackTrace();
14         }
15     }
16 }
17 /************
18 控制台显示：
19 非数据类型不能强制类型转换。
20 *************/

throw和throws 两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），它们只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用者来处理。

通常情况，程序对可能会出现异常的部分，要用try{...}catch{...}去捕捉它，并在catch{...}中对该异常进行处理。处理的方式可以是一句简单的输出语句，可以是栈输出e.printStackTrace(); ，或者其它。

如果是捕捉IO输入输出流中的异常，一定要在try{...}catch{...}后加finally{...}把输入输出流关闭。

如果在函数体内用throw抛出某种异常，最好要在函数名中用throws对抛出的异常进行声明，然后交给调用它的上层函数通过catch{...}进行处理。

（5）synchronized、volatile

synchronized：表示一段代码需要同步执行。
volatile：表示两个或多个变量必须同步地发生变化。

2. break自定义标签跳转

 1 public class Test {
 2     public static void main(String[] args) {
 3         int i, j;
 4         first: for (i = 4; i > 1; i--) {
 5             second: for (j = 4; j > 1; j--) {
 6                 if (j == 2) {
 7                     break first;
 8                 }
 9                 System.out.println(i + "-" + j);
10             }
11         }
12     }
13 }
14
15 /****************
16 输出结果：
17 4-4
18 4-3
19 *****************/

3. try、catch、finally的搭配

try语句后面必须要有一个别的语句（catch块或者finally块）跟在后面。try-catch、try-catch-finally、try-finally。其中catch和finally不能同时省略。