（五）final、抽象类、接口、内部类

最新推荐文章于 2022-07-27 20:37:49 发布

来世做春风嘛

最新推荐文章于 2022-07-27 20:37:49 发布

阅读量559

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/yirenyuan/article/details/125883561

版权

本文详细介绍了Java中的final关键字，包括其用法、注意事项和细节，如final修饰类、方法和变量的规则。接着讲解了抽象类的概念，强调抽象类用于设计，不可实例化，其抽象方法不能有实现。最后，阐述了接口的作用，作为规范的制定，接口中的方法默认是public抽象的，并在JDK8后支持静态和默认方法。同时对比了继承和实现接口的区别，以及内部类的分类和使用场景。

摘要由CSDN通过智能技术生成

一、final 关键字（P394）

1. 基本介绍

final 中文意思：最后的，最终的

final 可以修饰类、属性、方法和局部变量

使用到 final 的情况：

（1）当不希望类被继承时，可以用final修饰。

（2）当不希望父类的某个方法被子类覆盖/重写（override）时，可以用final关键字修饰。

（3）当不希望类的的某个属性的值被修改，可以用final修饰。

（4）当不希望某个局部变量被修改，可以使用final修饰。

2. final 使用注意事项和细节

（1）final修饰的属性又叫常量，一般用XX_XX_XX来命名

（2）final修饰的属性在定义时，必须赋初值，并且以后不能再修改，赋值可以在如下位置之一：

① 定义时
② 在构造器中
③ 在代码块中

（3）如果 final 修饰的属性是静态的，则初始化的位置只能是

① 定义时

② 在静态代码块

③ 不能在构造器中

（4）final类不能继承，但是可以实例化对象。

（5）如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可
以被继承。

（6）一般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法。

（7）final不能修饰构造方法（即构造器）

（8）final和static往往搭配使用，效率更高，底层编译器做了优化处理。

（9）包装类（Integer、Double、Float、Boolean等都是final），String也是final类。

二、抽象类（P398）

当父类的一些方法不能确定时，可以用 abstract 关键字来修饰该方法，这个方法就是抽象方法，用 abstract 来修饰该类就是抽象类。

1. 抽象类的介绍

（1）用abstract关键字来修饰一个类时，这个类就叫抽象类

（2）用abstract关键字来修饰一个方法时，这个方法就是抽象方法

（3）抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类

2. 抽象类使用的注意事项和细节讨论

（1）抽象类不能被实例化

（2）抽象类可以没有抽象方法。

（3）有抽象方法的类一定是抽象类。

（4）abstract 只能修饰类和方法，不能修饰属性和其它的。

（5）抽象类可以有任意成员【因为抽象类本质还是类】，比如：非抽象方法、构造器、静态属性等等

（6）抽象方法不能有主体，即不能实现。

（7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为
抽象类。

（8）抽象方法不能使用 private、final 和 static 来修饰，因为这些关键字都是和重写相违背的。

三、接口（P403）

1. 基本介绍

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

语法：

interface接口名｛

//属性

//方法

｝

class 类名 implements 接口｛

                自己属性；
                自己方法：
                必须实现的接口的抽象方法

｝

小结：

（1）在 Jdk7.0 前接口里的所有方法都没有方法体
（2）在 Jdk8.0 后接口类可以有静态方法（static），默认方法（default），也就是说接口中可以有方法的具体实现。

2. 注意事项和细节

（1）接口不能被实例化

（2）接口中所有的方法是public方法接口中抽象方法，可以不用abstract修饰

（3）一个普通类实现接口，就必须将该接口的所有方法都实现

（4）抽象类实现接口，可以不用实现接口的方法

（5）一个类同时可以实现多个接口

（6）接口中的属性，只能是public static final 修饰符。

比如：inta=1；实际上是public static final int a = 1；（必须初始化）

（7）接口中属性的访问形式：接口名 . 属性名

（8）一个接口不能继承其它的类，但是可以继承多个别的接口

（9）接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

3. 实现接口vs继承类

接口和继承解决的问题不同

（1）继承的价值主要在于：解决代码的复用性和可维护性
（2）接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法。

接口比继承更加灵活：
继承是满足 is-a 的关系，而接口只需满足 like-a 的关系

四、内部类（P413）

1. 基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。

2. 内部类的分类

定义在外部类局部位置上（比如方法内）：

（1）局部内部类（有类名）

（2）匿名内部类（没有类名，重点）

定义在外部类的成员位置上：

（1）成员内部类（没用static修饰）

（2）静态内部类（使用static修饰）

3. 局部内部类的使用

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名

（1）可以直接访问外部类的所有成员，包含私有的
（2）不能添加访问修饰符，但是可以使用final修饰
（3）作用域：仅仅在定义它的方法或代码块中

（4）外部类---访问---->局部内部类的成员
访问方式：创建对象，再访问（注意：必须在作用域内）

（5）外部其他类---不能访问----->局部内部类

（6）如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成
员，则可以使用（外部类名.this.成员）去访问。

4. 匿名内部类

（1）本质是类（2）内部类（3）该类没有名字（4）同时还是一个对象

说明：匿名内部类是定义在外部类的局部位置，并且没有类名。

4.1 匿名内部类使用细节：

（1）基本语法

new 类或接口（参数列表）｛

类体

｝；

（2）匿名内部类的语法比较奇特。因为匿名内部类既是一个类的定义，同时它本身也是一个对象。因此从语法上看，它既有定义类的特征，也有创建对象的特征

（3）可以直接访问外部类的所有成员，包含私有的。

（4）不能添加访问修饰符，因为它的地位就是一个局部变量。

（5）作用域：仅仅在定义它的方法或代码块中。

（6）匿名内部类---访问---->外部类成员 [访问方式：直接访问]

（7）外部其他类---不能访问----->匿名内部类

（8）如果外部类和匿名内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成
员，则可以使用（外部类名.this.成员）去访问。

5. 成员内部类

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰。

（1）可以直接访问外部类的所有成员，包含私有的。

（2）可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。

（3）作用域：和外部类的其他成员一样，为整个类体。在外部类的成员方法中创建成只内部类对象，再调用方法。

（4）成员内部类---访问---->外部类成员【访问方式：直接访问】

（5）外部类---访问------>成员内部类【访问方式：创建对象，再访问】

（6）外部其他类---访问---->成员内部类

// 外部其他类
public class Demo {

    public static void main(String[] args) {

        Waibu waibu = new Waibu();
        // 方式一
        Waibu.Neibu neibu1 = waibu.new Neibu();
        // 方式二
        Waibu.Neibu neibu2 = waibu.getNeibu();
    }
}


// 外部类
class Waibu{

    // 内部类
    class Neibu{}

    public Neibu getNeibu(){
        return new Neibu();
    }
}

6. 静态内部类

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

（1）可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
（2）可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是
一个成员。
（3）作用域：同其他的成员，为整个类体

（4）静态内部类---访问---->外部类【访问方式：直接访问所有静态成员】
（5）外部类---访问------>静态内部类【访问方式：创建对象，再访问】

（6）外部其他类---访问---->静态内部类

// 外部其他类
public class Demo {

    public static void main(String[] args) {

        // 方式一
        Waibu.Neibu neibu = new Waibu.Neibu();
        // 方式二
        Waibu.Neibu neibu2 = Waibu.getNeibu();


    }
}

// 外部类
class Waibu{

    // 静态内部类
    public static class Neibu{}

    public static Neibu getNeibu(){
        return new Neibu();
    }
}