java三大特性--继承

  在讲解之前我们先看一个例子

Husband.java

public class Husband {
    private String name;
    private String sex;
    privateintage;
    private Wife wife;
    //省略属性的getter和setter方法
}

Wife.java

public class Wife {
    private String name;
    private int age;
    private String sex;
    private Husband husband;
    //省略属性的getter和setter方法
}

  从这里我们可以看出,Wife、Husband两个类除了各自的husband、wife外其余部分全部相同,作为一个想最大限度实现复用代码的我们是不能够忍受这样的重复代码,如果再来一个小三、小四、小五……我们是不是也要这样写呢?那么我们如何来实现这些类的可复用呢?利用继承!!

  首先我们先离开软件编程的世界,从常识中我们知道丈夫、妻子、小三、小四…,他们都是人,而且都有一些共性,有名字、年龄、性别、头等等,而且他们都能够吃东西、走路、说话等等共同的行为,所以从这里我们可以发现他们都拥有人的属性和行为,同时也是从人那里继承来的这些属性和行为的。

从上面我们就可以基本了解了继承的概念了,继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力。继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码,能够大大的提高开发的效率。

  看如下代码,首先定义父类

Person.java

public class Person {
    private String name;
    private String sex;
    private int age;
}

Husband.java

public class Husband extends Person {
    private Wife wife;
    //省略属性的getter和setter方法
}

Wife.java

public class Wife extends Perso {
    private Husband husband;
    //省略属性的getter和setter方法
}

  对于Wife、Husband使用继承后,除了代码量的减少我们还能够非常明显的看到他们的关系。

  继承所描述的是“is-a”的关系,如果有两个对象A和B,若可以描述为“A是B”,则可以表示A继承B,其中B被称之为继承者的父类或者超类。A是继承者,称之为子类或者派生类。

  实际上继承者是被继承者的特殊化,它除了拥有被继承者的特性外,还拥有自己独有得特性。例如猫有抓老鼠、爬树等其他动物没有的特性。同时在继承关系中,继承者完全可以替换被继承者,反之则不可以,例如我们可以说猫是动物,但不能说动物是猫就是这个道理,其实对于这个我们将其称之为“向上转型”,下面介绍。

  继承定义了类如何相互关联,共享特性。对于若干个相同或者相似的类,我们可以抽象出他们共有的行为或者属性并将其定义成一个父类或者超类,然后用这些类继承该父类,他们不仅可以拥有父类的属性、方法还可以定义自己独有的属性或者方法。

  同时在使用继承时需要记住三句话:

    1、子类拥有父类非private的属性和方法。

    2、子类可以拥有自己属性和方法,即子类可以对父类进行扩展。

    3、子类可以用自己的方式实现父类的方法。(以后介绍)。

  综上所述,使用继承确实有许多的优点,除了将所有子类的共同属性放入父类,实现代码共享,避免重复外,还可以使得修改扩展继承而来的实现比较简单。

  讲到继承一定少不了这三个东西:构造器、protected关键字、向上转型。

构造器

  通过前面我们知道子类可以继承父类的属性和方法,除了那些private的外还有一样是子类继承不了的---构造器。对于构造器而言,它只能够被调用,而不能被继承。调用父类的构造方法我们使用super()即可。

  对于子类而言,其构造器的正确初始化是非常重要的,当且仅当只有一个方法时可以保证这点:在构造器中调用父类构造器来完成初始化,而父类构造器具有执行父类初始化所需要的所有知识和能力。

class Person {
    protected String name;
    protected int age;
    protected String sex;
    Person() {
        System.out.println("Person Constrctor...");
    }
}

public class Husband extends Person {
    private Wife wife;
    Husband() {
        System.out.println("Husband Constructor...");
    }
    public staticvoid main(String[] args) {
        Husband husband = new Husband();
    }
}
Output:
Person Constrctor...
Husband Constructor... 

  通过这个示例可以看出,构建过程是从父类“向外”扩散的,也就是从父类开始向子类一级一级地完成构建。而且我们并没有显示的引用父类的构造器,这就是java的聪明之处:编译器会默认给子类调用父类的构造器。

  但是,这个默认调用父类的构造器是有前提的:父类有默认构造器。如果父类没有默认构造器,我们就要必须显示的使用super()来调用父类构造器,否则编译器会报错:无法找到符合父类形式的构造器。

class Person {
    protected String name;
    protected int age;
    protected String sex;
    Person(String name) {
        System.out.println("Person Constrctor-----" + name);
    }
}
public class Husband extends Person {
    private Wife wife;
    Husband() {
        super("show");//没有这行代码,编译器默认隐式调用父类的无参构造,但是父类没用无参构造,只能显示的调用父类的有参构造
        System.out.println("Husband Constructor...");
    }
    public static void main(String[] args) {
        Husband husband = new Husband();
    }
}
Output:
Person Constrctor-----show
Husband Constructor... 

  综上所述:对于继承而言,子类会默认调用父类的无参构造器,但是如果父类没默认有无参构造器,子类必须要显示的指定父类的构造器,而且必须是在子类构造器中做的第一件事(第一行代码)。

protected关键字

  private访问修饰符,对于封装而言,是最好的选择,但这个只是基于理想的世界,有时候我们需要这样的需求:我们需要将某些事物尽可能地对这个世界隐藏,但是仍然允许子类的成员来访问它们。这个时候就需要使用到protected。

  对于protected而言,就类用户而言,他是private,但是对于任何继承与此类的子类而言或者其他任何位于同一个包的类而言,他却是可以访问的。

class Person {
    private String name;
    private int age;
    private String sex;
    protected String getName() {
        return name;
    }
    protected void setName(String name) {
        this.name = name;
    }
    public String toString() {
        return"this name is " + name;
    }
    /** 省略其他setter、getter方法 **/
}
public class Husband extends Person {
    private Wife wife;
    public String toString() {
        setName("show"); // 调用父类的setName();
        return super.toString(); // 调用父类的toString()方法
    }
    publics tatic void main(String[] args) {
        Husband husband = new Husband();
        System.out.println(husband.toString());
    }
}
Output:
this name is show

  从上面示例可以看出子类Husband可以明显地调用父类Person的setName()。

  尽管可以使用protected访问修饰符来限制父类属性和方法的访问权限,但是最好的方式还是将属性保持为private(我们应当一致保留更改底层实现),通过protected方法来控制类的继承者的访问权限。

向上转型

  在上面的继承中我们谈到继承是is-a的相互关系,猫继承于动物,所以我们可以说猫是动物,或者说猫是动物的一种。这样将猫看做动物就是向上转型。如下:

class Person {
    public void display() {
        System.out.println("Play Person...");
    }
    static void display(Person person) {
        person.display();
    }
}
public class Husband extends Person {
    public staticvoid main(String[] args) {
        Husband husband = new Husband();
        Person.display(husband); // 向上转型
    }
}

  在这我们通过Person.display(husband)。这句话可以看出husband是person类型。

  将子类转换成父类,在继承关系上面是向上移动的,所以一般称之为向上转型。由于向上转型是从一个叫专用类型向较通用类型转换,所以它总是安全的,唯一发生变化的可能就是属性和方法的丢失。这就是为什么编译器在“未曾明确表示转型”或“未曾指定特殊标记”的情况下,仍然允许向上转型的原因。

小结

上面讲了继承所带来的诸多好处,那我们是不是就可以大肆地使用继承呢?慎用继承。

首先我们需要明确,继承存在如下缺陷:

1、父类变,子类就必须变。

2、继承破坏了封装,对于父类而言,它的实现细节对与子类来说都是透明的。

3、继承是一种强耦合关系。

所以说当我们使用继承的时候,我们需要确信使用继承确实是有效可行的办法。那么到底要不要使用继承呢?《Think in java》中提供了解决办法:问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型,则继承是必要的,但是如果不需要,则应当好好考虑自己是否需要继承。

时间: 2024-10-15 02:20:18

java三大特性--继承的相关文章

Java提高篇之理解java的三大特性——继承

在<Think in java>中有这样一句话:复用代码是Java众多引人注目的功能之一.但要想成为极具革命性的语言,仅仅能够复制代码并对加以改变是不够的,它还必须能够做更多的事情.在这句话中最引人注目的是"复用代码",尽可能的复用代码使我们程序员一直在追求的,现在我来介绍一种复用代码的方式,也是java三大特性之一-继承. 继承 在讲解之前我们先看一个例子,该例子是前篇博文(java提高篇之理解java的三大特性--封装)的. 从这里我们可以看出,Wife.Husband

java三大特性之一继承

继承 众所周知,java是跨平台,健壮性的语言 他拥有封装,继承,多态三大特性 继承: 首先,子类继承父类之后,子类可以拥有父类的的方法,构造方法不能被继承 使用场景: 如果我们定义好几个类,每个类都拥有相同的方法或者参数, 然后我们就可以抽取相同的内容为父类,然后子类继承父类的参数或者方法,极大的提高了 代码的复用性,减少了我们的工作量 范例: public class Demo { public static void main(String[] args) { teacher t = ne

Java入门——深入理解Java三大特性

Java入门——深入理解Java三大特性 本Blog内容: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法(getter,setter),如果不想被外界方法,我们大可不必提供方法给外界访问. 封装确实可以使我们容易地修改类的内部实现,而无需修改使用了该类的客户代码. 可以对成员变量进行更精确的控制.(在setter方法中进行实际意义的校验) 总结:控制属性访问权限,不是你想改就能改.容易修改属性类型.精确控制属性的取值范围. 继承 继承是使用已存在的类

java三大特性-----------------------多态

Java三大特性之多态 多态的定义:指允许不同类的对象对同一个消息做出响应,即同一消息可以根据发送对象的不同采用多种行为方式. 就我个人经历来说,对一个新人一开始就理解这个定义还是有一点难度的(可能是我比较蠢).我觉的还是用java的方式来理解可能会简单一点: 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决

浅谈Java三大特性

Java三大特性想必大家都不陌生:封装.继承以及多态.很多刚接触Java的小伙伴都会想,它们到底有什么了不得之处,又赋予Java这门编程语言什么魔力呢?今天我们来探讨一下吧~~ 首先,名词解释: 封装,即是隐藏一切可隐藏的东西,对外界只提供最简单的编程接口.比如,在一个类中,把数据和操作方法绑定起来,对数据的访问只能通过这些 get/set 方法(又称为接口)来实现. 为什么封装?比如,我是一个厨师,我有一本食谱,你今天想吃肉,让我帮忙露两手.具体加了多少盐,放了多少醋你不需要关心(隐藏具体实现

跟王老师学Java三大特性(一):案例 QuickHit:需求分析

项目案例:QuickHit:需求分析 主讲教师:王少华   QQ群号:483773664 学习目标 学会用面向对象思想来进行需求分析 一.需求 根据输入速率和正确率将玩家分为不同级别 级别越高,一次显示的字符数越多,玩家正确输入一次的得分也越高 规定时间内完成规定次数的输入,正确率达到规定要求,则升级 玩家最高级别为6级.初始级别一律为1级 用户错误输入一次,游戏结束 二.面向对象分析 (一) 发现类 玩家(Player)类 游戏(Game)类 级别(Level)类 (二)发现类的属性 1.玩家

java三大特性之封装

1.封装 封装概述:是指隐藏对象的属性和实现细节,仅仅对外提供公共访问方式. 好处: 隐藏实现细节,提供公共的访问方式 提高了代码的复用性 提高了安全性 封装原则: 将不需要对外提供的内容都隐藏起来. 把属性隐藏,提供公共方法对其访问. 2.private关键字 private关键字是一个权限修饰分,可以修饰成员变量和成员方法,被private修饰的成员变量或成员方法只能在本类中使用. private最常见的应用:1.把成员变量用private修饰 2.提供对应的setter和getter方法.

跟王老师学Java三大特性(三):案例 QuickHit:确认输入并输出结果

案例 QuickHit:确认输入并输出结果 主讲教师:王少华   QQ群号:483773664 学习目标 完成Game类中的printResult方法的编写 一.需求说明 确认用户输入并输出结果 二.思路分析 确认玩家输入是否正确 如果输入不正确,则直接输出错误信息并退出程序 如果输入正确 如果超时,则直接输出错误信息并退出程序 如果不超时 计算玩家当前积分 计算 玩家已用的时间 输出当前玩家的级别.当前积分.已用时间: 判断用户是已经闯过最后一关并处理 三.参考代码 1 2 3 4 5 6 7

Golang-面向对象编程三大特性-继承、多重继承

Golang-面向对象编程三大特性-继承 继承基本介绍和示意图 继承可以解决代码复用,让我们的编程更加靠近人类思维. 当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体(比如刚才的Student),在该结构体中定义这些相同的属性和方法. 其它的结构体不需要重新定义这些属性(字段)和方法,只需嵌套一个 Student 匿名结构体即可. [画出示意图] 也就是说:在 Golang 中,如果一个 struct 嵌套了另一个匿名结构体,那么这个结构体可以直接访问匿名结构体的字段和