菜鸡的Java笔记 第十二 - java 构造方法与匿名对象

1.点
    构造方法的作用以及定义要求
    匿名对象的使用
    构造方法：
        只要出现（）的都表示方法
        构造方法就是类构造对象时调用的方法，主要用来实例化对象。

>>>>
    2.1构造方法
        首先看一个格式：实例化对象操作。
            ①类名称 ②对象名称 = ③new ④类名称（）；
        每个组成部分的意义；
            “①类名称”：用于标记对象的类型，因为对象开辟空间后需要开辟堆内存，堆内存保存属性，属性在类中定义；
            “ ②对象名称”：如果要想操作类中的属性或者方法，那么必须依靠对象名称完成；
            “ ③new”：类属于引用数据类型，开辟新的堆内存空间，一定使用 new 完成；
            “④类名称（）”：只要出现“（）”的都表示方法，................这个实际上就是构造方法。

 

只要是 方法就一定能重载
构造方法重载的时候不需要 考虑方法名称 因为必须跟类名称一样 只需要考虑参数类型或者个数即可
    构造方法重载需要注意 按照参数的个数顺序降序或 升序排列
 
    而且需要注意：类中的基本组成属性构造方法，普通方法，在编写的时候也要注意顺序
 
 实际上在进行JAVA 代码的编译的过程之中系统会自动加入一些代码
 如果发现你现在定义的类中没有 定义构造方法 那么系统会自动帮助用户提供一个无参的什么都做的构造方法
 这样就可以保证每一个类中都一定会有一个以上的构造方法

        构造方法的定义要求：
            要求方法名称与类名称相同，并且没有返回值类型声明
        范例：

class Student{
    public Student(){ // 方法名称与类名称相同，无返回值声明
        System.out.println("*************************");
    }
}
public class javaDemo{
    public static void main(Srting args[]){
        Student stu = null; // 声明对象 //没有调用构造方法
        stu = new Student(); // 实例化对象时调用构造方法
    }
}

        通过以上的代码执行可以发现，所有类中的构造方法都在使用关键字 new 实例化新对象的时候才会被使用到。一使用 new 就需要构造方法。
        但是在之前没有定义构造方法

        实际上在进行JAVA 代码的编译的过程中，系统会自动加入一些代码。所以这个时候如果发现你现在的类中并没有定义构造方法，那么系统会自动帮助用户提供一个无参的什么都不做的构造方法，类似如下：
　　public Student(){//方法名称与 类名称相同，无返回值声明
　　}

        这样就可以保证每一个类中都一定会至少存在一个构造方法。所有的类都肯定有构造方法，至少有一个。

        那么这个构造方法有什么用呢？
            构造方法是在使用关键字 new 实例化对象的时候才会被调用，那么实例化对象的时候实际上也就属于内存空间的开辟，也就属于属性的初始化过程，但是发现，默认情况下属性初始化后的内容都是其对应数据类型的默认值。所以如果现在希望可以在对象实例化时传递一些属性的内容，那么就可以依靠构造方法完成。

        一旦类中定义了有参构造方法，则默认的构造方法不会出现

        分析：如果按照传统的无参呢构造形式处理，则对象创建之后需要明确的调用 stter 设置属性内容

class Person { //现在定义一个类
    //定义类中的两个属性
    private String name; // 表示人的姓名
    private int age;  // 表示人的年龄
    public Preson(){
    }
    public void tell(){
        system.out.println("姓名：" + name +"年龄：" + age);
    }
    public void setName(String n){
        name = n;
    }
    public void getName(){
        return name;
    }
    public void setAge(int a){
        if(a >= 0&&a <= 100){
            age = a;
        }
    }
    public void getAge(){
        return age;
    }
}
public class T{// 另一个类
    public static void main (String args[]){
        Person per = new Person();
        per.setName("少爷");
        per.setAge(18);
        System.out.println(per.getInfo());
    }
}

　　分析：如果有构造方法呢

class Person { //现在定义一个类
    //定义类中的两个属性
    private String name; // 表示人的姓名
    private int age;  // 表示人的年龄
    public Preson(String n,int a){
        setName(n); // 调用本类普通方法
        setAge(a);
    }
    public void tell(){
        system.out.println("姓名：" + name +"年龄：" + age);
    }
    public void setName(String n){
        name = n;
    }
    public void getName(){
        return name;
    }
    public void setAge(int a){
        if(a >= 0&&a <= 100){
            age = a;
        }
    }
    public void getAge(){
        return age;
    }
}
public class T{// 另一个类
    public static void main (String args[]){
        Person per = new Person(“少爷”，18);
        System.out.println(per.getInfo());
    }
}

// 以上代码执行可以发现，所有类中的构造方法都在使用关键字 new 实例化对象时候才会被使用到
// 一使用 new  就需要构造方法

        所以现在可以发现构造方法最大的用处在于：对象实例化的同时可以为类中的操作进行初始化准备
        构造方法本身算是方法的定义范畴，所以来讲构造方法也是允许重载的，不过与普通方法的重载不同，构造方法在进行重载的时候只需要考虑参数的类型以及个数不同即可

class Person { //现在定义一个类
    //定义类中的两个属性
    private String name; // 表示人的姓名
    private int age;  // 表示人的年龄
    public Preson();   // 构造方法重载
    public Preson(String n ){ // 单参构造方法
        setName(n );
    }
    public Person(String n,int a){  //  定义有参构造
        setName(n);
        setAge(a);
    }
    public void tell(){
        system.out.println("姓名：" + name +"年龄：" + age);
    }
    public void setName(String n){
        name = n;
    }
    public void getName(){
        return name;
    }
    public void setAge(int a){
        if(a >= 0&&a <= 100){
            age = a;
        }
    }
    public void getAge(){
        return age;
    }
}
public class T{// 另一个类
    public static void main (String args[]){
        new Person("少爷",-3).tell();
    }
}

        对于构造方法的总结如下：
            每当使用关键字 new 开辟新对象时一定会调用构造方法，构造方法只会在对象实例化的时候调用唯一一次
            构造方法要求名称与类名称保持一致，并且无返回值定义 ，不能够使用 void（变为普通方法）
                所有的类都肯定有构造方法，至少有一个。
                如果发现你现在的类中并没有定义构造方法，那么系统会自动帮助用户提供一个无参的什么都不做的构造方法

/*

　　此时的程序在实例化 Person 类对象的时候会自动的将 name 与 age 属性传递到对应的属性之中， 这样的做得好处相当于省略了一系列的sett 方法的调用

    疑问 既然构造方法没有返回值为什么不使用void声明？
    　　构造方法是在实例化对象的时候只能调用一次，
    　　而所有的普通方法呢 可以利用对象调用多次
   　　 如果说构造当现在定义为  public void Person(){}   这就属于普通方法


/*  匿名对象
　　匿名就是没有名字，匿名对象指的是没有名字的对象，只使用一次的对象由于其没有任何栈内存的指向，所以一次之后将成为垃圾
　　对象的名字都保存在栈内存之中在整个对象操作之中，真正有用的不是栈内存，因为栈内存指向的是堆内存，真正用的是堆内存堆内存依靠 new 来开辟，·所以此时的代码可以直接用“new Person("少爷",-3)”来调用类中方法
例

public class T{// 另一个类
    public static void main(String args[]){
        new Person("少爷",-3).tell();
    }
}

       
    但是此时的对象由于没有名字，所以使用一次后会自动成为垃圾
*/
/*>>>>>
    1 开辟新的堆内存空间除去使用关键字new 之外还要调用构造方法
    2 只使用一次的对象可以使用匿名对象完成 匿名对象的本质就是只有堆内存空间没有栈引用的对象
*/