精华内容
下载资源
问答
  • Java 抽象类,抽象方法接口

    千次阅读 2015-03-26 20:50:40
    讲述Java中抽象类,抽象方法接口的各种用法。

    抽象类和抽象方法

    在Java中用abstract修饰的类是抽象类,用abstract修饰的类的方法是抽象方法,抽象类和抽象方法用法总结如下。

    1. abstract可以修饰class表示抽象类,可以修饰方法表示抽象方法,但是不能修饰成员变量,也就是没有抽象的成员变量。
    2. 用abstract修饰的类中可以有abstract方法,也可以没有abstract方法;可以有非abstract方法,也可以没有非abstract方法。
    3. 只有abstract类中才能声明abstract方法,abstract方法不能声明在非abstract类中。
    4. abstract类可以是外部类,也可以是内部类。abstract类如果是外部类,不能用private修饰;abstract类如果是内部类,可以用private修饰。
    5. abstract方法不能有方法体,abstract方法必须对其子类可见,即不能用private修饰。

      // abstract类中可以没有abstract方法,但有abstract方法的类必须定义为abstract类
      abstract class C3 {
          // abstract类中可以有成员变量,但成员变量不能用abstract修饰
          private int mPara;
          // abstract方法不能有方法体,abstract方法不能是private
          public abstract void setPara(int para);
          // 抽象类中可以有非抽象方法
          public int getPara(){
              return mPara;
          }
      }
    6. abstract类可以继承自其他类,这个父类可以是abstract类,也可以是非abstract类。如果它继承自abstract类,它可以选择实现其父类中的abstract方法,也可以不实现。

    7. abstract类可以实现一个接口。它可以选择实现接口中的接口方法,也可以不实现。
    8. abstract类只有被继承时才有用,它的子类可以是abstract类,也可以是非abstract类。如果它的子类是abstract类,则会自动继承所有其所有的abstract方法,abstract子类中也可以定义新的abstract方法,如果它的子类是非abstract类,则子类必须实现其所有的abstract方法。
    9. abstract类可以用来定义变量,但不能实例化,也就是不能通过new来构造一个abstract类的对象。abstract类定义的变量可以被赋值为其非abstract子类的对象。
    10. abstract类中可以有构造方法,抽象类的构造方法不能是抽象方法。
    11. abstract类和abstract方法都不能用final修饰。

    接口

    在Java中用interface来定义一个接口,接口用法总结如下。

    1. interface只能用来定义接口,不能用来修饰类,成员变量或成员方法。
    2. interface中可以有成员变量,成员变量一定是public static final的,但允许在声明变量时仅指定部分修饰符。但即使没有添加public,static,final中任何一个修饰符,该变量仍然是public static final的。此外,由于final成员变量必须在定义时初始化,因此,接口类中定义的成员变量必须在定义时赋值。赋值可以用常量表达式,也可以用任意在该接口中能够访问的对象组成的表达式。例如:

      private interface I1 {
          //len是public static final的,len必须被初始化
          int len = String.valueOf(new GregorianCalendar().getTimeInMillis()).length();
      }
    3. interface中的成员变量在实现该接口的类中可以直接使用,在没有实现该接口,但是可见该接口的类中可以通过“接口名.成员变量名”来访问。例如:用I1.len来访问上述例子中的接口中定义的len成员变量。

    4. interface中可以有成员方法,成员方法都是public abstract的抽象方法,不能有方法体。允许声明成员方法时指定部分或不指定修饰符,但即使没有添加public abstract中任何一个修饰符,该成员方法仍然是public abstract的。
    5. 一个接口可以继承自其他接口。接口之间的继承用extends关键字,不能用implements。一个接口可以继承多个其他接口。多个接口之间用逗号分隔。例如:private interface I1 extends I2, I3{}
    6. 一个接口不能继承自任何类,包括抽象类。
    7. 一个非抽象类如果实现了某个接口,它必须要实现该接口中声明的所有的抽象方法。一个抽象类如果实现了某个接口,它可以实现该接口中声明的抽象方法,也可以不实现。
    8. 接口可以用来定义变量,但不能实例化,也就是不能通过new来构造一个接口的对象。接口定义的变量可以被赋值为实现该接口的类的对象。
    9. 接口中没有构造方法。接口不能用final修饰。
    10. 接口中可以定义内部类和内部接口
    展开全文
  • 文章目录抽象方法抽象抽象方法抽象抽象类的概念以及使用为什么需要抽象接口接口的概念接口的使用接口抽象类的区别使用一个人的例子更直观的了解下接口:内部类内部类的概念内部类的作用内部类的分类成员...

    抽象方法和抽象类

    抽象方法

    使用abstract修饰的方法,没有方法体,只有声明。定义的是一种规范,就是告诉子类必须要给抽象方法提供具体的实现(子类也可以部分实现或完全不实现父类的所有抽象方法,但此时子类必须声明为抽象类)。

    抽象类

    抽象类的概念以及使用

    1. 定义了抽象方法的类必须被声明为抽象类,不过抽象类可以没有抽象方法。
    2. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例,只能用来被子类调用。
    3. 抽象类只能用来被继承,不能使用new关键字创建对象。
    4. 子类必须要给抽象方法提供具体的实现,子类也可以部分实现或完全不实现父类的所有抽象方法,但此时子类必须声明为抽象类。

    为什么需要抽象类

    1. 抽象方法和抽象类看起来像是多余的,对于抽象方法,不知道如何实现,定义一个空的方法体不就好了,抽象类不能创建对象,看起来只是添加一个限制条件。
    2. 在Java中引入抽象方法和抽象类,是一种规范体现,对于某些类和方法的使用,能引导使用者正确的使用它们。
      (1)使用抽象方法而不是使用非空方法体,子类就知道它必须实现该方法,而不能忽略,忽略的话编译器就会报错。
      (2)使用抽象类,类的使用者创建对象的时候,就知道要使用某个具体子类,而不可能使用不完整的抽象类。

    用一个植物的例子更直观的明白抽象类以及抽象方法的使用:

    public class AbstractTest {
        public static void main(String[] args) {
            Flower flower=new Flower();
            flower.plant();
            flower.growsIn();
            Aqua_plant aqua_plant=new Aqua_plant();
            aqua_plant.plant();
            aqua_plant.growsIn();
        }
    }
    
    abstract class Plant{
        //普通方法
        public void plant(){
            System.out.println("都是植物");
        }
        //抽象方法
        public abstract void growsIn();
    }
    
    class Flower extends Plant{
        @Override
        public void growsIn() {
            System.out.println("花生在土里。");
        }
    }
    
    class Aqua_plant extends Plant{
        @Override
        public void growsIn() {
            System.out.println("水草生在水里。");
        }
    }
    

    接口

    接口的概念

    接口就是比“抽象类”还“抽象”的“抽象类”,可以更加规范的对子类进行约束。全面地专业地实现了:规范和具体实现的分离。

    接口的使用

    声明格式:

    [访问修饰符]  interface 接口名   [extends  父接口1,父接口2]  {
    	常量定义;
    	方法定义;
        (静态方法定义;)
    }
    
    1. 访问修饰符:只能是public或默认。
    2. 接口名:和类名采用相同命名机制。
    3. extends:接口可以多继承。
    4. 常量:接口中的属性只能是常量,总是:public static final 修饰。不写也是。
    5. 方法:接口中的方法只能是:public abstract。 省略的话,也是public abstract。
    6. JDK1.8之后,接口可以包含普通的静态方法

    子类使用方法:

    1. 子类通过implements来实现接口中的规范,一个类可以实现多个接口。
    2. 接口不能创建实例,但是可用于声明引用变量类型。
    3. 一个类实现了接口,必须实现接口中所有的方法,并且这些方法只能是public的。
    4. JDK1.7之前,接口中只能包含静态常量、抽象方法,不能有普通属性、构造方法、普通方法,JDK1.8后,接口可以包含普通的静态方法。

    接口与抽象类的区别

    接口和抽象类中都包含了抽象类,但是接口和抽象类有以下几种区别:

    1. 接口是多继承的,而类是单继承。
    2. 一个类可以实现任意多个接口,但最多只能作为一个抽象类的子类。
    3. 一个抽象类可以有若干个抽象方法(但到少要有一个),而接口的所有方法都是抽象的,无论是否将它的方法显示地声明为抽象的。
    4. 一个抽象类可以声明实例变量,其子类可以继承这些实例变量。而一个接口不能声明实例变量,不过接口可以声明static final修饰域。
    5. 抽象类可以有构造方法,而接口不能,但是两者都不能直接实例化,都必须通过其他类的实现才能使用。
    6. 抽象类的可见性修饰符可以是public、protected、private或无修饰符(表示包内可见);而接口的可见性修饰符只能是 public,或无修饰符(包内可见)。
    7. 抽象类的方法的可见性修饰符可是以protected、private,或无(表示包内可见);而一个接口的方法的可见性修饰符只能是 public (JDK1.8之后,接口可以包含普通的静态方法)
    8. 抽象类是从object类派生而来,它继承了object的clone()和equals()方法。
    9. 设计模式讲,继承强调是:is-a;而接口强调的则是has-a。

    使用一个人的例子更直观的了解下接口:

    public class InterfaceTest {
        public static void main(String[] args) {
            People.say();  //调用接口中的静态方法需要通过接口来调用
            Teacher teacher=new Teacher();
            teacher.profession();
            teacher.work();
            Student student=new Student();
            student.profession();
            student.work();
        }
    }
    interface A{
    }
    interface B{
    }
    interface People extends A,B/*接口的多继承*/{
        //定义静态常量
        public static final int a=10;
        /*public static final */boolean flag=true;  //默认也是public static final修饰
        //定义抽象方法
        /*public abstract */void profession();  //默认也是public abstract修饰
        public abstract void work();
        //JDK1.8之后,接口可以包含普通的静态方法
        public static void say(){
            System.out.println("Hello!");
        }
    }
    //子类必须实现接口中所有的抽象方法(静态方法就不需要实现)
    class Teacher implements People,A,B/*子类可以实现多个接口*/ {
        @Override
        public void profession() {
            System.out.print("教师");
        }
        @Override
        public void work() {
            System.out.println("教学");
        }
    }
    class Student implements People{
        @Override
        public void profession() {
            System.out.print("学生");
        }
        @Override
        public void work() {
            System.out.println("学习");
        }
    }
    

    内部类

    内部类的概念

    内部类我们从外面看是非常容易理解的,无非就是在一个类的内部在定义一个类。一般情况,我们把类定义成独立的单元,有些情况下,我们把一个类放在另一个类的内部定义,称为内部类。内部类可以使用public、default、protected 、private以及static修饰,而外部类(我们以前接触的类)只能使用public和default修饰。

    注意事项: 内部类只是一个编译时概念,一旦我们编译成功,就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部定义的名为Inner的内部类。编译完成后会出现Outer.class和Outer$Inner.class两个类的字节码文件。所以内部类是相对独立的一种存在,其成员变量/方法名可以和外部类的相同。

    内部类的作用

    1. 内部类提供了更好的封装。只能让外部类直接访问,不允许同一个包中的其他类直接访问。

    2. 内部类可以直接访问外部类的私有属性,内部类被当成其外部类的成员。 但外部类不能访问内部类的内部属性。

    3. 接口只是解决了多重继承的部分问题,而内部类使得多重继承的解决方案变得更加完整。

    4. 由于内部类提供了更好的封装特性,并且可以很方便的访问外部类的属性。所以,在只为外部类提供服务的情况下可以优先考虑使用内部类。

    5. 使用内部类间接实现多继承:每个内部类都能独立地继承一个类或者实现某些接口,所以无论外部类是否已经继承了某个类或者实现了某些接口,对于内部类没有任何影响。

    内部类的分类

    在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。

    成员内部类

    非静态内部类
    1. 外部类里使用非静态内部类和平时使用其他类没什么不同。
    2. 非静态内部类必须寄存在一个外部类对象里。因此,如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
    3. 非静态内部类可以直接访问外部类的成员,但是外部类不能直接访问非静态内部类成员。
    4. 非静态内部类不能有静态方法、静态属性和静态初始化块。
    5. 外部类的静态方法、静态代码块不能访问非静态内部类,包括不能使用非静态内部类定义变量、创建实例。
    6. 非静态内部类成员变量的访问方法:A.内部类里方法的局部变量:变量名。B.内部类属性:this.变量名。C.外部类属性:外部类名.this.变量名。
    7. 内部类的访问方法:A.外部类中定义内部类:new 内部类名();B.外部类以外的地方使用非静态内部类:外部类名.内部类名 变量名= new 外部类名().new 内部类名()。
    静态内部类
    1. 当一个静态内部类对象存在,并不一定存在对应的外部类对象。 因此,静态内部类的实例方法不能直接访问外部类的实例方法。
    2. 静态内部类看做外部类的一个静态成员。 因此,外部类的方法中可以通过:静态内部类.名字的方式访问静态内部类的静态成员,通过new 静态内部类()访问静态内部类的实例。在外部类以外的地方使用可以通过外部类名.内部类名 变量名 =new 外部类名.内部类名();来访问。

    匿名内部类

    匿名内部类适用于仅需要使用一次的类。

    • 静态内部类的语法:
    new 父类构造器(实参类表)或实现接口() {
    	//匿名内部类类体
    }
    
    • 注意事项:
    1. 匿名内部类没有访问修饰符。
    2. 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

    局部内部类

    局部内部类是定义在方法内部的,作用域只限于本方法。局部内部类的用法和成员内部类的用法一样,但是它只能在定义的方法体中使用,离开了方法体就失效。

    展开全文
  • 接口抽象

    千次阅读 2014-10-09 22:40:35
    抽象类描述了系列"东西"的本质。 接口描述系列"东西"应该具有的功能,或者说接口就是组契约。
    首先声明,本文基本参考自
    
    http://dev.yesky.com/436/7581936.shtml
    加入从其他资料中获得的观点。

    1从逻辑上说

       抽象类描述了一系列"东西"的本质。
       接口描述一系列"东西"应该具有的功能,或者说接口就是一组契约。
       在oop的观点里,世界上任何实物都能在思想的角度给一个类与之配对,但反过来说,并不是思想中所有的类都能在现实世界里找到一个实物配对。(这里说的思想里的类 也是个逻辑概念 包括普通的类也包括抽象类 接口等等)
    举个例子,我们设计一个绘图软件,这里面会有正方形三角形,直线曲线,实线虚线,红色蓝色各种逻辑概念。我们现在只讨论正方形三角形这个问题域,通过对这个问题域的思考,我们能设计出一个"形状"的概念,我们能从绘图软件的侧边栏拖出一个三角形一个正方形,但是我们不能拖出一个"形状"!因为在我们的问题域里其实不存在"形状"的概念,它是我们抽象出来的。既然是抽象的自然就不能实例化喽!

    2从语法定义上说

       abstract class Demo{
       abstract void meth1();
       abstract void meth2();
       }
       interface Demo2{
       void meth1();
       void meth2();
       }
    最基本的定义如上。
    一个类只可以继承一个类,却可以实现很多个接口(多少个? 好像是65535 估计够咱们用了)
    先说属性,抽象类中可以有自己的数据成员。接口中也可以有数据成员,不过都是static final型的,另外虽然接口从语法角度可以有属性,但是实际情况中,我们并不在接口中定义属性。
    再说方法,接口中的所有的方法都是抽象的(不能有方法体),且都默认是public。抽象类中的方法可以有方法体,也可以没有方法体(没有方法体时要注明abstract)
    抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰符修饰。原因如下:抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法用static修饰没有意义;使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰 类方法。则用this变量锁。但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方 法也就不能用synchronized关键字修饰了;native,这个东西本身就和abstract冲突,他们都是方法的声明,只是一个吧方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢?
    上一段参考资料
    http://blog.sina.com.cn/s/blog_7ffb8dd5010111yu.html

    3从设计层面来说

      在回忆一下上文的观点
       抽象类描述了一系列"东西"的本质。
       接口描述一系列"东西"应该具有的功能,或者说接口就是一组契约。
       现在我们设计了一个door,它具有open与close的功能,我们可以用抽象类的方式实现,也可以用接口的方式实现。
       如果我们现在又设计了一个带报警功能的门呢?
       方法一
            我们在原来的抽象类/接口中加上一个报警的方法(只有一个概念)
    问题出现了,从逻辑上说,我们一直都在重复抽象类描述的事一系列东西的本质,报警算是门的本质么?应该不算吧。另外从软件的角度来看,我们确实存在一些类,它是单单依赖于门这个类的,现在我们把门改了加上了报警的特性, 那么那些原本只依赖门open与close的类也得改。
       方法二
            把门和报警器设计成两个概念
    1门和报警器都是抽象类
    java中不允许多重继承。
    2门和报警器都是接口
    那带报警器的门罗逻辑上来说到底是门能还是接口呢?
    "带报警器的门"从语法上分析,我们都能看出来"带报警器"是"门"的一个定语起修饰作用,带报警器的门的实质还是门。因此就有了第3中思路
            3门是抽象类,报警器是接口
    显而易见,门是抽象类,报警器是接口这种方式是我们所需要的。


    总而言之,设计层面上的东西没有对错之分,只有合适与否之别,上面的问题中,如果我们认为带报警器的门本质上是报警器同时又门的功能,那咱们就把程序设计成门市接口,报警器是抽象类即可!
    言而总是,类的继承说的是" a ia b"的关系;类的实现说的是"a is like b"(a像b)的关系!
    展开全文
  • Java中抽象类与接口区别

    千次阅读 2017-12-20 09:18:19
    抽象类:抽象类是无法实例化的特殊类。所以问题是为什么我们需要一个不能被... 接口:接口不是类,由Interface关键词定义,接口只有方法签名,没有方法实现(8之后支持默认方法)。与抽象类类似,它也是一种契约,用

    抽象类:抽象类是无法实例化的特殊类。所以问题是为什么我们需要一个不能被实例化的类,抽象类只能是子类(继承自)。换句话说,它只允许其他类继承它,但不能实例化。优点是它为所有子类执行特定的层次结构。简而言之,它是一种契约,它强制所有子类执行相同的层次或标准。

    接口:接口不是类,由Interface关键词定义,接口只有方法签名,没有方法实现(8之后支持默认方法)。与抽象类类似,它也是一种契约,用于定义所有子类的层次结构,或者它定义了特定的方法集和它们的参数。它们之间的主要区别是,一个类可以实现多个接口,但只能继承一个抽象类。

    属性接口抽象类
    多继承一个类可以实现多个接口一个类只能继承一个抽象类
    默认实现接口只包含接口签名抽象类可以提供默认实现,子类可以重载抽象类方法
    访问修饰符接口默认所有的方法均为public抽象类可以包含protected修饰符
    内在 vs 外在接口用以定义类具备的外在能力特征,比如人和车辆都具备可移动的特性,因此他们均可以继承实现IMovable接口。抽象类定义的是类所具备的内在特征,如果应用场景需要定义同一类型的对象,最好使用抽象。
    同质性如果应用场景是同一方法的不同实现,那么最好是使用接口如果不同的方法实现需要共享同样的行为或者状态(参考上一章的装饰器模式实例),那么抽象类是首选
    速度因为编译器需要确定方法实现类,所以,相对于抽象类,接口通常耗时会更长。
    重构代价:功能升级如果我们需要为接口新增一个签名方法,那么我们必须对应修改所有接口实现类,并且为新方法指定方法实现。如果我们需要为抽象类新增方法,我们可以仅在抽象类中指定默认实现,而无须修改所有实现类。
    属性与常量接口中不允许定义任何属性抽象类中允许定义属性和常量

    https://www.codeproject.com/articles/11155/abstract-class-versus-interface

    展开全文
  • 抽象类和接口

    千次阅读 2021-05-17 19:44:43
    一个基类 定义为抽象类后就不再允许定义它的对象了。 sysout+alt+/ 方法名+alt+/ 重写 public interface Comparable{//接口 public final int NUM = 20;//定义常量属性 int NUM = 20;//定义常量的第二种...
  • 就以适配器类来说吧 MouseAdapter是抽象类,但是没有抽象方法 ...一个没有抽象方法抽象类一般来讲都会有诺干空的方法,这些方法不是必须要实现的,但是如果都不去实现这些方法,那这个类就没有什么意义了。
  • 本文主要讲解多态的概念及实现多态的三种方法:虚方法抽象类、接口
  • JAVA中的接口抽象

    万次阅读 2016-12-12 23:24:40
    抽象是面向对象设计的几大特点之,在JAVA中的体现则是抽象类和接口。这两者十分的相似,想很多初学者甚至接触java几年的人也很难分清他们。今天笔者在查看集合类相关的代码的时候,发现了有部分是接口如List、Map...
  • 由这两问题开始深入的理解一下虚函数,纯虚函数以及抽象类和接口之间的关系。 虚函数 百度定义:简单地说,那些被virtual关键字修饰的成员函数,就是虚函数。虚函数的作用,用专业术语来解释就是实现多态性...
  • Kotlin-抽象类和接口

    千次阅读 2016-10-19 16:48:39
    抽象方法抽象方法种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为:abstract fun doSwim()抽象方法必须用abstract关键字进行修饰 抽象方法不用手动添加open,默认被open修饰 抽象方法没有...
  • Java中抽象类和接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    对于面向对象编程来说,抽象是它的大特征之。在Java中,可以通过两种形式来体现OOP的抽象接口抽象类。...抽象方法种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为...
  • 深入理解Java的接口抽象

    千次阅读 2020-07-06 10:46:54
    文章目录.抽象类二.接口三.抽象类和接口的区别①、语法层面上的区别②、设计层面上的区别③、举例说明 深入理解Java的接口抽象类   对于面向对象编程来说,抽象...抽象方法种特殊的方法:它只有声明,而没.
  • Java抽象类与接口的异同点

    千次阅读 2019-08-31 17:25:52
    抽象类与接口相同点: 都可以定义抽象方法 都不可以被实例化 子类必须对所有的抽象方法提供具体实现,...类只能extends一个抽象类,但是可以implements多个接口 一、抽象类(关键字abstract) 定义:描述不具体的...
  • 接口可以继承接口。。抽象类可以实现(implements)接口抽象类是否可继承具体类。抽象类中可以有静态的main方法。 备注:只要明白了接口和...只有记住抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstr...
  • 抽象类、接口、内部类

    千次阅读 2018-12-02 16:09:27
    抽象抽象方法抽象抽象方法抽象类必须使用abstract修饰符来定义,有抽象方法的类只能被定义为抽象类,...抽象类可以包含成员变量、方法(普通方法抽象方法都可以)、构造器、初始化块、内部类(接口、...
  • C#中的抽象类、抽象属性、抽象方法

    千次阅读 2020-06-10 00:51:31
    前言:本博文讲述了C#面向对象中的抽象类,通过本博文的阅读,读者可以掌握C#抽象类的概念、应用、好处以及一些特性。...注意:类是一个模板,那么抽象类就是一个不完整的模板。我们自然不可以使用不完
  • 抽象类和接口的区别

    千次阅读 2017-05-07 22:44:50
    接口完全是抽象的,根本不存在方法的实现 实现 子类使用extends关键字继承抽象类.如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法实现. 子类使用关键字implements实现接口.它需要提供接口中所有声明
  • 一个类可以实现一个或多个接口,如果类实现接口(可能是多个)其中有部分抽象方法(哪怕只有1个)没有被实现,则这个类只能是抽象类,如果你希望定义一个实体类,则必须实现所有抽象方法抽象类:可以有抽象方法,...
  • 面向对象——抽象类与抽象方法

    千次阅读 2020-04-13 09:26:04
    如果一个类不与具体的食物相联系,而只表达一种抽象的概念,仅是作为其派生类的一个基类,这样的类就是派生类,在抽象类中,声明抽象类中声明抽象方法是,如果加上abstract关键字则为抽象方法。abstract 修饰符可...
  • Java 的抽象特性:抽象类与接口深度解析

    千次阅读 热门讨论 2016-10-27 11:56:48
    对于面向对象编程来说,抽象是它的四大特征之。在Java中,可以通过两种形式来体现OOP的抽象:...接口抽象类为我们提供了种将接口与实现分离的更加结构化的方法。总的来说,抽象类是种模板,而接口种契约。
  • java中抽象类与接口的区别

    千次阅读 2017-10-14 15:08:27
    java中抽象类与接口的区别一、抽象类用abstract关键字修饰一个类时,这个类叫做抽象类,用abstract修饰一个方法时,这个方法叫做抽象方法。含有抽象方法的类必须被声明为抽象类,抽象类必须被继承,抽象方法必须被...
  • java:抽象的两种实现方式(抽象类和接口)及其比较

    千次阅读 多人点赞 2018-02-23 20:57:38
    对于面向对象编程来说,抽象是它的大特征之。在Java中,可以通过两种形式来体现面向对象的编程(OOP)的抽象...抽象方法种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为: abstract v...
  • 一文理解接口抽象

    千次阅读 2020-09-28 16:44:51
    一.抽象类  在了解抽象类之前,先来了解一下抽象方法。... 下面要注意一个问题:如果一个类不包含抽象方法,只是用abstract修饰的话也是抽象类。也就是说抽象类不一定必须含有抽象方法。个人觉..
  • Java 抽象接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口抽象类的概念不一样。接口是对动作的抽象抽象类是对根源的抽象抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。...所以,在高级语言上,一个类只能继承一个类(抽象类,jav
  • Thinking in Java--抽象类与接口

    千次阅读 2015-05-27 11:24:08
    抽象类:我们用abstract关键字定义抽象类和抽象方法抽象方法指的是只有定义没有实现的方法,并且规定如果一个类包含一个或者多个抽象方法,则一定要声明为抽象类.抽象类中也可以包含普通的方法,甚至完全没有抽象...
  • 抽象类和接口的区别有哪些?...3.抽象类只能单继承,接口可以继承多接口。 4.Java8中接口会有default方法,即方法可以被实现。 追加:抽象类和接口如何选择? 答: 1.如果要创建不带任何方法定义...
  • 一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,各个对象内部是如何实现自己的对系统设计人员来讲就不那么重要了;而各个对象之间的协作关系则成为系统设计的关键。小到...
  • C# 虚方法抽象方法区别

    千次阅读 2015-02-17 21:40:46
    抽象方法只有定义、没有实际方法体的函数,它只能在抽象函数中出现,并且在子类中必须重写;虚方法则有自己的函数体,已经提供了函数实现,但是允许在子类中重写或覆盖。 重写的子类虚函数就是被覆盖了。 抽象...
  • Java中接口抽象类的区别

    千次阅读 2019-04-29 19:51:53
    java中接口抽象类的区别 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 189,686
精华内容 75,874
关键字:

允许接口只有一个抽象方法