Java构造器（构造方法）详解
 
什么是构造器
 
构造器通常也叫构造方法、构造函数，构造器在每个项目中几乎无处不在。当你new一个对象时，就会调用构造器。构造器格式如下：
 
[修饰符，比如public] 类名 (参数列表，可以没有参数){ //这里不能有return}
 


 
文章目录
 
Java构造器（构造方法）详解
Java构造器
怎么定义构造器
构造器的使用
构造器的继承
构造器、静态代码块、构造代码块的执行顺序，详见下文实例
实例
1.默认构造器
2.禁止对象被外部创建
3.构造器重载
4.构造器的继承
5. 构造器、静态代码块、构造代码块的执行顺序
5.1无继承的情况
5.2有继承的情况
   
  
 

 
Java构造器
 
构造器的注意事项：
 
构造器的名称必须和类名一致
一个类中可以定义多个构造器，但是构造器的参数列表必须不同(重载)
如果我们没有手动定义构造器，则Java系统会提供一个默认的构造器给我们使用，一旦我们定义了构造器，则系统会把默认的构造器收回
构造器的作用：实例化对象，给对象赋初始值
代码游离块优先执行
 
怎么定义构造器
 
构造方法的名字必须和所在类的名字一致，没有返回值，但不能声明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("子类第一个参数","子类第二个参数");
    }
 
执行上述代码
 
父类的静态代码块，程序启动后执行，只会执行一次
子类的静态代码块，程序启动后执行，只会执行一次，先执行父类的，在执行子类的
-----------------------------------
父类构造代码块，每次调用构造方法都会执行的
父类的默认构造方法
子类构造代码块，每次调用构造方法都会执行的
-----------------------------------
父类构造代码块，每次调用构造方法都会执行的
父类的带参构造方法，参数为：子类第一个参数
子类构造代码块，每次调用构造方法都会执行的
子类带参构造器：子类第二个参数

 
 
写在前面：博主是一只经过实战开发历练后投身培训事业的“小山猪”，昵称取自动画片《狮子王》中的“彭彭”，总是以乐观、积极的心态对待周边的事物。本人的技术路线从Java全栈工程师一路奔向大数据开发、数据挖掘领域，如今终有小成，愿将昔日所获与大家交流一二，希望对学习路上的你有所助益。同时，博主也想通过此次尝试打造一个完善的技术图书馆，任何与文章技术点有关的异常、错误、注意事项均会在末尾列出，欢迎大家通过各种方式提供素材。
 
 
对于文章中出现的任何错误请大家批评指出，一定及时修改。
有任何想要讨论和学习的问题可联系我：zhuyc@vip.163.com。
发布文章的风格因专栏而异，均自成体系，不足之处请大家指正。
 
Java初始化对象的工具 - 构造器
 
本文关键字：对象、初始化、实例化、构造器、构造方法
 

 
文章目录
 
Java初始化对象的工具 - 构造器
一、构造器的作用
二、构造器的定义
1. 构造器的别称
2. 构造器定义格式
3. 隐式构造器
4. 构造器的重载
   
三、构造器的调用
 

 
一、构造器的作用
 
明确了类与对象的关系后，我们知道：类只是一个定义的结构，用来表述我们想要描述的事物，即具备哪些属性（成员变量），可以产生哪些行为（方法）。那么具体行为的发生，也就是方法的调用要靠对象来完成，同时属性值也要附着在对象上才有意义。创建对象的过程被叫做类的实例化，或者称为对象的初始化，在这个过程中需要使用的就是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 对象。在看本篇之前先了解 使用构造器执行初始化 。
 
 


 
文章目录
 
1、构造器的重载
1.1、代码表示
1.2、运行结果
   
   
2、构造器间的相互调用
2.1、代码表示
2.2、运行结果
   
   
3、知识补充
3.1、为什么要用 this 来调用构造器，而不是直接复制代码？
   
  
 

 
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 进行修改既可。
 
 
如果仅仅从软件功能实现上来看：这样复制、粘贴确实可以实现所想要的功能；
从软件工程的角度来看：这样做是相当糟糕的。
 
​ 在软件开发里有一个规则：不要把相同的代码段书写两次以上（就是冗余代码，现在有印象了吧(∩_∩)）。因此，尽量避免相同的代码重复出现，充分复用每一段代码（毕竟按代码行数算钱的时代已经过去 (￣▽￣)），既可让程序代码更加简洁，也可以降低软件的维护成本。
 
 
  

上一篇：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.属性注入变形
 
在属性绑定的案例中我们同样也可以使用@EnableConfigurationProperties，此时不需要提供@Component。
如果一个配置类只配置@ConfigurationProperties注解，而没有使用@Component，那么在IOC容器中是获取不到properties 配置文件转化的bean。
而如果使用@EnableConfigurationProperties 相当于把使用 @ConfigurationProperties 的类进行了启用注入
这样的话Properiteis文件上就可以不用@Component了。只需要在使用它的类上写上@EnableConfigurationProperties(YmlProperties.class)
 即可。
 
下一篇：06-Springboo第三方组件注入：yum文件和@Bean的第三方组件注入https://blog.csdn.net/fsjwin/article/details/109706247