清露草木的博客

技术积累

java 接口 抽象类 继承 重载 重写 多态

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




阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/u012803478/article/details/51927212
文章标签: java基础
个人分类: java基础
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭