精华内容
下载资源
问答
  • java程序设计语言提供了两种机制,可以用来定义允许多个实现的类型:接口和抽象。这两种机制之间最明显的区别在于,抽象允许包含某些方法的实现,但是接口不允许,一个更重要的区别在于,为了实现抽象定义的类型...

    java程序设计语言提供了两种机制,可以用来定义允许多个实现的类型:接口和抽象类。这两种机制之间最明显的区别在于,抽象类允许包含某些方法的实现,但是接口不允许,一个更重要的区别在于,为了实现抽象定义的类型,类必须成为抽象类的子类,任何一个类,只要它定义了所有必要的方法,并且遵守通用约定,它就被允许实现一个接口,而不管这个类是处于类层次的那个位置。可以Java只允许单继承,所以抽象类作为类型定义受到了极大的限制。

    现有的类可以很容易被更新,以实现新的接口。
    如果这些方法尚不存在,你需要做的就只是增加必要的方法,然后在类的声明中增加一个implement子句。
    如果你希望实现两个类扩展同一个类的抽象类,就必须把抽象类放到类型层次的高处,以便这两个类的一个祖先成为它的子类。遗憾的是,这样做会间接的伤害到类层次,迫使这个公共祖先的所有的后代类都扩展了这个新的抽象类,无论它对于这些后代类是否合适。

    接口是定义mixin(混合类型)的理想选择。
    不严格的来讲,mixin是指这样的类型:类除了实现它的“基本类型”之外,还可以实现这个mixin类型,以表明它提供了某些可选择的行为。这样的接口之所以被称为mixin,是因为它允许任选的功能可被混合到类型的主要功能中。抽象类不能够被定义为mixin,同样也是因为它们不能被更新到现有的类:类不可能有一个以上的父类,类层次结构中也没有适当的地方来插入mixin。

    接口允许我们构造非层次结构的类型框架。
    类型层次对于组织某些事物是非常合适的。但是其他有些事物并不能被整齐地组织成一个严格的层次结构。

    例:假设我们有一个接口代表一个singer,另一个接口代表一个songweiter。

    public interface Singer{
     AudioClip sing(Song s);
    }
    public interface Songwriter{
     Song compose(boolean hit);
    }

    在现实生活中,有些歌唱家本身也是作曲家。因为我们使用了接口而不是抽象类来定义这些类型,所以对于单个类而言,它同时实现Singer和Songwriter是允许的,实际上我们可以定义第三个接口,他同时扩展了Singer和Songwriter,并添加了一些适合于这种组合的新方法:

    public interface SingerSongwriter extends Singer, Songwriter{
     AudioClip strum();
     void actSensitive();
    }
    

    你并不是总是需要这种灵活性,但是一旦你这样做了,接口可就成为了救世主,能帮助你解决大问题。另外一种做法是编写一个臃肿的类层次,对于每一种要被支持的属性组合,都包含一个单独的类。如果在整个类型系统中有n个属性,那么必须支持2^n种可能的组合。这种现象被称为“组合爆炸”。类层次的臃肿也导致类也臃肿,这些类也包含许多方法,并且这些方法只是在参数的类型上有所不同而已,因为类层次中没有任何类型体现公共的行为特征。

    通过第16条中介绍的包装类模式,接口是个安全的增加类的功能称为可能。如果使用抽象类来定义类型,那么程序员除了使用继承的手段来增加功能,没有其他的选择,这样得到的类与包装相比,功能更差,也更加脆弱。

    虽然接口不允许包含方法的实现,但是接口来定义类型并不妨碍你为程序员提供实现上的帮助。通过对你导出的每个重要接口都提供一个抽象的骨架实现类。把接口和抽象类的优点结合起来。接口的作用仍然是定义类型,但是骨架实现类接管了所有与接口实现相关的工作。

    按照惯例,骨架实现被称为AbstractInterface,这里的Interface是指所是实现的接口的名字。例如Collections、Framework为每个重要的集合接口都提供了一个骨架实现,包括AbstractCollection、AbstractSet、AbstractList和AbstractMap。将他们称作SkeletalCollection、SkeletalSeet、SkeletalList和SkeletalMap也是有道理的,但是现在Abstract的用法已经根深蒂固。

    如果设计得当,骨架实现可以使程序员很容易提供他们的接口实现。

    例:一个静态工厂方法,它包括一个完整的,功能全面的List实现:

    //Concrete implementation built atop skeletak implementation
    static List<Integer> intArrayAsList(final int[] a){
        if(a == null )
            throw new NullPointerException();
        return new AbstractList<Integer>(){
            public Integer get(int i){
                return a[i];//Autoboxing (Item s)
            }
    
            @Override
            public Integer set(int i,Integer val){
                int oldVal=a[i];
                a[i]=val;//Anto-unboxing
                return oldVal;//Antoboxing
            }
            public int size(){
                return a.length;
            }
        };
    }

    当你考虑一个List实现应该为你完成那些工作的时候,可以看出,这个例子充分演示了骨架实现的强大功能。

    骨架实现的美妙之处在于,它们为抽象类提供了实现上的帮助,但又不强加“抽象类被用作类型定义时”所特有的严格限制。对于接口的大多数实现来讲,扩展骨架实现类是个很明显的选择,但不是必须的。如果预置的类无法扩展骨架实现类,这个类始终可以手工实现这个接口。此外,骨架实现类仍然能够有助于接口的实现。实现这个接口的类可以把对于接口方法的调用,转发到一个内部私有类的实例上,这个内部私有类扩展了骨架实现类。这种方法被称作模拟多态继承,它与第16条中讨论的包装类模式密切相关。这项技术具有多重继承的绝大多数有点,同时又避免了相应的缺陷。

    编写骨架实现类相对比较简单,只是有点单调乏味。首先,必须认真研究接口,并确定哪些方法是最为基本的,其他方法则可以根据它们来实现。这些基本方法将成为骨架实现类中的抽象方法。然后,必须为接口中的所有其他的方法提供具体实现。

    例:Map.Entry接口的骨架实现类

    public abstract class AbstractMapEntry<K, V> implements Map.Entry<K, V> {
        //Primitive operations
        public abstract K getKey();
    
        public abstract V getValue();
    
        //Entries in modifiable maps must override this method
        public V setValue(V value) {
            throw new UnsupportedOperationException();
        }
    
        //Implements the general contract of Map.Entry.equals
        @Override
        public boolean equals(Object obj) {
            if (obj == this) {
                return true;
            }
            if (!(obj instanceof Map.Entry)) return false;
            Map.Entry<?, ?> arg = (Map.Entry<?, ?>) obj;
            return equals(getKey(), arg.getKey())
                    && equals(getValue(), arg.getValue());
        }
    
        private static boolean equals(Object o1, Object o2) {
            return o1 == null ? o2 == null : o1.equals(o2);
        }
    
        //Implements the general contract of Map.Entry.equals
        @Override
        public int hashCode() {
            return hashCode(getKey()) ^ hashCode(getValue());
        }
    
        private static int hashCode(Object obj) {
            return obj == null ? 0 : obj.hashCode();
        }
    }

    **因为骨架实现类是为了继承的目的而设计的,所以应该遵守第17条中介绍的所有关于设计和文档的指导原则。
    骨架实现有个小小不的不同,就是简单实现(simple implementation),**AbstractMap.SimpleEntry就是个例子。简单实现就像个骨架实现,这是因为它实现了接口,并且是为了继承而设计的,但是区别在于它不是抽象的:它是最简单的可能的有效实现。你可以原封不动的使用,也可以看情况将它子类化。

    抽象类相对于接口有一个优势:抽象类的演变比接口的演变要容易的多。如果在后续的发行版本中,你希望在抽象类中增加新的方法,始终可以增加具体方法,它包含合理的默认实现。然后,该抽象类的所有实现都将提供这个新的方法。对于接口,这样做是行不通的。因此设计共有接口要非常谨慎,接口一旦被公开发行,并且已被广泛实现,在想改变这个接口几乎是不可能的。

    展开全文
  • Java中抽象类和接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    Java中,可以通过两种形式来体现OOP的抽象:接口和抽象。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口...

    对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口和抽象类。

    一、抽象类

    在了解抽象类之前,先来了解一下抽象方法。抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为:

    abstract void fun();

    抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法,则称这个类为抽象类,抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象。

    下面要注意一个问题:在《JAVA编程思想》一书中,将抽象类定义为“包含抽象方法的类”,但是后面发现如果一个类不包含抽象方法,只是用abstract修饰的话也是抽象类。也就是说抽象类不一定必须含有抽象方法。个人觉得这个属于钻牛角尖的问题吧,因为如果一个抽象类不包含任何抽象方法,为何还要设计为抽象类?所以暂且记住这个概念吧,不必去深究为什么。

    [public] abstract class ClassName {
    
        abstract void fun();
    
    }

     从这里可以看出,抽象类就是为了继承而存在的,如果你定义了一个抽象类,却不去继承它,那么等于白白创建了这个抽象类,因为你不能用它来做任何事情。对于一个父类,如果它的某个方法在父类中实现出来没有任何意义,必须根据子类的实际需求来进行不同的实现,那么就可以将这个方法声明为abstract方法,此时这个类也就成为abstract类了。

    包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。注意,抽象类和普通类的主要有三点区别:

    • 抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public。
    • 抽象类不能用来创建对象;
    • 如果一个类继承于一个抽象类,则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。

    在其他方面,抽象类和普通的类并没有区别。

    二、接口

    接口,英文称作interface,在软件工程中,接口泛指供别人调用的方法或者函数。从这里,我们可以体会到Java语言设计者的初衷,它是对行为的抽象。在Java中,定一个接口的形式如下:

    [public] interface InterfaceName {
    
     
    
    }

    接口中可以含有 变量和方法。但是要注意,接口中的变量会被隐式地指定为public static final变量(并且只能是public static final变量,用private修饰会报编译错误),而方法会被隐式地指定为public abstract方法且只能是public abstract方法(用其他关键字,比如private、protected、static、 final等修饰会报编译错误),并且接口中所有的方法不能有具体的实现,也就是说,接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别,接口是一种极度抽象的类型,它比抽象类更加“抽象”,并且一般情况下不在接口中定义变量。

    要让一个类遵循某组特地的接口需要使用implements关键字,具体格式如下:

    class ClassName implements Interface1,Interface2,[....]{
    
    }

    可以看出,允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口,就必须实现该接口中的所有方法。对于遵循某个接口的抽象类,可以不实现该接口中的抽象方法。

    三、抽象类和接口的区别

    1.语法层面上的区别

    • 抽象类可以提供成员方法的实现细节,而接口中只能存在public abstract 方法;
    • 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的;
    • 接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块和静态方法;
    • 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    2.设计层面上的区别

    1)抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。举个简单的例子,飞机和鸟是不同类的事物,但是它们都有一个共性,就是都会飞。那么在设计的时候,可以将飞机设计为一个类Airplane,将鸟设计为一个类Bird,但是不能将 飞行 这个特性也设计为类,因此它只是一个行为特性,并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly,包含方法fly( ),然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机,比如战斗机、民用飞机等直接继承Airplane即可,对于鸟也是类似的,不同种类的鸟直接继承Bird类即可。从这里可以看出,继承是一个 "是不是"的关系,而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系,比如鸟是否能飞(或者是否具备飞行这个特点),能飞行则可以实现这个接口,不能飞行就不实现这个接口。

    2)设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。而接口是一种行为规范,它是一种辐射式设计。什么是模板式设计?最简单例子,大家都用过ppt里面的模板,如果用模板A设计了ppt B和ppt C,ppt B和ppt C公共的部分就是模板A了,如果它们的公共部分需要改动,则只需要改动模板A就可以了,不需要重新对ppt B和ppt C进行改动。而辐射式设计,比如某个电梯都装了某种报警器,一旦要更新报警器,就必须全部更新。也就是说对于抽象类,如果需要添加新的方法,可以直接在抽象类中添加具体的实现,子类可以不进行变更;而对于接口则不行,如果接口进行了变更,则所有实现这个接口的类都必须进行相应的改动。

    下面看一个网上流传最广泛的例子:门和警报的例子:门都有open( )和close( )两个动作,此时我们可以定义通过抽象类和接口来定义这个抽象概念:

    abstract class Door {
    
        public abstract void open();
    
        public abstract void close();
    
    }

    或者:

    interface Door {
    
        public abstract void open();
    
        public abstract void close();
    
    }

    但是现在如果我们需要门具有报警alarm( )的功能,那么该如何实现?下面提供两种思路:

    1)将这三个功能都放在抽象类里面,但是这样一来所有继承于这个抽象类的子类都具备了报警功能,但是有的门并不一定具备报警功能;

    2)将这三个功能都放在接口里面,需要用到报警功能的类就需要实现这个接口中的open( )和close( ),也许这个类根本就不具备open( )和close( )这两个功能,比如火灾报警器。

    从这里可以看出, Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为,open()和close()属于门本身固有的行为特性,而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口,包含alarm()行为,Door设计为单独的一个抽象类,包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

    interface Alram {
    
        void alarm();
    
    }
    
     
    
    abstract class Door {
    
        void open();
    
        void close();
    
    }
    
     
    
    class AlarmDoor extends Door implements Alarm {
    
        void oepn() {
    
          //....
    
        }
    
        void close() {
    
          //....
    
        }
    
        void alarm() {
    
          //....
    
        }
    
    }

    最后再用一个表格的形式来总结一下抽象类和接口的区别:

    参数抽象类接口
    默认的方法实现它可以有默认的方法实现接口完全是抽象的。它根本不存在方法的实现
    实现子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
    构造器抽象类可以有构造器接口不能有构造器
    与正常Java类的区别除了你不能实例化抽象类之外,它和普通Java类没有任何区别接口是完全不同的类型
    访问修饰符抽象方法可以有publicprotecteddefault这些修饰符接口方法默认修饰符是public。你不可以使用其它修饰符。
    main方法抽象方法可以有main方法并且我们可以运行它接口没有main方法,因此我们不能运行它。
    多继承抽象方法可以继承一个类和实现多个接口接口只可以继承一个或多个其它接口
    速度它比接口速度要快接口是稍微有点慢的,因为它需要时间去寻找在类中实现的方法。
    添加新方法如果你往抽象类中添加新的方法,你可以给它提供默认的实现。因此你不需要改变你现在的代码。如果你往接口中添加方法,那么你必须改变实现该接口的类。

     我有一个微信公众号,经常会分享一些Java技术相关的干货;如果你喜欢我的分享,可以用微信搜索“Java团长”或者“javatuanzhang”关注。

    展开全文
  • java接口和类

    千次阅读 2018-06-15 09:00:07
    是具有相同属性服务的一组对象的集合。为属于该的所有对象提供了统一的抽象描述,其内部包括属性服务两个主要部分。在面向对象的编程语言中,是一个独立的程序单位,应该有一个类名并包括属性说明...

    类:

    类是具有相同属性和服务的一组对象的集合。为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分。在面向对象的编程语言中,类是一个独立的程序单位,应该有一个类名并包括属性说明和服务说明两个主要部分。

    接口的功能:

    (1) 通过接口可以实现不相干类的相同行为而不需考虑这些类之间的层次关系。

    (2) 通过接口可以实现多继承机制。

    (3) 通过接口可以了解对象的交互界面而不需了解对象所对应的类。

    接口和类之间的区别:

    (1)类只能继承一个类,而对于接口,可以实现继承多个接口。
    (2)对于继承性,类继承了父类的方法,子类可以选择是否覆盖父类的方法。
    (3)接口的方法没有实现,因此,类必须实现接口中的每个方法。

    展开全文
  • 类和接口Java程序设计语言的核心,也是java语言的基本抽象单位。java语言提供许多强大基本元素,供我们来设计接口。怎么才能设计出更加有用,健壮灵活的类和接口? 首先区别设计良好的模块与设计不好的模块...
    类和接口是Java程序设计语言的核心,也是java语言的基本抽象单位。java语言提供许多强大基本元素,供我们来设计接口。怎么才能设计出更加有用,健壮和灵活的类和接口?
    


    首先区别设计良好的模块与设计不好的模块,区别的因素就是该模块对于外部的其他模块而言,是否隐藏其内部数据和其他实现细节。


    软件设计的基本原则: 封装/信息隐藏:设计良好的模块会隐藏所有的实现细节,把他的API与它的实现清晰地分隔,模块之间只能通过他们的API进行通信,不需要知道其他模块的内部工作情况。


    正确的使用修饰符对于实现信息隐藏是非常关键:
    private --该成员的顶层类内部才可以访问。

    package-private(缺省) --该成员包内部的任何类可以访问。

    protected --该成员的类与子类可以访问这个成员,并且该成员包内部的任何类也可以访问。

    public --任何地方度可以访问

    总而言之,我们应该始终尽可能的降低可访问性。
    展开全文
  • java接口和类的区别

    千次阅读 2018-11-02 19:49:57
    接口(interface)在java语言中就是一个抽象类型,但接口并不是一个抽象,是抽象方法的集合,接口通常以interface来声明。一个通过继承接口的方式,从而来继承接口的抽象方法。使用方法为: implement 接口名 ...
  • 实现接口时,接口就充当可以引用这个类型的实例的类型。因此,实现了接口,就表明客户端可以对这个的实例实施某些动作。为了任何其他目的而定义接口时不恰当的。 有一种叫做常量接口,他不满足上面的条件...
  • 抽象类和具体是相对的概念。“抽象”是一种存在思想逻辑中的概念,而“具体”是一种可见可触摸的现实对象。简单说,比如“人”比“男人”抽象一点,“动物”又比“人”更抽象一点,而“生物”又比“动物”更抽象。...
  • java抽象类和接口

    千次阅读 2019-05-14 17:34:15
    java抽象类和接口 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具与关键技术:MyEclipse10 作者:朱海恩 撰写时间: 2019.04.30 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
  • 继承指的是一个(称为子类、子接口)继承另外的一个(父类、父接口)的功能,并可以增加它自己的新功能的能力。在java中继承关系通过关键字extends明确标识,在设计时一般没有争议性。在UML类图设计中,继承用...
  • java接口的区别

    千次阅读 2019-06-17 14:29:40
    java接口的区别 解决方法: 1.接口没有构造方法,不能用于实例化对象。 2.接口中所有的方法必须是抽象方法。 3.http://www.yayihouse.com/yayishuwu/chapter/1975 ...
  • Java抽象类和接口的区别

    千次阅读 2020-02-09 16:56:31
    抽象:如果一个含有抽象方法(抽象方法是一种特殊的方法,它只有声明,而没有具体的实现),则称这个为抽象,...包含抽象方法的称为抽象,但并不意味着抽象中只能有抽象方法,它普通一样,同样...
  • Java类的继承、接口的继承实现

    千次阅读 2017-04-23 17:08:47
    Java接口有继承实现两个概念,接口可以继承另一个接口,并获得其父接口里的所有方法成员变量,接口也可以被一个实现,实现接口需要实现接口及其父接口里的所有抽象方法,怎么理解呢? (1)如果...
  • Java接口

    千次阅读 多人点赞 2018-12-24 12:00:36
    java中的接口的蓝图。 它有静态常量抽象方法。java中的接口是一种实现抽象的机制。 接口中只有抽象方法而不是方法体。接口用于在Java中实现抽象多重继承。Java接口也表示IS-A关系。它不能像抽象一样被实例...
  • 开心一笑【刚在路上遇到一只狗,我蹲下来问它:我2017年的运势,它慎重考虑了下说:旺旺旺,这下我就放心了……】提出问题java中的嵌套接口和嵌套???解决问题接口嵌套接口/** * 花(接口嵌套接口) */ interface...
  • Java高级系列——如何设计类和接口

    万次阅读 2018-01-06 14:27:55
    一、介绍 无论你使用哪一种编程语言(在这里Java也不排除),遵循一种好的设计规则对于写出清晰、易于理解、可测试、长生命周期...确切的讲,我们将会讨论接口(interfaces)和接口默认方法(interfaces with default
  • class Square extends Rectangle{ Square(double side){ super(side,side); } }
  • java找到指定接口的实现

    千次阅读 2020-02-10 13:30:20
    一、背景 想在自己开发的项目上加一个算法工具用来...因此开始在学习如何实现,在学习过程中发现需要写一个方法用来找到指定接口的实现,因此开启了这趟学习之旅。 二、寻求答案的路途 刚开始看到根据指定接...
  • Arrays.sort(stringArray, new Comparator<T>() { @Override public int compare(String s1, String s2) { // TODO Auto-generated method stub return s1.length() - s2.length(); } ...
  • java接口和抽象的区别

    万次阅读 多人点赞 2018-09-21 23:18:35
    接口和抽象的区别? 接口(interface)和抽象(abstract class)是支持抽象定义的两种机制。 接口是公开的,不能有私有的方法或变量,接口中的所有方法都没有方法体,通过关键字interface实现。 抽象是可以有...
  • java中的内部内部接口详解

    千次阅读 2020-05-08 06:24:42
    一般来说,我们创建类和接口的时候都是一个一个文件,一个接口一个文件,但有时候为了方便或者某些特殊的原因,java并不介意在一个文件中写多个类和多个接口,这就有了我们今天要讲的内部类和内部接口。...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JREJDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序小程序的...
  • Java 枚举类和自定义枚举类和enum声明及实现接口1.枚举1.枚举的属性2.自定义枚举2.Enum枚举3.实现接口的枚举 1.枚举 注: JDK1.5之前需要自定义枚举 JDK 1.5 新增的 enum 关键字用于定义枚举 ...
  • JAVA接口练习题

    千次阅读 2018-10-30 16:35:55
    在classB中覆写了抽象A的g方法,还定义了接口A的方法,最终在main函数中,向上实例化一个抽象A的实例a,一个接口A的实例b,通过a,b来调用他们各自的方法,则输出一个good(来自a.g())一个(空格) ...
  • 首先抽象归根结底还是属于,对于抽象方法,是只能存在于抽象中的,我们无法再一个非抽象的中声明一个抽象方法,其次抽象方法只需要声明,并不需要事先。当我们要写一个抽象的时候只需要在的前面声明为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,814,501
精华内容 725,800
关键字:

java类和接口

java 订阅