0393_final
目录
final关键字
final可以修饰类、属性、方法和局部变量
什么情况下会用到final：
1）、当不希望类被继承时，可以使用final修饰
//1）、当不希望类被继承时，可以使用final修饰
final class AAA {
}
//Cannot inherit from final 'Single.AAA'
class BBB extends AAA{
}
2)、当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰
//当不希望父类的某个方法被子类覆盖/重写(override)时，可以用final关键字修饰
class AAA {
public final void say(){
System.out.println("hai");
}
}
//'say()' cannot override 'say()' in 'Single.AAA'; overridden method is final
class BBB extends AAA{
@Override
public void say() {
super.say();
}
}
3)、当不希望类的某个属性的值被修改，可以用final来修饰。
//3)、当不希望类的某个属性的值被修改，可以用final来修饰。
class AAA {
public final int A = 10;
}
//Cannot assign a value to final variable 'A'
class BBB extends AAA{
public void test() {
super.A = 100;
}
}
4)、当不希望某个局部变量被修改时候，可以使用final修饰
class BBB extends AAA{
public void test() {
//super.A = 100;
final int num = 50;
num = 100;
//Cannot assign a value to final variable 'num'
}
}
0394-final使用的注意事项和细节的讨论
1、final修饰的属性又叫做常量，一般用XX_XX_XX来命名；
2、final修饰的属性在定义的时候，必须要赋初值，并且以后不能修改，可以在如下的位置赋值：定义的时候：如public final double TAX_RATE = 0.08;
构造器中；
在代码块中
package finalDetail;
public class FinalDetail {
}
class testfinal{
//1、定义的时候
private final double TAX_TEST = 50.0;
public final double TAX_TEST1;
public final double TAX_TEST2;
public testfinal(){
//构造器中；
TAX_TEST1 = 0.08;
}
{
//代码块中
TAX_TEST2 = 0.05;
}
}
3、如果final修饰的属性是静态的，则初始化的位置只能是:1、定义的时候；
在静态代码块，不能在构造器中赋值。原因:类加载的时候就要给值，构造器是在创建对象的时候。
package finalDetail;
public class FinalDetail {
}
class testfinal{
//1、定义的时候
public static final double TAX_TEST3 = 50;
public static final double TAX_TEST4;
static {
//2、静态代码块中
TAX_TEST4 = 0.05;
}
}
4、final类不能继承，但是可以实例化对象。
package finalDetail;
public class FinalDetail {
public static void main(String[] args) {
//可以实例化对象。
AA aa = new AA();
}
}
class testfinal{
//1、定义的时候
public static final double TAX_TEST3 = 50;
public static final double TAX_TEST4;
static {
//2、静态代码块中
TAX_TEST4 = 0.05;
}
}
final class AA{
}
//Cannot inherit from final 'finalDetail.AA'
//class BB extends AA{
//}
5、如果类不是final 类，但是含有final方法，则改方法虽然不能重写，但是可以继承
0395 final的细节2
0395
5、一般来说，如果一个类已经是final类了，就没有必要将方法修饰成final方法了（原因是：final方法是无法改写的，既然都继承不了还怎么改写）
6、final 不能修饰构造方法
7、final和static往往搭配使用，效率更高，底层编译器做了优化的处理。
8、包装类(Integer,Double,Float,Boolean等都是final)，String 也是final类
0397 抽象类
当父类的某些方法，需要声明，但是又不确定如何实现的时候，可以将其声明为抽象方法，那么这个类就是抽象类(用abstract来修饰该方法)。
0398 抽象类的介绍
1、用abstract关键字来修饰一个类时，这个类就叫抽象类
访问修饰符 abstract 类名{
}
2、用abstract关键字来修饰一个方法时，这个方法就是抽象放大
访问修饰符 abstract 返回类型 方法名
3、抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()
4、抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多
抽象类的细节
1、抽象类不能被实例化
2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract
3、一旦包含了abstract方法，则这个类必须声明为abstract
4、abstract 只能修饰类和方法，不能修饰属性和其他的
package AbstractDetails;
public class Abstractdetail {
public static void main(String[] args) {
//AA aa = new AA();
}
}
//'AA' is abstract; cannot be instantiated
//1、抽象类不能被实例化
abstract class AA{
}
//2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract
//还可以有实现的方法
abstract class BB{
public void sayhi(){
System.out.println("hi");
}
}
//3、一旦包含了abstract方法，则这个类必须声明为abstract
//Abstract method in non-abstract class
class CC{
abstract void play();
}
//4、abstract 只能修饰类和方法，不能修饰属性和其他的
//Modifier 'abstract' not allowed here
class DD{
public abstract int a = 5;
}
0399 抽象类的细节2
5、抽象类可以有任意的成员(抽象类的本质还是类)，比如：非抽象方法、构造器、静态属性等等
6、抽象方法不能有主题，就是不能实现
7、如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类；
abstract class EE{
public abstract void abs();
}
//Class 'GG' must either be declared abstract
// or implement abstract method 'abs()' in 'EE
class GG extends EE{
}
abstract class EE{
public abstract void abs();
}
//Class 'GG' must either be declared abstract
// or implement abstract method 'abs()' in 'EE
class GG extends EE{
@Override
public void abs() {
//这里就相当于实现了父类E的抽象方法，所谓的实现方法，就是有方法体
}
}
8、抽象方法不能用private final 和 static 来修饰，因为这些关键字都和重写违背 private final修饰的话，子类无法重写 static是无关的
0401 抽象模板模式
需求
有多个类，完成不同的任务job
要求能够得到各自完成任务的时间
使用的是下面的函数方法
For循环的快捷键(num.for)
因为统计时间的方法一直是那两个句子，代码复用性不好
我们知道这个流程就可以了
上面这个是模板类
执行的时候会发生动态绑定，因为运行类型是aa，所以去哪个AA类找
0402 接口
usb插槽就是现实中的接口。你可以把手机，相机，u盘都插在usb插槽上，而不用担心那个插槽是专门插哪个的，原因是做usb插槽的厂家和做各种设备的厂家都遵守了统一的规定包括尺寸，排线等等。
先新建一个Interface01测试类
然后新建UsbInterface接口类
package Interface;
public interface UsbInterface { //接口
//规定接口的相关的方法，老师规定的
public void start();
public void stop();
}
再新建Camera和Phone类
package Interface;
public class Camera implements UsbInterface{
@Override
public void start() {
System.out.println("相机开始工作了");
}
@Override
public void stop() {
System.out.println("相机停止工作了");
}
}
package Interface;
public class Phone implements UsbInterface {
@Override
public void start() {
System.out.println("手机开始工作了");
}
@Override
public void stop() {
System.out.println("手机停止工作了");
}
}
然后新建电脑类接入Computer
package Interface;
public class Computer {
public void work(UsbInterface usbInterface){
//通过接口来调用，来调用方法
usbInterface.start();
usbInterface.stop();
}
}
最后再进行测试Interface01
package Interface;
public class Interface01 {
public static void main(String[] args) {
//创建手机，相机的对象
Camera camera = new Camera();
Phone phone = new Phone();
//把相机接入电脑
Computer computer = new Computer();
computer.work(camera);
}
}
显示的结果为
0403 接口的快速入门
基本介绍：
接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。语法:
interface 接口名{
//接口
//方法
}
class 类名 implements 接口{
自己的属性；
自己的方法；
必须实现的接口的抽象方法
}
package Interface;
public interface AInterface01 {
//在接口中可以省略abstract关键字
public void hi();
//在jdk8之后，可以有默认实现方法，需要用default关键词来修饰
default public void default01(){
System.out.println("ok");
}
public static void cry(){
System.out.println("cry");
}
}
小结：
1、在JDK7.0前 接口里的所有方法都没有方法体，即都是抽象方法。
2、Jdk8.0后接口可以有静态方法、默认方法，也就是说接口中有可以有方法的具体实现。
0404 接口的实用性
接口的作用就如下图，这样写的connect和close函数都能够统一了名字
0405 接口的使用细节
1、接口不能被实例化
2、接口中所有的方法是public方法，接口中抽象方法，可以不用abstract修饰，
3、一个普通类实现接口，就必须将该接口的所有方法都实现。
4、抽象类实现接口，可以不用实现接口的方法
5、一个类同时可以实现多个接口
6、接口中的属性，只能是final的，而且是public static final 修饰符。比如：
int a = 1；实际上是public static final int a= 1; (必须初始化)
7、接口中属性的访问形式：接口名.属性名
8、一个接口不能继承其他的类，但是可以继承多个别的接口
9、接口的修饰符只能是public 和默认，这点和类的修饰符是一样的。
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
