Java——构造器

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);
        }
    }  结果：

1. ----Animal无参构造器-----
2. ----Horse无参构造器-----
3. ----Animal无参构造器-----
4. ----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();
        }
    } 

结果：

1. ----Animal无参构造器-----
2. ----Horse有参构造器-----
3. ----Horse无参构造器-----

引用参考：http://www.jb51.net/article/75880.htm

引用参考：http://blog.csdn.net/yoamy/article/details/51250218