Java中面向对象三大特性之继承

1. 继承的概述

继承就是子类继承父类的变量和方法，下面用代码解释一下：

class Student {// 定义学生类

String name;

int age;

void study() {

System.out.println(name + "studay good" + age);

}

}

class Work {// 定义工人类

String name;

int age;

void work() {

System.out.println(name + "work good" + age);

}

}

从上述例子中可以看到，学生类和工人类都有共同的特征，为了实现代码复用性，进行抽取，java中抽取用类表示将共有的的行为或特征进行抽取，然后原来的来类也要可以用，我们就需要用原来类继承我们抽取的类，用extends关键字进行调用，如：

class Student extends Person {// 定义学生类

void study() {

System.out.println(name + "studay good" + age);

}

}

class Work extends Person {// 定义工人类

void work() {

System.out.println(name + "work good" + age);

}

}

class Person {// 定义我们抽取的类

String name;

int age;

}

通常称Person（被继承的类）类为父类（也叫操类，基类），称Work和Student（继承类）称为子类。

2. 继承的优点

提高代码复用性

让类与类产生关系，给多态提供了前提

java支持单继承，不支持多继承，对C++多继承进行改良

单继承：一个子类只能有一个直接父类

class A {

}

class B {

}

class C extends A {

}

或者

class A {

}

class B {

}

class C extends B {

}

多继承：一个子类能有多个直接父类(为什么不能多继承)【不直接支持，会产生调用的不确定性】

class A {

void show() {

System.out.println(a);

}

}

class B {

void show() {

System.out.println(b);

}

}

class C extends A,B {

}

当我们new c();调用show方法，调用的是A的还是B的？为了区分java对此进行了改良，不用多继承，用接口

java支持多层（多重继承）=>传递性

class A {

}

class B extends A {

}

class C extends B {

}

3. 类的继承原则

单继承

继承具有传递性

继承不能循环

除Object类，所有类都有父类

4. 继承的使用

当要使用一个继承体系时，如何使用 ?

查看该体系中顶层类，了解该体系的基本功能。

创建该体系中最子类的对象，完成功能的使用。

什么时候写继承？

当类存在所属关系，就定义继承，A属于B,则A继承B

5. 继承中的成员变量

当本类局部和成员变量名相同时用this区分

当子父类中成员变量相同时用super区分

this和super的用法很相似

this：代表一个本类对象的引用

super：代表一个父类空间

class A {

int num = 5;

}

class B extends A {

int num = 10;

void show() {

System.out.println(this.num + "……" + super.num);//调用子类和父类的成员变量

}

}

注意：子类不能直接访问父类的私有成员

6. 继承中的成员方法

class A {

int num = 5;

void show1() {

System.out.println(num);

}

}

class B extends A {

int num = 10;

void show2() {

System.out.println(num);

}

}

public class Extendstext {

public static void main(String[] args) {

B b = new B();

b.show1();

b.show2();

}

}

当子父类中函数一样，将会运行子类的函数，称为覆盖操作

class A {

int num = 5;

void show() {

System.out.println(num);

}

}

class B extends A {

int num = 10;

void show() {

System.out.println(num);

}

}

public class Extendstext {

public static void main(String[] args) {

B b = new B();

b.show();

}

}

6.1 函数的两个特性

重载：同一个类

覆盖：子类中，覆盖也叫重写

6.2 注意事项

子类的方法覆盖父类方法时，子类的权限必须大于父类的权限

静态只能覆盖外汇返佣静态，或被静态覆盖

6.3 什么时候使用覆盖操作

当对一个类进行子类扩展时，子类需要保留父类的功能声明，但要定义子类中功能的特有内容时，就用覆盖操作完成。(修改方法，添加功能)如：

class Phone {// 定义一个手机类

void call() {// 通话功能

}

void show() {// 展示功能

System.out.println("number");

}

}

class newphone extends Phone {

void show() {// 展示功能重写

System.out.println("name");

System.out.println("jpg");

System.out.println("number");

}

}

或者

class newphone extends Phone {

void show() {// 展示功能重写

System.out.println("name");

System.out.println("jpg");

super.show();//调用父类show方法

}

}

7. 继承中的构造函数

在子类构造对象时，访问子类构造函数时，父类也运行，在子类的构造函数中，有一个默认的隐士语句，super();调用父类中空参数的构造函数，无覆盖，无继承

无参数

class fu {

fu() {

System.out.println("fu run");

}

}

class zi extends fu {

zi() {

super();//隐士自带的调用父类空参数构造函数

System.out.println("zi run");

}

}

有参数

class fu {

fu(int x) {

System.out.println("fu run");

}

}

class zi extends fu {

zi() {

super(4);//隐士自带的调用父类空参数构造函数

System.out.println("zi run");

}

}

子类的实例化过程，子类中的每个构造函数都会访问父类中空参数的构造函数

结果：AC AD

public class Extendstext {

public static void main(String[] args) {

new zi();

new zi(6);

}

}

class fu {

fu(){

System.out.println("A");

}

fu(int x) {

System.out.println("B");

}

}

class zi extends fu {

zi() {

System.out.println("C");

}

zi(int x){

System.out.println("D");

}

}

结果：BD

public class Extendstext {

public static void main(String[] args) {

new zi(6);

}

}

class fu {

fu(){

System.out.println("A");

}

fu(int x) {

System.out.println("B");

}

}

class zi extends fu {

zi() {

System.out.println("C");

}

zi(int x){

super(x);//覆盖隐式super();

System.out.println("D");

}

}

继承的优势 ：

提高代码的复用性，更简洁。

关于继承的内存结构 ：（代码如下）

//子类

package com.ss.cn;

/*

* 面向对象 --继承

* 要创建俩个老师的类 java php老师

*  老师有什么属性 :name age

*  老师的行为  ：teach  sleep 休息

*

*/

public class JavaTeacher extends Teacher {

//利用封装的方式

/*private String name;

private int age;*/

//方法 ：

public void teach() {

/*

* 就是说的当前那么不是子类中的name，不是本类的东西那是绝对访问不了

* name现在在父类中，private String name 私有的受保护的，就是说其他类要是访问不了的，即使他有继承的关系

*

*/

System.out.println(getName()+"在教课");

}

//为什么要setget 方法

/*

* 利用封装时要想取得到值 也必须需要生成set/get方法

* 生成set/get方法快捷键 ： shift+alt+s

*/

}

//子类 ：

package com.ss.cn;

/*

* 面向对象 --继承

* 要创建俩个老师的类 java php老师

*  老师有什么属性 :name age

*  老师的行为  ：teach  sleep 休息

*  创建老师的父类

*  继承的语法 ：关键字 extends

*    class 子类 extends 父类{

*      子类的属性；

*      子类的方法；

*    }

*    特点 ： 子类会把福父类的所有属性和方法继承下来（出来final）

*/

public class HtmlTeacher extends Teacher{

public void teach() {

System.out.println(getName()+"在教html课");

}

}

package com.ss.cn;

//父类

public class Teacher {

//公共类

private  String name;

private  int age;

public void sleep() {

System.out.println(name+"在睡觉");

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

//测试类

package com.ss.cn;

public class ExtendsDemo {

public static void main(String[] args) {

// TODO Auto-generated method stub

//1.对象中的属性就必须创建对象

JavaTeacher jTeacher=new JavaTeacher();

jTeacher.setName("Mrs");

jTeacher.setAge(25);

jTeacher.teach();

//同理 ：

HtmlTeacher hTeacher=new HtmlTeacher();

hTeacher.setName("ssy");

hTeacher.setAge(23);

hTeacher.sleep();

hTeacher.teach();

}

}

为什么自子类实例化的时候，会调用父类构造方法？

子类继承父类，所以子类有父类的属性，在使用父类内容前，要先看父类如何对自己的内容进行初始化，所以子类构造函数初始化的时候，必须调用父类构造函数，所以在子类的构造函数默认加了super();

如果父类中没有定义无参构造函数或者说是父类中定义了有参，没有定义无参，那么必须用super();来指定调用父类的构造函数

如果子类的构造函数中使用了this();调用本类的构造函数，那么super();就没有了，因为super和this只能定义在第一行，所以只能有一个，但是可以保证的是，子类中肯定会有其他构造方法来访问父类的构造函数。

注意：super();语句必须要定义在子类构造函数的第一行，因为父类的初始化要先完成