Day17-final、接口

 

總結：

final：

                final 修飾類：此類不能被繼承。

                final 修飾方法：此方法不能被覆蓋。

                final 修飾變量：此變量不可被改變。

                基本數據類型常量：值不可變。                引用數據類型常量：地址不可變。

接口：

                接口不是類。

                接口中只能定義 公開 靜態 常量（變量）      接口中只能定義 公開 抽象 方法（方法）

                沒有構造方法、沒有動態代碼塊、沒有靜態代碼塊。

                僅可調用接口中所聲明的方法，而不可調用實現類中獨有的方法。

                實現接口中的抽象方法時，訪問修飾符必須是public。

 

習題：

C7.7:  有如下代碼：

class MyClass{
    final int value;
    public MyClass(){}
    public MyClass(int value){
        this.value=value;
    }
}

public class TestMain{
    public static void main(String[] args){
        MyClass mc=new MyClass(10);
        System.out.println(mc.value);
    }
}

                選擇正確答案：C

                A.編譯通過，輸出10

                B.編譯不通過，把第2行改爲 final int value=10;

                C.編譯不通過，把第3行改爲 public MyClass(){ value=10; }

 

C7.8:  有如下代碼：

class MyClass{
    public void printValue(final int value){
        System.out.println(value);
    }
    public void changeValue(int value){
        value=value*2;
        System.out.println(value);
    }
}

public class TestMain{
    public static void main(String[] args){
        MyClass mc=new MyClass();
        int value=5;
        final int fvalue=10;
        mc.printValue(value);//1
        mc.printValue(fvalue);//2
        mc.changeValue(value);//3
        mc.changeValue(fvalue);//4
    }
}

                選擇正確答案：A.編譯通過

 

C7.9  有如下代碼：

class MyValue{
    int value;
}

public class TestFinal{
    public static void main(String[] args){
        final MyValue mv=new MyValue();
        mv.value=100;
        //1
        System.out.println(mv.value);
    }
}

                下面說法正確的是：C.編譯通過。如果在//1處加上：mv=new MyValue(); 則編譯不通過。

 

C7.10 有如下代碼：

class Super{
    public final void m1(){
        System.out.println("m1() in Super");
    }
    public void m1(int i){
        System.out.println("m1(int) in Super");
    }
}

class Sub extends Super{
    public void m1(int i){
        System.out.println("m1(int) in Sub");
    }
    public void m1(double d){
        System.out.println("m1(double) in Sub");
    }
}

public class TestMain{
    public static void main(String[] args){
        Sub s=new Sub();
        s.m1();
        s.m1(10);
        s.m1(1.5);
    }
}

                程序能否編譯通過：能

                運行結果爲：

 

C7.13 下列方法聲明中正確的是：DF

                A. abstract final void m()        final不能被子類覆蓋，abstract要被子類覆蓋

                B. public void final m()           修飾符要在前邊？

                C. static abstract void m()      靜態沒有多態

                D. private final void m()

                E. private abstract void m()   private不能被繼承，子類就無法覆蓋父類

                F. public static final void m()

 

C8.1 代碼改錯：

interface IA{
    void m1();
    int a=100;
}

class MyClass implements IA{
    void m1(){} //public
}

public class TestInterface{
    public static void main(String[] args){
        Ia ia=new MyClass();
        ia.m1();
        System.out.println(IA.a);
    }
}

               

C8.2 代碼填空：

interface IA{
    void m1();
    void m2();
}

_____class MyClassA implements IA{ //abstract
    public void m1(){}
}

class MyClassB extends MyClassA{
    ________{} //public void m2()
}