精华内容
下载资源
问答
  • Java父类与子类方法调用顺序 父类 FatherClass package 父类与子类方法调用顺序; /** * 父类 * @author shundong * */ public class FatherClass { private int i =0; private String name; /** * 父类无参...

    Java父类与子类方法调用顺序
    在这里插入图片描述
    父类 FatherClass

    package 父类与子类方法调用顺序;
    /**
     * 父类
     * @author shundong
     *
     */
    public class FatherClass {
        private int i =0;
        private String name;
        /**
         * 父类无参构造
         */
        FatherClass(){
            System.out.println("--父类无参构造--");
        }
        /**
         * 父类带参构造
         * @param name
         */
        FatherClass(String name){
            this.name=name;
            System.out.println("--父类带参构造--"+this.name);
        }
        /**
         * 父类静态代码块
         */
        static{
            System.out.println("--父类的静态代码块--");
        }
        /**
         * 父类非静态代码块
         */
        {
            ++i;
            System.out.println("--父类的非静态代码块--"+i);
        }
        /**
         * 父类的方法
         */
        public void speak(){
            System.out.println("--父类的方法--");
     
        }
        //加入一个main程序后
        public static void main(String[] args) {
            System.out.println("--父类主程序--");
            FatherClass father=new FatherClass("父类");
            father.speak();
        }
    }
    

    结果:

    在这里插入图片描述

    package 父类与子类方法调用顺序;
    /**
     * 子类
     * @author shundong
     *
     */
    public class SonClass extends FatherClass {
     
        private String name;
     
        /**
         * 子类无参构造
         */
        SonClass(){
            System.out.println("--子类无参构造--");
        }
        /**
         * 子类带参构造
         * @param name
         */
        SonClass(String name){
            this.name=name;
            System.out.println("--子类带参构造--"+this.name);
        }
        /**
         * 子类静态代码块
         */
        static{
            System.out.println("--子类静态代码块--");
        }
        /**
         * 子类的非静态代码块
         */
        {
            System.out.println("--子类的非静态代码块--");
        }
        /**
         * 重写父类方法
         */
        @Override
        public void speak(){
            System.out.println("--子类重写(Override)了父类的方法--");
        } 
        //然后再加入一个main函数
     
        public static void main(String[] args) {
     
            System.out.println("--Main主程序调动--");
            FatherClass father=new FatherClass("父亲");
            father.speak();
            SonClass son=new SonClass("儿子");
            son.speak();
     
        }
    }
    

    在这里插入图片描述

    展开全文
  • 解决Lombok父类与子类Builder不兼容

    千次阅读 2020-05-24 15:31:02
    解决父类与子类 Builder不兼容报错问题; Error:(59, 5) java: chldDTO 中的 builder() 无法隐藏 xxx 中的 builder() 返回类型parentBuilder不兼容问题

    Lombok 是我们经常使用的插件,@Builder也是我们经常使用的注解,那你有没有遇见过如下错误呢?

    父类与子类 Builder不兼容场景

     Error:(16, 1) java: com.jdcloud.jdsf.demo.consumer.domain.ChildModel 中的 builder() 无法隐藏 com.jdcloud.jdsf.demo.consumer.domain.ParentModel 中的 builder()
      返回类型com.jdcloud.jdsf.demo.consumer.domain.ChildModel.ChildModelBuilder与com.jdcloud.jdsf.demo.consumer.domain.ParentModel.ParentModelBuilder不兼容
    

    父类与子类 Builder不兼容场景

    解决方案

    不要将子类的@builder 加载类上,单独写一个需要builder 的构造函数,加载构造函数上,并对子类builder 进行单独命名,同时使用时,也需要使用子类指定的builder。 请见如下代码:

    父类使用buidler

    package com.jdcloud.jdsf.demo.consumer.domain;
    
    import lombok.*;
    
    /**
     * 测试 Lombok, 父类
     * @author wangyushuai2@jd.com
     * @date 2020/5/24
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @Builder
    public class ParentModel {
    
        private String parentProp1;
    
    }
    
    

    子类使用builder

    注意 单独命名 childBuilder, 使用的时候,也是用 chilerBuilder 进行构建

    package com.jdcloud.jdsf.demo.consumer.domain;
    
    import lombok.*;
    
    /**
     * Lombok 子类
     * @author wangyushuai2@jd.com
     * @date 2020/5/24
     */
    @Data
    @NoArgsConstructor
    @EqualsAndHashCode(callSuper = true)
    @ToString(callSuper = true)// toString时,将也打印父类的属性,默认时false 的
    public class ChildModel extends ParentModel {
    
        private String childProp1;
    
        @Builder(builderMethodName = "chilerBuilder")
        public ChildModel(String parentProp1, String childProp1) {
            super(parentProp1);
            this.childProp1 = childProp1;
        }
    }
    
    
    
    
    

    例子

    package com.jdcloud.jdsf.demo.consumer.domain;
    
    import lombok.extern.slf4j.Slf4j;
    
    /**
     * lombok demo
     * @author wangyushuai2@jd.com
     * @date 2020/5/24
     */
    @Slf4j
    public class TestLombokServiceImpl {
    
        public static void main(String[] args) {
    
            ChildModel model = ChildModel.chilerBuilder().childProp1("child").parentProp1("parent").build();
            log.info("{}",model);
        }
    }
    
    

    运行结果

    推荐文档

    lombok 常用注解

    展开全文
  • 关于父类与子类的构造函数调用顺序

    废话不多说先上代码:
    父类:

    class People{
    
        String name;
        public People(){
            System.out.printf("1");
        }
    
        public People(String name){
            System.out.printf("2");
            this.name=name;
        }
    
    }
    

    子类:

    class Child extends People{
    
        People father;
    
        public Child(String name){
            System.out.printf("3");
            this.name=name;
            father=new People(name+"F");
        }
    
        public Child(){
            System.out.printf("4");
        }
    
    }
    

    测试类:

    public class Test {
        public static void main(String[] args) {
    
            Child c=new Child("mike");
    
        }
    }
    

    执行结果为:132
    由此可以看出Java中,子类的构造过程中必须调用其父类的构造函数,因为继承关系,子类必须把父类的内容继承下来。但如果父类有多个构造函数时,该如何选择调用呢?
    1.子类的构造过程中,必须 调用其父类的构造方法。一个类,如果我们不写构造方法,那么编译器会默认帮我们加上一个默认的构造方法(就是没有参数的构造方法),如果你自己写了构造方法,那么编译器就不会给你添加了,所以有时候当你new一个子类对象的时候,肯定调用了子类的构造方法,但是如果在子类构造方法中我们并没有显示的调用基类的构造方法,如:super();这样就会调用父类没有参数的构造方法。从上面测试类中我们可以看出我们调用的是子类中有参数的构造方法,而且该构造方法并没有显示的调用基类的构造方法,所以默认会调用基类中没有参数的构造方法,所以执行结果为:132

                如果将子类有参数的构造方法改为:        
    
                public Child(String name){
                    super(name);
                    System.out.printf("3");
                    this.name=name;
                    father=new People(name+"F");
                }
    

    执行结果为:232
    2.如果子类的构造方法中既没有显示的调用基类构造方法,而基类中又没有无参的构造方法,则编译出错,所以,通常我们需要显示的:super(参数列表),来调用父类有参数的构造函数,此时无参的构造函数就不会被调用。
    总之,一句话:子类没有显示调用父类构造函数,不管子类构造函数是否带参数都默认调用父类无参的构造函数,若父类没有则编译出错。

    展开全文
  • C#中父类与子类的继承关系

    千次阅读 2019-01-11 00:27:48
    C#中的父类与子类的继承关系C和C++中的类似,这里先阐述最重要的一点:假如子类继承了父类,那么子类可以强制转换为父类,并且保证编译和运行都不出错;但是父类强制转换成子类的时候,编译可以通过运行通不过。请...

      C#中的父类与子类的继承关系与C和C++中的类似,这里先阐述最重要的一点:假如子类继承了父类,那么子类可以强制转换为父类,并且保证编译和运行都不出错;但是父类强制转换成子类的时候,编译可以通过运行通不过。请看如下代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FatherAndSon
    {
        class ClassA
        {
            static void Main(string[] args)
            {
                //编译和运行都能通过
                ClassB b = new ClassB();
                ClassA a = (ClassA)b;
               
                //编译能通过,运行通不过
                ClassA aa = new ClassA();
                ClassB bb = (ClassB)aa;
            }
    
        }
    
        class ClassB : ClassA
        {
           
        }
    }
    
    

      实际上:将子类强制转换为父类之后,在用这个父类强制转换为另外一个子类的时候编译和运行也都能通过;只是如果将父类直接转换为子类的时候运行会出错。这就好比:假设父类是一个装了5个“苹果”的“小型篮子”,而子类则是一个装了5个“苹果”和5个”西瓜“的大型篮子;将子类强制转换为父类<=>把父类的”小型篮子“换成”大型篮子“,但还是只装5个”苹果“(将父类的引用指向子类,但父类只能调用父子自身的变量和方法),之后再用这个父类强制转换为另外一个子类<=>向”大型篮子“里面装入5个”西瓜“送给子类的引用;而将父类直接转换为子类<=>用父类的”小型篮子“装”5个苹果和5个西瓜“送给子类的引用(当然是装不下)请看如下代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FatherAndSon
    {
        class ClassC
        {
            static void Main(string[] args)
            {   
                //先将子类强制转换为父类,然后用此父类强制转换为另外一个子类(通过)
                ClassB b = new ClassB();
                ClassA a = (ClassA)b;
                ClassB bbbbb = (ClassB)a;
    
               
                //(将父类直接强制转换为子类)编译能通过,运行通不过
                ClassA aa = new ClassA();
                ClassB bb = (ClassB)aa;
            }
           
        }
    
        class ClassA
        {
            
        }
        class ClassB : ClassA
        {
            
        }
    }
    
    

      另外一个值得非常注意的地方是:无论是子类强制转换赋给父类,还是父类(由子类强转得到)强制转换为子类;类对象是根据声明的类型(子类或父类)去调用其变量和函数的,与赋值无关。请看如下代码:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FatherAndSon
    {
        class ClassC
        {
            static void Main(string[] args)
            {   
                //先将子类强制转换为父类,然后用此父类强制转换为另外子类(通过)
                ClassB b = new ClassB();
                b.PrintFunc();
                Console.WriteLine(b.myStr);
    
                ClassA a = (ClassA)b;
                a.PrintFunc();
                Console.WriteLine(a.myStr);
    
                ClassB bbbbb = (ClassB)a;
                bbbbb.PrintFunc();
                Console.WriteLine(bbbbb.myStr);
               
                //(将父类直接强制转换为子类)编译能通过,运行通不过
                //ClassA aa = new ClassA();
                //ClassB bb = (ClassB)aa;
                //bb.PrintFunc();
            }
           
        }
    
        class ClassA
        {
            public string myStr;
            public ClassA()
            {
                myStr = "Hello, This is myStr in ClassA";
            }
    
            public void PrintFunc()
            {
                Console.WriteLine("This is the Print Function in ClassA");
            }
        }
    
        class ClassB : ClassA
        {
            public string myStr;
            public ClassB()
            {
                myStr = "Hello, This is myStr in ClassB";
            }
            public void PrintFunc()
            {
                Console.WriteLine("This is the Print Function in ClassB");
            }
        }
    }
    
    

      上面代码输出的结果为:

        This is the Print Function in ClassB

        Hello, This is myStr in ClassB

        This is the Print Function in ClassA

        Hello, This is myStr in ClassA

        This is the Print Function in ClassB

        Hello, This is myStr in ClassB

      可以看出:类的实例对象在调用其变量和方法时,确实是以 声明 成为的类为依据的。

    展开全文
  • c++(父类与子类,继承)

    2015-11-15 21:18:47
    c++(父类与子类,继承)
  • Java:简述父类与子类构造函数的调用次序 一、题目: 下列代码在执行new Child(“test”)的时候,输出结果是什么呢? class People { String name; public People() { System.out.println(1); } public ...
  • 一、父类与子类的一个实例 package HELLO; //====================== 【Father类 - 父类】 class Father { public void print1() // { print2(); } public void print2() { System.out.println("我是...
  • 父类与子类、继承关系总结

    万次阅读 2012-01-17 15:17:23
    一、父类与子类 1.父类与子类的相互转换 派生类的对象可以赋给基类,反之不行 基类的指针可以指向派生类,反之不行 基类的引用可以初始化为派生类的对象,反之不行 派生类指针必须强制转换为基类指针后才...
  • java中父类与子类的转换问题

    千次阅读 2017-11-23 22:35:06
    今天楼主结课测试,结果被一道说难不难,说简单不简单的题目搞晕了,充分说明了楼主的基础不扎实,很多细节没有搞清晰,就包括这一个经典的父类与子类的转换问题。今天总结一下。 1、子类对象转换为父类对象看一段...
  • java中父类与子类有相同属性调谁?答案是:取决于左边! 一、 在今天的继承复习当中,我有对继承中的属性有新的感悟------>子类继承父类,会继承父类的方法和属性,看下图: 从上图可以看出,即使子类是一个...
  • 父类与子类的继承,在子类没有重写父类的相同的方法时,父类的对象需要强制转换为子类,才可以访问子类中的方法。 但是若子类重写了父类的虚方法,则可以直接调用父类的方法。 体现了虚方法的优势。 在使用虚方法...
  • 1.父类指针可以指向子类对像,多态特性就是这么出来的。 2.父类引用可以直接引用子类对象, 3.子类指针不可以指向父类, 3.子类对象可以无条件当父类对象使用,即子类可以隐式的转换为父类, 为什么呢? 因为子类继承...
  • Java中父类与子类的加载顺序详解

    千次阅读 2017-08-30 08:52:00
    然后就看到有关于Java中父类与子类的加载顺序的题,出简单点的就出选择题,出复杂的就出成简答题了。说句实话,在实际开发工作中,好像用不到(也许是我技术不到家,所以没用到吧)但是为了应付笔试还是得了解。开始...
  • java中父类与子类的关系以及使用

    万次阅读 多人点赞 2018-03-15 20:45:25
    在java中规定:一个父类可以有多个子类,但是一个子类只能有一个父类子类可以通过extends关键字来继承父类。做个比较通俗的比喻,就像一个父亲可以有多个亲孩子,但是一个孩子只能有一个亲生父亲。1.继承以及重写...
  • Java规定:一个父类可以有多个子类,但是一个子类只有一个父类子类通关键字extends继承父类。 //父类: public class FatherClass { int a=3; FatherClass(){ System.out.println("父类无参构造函数"); } ...
  • java 父类与子类 extends

    千次阅读 2018-12-27 19:05:27
    继承:子承父业。  在一些类中拥有一些共性内容...继承父类的类称为子类。 单根继承: 在java中,类只支持单根继承。一个类只有一个直接父类。 多重继承: java中,支持多重继承,爷爷..爸爸..儿子.. 继承是ja...
  • 功能:为了验证C++中父类与子类的赋值,引用,取地址。 ****************/     #include &lt;iostream&gt; using namespace std; class Parent//父类 {  private:  int a;    public:  Parent...
  • python3 父类与子类

    2018-09-07 15:27:36
    类A有某种属性1,类B也有某种属性1,类C也有某种属性1, 定义类A的时候把属性1声明一遍,定义类B的时候又声明一遍,定义类C又声明一遍实在太...子类继承父类,拥有父类的全部属性,这样就不用每次都定义属性1了。...
  • python 父类与子类的一些说明

    千次阅读 2017-06-15 13:50:45
    Python中类的初始化方法是__init__(),因此父类子类的初始化方法都是这个,如果子类不实现__init__()这个函数,初始化时调用父类的初始化函数, 如果子类实现了这个函数,则要在这个函数里显式调用一下父类的__...
  • 1.父类子类之间代码块构造方法public class HelloA { public HelloA(){ System.out.println(&amp;amp;amp;amp;amp;amp;amp;amp;quot;HelloA&amp;amp;amp;amp;amp;amp;amp;amp;quot;); } {System.out....
  • java中的继承——父类与子类的关系

    千次阅读 2020-03-24 15:44:52
    父类引用指向子类对象时
  • 一、子类的实列化通过父类实现。(代码正常) 二、基于子类的实列化是通过父类实现,强制转换父类。(代码正常) 三、父类的实列化不能强制转换为子类。(代码错误,提示:java.lang.ClassCastException) 针对第...
  • 子类转换成父类很自然,但是父类转换成子类需要强制类型转换,且只有父类的本质是子类时才会转换成功。//成功转换
  • 理清楚4个目标 父类引用(“名”) 父类对象(“实”) 子类引用 子类对象 理清楚几个操作 // 父类 public class parent{ ...// 子类 ...父类引用指向父类对象 ...子类引用指向父类对象(错误!) son s2 = new pare
  • JAVA的多态----父类与子类转换问题

    千次阅读 2018-10-25 20:38:27
    每个子类对象都算是父类对象(子类对象可以当作父类变量所引用) 那反过来可不可以呢? 答案是取决于父类变量引用的是谁 如果父类变量引用的是子类对象的实例, 可以通过强转被子类变量引用 如果父类变量引用的是...
  • 一、子类父类 List<A> childList = getxxxxxx; List<B> dadList = new ArrayList<B>(); for(A a : childList){ dadList.add(a); //依次加到父类List里 } 二、父类转子类 List<B> ...
  • 父类与子类之间的调用顺序

    千次阅读 2018-03-10 21:09:58
    a) 父类静态代码块b) 子类静态代码块c) 父类构造方法d) 子类构造方法e) 子类普通方法f) 重写父类的方法,则打印重写后的方法总结:没有为什么,这就是虚拟机编译的先后顺序,如果需要理解的话,首先静态的东西一般都...
  • 父类与子类有相同属性调父类

    千次阅读 2018-02-28 14:01:13
    本帖最后由 宫明星 于 2012-9-29 23:17 编辑多态是父类的引用指向了自己的子类对象。但是有前提,必须是类类之间有关系。要么继承,要么实现(或者覆盖也行)。在多态中成员函数的特点:在编译时期:参阅引用型...
  • 父类与子类之间 指针引用等互调

    千次阅读 2015-08-25 16:44:45
     因为子类包含有父类,把子指针赋给父指针时其实只是把子类父类部分的地址赋给了父类指针而已,而父类里没有包含子类,所以不能复制,建议楼主变个程序然后再对照看下汇编就清楚了 因为子类继承了父类,所以说他...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 555,574
精华内容 222,229
关键字:

父类与子类