Java方法重写，匿名对象，抽象类-CSDN博客

本文链接：https://blog.csdn.net/lizhiwei21/article/details/140273297

1-方法重写

什么是方法重写 ?
- 子类和父类出现了一模一样的方法的声明(方法名 , 参数列表)
为什么要学习方法重写 ?
- 当子类需要使用父类的功能 , 但是父类的功能又满足不了子类 , 那么子类需要重写 , 这样既可以使用父类的功能 ,也可以增加新的功能
如果进行方法重写 ?
- 子类和父类的方法声明一样 , 方法体中的内容重新定义
Override注解是做什么的，有什么用？
- @Override是放在重写后的方法上，作为重写是否正确的校验注解，加上该注解后如果重写错误，编译阶段会出现错误提示。建议重写方法都加@Override注解，代码安全，优雅！
- 如何使用Override

@Override 是一个注解，用于告诉编译器，当前的方法是重写（覆盖）父类或者接口中的方法。它通常用于增强代码的可读性和可维护性，同时也有助于捕获一些常见的错误，比如拼写错误或者意外地不小心改变了方法签名。

使用方法

在Java中，当你打算重写一个父类或者接口中的方法时，可以在方法的声明前添加 @Override 注解。具体步骤如下：

确保方法签名正确： 确保你的方法签名（方法名、参数类型和个数、返回类型）与父类或接口中的方法签名完全一致。
添加 @Override 注解： 在方法的声明行前加上 @Override 注解。例如：
```
@Override
public void methodName() {
    // 方法体
}
```
这里的 methodName() 方法就是在子类中重写父类的方法。
编译检查： 编译器会检查这个方法是否真的覆盖了父类或接口中的方法。如果父类或接口中不存在对应的方法（方法签名不一致），编译器会报错。

示例

假设有一个父类 Animal 和它的子类 Dog，其中 Animal 中有一个 makeSound() 方法：

public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

现在，你想在 Dog 类中重写 makeSound() 方法。可以这样做：

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

在这个示例中，@Override 注解确保了 Dog 类中的 makeSound() 方法真的是对 Animal 类中的 makeSound() 方法的重写。如果你不小心拼写错误或者方法签名不匹配，编译器会提醒你，帮助你及早发现和修复问题。

总结

@Override 注解在实际开发中是一个非常有用的工具，它帮助开发者遵循重写方法的规范，提高代码的可靠性和可读性。

方法重写的注意事项 ?
- 私有的方法无法重写
- 重写的方法与被重写的方法 , 名字 , 参数列表需要保持一致
- 子类重写父类方法时，子类方法访问权限必须大于或者等于父类方法权限（暂时了解：缺省 < protected < public）
  - 一般保持一致即可

举例

2-匿名对象

什么是匿名对象 ?
- 没有变量接收的对象 , 称作为匿名对象
匿名对象的使用 ?
- 直接使用匿名对象调用方法
- 匿名对象作为方法传参
- 匿名对象作为方法的返回值

调用方法

// 定义一个简单的类
class Person {
    public void introduce() {
        System.out.println("Hello, I'm a person.");
    }
}

// 在主程序中使用匿名对象调用方法
public class Main {
    public static void main(String[] args) {
        // 使用匿名对象调用 introduce() 方法
        new Person().introduce();
    }
}

在上面的例子中，new Person().introduce() 创建了一个 Person 类的匿名对象，并立即调用了其 introduce() 方法。这种方式适合于只需要临时使用某个对象执行一些操作，而不需要在后续的代码中再次引用它。

作为方法参数

// 定义一个类
class Calculation {
    public void add(int a, int b) {
        int sum = a + b;
        System.out.println("Sum: " + sum);
    }
}

// 在主程序中将匿名对象作为参数传递给方法
public class Main {
    public static void main(String[] args) {
        // 将匿名对象作为参数传递给 add 方法
        new Calculation().add(5, 3);
    }
}

这个例子中，new Calculation().add(5, 3) 创建了一个 Calculation 类的匿名对象，并将其作为参数传递给 add 方法。这种方式可以简化代码，避免显式地创建变量来引用对象。

注意事项

匿名对象的生命周期仅限于当前使用的代码块，一旦执行完对它的操作，它就会被释放。
由于匿名对象没有引用变量指向它们，因此无法再次使用或者在其他地方引用。

3-抽象类

抽象类（Abstract Class）是在面向对象编程中的一个重要概念。它本身无法被实例化，主要用于其他类继承（extends）或者实现（implements）。抽象类通常用于表示一类对象的通用特征，它可以包含抽象方法、非抽象方法、构造方法、静态方法等。

主要特点：

不能被实例化： 抽象类不能被直接实例化为对象。也就是说，不能使用 new 关键字来创建抽象类的实例。
包含抽象方法： 抽象类中可以包含抽象方法（没有方法体，只有方法签名）。子类必须实现抽象类中的所有抽象方法，除非子类也是抽象类。
可以包含具体方法： 抽象类可以包含具体的方法实现，这些方法可以直接被子类继承和使用。
用于继承和多态： 抽象类用于通过继承来共享代码和行为。它可以定义子类的结构和行为，而具体的实现由子类完成，从而实现多态性。

举例

// 定义一个抽象类 Animal
abstract class Animal {
    // 抽象方法，子类必须实现
    public abstract void makeSound();
    
    // 具体方法
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// 继承抽象类 Animal 的子类 Dog
class Dog extends Animal {
    // 实现抽象方法 makeSound
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

// 主程序测试
public class Main {
    public static void main(String[] args) {
        // 不能直接实例化抽象类 Animal
        // Animal animal = new Animal();  // 编译错误
        
        // 可以创建 Dog 类的对象
        Dog dog = new Dog();
        dog.makeSound();  // 输出: Dog barks
        dog.eat();  // 输出: Animal is eating
    }
}

在上面的例子中，Animal 是一个抽象类，它包含一个抽象方法 makeSound() 和一个具体方法 eat()。Dog 类继承自 Animal 类，并实现了 makeSound() 方法。注意，抽象类 Animal 不能直接实例化，但可以通过其子类 Dog 来创建对象。