Java——构造器-CSDN博客

Java 构造器的由来：构造器是一个创建对象时被自动调用的特殊方法，为的是初始化。

当创建一个个对象时，系统会该对象的属性默认初始化，基本类型属性的值为0（数值类型），false（布尔类型），把所有的引用类型设置为null。构造器可以改变这种默认的初始化。构造器不是函数。

要求：构造器的名称应与类的名称一致。调用构造器是编译器的责任，所以必须让编译器知道调用的是哪一个方法。所以Java采取了与类同名的方法命名构造器。

public class Person {
    public String name;
    public int age;
    //系统会自动分配
    public void Person(){}// 自定义构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

 public static void main(String[] args) {
        // 使用自定义的构造器创建对象（构造器是创建对象的重要途径） Person p = new Person("小明", 12); System.out.println(p.age); System.out.println(p.name); } }

package collection;
//插入一段this的用法
public class Leaf{
        private int i=0;
        Leaf (int i){this.i=i;}
        Leaf increment(){
        i++;
        return this;
  }
        
        void print(){
        System.out.println("i="+i);
  }
        public static void main (String [] args)
        {
        Leaf x =new Leaf(100);//这条语句过后i=100.
        x.increment().increment(). increment().print();//结果是103
  }        
}

无参构造器：

1.0：如果在类中你提供了其他有参的构造器，则编译器不会提供默认的无参构造器。

    class Animal {  
        Animal(String name) { }  
        public static void main(String[] args){  
            Animal a = new Animal();  
        }  
    }

此段代码不能被编译通过

2.0：如果在类中你没有提供任何构造器，则编译器会提供一个默认的无参构造器。

    class Animal {  
        public static void main(String[] args){  
            Animal a = new Animal();  
        }  
    }

此段代码可以通过

3.0：如果你提供了一个构造器，你无须手动添加super()到你的构造器，编译器会默认添加。

    class Animal {  
        Animal (){  
            System.out.println("----Animal无参构造器-----");  
        }  
    }  
    class Horse extends Animal {  
        Horse() {  
    //      super(); //此行代码有与没有都是一样的  
            System.out.println("----Horse无参构造器-----");  
        }  
        Horse(int a) {  
    //      super(); //此行代码有与没有都是一样的  
            System.out.println("----Horse有参构造器-----");  
        }  
        public static void main(String[] args){  
            Horse a = new Horse();  
            Horse b = new Horse(3);  
        }  
    }  
结果：

----Animal无参构造器-----
----Horse无参构造器-----
----Animal无参构造器-----
----Horse有参构造器-----

4.0:如果父类未提供无参构造器，子类会报错：

class Animal {  
    Animal (int a){  
        System.out.println("----Animal有参构造器-----");  
    }  
}  
class Horse extends Animal {  
    Horse() {  
        System.out.println("----Horse无参构造器-----");  
    }  
    public static void main(String[] args){  
        Horse a = new Horse();  
    }  
} 
此段代码不能通过

5. 如果构造器中添加了this引用该类的其他构造器，或者添加了super()调用父类构造器，this和super必须在构造器第一行，this引用其他构造器和super()语句不会同时出现

    class Animal {  
        Animal (){  
            System.out.println("----Animal无参构造器-----");  
        }  
    }  
    class Horse extends Animal {  
        String name;  
        Horse() {  
            System.out.println("----Horse无参构造器-----");  
            this("马");  //提示错误，  
        }  
        Horse(String name){  
            this.name = name;  
        }  
    }

6. 如果构造器中添加了this引用该类的其他构造器，或者添加了super()调用父类构造器，如果this和super中有参数，则只能是静态的方法和静态变量或常量

    class Animal {  
        Animal (){  
            System.out.println("----Animal无参构造器-----");  
        }  
    }  
    class Horse extends Animal {  
        String name;  
        Horse() {  
            this(getRondomName());<span style="font-family:Arial, Helvetica, sans-serif;"> //代码段A</span>  
            System.out.println("----Horse无参构造器-----");  
        }  
        Horse(String name){  
            System.out.println("----Horse有参构造器-----"); //代码段B  
            this.name = name;  
        }  
        static String getRondomName(){  
            int x = (int) (Math.random() * 5);  
            String name = new String[] {"马", "猪", "牛", "羊","猫"}[x];  
            return name;  
        }  
        public static void main(String[] args){  
            Horse a = new Horse();  
        }  
    } 

结果：