人生苦短我学Java10final关键字/代码块/抽象类 广深

 一、final关键字

修饰符，可修饰变量、类、方法

• 1.被final修饰的变量为常量，变量必须赋值，否则编译报错。可直接赋值或者构造赋值
• 2.被final修饰的类不能被继承
• 3.被final修饰的方法不能被重写

package com.ppl.day;
/*
com.ppl.day：学习项目
@user：广深-小龙
@date：2022/1/3 17:03
*/

public class Day15 {
    public static void main(String[] args) {
        FinalTest f = new FinalTest();
        System.out.println(f.age);
//        f.age=10;     // 为常量不可修改
    }
}

/*
final关键字：修饰符，可修饰变量、类、方法
1.被final修饰的变量为常量
2.被final修饰的类不能被继承
3.被final修饰的方法不能被重写
*/

final class FinalTest {
    // 1.被final修饰的变量为常量
    final int age = 20;
}

// 2.被final修饰的类不能被继承
//class Final extends FinalTest { }

class Final {
    public final void eat() {
        System.out.println("重写 eat()");
    }
}

class FinalCz extends Final {
      // 3.被final修饰的方法不能被重写
//    public  void eat() { }
}

 二、代码块

1、局部代码块

• 使变量执行到此将在内存中消失

// 局部代码块
{
    int a = 10;
    System.out.println(a);
}   // a变量执行到此将在内存中消失

2、构造代码块

• 构造代码块,实现构造方法共性

// 构造代码块,实现构造方法共性
class AClass {

    // 调用以下三个不同参数的构造方法都会执行这个：构造代码块
    {
        System.out.println("哭...");
    }

    public AClass() {
//        System.out.println("哭...");
    }

    public AClass(String name) {
//        System.out.println("哭...");
    }

    public AClass(String name, int age) {
//        System.out.println("哭...");
    }
}

2、静态代码块

• 当.class文件被加载时执行
• 只会执行一次，因为：.class加载字节码程序运行只运行一次
• 给数据初始化，启动时的一次性加载配置。

// 静态代码块，只会执行一次
static {
    System.out.println("静态代码块 static");
}

 三、抽象类

 1、什么是抽象类?

被abstract关键字所修饰的类就是个抽象类，有抽象方法的类就是抽象类

2、什么是抽象方法?
没有方法体的方法就是抽象方法

抽象类的特点?

1. abstract关键字修饰
2. 抽象类可以没有抽象方法，但是有抽象方法的类一定是抽象类
3. 抽象类不能创建对象，new 类
4. 继承抽象类，子类也需为抽象类，或者普通类重写抽象方法

四、接口

成员变量：默认修饰符 public static final 所以可以直接访问

成员方法：默认修饰符 abstract

构造方法：没有构造方法

接口与接口可以是继承关系。

public class Day16 {
    public static void main(String[] args) {
        // 访问接口变量
        Test1 t1 = new Test1();
        System.out.println(t1.i);
//        t1.i = 1;     // 不可以赋值
        System.out.println(Test.i);     // 默认修饰符 public static final 所以可以直接访问
        System.out.println(Test1.j);
    }
}

/*
接口：interface，有类实现该接口
特点：
1.不能创建对象
2.一个类想要实现接口，要么该类是一个抽象类，要么是普通类重写所有抽象方法
3.接口的变量都是自定义常量，接口没有构造方法

什么时候用？需求功能除了继承父类的功能，还需要额外的功能，就可以使用接口。继承+接口实现
*/
interface MyInterface {
    //    int i;   // 这样写编译报错
    int i = 100;

    public abstract void eat();
}

interface MyInterface1 extends MyInterface {
    //    int i;   // 这样写编译报错
    int j = 1000;

    public abstract void eat();
}

// Test类实现接口:抽象类
abstract class Test implements MyInterface {

}

// Test类实现接口:普通类,多实现接口
class Test1 implements MyInterface,MyInterface1 {
    public void eat() {
    }
}

欢迎来大家QQ交流群一起学习：482713805，博主微信+：gogsxl