Java——面向对象进阶（三）
拉普达的城 2024-07-05 10:05:03 阅读 58
前言：
抽象类，接口，内部类
文章目录
一、抽象类1.1 抽象方法1.2 抽象类1.3 抽象类的使用
二、 接口2.1 接口的定义和实现2.2 default 关键字2.3 实现接口时遇到的问题
三、内部类3.1 成员内部类3.2 静态内部类3.3 成员内部类3.4 匿名内部类（最常用）
一、抽象类
在Java中，抽象类是一种不能被实例化的类，它通常用于定义一些共用的方法和字段，在该类中不知道具体的实现，但还是想让子类必须去实现这些方法，所以将成员方法定义成抽象方法，该类定义成抽象类。<code>abstract 用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。
1.1 抽象方法
使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
定义格式：
修饰符 abstract 返回值类型 方法名 (参数列表);
示例:
public abstract void run();
1.2 抽象类
使用abstract 关键字修饰类，
形式:
abstract class 类名字 {
}
示例:
public abstract class Animal {
public abstract void run()；
}
！注意：抽象类不一定有抽象方法，但有抽象方法的类一定要定义成抽象类
1.3 抽象类的使用
继承抽象类：
如果一个类继承了一个抽象类，并且这个类不是抽象类，那么它必须实现所有从抽象类继承的抽象方法。如果一个类继承了一个抽象类，但没有实现所有的抽象方法，那么这个类必须声明为抽象类。
抽象类的继承链：
一个抽象类可以继承另一个抽象类，并且可以选择性地实现部分或全部继承的抽象方法。最终，必须有一个具体（非抽象）的子类实现所有抽象方法。
示例代码：
子类实现所有抽象方法
abstract class Animal {
abstract void makeSound();
abstract void eat();
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("Woof!");
}
@Override
void eat() {
System.out.println("Dog is eating.");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.makeSound();
myDog.eat();
}
}
Dog类继承了Animal类，并且实现了所有的抽象方法。
子类没有实现所有抽象方法，必须声明为抽象类
abstract class Animal {
abstract void makeSound();
abstract void eat();
}
abstract class Canine extends Animal {
@Override
void makeSound() {
System.out.println("Howl!");
}
// `eat` 方法没有实现，所以 Canine 仍然是抽象类
}
class Dog extends Canine {
@Override
void eat() {
System.out.println("Dog is eating.");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.makeSound();
myDog.eat();
}
}
Canine类实现了makeSound方法，但没有实现eat方法，因此Canine必须声明为抽象类。Dog类继承了Canine并实现了eat方法，使得Dog成为具体类，可以被实例化。
二、 接口
接口（Interface）在Java中是一个重要的概念，用于定义一组方法的规范，而不提供任何实现。接口主要用于定义类之间的契约和规范，确保实现这些接口的类遵循相同的方法签名。
2.1 接口的定义和实现
接口的定义：
接口使用interface关键字定义，接口中的所有方法默认是public和abstract，所有成员变量默认是public static final。以下是一个简单的接口示例：
public interface Animal {
void makeSound();
void eat();
}
实现接口
类通过implements关键字实现接口，一个类可以实现多个接口，这与抽象类的单继承限制不同。以下是实现Animal接口的两个类：
public class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
@Override
public void eat() {
System.out.println("Dog is eating.");
}
}
public class Cat implements Animal {
@Override
public void makeSound() {
System.out.println("Meow!");
}
@Override
public void eat() {
System.out.println("Cat is eating.");
}
}
类实现接口的要求：
必须重写实现的全部接口中所有抽象方法。如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。
如果一个类实现了多个接口，而这些接口有相同的抽象方法，那么这个类只需要实现这个抽象方法一次即可，因为Java不允许同一个类中出现重复的方法签名。这种情况下，类只需要提供一次方法的实现，而不需要重复实现多次。
2.2 default 关键字
default关键字主要用于接口中的默认方法（default methods），这是从Java 8开始引入的特性。默认方法允许在接口中为方法提供默认的实现，这样可以在不破坏现有实现的情况下，向接口添加新的方法。
默认方法（Default Methods）定义方式：
public interface InterfaceName {
// 抽象方法
void regularMethod();
// 默认方法
default void defaultMethod() {
// 默认实现
System.out.println("This is a default method.");
}
}
在上面的例子中，defaultMethod 就是一个默认方法。默认方法使用 default 关键字修饰，它提供了一个默认的实现。所有实现了这个接口的类都会继承这个默认方法，如果需要的话，可以在实现类中重写默认方法。
示例：
public interface Vehicle {
void start();
default void honk() {
System.out.println("Vehicle is honking.");
}
}
public class Car implements Vehicle {
@Override
public void start() {
System.out.println("Car is starting.");
}
// Car可以选择不重写honk方法，使用默认实现
}
public class Bike implements Vehicle {
@Override
public void start() {
System.out.println("Bike is starting.");
}
@Override
public void honk() {
System.out.println("Bike is honking."); // Bike提供了自己的honk方法实现
}
}
当需要扩展一个接口，但又不能破坏所有实现这个接口的类时，可以使用默认方法。
注意事项:
如果一个类实现了多个接口，而这些接口有相同的默认方法，实现类必须重写这个默认方法来解决冲突。
interface A {
default void hello() {
System.out.println("Hello from A");
}
}
interface B {
default void hello() {
System.out.println("Hello from B");
}
}
class C implements A, B {
@Override
public void hello() {
A.super.hello(); // 明确指定调用接口A的默认方法
//B.super.hello(); 或明确指定调用接口B的默认方法
}
}
2.3 实现接口时遇到的问题
如果一个类继承了一个类并实现了一个接口，且父类和接口中有都有相同签名的方法。
处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。
如果一个接口中，有多个抽象方法，但在实现类中，只需要用其中一个或部分
方法一：实现类声明为抽象类
你可以将实现类声明为抽象类，并只实现部分抽象方法，这样子类就可以根据需要选择性地实现接口的方法。
// 定义一个接口
interface MyInterface {
void method1(); // 抽象方法1
void method2(); // 抽象方法2
void method3(); // 抽象方法3
}
// 实现类声明为抽象类，并只实现部分方法
abstract class MyAbstractClass implements MyInterface {
@Override
public void method1() {
System.out.println("Implemented method1");
}
// 不需要实现 method2 和 method3
}
// 子类继承抽象类，选择性实现部分方法
class MyClass extends MyAbstractClass {
@Override
public void method2() {
System.out.println("Implemented method2");
}
}
方法二：使用适配器模式（Adapter Pattern）
如果不想使用抽象类，可以使用适配器模式，它允许提供接口的默认实现，然后子类可以选择性地覆盖它们。
// 定义一个接口
interface MyInterface {
void method1(); // 抽象方法1
void method2(); // 抽象方法2
void method3(); // 抽象方法3
}
// 创建适配器类，提供接口的默认实现
abstract class MyInterfaceAdapter implements MyInterface {
@Override
public void method1() {
// 默认实现
}
@Override
public void method2() {
// 默认实现
}
@Override
public void method3() {
// 默认实现
}
}
// 子类选择性地覆盖需要的方法
class MyClass extends MyInterfaceAdapter {
@Override
public void method2() {
System.out.println("Implemented method2");
}
}
三、内部类
内部类（Inner Class）是定义在另一个类内部的类。Java 提供了多种内部类，包括成员内部类、局部内部类、匿名内部类和静态内部类。
按定义的位置来分：
成员内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)局部内部类，类定义在方法内匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。
3.1 成员内部类
定义格式:
class OuterClass {
class InnerClass {
// Inner class members
}
}
内部类的使用格式：
外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类
创建内部类实例：
方式一：外部直接创建成员内部类的对象
OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
//或
OuterClass.InnerClass inner = new OuterClass().new InnerClass();
方法二：在外部类中定义一个方法提供内部类的对象
public class Outer {
private class Inner{
}
public Inner getInstance(){
return new Inner();
}
}
public class Test {
public static void main(String[] args) {
Outer outer = new Outer();
Inner inner = outer.getInstance();
}
}
成员内部类的细节
成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等
成员内部类可以访问外部类的所有成员，包括私有成员。这是因为成员内部类持有一个对外部类实例的引用Outer.this。
public class Outer {
private String outerField = "Outer field";
class Inner {
void display() {
System.out.println("Inner class accessing: " + outerField);
System.out.println("Inner class accessing through Outer.this: " + Outer.this.outerField);
}
}
public static void main(String[] args) {
Outer outer = new Outer(); // 创建外部类对象
Outer.Inner inner = outer.new Inner(); // 创建内部类对象
inner.display(); // 调用内部类的方法
}
}
//输出:
Inner class accessing: Outer field
Inner class accessing through Outer.this: Outer field
内存图示例:
在 JDK 8 之前，局部变量必须显式声明为 final 才能被成员内部类。在 JDK 8 及之后，只要局部变量在初始化后没有被修改，它们就被隐式地视为 final（即有效 final），不再需要显式声明为 final。
3.2 静态内部类
定义格式：
<code>class OuterClass {
static class StaticInnerClass {
// 静态内部类的成员
}
}
创建实例：
OuterClass.StaticInnerClass innerObject = new OuterClass.StaticInnerClass();
静态内部类的特点
静态内部类可以直接访问外部类的静态成员，但不能访问外部类的非静态成员，如果要访问需要创建外部类的对象，用对象调用。
public class Outer {
private static String staticOuterField = "Static Outer Field";
private String nonStaticOuterField = "Non-Static Outer Field";
static class StaticInner {
void display() {
// 静态内部类可以访问外部类的静态成员
System.out.println("Static Inner Class accessing static outer field: " + staticOuterField);
// 但不能直接访问外部类的非静态成员
// System.out.println("Static Inner Class accessing non-static outer field: " + nonStaticOuterField); // 编译错误
}
}
public static void main(String[] args) {
// 创建静态内部类的实例
StaticInner inner = new StaticInner();
inner.display(); // Output: Static Inner Class accessing static outer field: Static Outer Field
// 如果要访问外部类的非静态成员，需要创建外部类的对象
Outer outer = new Outer();
System.out.println("Access non-static outer field through outer object: " + outer.nonStaticOuterField);
}
}
无需外部类实例： 可以直接创建静态内部类的实例，而不需要外部类的实例。
:静态内部类中没有隐含的 Outer.this。
3.3 成员内部类
局部内部类是定义在方法或作用域内部的内部类。
特点
作用域限制： 局部内部类的作用域仅限于定义它的方法或代码块中，不能在外部访问。访问权限： 局部内部类可以访问外部类的所有成员，包括私有成员。访问局部变量： 局部内部类可以访问方法内的 final 局部变量（JDK 8+版本可以访问非 final 的局部变量，但其值不能在局部类中被修改）。生命周期： 局部内部类的生命周期仅限于方法调用，方法结束后局部内部类实例也会被销毁。
示例
public class Outer {
private int outerField = 10;
public void methodWithLocalInnerClass() {
final int localVar = 20; // JDK 8+ 可以不用final修饰，但不可变
class LocalInner {
void display() {
System.out.println("Outer field: " + outerField);
System.out.println("Local variable: " + localVar);
}
}
// 创建局部内部类的实例并调用方法
LocalInner inner = new LocalInner();
inner.display();
}
public static void main(String[] args) {
Outer outer = new Outer();
outer.methodWithLocalInnerClass();
}
}
3.4 匿名内部类（最常用）
匿名内部类是一种没有显式声明类名的内部类，它在创建对象的同时定义类的实现。匿名内部类通常用于创建只需使用一次且没有额外的逻辑的类实例。
格式：
new 类名或者接口名() {
重写方法;
};
这里同时包含了继承或实现，方法重写，创建对象
从new关键字到";"整个整体是匿名内部类的实例，"{}"内的是匿名内部类，没有类名
使用：
以接口为例，匿名内部类的使用，代码如下：
interface Swim {
public abstract void swimming();
}
public class Test {
public static void main(String[] args) {
// 接口 变量 = new 实现类(); // 多态,走子类的重写方法
Swim s2 = new Swim() {
@Override
public void swimming() {
System.out.println("蛙泳...");
}
};
s2.swimming();
}
}
如果你喜欢这篇文章，点赞👍+评论+关注⭐️哦！
欢迎大家提出疑问，以及不同的见解。
声明
本文内容仅代表作者观点，或转载于其他网站，本站不以此文作为商业用途
如有涉及侵权，请联系本站进行删除
转载本站原创文章，请注明来源及作者。