Question

在这段代码中，它是创建抽象类或匿名类的对象吗？请告诉我。我在这里有点困惑。

public abstract class AbstractDemo {

    abstract void showMessage();
    abstract int add(int x,int y);

    public int mul(int x,int y){
        return x+y;
    }


    public static void main(String[] args) {
        AbstractDemo ad = new AbstractDemo() {

            @Override
            void showMessage() {
                // TODO Auto-generated method stub

            }

            @Override
            int add(int x, int y) {
                // TODO Auto-generated method stub
                return 0;
            }
        };

        System.out.println(ad.mul(10, 12));
        System.out.println(ad.getClass());
    }

}

Answer 1

您创建了一个扩展抽象类的匿名类。

在下面的剪辑中，您正在扩展AbstractDemo并为其抽象方法提供实现。

new AbstractDemo() {
    @Override
    void showMessage() {
        // TODO Auto-generated method stub
    }

    @Override
    int add(int x, int y) {
        // TODO Auto-generated method stub
        return 0;
    }
};

Answer 2

以下是这段简短而无辜的代码中发生的事情：

AbstractDemo ad = new AbstractDemo() {

            @Override
            void showMessage() {
                // TODO Auto-generated method stub

            }

            @Override
            int add(int x, int y) {
                // TODO Auto-generated method stub
                return 0;
            }
        };

定义了新类（没有名称，所谓的匿名类）
这个新类扩展了AbstractDemo class
在这个新类

AbstractDemo

创建了此新类的新实例，并将其分配给ad变量

详细了解Java here中的anonymous classes。

Answer 3

您无法创建抽象类的实例。
您可以创建扩展抽象类的类的实例。

抽象类的重点在于它是抽象的 - 你已经定义了一个接口而不是一个实现。如果没有实现，实例化类将不会产生有意义或有用的结果。如果确实/ /将有意义地实例化该类的对象，那么您根本就不想首先使用抽象类。

您可以对以下实例使用匿名类概念：

AbstractDemo abstractDemo  = new AbstractDemo() {
            @Override
            void showMessage() {
                // TODO Auto-generated method stub
            }
            @Override
            int add(int x, int y) {
                // TODO Auto-generated method stub
                return 0;
            }
        };

Answer 4

@Override // Here
void showMessage() {
    // TODO Auto-generated method stub
}

@Override // here
int add(int x, int y) {
    // TODO Auto-generated method stub
    return 0;
}

首先你要知道你不能为instance创建一个abstract class，这里你只是创建一个anonymous class，就像{{1}这扩展了inner class，因此它属于您的abstract class。

Answer 5

您在abstract methods中覆盖 anonymous class ..这就是您可以创建对象的原因。见下文。

        @Override // Here
        void showMessage() {
            // TODO Auto-generated method stub

        }

        @Override // here
        int add(int x, int y) {
            // TODO Auto-generated method stub
            return 0;

Abstract Class的实现可以像您一样实例化。

Answer 6

无法创建一个独立的Abstract类的Object，但可以创建一个匿名的抽象类对象，因为它提供了实现。

Java不允许抽象类对象的原因是，因为它没有任何方法或某些方法的任何实现，所以你怎么能有一个不完整类的对象。但是在匿名的方式，你给它实现，所以它允许你有一个对象。

与界面相同的情况

 AbstractDemo ad = new AbstractDemo() {

            @Override
            void showMessage() {
                // TODO Auto-generated method stub

            }

            @Override
            int add(int x, int y) {
                // TODO Auto-generated method stub
                return 0;
            }
        };

这里AbstractDemo类是抽象的，但它的实现类可以有对象，这里匿名类代码实现了代码，因此完全允许有对象。

更多深入研究，请参阅下面的代码，MyAbstractClass是一个抽象类，现在如果你注释掉了

abstract void play();

然后它工作正常，Java允许创建这个抽象类的对象但是当你取消注释时，它会拒绝，因为它没有关于该方法的任何实现，所以拒绝创建对象。

abstract class MyAbstractClass {
    private String name;

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

    public String getName(){
        return this.name;
    }
    abstract void play();



}


public class Test2 {

    public static void main(String [] args)
    {
        MyAbstractClass ABC = new MyAbstractClass("name") {
        };

        System.out.println(ABC.getName());
    }

}

在构造函数调用之后仔细检查它是{}，这意味着不再需要实现，或者你可以覆盖它的方法之一或更多。

Answer 7

在抽象方法在匿名类中实现之后，您的AbstractDemo不再是抽象的。它说得好：

Class AbstractDemoImpl extends AbstractDemo {

    void showMessage() {
            // TODO Auto-generated method stub
    }
    int add(int x, int y) {
            // TODO Auto-generated method stub
            return 0;
    }
}

Answer 8

这里我们提供抽象类的实现。在我们创建对象的时候，我们提供它的实现并覆盖所有抽象方法。在Abstract类只有具体方法的情况下。见下面的例子

abstract class MyAbstractClass {
    private String name;

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

    public String getName(){
        return this.name;
    }
}

public class Test {

    public static void main(String [] args)
    {
        MyAbstractClass ABC = new MyAbstractClass("name") {
        };

        System.out.println(ABC.getName());
    }
}

这里我们只是使用像{}这样的调用构造函数来创建对象。

我们正在使用匿名类证明实现。

2.什么只是没有名字的类，我们需要做的就是当我们制作一个物体时。

是的，我们通过在运行时证明实现来创建抽象类的对象。

4.它打开了答案，就像为什么抽象类允许构造函数？但我们无法创造它的对象。

5.与抽象类相关的另一个问题是我们在抽象类中只能有静态块。这是什么意思？

6.仅静态阻止，因为我们只想加载一次而不扩展和创建对象。

7.编译代码后，我们用来获取每个具体类，抽象类或接口的.class。

8.下一个问题出现在这里为什么java人不允许在接口中使用静态块？

创建抽象类或匿名类的实例

8 个答案: