Java知识总结（其二）

一、类的继承

1. 什么是继承？

继承是面向对象编程的核心概念之一，允许一个类（子类）基于另一个类（父类）构建，继承父类的属性和方法，实现代码的重用和扩展。

2. 如何实现继承？

使用关键字 extends 实现类的继承。例如：

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

Dog 类继承了 Animal 类，可以使用 eat 方法，并且还有自己的方法 bark。

注意事项：

• 类只支持单继承，也就是说一个类只能有一个直接父类，多个类可以继承一个父类
• 多层继承是可以的，即一个类的父类可以再去继承另外的父类
• 子类和父类是一种相对概念，也就是说一个类是某个类的父类的同时，也可以是另一个类的子类。

3. 继承的好处

• 提高代码的重用性
• 提高代码的可扩展性
• 通过多态实现运行时动态绑定

二、抽象类

1. 什么是抽象类？

抽象类是一种不能被实例化的类，通常用于定义一些通用的属性和方法，其中包含抽象方法，含有的方法只有方法名，没有方法体的类， 需要在子类中具体实现。

2. 如何定义抽象类？

使用关键字 abstract 定义抽象类。例如：

abstract class Shape {
    abstract void draw(); // 抽象方法，子类必须实现
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle");
    }
}

3. 抽象类的作用

• 提供类的模板，规范子类的实现
• 包含一些通用的方法和属性

4.抽象类特点总结

1. 抽象类由关键字abstract来修饰；
2. 抽象方法也有关键字abstract来修饰， 且没有方法体， 连大括号都没有；
3. 抽象类可以含有抽象方法， 也可以含有普通方法， 也可以任何方法都不含；
4. 抽象类不能直接创建对象（建自己的对象） ， 因为抽象类中含有了抽象方法后， 使用对象的引用去调用是没有任何意义的；
5. 抽象类是可以通过多态的形式， 建立子类对象的， 这种方式叫做： 向上造型；
6. 抽象类也是类， 类与类之间就可以形成继承关系， 当一个普通类继承了抽象类后， 就需要实现抽象类的全部抽象方法， 即重写； 否则， 当前的普通类业的是一个抽象， 只继承不线上是被允许的

5.abstract关键字的冲突

• final：被 abstract 修饰的方法， 强制要求子类重写， 被 final 修饰的方法子类不能重写
• private：被 abstract 修饰的方法， 强制要求子类重写， 被 private 修饰的方法子类不能重写
• static：被 static 修饰的方法可以类名调用， 类名调用抽象方法没有意义

6.类的高级特性

（1）static

static 是静态的意思， 可以修饰成员变量， 也可以修饰成员方法

修饰成员的特点：

• 被其修饰的成员, 被该类的所有对象所共享
• 多了一种调用方式, 可以通过类名调用
• 随着类的加载而加载, 优先于对象存在

（2）final

final 关键字意思是最终，不可变的，可以修饰（ 方法，类，变量）

final 修饰成员的特点：

• 修饰方法：表明该方法是最终方法，不能被重写
• 修饰类：表明该类是最终类，不能被继承
• 修饰变量：表明该变量是常量，不能再次被赋值

三、接口

1. 什么是接口？

接口定义了一组方法的签名，但没有提供具体实现。一个类可以实现一个或多个接口，从而获得接口定义的方法。Java中的接口更多体现的是对行为的抽象。

2. 如何定义接口？

使用关键字 interface 定义接口。例如：

interface Drawable {
    void draw(); // 接口方法
}

class Circle implements Drawable {
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

接口不能实例化，且接口没有构造方法 ,接口和类之间是实现关系，通过implements关键字表示

3.接口中的成员特点

• 成员变量:

  只能是常量,默认修饰符： public static final

• 成员方法:

  只能是抽象方法

• 默认修饰符：

  public abstract

4. 接口的优势

• 实现多继承
• 降低类之间的耦合性
• 提高代码的灵活性

四、代码块

1. 什么是代码块？

代码块是一组语句，使用 { } 括起来，分为静态代码块和实例代码块。静态代码块在类加载时执行，实例代码块在对象创建时执行。

2. 代码块的应用场景

class Example {
    static {
        System.out.println("Static block"); // 静态代码块
    }

    {
        System.out.println("Instance block"); // 实例代码块
    }

    Example() {
        System.out.println("Constructor"); // 构造方法
    }
}

3.代码块分类

• 构造代码块

位置： 类中方法外定义

特点： 每次构造方法执行的时， 都会执行该代码块中的代码，并且在构造方法执行前执行

作用： 将多个构造方法中相同的代码， 抽取到构造代码块中， 提高代码的复用性

• 静态代码块

位置： 类中方法外定义

特点： 需要通过static关键字修饰， 随着类的加载而加载， 并且只执行一次作用： 在类加载的时候做一些数据初始化的操作

• 局部代码块

位置： 方法中定义

作用： 限定变量的生命周期， 及早释放， 提高内存利用率

4. 代码块的作用

• 初始化静态变量
• 提供实例初始化逻辑

五、匿名对象

1. 什么是匿名对象？

匿名对象是在创建对象的同时进行方法调用，只有创建对象的语句， 没有被赋予明确的引用变量。适用于一次性的操作。

2. 匿名对象的使用

class Printer {
    void print(String message) {
        System.out.println(message);
    }
}

public class Main {
    public static void main(String[] args) {
        new Printer().print("Hello, World!"); // 匿名对象的使用
    }
}

3. 匿名对象的特点

• 一次性使用
• 不占用栈内存空间

六、内部类

1. 什么是内部类？

内部类是定义在其他类内部的类，可以访问外部类的私有成员。分为成员内部类、局部内部类、静态内部类 、匿名内部类等。

2. 成员内部类的定义和使用？

class Outer {
    private int outerVar = 10;

    class Inner {
        void display() {
            System.out.println("OuterVar: " + outerVar);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner(); // 创建内部类对象
        inner.display(); // 调用内部类方法
    }
}

以上详细就是我对类的继承、抽象类、接口、代码块、匿名对象、内部类等 Java 高级概念的总结。深入理解这些特性将有助于更好地设计和组织代码，提高开发效率和代码质量。如有错误请大佬帮忙指正谢谢。