精华内容
下载资源
问答
  • 1.简介java的四大特性:继承抽象,封装,多态封装我们大多只知道get、set方法,其实他主要是为了隐藏对象属性,保证有些属性只存在内部,而不被其他修改或这使用多态我个人理解是特性与共性的关系,子类可以有...

    1.简介java的四大特性:继承,抽象,封装,多态

    封装我们大多只知道get、set方法,其实他主要是为了隐藏对象属性,保证有些属性只存在类内部,而不被其他类修改或这使用

    多态我个人理解是特性与共性的关系,子类可以有父类的属性与方法,但同时他也应该有自己的属性和方法,有时子类中拥有的父类方法不是他想要的,他就可以重写这些方法,或者编写特有的方法

    抽象就是把属性和方法抽出来,只声明而不实现,最常见的就是接口的使用

    而继承是大家最常见的,就不多说了,但是大家需要知道的是父类转换为子类并不是类型安全的,需要强制转换,而子类转换为父类会丢失自己特有的属性和方法

    2.继承的使用先看代码

    /**

    * @ClassName: Test01

    * @Description: 不是用接口,用继承的特性使两个对象有同名方法

    * @author: h

    * @date: 2017年3月16日 下午3:08:32

    */

    public class Test01 {

    /**

    * @Title: process

    * @param p

    * 传入一个{@link Father}类的对象

    * @param input

    * 需要说的一句话

    * @return: void

    */

    public static void carry(Father p, String input) {

    System.out.println("调用对象名:" + p.name());

    System.out.println(p.talk(input));

    }

    public static void main(String[] args) {

    carry(new Son(), TestUtils.GMS);

    carry(new Daughter(), TestUtils.GMS);

    }

    }

    class Father {

    public String name() {

    return getClass().getSimpleName();

    }

    String talk(String s) {

    return s;

    }

    }

    class Son extends Father {

    @Override

    String talk(String input) {

    return input.toUpperCase();

    }

    }

    class Daughter extends Father {

    @Override

    String talk(String input) {

    return Arrays.toString(input.split(" "));

    }

    }

    可以看出,父类拥有的方法,子类都有,并且子类可以重写他们,这里不建议父子类间的转换,我认为父子类更应该放在泛型约束中使用,这点我会在其他文章中另说

    3.接口的使用/**

    * @ClassName: Test02

    * @Description: 每个对象只能继承一个对象,而对象间的共性和特性是有交集、并集、相离等情况的,

    * 不可能有一个父类满足这些,所以用到接口

    * @author: h

    * @date: 2017年3月16日 下午3:14:19

    */

    public class Test02 {

    /**

    * @Title: process

    * @param p

    * 传入接口特性{@link TalkPower},具体的执行过程在实现类中搞定

    * @param input

    * 需要说的话

    * @return: void

    */

    public static void carry(TalkPower p, String input) {

    System.out.println("调用对象名:" + p.getClass().getName());

    System.out.println(p.talk(input));

    }

    public static void main(String[] args) {

    carry(new People(), TestUtils.GMS);

    carry(new Anima(), TestUtils.GMS);

    }

    }

    interface TalkPower {

    String talk(String input);

    }

    class People implements TalkPower {

    @Override

    public String talk(String input) {

    return input.toUpperCase();

    }

    }

    class Anima implements TalkPower {

    @Override

    public String talk(String input) {

    return Arrays.toString(input.split(" "));

    }

    }

    也是很简单的例子,对象都实现了同一个接口,我们可以直接声明接口的类型为泛型,在具体实例化的时候使用实现了这个接口的类

    4.简述其实接口和继承都可以很好的形成一种规范,但类只能继承一个,接口可以多个实现,我认为父类主要的是他提供了一个方法,并提供了一种默认的实现代码,而接口往往只声明了方法,不存在方法的实现(java8中可以有默认方法了,但用在函数式编程中),这么设计意在形成一种规范,同时也是为了解决java不可以以方法为参数进行传递的设计

    例如,我们可以在编写方法是要求传入的是某个接口,然后在方法中调用接口的方法,然后再让一些类实现这个接口,并完善各自的方法,然后将这些类作为参数传递给之前的方法,这也就形成了一个代码的传递

    接口和继承还能和泛型有很好的配合,给代码提供更好的规范作用,减少异常的产生

    展开全文
  • 如何使用抽象类:抽象类的使用可以通过继承来实现,也就是使用extends关键字,同时继承了抽象类的子类,必须实现抽象类的抽象方法...2、使用了抽象类和接口的子类,必须实现其中的抽象方法。 3、抽象类中的抽象方法访
    如何使用抽象类:抽象类的使用可以通过继承来实现,也就是使用extends关键字,同时继承了抽象类的子类,必须实现抽象类的抽象方法。
    如何使用接口:可以通过关键字implements来实现,这个词也是“实现”的意思,同样,实现接口的类,必须要实现接口中所有的抽象方法。
    补充内容:
    1、抽象类与接口不能被实例化
    2、使用了抽象类和接口的子类,必须实现其中的抽象方法。
    3、抽象类中的抽象方法访问修饰符不能为private,接口中的抽象方法访问修饰符必须为public。
    抽象类,使用abstract 修饰符来定义,它可以拥有抽象方法与普通方法,抽象方法不能使用private修饰。
    接口,使用interface关键字来定义,接口中只能拥有抽象方法,并且,抽象方法只能使用public来修饰。
    使用抽象类和接口的时候需要注意:抽象类与接口不能实例化,继承抽象类或者实现接口的子类,必须实现其中的抽象方法。
    抽象类与接口的作用:
    抽象类便于复用,接口便于代码维护,在今后的开发设计当中,需要记住面相对象设计的几个原则:
    1、多用组合,少用继承。
    2、针对接口编程。
    3、针对扩展开发。
    4、针对改变关闭。 
    展开全文
  • Java笔记:抽象类和接口抽象类接口接口多重实现接口继承接口嵌套接口工厂模式 抽象类 在普通类中,一个类必须实现自身写的所有方法,每个方法必须含有自己的方法体。即便先创建一个父类,再由后续的类去继承该类,...

    抽象类

    在普通类中,一个类必须实现自身写的所有方法,每个方法必须含有自己的方法体。即便先创建一个父类,再由后续的类去继承该类,父类所有方法也必须如此。倘若创建该父类只是为了构造一个后续类的模板,那么可以考虑抽象类,仅仅说明要怎么做并且把具体步骤放到实现该抽象类的类中:含有抽象方法的类叫做抽象类,同时只有抽象类才能含有抽象方法,抽象类也可含有普通方法。例如:

    abstract class animal{
    
        int age;
        String name;
    
        animal(String name, int age){
            this.age = age;
            this.name = name;
        }
    
        abstract void canMove(int stepNum);
    
        public void eat(){
    
        }
    
    }
    

    可见,一个抽象类可以含有成员变量、构造方法、抽象方法和普通方法。abstract只能修饰类(将其变为抽象类)、普通方法(将其变为抽象方法),而不能修饰成员变量和构造方法。同时抽象方法不能含有方法体,即{},参数列表则有无皆可。尝试一下直接用抽象类new对象:

    //!animal theAnimal = new animal("puppy", 5);
    animal dog = new animal("puppy", 5) {
        @Override
        void canMove(int stepNum) {
            System.out.println(this.name + " walks " + stepNum  + " steps.");
        }
    };
    dog.canMove(5);
    
    //!animal theNewAnimal = new animal("kitty", 6);
    animal cat = new animal("kitty", 6){
        @Override
        void canMove(int stepNum){
            System.out.println(this.name + " jumps " + stepNum + " steps");
        }
    };
    cat.canMove(5);
    
    

    显然,抽象类不可以直接生成对象,而可以在生成对象时同时采用内部类的方法重写抽象类的抽象函数达到实现该抽象类的方法,使得生成的当前一个对象可以使用新生成的没有名字但的确实现了抽象类的类,但因为其作用域只在生成对象的语句内,所以一次只能作用于当前的一个对象,后续的对象无法使用前面依照如此改动的类。也能凭此创造出仅对应该对象的类,且该类定义的对象只在该语句中才出现。
    并且通过以上的例子可以看出:抽象类想要生成对象,就必须用其他类通过方法重写(需依照重写规则)实现其抽象方法。同时子类在自己的构造方法中可使用super(参数列表)调用被继承的抽象类的构造方法,不可仅有抽象类含有构造方法而子类没有构造方法。若抽象类和子类都没有构造方法,自动使用无参构造方法。上面的例子凑巧用似乎是内部类的方式写出了隐式实现抽象类的方式,显式继承抽象类的方式见下:

    class dog extends animal{
    
        public dog(String name, int age){
            super(name, age);
        }
    
        @Override
        void canMove(int stepNum) {
            System.out.println(this.name + " runs " + stepNum + " steps. ");
        }
    }
    
    

    接口

    用interface声明的更加抽象的类,其成员变量、包含域默认由static、final修饰,归类所有且不可更改;其方法都是抽象方法,没有任何实现,且不能被private或static修饰,默认为public类型,也可在接口中显式声明出来。类想要实现借口,需使用implements关键字,方法需为public。创建接口和接口实例化例子如下:

    interface eatAble{
        void canBeEaten();
    }
    
    class apple implements eatAble{
         public void canBeEaten(){
             System.out.println(this + " can be eaten");
        }
        public String toString(){
             return "apple";
        }
    }
    
    class banana implements eatAble{
        public void canBeEaten(){
            System.out.println(this + " can be eaten");
        }
        public String toString(){
            return "banana";
        }
    }
    
    

    接口为每个实现该接口的类提供相同的方法,保证实现了该接口的类的一定程度的统一,类似继承中子类对父类方法的重写。

    接口多重实现

    在Java中继承关系是不允许多继承的,即一个子类含有多个父类,因为若多个父类中含有相同的成员变量、域或方法,子类若继承多个父类时若要调用相同域会出现歧义(菱形继承),而在Java中一个类可以实现多个接口,因为接口没有任何具体的实现。在例子中写父类Fruit被grape类继承,同时grape类实现eatAble、colorful两个接口。

    class Fruit{
        public void ripe(){
            System.out.println("The Fruit is ripe.");
        }
    }
    
    interface colorful{
        
        int trick = 1;
        void hasColor();
    }
    
    interface colourful{
        
        int trick = 2;
        void hasColor();
    }
    
    class grape extends Fruit implements eatAble, colorful, colourful{
    
    int trick = colorful.trick;
    
        @Override
        public void hasColor() {
            System.out.println(this + " is purple.");
        }
    
        @Override
        public void canBeEaten() {
            System.out.println(this + " can be eaten.");
        }
    
        @Override
        public String toString() {
            return "grape";
        }
    
        @Override
        public void ripe() {
            System.out.println(this + "is ripe");
        }
    }
    
    

    尝试了以下接口多实现,且colorful、colourful接口含有相同的待实现方法hasColor()(同void类型),且含有相同名称的已赋值的变量trick。若grape同时implements两个接口且重写该方法,则两个接口同时被实现,毕竟存在于接口中的方法为没有方法体、待实现的抽象方法,所以即使接口内方法重名,也需要实现了该接口的类去实现该方法。但当grape想创建成员变量trick时,就必须声明该trick具体来自于哪个接口,应注意此处的trick不过是grape类中的一个普通成员变量,此时未被任何修饰符修饰,仅仅将colorful接口中的trick值赋给了它而已,在其他地方仍可对其进行修改。

    若类要实现的两个接口含有相同名称的成员变量和方法,但成员变量数据类型以及方法返回值不同,再与继承相混用,成员变量的变化不难判断,如上文,需要声明变量具体来自哪个接口。为观察方法的代码见下(摘自《Java编程思想》):

    interface I1{
        void f();
    }
    
    interface I2{
        int f(int i);
    }
    
    interface I3{
        int f();
    }
    
    class C1{
        int f(){
            return 1;
        }
    }
    
    class poorGuy1 implements I1, I2{
    
        @Override
        public void f() {
    
        }
    
        @Override
        public int f(int i) {//also overload method "public void f()"
            return 0;
        }
    }
    
    class poorGuy2 extends C1 implements I2{
        @Override
        public int f(int i) {
            return 0;
        }
    }
    
    class poorGuy3 extends C1 implements I3{
        @Override
        public int f() {
            return 0;
        }
    }
    
    // !  class poorGuy4 extends C1 implements I1{ public void f() {}}
    // !  interface I4 extends I1,I3{void f();}
    
    

    在类poorGuy1中,poorGuy1实现了接口I1、I2,两者拥有相同名称的方法f(),虽然返回类型不同,但因参数不同可以将两个方法区分开。poorGuy2继承了C1且实现了I2接口,也可通过参数不同确定重写的方法是来自于继承父类还是实现接口。poorGuy3继承C1实现I3接口,父类方法与接口内含有的抽象方法重名、返回类型相同且参数列表相同(都为空),写出无参方法f(),即可完成对要实现接口抽象类的抽象方法的重写。然而要实现抽象方法的类或接口其抽象方法不可冲突,即返回类型不同且参数列表相同,因为如此类或对象便不能根据传入参数决定调用的方法。所以为避免如此情况的发生,应让方法的命名多样化。

    接口继承接口

    通过接口继承接口,位置位于子类的接口便可获得“父类”接口的方法及成员变量,便实现了扩展接口。

    interface delicious extends eatAble{
    //    void canBeEaten();
        void isDelicious();
    }
    
    

    写出一个接口delicious继承eatAble,同时接口中重写方法canBeEaten()、添加方法isDelicious(),然而在接口中重写“父类”接口方法并没有具体用处,因为在父类和子类接口中都没有方法的具体实现,实现子接口的类必然要实现父类和子类接口的方法。将canBeEaten()方法注释化,写出meat类实现delicious接口:

    class meat implements delicious{
    
        @Override
        public void canBeEaten() {
            System.out.println(this + " can be eaten.");
        }
    
        @Override
        public void isDelicious() {
            this.canBeEaten();
            System.out.println(this + " is also very delicious");
        }
    
        @Override
        public String toString() {
            return "meat";
        }
    }
    
    
    嵌套接口

    接口可以嵌套在类或其他接口中,即在类或其他接口中定义接口。如此,尝试:接口内的接口、类中的接口、接口中的类。代码如下:

    interface theI1{ interface innerI1{void f();} void g();}
    
    class theC2{interface innerI2{void f();}}
    
    interface theI2{abstract class innerC1{void f(){System.out.println("theI2.innerC1.f()");}}}
    
    class test implements theI1.innerI1{public void f(){}}
    
    class test2 implements theI1{public void g() { }}
    
    

    然而,由于接口内域都为public,所以可以用接口名称加“.”表示所属关系且extends类或implements接口。也可用此方法implements上面代码中theC2类的innerI2。但倘若将类中接口设置为private则只可在该类作用域中实现该接口,因而只能用该类的内部类来实现。

    工厂模式

    不通过new对象而实例化对象的方式。在其他地方创建返回值为该类的方法,通过return方法中new出的对象实现对象的实例化。

    class fruit{
        public void show(){}
    }
    
    class apple extends fruit{
        public void show(){
            System.out.println("this is an apple.");
        }
    }
    
    class pear extends fruit{
        public void show(){
            System.out.println("this is a pear");
        }
    }
    
    class fruitFactory{
        public fruit createFruit(String choice){
            if(choice.equals("apple")){
                return new apple();
            }
            else if(choice.equals("pear")){
                return new pear();
            }
            else{
                System.out.println("null");
                return null;
            }
        }
    }
    
    

    调用:

    fruitFactory fruitFactory = new fruitFactory();
    fruit f1 = fruitFactory.createFruit("apple");
    f1.show();
    
    

    结果为:this is an apple.

    此处可以看到:工厂要生产出来的产品都是继承自同一父类,这样在调用工厂中父类返回值方法时才能返回包含了父类所有域的子类,在由工厂创建实例时,再由父类引用引用子类返回实现类似向上造型的操作。可以看到,f1引用的为apple类的对象。

    展开全文
  • 概念:使用abstract修饰,继承时使用extends,由于抽象的,所以不能创建对象,同时,在的内部的抽象方法无方法体并且要由子类去实现 格式: abstract class 类名{ 权限修饰词 abstract 返回值类型 类名(); } ...

    在eclipse的使用使用中会有些抽象的用法,举个例子,人,“人”是比较抽象的,怎么样才算是“人”呢?会说话是个“人”吗,会跑步是个“人”吗等等,因为这些都是人的特征,所以就有抽象出了“人”的概念

    抽象类

    1. 概念:使用abstract修饰,继承时使用extends,由于类是抽象的,所以不能创建对象,同时,在类的内部的抽象方法无方法体并且要由子类去实现
    2. 格式:
      abstract class 类名{
      权限修饰词 abstract 返回值类型 类名();
      }
    3. 抽象类与普通类的区别:
      (1) 抽象类必须用public或protected修饰(若为private修饰,无法被子类继承,从而无法实现其抽象方法,在默认情况是public)
      (2) 若子类继承了该抽象类则必须要实现抽象类中的抽象方法,否则要将其子类也要定义为抽象类

    那接口是什么呢?其实接口就相当于某团体具备着共同的特征或行为,举个例子,当我们去银行取钱的时候,会有不同的窗口,这些不同的窗口都可以帮你办理业务,因为他们有共同的任务,只不过由不同的窗口去实现

    接口

    1. 概念:使用interface修饰,继承时用implements,由于接口不能有具体的特征,要靠继承的子类去实现,就好像公务员是一个职位,但不同的公务员负责不同的工作
    2. 格式:
      interface 接口名称{
      数据类型 数据名称; //表示为全局常量
      权限修饰词 返回值类型 方法名(); //表示抽象方法
      }
    3. 继承时,接口可以实现多个实现:
      class 子类 implements 接口1,接口2…{
      }
      在与类的继承一起使用时:
      class 子类 extends 父类 implements 接口1,接口2…{
      }
    4. 注意:
      (1) 接口中可拥有变量和方法,但是,不能在接口内部实现,只能由子类实现
      (2) 当接口中有public static final时,则修饰的变量变为常量
      (3) 当接口要使用时,必须通过子类的继承,由子类实现抽象方法的进行使用(当子类为抽象类时,则仍需要抽象类的子类进而实现类与接口中的全部抽象方法)

    抽象类与接口的异同之处

    1. 相同点:
      (1) 两者均不能被实例化
      (2)两者的抽象方法中均不能有具体的实现

    2. 不同点:
      (1) 一个类只能继承一个类,而接口可以是多个,比如:
      在类的继承中:
      class 子类 extends 父类 {
      }
      这种继承的方法是正确的
      class 子类 extends 父类1,父类2,… {
      }
      这种是错误的,子类只能有一个父类,就好比一个儿子只能有一个亲爹

       	而接口:
       	class 子类 implements 接口1,接口2,...{
       	}
       	对接口继承的理解就好比,一个儿子可以有好多个干爹
      

      (2) 在定义时,接口中的变量是公共静态变量(但不能是具体的),而抽象类的是普通变量(可以是具体的)
      (3) 在抽象类中可以有在内部的具体实现方法(指的是普通方法),而在接口中不能有具体的方法(只能有抽象方法)

    展开全文
  • //接口中包含了抽象类和抽象方法 public static final String NAME = "newsainton"; public abstract void fun(); } // 一个类可以继承多个接口,但如果该类不是抽象类的话,则必须实现抽象类中的所有抽象方法 ...
  • 疯狂JAVA讲义

    2014-10-17 13:35:01
    第1章 Java概述 1 1.1 Java语言的发展简史 2 1.2 Java的竞争对手及各自优势 4 ...11.8.1 Image抽象类和BufferedImage实现类 425 11.8.2 使用ImageIO输入/输出位图 427 11.9 剪贴板 432 11.9.1 数据传递的类...
  • 继承被恰当使用时,所有从抽象类导出的类将共享该抽象类接口。这意味着子类仅仅添加 或重定义操作,而没有隐藏父类的操作。这时,所有的子类都能响应抽象类接口中的请求,从而子 类的类型都是抽象类的子类型。 ...
  • java面试宝典

    2013-02-28 16:04:01
    抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)? 12 41、Java接口和C++的虚类的相同不同处。 12 42、一个“.java”源文件中是否可以包含多个类(不是内部类)?有什么限制? 12 ...
  • java面试题典 java 面试题 经典

    热门讨论 2010-06-18 13:42:36
    抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)? 11 22. List, Set, Map是否继承自Collection接口? 11 23. abstract的method是否可同时是static,是否可同时是native,是否可同时是...
  • java 面试题 总结

    2009-09-16 08:45:34
    声明方法的存在而不去实现它的类被叫做抽象类(abstract class),它用于要创建一个体现某些基本行为的类,并为该类声明方法,但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量,其...
  • java面试宝典2012

    2012-12-16 20:43:41
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 16 21、写clone()方法时,通常都有一行代码,是什么? 16 22、面向对象的特征有哪些方面 17 23、...
  • java基础题 很全面

    2009-05-09 09:24:24
    抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)? 10 27. List, Set, Map是否继承自Collection接口? 10 28. abstract的method是否可同时是static,是否可同时是native,是否可同时是...
  • JAVA面试宝典2010

    2011-12-20 16:13:24
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 ...
  • Java面试宝典2012新版

    2012-06-26 19:20:00
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 21、写clone()方法时,通常都有一行代码,是什么? 22、面向对象的特征有哪些方面 23、java中...
  • Java面试笔试资料大全

    热门讨论 2011-07-22 14:33:56
    抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、...
  • List框架图首先上面的框架图可以表明顺序的关联关系,但并不全面,如ArrayList在继承了AbstractList抽象类同时实现了List接口。List是一个接口继承了Collection,同时Collection继承了Iterable,表明List的...
  • 21天学通Java-由浅入深

    2011-06-06 09:59:14
    174 9.1 什么是接口 174 9.1.1 接口的定义 174 9.1.2 访问接口里的常量 176 9.2 接口的使用 177 9.2.1 接口里的方法如何创建 177 9.2.2 接口引用怎么使用 178 9.3 什么是抽象类 180 9.3.1 抽象类的使用特点 ...
  • 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、...
  • 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有一行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、...
  • Java 面试宝典

    2013-02-01 10:02:08
    抽象类是否可实现(implements)接口? 抽象类是否可继 承具体类(concrete class)? 抽象类中是否可以有静态的 main 方法? ...................... 16 21、写 clone()方法时,通常都有一行代码,是什么? ..............
  • 抽象类是否可实现(implements)接口?抽象类是否可继承具体类(concreteclass)?抽象类中是否可以有静态的main方法?.......................................................................2 21、写clone()方法时,...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

java怎么同时继承抽象类和实现接口

java 订阅