继承 订阅
按照法律或遵照遗嘱接受死者的财产、职务、头衔、地位等。 展开全文
按照法律或遵照遗嘱接受死者的财产、职务、头衔、地位等。
信息
词    目
继承
拼    音
jì chéng
基本解释
依法承受等
词    性
动词
用    法
谓语等
组    词
~权,~人等
继承基本信息
【词目】继承【拼音】jì chéng【基本解释】泛指把前人的作风、文化、知识等接受过来。
收起全文
精华内容
下载资源
问答
  • java中的继承 (extends) 详解

    万次阅读 多人点赞 2019-08-18 10:45:21
    继承(extends) 1. 父类与子类 父类也叫基类、超类 子类也叫派生类 在继承的而关系中,“子类就是一个父类“。也就是说,子类可以被当做父类来看待。例如父类是员工,子类是老师,那么我们可以说**”...

    继承(extends)

    1. 父类与子类

    • 父类也叫基类、超类

    • 子类也叫派生类

    • 在继承的而关系中,“子类就是一个父类“。也就是说,子类可以被当做父类来看待。例如父类是员工,子类是老师,那么我们可以说**”老师就是一个员工“**。

    2. 继承的格式

    2.1 定义父类的格式:(一个普通的类定义)

    public class 父类名称{
        //.....
    }
    

    2.2 定义子类的格式

    public class 子类名称 extends 父类名称{
        //.....
    }
    

    2.3 代码演示(老师类继承员工类)

    • 2.3.1 Employee类
    public class Employee(){
        public void method(){
            System.out.println("方法执行")
        }
    }
    
    • 2.3.2 Teacher类,继承自Employee类
    public class Teacher extends Employee{
    	//我们先不在里面添加任何东西
    }
    
    
    • 2.3.3 在main中,创建一个Teacher类的对象
    public class Main {
    
        public static void main(String[] args) {
    	    Teacher one = new Teacher();
            //Teacher类继承了Empolyee类的方法
    	    one.method();
        }
    }
    /*输出结果:
        执行方法
     */
    

    2.3.4 小结论

    Teacher类继承了Employee类,也就继承了它的 public void method() 方法,达到了代码复用的效果,当父类有我们子类需要用的方法时,我们就不用再去重新打一次,直接可以拿来用。

    3. 继承中成员变量的访问特点

    3.1 成员变量之间的访问 (变量不重名的情况)

    • 3.1.1 先创立一个父类Fu
    public class Fu {
        public int numFu = 10;  //关键字为public,可以直接通过(对象.变量名)访问,方便说明问题
    }
    
    • 3.1.2 再创立一个子类Zi
    public class Zi extends Fu{
        public int numZi = 20;
    }
    
    • 3.1.3 在main中分别建立父类和子类的对象
    public class Demo02ExtendsField {
        public static void main(String[] args) {
            //创建父类对象
            Fu fu = new Fu();
            //父类只能找到自己的成员numFu,并没有找到子类的成员numZi
            System.out.println(fu.numFu);
    
            //创立一个子类对象
            Zi zi = new Zi();
            //子类对象既可以打印父类的成员numFu,也可以打印自己的成员numZi
            //还是那句"先人不知道后人的事情,而后人知道先人的事情"
            System.out.println(zi.numFu);
            System.out.println(zi.numZi);
        }
    }
    

    3.2 成员变量之间的访问 (变量重名的情况)

    有两种情况:

    1. 直接通过对象访问成员变量:

      等号左边是谁,就优先用谁,没有则向上找

    2. 间接通过成员方法访问成员变量

      该方法属于谁,就优先用谁,没有则向上找

    • 假设现在父类 Fu 和子类 Zi 都有一个变量名叫num

    • Fu 类

      public class Fu {
          public int num = 10;
      
          public void methodFu(){
              //这里打印的num,一定是本类的,不会再往下找子类的
              System.out.println(num);
          }
      }
      
    • Zi类

      public class Zi extends Fu{
          public int num = 20;
      
          public void methodZi(){
              //这里打印的num,如果本类有,就优先打印本类的,如果没有再往上找
              System.out.println(num);
          }
      }
      

    第一种情况:直接通过对象访问成员变量

    等号左边是谁,就优先用谁,没有则向上找。Fu fu = new Zi();等号的左边是父类

    public class Demo02ExtendsField {
        public static void main(String[] args) {
         // Zi zi = new Fu(); 不能通过父类来构造子类,先人(父类)根本不知道后人(子类)长什么样子
            Fu fu = new Zi(); //可以通过子类来构造父类,这时等号左边是父类
            System.out.println(fu.num);  //10,打印的是父类的num
        }
    }
    

    第二种情况:间接通过成员方法访问成员变量

    public class Demo02ExtendsField {
        public static void main(String[] args) {
    
            Fu fu = new Fu();
            Zi zi = new Zi();
    
            //打印的是父类的num,因为该类没有继承其它类,他自己肯定有一个num,才能写出这个方法
            fu.methodFu();  //父类的num 10,补充:没有fu.methodZi(), 先人不知道后人的方法
    
            //如果子类有一个num,那就优先打印本类的,没有的话再往父类那里找
            zi.methodZi();  //子类的num 20
    
            //重点!子类用的是父类的方法打印num,这就要看这个方法属于谁,是谁定义的这个方法
            //因为methodFu()这个方法是属于父类的,打印的当然就是父类的num
            zi.methodFu();  //父类的num 10
        }
    }
    

    4. 区分子类方法中的重名

    假如有好多个num,父类有一个,子类有两个,怎么才能正确地打印想要的那个num呢?

    • 4.1 父类

      public class Fu {
          public int num = 10;
      }
      
    • 4.2 子类

      public class Zi extends Fu {
          public int num = 20;
      
          public void methodZi(){
              int num = 30;
              System.out.println(num);      //30, 局部变量
              System.out.println(this.num); //20, 本类的成员变量
              System.out.println(super.num);//10, 父类的成员变量
          }
      }
      
    • 4.3 看看子类方法 methodZi() 能不能正确区分三个num

      public class Demo03Main {
          public static void main(String[] args) {
              Zi zi = new Zi();
              zi.methodZi();  //30, 20, 10
          }
      }
      
    • 4.4 总结:要想正确地打印想要的num,可以这样打

      • 局部变量,上面的那个num = 30,就可以直接写
      • 本类的成员变量,上面的num = 20, 用this.成员变量名
      • 父类的成员变量,上面的num = 10, 用super.成员变量名

    5. 继承中成员方法重名的问题

    假如子类和父类都有一个方法叫 method() , 那怎么知道用的是哪一个呢?

    • 5.1 父类

      public class Fu {
          public void method(){
              System.out.println("父类重名方法执行");
          }
      }
      
    • 5.2 子类

      public class Zi extends Fu {
          public void method(){
              System.out.println("子类重名方法执行");
          }
      }
      
    • 5.3 在main中调用 method() 方法

      public class Demo04Main {
          public static void main(String[] args) {
              Fu fu1 = new Fu();
              Fu fu2 = new Zi(); //通过子类来构造fu2
              Zi zi = new Zi();
      
              fu1.method(); //父类重名方法执行, 用的是父类方法
              fu2.method(); //子类重名方法执行,用的是子类方法
              zi.method();  //子类重名方法执行, 用的是子类方法
          }
      }
      
    • 结论 :

    1. 创建的对象是谁,用谁的类来构造对象的,就优先用谁,如果没有就向上找。比如Fu fu2 = new Zi();,fu2是用子类来构造的,那fu2.method()就是用的子类的方法
    2. 注意!无论是成员变量还是成员方法,如果没有都是向上找父类,绝对不会向下找子类的。

    6. 继承方法中的覆盖重写

    5. 继承中成员方法重名的问题,我们可以引出重写(Override)的概念

    重写:在继承关系中,方法的名称一样,参数列表也一样

    • 6.1 重写 (Override) 和 重载 (Overload) 的区别

      重写:方法的名称一样,参数列表【也一样】。也叫覆盖、覆写

      重载:方法的名称一样,参数列表【不一样】。

    • 6.2 覆盖重写的注意事项 (了解)

      • 6.2.1 必须保证父子类之间方法的名称相同,参数列表也相同,否则无法进行覆盖重写

      • 6.2.2 注解:@Override,这个注解写在方法的前面,用来检验是不是有效的覆盖重写,例如当方法名写错了,@Override底下就会出现红色的波浪线,提示你这不是有效的覆盖重写。

        public class Zi extends Fu {
            @Override
            public void method(){
                System.out.println("子类重名方法执行");
            }
        }
        

        这个注解可写可不写,但是强烈推荐把它写上去。

      • 6.2.3 子类方法的返回值必须【小于等于】父类方法的返回值范围。java.lang.Object是所有类的公共最高父类(祖宗类),每个类都默认继承了它,例如String类就是Object的子类。下面代码会报错,是因为返回值的范围问题

        • 6.2.3.1 父类

          public class Fu {
              public String method(){
                  System.out.println("父类重名方法执行");
              }
          }
          
        • 6.2.3.2 子类

          public class Zi extends Fu {
              @Override
              public Object method(){  //范围:Object > String 报错
                  System.out.println("子类重名方法执行");
              }
          }
          
      • 6.2.4 子类方法的权限必须【大于等于】父类方法的权限修饰符。权限的排名:public > protected > (default) > private。备注:(default)不是关键字default,而是什么都不写,留空,例如:

        public class Fu{
            int num; //num的访问权限是default
        }
        

        下面的代码会因为重写方法的权限问题而报错:

        • 6.2.4.1 父类

          public class Fu {
              public void method(){
                  System.out.println("父类重名方法执行");
              }
          }
          
        • 6.2.4.2 子类

          public class Zi extends Fu {
              @Override
              protected void method(){  //protected < public 报错
                  System.out.println("子类重名方法执行");
              }
          }
          
          
    • 6.3 覆盖重写实战演练

      假如旧手机的功能有打电话、发短信、来电显示(显示号码)

      新手机的功能有来电显示、发短信、来电显示(显示号码、显示头像、显示姓名)

      可见新旧手机的打电话和发短信功能是一样的,但是新手机的来电显示功能比旧手机多了显示头像、显示姓名。

      我们可以把旧手机当做父类,把新手机当做子类,新手机只需要重写旧手机的来电显示功能即可

      • 6.3.1 旧手机是父类,名为Oldphone类

        public class Oldphone {  
            //打电话功能
            public void call(){
                System.out.println("打电话");
            }
            //发短信功能
            public void send(){
                System.out.println("发短信");
            }
            //来电显示功能
            public void show(){
                System.out.println("显示号码");
            }
        }
        
      • 6.3.2 新手机是子类,名为Newphone类

        public class Newphone extends Oldphone{
        
            @Override
            public void show() {
                super.show();  //不要修改原来的代码,直接通过super调用它,后面再添加新的内容
                System.out.println("显示头像");
                System.out.println("显示姓名");
            }
        }
        
      • 6.3.3 在main中实验一下

        public class Demo05Main {
            public static void main(String[] args) {
                Newphone newphone = new Newphone();
                newphone.call();
                newphone.send();
                newphone.show();
            }
        }
        /*输出结果:
            打电话
            发短信
            显示号码
            显示头像
            显示姓名
         */
        

    7. 继承中构造方法的访问特点

    7.1 概述

    子类的构造方法启动时,一定会先跑去启动父类的构造方法,等父类的构造方法执行完后,再去执行子类(本类)的构造方法。

    7.2 代码说明一下7.1

    • 7.2.1 父类(只有无参构造方法)

      public class Fu {
          //父类的无参构造方法
          public Fu(){
              System.out.println("父类构造方法执行");
          }
      }
      
      
    • 7.2.2 子类

      public class Zi extends Fu {
          //子类的无参构造方法
          public Zi(){
              System.out.println("子类构造方法执行");
          }
      }
      
      
    • 7.2.3 在main中构造一个子类

      public class Demo06Main {
          public static void main(String[] args) {
              Zi zi = new Zi();
          }
      }
      
      /*输出结果:
          父类构造方法执行
          子类构造方法执行
       */
      
    • 7.2.4 小总结

      其实子类的构造方法中隐含了super()调用,如果子类的构造方法没有写super(),编译器会帮我们默认加上去。子类就变成

      public class Zi extends Fu {
          //子类的无参构造方法
          public Zi(){
              super();  //注意!这句必须写在第一行的位置,如果父类构造函数有参数,就是super(参数),有                   参数的调用,必须要自己写上去,不然会默认调用无参构造
              System.out.println("子类构造方法执行");
          }
      }
      

    8. super关键字的三种用法总结

    8.1 用法1

    在子类的成员方法中,访问父类的成员变量,比如:

    • 8.1.1 父类

      public class Fu {
          public int num = 10;
      }
      
    • 8.1.2 子类

      public class Zi extends Fu {
          public int num = 20;
      
          public void methodZi(){
             // System.out.println(num);  这样打印的一定是本类的num
              System.out.println(super.num); //打印的是父类的num
          }
      }
      

    8.2 用法2

    在子类的成员方法中,访问父类的成员方法,比如:

    • 8.2.1 父类

      public class Fu {
          public void methodFu(){
              System.out.println("父类的成员方法执行");
          }
      }
      
      
    • 8.2.2 子类

      public class Zi extends Fu{
          public void methodZi(){
              super.methodFu(); //访问父类的methodFu()方法
              System.out.println("子类的成员方法执行");
          }
      }
      
    • 在main中执行子类的方法

      public class Demo07Main {
          public static void main(String[] args) {
              Zi zi = new Zi();
              zi.methodZi();
          }
      }
      /*输出结果:
          父类的成员方法执行
          子类的成员方法执行
       */
      

    8.3 用法3

    在子类的构造方法中,访问父类的构造方法。就在 7. 继承中构造方法的访问特点 中,请自行查阅。

    9. this关键字的三种用法

    9.1 概述

    9.1.1 在本类的成员方法中,访问本类的成员变量

    9.1.2 在本类的成员方法中,访问本类的另一个成员方法

    9.1.3 在本类的构造方法中,访问本类的另一个构造方法

    9.2 代码说明一下

    public class Zi extends Fu {
        private int num = 10;
    
        public Zi(){
            this(123);  //9.1.3 在本类的无参构造中调用有参构造
        }
    
        public Zi(int num){
            this.num = num;
        }
    
        public void methodZi(){
            System.out.println(this.num); //9.1.1 在本类的成员方法中,访问本类的成员变量
        }
    
        public void methodA(){
            System.out.println("A方法");
        }
    
        public void methodB(){
            this.methodA();  //9.1.2 在本类的成员方法中,访问本类的另一个成员方法
            System.out.println("B方法"); 
    
    

    9.3 注意事项

    • 在构造方法中调用this,那这个this调用必须是该函数中的第一个语句,也是唯一的一个
    • super和this两种在构造调用中,不能同时使用。两个都要排在第一行,我哪知道该怎么排。

    10. java继承的三个特点

    10.1 java语言是单继承

    一个类的直接父类只能有唯一的一个。

    class A{}
    class B extends A{}  正确写法
    class C{}
    class D extends A,C{} 错误写法,不能同时继承A和C
    

    试想假如class A{}有一个 method() 方法,

    Class C{}也有一个 method() 方法,

    子类D同时继承类A和类C,那当我新建一个D类对象d后,

    对象d想要调用父类的method方法,那它应该用A的 method() 还是C的 method() 呢?这就乱套了!

    在这里插入图片描述

    10.2 java语言是可以多级继承的

    虽然,java语言是单继承的,一个类的直接父类只有一个,类D不能同时继承类A和类C

    但是,可以让类A继承类C之后,类D再继承类A,C就是爷爷,A就是爸爸,D就是儿子

    类D --> 类A --> 类C,这就叫多级继承。
    在这里插入图片描述

    10.3 java语言中,一个父类可以有多个子类

    这就好比二胎政策,一个爸爸可以有多个儿子

    在这里插入图片描述

    展开全文
  • 新手小白学JAVA 继承 super

    万次阅读 多人点赞 2021-05-10 08:49:27
    1 继承 1.1概念 继承是面向对象最显著的一个特征 继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并扩展新的能力. Java继承是会用已存在的类的定义作为基础建立新类的技术 新类的定义可以增加...

    1 继承

    1.1概念

    继承是面向对象最显著的一个特征
    继承是从已有的类中派生出新的类,新类能吸收已有类的数据属性和行为,并扩展新的能力.
    Java继承是会用已存在的类的定义作为基础建立新类的技术
    新类的定义可以增加新的数据或者新的功能,也可以使用父类的功能,但不能选择性的继承父类(超类/基类)
    这种继承使得复用以前的代码非常容易,能够大大的缩短开发的周期,降低开发费用.

    1.2 特点

    1. 使用extends关键字来表示继承关系
    2. 相当于子类把父类的功能复制了一份
    3. Java只支持单继承
    4. 继承可以传递(爷爷/儿子/孙子这样的关系)
    5. 父类的私有成员也会被继承,但由于私有限制访问,所以子类不能使用父类的私有资源
    6. 继承多用于功能的修改,子类可以在拥有父类功能的同时,进行功能拓展
    7. 像是is a的关系

    1.3 练习:继承入门案例

    创建包: cn.tedu.oop2
    创建类: TestExtends.java

    package cn.tedu.oop2;
    /*本类用于继承的入门案例*/
    public class TestExtends {
        public static void main(String[] args) {
            //5.分别创建3个类的对象
            Animal a = new Animal();
            Cat c = new Cat();
            MiaoMiao m = new MiaoMiao();
            //6.利用对象调用方法进行测试
            /*3.继承相当于是子类将父类的功能复制了一份
            继承还具有传递性,爷爷的功能会传给爸爸,爸爸的功能会传给孙子*/
            a.eat();//爷爷类使用自己的方法
            c.eat();//爸爸类可以使用从爷爷类中继承过来的方法
            m.eat();//孙子类也可以使用从爷爷类中继承过来的方法
        }
    }
    /*1.我们通过extends关键字建立子类与父类的继承关系,格式:子类 extends 父类*/
    /*2.Java只支持单继承,一个子类只能有一个父类,但是一个父类可以有多个子类*/
    //1.创建小动物类--爷爷类
    class Animal{
        //4.添加爷爷类的普通方法
        public void eat(){
            System.out.println("小动物Animal吃啥都行~");
        }
    }
    //2.创建小猫类--爸爸类
    /*6.继承是is a的关系,比如小猫是小动物,MiaoMiao是一只小猫
    * 继承要求子类必须是父类的一种下属类型,依赖性非常强,强耦合*/
    class Cat extends Animal{
        //7.定义爸爸类中的属性
        int a = 10;//普通属性
        private int b = 100;//私有属性
    }
    //3.创建MiaoMiao类--孙子类
    class MiaoMiao extends Cat{
        /*4.子类可以拥有自己独有的方法,实现了功能的拓展,青出于蓝而胜于蓝*/
        //8.定义孙子类的方法
        public void studyJava(){
            System.out.println("正在学Java");
            System.out.println(a);
            /*5.子类继承了父类以后,可以使用父类的所有非私有资源
            * 注意:这个私有资源由于被private修饰,所以没有访问权限*/
            //System.out.println(b);//不可以,私有资源被限制访问
        }
    }
    

    2 super

    我们可以把super看作是父类的对象:Father super = new Father();
    1.当父类的成员变量与子类的变量同名时,使用super指定父类的成员变量
    2.使用super在子类构造方法的第一行调用父类构造方法的功能
    super();–调用的是父类的无参构造
    super(参数);–调用的是父类对应参数的构造方法
    注意:在构造方法里,出现的调用位置必须是第一行

    3 继承的用法

    3.1 练习:super之继承中成员变量使用

    创建包: cn.tedu.oopextends
    创建类: TestExtends1.java

    package cn.tedu.oop2;
    /*本类用于测试继承中变量的使用*/
    public class ExtendsDemo1 {
        public static void main(String[] args) {
            //7.创建子类的匿名对象,调用study()
            new Son().study();
        }
    }
    //1.创建父类
    class Father{
        //3.创建父类的成员变量
        int sum = 1;
        int count = 2;
    
    }
    //2.创建子类
    class Son extends Father{
        //4.创建子类的成员变量
        int sum = 10;
        //5.创建子类的普通方法
        public void study(){
            System.out.println("goog good study , day day up");
            //6.创建子类的局部变量
            int sum = 100;
            //8.打印子类的局部变量sum
            System.out.println(sum);//100
            //9.打印子类的成员变量sum
            System.out.println(this.sum);//10
            //10.打印父类的成员变量sum
            /*当父类的成员变量与子类的成员变量同名时,可以使用super指定父类的成员变量
            * 我们可以把super看作是父类的对象:Father super = new Father();*/
            System.out.println(super.sum);//1
            System.out.println(count);
        }
    }
    

    3.2 练习:super之继承中构造方法的使用

    创建包: cn.tedu.oop2
    创建类: ExtendsDemo2.java

    package cn.tedu.oop2;
    /*本类用于测试继承中构造方法的使用
    * 1.子类在创建对象时,默认会先调用父类的构造方法
    * 2.原因是子类构造函数中的第一行默认存在super();--表示调用父类的无参构造
    * 3.当父类没有无参构造时,可以通过super(参数)调用父类的其他含参构造
    * 子类必须调用一个父类的构造函数,不管是无参还是含参,选一个即可
    * 4.构造方法不可以被继承!因为语法的原因:要求构造方法的名字必须是本类类名
    * 不能在子类中出现一个父类名字的构造方法*/
    public class ExtendsDemo2 {
        public static void main(String[] args) {
            //6.1通过父类的无参构造创建父类对象
            //Father2 f = new Father2();
            //6.2通过父类的含参构造创建父类对象
            //Father2 f2 = new Father2("哈哈哈");
            //7.创建子类对象
            Son2 s = new Son2();
        }
    }
    //1.创建父类
    class Father2{
        //3.创建父类的无参构造
    //    public Father2(){
    //        System.out.println("我是父类的无参构造");
    //    }
        //4.创建父类的含参构造
        public Father2(String s){
            System.out.println("我是父类的含参构造"+s);
        }
    }
    //2.创建子类
    class Son2 extends Father2{
        //5.创建子类的无参构造
        public Son2(){
            //super();//调用父类的无参构造
            super("你好~");
            System.out.println("我是子类的无参构造");
        }
    }
    
    

    4 方法重写Override

    1. 继承以后,子类就拥有了父类的功能
    2. 在子类中,可以添加子类特有的功能,也可以修改父类的原有功能
    3. 子类中方法的签名与父类完全一样时,会发生覆盖/复写的现象
    4. 注意: 父类的私有方法不能被重写
    5. 重写的要求:两同两小一大
      两同:方法名 参数列表 要完全一致
      两小:
      子类返回值类型小于等于父类的返回值类型(注意此处说的是继承关系,不是值大小)
      子类抛出异常小于等于父类方法抛出异常
      一大:子类方法的修饰符权限要大于等于父类被重写方法的修饰符权限

    4.1 练习:继承中成员方法的使用

    创建包: cn.tedu.oop2
    创建类: ExtendsDemo3.java

    package cn.tedu.oop2;
    /*本类用于测试继承中方法的使用*/
    public class ExtendsDemo3 {
        public static void main(String[] args) {
            //4.创建对象进行测试
            Father f = new Father();
            Son s = new Son();
            f.eat();
            s.eat();
            f.play();
            s.play();
        }
    }
    //1.创建父类
    class Father{
        //3.定义父类中的普通方法
        public void eat(){
            System.out.println("爸爸爱吃肉");
        }
        public void play(){
            System.out.println("爸爸爱放风筝");
        }
    }
    //2.创建子类
    class Son extends Father{
        //5.如果子类对父类的方法不满意,可以重写父类的方法
        /*重写的原则:两同 两小 一大
        * 两同:子类方法的 方法名与参数列表 和父类方法的相同
        * 一大:子类方法的 方法修饰符权限 >= 父类方法的
        * 两小:子类方法的返回值类型 <= 父类方法的返回值类型
        * 注意:这里所说的<=是指子类方法的返回值类型是父类返回值类型的子类
        * 或者与父类的返回值类型一致,如果父类方法的返回值类型是void,子类保持一致即可
        * */
        @Override //注解,用来加在方法上,表示这是一个重写的方法
        public void eat(){
            System.out.println("儿子爱吃蔬菜");
        }
        @Override
        public void play(){
            System.out.println("儿子爱玩游戏");
        }
    }
    

    5. 拓展

    5.1 this与super的区别

    this代表的是本类对象的引用,我们可以把this看作是Cat this = new Cat();
    super代表的是父类对象的引用,我们可以把super看作是Father super = new Father();
    当本类的成员变量与局部变量同名时,需要使用this.变量名指定本类的成员变量
    当本类的成员变量与父类的成员变量同名时,需要使用super.变量名指定父类的成员变量
    this可以实现调用本类构造方法的功能,不能互相调用,需要写在构造方法首行
    this();表示调用本类的无参构造 this(参数);表示调用本类的对应参数的构造
    super也可以实现调用父类构造方法的功能
    super();表示调用父类的无参构造 super(参数);表示调用父类的对应参数的构造
    注意:super的使用前提是继承,没有父子类关系,就没有super
    注意:this调用构造方法或者super调用构造方法,都必须出现在构造方法的第一行
    注意:如果父类没有无参构造,需要手动在子类构造方法的第一行调用其他的含参构造
    拓展:如果子类重写了父类的方法以后,可以使用super.方法名(参数列表)来调用

    5.2 重载Overload 与重写Override的区别

    重载:在一个类中的现象:同一个类中,存在方法名相同,参数列表不同的方法
    重写:是指建立了继承关系以后,子类对父类的方法不满意,可以重写,遵循两同两小一大原则
    重载的意义:是为了外界调用方法时方便,不管传入什么样的参数,都可以匹配到对应的同名方法
    重写的意义:在不修改源码的情况下,进行功能的修改与拓展(OCP原则:面向修改关闭,面向拓展开放)

    展开全文
  • 这个继承,不仅仅是一级的继承关系,包括好几层的继承。父类的父类的父类。直到最后。 可以很清楚明了的了解一个类的实现关系。diagram 英[ˈdaɪəgræm] 美[ˈdaɪəˌɡræm] n. 图表; 示意图; 图解; [数] 线图;....

    IntelliJ IDEA使用教程 (总目录篇)

    在 IntelliJ IDEA 中这个查看一个类也就是当前类的所有继承关系,包括实现的所有的接口和继承的类,

    这个继承,不仅仅是一级的继承关系,包括好几层的继承。父类的父类的父类。直到最后。
    可以很清楚明了的了解一个类的实现关系。
    diagram 英[ˈdaɪəgræm] 美[ˈdaɪəˌɡræm]
    n. 图表; 示意图; 图解; [数] 线图;
    vt. 图解; 用图表示;

    下面看这个编辑器怎么以图解的形式,查看这种继承关系。

    (上面的是查看的Java源码的类的所有继承关系,最下面的这个是在查看spring项目里面的一个类的继承关系的时候,可能会有spring关系图,这个spring关系太复杂了,简直跟蜘蛛网一样,还是就看看各个类的继承图就可以啦。)

     

    更新:这个地方是有放大镜功能哦。我也是意外发现的,具体看图。

    20170508,追加;

    看了楼下的评论,还真的有个uml插件,然后,就看下面的截图,要是你们是社区版的,看看下载了这个插件之后,能不能用?

    2017/08/01追加

    上面示范的是如何向上看----看一个类的继承关系;

    下面再看看,怎么向下看,-----看一个类的子类实现关系。

    先看下map接口的实现类,哇赛赛,600多个。

    这个so far。我上面截图理解的有点问题,不是没找到,是暂时没有继续扩展,因为jdk也是一直在发展的,所以,这个map接口的实现类,以后只会多,不会少的。所以,他这个地方的so far ,就目前为止,也许再过些年,六千个也是可能的。

    再看个少点的。

    这个是我们自己写的一个类,他有四个类继承了这个类。这个少。

    那么快捷键是啥呢?

    我这个就是告诉你,怎么在你的电脑上,找到你自己对应的快捷键。我这是Ctrl + T。不知道你那是啥。

     

    我写完文章,给自己点个赞,不过分吧,
    不过分,那我可就点啦啊。
    我先点为敬,你们随意。大家随意。不要客气。。。

    展开全文
  • 7.1.4继承

    万次阅读 2020-02-03 20:52:03
    继承 生活中的继承 类的继承格式 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下: class 父类 { } class 子类 extends 父类 { } 为什么需要继承 接下来我们通过...

    继承

    生活中的继承

    类的继承格式

    在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:

    class 父类 {
    }
     
    class 子类 extends 父类 {
    }

    为什么需要继承

    接下来我们通过实例来说明这个需求。

    开发动物类,其中动物分别为企鹅以及老鼠,要求如下:

    • 企鹅:属性(姓名,id),方法(吃,睡,自我介绍)
    • 老鼠:属性(姓名,id),方法(吃,睡,自我介绍)
    public class AA
    {
    	public static void main(String[] args)
    	{
    		dog TOM = new dog("TOM");//新建dog对象
    	}
    }
    class dog extends Animal//继承Animal类  相当于把Animal类的东西送给dog
    {
    	public  dog(String name) //构造函数
    	{
    		this.name=name;//继承Animal的name
    		System.out.print(this.name);
    		eat("食物");//调用继承函数eat
    		sleep();//调用继承函数sleep
    	}	
    }
    class Animal 	//动物   包含  吃 和 睡 
    {
    	public String name;
    
    	/睡睡睡
    	public void sleep()
    	{
    		System.out.print("sleep now");
    	}
    	/吃吃吃
    	public void eat(String something)
    	{
    		System.out.print(something);
    	}
    	
    	
    }
    

    继承类型

    需要注意的是 Java 不支持多继承,但支持多重继承。

    继承关键字

    继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类

    extends关键字

    在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。

    public class Animal { 
        private String name;   
        private int id; 
        public Animal(String myName, String myid) { 
            //初始化属性值
        } 
        public void eat() {  //吃东西方法的具体实现  } 
        public void sleep() { //睡觉方法的具体实现  } 
    } 
     
    public class Penguin  extends  Animal{ 
    }

    implements关键字

    使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

    public interface A {
        public void eat();
        public void sleep();
    }
     
    public interface B {
        public void show();
    }
     
    public class C implements A,B {
    }

    super 与 this 关键字

    super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。

    this关键字:指向自己的引用。

    class Animal {
      void eat() {
        System.out.println("animal : eat");
      }
    }
     
    class Dog extends Animal {
      void eat() {
        System.out.println("dog : eat");
      }
      void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
      }
    }
     
    public class Test {
      public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
      }
    }

    final关键字

    final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:

    • 声明类:

      final class 类名 {//类体}
    • 声明方法:

      修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

    :实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final,但是实例变量并不是 final

     

    构造器

    子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

    如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。

    
    
    public class AA extends Animal
    {
    	public static void main(String[] args)
    	{
    		new AA("继承构造函数");
    	}
    	
    	public AA(String A)
    	{
    		super(A);
    	}
    }
    
    class Animal 	//动物   包含  吃 和 睡 
    {
    	
    	public Animal(String A)
    	{
    		System.out.print(A);
    	}
    	
    	
    	
    }
    

     

    展开全文
  • 考虑用Mix-in组件代替多继承

    万次阅读 2020-10-28 11:24:25
    Python是面向对象的编程语言,它提供了一些内置的编程机制,使得开发者可以适当地实现多继承。但是,我们仍然应该尽量避开多继承。 若一定要利用多继承所带来的便利及封装性,那就考虑编写min-in类。min-in是一种...
  • Java 继承

    千次阅读 多人点赞 2019-05-07 11:12:43
    java继承的概念 Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为, 并能扩展新的能力, 继承使用的是extends 类的继承格式 class 父类 { } class ...
  • C++公有继承,保护继承,私有继承的区别

    万次阅读 多人点赞 2018-08-21 15:34:32
    1.公有继承–public 公有继承时,对基类的公有成员和保护成员的访问属性不变,派生类的新增成员可以访问基类的公有成员和保护成员,但是访问不了基类的私有成员。派生类的对象只能访问派生类的公有成员(包括继承的...
  • Java继承超详细

    千次阅读 多人点赞 2021-03-02 14:58:30
    继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。 继承的作用:通过继承可以快速创建新的类,实现代码的重用,提高程序的可...
  • C++继承

    千次阅读 多人点赞 2020-06-06 19:45:20
    C++继承 1.继承的概念及定义 1.1继承的概念 继承机制是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称派生类。继承呈现了面向对象...
  • java中的继承详解

    万次阅读 多人点赞 2020-12-19 08:43:00
    继承的描述在现实生活中,继承一般指的是子女继承父辈的财产。在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物,程序中便可以描述为猫...
  • 1 三种继承方式    (1) 公有继承(public) 公有继承的特点是基类的公有成员和保护成员作为派生类的成员时,它们都保持原有的状态,而基类的私有成员仍然是私有的,不能被这个派生类的子类所访问。  (2) 私有...
  • C++继承之菱形继承

    千次阅读 2020-02-20 15:46:42
    在学习菱形继承之前,我们先了解两个概念:单继承、多继承。 单继承 一个子类只有一个直接父类时称这个继承关系为单继承。 多继承 一个子类有两个或以上直接父类时称这个继承关系为多继承。 菱形继承 菱形继承是多...
  • C++ 继承

    千次阅读 2021-03-23 20:32:55
    C++ 继承 继承和派生的概念 继承:在定义一个新的类 B 时,如果该类与某个已有的类 A 相似,指的是 B 拥有 A 的全部特点,在属性上 A 是 B 的子集;那么就可以把 A 作为一个基类,而把 B 作为基类的一个派生类也称为...
  • Python:类的继承,调用父类的属性和方法基础详解

    万次阅读 多人点赞 2018-12-30 11:35:01
    备注:这里省略了关于继承含义的解释,直接上代码了,更直观点 子类:Son类 父类:Father类 以下案例均表示Son类继承父类的一些属性和初始化参数构造等。 5个模块: (1):直接调用父类属性方法; (2):重写...
  • JS继承

    千次阅读 多人点赞 2018-11-11 11:05:41
    最近在面试中被问到js的继承,当时回答的不太好,所以今天特别总结一下。 我们先来看一个基于原型链的继承 //父类 function Person(){} //子类 function Student(){} //继承 Student.prototype = new Person...
  • 公有继承,私有继承,保护继承的区别

    万次阅读 多人点赞 2016-04-29 16:01:11
    一个子类继承父类时,可按照public、private和protected方式继承父类,每种继承方式的区别如下: 1) public继承方式 基类中所有public成员在派生类中为public属性;基类中所有protected成员在派生类中为...
  • Python中类的继承、多层继承和多继承 Python中,一个类可以通过继承的方式来获得父类中的非私有属性和非私有方法。 一、继承、重写、和调用重写的父类方法 继承的语法为在类名后的小括号()中写入要继承的父类名,...
  • JS继承之组合继承

    千次阅读 2018-09-05 16:39:17
    前面介绍了原型链继承以及构造函数继承,它们都有各自的优缺点 特点 优点 缺点 原型链继承 子类原型prototype对父类实例化来实现 子类不仅仅可以访问父类原型上的属性和方法,同样也可以访问从父类...
  • C++多继承与虚继承

    千次阅读 2018-12-06 08:57:08
    目录   多继承与虚继承以及存在的问题 例子 多继承与虚继承以及存在的问题 虚继承 ...有了多继承,虚继承才会有意义 ...如果这样继承B,C虚继承了A,virtual public,然后D继承B,C 通常的理...
  • C++中的继承

    万次阅读 多人点赞 2019-06-02 22:41:24
    1.为什么要使用继承 继承性是一个非常自然的概念,现实世界中的许多事物都是具有继承性的。人们一般用层次分类的方法来描述他们的关系。例如,下图就是一个简单的汽车分类图: 在这个分类树中建立了一个层次结构,...
  • JS继承之寄生继承

    千次阅读 2018-09-05 16:58:57
    JavaScript继承还有一种继承模式——寄生继承。 举个例子: function object(o) { function F() {}; F.prototype = o; return new F(); } var twoD = { name: '2D shape', dimensions: 2 } function triangle...
  • 多重继承和多继承 这个我们来讲讲这两个的概念问题,一字之差,千差万别。 多重继承,比如有三个类,人类-士兵类-步兵类,三个依次继承,这样的继承称为多重继承。class Person {};class Soldier :public Person {...
  • Java中继承

    万次阅读 多人点赞 2019-06-06 17:25:11
    面向对象编程中,继承是一个比较重要的概念,继承描述的是事物之间的所属关系,是从已有的类中构建出新的类,已有的类称为父类,新的类称为子类,子类具有父类的数据属性和方法,并能扩展新的属性和方法(不能继承...
  • Kotlin 继承

    千次阅读 2020-08-17 11:32:24
    文章目录Kotlin 继承构造函数子类有主构造函数子类没有主构造函数实例重写属性重写END Kotlin 继承 Kotlin 中所有类都继承该 Any 类,它是所有类的超类,对于没有超类型声明的类是默认超类: class Example // 从 ...
  • 菱形继承与虚继承

    千次阅读 2018-08-07 11:23:07
    菱形继承 先介绍一下单继承和多继承  单继承 多继承   菱形继承 菱形继承是单继承和多继承的集合  ...
  • 文章目录继承单一继承派生列表多继承菱形继承继承 继承 继承是面向对象程序设计中复用代码的重要手段,它允许程序员在原有类特性的基础上进行扩展增加功能。这样产生的新的类叫派生类。 继承体现了面向对象程序...
  • 区分接口继承和实现继承

    千次阅读 2018-04-27 12:19:07
    公有继承public的概念,可以分为两部分:函数接口继承和函数实现继承。在public继承下,派生类总会继承基类的接口。也就是成员函数的接口总是会被继承。pure virtual纯虚函数只具体指定接口继承。impure virtual(非...
  • 一、菱形继承 在介绍虚继承之前介绍一下菱形继承 概念:A作为基类,B和C都继承与A。最后一个类D又继承于B和C,这样形式的继承称为菱形继承 菱形继承的缺点: 数据冗余:在D中会保存两份A的内容 访问不明确(二...
  • C++ 深入理解 虚继承、多重继承和直接继承

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,522,306
精华内容 1,008,922
关键字:

继承