面向对象进阶：多态、内部类、常用API

目录

Java中的接口

Java中的内部类

常用API

StringBuilder类

Java高级面向对象编程

在这篇博客文章中，我们将探索Java中的高级面向对象编程概念，包括接口、内部类和常用API。每个概念都将通过代码示例来演示它们的应用。

Java中的接口

什么是接口？

接口是Java中的一种引用类型，类似于类，它可以包含常量、方法签名、默认方法、静态方法和嵌套类型。接口不能包含实例字段，接口中的方法默认是抽象的。

接口的特点

• **声明**：接口使用`interface`关键字声明。
• **实现**：类使用`implements`关键字实现接口。
• **多继承**：一个类可以实现多个接口。

示例

```java
public interface Animal {
    void eat();
    void sleep();
}

public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog eats bone");
    }

    @Override
    public void sleep() {
        System.out.println("Dog sleeps");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}
```

在这个示例中，我们定义了一个名为`Animal`的接口，和一个实现该接口的`Dog`类。`Dog`类实现了`Animal`接口的所有方法。

JDK 8及以后接口的新特性

• **默认方法**：使用`default`关键字，允许在接口中定义方法体。
• **静态方法**：使用`static`关键字，可以直接在接口中调用，而不需要实现类。
• **私有方法**：从JDK 9开始，接口可以包含`private`方法，供其他默认方法或私有方法调用。

示例

```java
public interface Vehicle {
    default void start() {
        System.out.println("Vehicle is starting");
    }

    static void check() {
        System.out.println("Vehicle check");
    }

    private void clean() {
        System.out.println("Vehicle clean");
    }
}

public class Car implements Vehicle {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();  // 调用默认方法
        Vehicle.check();  // 调用静态方法
    }
}
```

Java中的内部类

内部类的概述

内部类是在一个类里面定义的类。根据定义的位置不同，内部类可以分为以下几种类型：

1. **静态内部类**：使用`static`关键字修饰，属于外部类本身。
2. **成员内部类**：不使用`static`修饰，属于外部类的对象。
3. **局部内部类**：定义在方法、代码块或构造器中。
4. **匿名内部类**：没有名字的内部类，通常用于简化代码。

示例：静态内部类

```java
public class Outer {
    public static class StaticInner {
        public void display() {
            System.out.println("Static Inner Class");
        }
    }

    public static void main(String[] args) {
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.display();
    }
}
```

示例：成员内部类

```java
public class Outer {
    public class MemberInner {
        public void show() {
            System.out.println("Member Inner Class");
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.MemberInner inner = outer.new MemberInner();
        inner.show();
    }
}
```

示例：匿名内部类

```java
public interface Greeting {
    void sayHello();
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Hello, Anonymous Inner Class!");
            }
        };
        greeting.sayHello();
    }
}
```

常用API

Object类

`Object`类是Java所有类的父类，提供了一些常用方法，如`toString()`和`equals()`。

示例

```java
public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "'}";
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return name.equals(person.name);
    }

    public static void main(String[] args) {
        Person p1 = new Person("Alice");
        Person p2 = new Person("Alice");
        System.out.println(p1);  // 输出：Person{name='Alice'}
        System.out.println(p1.equals(p2));  // 输出：true
    }
}
```

StringBuilder类

`StringBuilder`是一个可变的字符串类，提供了高效的字符串操作能力。

示例

```java
public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Hello");
        sb.append(" ");
        sb.append("World");
        System.out.println(sb.toString());  // 输出：Hello World
    }
}
```

通过这些示例，我们可以看到Java中的高级面向对象编程概念如何应用于实际开发中，提高代码的灵活性和可维护性。

希望这篇文章对您理解Java的高级面向对象概念有所帮助！如果有任何问题，欢迎讨论。

原文链接: https://blog.csdn.net/2302_80084329/article/details/140882135