构造方法

构造方法的作用：

    作用1： 创建对象。

    作用2： 给属性赋值。

 

构造方法怎么去调用？

    new 类名();

 

构造方法名和什么一致？

    构造方法名和类型必须保持一致。

 

构造方法有没有返回值类型？

    没有返回值类型（有返回值类型的是普通方法）

 

构造方法可以重载吗？

    可以。

 

什么是重载：

    在同一个类中，方法名相同，参数列表个数和类型不同。

 

案例1：

/*
    构造方法
    1 什么是构造方法？有什么用？
        构造方法是一个比较特殊的方法，通过构造方法可以完成对象的创建以及实例化变量的初始化。
        换句话说。构造方法就是用来创建对象，并且同时给对象的属性赋值。（注意：实例变量没有手动赋值的时候，系统会默认赋值。）
    
    2 重点（需要记忆）：当一个类没有提供任何构造方法，系统会默认提供一个无参数的构造方法。（而这个构造方法被称为缺省构造器。）
    
    3 调用构造方法怎么调用呢？
        使用哪个运算符呢？
            使用new运算符来调用构造方法。
            语法格式:
                new 构造方法名(实际参数列表);
    
    4 构造方法的语法结构是？
        [修饰符列表] 构造方法名(形式参数列表){
            构造方法体；
            通常在构造方法体当中给属性赋值，完成属性的初始化。
        }
        
        注意：
            第一：修饰符列表目前统一写：public 千万不要写public static。
            第二：构造方法名和类名必须一致。
            第三：构造方法不需要指定返回值类型。也不能写void ，写上void表示普通方法，就不是构造方法了。
        
        普通方法的语法结构是?
        [修饰符列表] 返回值类型 方法名(){
            方法体;
        }
    
    5 构造方法。
        5.1 当一个类中没有提供任何构造方法，系统默认提供一个无参数的构造方法。这个无参数的构造方法叫做缺省构造器。
        
        5.2 当一个类中手动的提供了构造方法，那么系统将不再默认提供无参数构造方法。
                建议讲一个无参数构造方法手动的写出来，这样一定不会出现问题。
        
        5.3 无参数构造方法和有参数的构造方法都可以调用。
            Student x = new Student();
            Student y = new Student(100);
        
        5.4 构造方法支持方法重载吗？
            构造方法是支持方法重载的。
            在一个类当中构造方法可以有多个。
            并且所有的构造方法名字都是一样的。
            
            方法重载特点：
                在同一个类中，方法名相同，参数列表不同。
                
        5.5 对于实例变量来说，只要你在构造方法中没有手动给它赋值，统一都会默认赋值。默认赋系统值。
        
*/
public class ConstructionTest01{
    public static void main(String[] args){
        
        // 调用Student类中的无参数构造方法
        new Student();
        
        // 调用普通方法
        ConstructionTest01.doSome();
        doSome();
        
        // 创建Student类型的对象
        Student s = new Student();
        // 输出“引用”
        // 只要输出结果不是null,说明这个对象一定是创建完成了。
        // 此处的输出结果大家目前是看不懂的，后期再说。
        System.out.println(s);// Student@54bedef2
        
        Student s3 = new Student(100);
        System.out.println(s3);
    }
    
    public static void doSome(){
        System.out.println("do Some");
    }
}

public class Student{
    //学号
    int no;
    //姓名
    String name;
    //年龄
    int age;
    
    // 当前的Student这个类中并没有定义任何构造方法。
    // 但是系统实际上会自动给Student类提供一个无参数的构造方法。
    // 将无参数的构造方法（缺省构造器）写出来
    public Student(){
        System.out.println("无参数的构造方法执行了");
    }
    
    // 定义一个有参数的构造方法
    public Student(int i){
        System.out.println("有参的构造方法执行了,实际参数列表的字面量(值)为：" + i);
    }
    
    // 没有返回值类型，编译器会判定该方法是构造方法。
    // 于是编译器会检测方法名是否和类名一致，结果发现不一致。
    // 编译器报错。
    /*
        编译器检测到该方法名“Studet”，返现这个名字和类名不一致，编译器会认为该方法是一个普通方法，普通方法应该有返回值
        但是没有写返回值类型，所以报错了。
        错误: 方法声明无效; 需要返回类型
    */
    /*public Studet(String x){
        System.out.println("有参的构造方法执行了,实际参数列表的字面量(值)为：" + x);
    }*/
    
    // 第一种修改方法
    /*
    public void Studet(String x){
        System.out.println("有参的构造方法执行了,实际参数列表的字面量(值)为：" + x);
    }
    */
    
    // 第二种修改方法
    public Student(String x){
        System.out.println("有参的构造方法执行了,实际参数列表的字面量(值)为：" + x);
    }
    
}

案例2：

/*
    1 构造方法对应的英语单词：Construction【构造器】
    2 构造方法的作用？
        创建对象，并且创建对象的过程中给属性赋值（初始化。）
*/
public class ConstructionTest02{
    public static void main(String[] args){
            
            User u = new User();
            System.out.println(u.id); // 111
            System.out.println(u.userName); // lisi
            System.out.println(u.age); // 30
            
            User u2 = new User(1111111);
            System.out.println(u2.id); // 0
            System.out.println(u2.userName); // null
            System.out.println(u2.age); // 0
    }    
}

/*
    1 id name age 都有默认值对嘛？
        对。
    
    2 id的默认值：0
        userName的默认值：null
        age的默认值：0
    
    3 思考：实例变量没有手动赋值的时候，实际上系统会默认赋值，那么这个默认赋值操作是在什么时间进行的？
        是在类加载的时候给这些变量赋值的吗？
        
        不是，实例变量是在构造方法执行的过程中完成初始化的，完成赋值的。
        
*/
public class User{
    // 3个属性，3个实例变量【对象字面量】
    
    //用户id
    int id;// System.out.println(User.id); 错误的，需要先new对象，只有对象有了才能谈id的赋值。
    //用户名
    String userName;
    //年龄
    int age;
    
    //手动定义有参数的构造方法，无参数构造方法将消失。
    /*public User(int a){
        
    }*/
    
    public User(int a){
    
    }
    
    public User(){
        // 这里是有三行方法的，只是你看不到。
        // 无参构造方法体当中虽然什么代码都没写，但是实际上是在这个方法体里面进行的实例变量默认初始化。
        /*id = 0;
        userName = null;
        age = 0;*/
        
        // 这就表示不再采用系统默认值，手动赋值了。
        id = 111;
        userName = "lisi";
        age = 30;
    }
}

案例3：

public class ConstructionTest03{
    public static void main(String[] args){
        //调用不同的构造方法创建对象
        Vip v1 = new Vip();
        System.out.println(v1.no);
        System.out.println(v1.name);
        System.out.println(v1.birth);
        System.out.println(v1.sex);
        
        System.out.println("--------v1---------");
        
        Vip v2 = new Vip(111L,"zhangsan");
        System.out.println(v2.no);
        System.out.println(v2.name);
        System.out.println(v2.birth);
        System.out.println(v2.sex);
        
        System.out.println("--------v2---------");
        
        Vip v3 = new Vip(111L,"zhangsan","2020-05-26");
        System.out.println(v3.no);
        System.out.println(v3.name);
        System.out.println(v3.birth);
        System.out.println(v3.sex);
        
        System.out.println("--------v3---------");
        
        Vip v4 = new Vip(111L,"zhangsan","2020-05-26",true);
        System.out.println(v4.no);
        System.out.println(v4.name);
        System.out.println(v4.birth);
        System.out.println(v4.sex);
        
        System.out.println("--------v4---------");
        
    }
}

public class Vip{
    // 会员号
    long no;
    // 会员姓名
    String name;
    // 生日
    String birth;
    // 性别
    boolean sex;
    
    // 无参数构造方法
    public Vip(){
        
    }
    // 有参数构造方法
    public Vip(long huiYuanHao,String xingMing){
        // 给实例变量赋值[初始化实例变量，初始化属性]
        no = huiYuanHao;
        name = xingMing;
        // 实际上这里还有两行代码(没有手动赋值，系统都会默认赋值。)
        //birth = null;
        //sex = false;
    }
    
    // 有参数构造方法
    public Vip(long huiYuanHao,String xingMing,String shengRi){
        // 给实例变量赋值[初始化实例变量，初始化属性]
        no = huiYuanHao;
        name = xingMing;
        birth = shengRi;
        // 实际上这里有一行代码。你看不见
        //sex = false;
    }
    
    // 有参数构造方法
    public Vip(long huiYuanHao,String xingMing,String shengRi,boolean xingBie){
        // 给实例变量赋值[初始化实例变量，初始化属性]
        no = huiYuanHao;
        name = xingMing;
        birth = shengRi;
        sex = sex;
    }
}