11_Java中的继承

Java中的继承

一、继承概述

1、继承概述：

在类中：有一些类具有一些相同的属性和方法，即相同的一些特征。

继承是面向对象的三大特性之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义、追加属性和方法

2、继承格式：

格式：

public class 子类名 extends 父类名{}	//extends 继承、扩展
//示例：
public class Son extends Base{}
//Son:	是子类，也称为派生类
//Base:	是父类，也称为基类，超类

3、继承中子类的特点：

子类可以有父类的内容

子类还可以有自己特有的内容

思考？当子类与父类中有同名属性和方法时，调用时如何区分？

二、继承的好处和弊端

1、继承的好处：

提高了代码的复用性（多个类相同的成员可以放到同一个类中）

提高了代码的维护性（如果方法需要修改，只用将父类修改既可）

2、继承的弊端：

继承让类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

3、什么时候使用继承：

继承体现的关系：is a

假设法：我有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们之间存在继承关系，这个时候就可以考虑使用继承来实现，否则就不能滥用继承。

举例：苹果 和 水果，猫 和 动物

三、继承中变量访问的特点：

在子类的方法中访问一个变量时访问优先顺序是

1、子类局部范围（方法中）找

2、子类成员范围（本类中）找

3、父类成员范围（父类中）找

如果都没有就报错：注意这里只考虑到父亲，父亲以上不考虑

package com.itheima_02;
/*
父类
 */
public class Base {
    //成员变量
    public int age = 40;    //此处为了测试使用public权限
}

package com.itheima_02;
/*
子类
 */
public class Son extends Base{
    //成员属性
    public int height = 175;    //身高

    public int age = 20;        //年龄 当子类中存在这个成员属性时会优先调用自己的

    //show方法
    public void show(){
        int age = 30;           //没有用this指针来指明是 又优先使用的方法里面的age变量
        System.out.println(age);
        System.out.println(height);
        //报错 方法中找不到->本类中找不到->父类中也找不到
//        System.out.println(weight);
    }
}

package com.itheima_02;
/*
测试类
 */
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Son s = new Son();
        s.show();
    }
}

四、super关键字

1、super与this:

用于访问父类成员变量

在Java中貌似没有作用域的方法：

super关键字的用法和this关键字的用法相似

this：代表本类对象的引用

super：代表父类存储空间的标识（可以理解为父类对象引用）

2、两个关键字的使用：

关键字	访问成员变量	访问构造方法 （...表示参数）	访问成员方法
this	this.成员变量 访问本类成员变量	this(...) 访问本类构造方法	this.成员方法名(...) 访问成员方法
super	super.成员变量 访问父类成员变量	super(...) 访问父类构造方法	super.成员方法(...) 访问父类成员方法

3、参考代码：

package com.itheima_03;
/*
父类
 */
public class Base {
    public int age = 40;
}

package com.itheima_03;
/*
子类
 */
public class Son extends Base{
    public int age = 20;

    public void show(){
        int age = 30;
        System.out.println(age);

        //需求，访问本类中的成员变量？ this指针
        System.out.println(this.age);

        //我要访问父类的成员变量？  super
        System.out.println(super.age);
    }
}

package com.itheima_03;
/*
测试类
 */
public class Demo {
    public static void main(String[] args){
        //创建对象，调用方法
        Son s = new Son();
        s.show();

    }
}

4、参考（看着玩就行）：

//C++中可以通过作用域 来区分调用 子类、父类、方法中 同名变量 的位置
#include <iostream>
using namespace std;
class Base 
{
public:
	int age = 40;
};

class Son :public Base 
{
public:
	int age = 20;

public:
	void show() 
	{
		int age = 10;
		//调用父类
		cout << Base::age << endl;
		//调用子类
		cout << Son::age << endl;	//或者cout<<this->age<<endl;
		//调用方法中的变量
		cout << age << endl;
	}
};

int main()
{
	Son s;
	s.show();

	system("pause");
	return 0;
}

五、继承中构造方法的访问特点：

理解提示：先有父亲 才能 有你，所以父类先要初始化

1、子类中的所有的构造方法默认都会访问父类中无参构造方法

为什么？

1、因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化

2、每一个子类构造方法的第一条语句默认都是：super() -> 表示调用父类构造函数 括号中无参数所以都是访问的父类无参构造

2、父类中没有无参构造方法，只有带参构造方法 或者说 我们想要先调用的是父类中的有参构造方法

1、通过修改默认语句：super(); 为 super(参数列表); 来解决这两个问题

2、如果只是前者，我们推荐补全父类无参构造

3、参考代码：

package com.itheima_04;
/*
父类
 */
public class Base {
    public Base(){
        System.out.println("父类无参构造方法被调用");
    }

    public Base(int age){
        System.out.println("父类有参构造方法被调用");
    }
}

package com.itheima_04;
/*
子类
 */
public class Son extends Base{
    public Son(){
//        super();  默认存在可以不写
// 如果 需要调用父类中的带参构造方法（或者父类无无参构造：写了有参没写无参）就 使用带参语句super(参数列表);
        super(10);
        System.out.println("子类无参构造方法被调用");
    }

    public Son(int age){
//        super();  默认存在可以不写
        super(10);    //如果 需要调用父类中的带参构造方法就 使用带参语句super(参数列表);
        System.out.println("子类有参构造方法被调用");
    }
}

package com.itheima_04;
/*
测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建对象
        Son s = new Son();  //可以发现先调用了父类的无参构造

        Son s2 = new Son(10);

    }
}

六、继承中成员方法的访问特点

通过子类对象访问一个方法

1、子类范围找

2、父类范围找

如果还没找到就报错（同变量，不考虑父亲的父...）

package com.itheima_05;
/*
父类
 */
public class Base {
    public Base(){};


    public void show(){
        System.out.println("父类中show方法的调用");
    }
}

package com.itheima_05;
/*
子类
 */
public class Son extends Base{
    public Son(){};

    public void method(){
        System.out.println("子类中method方法的调用");
    }

    public void show(){
        super.show();
        System.out.println("子类中show方法被调用");
    }
}

package com.itheima_05;
/*
测试类
 */
public class Demo {
    public static void main(String[] args){
        //创建对象调用方法
        Son s = new Son();
        s.method();

        s.show();
    }
}

总结：继承中的成员（包括方法和属性）由子类创建对象进行（同名成员）调用时是由近到远来寻找，也可以通过this与super关键字来直接限定调用和使用；而对于构造方法会通过默认语句调用父类无参，也可以通过修改默认语句调用有参构造方法

七、super内存图：

略...

八、方法重写

一、方法重写的概述：

1、方法重写概述：

子类中出现了和父类中一摸一样的方法声明

2、方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

3、练习手机类和新手机类：

@Override

是一个注释（注解后面会学习到）

可以帮助我们检查重写方法的方法声明的正确性

二、方法重写注意事项：

1、私有方法不能被重写（父类私有成员子类是不能继承的）

2、子类方法的访问权限不能更低（public > 默认 > private）

3、参考代码：

package com.itheima_07;
/*
父类
 */
public class Base {
    private void show(){
        System.out.println("父类中show()方法被调用");
    }

    void method(){
        System.out.println("父类中method()方法被调用");
    }

}

package com.itheima_07;
/*
子类
 */
public class Son extends Base{
    //子类不能继承父类中的 私有内容
    /* @Override
    private void show(){
        System.out.println("子类中show()方法被调用");
    }*/

   /* @Override
    public void method(){
        System.out.println("父类中method()方法被调用");
    }*/

    @Override
    public void method(){  //当不提供访问权限修饰符时 默认提供一个
        System.out.println("父类中method()方法被调用");
    }
}

九、Java中继承的注意事项

1、Java中类只支持单继承，不支持多继承

2、Java中类支持多层继承

3、参考代码：

package com.itheima_08;

public class Granddad {
    public void drink(){
        System.out.println("爷爷爱喝酒");
    }
}

package com.itheima_08;

public class Father extends Granddad{
    public void NoSmoke(){
        System.out.println("爸爸不爱抽烟");
    }
}

package com.itheima_08;

public class Mother {
    public void dance(){
        System.out.println("妈妈爱跳舞");
    }
}

package com.itheima_08;

/*  在Java中不支持多继承
public class Son extends Father, Mother{

}*/

public class Son extends Father{

}

十、继承案例

1、老师学生：

需求：先定义一个老师类和一个学生类，再抽取这两个类中的共性内容创建一个父类

package com.itheima_10;
/*
人类
 */
public class Person {
    private String name;
    private int age;

    public Person(){};

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return age;
    }
}

package com.itheima_10;
/*
学生类
 */
public class Student extends Person{
    //添加构造方法
    public Student(){};

    public Student(String name, int age){
//        this.name = name;	
//        this.age = age;
        super(name, age);
    }

    public void study(){
        System.out.println("好好学习，天天向上");
    }
}

package com.itheima_10;
/*
老师类
 */
public class Teacher extends Person{
    public Teacher(){}  //手动提供了无参构造，因为下面有有参构造

    public Teacher(String name, int age){
        //此处无法访问父类的私有权限
//        this.name = name;
//        this.age = age;
        super(name, age);
    }

    public void teach(){
        System.out.println("用爱成就每一位学生");
    }
}

package com.itheima_10;
/*
测试类
 */
public class PersonDemo {
    public static void main(String[] args){
        //1、创建一个老师类对象
        //无参构造
        Teacher t1 = new Teacher();
        t1.setName("张三");
        t1.setAge(30);
        System.out.println(t1.getName() + "," + t1.getAge());
        t1.teach();
        //有参构造
        Teacher t2 = new Teacher("李四", 33);
        System.out.println(t2.getName() + "," + t2.getAge());
        t2.teach();

        //2、创建一个学生类对象
        //无参构造
        Student s1 = new Student();
        s1.setName("小明");
        s1.setAge(18);
        System.out.println(s1.getName() + "," + s1.getAge());
        s1.study();

        //有参构造
        Student s2 = new Student("小红", 19);
        System.out.println(s2.getName() + "," + s2.getAge());
        s1.study();
    }
}

2、猫和狗：

package com.itheima_11;
/*
动物类
 */
public class Animal {
    //成员变量
    private String name;
    private int age;
    //构造方法
    public Animal(){};

    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }

    //set/get/show方法
    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public void setAge(int age){
        this.age = age;
    }

    public int getAge(){
        return this.age;
    }

    public void show(){
        System.out.println(getName() + "," + getAge());
    }
}

package com.itheima_11;
/*
猫类
 */
public class Cat extends Animal{
    //构造函数
    public Cat() {
    }

    public Cat(String name, int age) {
        //这里不能使用 this
        // 应为本类中没有提供这两个属性 而且父类中这两个属性是private没有继承过来
        super(name, age);
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

package com.itheima_11;
/*
狗类
 */
public class Dog extends Animal{
    //构造方法
    public Dog() {
    }

    public Dog(String name, int age) {
        //这里不能使用 this
        // 应为本类中没有提供这两个属性 而且父类中这两个属性是private没有继承过来
        super(name, age);
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

package com.itheima_11;
/*
测试类
 */
public class AnimalDemo {
    public static void main(String[] args){
        //创建猫类对象并进行测试
        Cat c1 = new Cat();
        c1.setName("加菲猫");
        c1.setAge(5);
        System.out.println(c1.getName() + "," + c1.getAge());
        c1.catchMouse();

        Cat c2 = new Cat("汤姆猫", 7);
        System.out.println(c2.getName() + "," + c2.getAge());
        c2.catchMouse();

        //创建狗类对象并进行测试
        Dog d1 = new Dog();
        d1.setName("旺财");
        d1.setAge(5);
        System.out.println(d1.getName() + "," + d1.getAge());
        d1.lookDoor();

        Dog d2 = new Dog("来福", 8);
        System.out.println(d2.getName() + "," + d2.getAge());
        d2.lookDoor();
    }
}