构造方法

构造方法的作用:
    作用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;
    }
}
posted @ 2020-06-06 00:01  xlwu丶lz  阅读(329)  评论(0编辑  收藏  举报