构造器 订阅
构造器是Java和C#学习中很重要的一个概念,构造器可以提供许多特殊的方法,构造器作为一种方法,负责类中成员变量(域)的初始化。实例构造器分为缺省构造器和非缺省构造器。 展开全文
构造器是Java和C#学习中很重要的一个概念,构造器可以提供许多特殊的方法,构造器作为一种方法,负责类中成员变量(域)的初始化。实例构造器分为缺省构造器和非缺省构造器。
信息
外文名
Constructor
特    点
提供许多特殊的方法
分    类
静态构造器等
用    途
Java和C#学习中很重要的一个概念
中文名
构造器
构造器构造器的简介
构造器最大的用处就是在创建对象时执行初始化,当创建一个对象时,系统会为这个对象的实例进行默认的初始化。如果想改变这种默认的初始化,就可以通过自定义构造器来实现。构造器是为了创建一个类的实例化对象的时候用到:InstanceObject IO = new InstanceObject(); 构造器可以用来在初始化对象时,初始化数据成员,即包括初始化属性和方法。一个类可以有多个构造器。一个类的构造器的名称必须与该类的名称一致。要退出构造,可以使用返回语句“return;”。相反,方法的作用是为了执行java代码。相同点:构造器也是Java类中的一种方法。不同点:构造器和方法在下面三个方面的区别:修饰符,返回值,命名。(1)修饰符:和方法一样,构造器可以有任何访问的修饰符: public, protected, private或者没有修饰package(通常被package 和 friendly调用). 不同于方法的是,构造器不能有以下非访问性质的修饰: final,,static,,abstract,synchronized,native。(2)返回类型:方法能返回任何类型的值或者无返回值(void),构造器没有返回值,也不需要void。(3)两者的命名:构造器通常用首字母为大写的一个名词开始命名,并且使用和类相同的名字命名。而方法则不同,方法通常用小写字母英文动词开始,其后跟随首字母为大写的名称、形容词等等组成的驼峰命名方式,方法通常更接近动词,因为它说明一个操作。
收起全文
精华内容
下载资源
问答
  • 在本篇文章里小编给大家分享的是关于java中构造器内部调用构造器实例内容,需要的朋友们可以学习下。
  • NX10.0后处理构造器.rar

    2019-11-27 14:35:12
    亲测好用 大家快来下载吧 NX10.0后处理构造器,覆盖安装目录下面的同名文件夹即可 挺不错的一个资源
  • NX12.0.2.9 后处理构造器,覆盖安装目录下面的同名文件夹即可
  • NULL 博文链接:https://cdxs2.iteye.com/blog/1940307
  • HYPERMILL五轴后处理构造器HYPERMILL五轴后处理构造器HYPERMILL五轴后处理构造器HYPERMILL五轴后处理构造器HYPERMILL五轴后处理构造器
  • 用于NX加工程序后处理的一个小软件,发给大家分享抓取使用!
  • Java构造器(构造方法)详解

    千次阅读 2021-09-11 21:47:58
    文章目录Java构造器(构造方法)详解Java构造器怎么定义构造器构造器的使用构造器的继承**构造器、静态代码块、构造代码块的执行顺序,详见下文实例**实例1.默认构造器2.禁止对象被外部创建3.构造器重载4.构造器的...

    Java构造器(构造方法)详解

    什么是构造器

    构造器通常也叫构造方法、构造函数,构造器在每个项目中几乎无处不在。当你new一个对象时,就会调用构造器。构造器格式如下:

    [修饰符,比如public] 类名 (参数列表,可以没有参数){ //这里不能有return}

    Java构造器

    构造器的注意事项:

    1. 构造器的名称必须和类名一致
    2. 一个类中可以定义多个构造器,但是构造器的参数列表必须不同(重载)
    3. 如果我们没有手动定义构造器,则Java系统会提供一个默认的构造器给我们使用,一旦我们定义了构造器,则系统会把默认的构造器收回
    4. 构造器的作用:实例化对象,给对象赋初始值
    5. 代码游离块优先执行

    怎么定义构造器

    构造方法的名字必须和所在类的名字一致,没有返回值,但不能声明void,访问权限可以为任意,但是一般情况下使用public方法权限,构造方法中的参数可以根据需要自行定义,参数的不同的构造方法构成重载

    public 构造方法名(参数){
        ...
    }
    
    /*注意:
      1.构造方法没有返回值类型
      2.构造方法名必须和该类的类名保持一致,大小写都一样
    

    例:

       class Fu
       {
         public Fu(){} //无参的公有构造方法
         public Fu(int i){} //参数类型为int的公有构造方法
       ......
       }
    
    
       public class Demo extends Fu
       {
         public Demo(){} //无参的公有构造方法
         public Demo(int i){} //参数类型为int的公有构造方法
         public Demo(int i,double d){} //参数类型为int和double的公有构造方法
         ...
       }
    

    构造器的使用

    Java中构造方法的使用有两个地方,一个是跟在关键字new后面,类名加上一个小括号(),小括号内根据实际加上实参,另外一个是跟在关键字super或this后加上一个小括号(),小括号内根据实际添加实参,下面进行举例。

    例1:

    Demo demo = new Demo(); //这里是调用的是一个无参的构造方法,必须声明在方法中,最好声明在主方法

    上面构造方法的参数根据实际添加实参,Jvm根据构造方法的参数不同加载不同的构造方法

    例2:

    public Demo(){
      this(2); //这里调用参数为int类型的本类的构造方法
     }
    

    例3:

    public Demo(){
      super(1); //调用参数为int类型的父类的构造方法
     } 
    

    注意:例2和例3中this或super调用构造方法只能出现在构造方法中,而且必须出现在第一行,所以一个构造方法中第一行只能为this或super调用构造方法,两者不能同时调用构造方法出现,而且注意this或super调用构造方法时,要留构造方法出口,意思就是最后调用的构造方法中没有再调用别的构造方法!

    构造器的继承

    子类构造器会默认调用父类无参构造器,如果父类没有无参构造器,则必须在子类构造器的第一行通过 super关键字指定调用父类的哪个构造器,具体看下文例子。final类是不允许被继承的,编译器会报错。很好理解,由于final修饰符指的是不允许被修改,而继承中,子类是可以修改父类的,这里就产生冲突了,所以final类是不允许被继承的。

    构造器、静态代码块、构造代码块的执行顺序,详见下文实例

    • 无继承的情况下的执行顺序静态代码块:只在程序启动后执行一次,优先级最高构造代码块:任何一个构造器被调用的时候,都会先执行构造代码块,优先级低于静态代码块构造器:优先级低于构造代码块总结一下优先级:静态代码块 > 构造代码块 > 构造器
    • 有继承的情况下的执行顺序:父类静态代码块:只在程序启动后执行一次,优先级最高 子类静态代码块:只在程序启动后执行一次,优先级低于父类静态代码块 父类构造代码块:父类任何一个构造器被调用的时候,都会执行一次,优先级低于子类静态代码块父类构造器:优先级低于父类构造代码子类构造代码块:子类任何一个构造器被调用的时候,都会执行一次,优先级低于父类构造器子类构造器:优先级低于子类构造代码块总结一下优先级:父类静态代码块 > 子类静态代码块 > 父类构造代码块 > 父类构造器 > 子类构造代码块 > 子类构造器

    实例

    1.默认构造器

    新建一个类,不提供任何构造器,编译器会默认提供一个无参构造器,这就是为什么没定义任何构造器,却可以new 某个对象()

    public class People {}
    //以上这个People类就可以直接通过new People()来实例化
    

    2.禁止对象被外部创建

    如果不希望People在外部通过new People()来实例化,只需要将构造器定义为private

    public class People{
        private People(){
            
        }
    }
    

    3.构造器重载

    重载可以简单理解为:同个方法名,不同的参数列表。如果希望People能在外部通过new People() 或 new People(“字符串”) 来实例化,则通过以下代码即可

    public class People{
        //通过new People()调用
        public People(){
            
        }
        //通过new People("字符串")调用
        public People(String str){
            
        }
        
        
    }
    

    4.构造器的继承

    定义父类构造器,由于该构造器自定义了一个带参构造器,覆盖了默认的无参构造器,所以不能直接 new Father() 调用了,除非再定义一个无参构造器

    //父类构造器
    public class Father{
        
        //自定义带参构造器
        public Father(String str){
            System.out.println("父类的带参构造方法,参数为:"+str);
        }
        
    }
    

    定义子类构造器,继承Father,由于Father没有无参构造器,所以必须在子类构造器中通过 super(“字符串”)来调用,否则编译器会报错

    //子类构造器
    public class Son extends Father{
        
        //无参构造器
        public Son(){
            //由于Father()没有无参构造器,所以必须在子类型构造器中通过super("字符串")来调用,否则编译器会报错。
            //如果没定义这句,系统会默认调用super()
            super("");
        }
        
        //带参构造器
        public Son(String str){
            //由于Father()没有无参构造器,所以必须在子类型构造器中通过super("字符串")来调用,否则编译器会报错。
            //如果没定义这句,系统会默认调用super()
            super(str);      
        }  
        
    }
    

    5. 构造器、静态代码块、构造代码块的执行顺序

    5.1无继承的情况

    public class Father {
        static {
            System.out.println("父类的静态代码块,程序启动后执行,只会执行一次");
        }
    
        //父类无参构造方法
        public Father(){
            System.out.println("父类的默认构造方法");
        }
    
        //重载,自定义父类带参构造方法
        public Father(String str){
             System.out.println("父类的带参构造方法,参数为:"+str);
        }
        
        {
            System.out.println("父类构造代码块,每次调用构造方法都会执行的");
        }
    }
    

    实例化Father

    //实例化Father
        public static void main(String[] args) {
            System.out.println("---------------------------------------");
            Father father1 = new Father();
            System.out.println("---------------------------------------");
            Father father2 = new Father("阿马");
        }
    

    执行上述代码

    父类的静态代码块,程序启动后执行,只会执行一次
    ---------------------------------------
    父类构造代码块,每次调用构造方法都会执行的
    父类的默认构造方法
    ---------------------------------------
    父类构造代码块,每次调用构造方法都会执行的
    父类的带参构造方法,参数为:阿马
    

    5.2有继承的情况

    定义父类Father

    public class Father {
        
        static {
            System.out.println("父类的静态代码块,程序启动后执行,只会执行一次");
        }
    
        //父类无参构造方法
        public Father(){
            System.out.println("父类的默认构造方法");
        }
    
        //重载,自定义父类带参构造方法
        public Father(String str){
             System.out.println("父类的带参构造方法,参数为:"+str);
        }
        
        {
            System.out.println("父类构造代码块,每次调用构造方法都会执行的");
        }
    }
    

    定义子类Son,继承自父类Father

    //子类构造器
    public class Son extends Father{
        static {
            System.out.println("子类的静态代码块,程序启动后执行,只会执行一次,先执行父类的,在执行子类的");
        }
        {
            System.out.println("子类构造代码块,每次调用构造方法都会执行的");
        }
    
        //无参构造器
        public Son(){
            //这里没有指定调用父类的哪个构造方法,会默认调用super(),调用父类的无参构造器public Father()
        }
    
        //重载构造器,多传两个参数
        public Son(String str1,String str2){
            //必须写在构造器第一行,调用父类的带参构造器public Father(str)
            super(str1);
            System.out.println("子类带参构造器:"+str2);
        }
    }
    

    实例化Son

    public static void main(String[] args) {
            System.out.println("-----------------------------------");
            Son son1 = new Son();
            System.out.println("-----------------------------------");
            Son son2 = new Son("子类第一个参数","子类第二个参数");
        }
    

    执行上述代码

    父类的静态代码块,程序启动后执行,只会执行一次
    子类的静态代码块,程序启动后执行,只会执行一次,先执行父类的,在执行子类的
    -----------------------------------
    父类构造代码块,每次调用构造方法都会执行的
    父类的默认构造方法
    子类构造代码块,每次调用构造方法都会执行的
    -----------------------------------
    父类构造代码块,每次调用构造方法都会执行的
    父类的带参构造方法,参数为:子类第一个参数
    子类构造代码块,每次调用构造方法都会执行的
    子类带参构造器:子类第二个参数
    
    展开全文
  • NX10.0后处理构造器

    2015-01-08 11:22:13
    NX10.0后处理构造器,覆盖安装目录下面的同名文件夹即可
  • java构造方法是java类中最重要的一个概念,这篇文档涵盖了,java对象初始化过程中构造器调用的顺序,及作用。
  •  要学习Java,你必须理解构造器。因为构造器可以提供许多特殊的方法,这个对于初学者经常混淆。但是,构造器和方法又有很多重要的区别。  原作者:Robert Nielsen 原站:www.javaworld.com  我们说构造器是一...
  • Scala进阶_构造器

    2021-01-07 05:49:14
    类的构造器 当创建类对象的时候,会自动调用类的构造器。之前使用的都是默认构造器,我们接下来要学习如何自定义构造器。 主构造器 我们学习过,Java的构造器,有构造列表和构造代码块 class Person { // 成员变量 ...
  • Java初始化对象的工具 - 构造器

    千次阅读 多人点赞 2020-03-12 02:06:15
    本文关键字:对象、初始化、实例化、构造器、构造方法。明确了类与对象的关系后,我们知道:类只是一个定义的结构,用来表述我们想要描述的事物,即具备哪些属性(成员变量),可以产生哪些行为(方法)。那么具体...

    写在前面:博主是一只经过实战开发历练后投身培训事业的“小山猪”,昵称取自动画片《狮子王》中的“彭彭”,总是以乐观、积极的心态对待周边的事物。本人的技术路线从Java全栈工程师一路奔向大数据开发、数据挖掘领域,如今终有小成,愿将昔日所获与大家交流一二,希望对学习路上的你有所助益。同时,博主也想通过此次尝试打造一个完善的技术图书馆,任何与文章技术点有关的异常、错误、注意事项均会在末尾列出,欢迎大家通过各种方式提供素材。

    • 对于文章中出现的任何错误请大家批评指出,一定及时修改。
    • 有任何想要讨论和学习的问题可联系我:zhuyc@vip.163.com。
    • 发布文章的风格因专栏而异,均自成体系,不足之处请大家指正。

    Java初始化对象的工具 - 构造器

    本文关键字:对象、初始化、实例化、构造器、构造方法

    一、构造器的作用

    明确了类与对象的关系后,我们知道:类只是一个定义的结构,用来表述我们想要描述的事物,即具备哪些属性(成员变量),可以产生哪些行为(方法)。那么具体行为的发生,也就是方法的调用要靠对象来完成,同时属性值也要附着在对象上才有意义。创建对象的过程被叫做类的实例化,或者称为对象的初始化,在这个过程中需要使用的就是new关键字和类的构造器。
    对于相关概念还不清楚的同学请进传送门:Java中的基本操作单元 - 类和对象

    二、构造器的定义

    1. 构造器的别称

    没错,他们都是同一个意思。

    • 构造器
    • 构造方法
    • 构造函数

    2. 构造器定义格式

    构造器本身更像一种方法,因此定义的格式与方法类似,可以区别着进行记忆。构造器同样被定义在class的大括号内,构造器的定义格式如下:

    public class className{
        // 构造器定义开始
        [权限修饰符] 类名(参数列表){
            // 代码部分
        }
        // 构造器定义结束
    }
    

    从以上的结构我们看到,构造器的声明格式与方法类似:

    • 以权限修饰符开头
    • 不能被static、final、abstract等修饰符修饰
    • 无返回值类型
    • 方法名称与类名相同
    • 一个类中可以出现多个构造方法,区别在于参数列表不同

    那么,在这个构造方法当中我们都应该写些什么呢?还是从构造器的作用入手,既然他的作用是初始化一个对象,那么对象在初始化时最需要做的就是对属性赋值,所以如果有需要我们会在调用时传入某些属性的初始值,或者在对象初始化时执行某些代码,帮助我们判断对象初始化的状态。

    public class Student{
        public Student(){
            System.out.println("学生对象初始化成功");
            // 其他代码
        }
    }
    
    public class Test{
        public static void main(String[] args){
            Student student = new Student();
            // 执行效果 -> 输出:学生对象初始化成功
        }
    }
    

    对于创建对象时为属性赋值的用法将在构造器的重载中演示。

    3. 隐式构造器

    在刚刚开始学习面向对象部分时,可能都会存在一个疑问,之前定义的class都没有定义构造器呀,不是一样可以通过new来创建实例吗?这是因为当一个类被定义后,如果没有手动的创建任何的构造方法,会默认提供一个空的构造器,供初始化使用,这个过程是编译时完成的。

    public class Person{
    
    }
    

    我们对Person类进行编译,得到Person.class文件,然后我们对class文件进行反编译,就可以看到已经出现了一个空的构造器:

    Java程序在执行时,加载的都是.class文件,并且所生成的.class文件与我们定义的.java文件一般都是存在差异的。所以这就能够解释,为什么明明我们在.java文件中没有定义构造器,但是在创建对象时却可以使用new调用到。
    隐式构造器还有一个特点,就是如果我们已经手动创建了一个无参的构造器,或者一个有参的构造器,那么在编译时就不会生成无参构造器了。

    public class Person{
        public Person(String name){
            System.out.println(name);
        }
    }
    

    此时,由于我们已经手动指定了一个构造器了,所以在编译时就不会再产生默认的无参构造器了,只会有自己手动定义的构造器:

    那么,大家应该也注意到了一个问题,既然用new创建对象时是调用的构造器,那么现在我们自己定义了一个有参数的构造器,那么就会使得我们最常使用的new Person()这种实例化的代码报错,因为此时类中已经没有无参构造器可供调用了,也可以认为无参的构造器被覆盖了,必须要传入一个参数才能初始化对象。

    public class Test{
        public static void main(String[] args){
            Person person = new Person();
            // 编译不通过,已经无法调用无参构造器来初始化对象
        }
    }
    

    那么如果我们还是想用这个无参构造器来创建对象该怎么办呢?没错,手动声明一下就好了,里面不需要写任何内容:

    public class Person{
        // 无参构造器
        public Person(){}
        // 有参构造器,可以接收一个参数
        public Person(String name){
            System.out.println(name);
        }
    }
    

    我们来看一下效果,很明显,将会同时存在两个构造器,我们在使用new进行对象初始化的时候可以根据需要来使用。
    `

    public class Test{
        public static void main(String[] args){
            Person person1 = new Person();
            // 编译通过,执行后person1被成功实例化,无输出
            Person person2 = new Person("小明");
            // 编译通过,执行后person2被成功实例化,输出:小明
        }
    }
    

    4. 构造器的重载

    从上面的例子我们已经可以看到,一个类结构中可以存在多个构造器,用于在有不同需要时被调用。而且由于构造器本身的主要作用是用于为类的属性赋初始值,所以在构造器中我们会指定一些参数,用于被调用时传入,为当前类的属性赋值。

    public class Person{
        // 无参构造器
        public Person(){}
        // 两参构造器,可以给name和age属性赋值
        public Person(String name,int age){
            this.name = name;
            this.age = age;
        }
        // 三参构造器,可以给name、age和job属性赋值
        public Person(String name,int age,String job){
            this.name = name;
            this.age = age;
            this.job = job;
        }
        public String name;
        public int age;
        public String job;
    }
    

    在上面的代码中我们可以看到有三个构造器,名称相同,只有参数列表不同,这种关系被称为重载,在方法中也有类似的概念。可以看到构造器中存在部分代码,且都是赋值语句。

    • this关键字的用法

    this可以指代当前对象,使用this可以调用出直接在类下定义的成员(变量和方法),其中一个最主要的作用就是可以区分同名的变量。我们在进行变量命名时,一直强调见名知意,那么问题就来了:在类中定义的成员变量名称已经确定了,而构造器中传入的参数就是为了给这些属性赋值的,那么参数的名称是不是应该和类成员变量一样才更能表达意思呢?如果这样的话就造成了参数列表中的变量名称与类成员变量的名称同名,这时就可以通过this来区分。
    明确了this的用法,我们再来看构造器中的内容就很好理解了,将传入的参数赋值给当前对象的类成员变量,具体的调用过程我们看下面的例子。

    三、构造器的调用

    src
    └──edu
        └──sandtower
            └──bean
                │    Person.java
            └──test
                │    Test.java
    

    以上为实体类与测试类所在的目录结构,Person实体类所在包:edu.sandtower.bean,Test测试类所在包:edu.sandtower.test,则代码如下:

    package edu.sandtower.bean;
    
    public class Person{
        // 无参构造器
        public Person(){}
        // 三参构造器,可以给name、age和job属性赋值
        public Person(String name,int age,String job){
            this.name = name;
            this.age = age;
            this.job = job;
        }
        public String name;
        public int age;
        public String job;
    }
    
    package edu.sandtower.test;
    // 导包操作:指明需要使用的Person类的所在位置
    import edu.sandtower.bean.Person;
    
    public class Test{
        public static void main(String[] args){
            Person person1 = new Person();
            // person1被成功实例化,各属性无初始值,可以手动赋值
            person1.name = "小张";
            person1.age = 26;
            person1.job = "Linux运维工程师";
            Person person2 = new Person("小李",25,"Java开发工程师");
            // person2被成功实例化,并具有如下初始值
            // name:小李
            // age:25
            // job:Java开发工程师
            // 输出进行验证
            System.out.println("name:" + person2.name);
            System.out.println("age:" + person2.age);
            System.out.println("job:" + person2.job);
        }
    }
    

    在进行对象的初始化时,可以根据需要取得一个空的对象(如:person1)后手动赋值,也可以通过有参构造器直接对属性赋值(如:person2),避免逐一赋值的麻烦。

    扫描下方二维码,加入官方粉丝微信群,可以与我直接交流,还有更多福利哦~

    在这里插入图片描述

    展开全文
  • 前言:同一个类里具有多个构造器,多个构造器的形参列表不同,即被称为构造器重載。构造器重载允许 Java 类里包含多个初始化逻辑,从而允许使用不同的构造器来初始化 Java 对象。在看本篇之前先了解 使用构造器执行...

    前言:同一个类里具有多个构造器,多个构造器的形参列表不同,即被称为构造器重載。构造器重载允许 Java 类里包含多个初始化逻辑,从而允许使用不同的构造器来初始化 Java 对象。在看本篇之前先了解 使用构造器执行初始化


    1、构造器的重载

    ​ 构造器重载和方法重载基本相似:概况起来就是名称相同参数列表不同。要求构造器的名字相同,这一点无须特别要求,因为构造器必须与类名相同,所以同一个类的所有构造器名肯定相同。为了让系统能区分不同的构造器,多个构造器的参数列表必须不同。

    1.1、代码表示

       public class ConstructorOverload {
        public String name;
        public int count;
    
        /**
         * 提供无参数的构造器
         */
        public ConstructorOverload() {
    
        }
    
        /**
         * 提供一个参数的构造器,对构造器返回的对象进行初始化
         *
         * @param name 名称
         */
        public ConstructorOverload(String name) {
            this.name = name;
        }
    
        /**
         * 提供两个参数的构造器,对构造器返回的对象进行初始化
         *
         * @param name  名称
         * @param count 数量
         */
        public ConstructorOverload(String name, int count) {
            this.name = name;
            this.count = count;
        }
    
        public static void main(String[] args) {
            // 通过无参数的构造器创建 ConstructorOverload 对象
            ConstructorOverload con1 = new ConstructorOverload();
            // 通过一个参数的构造器创建 ConstructorOverload 对象
            ConstructorOverload con2 = new ConstructorOverload("西瓜");
            // 通过两个参数构造器创建 ConstructorOverload 对象
            ConstructorOverload con3 = new ConstructorOverload("玉米", 100);
    
            // 开始调用方法
            System.out.println("名称:" + con1.name);
            System.out.println("名称:" + con2.name);
            System.out.println("名称:" + con3.name + "\t 数量:" + con3.count);
        }
    }
    

    1.2、运行结果

    名称:null
    名称:西瓜
    名称:玉米     数量:100
    

    2、构造器间的相互调用

    ​ 上面的 ConstructorOverload 类提供了两个重载的构造器,两个构造器的名字相同,但形参列表不同。系统通过 new 调用构造器时,系统将根据传入的实参列表来决定调用哪个构造器。如果系统中包含多个构造器,其中一个构造器的执行体里完全包含另一个构造器的执行体,如下图所示:

    ​ 从图中可以看出,构造器 B 完全包含了构造器 A 。对于这种完全包含的情况分两种:

    • 方法之间:如果是两个方法之间存在这种关系,则可在方法 B 中直接调用方法 A 。

    • 构造器之间:构造器不能直接被调用,构造器必须使用 new关键字来调用。但一旦使用 new 关键字来调用构造器,将会导致系统重新创建一个对象

    2.1、代码表示

    ​ 为了在构造器 B 中调用构造器 A 中的初始化代码,又不会重新创建一个 Java 对象,可以使用 this 关键字来调用相应的构造器。下面代码实现了在一个构造器中,直接使用另一个构造器的初始化代码。

       /**
     * @author Administrator
     */
    public class ConstructorInvoke {
        public String name;
        public int count;
        public double weight;
    
        /**
         * 无参构造
         */
        public ConstructorInvoke() {
    
        }
    
        /**
         * 两个参数的构造器
         *
         * @param name  名称
         * @param count 数量
         */
        public ConstructorInvoke(String name, int count) {
            this.name = name;
            this.count = count;
        }
    
        /**
         * 三个参数的构造器
         *
         * @param name   名称
         * @param count  数量
         * @param weight 重量
         */
        public ConstructorInvoke(String name, int count, double weight) {
            /*this.name = name;
            this.count = count;*/
    
            // 通过 this 调用另一个重载的构造器的初始化代码
            this(name, count);
            // 下面 this 引用该构造器正在初始化的 Java 对象
            this.weight = weight;
        }
    
        public static void main(String[] args) {
            ConstructorInvoke radish = new ConstructorInvoke("萝卜", 200, 2);
            System.out.println("名称:" + radish.name + "\t数量:" + radish.count + "\t" + "重量" + radish.weight);
        }
    }
    

    2.2、运行结果

    名称:萝卜    数量:200    重量2.0
    

    ​ 上面的 ConstructorInvoke 类里包含了三个构造器,其中第三个构造器通过 this 来调用另一个重载构造器的初始化代码。程序中 this (name, color ); 调用表明调用该类另一个带两个字符串参数的构造器。

    ​ 使用 this 调用另一个重载的构造器,只能在构造器中使用,而且必须作为构造器执行体的第一条语句 ,使用 this调用重载的构造器时,系统会根据this 后括号里的实参来调用形参列表与之对应的构造器。

    3、知识补充

    3.1、为什么要用 this 来调用构造器,而不是直接复制代码?

    ​ 从图1中其实就可以知道为什么要调用构造器,而不是复制代码了。为啥?😉 往下看 baby

    ​ 因为软件是一个需要不断更新的产品,如果有一天需要更新图1中构造器 A 的初始化代码,假设构造器 B、构造器 C 都含有相同的初始化代码,则需要同时打开构造器 A、构造器 B、构造器 C …… 的代码进行修改;反之,如果构造器 B、构造器 C …… 是通过 this 调用了构造器 A 的初始化代码,则只需要打开构造器 A 进行修改既可。

    • 如果仅仅从软件功能实现上来看:这样复制、粘贴确实可以实现所想要的功能;
    • 从软件工程的角度来看:这样做是相当糟糕的。

    ​ 在软件开发里有一个规则:不要把相同的代码段书写两次以上(就是冗余代码,现在有印象了吧(∩_∩))。因此,尽量避免相同的代码重复出现,充分复用每一段代码(毕竟按代码行数算钱的时代已经过去 ( ̄▽ ̄)),既可让程序代码更加简洁,也可以降低软件的维护成本。

    展开全文
  • 上一篇说了属性绑定,但是在springboot底层使用更多的还是构造器绑定: 1.YmlProperties.java package com.yuhl; import lombok.Data; import lombok.ToString; import org.springframework.boot.c

    上一篇:04-Springboot属性绑定:yum文件和Properties类的属性绑定https://blog.csdn.net/fsjwin/article/details/109699991

    上一篇说了属性绑定,但是在springboot底层使用更多的还是构造器绑定:

    在这里插入图片描述

    1.YmlProperties.java

    package com.yuhl;
    
    import lombok.Data;
    import lombok.ToString;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.boot.context.properties.ConstructorBinding;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /**
     * @author yuhl
     * @Date 2020/11/14 10:19
     * @Classname YmlProperties
     * @Description yml测试 Properties类
     */
    @Data
    @ToString
    @ConstructorBinding //构造器绑定 和 @Component 只能有一个
    @ConfigurationProperties(prefix = "yml") //从配置文件中读取数据的开图字符
    public class YmlProperties {
        private String str;
        private String specialStr;
        private Integer num;
        private Double dnum;
        private Date birth;
        private List list;
        private Set set;
        private Map map;
        private List<User> users;
    }
    
    

    2. yml文件

    yml:
      str: 普通字符串
      specialStr: "换\n行字符串"
      num: 520
      dnum: 520:22
      birth: 2020/11/11 11:11:11
      list:
        - 大鸟
        - 小鸟
        - 中鸟
      set:
        - set1
        - set2
        - set3
      #set: [set3,set5,set6]
      map: {k1: v1, k2: v2}
      users:
        - name: yuhl
          age: 20
        - name: rll
          age: 18
    
    ymlother:
      str: 普通字符串
      specialStr: "换\n行字符串"
      num: 520
      dnum: 520:22
      birth: 2020/11/11 11:11:11
      list:
        - 大鸟
        - 小鸟
        - 中鸟
      set:
        - set1
        - set2
        - set3
      #set: [set3,set5,set6]
      map: {k1: v1, k2: v2}
      users:
        - name: yuhl
          age: 20
        - name: rll
          age: 18
    
    validata:
      num: 100
    

    3.控制器HelloController

    package com.yuhl;
    
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author yuhl
     * @Date 2020/11/14 8:54
     * @Classname controller
     * @Description TODO
     */
    @RestController
    @EnableConfigurationProperties(YmlProperties.class)
    public class HelloController {
        //注入
        @Autowired
        YmlProperties ymlProperties;
        @RequestMapping("/yml")
        public YmlProperties yml() {
            System.out.println("properties:" +ymlProperties);
            return ymlProperties;
        }
    }
    
    

    4.测试

    在这里插入图片描述

    5.属性注入变形

    1. 属性绑定的案例中我们同样也可以使用@EnableConfigurationProperties,此时不需要提供@Component。
    2. 如果一个配置类只配置@ConfigurationProperties注解,而没有使用@Component,那么在IOC容器中是获取不到properties 配置文件转化的bean。
    3. 而如果使用@EnableConfigurationProperties 相当于把使用 @ConfigurationProperties 的类进行了启用注入
    4. 这样的话Properiteis文件上就可以不用@Component了。只需要在使用它的类上写上@EnableConfigurationProperties(YmlProperties.class)
      即可。

    下一篇:06-Springboo第三方组件注入:yum文件和@Bean的第三方组件注入https://blog.csdn.net/fsjwin/article/details/109706247

    展开全文
  • 深度分析Spring中的构造器注入

    万次阅读 多人点赞 2019-01-02 09:30:21
    深入源码分析Spring中的构造器注入 文章目录深入源码分析Spring中的构造器注入1. 示例疑问点小结2. 依赖注入伊始3. 初始化Bean4.总结 在往期文章中我没有提到在Spring中是如何将Bean注入到构造器,其实这个过程发生...
  • Dart中的类——初始化列表、命名构造器、factory构造器、常量构造器构造器私有化、get和set方法、枚举 1、调用成员变量——使用"."来调用成员变量或方法 var p = Point(2, 2); // Set the value of the instance ...
  • 构造器是什么?(Java篇)

    千次阅读 2020-03-16 17:40:48
    构造方法也叫构造器或者构造函数 构造方法与类名相同,没有返回值,连void都不能写 构造方法可以重载(重载:方法名称相同,参数列表不同) 如果一个类中没有构造方法,那么编译器会为类加上一个默认的构造方法。 ...
  • 构造器(有参、无参)

    千次阅读 多人点赞 2020-07-26 16:59:59
    构造器: 就是和类名相同但无返回类型的方法。用于当前或某一对象的实例化,并将当前或某一对象返回。无参构造:1、如果使用new关键字实际上是调用无参构造器;2、无参构造往往是为了初始化一些值。有参构造:一旦...
  • Mybatis-Plus条件构造器

    千次阅读 2019-07-10 01:59:51
    mybatis-plus提供了强大的条件构造器。这里简要介绍了条件构造的结构与关系,并通过简要的示例描述条件查询、删除和修改的构造方式。 二、条件构造器结构 备注 绿色框为抽象类abstract 蓝色框为正常class类,可new...
  • java构造器的重载

    千次阅读 2019-05-07 17:29:42
    使用对象构造器构造器也叫构造方法或者构造函数,构造器与类名相同,没有返回值,不能使用void;名称与类名相同,没有返回值,不能写void;如果类中没有手动添加构造器,编译器会默认再添加一个无参构造器。如果...
  • Spring构造器注入循环依赖的解决方案及原理探索

    千次阅读 多人点赞 2020-03-29 16:49:30
    前言 我们都知道Spring解决了Setter注入或者Field注入的循环依赖问题,依靠的是三...但是,构造器注入下的循环依赖,Spring并没有直接解决,因此网上有许多文章都会说Spring的构造器注入循环依赖无解,实则不然,Spr...
  • 构造器 与构造方法的关系

    万次阅读 2020-06-28 22:48:42
    构造器的作用: 构造器的产生过程实际上是一个**代码收敛的过程**,**编译器会把语句块**(对于实例构造器而言是“{}”块,对于类构造器而言是“static{}”块)、**变量初始化**(实例变量和类变量)、**调用父类的...
  • 好的,说到构造器,我们先来看一什么是构造器: 最简单直白的话,当你要new一个对象的时候,必须要有构造器才能new出来,类里面默认有无参的构造器,看不到的,当我们要创建一个有参构造的时候,最好也把无参构造写...
  • MyBatis-Plus条件构造器

    千次阅读 2020-12-30 17:08:40
    条件构造器 wapper介绍 : Wrapper : 条件构造抽象类,最顶端父类,抽象类中提供4个方法 AbstractWrapper : 用于查询条件封装,生成 sql 的 where 条件 AbstractLambdaWrapper : Lambda 语法使用 Wrapper统一处理...
  • Java构造器介绍

    千次阅读 2018-11-30 22:22:34
    Java构造器基础 1.构造器概念:构造器可以提供许多特殊的方法...(缺省构造器:缺省构造器是在一个类没有声明任何构造器的情况下,编译器强制为该类添加的一个无参数的构造器,该构造器仅仅调用父类的无参数构造器,...
  • Mybatis-Plus中的条件构造器

    千次阅读 2020-07-06 16:30:00
    Mybatis-Plus中的条件构造器 ​ 条件构造器(Wrapper)的作用: ​ MP提供的通用Mapper中,删改查(没有insert)的方法通常会需要我们传入一个条件构造器,用来生成最后执行的SQL语句。 ​ 比如List selectList( ...
  • * 主要原因是:构造器和方法不一样,方法是可以通过(对象.方法)来调用的 ,但是构造器是为了 造对象的。 * * fields 属性 constructor 构造器(又称构造方法) * * 类的结构之三:构造器 (或构造方法、con...
  • 构造器注入

    千次阅读 2018-12-01 16:39:59
    构造器注入:简单注入 --> < bean id= "emp" class= "construct.easyinjection.employee" > < constructor-arg name= "username" value= " 洲洲 " > constructor-arg > < constructor-arg name...
  • JPA构造器的使用样例

    2009-11-01 04:20:32
    多表查询所用到的用来构造list的java类,用于演示在 jpa SQL 查询中如何使用自定义构造器
  • IDEA快速生成构造器(构造函数)

    千次阅读 2021-08-19 18:44:28
    IDEA快速生成构造器 Java里面的构造器和是C++里面的构造函数极其类似 话不多说,直接上干货。如果生成位置不理想可以看小tips哦 0x0 效果图 0x1 自己创建一个类 第一步自己创建一个类,并且写上属性。如下 0x2 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,253,967
精华内容 501,586
关键字:

构造器