【273天】我愛刷題系列(32)

叨叨兩句

  1. 學到腦殼疼,看來必須時刻保持血糖穩定,否則身體無法持續戰鬥

牛客網——java專項練習012

1

在某個類A中存在一個方法:void set(int x),如下不能做爲這個方法的重載的聲明的是()
正確答案: A 你的答案: A (正確)html

A void set(int y)
B int set(int x,double y)
C double set(int x,int y)
D void set(int x,int y)java

方法重載知足的條件  1. 同一個類中,方法名相同,參數列表不一樣的2個或多個方法構成方法的重載   2.參數列表不一樣指參數的類型,參數的個數,參數的順序至少一項不一樣    3.方法的返回值類型,方法的修飾符能夠不一樣。

2

下列說法正確的有()
正確答案: C 你的答案: C (正確)程序員

A class中的constructor不可省略
B constructor必須與class同名,但方法不能與class同名
C constructor在一個對象被new時執行
D 一個class只能定義一個constructororacle

B選項錯在普通的類方法是能夠和類名同名的,和構造方法惟一的區分就是,構造方法沒有返回值

3

執行下列代碼的輸出結果是( C )
A 10
B 20
C 30
D 40函數

public class Demo{
 public static void main(String args[]){
   int num = 10;
   System.out.println(test(num));
}
public static int test(int b){
   try
   {
    b += 10;
    return b;
   }
   catch(RuntimeException e)
   {
   }
   catch(Exception e2)
   {
   }
   finally
   {
    b += 10;
    return b;
   }
  }
}

推薦博文try-catch-finally執行順序詳解:http://qing0991.blog.51cto.co...學習

try塊中拋出異常,try、catch和finally中都有return語句
public static int WithException(){
            int i=10;
            try{
                System.out.println("i in try block is : "+i);
                i = i/0;
                return --i;
            }
            catch(Exception e){
                System.out.println("i in catch - form try block is : "+i);
                --i;
                System.out.println("i in catch block is : "+i);
                return --i;
            }
            finally{          
                System.out.println("i in finally - from try or catch block is--"+i);
                --i;
                System.out.println("i in finally block is--"+i);
                return --i;
            }
}
執行結果:
============WithException==================
i in try block is : 10
i in catch - form try block is : 10
i in catch block is : 9
i in finally - from try or catch block is--8
i in finally block is--7
6
===============================
執行順序:
拋出異常後,執行catch塊,在catch塊的return的--i執行完後,並不直接返回而是執行finally,因finally中有return語句,因此,執行,返回結果6。
結論:
try塊中拋出異常,try、catch和finally中都有return語句,返回值是finally中的return。

整體結論:
結論一:
return語句並非函數的最終出口,若是有finally語句,這在return以後還會執行finally(return的值會暫存在棧裏面,等待finally執行後再返回)
結論二:
finally裏面不建議放return語句,根據須要,return語句能夠放在try和catch裏面和函數的最後。可行的作法有四:
(1)return語句只在函數最後出現一次。
(2)return語句僅在try和catch裏面都出現。
(3)return語句僅在try和函數的最後都出現。
(4)return語句僅在catch和函數的最後都出現。
注意,除此以外的其餘作法都是不可行的,編譯器會報錯

4

What will be printed when you execute the following code?this

class C {
    C() {
        System.out.print("C");
    }
}
 
class A {
    C c = new C();
 
    A() {
        this("A");
        System.out.print("A");
    }
 
    A(String s) {
        System.out.print(s);
    }
}
 
class Test extends A {
    Test() {
        super("B");
        System.out.print("B");
    }
 
    public static void main(String[] args) {
        new Test();
    }
}

正確答案: B 你的答案: B (正確)code

A BB
B CBB
C BAB
D None of the aboveorm

初始化過程是這樣的: 
1.首先,初始化父類中的靜態成員變量和靜態代碼塊,按照在程序中出現的順序初始化; 
2.而後,初始化子類中的靜態成員變量和靜態代碼塊,按照在程序中出現的順序初始化; 
3.其次,初始化父類的普通成員變量和代碼塊,在執行父類的構造方法;
4.最後,初始化子類的普通成員變量和代碼塊,在執行子類的構造方法; 
 
(1)初始化父類的普通成員變量和代碼塊,執行 C c = new C(); 輸出C 
(2)super("B"); 表示調用父類的構造方法,不調用父類的無參構造函數,輸出B 
(3) System.out.print("B"); 
 因此輸出CBB

5

下面代碼運行結果是()htm

public class Test{

public int add(int a,int b){   
     try {
         return a+b;      
     } 
    catch (Exception e) {  
        System.out.println("catch語句塊");
     }
     finally{ 
         System.out.println("finally語句塊");
     }
     return 0;
} 
 public static void main(String argv[]){ 
     Test test =new Test(); 
     System.out.println("和是:"+test.add(9, 34)); 
 }

}

正確答案: C 你的答案: C (正確)

A catch語句塊
和是:43

B 編譯異常

C finally語句塊
和是:43

D 和是:43
finally語句塊

先來看一段代碼:

public abstract class Test {
    public static void main(String[] args) {
        System.out.println(beforeFinally());
    }
     
    public static int beforeFinally(){
        int a = 0;
        try{
            a = 1;
            return a;
        }finally{
            a = 2;
        }
    }
}
/**output:
1
*/
從結果上看,貌似`finally` 裏的語句是在`return` 以後執行的,其實否則,實際上`finally` 裏的語句是在在`return` 以前執行的。那麼問題來了,既然是在以前執行,那爲何`a` 的值沒有被覆蓋了?
實際過程是這樣的:當程序執行到try{}語句中的return方法時,它會幹這麼一件事,將要返回的結果存儲到一個臨時棧中,而後程序不會當即返回,而是去執行finally{}中的程序, 在執行`a = 2`時,程序僅僅是覆蓋了a的值,但不會去更新臨時棧中的那個要返回的值 。執行完以後,就會通知主程序「finally的程序執行完畢,能夠請求返回了」,這時,就會將臨時棧中的值取出來返回。這下應該清楚了,要返回的值是保存至臨時棧中的。
再來看一個例子,稍微改下上面的程序:


public abstract class Test {
    public static void main(String[] args) {
        System.out.println(beforeFinally());
    }
     
    public static int beforeFinally(){
        int a = 0;
        try{
            a = 1;
            return a;
        }finally{
            a = 2;
            return a;
        }
    }
}
/**output:
2
*/
在這裏,finally{}裏也有一個return,那麼在執行這個return時,就會更新臨時棧中的值。一樣,在執行完finally以後,就會通知主程序請求返回了,即將臨時棧中的值取出來返回。故返回值是2.

6

往OuterClass類的代碼段中插入內部類聲明, 哪個是錯誤的:

public class OuterClass{

private float f=1.0f;
//插入代碼到這裏

}
正確答案: A B C D 你的答案: 空 (錯誤)

A class InnerClass{
public static float func(){return f;}
}

B abstract class InnerClass{
public abstract float func(){}
}

C static class InnerClass{
protected static float func(){return f;}
}

D public class InnerClass{
static float func(){return f;}
}

這是我學習Java內部類的筆記
1.爲何使用內部類?
使用內部類最吸引人的緣由是:每一個內部類都能獨立地繼承一個(接口的)實現,因此不管外圍類是否已經繼承了某個(接口的)實現,
對於內部類都沒有影響
1.1.使用內部類最大的優勢就在於它可以很是好的解決多重繼承的問題,使用內部類還可以爲咱們帶來以下特性:
(1)、內部類能夠用多個實例,每一個實例都有本身的狀態信息,而且與其餘外圍對象的信息相互獨。
(2)、在單個外圍類中,可讓多個內部類以不一樣的方式實現同一個接口,或者繼承同一個類。
(3)、建立內部類對象的時刻並不依賴於外圍類對象的建立。
(4)、內部類並無使人迷惑的「is-a」關係,他就是一個獨立的實體。
(5)、內部類提供了更好的封裝,除了該外圍類,其餘類都不能訪問。
2.內部類分類:
(一).成員內部類:

public class Outer{
        private int age = 99;
        String name = "Coco";
        public class Inner{
            String name = "Jayden";
            public void show(){
                System.out.println(Outer.this.name);
                System.out.println(name);
                System.out.println(age);
            }
        }
        public Inner getInnerClass(){
            return new Inner();
        }
        public static void main(String[] args){
            Outer o = new Outer();
            Inner in = o.new Inner();
            in.show();
        }
    }
1.Inner 類定義在 Outer 類的內部,至關於 Outer 類的一個成員變量的位置,Inner 類可使用任意訪問控制符,
如 public 、 protected 、 private 等
2.Inner 類中定義的 show() 方法能夠直接訪問 Outer 類中的數據,而不受訪問控制符的影響,
如直接訪問 Outer 類中的私有屬性age
3.定義了成員內部類後,必須使用外部類對象來建立內部類對象,而不能直接去 new 一個內部類對象,
即:內部類 對象名 = 外部類對象.new 內部類( );
4.編譯上面的程序後,會發現產生了兩個 .class 文件: Outer.class,Outer$Inner.class{}
5.成員內部類中不能存在任何 static 的變量和方法,能夠定義常量:
(1).由於非靜態內部類是要依賴於外部類的實例,而靜態變量和方法是不依賴於對象的,僅與類相關,
簡而言之:在加載靜態域時,根本沒有外部類,所在在非靜態內部類中不能定義靜態域或方法,編譯不經過;
非靜態內部類的做用域是實例級別
(2).常量是在編譯器就肯定的,放到所謂的常量池了
★★友情提示:
1.外部類是不能直接使用內部類的成員和方法的,可先建立內部類的對象,而後經過內部類的對象來訪問其成員變量和方法;
2.若是外部類和內部類具備相同的成員變量或方法,內部類默認訪問本身的成員變量或方法,若是要訪問外部類的成員變量,
可使用 this 關鍵字,如:Outer.this.name
(二).靜態內部類: 是 static 修飾的內部類,
1.靜態內部類不能直接訪問外部類的非靜態成員,但能夠經過 new 外部類().成員 的方式訪問 
2.若是外部類的靜態成員與內部類的成員名稱相同,可經過「類名.靜態成員」訪問外部類的靜態成員;
若是外部類的靜態成員與內部類的成員名稱不相同,則可經過「成員名」直接調用外部類的靜態成員
3.建立靜態內部類的對象時,不須要外部類的對象,能夠直接建立 內部類 對象名 = new 內部類();

public class Outer{
            private int age = 99;
            static String name = "Coco";
            public static class Inner{
                String name = "Jayden";
                public void show(){
                    System.out.println(Outer.name);
                    System.out.println(name);                  
                }
            }
            public static void main(String[] args){
                Inner i = new Inner();
                i.show();
            }
        }
(三).方法內部類:訪問僅限於方法內或者該做用域內 
(1).局部內部類就像是方法裏面的一個局部變量同樣,是不能有 public、protected、private 以及 static 修飾符的
(2).只能訪問方法中定義的 final 類型的局部變量,由於:
當方法被調用運行完畢以後,局部變量就已消亡了。但內部類對象可能還存在,
直到沒有被引用時纔會消亡。此時就會出現一種狀況,就是內部類要訪問一個不存在的局部變量;
==>使用final修飾符不只會保持對象的引用不會改變,並且編譯器還會持續維護這個對象在回調方法中的生命週期.
局部內部類並非直接調用方法傳進來的參數,而是內部類將傳進來的參數經過本身的構造器備份到了本身的內部,
本身內部的方法調用的實際是本身的屬性而不是外部類方法的參數;
防止被篡改數據,而致使內部類獲得的值不一致

   /*
        使用的形參爲什麼要爲 final???
         在內部類中的屬性和外部方法的參數二者從外表上看是同一個東西,但實際上卻不是,因此他們二者是能夠任意變化的,
         也就是說在內部類中我對屬性的改變並不會影響到外部的形參,而然這從程序員的角度來看這是不可行的,
         畢竟站在程序的角度來看這兩個根本就是同一個,若是內部類該變了,而外部方法的形參卻沒有改變這是難以理解
         和不可接受的,因此爲了保持參數的一致性,就規定使用 final 來避免形參的不改變
         */
        public class Outer{
            public void Show(){
                final int a = 25;
                int b = 13;
                class Inner{
                    int c = 2;
                    public void print(){
                        System.out.println("訪問外部類:" + a);
                        System.out.println("訪問內部類:" + c);
                    }
                }
                Inner i = new Inner();
                i.print();
            }
            public static void main(String[] args){
                Outer o = new Outer();
                o.show();
            }
        }    
(3).注意:在JDK8版本之中,方法內部類中調用方法中的局部變量,能夠不須要修飾爲 final,匿名內部類也是同樣的,主要是JDK8以後增長了 Effectively final 功能
http://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html
反編譯jdk8編譯以後的class文件,發現內部類引用外部的局部變量都是 final 修飾的 
(四).匿名內部類:
(1).匿名內部類是直接使用 new 來生成一個對象的引用;
(2).對於匿名內部類的使用它是存在一個缺陷的,就是它僅能被使用一次,建立匿名內部類時它會當即建立一個該類的實例,
該類的定義會當即消失,因此匿名內部類是不可以被重複使用;
(3).使用匿名內部類時,咱們必須是繼承一個類或者實現一個接口,可是二者不可兼得,同時也只能繼承一個類或者實現一個接口;
(4).匿名內部類中是不能定義構造函數的,匿名內部類中不能存在任何的靜態成員變量和靜態方法;
(5).匿名內部類中不能存在任何的靜態成員變量和靜態方法,匿名內部類不能是抽象的,它必需要實現繼承的類或者實現的接口的全部抽象方法
(6).匿名內部類初始化:使用構造代碼塊!利用構造代碼塊可以達到爲匿名內部類建立一個構造器的效果

  public class OuterClass {
            public InnerClass getInnerClass(final int   num,String str2){
                return new InnerClass(){
                    int number = num + 3;
                    public int getNumber(){
                        return number;
                    }
                };        /* 注意:分號不能省 */
            }
            public static void main(String[] args) {
                OuterClass out = new OuterClass();
                InnerClass inner = out.getInnerClass(2, "chenssy");
                System.out.println(inner.getNumber());
            }
        }
        interface InnerClass {
            int getNumber();
        }
相關文章
相關標籤/搜索