1. 技术文章
  2. 千锋逆战班 java学习day17

千锋逆战班 java学习day17

由 房东的猫 提交于 2020-02-25 19:52:46

在千锋“逆战”学习第17天
努力的最大好处在于：你可以选择自己想过的生活
三、final
1、final可修饰的内容：
类（最终类）
方法（最终方法）
变量（最终变量）
2、final修饰类：此类不能被继承
String、Math、System均为final修饰的类，不能被继承
3、final修饰方法：此方法不能被覆盖
意为最终方法，不支持子类以覆盖的形式修改
4、final修饰变量：此变量值不能被改变（常量）
【注】所有final修饰的变量只能赋值一次，值不允许改变

package com.qf.day17.t1.finalkeyword;
public class TestFinalKeyword {
	public static void main(String[] args) {
		final int A=10;//最终变量-->常量
		A=20;//无法为final修饰的最终变量进行二次赋值
	}
}
/*final*/ class Super{//最终类
	public /*final*/ void method(){//最终方法
		
	}
}
class Sub extends Super{//不能继承Super类
	public void method(){//不能覆盖method方法
		
	}
}

5、实例常量
实例常量不再提供默认值，必须手动赋予初始值
赋值时机：显示初始化、动态代码块、构造方法
注意：如果在构造方法中为实例常量赋值，必须保证所有的构造方法都能对其正确赋值

package com.qf.day17.t1.finalkeyword;

public class TestFinalVariable {

	public static void main(String[] args) {
		MyClass mc=new MyClass();//deadline在对象构建完毕之前，为实例常量赋值
		System.out.println(mc.num);

	}
}
class MyClass{
	final int num/*=10*/;//常量必须显示初始化
	{
		//num=20;
	}
	public MyClass(){
		num=30;
	}
	public MyClass(int n){
		num=n;
	}
}

6、静态常量
静态常量不再提供默认值，必须手动赋予初始值
赋值时机：显示初始化、静态代码块

static final double numbers=3.5;//显示初始化
	static{
		//numbers=3.5;
	}

7、对象常量：
final修饰基本类型：值不变
final修饰引用类型：地址不可变

package com.qf.day17.t1.finalkeyword;

public class TestFinalObject {

	public static void main(String[] args) {
		final int a=10;
		final int[] nums=new int[]{11,22,33};
		nums[0]=88;
		//nums=new int[]{1,2,3,4};//Error  nums中的地址不可变
		
		final Student s1=new Student();
		//s1.name ="jack";//Error
		//s1=new Student();//Error
	}
}
class Student{
	final String name="tom";
}

课堂案例：final修饰方法形参

package com.qf.day17.t1.finalkeyword;
/*
 * 课堂案例：final修饰方法形参
 */
public class TestFinalArguments {

	public static void main(String[] args) {
		int a=10;
		m1(a);
		System.out.println(a);//打印的还是main中的局部变量a
		final int[] nums={11,22,33};
		m2(nums);
		m3(nums);
		
		Teacher t1=new Teacher();
		t1.name="tom";
		m4(t1);
		
		final Teacher[] ts={new Teacher(),new Teacher(),new Teacher()};
		//teachers=m5(teachers);//Error
	}
	public static void m1(final int a){
		//a=20;//Error
	}
	public static void m2(int[] nums){
		nums=java.util.Arrays.copyOf(nums, nums.length*2);//Correct
		
	}
	public static void m3(final int[] nums){
		nums[0]=88;//Correct
	}
	public static void m4(final Teacher t1){
		t1.name="jack";//Correct
		//t1.age=31;//Error
		//t1=new Teacher();//Error
	}
	public static Teacher[] m5(Teacher...teachers){
		for(int i=0;i<teachers.length;i++){
			teachers[i].name=teachers[i].name+i;//Correct拼接字符串
			//teachers[i].age+=i;//Error
		}
		return teachers;
	}
	
}
class Teacher{
	String name;
	final int age=30;
}




第十章 接口

1、接口的语法：
接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似
使用interface关键字定义接口
没有构造方法，不能创建对象
只能定义：公开静态常量、公开抽象方法

package com.qf.day17.t2.interfaces;

public class TestBasicInterface {

public static void main(String[] args) {
	System.out.println(MyInterface.A);
	System.out.println(MyInterface.B);
	//MyInterface.A="AAA";
	//MyInterface.C="CCC";
	System.out.println(MyInterface.D);
}

}
interface MyInterface{
//公开静态常量（只能）
public static final String A=“aaa”;
public final String B=“bbb”;
public static String C=“ccc”;
String D=“ddd”;//public static final 隐式修饰

//公开抽象方法
public abstract void m1();
public void m2();//abstract 隐式存在
abstract void m3();//public 隐式存在
void m4();//public abstract 隐式存在

}

2、与抽象类的异同
相同：
可编译成字节码文件
不能创建对象
可以作为引用类型
具备Object类中定义的方法
不同：
所有属性都是公开静态常量，隐式使用public static final修饰
所有方法都是公开抽象方法，隐式使用public abstract修饰
没有构造方法、动态代码块、静态代码块   
3、什么是接口
微观概念：接口是一种能力和约定
接口的定义：代表了某种能力
方法的定义：能力的具体要求
经验：java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类的能力
接口支持多实现，可为类扩充多种能力
4、接口的规范
任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类
实现接口中的抽象方法时，访问修饰符必须是public

//定义了一种能力：会游的
interface Swimmable{
public abstract void swim();
}
//定义了一种能力：会跑的
interface Runnable{
public abstract void run();
}

//定义了一种能力：会爬的
interface Climbable{
void climb();
}
//定义了一种能力：会飞的
interface Flyable{
void fly();
}

class Animal{
String breed;
int age;
String sex;

public void eat(){}
public void sleep(){}

}
class Dog extends Animal implements Swimmable{//实现–>落地
String furcolor;
public void run(){
System.out.println(“狗在奔跑……”);
}
public void swim(){

}

}
class Cat extends Animal implements Runnable,Climbable{
String furcolor;
public void run(){//必须用public
System.out.println(“猫在奔跑……”);
}
public void climb(){
System.out.println(“猫在爬树……”);
}
}
class Fish extends Animal{
//public void swim(){}
}
class Bird extends Animal{
//public void fly(){}
}
class Bus implements Runnable{
public void run() {

}

}
class Boat implements Swimmable{
public void swim(){

}

}

5、接口的引用：
同父类一样，接口也可声明为引用，并指向实现类对象
注意：
仅可调用接口中所声明的方法，不可调用实现类中独有的方法
可强转回实现类本身类型，进行独有方法调用

习题七（final）
7、（final属性的初始化）有以下代码：
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.编译不通过，把第三行改为public MyClass(){value=10;}

8、（final变量）有以下代码：
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
A.编译通过
B.//1 出错
C.//2 出错
D.//3 出错
E.//4 出错

9、（final修饰引用）有以下代码：
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
A.编译不通过
B.编译通过。在//1处加上：mv.value=200;则编译不通过
C.编译通过，在//1处加上：mv=new MyValue();则编译不通过

10、（final方法、方法覆盖）有以下代码：
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);
}
}
以上程序能否编译通过？如果可以，输出运行结果；如果不可以，应该怎样修改？
m1() in Super
m1(int) in Sub
m1(double) in Sub

13、（修饰符综合）下列方法声明中正确的是： DF
A.abstract final void m() //abstract 与 final不能一起。
B.public void final m() //public final void m()
C.static abstract void m() //static 与 abstract 不能一起。
D.private final void m()
E.private abstract void m() //abstract不能private。
F.public static final void m()

Chapter 08 接口
Key Point：
●接口的基本语法
●接口的作用
●解耦合
习题：
1、代码改错
package t1;
interface IA{
void m1();
int a=100;
}
class MyClass implements IA{
void m1(){} //public void m1(){}
}
public class TestInterface {
public static void main(String[] args) {
IA ia=new MyClass();
ia.m1();
System.out.println(IA.a);
}
}
2、代码填空：
interface IA{
void m1();
void m2();
}
abstract class MyClassA implements IA{
public void m1(){}
}
class MyClassB extends MyClassA{
public void m2() {}
}

中国加油！武汉加油！千锋加油！我自己加油！

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