java 类继承map java类的继承代码

目录

1、继承概述

2、继承的好处和弊端

3、继承中变量的访问特点

4、super关键字

5、基础中构造方法的访问特点

6、方法重写

---

继承是所有OOP语言和Java语言不可缺少的组成部分。当创建一个类时，一定会继承其他的类，即使自己没有定义继承任何父类，Java语言也会隐式继承Java的标准根基类Object。既然继承这么重要，我们就一起来好好研究一下吧！

1、继承概述

继承的格式

• 格式：public class 子类名 extends 父类名{}
• 范例：public class Son extends Father{}
• Father：是父类，也被称为基类、超类
• Son：是子类，也被称为派生类

继承中子类的特点

• 子类可以有父类的内容
• 子类还可以有自己的内容

比如定义一个Farher类，再定义一个Son类继承Father的姓氏和方法。请看下面代码：

public class Father {
    public String name="李";

    public void showFather(){
        System.out.println("我是父亲，我姓："+name);
    }
}

public class Son extends Father{
    public void showSon(){
        System.out.println("我是儿子，我姓："+name);
    }
}

public class Main {
    public static void main(String[] args){
        Son son = new Son();
        son.showSon();
        son.showFather();
    }
}

子类Son继承了父类Father的name和showFather方法，运行结果：

2、继承的好处和弊端

继承好处：

• 提高了代码的复用性（多个类相同的成员可以放在同一个类中）
• 提高了代码的维护性（如果方法的代码需要修改，修改一处即可）

继承弊端

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

 

什么时候使用继承？

• 继承体现的关系：is a
• 假设法：有两个类A和B，如果这两个类之间满足A是B的一种，或者B是A的一种，就说明他们之间存在继承关系，这个时候就可以考虑继承来体现，否则就不能滥用继承。
• 举例：苹果和水果（继承）、动物和猫（继承）、狗和猫（非继承）

 

3、继承中变量的访问特点

在子类方法中访问一个变量

• 子类局部范围查找
• 子类成员范围查找
• 父类成员范围查找

请看下面的案例：

public class Father {
    public Integer age;
    public String name;
    public String sex;

    Father(){
        age = 56;
        name = "老子";
        sex = "男";
    }
}

public class Son extends Father{ //继承Father类
    public Integer age;
    public String name;

    Son(){
        age = 23;
        name = "儿子";
    }

    //子类局部范围查找
    public void showAge(){
        Integer age = 22;
        System.out.println("我的年龄是："+age);
    }

    //子类成员范围查找
    public void showName(){
        System.out.println("我的名字是："+name);
    }

    //父类成员范围查找
    public void showSex(){
        System.out.println("我的性别是："+sex);
    }
}

测试类如下：

public class MainDemo {
    //测试类
    public static void main(String[] args) {
        Son son = new Son();
        son.showAge();  //子类局部范围查找
        son.showName(); //子类成员范围查找
        son.showSex();  //父类成员范围查找
    }
}

测试结果：

4、super关键字

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

this代表本类对象的引用

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

关键字	访问成员变量	访问构造函数	访问成员方法
this	this.成员变量 访问本类成员变量	this(...) 访问本类构造方法	this.成员方法(...) 访问本类成员方法
super	super.成员变量 访问父类成员变量	super(...) 访问父类构造方法	super.成员方法(...) 访问父类成员方法

//父类
public class Father {
    public Integer age;
    public String name;
    public String sex;

    Father(){
        age = 56;
        name = "老子";
        sex = "男";
    }
}

//子类继承父类Father
public class Son extends Father{
    public Integer age;
    public String name;

    Son(){
        age = 23;
        name = "儿子";
    }

    //子类局部范围查找
    public void showAge(){
        Integer age = 22;
        System.out.println("我的年龄是："+age);
    }
    
    //父类局部范围查找
    public void showFatherAge(){
        System.out.println("我父亲的年龄是："+super.age);
    }
}

public class MainDemo {
    //测试类
    public static void main(String[] args) {
        Son son = new Son();
        son.showAge();  //输出子类的年龄值
        son.showFatherAge();//输出父类的年龄值
    }
}

程序运行结果：

5、基础中构造方法的访问特点

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

• 子类会继承父类的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类的初始化。
• 每一个子类构造方法的第一条语句默认都是：super()

如果父类中没有无参构造方法，只有带参构造方法，该怎么办？

• 通过使用super关键字去显示的调用父类的带参构造方法
• 只能在子类构造函数中显示调用父类构造函数，而且必须在子类构造函数第一行代码显示调用

//父类
public class Father {
    public Integer age;
    public String name;
    public String sex;

    //默认构造函数
    Father(){
        System.out.println("我是父类无参构造方法");
        age = 56;
        name = "老子";
        sex = "男";

    }

    //有参构造函数
    Father(Integer age){
        System.out.println("我是父类有参构造方法");
        this.age = age;
    }
}

//子类继承父类Father
public class Son extends Father{
    public Integer age;
    public String name;

    //默认构造函数
    Son(){
        System.out.println("我是子类无参构造方法");
        age = 23;
        name = "儿子";
    }

    //有参构造函数
    Son(Integer age){
        super(60); //显示调用父类构造函数，必须放在子类构造函数的第一行代码
        System.out.println("我是子类有参构造方法");
        this.age = age;
        name = "儿子";
    }

    //输出儿子的年龄
    public void showAge(){
        System.out.println("我的年龄是："+age);
    }

    //输出父亲的年龄
    public void showFatherAge(){
        System.out.println("我父亲的年龄是："+super.age);
    }
}

public class MainDemo {
    //测试类
    public static void main(String[] args) {
        Son son = new Son(); //此时先调用父类默认构造方法，再调用子类无参构造方法
        son.showAge();  //输出子类的年龄值
        son.showFatherAge();//输出父类的年龄值

        Son son1 = new Son(30); //此时先调用父类有参构造方法，再调用子类有参构造方法
        son1.showAge();  //输出子类的年龄值
        son1.showFatherAge();//输出父类的年龄值
    }
}

程序运行结果：

6、方法重写

方法重写概述

• 子类中出现了和父类中一模一样的方法声明
• 子类修改来自父类继承的方法

例如：子类和父类都有showAge()方法时，子类就重写了父类的showAge()方法

//父类
public class Father {
    public Integer age;
    public String name;
    public String sex;

    //默认构造函数
    Father(){
        age = 56;
        name = "老子";
        sex = "男";
    }

    //输出年龄
    public void showAge(){
        System.out.println("我的年龄是："+age);
    }
}

//子类继承父类Father
public class Son extends Father{
    public Integer age;
    public String name;

    //默认构造函数
    Son(){
        age = 23;
        name = "儿子";
    }

    //输出儿子的年龄
    public void showAge(){
        System.out.println("我的年龄是："+age);
    }

}

public class MainDemo {
    //测试类
    public static void main(String[] args) {
        Son son = new Son(); //此时先调用父类默认构造方法，再调用子类无参构造方法
        son.showAge();  //此时会调用子类重写后的方法
    }
}

程序运行结果：

End：感谢您阅读全文！