千锋逆战班学习日志

千锋逆战班学习第17天
努力或许没有收获，但不努力一定没收获，加油。
今天我学了Java课程的final关键字h和接口。
中国加油！！！武汉加油！！！千锋加油！！！我自己加油！！！

总结-final关键字

1. final关键字概念：最后的，不可更改的。
2. final可修饰的内容：
   （1）final修饰类（最终类）：此类不能被继承。
   （2）final修饰方法（最终方法）：此方法不能被覆盖。
   （3）final修饰变量（最终变量）：此变量值不能被改变（变量），无初始值，仅允许赋值一次。
3. 要求：
   （1）实例常量（修饰的实例变量不在提供默认值，必须手动赋值）
   (a)在对象构造之前赋值
   (b)赋值位置：显示初始化，动态代码块，构造方法（如果在构造方法中赋值，所 有构造方法必须赋值）
   (2)静态常量（必须手动赋值）
   (a)期限：在类加载完成之前（通过类名调用之前）
   (b)赋值位置：显示初始化，静态代码块。
   (3)局部变量：显示初始化。
   (4)基本数据类型常量：值不可变。
   (5)引用数据类型常量：地址不可变。

总结-接口

1. 语法：
   （1） 接口相当于特殊的抽象类，定义方法、组成部分与抽象类类似。
   (2)interface定义接口
   (3)只能定义公开静态常量、公开抽象方法
2. 与抽象类的异同
   相同：
   (1)可以编译成字节码文件。
   (2)不能创建对象（接口不是类，不是模板的概念，没有构造方法）。
   (3)可以声明、引用。
   (4)具备Object类中所定义的方法。
   差异：
   (1)接口中的属性都是公开静态常量（（隐式使用public static final修饰）
   (2)接口中的方法都是公开抽象方法（隐式使用public abstract修饰）
   (3)没有构造方法、没有动态代码块、没有静态代码块
3. 微观概念：接口是一种能力和约定。
   接口的定义：代表了某种能力。
   方法的定义：能力的具体要求。
   经验：
   (1)Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。
   (2)接口支持多实现，可为类扩充多种能力。
4. 使用规范：
   (1)任何类在实现接口时，必须实现接口中的所有的抽象方法，否则此类为抽象类。
   (2)实现接口中的抽象方法时，访问修饰符必须是public。
5. 接口引用：
   (1)同父类一样，接口也可声明为引用，并指向实现类对象。
   (2)注意：
   a)仅可调用接口中所声明的方法，不可调用实现类中独有的方法。
   b)可强转回实现类本身类型，进行独有方法调用。

Question_7-7

有如下代码：

1）class MyClass{
2）	final int value;
3）	public MyClass() {}
4）	public MyClass(int value) {
5）		this.value = value;
6）	}
7）}
8）public class TestMain {
9）	public static void main(String[] args) {
10）		MyClass mc = new MyClass(10);
11）		System.out.println(mc.value);
12）	}

13）}

选择正确答案：

A.编译通过，输出 10
B.编译不通过，把第 2 行改为 final int value = 10;
C.编译不通过，把第 3 行改为 public MyClass(){ value = 10; }
选择C

Question_7-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.编译通过
b.//1 出错
c.//2 出错
d.//3 出错
e.//4 出错
答案：a

Question_7-9

有如下代码：

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

下面说法正确的是：
A. 编译不通过 。
B. 编译通过。在//1 处加上：mv.value = 200; 则编译不通过
C. 编译通过。如果在//1 处加上：mv = new MyValue(); 则编译不通过。
答案：C

Question_7-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 i) {
		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);
	}
}

结果

Question_7-13

（修饰符综合）下列方法声明中正确的是：
a.abstract final void m()
b.public void final m()
c.static abstract void m()
d.private final void m()
e.private abstract void m()
f.public static final void m()
答案：d f
a中abstract 与final冲突
b中void 和final位置放反
c中static与abstract冲突
e中private与abstract冲突

Question_8-1

代码改错：

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

MyClass类中的“void m1(){}”改为“public void m1(){}”

Question_8-2

代码填空：

interface IA{
	void m1();
	void m2();
}
1____ class MyClassA implements IA{
	public void m1() {}
}
class MyClassB extends MyClassA{
	2__________ {}
}

1空填：abstract
2空填：public void m2()