14天Java基础学习——第8天：面向对象编程（高级特性）-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_38492276/article/details/143819639

面向对象编程（高级特性）——Java学习第8天内容

在本节课中，我们将深入探讨Java中的一些面向对象编程高级特性。这些特性包括内部类、匿名类与局部类，枚举类型与注解，字符串处理与StringBuilder，以及抽象类与接口的更高级应用。通过学习这些概念，您将能够编写更灵活、更易于维护的Java代码。

一、内部类、匿名类与局部类

1.1 内部类

内部类是定义在另一个类内部的类。内部类可以访问其外部类的成员，包括私有成员。使用内部类可以提高代码的可读性，并且逻辑上可以将相关类组合在一起。

例子代码：内部类

public class OuterClass {
    private String outerField = "外部类字段";

    class InnerClass {
        void display() {
            System.out.println("访问外部类字段: " + outerField);
        }
    }
    
    void createInnerClass() {
        InnerClass inner = new InnerClass();
        inner.display();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.createInnerClass();
    }
}

1.2 匿名类

匿名类是没有名字的类，用于快速创建类的实例。它通常用于实现接口或继承类的情况。匿名类的实例可以直接在创建时定义方法。

例子代码：匿名类

public class AnonymousClassExample {
    interface Greeting {
        void greet();
    }

    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            @Override
            public void greet() {
                System.out.println("你好，匿名类!");
            }
        };
        greeting.greet();
    }
}

1.3 局部类

局部类是在方法内部定义的类。局部类只能在定义它的方法内部访问，并且可以访问该方法的变量（需为final或有效final）。

例子代码：局部类

public class LocalClassExample {
    void methodWithLocalClass() {
        class LocalClass {
            void display() {
                System.out.println("这是一个局部类");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }

    public static void main(String[] args) {
        LocalClassExample example = new LocalClassExample();
        example.methodWithLocalClass();
    }
}

总结

内部类、匿名类与局部类各自有其独特的使用场景。内部类适合于需要紧密绑定到外部类的场景；匿名类方便于快速创建简单的类实例；局部类适合于仅在某个方法内部使用的情况。这三种类的使用增加了代码的灵活性和可读性。

二、枚举类型与注解

2.1 枚举类型

枚举类型（enum）是一种特殊的Java类，它表示一组常量。枚举提供了一种类型安全机制，避免了魔法数字或字符串的使用，提高了代码的可读性和可维护性。

例子代码：枚举类型

enum Day {
    SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}

public class EnumExample {
    Day day;

    public EnumExample(Day day) {
        this.day = day;
    }

    void tellItLikeItIs() {
        switch (day) {
            case MONDAY:
                System.out.println("今天是星期一");
                break;
            case FRIDAY:
                System.out.println("今天是星期五");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("今天是周末");
                break;
            default:
                System.out.println("工作日");
                break;
        }
    }

    public static void main(String[] args) {
        EnumExample firstDay = new EnumExample(Day.MONDAY);
        firstDay.tellItLikeItIs();
        
        EnumExample secondDay = new EnumExample(Day.SATURDAY);
        secondDay.tellItLikeItIs();
    }
}

2.2 注解

注解是一种元数据，可以为代码提供关于其行为的信息。注解可以用于类、方法、字段等。常见的内置注解包括@Override、@Deprecated和@SuppressWarnings。

例子代码：自定义注解

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String value() default "默认注解";
}

public class AnnotationExample {
    
    @MyAnnotation("自定义注解示例")
    public void myMethod() {
        System.out.println("这是一个注解方法");
    }

    public static void main(String[] args) throws Exception {
        AnnotationExample example = new AnnotationExample();
        MyAnnotation annotation = example.getClass()
                .getMethod("myMethod")
                .getAnnotation(MyAnnotation.class);
        
        System.out.println("注解值: " + annotation.value());
        example.myMethod();
    }
}

总结

枚举类型和注解为Java程序设计提供了更强大的工具。枚举增加了代码的可读性和可维护性，而注解则通过提供元数据使得代码更加灵活。通过熟练使用这两种特性，程序员可以编写出更安全、更易于理解的代码。

三、字符串处理与StringBuilder

3.1 字符串处理

在Java中，字符串是不可变的（immutable），这意味着字符串对象一旦创建，其内容不能更改。处理字符串时，任何修改都会生成新的字符串对象。

字符串操作示例

public class StringExample {
    public static void main(String[] args) {
        String str1 = "Hello, ";
        String str2 = "World!";
        String str3 = str1 + str2; // 字符串拼接
        System.out.println(str3);

        // 字符串长度
        System.out.println("长度: " + str3.length());
        
        // 查找字符
        System.out.println("位置: " + str3.indexOf("World"));
        
        // 子字符串
        System.out.println("子字符串: " + str3.substring(7));
        
        // 字符串分割
        String[] parts = str3.split(", ");
        for (String part : parts) {
            System.out.println("部分: " + part);
        }
    }
}

3.2 StringBuilder

StringBuilder是Java中的一个可变字符串类，适合用于频繁的字符串修改，例如在循环中拼接字符串。在使用StringBuilder时，不会生成新的对象，性能较String更佳。

例子代码：StringBuilder

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        sb.append(", World!"); // 拼接字符串
        System.out.println(sb.toString());

        // 替换字符串
        sb.replace(5, 6, "-");
        System.out.println(sb.toString());

        // 插入字符串
        sb.insert(5, " beautiful");
        System.out.println(sb.toString());

        // 删除字符串
        sb.delete(5, 16);
        System.out.println(sb.toString());

        // 反转字符串
        sb.reverse();
        System.out.println(sb.toString());
    }
}

总结

字符串处理在Java中非常常见，但由于Java中的字符串是不可变的，频繁的操作可能会影响性能。因此，在需要频繁修改的场景下，使用StringBuilder可以显著提高效率。这一特性在处理大量数据或字符串拼接时尤为重要。

四、抽象类与接口的高级应用

在Java中，抽象类和接口虽然都用于定义通用行为，但它们在使用上有所区别。抽象类允许部分实现，而接口则只定义方法规范。

4.1 抽象类的高级应用

抽象类可以包含字段、方法的实现和抽象方法。它适合用作基类，提供了一些默认的实现给子类。

例子代码：抽象类的使用

abstract class Animal {
    // 具体方法
    void eat() {
        System.out.println("动物在吃");
    }

    // 抽象方法
    abstract void makeSound();
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("汪汪!");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("喵喵!");
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();
        dog.makeSound();

        Animal cat = new Cat();
        cat.eat();
        cat.makeSound();
    }
}

4.2 接口的高级应用

接口可以多继承，允许一个类实现多个接口。使用接口可以实现更灵活的程序设计。

例子代码：接口的使用

interface Animal {
    void makeSound();
}

interface Pet {
    void play();
}

class Dog implements Animal, Pet {
    @Override
    public void makeSound() {
        System.out.println("汪汪!");
    }

    @Override
    public void play() {
        System.out.println("狗在玩耍");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.play();
    }
}