千峰逆战班，Day17

在千锋逆战班学习的第17天。

有人要赢那为什么不能是我呢？

今天我学习了JAVA课程的 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()
}