• java面向对象(继承)


    一.继承的概念

    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

    在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类,子类会自动拥有父类所有可继承的属性和方法

    二.类继承的格式

    通过 extends 关键字可以申明一个类是从另外一个类继承而来

    class 父类 {
    }
     
    class 子类 extends 父类 {
    }
    /*
     * 定义员工类Employee
     */
    class Employee {
        String name; // 定义name属性
        // 定义员工的工作方法
        public void work() {
            System.out.println("尽心尽力地工作");
        }
    }
    class Developer extends Employee {
        // 定义一个打印name的方法
        public void printName() {
            System.out.println("name=" + name);
        }
    }
    public class Example01 {
        public static void main(String[] args) {
            Developer d = new Developer(); // 创建一个研发部员工类对象
            d.name = "小明"; // 为该员工类的name属性进行赋值
            d.printName(); // 调用该员工的printName()方法
            d.work(); // 调用Developer类继承来的work()方法
        }
    }

    Developer类通过extends关键字继承了Employee类,这样Developer类便是Employee类的子类。

    子类虽然没有定义name属性和work()方法,但是却能访问这两个成员

    子类在继承父类的时候,会自动拥有父类的成员

    三.继承的好处和继承类型

    1.继承的出现提高了代码的复用性,提高软件开发效率。

    2.继承的出现让类与类之间产生了关系,提供了多态的前提。

     

    四.继承的特性

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

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

    子类可以用自己的方式实现父类的方法。

    Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 A 类继承 B 类,B 类继承 C 类,所以按照关系就是 C 类是 B 类的父类,B 类是 A 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。

    提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

    五.继承-子父类中成员变量的特点

    class Fu
    {
        //Fu中的成员变量。
        int num = 5;
    }
    class Zi extends Fu
    {
        //Zi中的成员变量
        int num2 = 6;
        //Zi中的成员方法
        public void show()
        {
            //访问父类中的num
            System.out.println("Fu num="+num);
            //访问子类中的num2
            System.out.println("Zi num2="+num2);
        }
    }
    class Demo 
    {
        public static void main(String[] args) 
        {
            Zi z = new Zi(); //创建子类对象
            z.show(); //调用子类中的show方法
        }
    }

    Fu类中的成员变量是非私有的,子类中可以直接访问,若Fu类中的成员变量私有了,子类是不能直接访问的。

    当子父类中出现了同名成员变量时,在子类中若要访问父类中的成员变量,必须使用关键字super来完成。super用来表示当前对象中包含的父类对象空间的引用。

    在子类中,访问父类中的成员变量格式:
    super.父类中的成员变量
    class Fu
    {
        //Fu中的成员变量。
        int num = 5;
    }
    class Zi extends Fu
    {
        //Zi中的成员变量
        int num = 6;
        void show()
        {
            //子父类中出现了同名的成员变量时
            //在子类中需要访问父类中非私有成员变量时,需要使用super关键字
            //访问父类中的num
            System.out.println("Fu num="+super.num);
            //访问子类中的num2
            System.out.println("Zi num2="+this.num);
        }
    }
    class Demo5 
    {
        public static void main(String[] args) 
        {
            Zi z = new Zi(); //创建子类对象
            z.show(); //调用子类中的show方法
        }
    }

    六.继承-子父类中成员方法特点-重写&应用

    1.子父类中成员方法的特点:当在程序中通过对象调用方法时,会先在子类中查找有没有对应的方法,若子类中存在就会执行子类中的方法,若子类中不存在就会执行父类中相应的方法。

    class Fu{
        public void show(){
            System.out.println("Fu类中的show方法执行");
        }
    }
    class Zi extends Fu{
        public void show2(){
            System.out.println("Zi类中的show2方法执行");
        }
    }
    public  class Test{
        public static void main(String[] args) {
            Zi z = new Zi();
            z.show(); //子类中没有show方法,但是可以找到父类方法去执行
            z.show2();
        }
    }

    2.成员方法特殊情况——覆盖:子类中出现与父类一模一样的方法时,会出现覆盖操作,也称为override重写、复写或者覆盖。

    class Fu
    {
        public void show()
        {
            System.out.println("Fu show");
        }
    }
    class Zi extends Fu
    {
        //子类复写了父类的show方法
        public void show()
        {
            System.out.println("Zi show");
        }
    }

    3.方法重写(覆盖)的应用

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

    在子类中,访问父类中的成员方法格式:
    super.父类中的成员方法();
    public class Test {
        public static void main(String[] args) {
            new NewPhone().showNum();
        }
    }
    
    //手机类
    class Phone{
        public void sendMessage(){
            System.out.println("发短信");
        }
        public void call(){
            System.out.println("打电话");
        }
        public void showNum(){
            System.out.println("来电显示号码");
        }
    }
    
    //智能手机类
    class NewPhone extends Phone{
        
        //覆盖父类的来电显示号码功能,并增加自己的显示姓名和图片功能
        public void showNum(){
            //调用父类已经存在的功能使用super
            super.showNum();
            //增加自己特有显示姓名和图片功能
            System.out.println("显示来电姓名");
            System.out.println("显示头像");
        }
    }

    当描述一个手机时,它具有发短信,打电话,显示来电号码功能,后期由于手机需要在来电显示功能中增加显示姓名和头像,这时可以重新定义一个类描述智能手机,并继承原有描述手机的类。并在新定义的类中覆盖来电显示功能,在其中增加显示姓名和头像功能

    七.方法重写的注意事项

    子类方法覆盖父类方法,必须要保证权限大于等于父类权限。

    class Fu(){    
    void show(){}
        public void method(){}
    }
    class Zi() extends Fu{
    public void show(){}  //编译运行没问题
        void method(){}      //编译错误
    }

    写法上稍微注意:必须一模一样:方法的返回值类型 方法名 参数列表都要一样。

    当一个类是另一个类中的一种时,可以通过继承,来继承属性与功能。如果父类具备的功能内容需要子类特殊定义时,进行方法重写。

  • 相关阅读:
    揭秘数字行为:快速地多次点击
    MySQL事务在MGR中的漫游记—路线图
    如何成为一名获客专家?
    10分钟快速构建汽车零售看板
    聊一聊整车厂的那些事——售后配件业务
    网易云易盾牵手百视通 助力广电领域新媒体内容安全
    人工智能热门图书(深度学习、TensorFlow)免费送!
    dubbo异步调用原理 (1)
    dubbo事件通知机制 (2)
    dubbo事件通知机制(1)
  • 原文地址:https://www.cnblogs.com/akiyama/p/10222145.html
Copyright © 2020-2023  润新知