精华内容
下载资源
问答
  • 抽象类和接口 面试题

    2020-04-27 15:39:53
    抽象类和接口 面试题 1.添加以下哪个选项不会引起编译器报错? abstract class AbstractAnimal { static String animalName = "AbstractAnimal"; // 添加代码处 } A:protected abstract void eat(); B: void ...

    抽象类和接口 面试题

    1.添加以下哪个选项不会引起编译器报错?

    abstract class AbstractAnimal {
        static String animalName = "AbstractAnimal";
          // 添加代码处
    }
    

    A:protected abstract void eat();
    B: void eat();
    C:abstract void eat(){};
    D:animalName += “Cat”;

    答:A

    题目解析:选项 B 普通方法必须有方法体;选项 C 抽象方法不能有方法体;选项 D 变量赋值操作必须在方法内。

    {方法体}

    2.执行以下代码会输出什么结果?

    interface IAnimal {
        static String animalName = "Animal Name";
    }
    class AnimalImpl implements IAnimal {
        static String animalName = new String("Animal Name");
        public static void main(String[] args) {
            System.out.println(IAnimal.animalName == animalName);
        }
    }
    

    答:执行的结果为 false。

    题目解析:子类使用 new String… 重新创建了变量 animalName,又因为使用 == 进行内存地址比较,所以结果就是 false。

    内存地址不一样

    展开全文
  • 抽象类和接口面试题

    2019-09-06 11:08:49
    Java抽象类可以有构造函数吗...现在一些面试官问,如果你不能对抽象类实例化那么构造函数的作用是什么?好吧,它可以用来初始化抽象类内部声明的通用变量,并被各种实现使用。另外,即使你没有提供任何构造函数,编...
    1. Java抽象类可以有构造函数吗?
      可以有,抽象类可以声明并定义构造函数。因为你不可以创建抽象类的实例,所以构造函数只能通过构造函数链调用(Java中构造函数链指的是从其他构造函数调用一个构造函数),例如,当你创建具体的实现类。现在一些面试官问,如果你不能对抽象类实例化那么构造函数的作用是什么?好吧,它可以用来初始化抽象类内部声明的通用变量,并被各种实现使用。另外,即使你没有提供任何构造函数,编译器将为抽象类添加默认的无参数的构造函数,没有的话你的子类将无法编译,因为在任何构造函数中的第一条语句隐式调用super(),Java中默认超类的构造函数。

    2. Java抽象类可以实现接口吗?它们需要实现所有的方法吗?
      可以,抽象类可以通过使用关键字implements来实现接口。因为它们是抽象的,所以它们不需要实现所有的方法。好的做法是,提供一个抽象基类以及一个接口来声明类型 。这样的例子是,java.util.List接口和相应的java.util.AbstractList抽象类。因为AbstractList实现了所有的通用方法,具体的实现像LinkedList和ArrayList不受实现所有方法的负担,它们可以直接实现List接口。这对两方面都很好,你可以利用接口声明类型的优点和抽象类的灵活性在一个地方实现共同的行为。Effective Java有个很好的章节,介绍如何使用Java的抽象类和接口,值得阅读。

    3. Java抽象类可以是final的吗?
      不可以,Java抽象类不能是final的。将它们声明为final的将会阻止它们被继承,而这正是使用抽象类唯一的方法。它们也是彼此相反的,关键字abstract强制继承类,而关键字final阻止类被扩张。在现实世界中,抽象表示不完备性,而final是用来证明完整性。底线是,你不能让你的Java类既abstract又final,同时使用,是一个编译时错误。

    4. Java抽象类可以有static方法吗?
      可以,丑娘类可以声明并定义static方法,没什么阻止这样做。但是,你必须遵守Java中将方法声明为static的准则,因为在面向对象的设计中是不受欢迎的,因为Java中的static方法是不可以被重载的。在抽象类中看到static方法是罕见的,但正如我所说的,如果你有很好的理由这样做的话,那没有什么可以阻止你。

    5. 可以创建抽象类的实例吗?
      不可以,你不能创建Java抽象类的实例,它们是不完全的。即使你的抽象类不包含任何抽象方法,你也不能对它实例化。将类声明为abstract的,就等你你告诉编译器,它是不完全的不应该被实例化。当一段代码尝试实例化一个抽象类时Java编译器会抛错误。

    6. 抽象类必须有抽象方法吗?
      不需要,抽象类有抽象方法不是强制性的。你只需要使用关键字abstract就可以将类声明为抽象类。编译器会强制所有结构的限制来适用于抽象类,例如,现在允许创建一些实例。是否在抽象类中有抽象方法是引起争论的。我的观点是,抽象类应该有抽象方法,因为这是当程序员看到那个类并做假设的第一件事。这也符合最小惊奇原则。

    7. Java抽象类和接口有何不同?
      这是最重要的经典Java面试题之一。我已经记不清多少次看到这个问题了。这个问题有趣的原因是可以举出例子。很容易回答核心OOPS的概念,如抽象,封装,多态和继承,但是,当涉及到微妙点就是这样,候选人往往失手。你可以从本文看出抽象类和接口之间的所有语法的差异。

    8. 何时选用抽象类而不是接口?
      这是对之前抽象类和接口对比问题的后续。如果你知道语法差异,你可以很容易回答这个问题,因为它们可以令你做出抉择。当关心升级时,因为不可能在一个发布的接口中添加一个新方法,用抽象类会更好。类似地,如果你的接口中有很多方法,你对它们的实现感到很头疼,考虑提供一个抽象类作为默认实现。这是Java集合包中的模式,你可以使用提供默认实现List接口的AbstractList。

    9. Java中的抽象方法是什么?
      抽象方法是一个没有方法体的方法。你仅需要声明一个方法,不需要定义它并使用关键字abstract声明。Java接口中所有方法的声明默认是abstract的。这是抽象方法的例子

    public void abstract printVersion();

    现在,为了实现这个方法,你需要继承该抽象类并重载这个方法。
    10. Java抽象类中可以包含main方法吗?
    是的,抽象类可以包含main方法,它只是一个静态方法,你可以使用main方法执行抽象类,但不可以创建任何实例。

    展开全文
  • 在Java语言中, abstract class interface是支持抽象类定义的两种机制。正是由于这两种机制的存在,才赋予了Java强大的 面向对象能力。abstract classinterface之间在对于抽象类定义的支持方面具有很大的相似性...

    在Java语言中, abstract class 和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在,才赋予了Java强大的 面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进 行抽象类定义时对于abstract class和interface的选择显得比较随意。其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对 于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析,试图给开发者提供一个在二者之间进行选择的依据。

    理解抽象类

    abstract class和interface在Java语言中都是用来进行抽象类(本文 中的抽象类并非从abstract class翻译而来,它表示的是一个抽象体,而abstract class为Java语言中用于定义抽象类的一种方法, 请读者注意区分)定义的,那么什么是抽象类,使用抽象类能为我们带来什么好处呢?

    在 面向对象的概念中,我们知道所有的对象都是通过类来描绘的,但是反过来却不是这样。并不是 所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。抽象类往往用来表征我们在对问题领域进行分析、 设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、 三角形这样一些具体概念,它们是不同的,但是它们又都属于形状这样一个概念,形状这个概念在问题领域是不存在的,它就是一个抽象概念。正是因为抽象的概念 在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能够实例化的。

    在面向对象领域,抽象类主要用来进行类型隐藏。 我们可以构造出一个固定的一组行为的抽象描 述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类,而这一组任意个可能的具体实现则表现为所有可能的派生类。模块可以操作一个 抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。熟悉OCP的读者一定知 道,为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)一个软件实体应当对扩展开放,对修改关闭.也就是说,我们在设计一个模块的时候,应当使这个模块可以在不被修改的前提下被扩展,换句话说就是,应当可以在不必修改源代码的情况下改变这个模块的行为.,抽象类是其中的关键所在。

    从语法定义层面看abstract class 和 interface

    在语法层面,Java语言对于abstract class和interface给出了不同的定义方式,下面以定义一个名为Demo的抽象类为例来说明这种不同。

    使用abstract class的方式定义Demo抽象类的方式如下:

    abstract class Demo{

    abstract void method1();

    abstract void method2();

    使用interface的方式定义Demo抽象类的方式如下:

    interface Demo{

    void method1();

    void method2();

    }

    在abstract class方式中,Demo可以有自己的数据成员,也可以有非 abstract的成员方法,而在interface方式的实现中,Demo只能够有静态的不能被修改的数据成员(也就是必须是static final 的,不过在interface中一般不定义数据成员),所有的成员方法都是abstract的。从某种意义上说,interface是一种特殊形式的 abstract class。

    从编程的角度来看,abstract class和interface都可以用来实现 "design by contract" 的思想。但是在具体的使用上面还是有一些区别的。

    首先,abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系(因为Java不支持多继承 -- 转注)。但是,一个类却可以实现多个interface。也许,这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。

    其次,在abstract class的定义中,我们可以赋予方法的默认行为。但是在interface的定义中,方法却不能拥有默认行为,为了绕过这个限制,必须使用委托,但是这会增加一些复杂性,有时会造成很大的麻烦。

    在 抽象类中不能定义默认行为还存在另一个比较严重的问题,那就是可能会造成维护上的麻烦。因 为如果后来想修改类的界面(一般通过 abstract class 或者interface来表示)以适应新的情况(比如,添加新的方法或者给已用的方法中添 加新的参数)时,就会非常的麻烦,可能要花费很多的时间(对于派生类很多的情况,尤为如此)。但是如果界面是通过abstract class来实现的,那 么可能就只需要修改定义在abstract class中的默认行为就可以了。

    同样,如果不能在抽象类中定义默认行为,就会导致同样的方法实现出现在该抽象类的每一个派生类中,违反了 "one rule,one place" 原则,造成代码重复,同样不利于以后的维护。因此,在abstract class和interface间进行选择时要非常的小心。

    从设计理念层面看 abstract class 和 interface

    上面主要从语法定义和编程的角度论述了abstract class和interface的区 别,这些层面的区别是比较低层次的、非本质的。本小节将从另一个层面:abstract class和interface所反映出的设计理念,来分析一下二者的区别。作者认为,从这个层面进行分析才能理解二者概念的本质所在。

    前面已经提到过,abstract class在Java语言中体现了一种继承关系,要想使得 继承关系合理,父类和派生类之间必须存在"is-a"关系,即父类和派生类在概念本质上应该是相同的。对于interface来说则不然,并不要求interface的实现者和interface定义在概念本质上是一致的, 仅仅是实现了interface定义的契约而已。为了使论述便于理解,下面将通过一个简单的实例进行说明。

    考虑这样一个例子,假设在我们的问题领域中有一个关于Door的抽象概念,该Door具有执行两个动作open和close,此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型,定义方式分别如下所示:

    使用abstract class方式定义Door:

    abstract class Door{

    abstract void open();

    abstract void close();

    }

    使用interface方式定义Door:

    interface Door{

    void open();

    void close();

    }

    其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

    如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢(在本例中, 主要是为了展示 abstract class 和interface 反映在设计理念上的区别,其他方面无关的问题都做了简化或者忽略)?下面将罗列出可能的解 决方案,并从设计理念层面对这些不同的方案进行分析。

    解决方案一:

    简单的在Door的定义中增加一个alarm方法,如下:

    abstract class Door{

    abstract void open();

    abstract void close();

    abstract void alarm();

    }

    或者

    interface Door{

    void open();

    void close();

    void alarm();

    }

    那么具有报警功能的AlarmDoor的定义方式如下:

    class AlarmDoor extends Door{

    void open(){…}

    void close(){…}

    void alarm(){…}

    }

    或者

    class AlarmDoor implements Door{

    void open(){…}

    void close(){…}

    void alarm(){…}

    这种方法违反了面向对象设计中的一个核心原则 ISP (Interface Segregation Principle),在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方 法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变(比如:修改alarm方法的参数)而改变,反 之依然。

    解决方案二:

    既然open、close和alarm属于两个不同的概念,根据ISP原则应该把它们分别定 义在代表这两个概念的抽象类中。定义方式有:这两个概念都使用 abstract class 方式定义;两个概念都使用interface方式定义;一个概念 使用 abstract class 方式定义,另一个概念使用interface方式定义。

    显然,由于Java语言不支持多重继承,所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的,但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

    如果两个概念都使用interface方式来定义,那么就反映出两个问题:1、我们可能没有 理解清楚问题领域,AlarmDoor在概念本质上到底是Door还是报警器?2、如果我们对于问题领域的理解没有问题,比如:我们通过对于问题领域的分 析发现AlarmDoor在概念本质上和Door是一致的,那么我们在实现时就没有能够正确的揭示我们的设计意图,因为在这两个概念的定义上(均使用 interface方式定义)反映不出上述含义。

    如果我们对于问题领域的理解是:AlarmDoor在概念本质上是Door,同时它有具有报 警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢?前面已经说过,abstract class在Java语言中表示一种继承关系,而继承关系 在本质上是"is-a"关系。所以对于Door这个概念,我们应该使用abstarct class方式来定义。另外,AlarmDoor又具有报警功能,说 明它又能够完成报警概念中定义的行为,所以报警概念可以通过interface方式定义。如下所示:

    abstract class Door{

    abstract void open();

    abstract void close();

    }

    interface Alarm{

    void alarm();

    }

    class Alarm Door extends Door implements Alarm{

    void open(){…}

    void close(){…}

    void alarm(){…}

    }

    这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其 实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。

    小结

    1.abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。

    2.在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的。

    3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。

    4.实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

    5.接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。

    6.抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以重新赋值。

    7.接口中的方法默认都是 public,abstract 类型的。

    结论

    abstract class 和 interface 是 Java语言中的两种定义抽象类的方式,它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概 念本质的理解、对于设计意图的反映是否正确、合理,因为它们表现了概念间的不同的关系(虽然都能够实现需求的功能)。这其实也是语言的一种的惯用法,希望读者朋友能够细细体会。

    展开全文
  • 抽象类和接口的应用 + 面试题抽象类定义在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是...

    抽象类和接口的应用 + 面试题

    抽象类

    定义

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。简单来说,使用关键字 abstract 修饰的类就叫做抽象类。

    抽象类使用

    示例代码,如下:

    abstract class AbstractAnimal {

    public AbstractAnimal() {

    System.out.println("Init AbstractAnimal.");

    }

    static String name = "AbstractAnimal";

    public abstract void eat();

    public void run() {

    System.out.println("AbstractAnimal Run.");

    }

    }

    class Animal extends AbstractAnimal {

    public static void main(String[] args) {

    AbstractAnimal animal = new Animal();

    animal.run();

    System.out.println(animal.name);

    animal.eat();

    }

    // 必须重写抽象父类方法

    @Override public void eat() {

    System.out.println("Animal Eat.");

    }

    }

    以上代码执行的结果:

    Init AbstractAnimal.

    AbstractAnimal Run.

    AbstractAnimal

    Animal Eat.

    抽象方法

    使用 abstract 关键字修饰的方法叫做抽象方法,抽象方法仅有声明没有方法体。如下代码:

    public abstract void m();

    抽象类的特性

    抽象类不能被初始化

    抽象类可以有构造方法

    抽象类的子类如果为普通类,则必须重写抽象类中的所有抽象方法

    抽象类中的方法可以是抽象方法或普通方法

    一个类中如果包含了一个抽象方法,这个类必须是抽象类

    子类中的抽象方法不能与父类中的抽象方法同名

    抽象方法不能为 private、static、final 等关键字修饰

    抽象类中可以包含普通成员变量,访问类型可以任意指定,也可以使用静态变量(static)

    接口

    定义

    接口(interface)是抽象类的延伸,它允许一个类可以实现多个接口,弥补了抽象类不能多继承的缺陷,接口是对类的描述,使用 interface 关键字来声明。

    接口使用

    示例代码,如下:

    interface IAnimal {

    void run();

    }

    class AnimalImpl implements IAnimal {

    public static void main(String[] args) {

    IAnimal animal = new AnimalImpl();

    animal.run();

    }

    @Override

    public void run() {

    System.out.println("AnimalImpl Run.");

    }

    }

    Java 8 中接口的改动

    1)接口中增加了 default 方法和 static 方法,可以有方法体

    示例代码,如下:

    interface IAnimal {

    static void printSex() {

    System.out.println("Male Dog");

    }

    default void printAge() {

    System.out.println("18");

    }

    }

    class AnimalImpl implements IAnimal {

    public static void main(String[] args) {

    IAnimal.printSex();

    IAnimal animal = new AnimalImpl();

    animal.printAge();

    }

    }

    注意:static 方法属于接口方法,可以直接使用;default 属于实例方法,必须先创建实例。

    2)接口中的静态变量会被继承

    示例代码,如下:

    interface IAnimal {

    static String animalName = "Animal Name";

    static void printSex() {

    System.out.println("Male Dog");

    }

    }

    class AnimalImpl implements IAnimal {

    public static void main(String[] args) {

    System.out.println(animalName);

    IAnimal.printSex();

    }

    }

    注意:静态变量会被继承,静态方法不会被继承。

    3)新增函数式接口

    函数式接口(Function Interface)是一个特殊的接口,使用 @FunctionInterface 注解声明,定义这种接口可以使用 Lambda 表达式直接调用。

    示例代码,如下:

    @FunctionalInterface

    interface IAnimal {

    static String animalName = "Animal Name";

    static void printSex() {

    System.out.println("Male Dog");

    }

    default void printAge() {

    System.out.println("18");

    }

    void sayHi(String name);

    }

    class FunctionInterfaceTest {

    public static void main(String[] args) {

    IAnimal animal = name -> System.out.println(name);

    animal.sayHi("WangWang");

    }

    }

    注意:使用 @FunctionInterface 声明的函数式接口,抽象方法必须有且仅有一个,但可以包含其他非抽象方法。

    相关面试题

    1.抽象类中能不能包含方法体?

    答:抽象类中可以包含方法体。抽象类的构成也可以完全是包含方法体的普通方法,只不过这样并不是抽象类最优的使用方式。

    题目解析:包含了方法体的抽象类示例代码如下:

    abstract class AbstractAnimal {

    public void run() {

    System.out.println("AbstractAnimal Run.");

    }

    }

    class Animal extends AbstractAnimal {

    public static void main(String[] args) {

    AbstractAnimal animal = new Animal();

    animal.run();

    }

    }

    以上代码执行的结果是: AbstractAnimal Run.

    2.抽象类能不能被实例化?为什么?

    答:抽象类不能被实例化,因为抽象类和接口的设计就是用来规定子类行为特征的,就是让其他类来继承,是多态思想的一种设计体现,所以强制规定抽象类不能被实例化。

    3.抽象方法可以被 private 修饰吗?为什么?

    答:抽象方法不能使用 private 修饰,因为抽象方法就是要子类继承重写的,如果设置 private 则子类不能重写此抽象方法,这与抽象方法的设计理念相违背,所以不能被 private 修饰。

    4.添加以下哪个选项不会引起编译器报错?

    abstract class AbstractAnimal {

    static String animalName = "AbstractAnimal";

    // 添加代码处

    }

    A:protected abstract void eat();

    B: void eat();

    C:abstract void eat(){};

    D:animalName += "Cat";

    答:A

    题目解析:选项 B 普通方法必须有方法体;选项 C 抽象方法不能有方法体;选项 D 变量赋值操作必须在方法内。

    5.以下关于抽象类和抽象方法说法正确的是?

    A:抽象类中的方法必须全部为抽象方法

    B: 抽象类中必须包含一个抽象方法

    C:抽象类中不能包含普通方法

    D:抽象类中的方法可以全部为普通方法(包含方法体)

    答:D

    题目解析:抽象类中可以没有方法或者全部为普通方法,都是允许的,如下代码所示:

    abstract class AbstractAnimal {

    public void run() {

    System.out.println("AbstractAnimal Run.");

    }

    }

    class Animal extends AbstractAnimal {

    public static void main(String[] args) {

    AbstractAnimal animal = new Animal();

    animal.run();

    }

    }

    程序执行的结果为:AbstractAnimal Run.

    6.接口和普通类有什么关系?

    答:在 Java 语言设计中,接口不是类,而是对类的一组需求描述,这些类必须要遵循接口描述的统一格式进行定义。

    7.接口能不能有方法体?

    答:JDK 8 之前接口不能有方法体,JDK 8 之后新增了 static 方法和 default 方法,可以包含方法体。

    8.执行以下代码会输出什么结果?

    interface IAnimal {

    static String animalName = "Animal Name";

    }

    class AnimalImpl implements IAnimal {

    static String animalName = new String("Animal Name");

    public static void main(String[] args) {

    System.out.println(IAnimal.animalName == animalName);

    }

    }

    答:执行的结果为 false。

    题目解析:子类使用 new String… 重新创建了变量 animalName,又因为使用 == 进行内存地址比较,所以结果就是 false。

    9.抽象类和接口有什么区别?

    答:抽象类和接口的区别,主要分为以下几个部分。

    默认方法

    抽象类可以有默认方法的实现

    JDK 8 之前接口不能有默认方法的实现,JDK 8 之后接口可以有默认方法的实现

    继承方式

    子类使用 extends 关键字来继承抽象类

    子类使用 implements 关键字类实现接口

    构造器

    抽象类可以有构造器

    接口不能有构造器

    方法访问修饰符

    抽象方法可以用 public / protected / default 等修饰符

    接口默认是 public 访问修饰符,并且不能使用其他修饰符

    多继承

    一个子类只能继承一个抽象类

    一个子类可以实现多个接口

    10.以下抽象方法描述正确的是?

    A:抽象方法可以是静态(static)的

    B:抽象方法可同时是本地方法(native)

    C:抽象方法可以被 synchronized 修饰

    D:以上都不是

    答:D

    题目解析:抽象方法需要被子类重写,而静态方法是无法被重写的,因此抽象方法不能被静态(static)修饰;本地方法是由本地代码实现的方法,而抽象方法没有实现,所以抽象方法不能同时是本地方法;synchronized 和方法的实现细节有关,而抽象方法不涉及实现细节,因此抽象方法不能被 synchronized 修饰。

    总结

    抽象类和接口都是面向对象编程中多态的具体实现,在 Java 编程思想中占据着重要的地位,同时也是初级面试岗位必问的问题之一,但由于接口在 JDK 8 中的改动比较大,因而面试者在网上搜到的绝大数关于接口和抽象类区别的答案也是不准确的,这点需要面试者特别注意一下。

    _

    欢迎关注我的公众号,回复关键字“Java” ,将会有大礼相送!!! 祝各位面试成功!!!

    %97%E5%8F%B7%E4%BA%8C%E7%BB%B4%E7%A0%81.png)

    展开全文
  • 抽象类定义在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。简单来说,使用关键字 ...
  • 抽象类和接口的区别(面试题

    万次阅读 多人点赞 2018-09-12 23:09:28
    含有abstract修饰符的class即为抽象类,abstract 类不能创建实例对象。含有abstract方法的类必须定义为abstract class,abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)...
  • 10个Java抽象类和接口面试题

    千次阅读 2018-03-04 11:00:44
    1. Java抽象类可以有构造函数...现在一些面试官问,如果你不能对抽象类实例化那么构造函数的作用是什么?好吧,它可以用来初始化抽象类内部声明的通用变量,并被各种实现使用。另外,即使你没有提供任何构造函数,编...
  • 抽象类 定义 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。简单来说,使用关键字...
  • 1.abstract class 在 Java 语言中表示的是一种继承关系,一个只能使用一次继承关系。但是,一个却可以实现多个interface。2.在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在...
  • 可以有,抽象类可以声明定义构造函数。因为你不可以创建抽象类实例,所以构造函数链调用(Java中构造函数链指的是从其他构造函数调用一个构造函数),例如,当你创建具体的实现类。有一些面试官会问,如果你不能对...
  • 4、抽象类和接口的区别是什么? 第一点. 接口是抽象类的变体,接口中所有的方法都是抽象的。而抽象类是声明方法的存在而不去实现它的类。 第二点. 接口可以多继承,抽象类不行 第三点. 接口定义方法,不能实现...
  • Java基础——抽象类和接口的对比 一、抽象类与接口的联系   1、抽象类可以使用implements实现接口,一个抽象类可以实现若干个接口(抽象类是个加强版的普通类)     ①若抽象类实现了接口,可以不实现接口的...
  • 面试题抽象类和接口

    2011-12-08 16:14:00
    抽象类 在面向对象的概念中,所有的对象都是通过类来描述的,但不是所有类都是用来描述对象的。如果一个类中没有足够的信息来描述一个具体的对象这样的类就是抽象类;   1、抽象类必须有abstract修饰符来修饰,...
  • 抽象类和接口的异同? 相同点:不能实例化;都可以包含抽象方法 不同点: 1)把抽象类和接口(java7、java8、java9)的定义,内部结构解释说明 2)类:单继承性 接口:多继承性 类与接口:多实现 ...
  • Java提供和支持创建抽象类和接口。它们的实现有共同点,不同点在于: (JDK1.7) 接口中所有的方法隐含的都是抽象的。而抽象类则可以同时包含抽象和非抽象的方法。 类可以实现很多个接口,但是只能继承一个抽象类 ...
  • 含有abstract修饰符的class 即为抽象类。abstract类不能创建实例对象;含有abstract的方法的类必须定义为abstract class ;abstract class 里的方法不必是抽象的;抽象类中定义抽象方法必须放在具体子类中实现;所以...
  • 面试题--抽象类和接口的区别

    千次阅读 2016-06-10 09:38:43
    抽象类和接口中都可以包含静态成员变量。 C.一个类可以实现多个接口,但只能继承一个抽象类 D.抽象类中可以包含非抽象的普通方法,接口中的方法必须是抽象的,不能有非抽象的普通方法。接口(interface)可以说成...
  • 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类
  • 接口和抽象类的区别(面试题

    千次阅读 多人点赞 2020-12-02 09:46:11
    抽象类和接口中都可以没有抽象方法 接口和抽象类都不能直接创建对象 接口和抽象类都可以利用多态操作 抽象类和接口的子类都必须实现里面的抽象方法 jdk1.8以后,接口和抽象类都可以拥有带有方法体的方法 不同点 ...
  • 在类之间,常见的关系有三种: 依赖(“uses-a”) 聚合(“has-a”) ...5、如果一个子类实现了父类(抽象类)的所有抽象方法,那么该子类可以不必是抽象类,否则就是抽象类;6、抽象类中的抽象方法只
  • 接口抽象类的联系与区别 接口 抽象类 联系 1.都不能被实例化; 2.都位于继承树的顶端,用于被其他类实现继承; 3.都可以包含抽象方法,实现接口或继承抽象类的普通子类都必须实现这些...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,421
精华内容 568
关键字:

抽象类和接口面试题