Java错误 - 方法的所有非法修饰符组合 wrt Abstract

在Java中，我们可以对类、方法、块和变量应用各种修饰符，每个修饰符都有不同的用例，所有这些主要定义了如何以及在何处访问和修改这些类、方法、块和变量.但并非所有修饰符都可以同时应用，因为它们的定义与这些修饰符使我们能够做什么之间存在一些矛盾。因此，不能同时应用的修饰符组合形成了非法的修饰符组合，无论我们在哪里使用，都会出现编译时错误。

例如——声明为公共的方法可以从程序中的任何地方访问，但私有方法只能在声明它的类中访问。因此，如果我们尝试将公共和私有修饰符应用于方法，它将形成非法修饰符组合并给出如下所示的编译时错误。

Java

// Java program to illustrate
// illegal modifier combination
 
import java.io.*;
 
class GFG {
    public static void main(String[] args)
    {
 
        System.out.println("GFG!");
    }
 
    // the below method has illegal modifier combination
    protected public void m1() {}
}

Java

// Java program to illustrate
// Abstract method
 
// Importing required packages
import java.util.*;
 
// Declaring an abstract class
abstract class Animal {
 
    // Declaring an abstract method
    public abstract String getSound();
}
 
// Declaring a class Cat by extending
// the above Animal class
class Cat extends Animal {
 
    // Implementing the above
    // abstract method of animal class
    public String getSound() { return "Meow!"; }
 
    // main method
    public static void main(String[] args)
    {
 
        // Creating an object of type class Cat
        Cat c = new Cat();
 
        // Calling getSound method
        System.out.println(c.getSound());
    }
}

上面的代码抛出编译时错误：

GFG.java:13: error: illegal combination of modifiers: public and protected
   protected public void m1() {}
                         ^
1 error

现在，在了解不同的非法修饰符组合之前，首先让我们了解抽象关键字。

在Java中， abstract是一个修饰符，适用于类和方法，但不适用于变量，它帮助我们在Java中实现抽象。抽象是一种我们只公开我们提供的服务而隐藏内部细节和实现的方式。

让我们了解一下抽象方法和抽象类：

抽象方法

即使我们不知道实现，我们仍然可以编写一个带有抽象修饰符的方法，即，唯一的声明可用但未实现。因此，抽象方法不应该有任何人并且应该以分号结尾。出于这个原因，每个扩展抽象类的类都必须实现所有的抽象方法，或者应该声明为抽象的。

下面给出了一个演示抽象方法的示例：

Java

// Java program to illustrate
// Abstract method
 
// Importing required packages
import java.util.*;
 
// Declaring an abstract class
abstract class Animal {
 
    // Declaring an abstract method
    public abstract String getSound();
}
 
// Declaring a class Cat by extending
// the above Animal class
class Cat extends Animal {
 
    // Implementing the above
    // abstract method of animal class
    public String getSound() { return "Meow!"; }
 
    // main method
    public static void main(String[] args)
    {
 
        // Creating an object of type class Cat
        Cat c = new Cat();
 
        // Calling getSound method
        System.out.println(c.getSound());
    }
}

输出

Meow!

抽象类

抽象类是我们无法实例化对象的类，它基本上定义并提供了派生类的蓝图以及具体类在继承该抽象类时必须实现的方法。

任何作为继承它的类的泛化的类都可以声明为抽象的。例如，Animal 类是对各种动物的概括。所有动物都有一些共同的属性，但价值和实现方式不同。因此，Animal 类可能如下所示：

abstract class Animal {

    public abstract String getSound();
    
    public abstract String getColour();
    
    public abstract move();
    
    // Many more methods follow...

}

现在，在学习所有非法修饰符组合之前，这里有一个快速建议：

Note: As abstract never talks about implementation, any modifier that has anything to do with implementation forms an illegal combination with abstract. Also, abstract keyword promotes inheritance and polymorphism and hence, any modifier that restrict inheritance or polymorphism also forms illegal combination. These can be used as thumb-rules while identifying those modifiers forming illegal combination with abstract.

编程需要懂一点英语

Java中抽象方法的所有非法修饰符组合

以下是抽象方法的各种非法修饰符组合 -

1. 最终摘要

编译时错误：修饰符的非法组合：“final”和“abstract”
原因：必须在子类中重写抽象方法以提供实现，而不能重写最终方法。因此，这是一种非法组合。
解决方案：我们可以仅将方法声明为 final，这将限制在子类中覆盖该方法，或者我们可以将其声明为仅抽象并根据需要在子类中实现该方法。

2. 原生摘要

编译时错误：修饰符的非法组合：“native”和“abstract”
原因：对于本机方法的实现已经存在于某些其他语言（C 或 C++）中，但对于抽象方法，不应该存在实现。因此，它也形成了非法组合。
解决方案：只有当其他语言的实现已经存在时，我们才能使用 native 或仅将方法保持为抽象。

3. 私人摘要

编译时错误：修饰符的非法组合：“private”和“abstract”
原因：子类应该可以使用抽象方法来提供实现，而子类不能使用私有方法，因此这是非法组合。
解决方案：如果子类中不需要该方法并且仅由定义它的类使用，则仅使用私有声明它或将其声明为抽象并在子类中实现。

4. 静态摘要

编译时错误：修饰符的非法组合：“静态”和“抽象”
原因：必须在子类中重写抽象方法以提供实现，而不能重写静态方法（可以隐藏静态方法，但这与重写根本不同）。
解决方案：如果您希望该方法由子类实现，则将其保持为抽象或仅在不允许覆盖时声明为静态。

5. Strictfp 摘要

编译时错误：修饰符的非法组合：“strictfp”和“抽象”
原因：如果一个方法被声明为 strictfp，那么它确保所有的浮点计算都应该遵循 IEEE 754 标准，并且会给出与平台无关的结果。所以基本上，它谈论的是实现，因此与抽象形成了非法组合。
解决方案：要么仅声明为抽象，要么声明为 strictfp，以确保平台独立的浮点计算。

6. 同步摘要

编译时错误：修饰符的非法组合：“同步”和“抽象”
原因：为了防止多个线程对给定对象同时执行一个方法，使用了 synchronized 关键字来防止不一致的问题。因此，当我们同步一个方法时，意味着我们正在同步其中的代码。因此，实施是必要的。因此，这种组合也是非法的。
解决方案：要么将方法声明为仅抽象方法，要么在线程安全很重要的情况下保持同步。