精华内容
下载资源
问答
  • 抽象类继承,如果子类也是一个抽象类,并不要求一定重写父类方法。如果子类不是抽象类,则要求子类一定要实现父类中的抽象方法。 接口类继承,如果是一个子接口,可以扩展父接口的方法;如果是一个子抽象类,可以...

    抽象类继承,如果子类也是一个抽象类,并不要求一定重写父类方法。如果子类不是抽象类,则要求子类一定要实现父类中的抽象方法。
    接口类继承,如果是一个子接口,可以扩展父接口的方法;如果是一个子抽象类,可以部分或全部实现父接口的方法;如果子类不是抽象类,则要求子类一定要实现父接口中定义的所有方法。
    


    展开全文
  • 简单总结,需要重写的有: ...2. 抽象类继承,如果子类也是一个抽象类,并不要求一定重写父类方法。如果子类不是抽象类,则要求子类一定要实现父类中的抽象方法。 3. 接口类继承。如果是一个子接...

     

    简单总结,需要重写的有:

    普通类继承抽象类,重写所有抽象类方法;(不包括普通方法)

    普通类继承接口,重写所有接口方法。(不包括default关键字修饰的方法)

     

    详解见下:

    1. 普通类继承,并非一定要重写父类方法。

    2. 抽象类继承,如果子类也是一个抽象类,并不要求一定重写父类方法。如果子类不是抽象类,则要求子类一定要实现父类中的抽象方法。

    3. 接口类继承。如果是一个子接口,可以扩展父接口的方法;如果是一个子抽象类,可以部分或全部实现父接口的方法;如果子类不是抽象类,则要求子类一定要实现父接口中定义的所有方法。

     

     

     

    不一定,关键要看子类是否是抽象类。

        如果子类是非抽象类,则必须实现接口中的所有方法;  

        如果子类是抽象类,则可以不实现接口中的所有方法,因为抽象类中允许有抽象方法的存在!

    1、抽象类定义

        抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。通常在编程语句中用 abstract 修饰的类是抽象类。在C++中,含有纯虚拟函数的类称为抽象类,它不能生成对象;在java中,含有抽象方法的类称为抽象类,同样不能生成对象。抽象类是不完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当全局变量的角色。

    2、抽象类特点

        1)抽象类不能实例化。

        2)抽象类可以包含抽象方法和抽象访问器。

        3)不能用 sealed 修饰符修饰抽象类,因为这两个修饰符的含义是相反的。 采用 sealed 修饰符的类无法继承,而 abstract 修饰符要求对类进行继承。

        4)从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。

    3、与具体类的比较

     

        1)抽象类不能直接实例化,并且对抽象类使用 new 运算符会导致编译时错误。虽然一些变量和值在编译时的类型可以是抽象的,但是这样的变量和值必须或者为 null,或者含有对非抽象类的实例的引用(此非抽象类是从抽象类派生的)。

        2)允许(但不要求)抽象类包含抽象成员。

        3)抽象类不能被密封。

    4、与接口的比较

        1)相同点

     

            a、不能实例化;

            b、包含未实现的方法声明;

            c、派生类必须实现未实现的方法,抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员)

        2)不同点

     

            a、类可以实现无限个接口,但仅能从一个抽象(或任何其他类型)类继承,从抽象类派生的类仍可实现接口,从而得出接口是用来解决多重继承问题的。

            b、抽象类当中可以存在非抽象的方法,可接口不能,且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。

            c、抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量默认的都是静态常量(static final)。

            d、抽象类是对象的抽象,然而接口是一种行为规范。

    ------------------------------------------------------

    上面是转载的,下面是自己的补充哈~

    首先创建接口ClassA,创建抽象类ClassB,创建类ClassC,

    关系:ClassA是基类接口,ClassB实现了ClassA,ClassC继承了ClassB

    public interface ClassA {
        void  a();
        void  aa();
    }

     

    
    public abstract class ClassB implements ClassA{
    
        @Override
        public void a() {
            Log.d("chenhua","我是B,实现了A中的a方法");
        }
    
        @Override
        public void aa() {
            Log.d("chenhua","我是B,实现了A中的aa方法");
        }
    }
    

     

    public class ClassC extends ClassB {
    
    }
    

    在activity中编写:

     ClassA classA = new ClassC();
            classA.a();
            classA.aa();
    

     得到输出:

    CassB实现了ClassA,对于抽象类实现接口类,不一定要重写他的全部方法,但是!!但是如果一个类继承了抽象类,比如ClassC继承了ClassB,那么ClassC必须重写ClassB中没有重写的ClassA的方法!这句好好理解下哦~

    看图示意:ClassA不变,ClassB不实现aa方法

    public abstract class ClassB implements ClassA{
    
            @Override
            public void a() {
                Log.d("chenhua","我是B,实现了A中的a方法");
            }
            
        }

    那么在ClassC中报红

    提示说,ClassC要么声明成抽象类,要么就实现aa()方法!

    展开全文
  • 4.1 抽象类 在面向对象领域由于抽象的概念在问题领域没有对应的具体...同时抽象类提供了继承的概念,它的出发点就是为了继承,否则它没有存在的任何意义。所以说定义的抽象类一定是用来继承的,同时在一个以抽象...

    4.1 抽象类

             在面向对象领域由于抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能实例化的。

         同时,抽象类体现了数据抽象的思想,是实现多态的一种机制。它定义了一组抽象的方法,至于这组抽象方法的具体表现形式有派生类来实现。同时抽象类提供了继承的概念,它的出发点就是为了继承,否则它没有存在的任何意义。所以说定义的抽象类一定是用来继承的,同时在一个以抽象类为节点的继承关系等级链中,叶子节点一定是具体的实现类。(不知这样理解是否有错!!!高手指点….)

         在使用抽象类时需要注意几点:

            1、抽象类不能被实例化,实例化的工作应该交由它的子类来完成,它只需要有一个引用即可。

             2、抽象方法必须由子类来进行重写。

            3、只要包含一个抽象方法的抽象类,该方法必须要定义成抽象类,不管是否还包含有其他方法。

            4、抽象类中可以包含具体的方法,当然也可以不包含抽象方法。

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

            6、abstract不能与final并列修饰同一个类。

            7、abstract 不能与private、static、final或native并列修饰同一个方法

     

             4.2接口

    接口是一种比抽象类更加抽象的“类”。这里给“类”加引号是我找不到更好的词来表示,但是我们要明确一点就是,接口本身就不是类,从我们不能实例化一个接口就可以看出。如new Runnable();肯定是错误的,我们只能new它的实现类。

         接口是用来建立类与类之间的协议,它所提供的只是一种形式,而没有具体的实现。同时实现该接口的实现类必须要实现该接口的所有方法,通过使用implements关键字,他表示该类在遵循某个或某组特定的接口,同时也表示着“interface只是它的外貌,但是现在需要声明它是如何工作的”。

         接口是抽象类的延伸,java了保证数据安全是不能多重继承的,也就是说继承只能存在一个父类,但是接口不同,一个类可以同时实现多个接口,不管这些接口之间有没有关系,所以接口弥补了抽象类不能多重继承的缺陷,但是推荐继承和接口共同使用,因为这样既可以保证数据安全性又可以实现多重继承。

         在使用接口过程中需要注意如下几个问题:

            1、个Interface的方所有法访问权限自动被声明为public。确切的说只能为public,当然你可以显示的声明为protected、private,但是编译会出错!

            2、接口中可以定义“成员变量”,或者说是不可变的常量,因为接口中的“成员变量”会自动变为为public static final。可以通过类命名直接访问:ImplementClass.name。

            3、接口中不存在实现的方法。

            4、实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。

            5、不能使用new操作符实例化一个接口,但可以声明一个接口变量,该变量必须引用(refer to)一个实现该接口的类的对象。可以使用 instanceof 检查一个对象是否实现了某个特定的接口。例如:if(anObject instanceof Comparable){}。

            6、在实现多接口的时候一定要避免方法名的重复。

     

             4.3,抽象类与接口的区别

    1、抽象层次不同。抽象类是对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。

         2、跨域不同。抽象类所跨域的是具有相似特点的类,而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分,然后泛化成抽象类,子类继承该父类即可,但是接口不同。实现它的子类可以不存在任何关系,共同之处。例如猫、狗可以抽象成一个动物类抽象类,具备叫的方法。鸟、飞机可以实现飞Fly接口,具备飞的行为,这里我们总不能将鸟、飞机共用一个父类吧!所以说抽象类所体现的是一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is-a" 关系,即父类和派生类在概念本质上应该是相同的。对于接口则不然,并不要求接口的实现者和接口定义在概念本质上是一致的,仅仅是实现了接口定义的契约而已。

         3、设计层次不同。对于抽象类而言,它是自下而上来设计的,我们要先知道子类才能抽象出父类,而接口则不同,它根本就不需要知道子类的存在,只需要定义一个规则即可,至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里,如果你这是就抽象成一个动物类,是不是设计有点儿过度?我们起码要有两个动物类,猫、狗在这里,我们在抽象他们的共同点形成动物抽象类吧!所以说抽象类往往都是通过重构而来的!但是接口就不同,比如说飞,我们根本就不知道会有什么东西来实现这个飞接口,怎么实现也不得而知,我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的,接口是自顶向下设计出来的。

     

    1.语法层面上的区别

     

      1)抽象类可以提供成员方法的实现细节,而接口中只能存在public abstract 方法;

     

      2)抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的;

     

      3)接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块和静态方法;

     

      4)一个类只能继承一个抽象类,而一个类却可以实现多个接口。

     

    2.设计层面上的区别

     

    1)  抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。

    2)  设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。

     

    总结

    1、 抽象类在java语言中所表示的是一种继承关系,一个子类只能存在一个父类,但是可以存在多个接口。

         2、在抽象类中可以拥有自己的成员变量和非抽象类方法,但是接口中只能存在静态的不可变的成员数据(不过一般都不在接口中定义成员数据),而且它的所有方法都是抽象的。

         3、抽象类和接口所反映的设计理念是不同的,抽象类所代表的是“is-a”的关系,而接口所代表的是“like-a”的关系。

     

             4.4,继承

     

    如果两个类存在继承关系,则子类会自动继承父类的方法和变量,在子类中可以调用父类的方法和变量。在java中,只允许单继承,也就是说一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承,也就是说一个类可以拥有多个子类。

     

      1.子类继承父类的成员变量

     

      当子类继承了某个类之后,便可以使用父类中的成员变量,但是并不是完全继承父类的所有成员变量。具体的原则如下:

     

      1)能够继承父类的public和protected成员变量;不能够继承父类的private成员变量;

     

      2)对于父类的包访问权限成员变量,如果子类和父类在同一个包下,则子类能够继承;否则,子类不能够继承;

     

      3)对于子类可以继承的父类成员变量,如果在子类中出现了同名称的成员变量,则会发生隐藏现象,即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量,需要使用super关键字来进行引用。

     

      2.子类继承父类的方法

     

      同样地,子类也并不是完全继承父类的所有方法。

     

      1)能够继承父类的public和protected成员方法;不能够继承父类的private成员方法;

     

      2)对于父类的包访问权限成员方法,如果子类和父类在同一个包下,则子类能够继承;否则,子类不能够继承;

     

      3)对于子类可以继承的父类成员方法,如果在子类中出现了同名称的成员方法,则称为覆盖,即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法,需要使用super关键字来进行引用。

     

      注意:隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的,而覆盖是针对普通方法的。(后面会讲到)

     

      3.构造器

     

    子类是不能够继承父类的构造器,但是要注意的是,如果父类的构造器都是带有参数的,则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器,则在子类的构造器中用super关键字调用父类构造器不是必须的,如果没有使用super关键字,系统会自动调用父类的无参构造器。

     

    3.如果子类构造函数没有显式调用超类构造函数,将会自动调用超类的无参构造函数,若超类没有无参构造函数,子类中又没有显式调用,则编译器报错

    4.java默认动态绑定机制,若不需要动态绑定则将方法定义为final阻止继承

    5.Aprotected修饰符的数据或方法,可以被同个包中的任何一个类访问(包括子类),也可以被不同包中的A的子类访问。

    6.覆盖一个方法时,子类的方法可见性不能低于父类方法的可见性。

     

     

    继承(inheritance)
        
    继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。这种技术使得复用以前的代码非常容易,能够大大缩短开发周期,降低开发费用。比如可以先定义一个类叫车,车有以下属性:车体大小,颜色,方向盘,论坛,而又由车这个类派生出教程和卡车两个类,为轿车添加一个小后备箱,而为卡车添加一个大货箱。

     

    类的继承知识点 
    1java不支持多重继承,也就是说子类至多只能有一个父类 
    2)子类继承了其父类中不是私有的成员变量和成员方法,作为自己的成员变量和方法 
    3)子类中定义的成员变量和父类中定义的成员变量相同时,则父类中的成员变量不能被继承 
    4)子类中定义的成员方法,并且这个成员方法的名字,返回类型,及参数个数和类型与父类的某个成员方法完全相同,则父类的成员方法不能被继承。 

     

    封装(encapsulation)
        
    类使得数据和对数据的操作集成在一起,从而对使用该类的其他人来说,可以不管它的实现方法,而只管用它的功能,从而实现所谓的信息隐藏。

    多态(polymorphism)
        
    多态又分为设计时多态和运行时多态,例如重载又被称为设计时多态,而对于覆盖或继承的方法,JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。总而言之,面向对象的设计的典型特点就是继承,封装和多态,这些特点也是面向对象之所以能如此盛行的关键所在。

    单继承与多继承
        JAVA
    不支持多重继承,单继承使JAVA的继承关系很简单,一个类只能有一个父类,易于管理程序,同时一个类可以实现多个接口,从而克服单继承的缺点。

     

    http://blog.csdn.net/stonecao/article/details/6317353

     

    java的继承与覆盖基本是java笔试中常出的题,也比较绕,我这里对java的继承覆盖做一个总结

    1.构造函数:

     当子类继承一个父类时,构造子类时需要调用父类的构造函数,存在三种情况

         (1),父类无构造函数或者一个无参数构造函数,子类若无构造函数或者有无参数构造函数,子类构造函数中不需要显式调用父类的构造函数,系统会自动在调用子类构造函数前调用父类的构造函数

       (2),父类只有有参数构造函数,子类在构造方法中必须要显示调用父类的构造函数,否则编译出错

       (3),父类既有无参数构造函数,也有有参构造函数,子类可以不在构造方法中调用父类的构造函数,这时使用的是父类的无参数构造函数

               //以上三个结论已经过代码验证

    2.方法覆盖:

        (1)子类覆盖父类的方法,必须有同样的参数返回类型,否则编译不能通过

        (2)子类覆盖父类的方法,在jdk1.5后,参数返回类可以是父类方法返回类的子类

        (3)子类覆盖父类方法,可以修改方法作用域修饰符,但只能把方法的作用域放大,而不能把public修改为private

          (4)子类方法能够访问父类的protected作用域成员,不能够访问默认的作用域成员

         (5)子类的静态方法不能隐藏同名的父类实例方法

         (6)java与C++一样,继承的方法具有多态性

             //以上6个结论已经过代码验证

    3.成员覆盖:

             (1)当子类覆盖父类的成员变量时,父类方法使用的是父类的成员变量,子类方法使用的是子类的成员变量

              这个听起来很容易理解的一回事,但是实际使用过程中很多人容易搞混:尤其是在多态的时候,调用一个被继承的方法,该方法访问是一个被覆盖的成员m,那么方法中到底是访问了父类的成员还是子类的成员m?结论是,若实际调用的是父类的方法,就使用了父类的该成员m,若实际调用的是子类的方法,就使用子类的成员m,记住一句,每个类使用成员都相当于在前面加了一个this指针。

     

    4.5重载重写

    重载(Overloading)

    (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。

     

    重载Overloading是一个类中多态性的一种表现。

     

     

    (2) Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。

     

    调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

     

     

    (3) 重载的时候,方法名要一样,但是参数类型和个数不一样,返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

    重写(Overriding

    (1) 父类与子类之间的多态性,对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。

     

    但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。

     

    方法重写又称方法覆盖。

     

     

        (2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法。

     

    如需父类中原有的方法,可使用super关键字,该关键字引用了当前类的父类。

     

     

        (3)子类函数的访问修饰权限不能少于父类的;、


     OOP三大特性:继承,多态,封装。

    重写方法的规则:

     

    1、参数列表必须完全与被重写的方法相同,否则不能称其为重写而是重载。

     

    2、返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载。

     

    3、访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)

     

    4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如:

     

    父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常,可以抛出非检查异常。

     

     

     

    而重载的规则:

     

    1、必须具有不同的参数列表;

     

    2、可以有不责骂的返回类型,只要参数列表不同就可以了;

     

    3、可以有不同的访问修饰符;

     

    4、可以抛出不同的异常;

     

     

     

    重写与重载的区别在于:

     

    重写多态性起作用,对调用被重载过的方法可以大大减少代码的输入量,同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。

     

    用好重写和重载可以设计一个结构清晰而简洁的类,可以说重写和重载在编写代码过程中的作用非同一般.

     

    4.6,多态

    什么是多态?

         

    多态分两种:

    (1)   编译时多态(设计时多态):方法重载。

     

    (2)   运行时多态:JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。(我们平时说得多的事运行时多态,所以多态主要也是指运行时多态)

     

    运行时多态存在的三个必要条件:
    一、要有继承(包括接口的实现);
    二、要有重写;
    三、父类引用指向子类对象。

    多态的好处:

    1.可替换性(substitutability)。多态对已存在代码具有可替换性。例如,多态对圆Circle类工作,对其他任何圆形几何体,如圆环,也同样工作。

    2.可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如,在实现了圆锥、半圆锥以及半球体的多态基础上,很容易增添球体类的多态性。

    3.接口性(interface-ability)。多态是超类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。如图8.3所示。图中超类Shape规定了两个实现多态的接口方法,computeArea()以及computeVolume()。子类,如CircleSphere为了实现多态,完善或者覆盖这两个接口方法。

    4.灵活性(flexibility)。它在应用中体现了灵活多样的操作,提高了使用效率。

    5.简化性(simplicity)。多态简化对应用软件的代码编写和修改过程,尤其在处理大量对象的运算和操作时,这个特点尤为突出和重要。

    class A...{ 

             public String show(D obj)...{ 

                    return ("A andD"); 

             }  

             public String show(A obj)...{ 

                    return ("A andA"); 

             }  

    }  

    class B extendsA...{ 

             public String show(B obj)...{ 

                    return ("B andB"); 

             } 

             public String show(A obj)...{ 

                    return ("B andA"); 

             }  

    class C extendsB...{}  

    class D extendsB...{} 

     

     

    A a1 = newA(); 

            A a2 = new B(); 

            B b = new B(); 

            C c = new C();  

            D d = new D();  

            System.out.println(a1.show(b));   ① 

            System.out.println(a1.show(c));   ② 

            System.out.println(a1.show(d));   ③ 

            System.out.println(a2.show(b));   ④ 

            System.out.println(a2.show(c));   ⑤ 

            System.out.println(a2.show(d));   ⑥ 

            System.out.println(b.show(b));    ⑦ 

            System.out.println(b.show(c));    ⑧ 

            System.out.println(b.show(d));    ⑨    

    复制代码

    答案:

    ①   A and A

    ②   A and A

    ③   A and D

    ④   B and A

    ⑤   B and A

    ⑥   A and D

    ⑦   B and B

    ⑧   B and B

    ⑨   A and D




    展开全文
  • java中普通类继承,抽象类继承,接口类继承,子类一定要重写父类中的方法吗 简单总结,需要重写的有: 普通类继承抽象类,重写所有抽象类方法;(不包括普通方法) 普通类继承接口,重写所有接口方法。(不包括...

    java中普通类继承,抽象类继承,接口类继承,子类一定要重写父类中的方法吗

     

    简单总结,需要重写的有:

    普通类继承抽象类,重写所有抽象类方法;(不包括普通方法)

    普通类继承接口,重写所有接口方法。(不包括default关键字修饰的方法)

     

    详解见下:

    1. 普通类继承,并非一定要重写父类方法。

    2. 抽象类继承,如果子类也是一个抽象类,并不要求一定重写父类方法。如果子类不是抽象类,则要求子类一定要实现父类中的抽象方法。

    3. 接口类继承。如果是一个子接口,可以扩展父接口的方法;如果是一个子抽象类,可以部分或全部实现父接口的方法;如果子类不是抽象类,则要求子类一定要实现父接口中定义的所有方法。

     

     

     

    不一定,关键要看子类是否是抽象类。

        如果子类是非抽象类,则必须实现接口中的所有方法;  

        如果子类是抽象类,则可以不实现接口中的所有方法,因为抽象类中允许有抽象方法的存在!

    1、抽象类定义

        抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。通常在编程语句中用 abstract 修饰的类是抽象类。在C++中,含有纯虚拟函数的类称为抽象类,它不能生成对象;在java中,含有抽象方法的类称为抽象类,同样不能生成对象。抽象类是不完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当全局变量的角色。

    2、抽象类特点

        1)抽象类不能实例化。

        2)抽象类可以包含抽象方法和抽象访问器。

        3)不能用 sealed 修饰符修饰抽象类,因为这两个修饰符的含义是相反的。 采用 sealed 修饰符的类无法继承,而 abstract 修饰符要求对类进行继承。

        4)从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。

    3、与具体类的比较

     

        1)抽象类不能直接实例化,并且对抽象类使用 new 运算符会导致编译时错误。虽然一些变量和值在编译时的类型可以是抽象的,但是这样的变量和值必须或者为 null,或者含有对非抽象类的实例的引用(此非抽象类是从抽象类派生的)。

        2)允许(但不要求)抽象类包含抽象成员。

        3)抽象类不能被密封。

    4、与接口的比较

        1)相同点

     

            a、不能实例化;

            b、包含未实现的方法声明;

            c、派生类必须实现未实现的方法,抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员)

        2)不同点

     

            a、类可以实现无限个接口,但仅能从一个抽象(或任何其他类型)类继承,从抽象类派生的类仍可实现接口,从而得出接口是用来解决多重继承问题的。

            b、抽象类当中可以存在非抽象的方法,可接口不能,且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。

            c、抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量默认的都是静态常量(static final)。

            d、抽象类是对象的抽象,然而接口是一种行为规范。

    展开全文
  • 【转载 】 Java中普通类继承,抽象类继承,接口类继承,子类一定要重写父类中的方法吗简单总结,需要重写的有:普通类继承抽象类,重写所有抽象类方法;(不包括普通方法)普通类继承接口,重写所有接口方法。(不...
  • 继承抽象类的子类需要把抽象类中的方法重写一遍吗? 抽象类中的非抽象方法不用重写,其他必须重写,接口的方法必须重写; 接口和抽象类中只有方法名,没有定义的,如果你不定义 也就是空方法,接口就是为了弥补...
  • Go继承的方法重写继承抽象类实现

    千次阅读 2019-04-20 15:55:47
    Go继承的方法重写继承抽象类实现 go的接口和继承就没什么好说的了,基本上大家都知道怎么玩,这里说下可能会困扰大家的问题。在Java里方法的重写抽象类是很好用的,对于抽象和尽量共用抽象出来的代码很重要,...
  • 继承抽象类的子类必须重写抽象类的方法 转载于:https://www.cnblogs.com/classmethond/p/9926283.html
  • 继承 : 抽象类可以继承抽象类 , 抽象类也可以继承正常类 , 正常类可以继承抽象类 ; ④ 重写 : 抽象类中可以使用抽象方法重写正常方法 , 也可以进行正常的方法重写 ; ⑤ 特征 : 抽象方法只能定义在抽象类中 , ...
  • 如果抽象类没有实现接口中的所有有方法(不用写方法体),那么A类继承抽象类后就必须重写抽象类没有实现的方法。所以为了方便的去使用个别方法,可以让抽象类去实现接口的所用方法(不用写方法体),这样A类就可以...
  • 抽象类中的非抽象方法不用重写,其他必须重写,接口的方法必须重写
  • 特质、抽象类继承重写 特质:(trait) 相当于java的接口。 可以只声明变量,不赋值,但在调用时需要重写赋值 可以只声明方法,不实现,但在调用时需要重写实现 /** * 特质 */ trait Flyable{ //声明...
  • 面向对象(继承,重写,this,super,抽象类).pdf
  • 定义“大雁”的时候直接重写“飞翔”接口中的方法就行了 另一种是接口继承接口 我们假设篮球运动员需要发球,女孩子需要生孩子,那么女子篮球运动员又会发球又能生孩子 我们定义了一个发球的接口和一个生孩子的...
  • 抽象类继承

    千次阅读 2019-09-22 15:56:23
    抽象类继承 抽象类的定义(可以构造方法) ...继承抽象类,抽象方法必须要重写! public class Cat extends Animal { public Cat() { System.out.println("子类构造方法"); } @Override public void eat() { Sy...
  • 接口 抽象类 继承 区别

    千次阅读 2012-07-19 18:00:45
    另外,实现接口的一定要实现接口里定义的所有方法,而实现抽象类可以有选择地重写需要用到的方法,一般的应用里,最顶级的是接口,然后是抽象类实现接口,最后才到具体类实现。 还有,接口可以实现多重继承,而一...
  • 继承中方法的重写抽象类

    千次阅读 2017-09-07 23:15:52
    子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为override重写、复写或者覆盖。'' 当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了...
  • C#: 一、继承 什么是继承:继承是允许重用现有类去创建新类的过程。分类的原则是一个类派生出来的子类具有这个类的所有非私有...派生类继承基类的语法如下: using System; public class Person { //这是基
  • 抽象类和类的继承。 创建抽象类Person,具有name属性,包含一个参数——姓名的构造方法,具备显示类信息的抽象方法display()。 创建Person的子类Student,属性包括姓名、年级、专业。重写父类的抽象方法。注意在类...
  • 抽象类中的非抽象方法可以不用重写。抽象方法必须重写。接口的方法必须重写。如果子类是抽象类,则可以不用重写
  • 抽象类不能继承接口

    千次阅读 2017-09-21 10:21:43
    1. 抽象类可以继承普通类,但不可以继承接口。 (public abstract class 抽象类 extends 普通类 { }) 2. 接口可以继承多接口,但不可以继承抽象类。 (public abstract class 接口1 extends 接口2,接口3 ,接口4{ }...
  • 接口 类 抽象类 继承 构造函数 方法重写 方法重载 自动转型 多态 引用传递
  • 子类A继承抽象类B,就一定要重写B的抽象方法 抽象方法没有方法体,只有个定义。如:public abstract void a(); 你某个类继承上面的类是,必须实现那个方法“a” 。 void a(){ 具体操作如输出一句话: System.out....
  • Java中抽象类与方法的重写

    千次阅读 2020-11-10 22:29:33
    1. 抽象类 关键字:abstract 类:用来描述一类具体的事物 抽象类:抽象的、模糊的、不具体的类 在Java的普通类中是不允许多继承的,原因是会出现调用 不明确的问题; 总结:父类中的功能是不能删除的,但其形式是...
  • 继承重写

    千次阅读 2021-06-13 10:03:23
    继承重写前言一、1. 成员变量2. 成员方法3. 权限修饰符4. 代码示例二、继承重写1. 继承(1)继承的特点(2)继承示例2. 重写(1) 重写的要求(2) 重写的示例总结 前言 现实生活中,对象就是事物存在的实体...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 201,312
精华内容 80,524
关键字:

抽象类继承重写