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

旧城冷巷雨未停 提交于 2021-01-12 06:31:54

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不能同时省略。

 

标签
易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!