14

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

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());
    }

}
4

8 回答 8

36

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

在下面的片段中，您正在扩展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;
    }
};
于 2013-05-28T07:17:06.500 回答
9

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

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;
            }
        };
  1. 定义了新类（没有名称，因此称为匿名类）
  2. 这个新类扩展AbstractDemo类
  3. 的抽象方法AbstractDemo在这个新类中被覆盖
  4. 这个新类的新实例已创建并分配给ad变量

在此处阅读有关anonymous classesJava 的更多信息。

于 2013-05-28T07:19:11.380 回答
5

您不能创建抽象类的实例。
您可以创建扩展抽象类的类的实例。

抽象类的全部意义在于它是抽象的——你定义了一个接口但没有定义一个实现。如果没有实现，实例化类不会产生有意义或有用的结果。如果实例化该类的对象确实/有意义，那么您根本不想首先使用抽象类。

您可以将匿名类概念用于如下实例：

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;
            }
        };
于 2013-05-28T07:18:13.480 回答
1 
@Override // Here
void showMessage() {
    // TODO Auto-generated method stub
}

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

首先你必须知道你不能创建一个instancefor abstract class，在这里你只是创建一个anonymous class它的行为就像一个inner class扩展 theabstract class所以它属于你的anonymous class.

于 2016-09-27T09:48:39.430 回答
0

在匿名类中实现抽象方法后，您的 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;
    }
}
于 2013-05-28T07:22:51.110 回答
0

您正在覆盖.. 这就是您可以创建对象的原因。见下文。abstract methodsanonymous 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可以在你做的时候被实例化。

于 2013-05-28T07:18:07.933 回答
0

不能制作独立的抽象类的对象，但可以制作匿名抽象类对象，因为它在当时和那里提供实现。

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());
    }

}

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

于 2013-05-28T07:18:43.400 回答
0

在这里，我们提供抽象类的实现。当我们制作对象时，我们正在提供它的实现并覆盖所有抽象方法。在抽象类只有具体方法的情况下。请参见下面的示例

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());
    }
}

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

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

2.这只不过是没有名称的类，我们在制作对象时需要这样做。

  1. 是的，我们通过在运行时证明实现来制作抽象类的对象。

4.它打开了为什么抽象类允许构造函数之类的答案？但我们不能创建它的对象。

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

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

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

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

于 2016-02-22T07:02:01.183 回答