精华内容
下载资源
问答
  • 怎样发现类之间的继承关系
    2021-05-20 22:05:47

    类与类之间的关系

    • A is-a B 泛化 (继承 实现)
    • A has-a B 包含 (组合 聚合 关联)
    • A use-a B 依赖 (依赖)

    类关系设计:高内聚 低耦合 :继承(实现)>组合>聚合>关联 > 依赖

    继承

    • 1.子类继承父类,通过一个关键字 extends

    • 2.子类对象可以调用父类中的(public protected)属性和方法 当作自己的来使用

    • 3.子类可以添加自己独有的属性和方法

    • 4.子类从父类中继承过来的方法不能满足子类需要,可以在子类中的重写(覆盖 override)父类的方法 更多指的是内容

    • 5.每一个类都有继承类,如果不写extends关键字,默认继承Object,如果写了extends则继承后面的那个父类

      Object 类,是任何引用类型的父类(直接或间接的继承Object类),Object类没有父类。

    • 6.java中的继承是单个存在的(单继承)每个类只有一个继承类(在extends关键字后面只能写一个类)

      可以通过传递的方式实现多继承的效果 可以用实现

    • 8.关于this和super的使用

      • this 和 super 都是指代词 代替的是对象

        this 代替的是 当前执行方法的那个对象 不一定是当前类

        super 代替的是当前执行方法的对象的父类的对象 空间内部的那个

        都能调用一般属性和一般方法

      • 可以放在类成员的任意位置(属性 方法 构造 块)

        注意调用一般方法的时候可以来回互相调用(写法 编译好用)执行可能产生问题(StackOverflowError)

        可以调用构造方法(放在构造方法的第一行)

      • 调用构造方法时:this 和 super不能同时出现,因为都需要放在第一行

      • 构造方法之间来回不能互相调用(编译就不好用)

    方法重载于方法重写的异同

    比较方法重写(OverRide)方法重载(OverLoad)
    产生两个继承关系的类一个类中的一组方法 子类重写父类方法
    权限子类可以小于等于父类没有要求
    特征final static abstract 父类的方法是final 子类不能重写 ,父类的方法是static 子类不存在 , 父类的方法是abstract 子类必须重写没有要求
    返回值子类可以大于等于父类没有要求
    名字必须与父类方法相同必须相同
    参数必须相同类型或个数或顺序必须不同
    异常异常 运行时 编译时 如果父类方法抛出运行时异常 子类可以不予理会;如果父类方法抛出编译时异常 子类抛出异常的个数少于等于父类,子类抛出异常的类型少于等于父类。
    方法体子类的方法内容与父类不一致每个重载的方法执行过程不一致
    更多相关内容
  • 高清qt5中的各种类关系继承图pdf帮助文档,支持放大缩小功能。
  • Qt各个类之间继承关系

    千次阅读 2021-04-01 15:32:26
  • Java类之间继承关系

    千次阅读 2020-08-21 16:23:07
    抽象、封装、继承、多态这四大特性都离不开,只有存在,才能体现面向对象编程的特点,今天我们就来了解一些继承的相关知识。首先,我们讲述一下与的初始化相关的东西,然后再从几个方面阐述继承这一大特性...

    对于面向对象的程序设计语言来说,类毫无疑问是其最重要的基础。抽象、封装、继承、多态这四大特性都离不开类,只有存在类,才能体现面向对象编程的特点,今天我们就来了解一些类与继承的相关知识。首先,我们讲述一下与类的初始化相关的东西,然后再从几个方面阐述继承这一大特性。以下是本文的目录大纲:

      一.你了解类吗?

      二.你了解继承吗?

      三.常见的面试笔试题

      若有不正之处,请多多谅解并欢迎批评指正。

     

    一.你了解类吗?

      在Java中,类文件是以.java为后缀的代码文件,在每个类文件中最多只允许出现一个public类,当有public类的时候,类文件的名称必须和public类的名称相同,若不存在public,则类文件的名称可以为任意的名称(当然以数字开头的名称是不允许的)。

      在类内部,对于成员变量,如果在定义的时候没有进行显示的赋值初始化,则Java会保证类的每个成员变量都得到恰当的初始化:

      1)对于  char、short、byte、int、long、float、double等基本数据类型的变量来说会默认初始化为0(boolean变量默认会被初始化为false);

      2)对于引用类型的变量,会默认初始化为null。

      如果没有显示地定义构造器,则编译器会自动创建一个无参构造器,但是要记住一点,如果显示地定义了构造器,编译器就不会自动添加构造器。注意,所有的构造器默认为static的。

      下面我们着重讲解一下 初始化 顺序:

      当程序执行时,需要生成某个类的对象,Java执行引擎会先检查是否加载了这个类,如果没有加载,则先执行类的加载再生成对象,如果已经加载,则直接生成对象。

      在类的加载过程中,类的static成员变量会被初始化,另外,如果类中有static语句块,则会执行static语句块。static成员变量和static语句块的执行顺序同代码中的顺序一致。记住,在Java中,类是按需加载,只有当需要用到这个类的时候,才会加载这个类,并且只会加载一次。看下面这个例子就明白了:

    public class Test {
        public static void main(String[] args) throws ClassNotFoundException {
             
            Bread bread1 = new Bread();
            Bread bread2 = new Bread();
        }
    }
     
     
    class Bread {
        static{
            System.out.println("Bread is loaded");
        }
        public Bread() {
            System.out.println("bread");
        }
    }

      运行这段代码就会发现"Bread is loaded"只会被打印一次。

      在生成对象的过程中,会先初始化对象的成员变量,然后再执行构造器。也就是说类中的变量会在任何方法(包括构造器)调用之前得到初始化,即使变量散步于方法定义之间。

    public class Test {
        public static void main(String[] args)  {
            new Meal();
        }
    }
     
     
    class Meal {
         
        public Meal() {
            System.out.println("meal");
        }
         
        Bread bread = new Bread();
    }
     
    class Bread {
         
        public Bread() {
            System.out.println("bread");
        }
    }    Bread bread = new Bread();} class Bread {         public Bread() {        System.out.println("bread");    }}

      输出结果为:

    bread
    meal

     

    二.你了解继承吗?

      继承是所有OOP语言不可缺少的部分,在java中使用extends关键字来表示继承关系。当创建一个类时,总是在继承,如果没有明确指出要继承的类,就总是隐式地从根类Object进行继承。比如下面这段代码:

    class Person {
        public Person() {
             
        }
    }
     
    class Man extends Person {
        public Man() {
             
        }
    }

      类Man继承于Person类,这样一来的话,Person类称为父类(基类),Man类称为子类(导出类)。如果两个类存在继承关系,则子类会自动继承父类的方法和变量,在子类中可以调用父类的方法和变量。在java中,只允许单继承,也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承,也就是说一个类可以拥有多个子类。

      1.子类继承父类的成员变量

      当子类继承了某个类之后,便可以使用父类中的成员变量,但是并不是完全继承父类的所有成员变量。具体的原则如下:

      1)能够继承父类的public和protected成员变量;不能够继承父类的private成员变量;

      2)对于父类的包访问权限成员变量,如果子类和父类在同一个包下,则子类能够继承;否则,子类不能够继承;

      3)对于子类可以继承的父类成员变量,如果在子类中出现了同名称的成员变量,则会发生隐藏现象,即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量,需要使用super关键字来进行引用。

      2.子类继承父类的方法

      同样地,子类也并不是完全继承父类的所有方法。

      1)能够继承父类的public和protected成员方法;不能够继承父类的private成员方法;

      2)对于父类的包访问权限成员方法,如果子类和父类在同一个包下,则子类能够继承;否则,子类不能够继承;

      3)对于子类可以继承的父类成员方法,如果在子类中出现了同名称的成员方法,则称为覆盖,即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法,需要使用super关键字来进行引用。

      注意:隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的,而覆盖是针对普通方法的。(后面会讲到)

      3.构造器

      子类是不能够继承父类的构造器,但是要注意的是,如果父类的构造器都是带有参数的,则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器,则在子类的构造器中用super关键字调用父类构造器不是必须的,如果没有使用super关键字,系统会自动调用父类的无参构造器。看下面这个例子就清楚了:

    class Shape {
         
        protected String name;
         
        public Shape(){
            name = "shape";
        }
         
        public Shape(String name) {
            this.name = name;
        }
    }
     
    class Circle extends Shape {
         
        private double radius;
         
        public Circle() {
            radius = 0;
        }
         
        public Circle(double radius) {
            this.radius = radius;
        }
         
        public Circle(double radius,String name) {
            this.radius = radius;
            this.name = name;
        }
    }

      这样的代码是没有问题的,如果把父类的无参构造器去掉,则下面的代码必然会出错:

      改成下面这样就行了:

      4.super

      super主要有两种用法:

      1)super.成员变量/super.成员方法;

      2)super(parameter1,parameter2....)

      第一种用法主要用来在子类中调用父类的同名成员变量或者方法;第二种主要用在子类的构造器中显示地调用父类的构造器,要注意的是,如果是用在子类构造器中,则必须是子类构造器的第一个语句。

     

    三.常见的面试笔试题

    1.下面这段代码的输出结果是什么?

    public class Test {
        public static void main(String[] args)  {
            new Circle();
        }
    }
     
    class Draw {
         
        public Draw(String type) {
            System.out.println(type+" draw constructor");
        }
    }
     
    class Shape {
        private Draw draw = new Draw("shape");
         
        public Shape(){
            System.out.println("shape constructor");
        }
    }
     
    class Circle extends Shape {
        private Draw draw = new Draw("circle");
        public Circle() {
            System.out.println("circle constructor");
        }
    }

     

    shape draw constructor
    shape constructor
    circle draw constructor
    circle constructor

      这道题目主要考察的是类继承时构造器的调用顺序和初始化顺序。要记住一点:父类的构造器调用以及初始化过程一定在子类的前面。由于Circle类的父类是Shape类,所以Shape类先进行初始化,然后再执行Shape类的构造器。接着才是对子类Circle进行初始化,最后执行Circle的构造器。

    2.下面这段代码的输出结果是什么?

    public class Test {
        public static void main(String[] args)  {
            Shape shape = new Circle();
            System.out.println(shape.name);
            shape.printType();
            shape.printName();
        }
    }
     
    class Shape {
        public String name = "shape";
         
        public Shape(){
            System.out.println("shape constructor");
        }
         
        public void printType() {
            System.out.println("this is shape");
        }
         
        public static void printName() {
            System.out.println("shape");
        }
    }
     
    class Circle extends Shape {
        public String name = "circle";
         
        public Circle() {
            System.out.println("circle constructor");
        }
         
        public void printType() {
            System.out.println("this is circle");
        }
         
        public static void printName() {
            System.out.println("circle");
        }
    }

     

    shape constructor
    circle constructor
    shape
    this is circle
    shape

      这道题主要考察了隐藏和覆盖的区别(当然也和多态相关,在后续博文中会继续讲到)。

      覆盖只针对非静态方法(终态方法不能被继承,所以就存在覆盖一说了),而隐藏是针对成员变量和静态方法的。这2者之间的区别是:覆盖受RTTI(Runtime type  identification)约束的,而隐藏却不受该约束。也就是说只有覆盖方法才会进行动态绑定,而隐藏是不会发生动态绑定的。在Java中,除了static方法和final方法,其他所有的方法都是动态绑定。因此,就会出现上面的输出结果。

     

    展开全文
  • 类之间关系继承

    千次阅读 2020-05-14 01:18:01
    文章目录类之间关系继承 A is-a B 泛化 A has-a B 包含(组合 聚合 关联) A use-a B 依赖(need-a) 继承 条件: 只要得有两个:子类、父类 子类继承父类,通过一个关键字:extends package ...

    类和类之间的关系


    A is-a B 泛化
    A has-a B 包含(组合 聚合 关联)
    A use-a B 依赖(need-a)

    继承

    条件: 只要得有两个类:子类、父类

    1. 子类继承父类,通过一个关键字:extends
    
    package extendsRleationIsA;
    
    /**
     * @class 动物的归类
     *
     */
    public class Animal {
        //属性
        public String name;
        //方法
        public void eat(){
            System.out.printf("吃饭的方法………………………………………………");
        }
        public void sleep(){
            System.out.printf("动物睡觉的方法……………………………………");
        }
    }
    
    
    
    package extendsRleationIsA;
    
    /**
     * @class 表示Person继承了Animal属性方法通过Java的关键字extends
     */
    public class Person extends Animal {
    }
    
    
    1. 子类可以调用父类中的(public protected(受保护的))属性方法 当作自己的来使用

    2. 子类可以添加自己独有的属性和方法的

    3. 子类从父类继承过来的方法不能满足子类的需求,可以在子类中重写父类的方法

    4. 每一个类都有一个默认继承关系的(Object)类,如果写了extends就继承我写的那个类

    5. Java中继承是单个存在的(单继承)每一个类只能有一个继承类(extends关键字后面只能写一个类)Java单继承好处在于更清晰看到代码

      • 可以通过传递的方式实现多继承 多实现interface接口概念
    6. 继承在内存中存储形式

      • 代码演示
      //Animal类
      public class Animal{
          //Animal的构造方法
          public void Animal(){
              System.out.printnl("Animal的构造方法…………………………");
          }
          public void eat(){
              System.out.println("动物吃饭的方法………………………………");
          }
      
      }
      //Person类
      public class Person{
          public void Person(){
              System.out.print("Person的构造方法………………………………");
          }
          //重写父类当中的eat方法
          public eat(){
              System.out.println("Person吃饭的方法…………………………");
          }
      }
      //程序的入口类
      public class RunMain(){
          public static void main(String [] args){
              //加载类的模板的过程
              //Person -- Animal -- Object
              Person person = new Person();
              /**
              *程序执行完成为什么先调的是Animal的构造方法而不是Prson的构造方法
              */
              person.hasCode();
              person.eat();//因为重写过后在内存空间里面先找Person模板类里面有Animal、Object、Person 发现Person自己有eat方法就直接调用了后面也没有调用所有加载出来(Person吃饭的方法…………………………)
          }
      }
      
    7. this(代替是当前调用方法属性时的那个对象,不一定是当前类的对象)

      • this和super使用

        1. this和super都是指代词,代替的是对象

        2. this代替的是当前执行方法是的那个对象,不一定是当前类的,就new出来这个对象的时候才是代替的this

        3. super代替的是当前执行方法时的对象的父类对象Animal中sleep()中要调用自己eat()你就只能使用super了因为在类加载模板中先创建的Person类

        4. 都能调用一般属性和一般方法

        5. 可以放置在类成员的任意(属性 方法 构造 块)

          • 注意调用一般方法的时候可以来会相互调用(写法 编译好用)执行可能产生问题(StakOverflowError)
        6. 可以调用构造方法(放在构造方法的第一行)

          • this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行

          • 构造方法之间不能来回调用(编译不好用)

      • 代码演示

          //Animal类
          public class Animal{
          //Animal的构造方法
              public void Animal(){
                  System.out.printnl("Animal的构造方法…………………………");
              }
              public void eat(){
                  System.out.println("动物吃饭的方法………………………………");
              }
              public void sleep(){
                  //this 代替是当前调用方法时的那个对象 不一定是当前类的对象 
                  //如果一定要调用Animal eat() 可以使用super()
                  this.eat();//Animl eat() /  Person eat()
      
                  System.out.println("动物的睡觉方法………………………………");
              }
      
          }
          //Person类
      
          public class Person{
              public void Person(){
                  System.out.print("Person的构造方法………………………………");
              }
              //重写父类当中的eat方法
              public void eat(){
                  System.out.println("Person吃饭的方法,讲究色香味俱全");
              }
              //好好学习方法
              public void study(){
                  System.out.println("Good Good study day day up");
              }
          }
      
          //程序入口类
          public class RunMain(){
              public static void main(String [] args){
                  //加载类的模板的过程
                  //Person -- Animal -- Object
                  Person person = new Person();
                  person.sleep();//从Animal类中
              }
          }
      
    8. Object是所有类的父类,Object没有父类啦啦,在看hashCode源码的时候看到了native特征符代表调用了底层C++语言方法

      • 代码演示
      
      //程序的入口类
      public class Test {
          public static void main(String[] args) {
              Person person = new Person();
              //person继承Obejct类
              person.equals();//比较两个对象的内容是否一致 Object默认效果用来比较地址可以重写 ==可以比较基本类型(比较值)可以比较引用类型(比较地址)
              person.hashCode();//将对象在内存中的地址经过计算得到一个int整数 Object源码public native int hasCode();它不是抽象方法而是底层调用了C++语言帮程序做事
              /*
              打印输出时将一个对象,变成字符串
                                                                                      打印的变量         返回          十六进制
              toString()方法三目运算符 (obj == null) ? "null" : obj.toString();  this.getClass().getName() + "@" + Integer.toHexString(this.hashCode());
              相当于if(a>b){
                  true
              }else{
                  flase
              }
              */
              person.toString();
              person.getClass();//获取对象映射(反射)
              person.notify();//线程唤醒
              person.notifyAll();//唤醒所有
              person.wait();//线程进入挂起等待状态 存在重载
              finalize();//权限修饰符是Protected 在对象被垃圾回收的时候  默认调用执行的方法 final finally finalize区别
              clone();//权限修饰是Protected 为了克隆 git clone
          }
      }
      

    方法重写Override和方法重载overload

    方法重写override方法重载overload
    产生两个继承关系的类一类中的一组方法
    权限子类可以大于等于父类没有要求
    特征符final static abstract没有要求
    返回值子类可以小于等于父类(多态)没有要求
    名字子类与父类一致一个类中的好多方法名必须一致
    参数子类与父类一致每个方法的参数必须不一致(个数 类型 顺序)
    异常运行时 编译时没有要求
    方法体子类的方法应该于父类不一致每一个重载的方法 执行过程不一致
    • 补充一下类重写类之间满足条件

      1. 重写必须需求

        • 子类必须重写父类的方法否则不存在重写
      2. 修饰符注意

        • 父类方法是final时子类不能重写

        • 父类方法是static子类不存在重写

        • 父类方法是abstract子类必须重写

        • 子类是具体必须重写,否则子类是抽象类 可以不重写

      3. 异常注意

        • 如果父类方法抛出运行时异常子类不予理会

        • 如果父类方法抛出编译时异常子类抛出异常的个数少于等于父类

        • 子类抛出异常的类型小于等于父类

    展开全文
  • JAVA学习笔记 1. 接口概述 接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用Java中的接口更多的体现在对行为的抽象 ...继承关系,只能单继承,但是可以多层继承 和接口的关系 实现关系可以单实
  • 类之间关系之——继承

    千次阅读 2019-01-07 21:39:32
    一、类之间的三大关系 (1)组合:一个是另一个的一部分 class A { class B {}; }; (2)代理:一个的方法是另一个方法的子集,也就是说这个它本身是不进行任何的操作,只是调用另一个来帮它...
  • 代码中创建的,主要是为了能将我们生活中的事物抽象成具体的属性和方法,但是在实际的场景中,有很多东西他们之间存在**有一定关联**的属性和方法,例如动物之间,城市之间等,他们存在有完全相同意义的属性和方法...
  • 主要介绍一下类之间关系,也就是面向对象编程先介绍两个术语 Object Oriented Programming OOP面向对象编程 Object Oriented Design OOD面向对象设计 对于类之间关系有很多种,但是我认为理解3种足够 ...
  • 编写Music来测试类之间继承关系 实现如下类之间继承关系,并编写Music来测试这些 Music.java???? package work.first; public class Music { public static void tune (Instrument i){ i.play...
  • io包中常用的作用、重要方法及类之间继承关系
  • 查看源码的时候,有时候需要搞清楚继承关系,那么要怎么搞呢?今天就和大家一起学习一下。 就拿HashMap来说吧。 方法一:使用快捷键Ctrl+T 可以实现,效果如下: 下面的都是HashMap的子类 例如...
  • Cocoa框架类之间继承关系,对初学苹果系统MACOS开发,了解COCOA函数框架很有用
  • idea 查看类继承关系的快捷键

    千次阅读 2021-01-12 18:28:49
    类似eclipse ctrl+t的快捷键,idea中是ctrl+H…找到对应的 查看类关系图…1.在想要查看的上按 Ctrl + H -> Diagrams -> Show Diagrams -> Java Class Diagrams -> Show Implementations -> Ctrl +...
  • java集合继承关系

    千次阅读 2021-02-26 10:05:51
    面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。...上述类图中,实线边框的是实现,比如ArrayList,LinkedList,HashMap...
  • 一、继承关系      继承指的是一个(称为子类、子接口)继承另外的一个(称为父类、父接口)的功能,并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识,在设计...
  • io类之间继承关系的图片,自己在网上搜的,感觉不错就拿来分享了~~~
  • 使用IntelliJ IDEA查看继承关系

    千次阅读 2020-08-07 11:14:18
    1、查看类继承关系链 在想查看的中右键,选择Diagrams—》show Diagrams/show Diagrams Group都行,一个是在本页面查看,一个是重新开启一个页面查看 点击后出现如下关系图 2、优化继承链图,看我所想看的 2.1 ...
  • 类图是使用频率最高的UML图之一,主要用于描述系统中所包含的以及它们之间的相互关系,帮助开发人员理解系统,它是系统分析和设计阶段的重要产物,也是系统编码和测试的重要模型依据。 间的关系包括关联、继承、...
  • UML 类之间关系

    2021-07-16 16:56:34
    继承关系也称泛化关系(Generalization),用于描述父类与子类之间的关系。父类又称作基类,子类又称作派生继承关系中,子类继承父类的所有功能,父类所具有的属性、方法,子类应该都有。子类中除了与父类一致...
  • 只要是在中用到了对方,那么他们之间就存在依赖关系。如果没有对方,编译通过不了。用虚线箭头。 public class PersonDao{} public class IDCard{} public class Person{} public class Department{} public class...
  • 这里我们可以通过查看继承关系, 明白的作用 查看DRF框架的APIView继承关系 下图就是我们查找的继承关系 查看DRF框架的GenericAPIView所在.py模块的所有类继承关系 1.通过Ctrl + 左键.
  • 类之间关系

    万次阅读 多人点赞 2018-06-28 17:21:10
    类之间的6种关系一、UMLa) Unified Modeling Language (UML)又称统一建模语言或标准建模语言b) 它是一个支持模型化和软件系统开发的图形化语言,为软件开发的所有阶段提供模型化和可视化支持c) 它不仅统一了...
  • Java集合继承关系MindManager
  • 类之间关系

    千次阅读 2022-03-08 17:58:50
    类之间的6种关系 分别是:继承,实现,依赖,关联,聚合,组合。
  • powerdesigner 继承关系

    千次阅读 2020-02-20 14:50:31
    在开发中,总是会面对部分相同的实体这种情况的。那么,我们需要在powerdesigner 中就直接关联好这种关系。... Class Table Inheritance (继承) 比如,教师与学生的设计关系来讲。有相同的姓名,性别,年...
  • 图中详细描述了g2o库的核心,及其类之间继承关系,有助于理解g2o的运行机制
  • 实现如下类之间继承关系,并编写Music来测试这些。 package com.hanqi.test; public class Instrument { //输出弹奏乐器 public void play() { System.out.println("弹奏乐器"); } ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 521,611
精华内容 208,644
热门标签
关键字:

怎样发现类之间的继承关系