构造方法

构造方法(构造器)

回顾对象的创建: 

Person p = new Person();

在右侧Person后面出现的小括号, 其实就是在调用构造方法 !


特点: 

    所有的Java类中都会至少存在一个构造方法 , 
    如果一个类中没有明确的编写构造方法,  则编译器会自动生成一个无参的构造方法, 方法中没有任何的代码 !

重点: 如果自行编写了任意一个构造器, 则编译器, 不会再帮我们生成无参的构造器!

定义的格式: 

与普通方法基本相同, 区别在于:  方法名称必须与类名相同, 没有返回值类型的声明 !

    public class Demo3{
        public static void main(String[] args){
            Person p = new Person();
            p = new Person();
            p = new Person();
            p = new Person();
        }
    }
    class Person{
        public Person(){
            System.out.println("对象创建时,此方法调用");
        }
    }


构造方法,  在创建对象时,自动调用 ! 

构造方法的作用是: 给对象初始化 !   

案例:

尝试使用特殊的构造方法, 去创建一个对象, 并给它的属性赋值

    public class Demo3{
        public static void main(String[] args){
            Person p = new Person("小明",18);
            p.say();
        }
    }
    class Person{
        String name;
        int age;
        public Person(String p_name,int p_age){
            name = p_name;
            age = p_age;
        }

        void say(){
            System.out.println("我是:"+name+",我今年"+age+"岁了");
        }
    }

构造方法的重载

一个类, 可以存在多个构造方法 : 

    参数列表的长度或类型不同即可完成构造方法的重载 ~ 

构造方法的重载 ,可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化! 


例如:  

    class Person{
        int age;
        int id;
        String name;
    }

我们可以提供:  仅对id进行初始化的构造器, 也可以提供仅对年龄进行初始化的构造器,

案例: 
    class Person{
        int age;
        int id;
        String name;
        //构造方法1 , 通过这个构造方法创建的对象, 需要传递一个年龄
        Person(int p_age){
            age = p_age;
        }
        //构造方法2. 通过这个构造方法,  可以创建出一个所有属性都传递的对象
        Person(int p_age,int p_id,String p_name){
            age = p_age;
            id = p_id;
            name = p_name;
        }
        /*构造方法3. 通过这个构造方法创建的对象,  需要传递一个编号(id)
        Person(int p_id){//错误的
            id = p_id;
        }*/

    }


在创建对象时, 我们只需要按照方法的参数列表传递不同的参数, 即可自动识别调用的构造方法: 


    例如使用上述的Person类: 

    当出现 new Person(整型值): 调用了一个int参数的构造器;

    当出现 new Person(整型值,整型值,字符串): 调用了: Person(int p_age,int p_id,String p_name)

构造方法的设计

建议自定义无参构造方法，不要对编译器形成依赖，避免错误发生。
当类中有非常量成员变量时，建议提供两个版本的构造方法，一个是无参构造方法，一个是全属性做参数的构造方法。
当类中所有成员变量都是常量或者没有成员变量时，建议不提供任何版本的构造。

方法的重载

方法的重载: 

        方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载 !  方法的重载与返回值无关!




正确案例: 


    void a(int a ,String b){
        return 1;
    }

    void a(double a, String b){

    }


规范: 

    -   方法的重载虽然与返回值类型无关, 但是建议统一返回值类型 !

    方法名  也属于 标识符 , 方法名最好能见名知意 ! 
    方法的重载中, 所有相同方法名的方法 , 那么它们应表达的 或者说 执行的 是大致相同的含义 !  那么它们的返回值也应设计的完全相同 




    int sum(int a ,int b){}

    void sum(int a,int b,int c)

变量的分类

1.  基本数据类型变量
2.  引用数据类型变量


1.  成员变量
2.  局部变量



成员变量 和 局部变量的名称可以重复 

在一个方法中使用变量 去运算时, 如果没有编写this关键字,  且局部变量名称与成员变量名称相同, 那么永远找的都是局部变量  (就近原则)



class Person{
//成员变量
    String name;

            //局部变量
    Person(String name){
        name = name;
    }

}

this关键字 (当前对象)

其实之前编写的代码, 自动的省略了一部分的内容: 

例如: 

class Person{
    String name;
    int age;
    Person(String p_name,int p_age){
        name = p_name;
        age = p_age;
    }
}

class Demo{
    public static void main(String[] args){
        Person p1 = new Person("小明",18);
        Person p2 = new Person("小帆",18);
    }
}



把省略了部分内容加上: 
class Person{
    String name;
    int age;
    Person(String p_name,int p_age){
        this.name = p_name;
        this.age = p_age;
    }
}



学习了this关键字后, 我们可以直接通过this这个引用, 找到当前的对象中的属性. 那么案例应这样去写: 


public class Demo8{
    public static void main(String[] args){
        Person p = new Person("小明",18);

    }
}

class Person{
    String name;
    int age;

    Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    void say(){
        System.out.println("我是"+this.name+",我今年"+this.age+"岁了~");
    }
}

构造方法之间的互相调用:

构造方法之间的调用 必须存在一个出口 !
对于this的调用, 必须放到构造器的第一句代码!

举例: 

class HaHaInt{
    int a;
    int b;
    int c;
    int d;
    int e;  
    HaHaInt(){

    }
    HaHaInt(int a ){
        this.a = a;
    }
    HaHaInt(int a,int b ){
        this.a = a;
        this.b = b;
    }
    HaHaInt(int a,int b ,int c){
        this.a = a;
        this.b = b;
        this.c = c;
    }
    HaHaInt(int a,int b ,int c,int d){
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
    }
    HaHaInt(int a,int b ,int c,int d,int e){
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
    }


}

---------------对比 --------------------------------------


class HaHaInt{
    int a;
    int b;
    int c;
    int d;
    int e;  
    HaHaInt(){
        this(0);
    }
    HaHaInt(int a ){
        this(a,0);
    }
    HaHaInt(int a,int b ){       //new HaHaInt(1,2);
        this(a,b,0);
    }
    HaHaInt(int a,int b ,int c){
        this(a,b,c,0);
    }
    HaHaInt(int a,int b ,int c,int d){
        this(a,b,c,d,0);
    }
    HaHaInt(int a,int b ,int c,int d,int e){
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
        this();

        //无论用户调用哪个构造方法,  那么这个方法一定会执行 !
        //  那么我们就可以在这里加入一些, 共性的代码!
    }

}


public class Demo7{
    public static void main(String[] args){
        Person p = new Person();
        p.say();
        p.say(1);
        p.say("...");
        p.say(2,"...");
    }
}

class Person{
    String name;
    int age;
    void say(){
        System.out.println("哈哈哈");
    }

    void say(int a){
        System.out.println("嘿嘿嘿"+a);
    }

    void say(String text){
        System.out.println("呵呵呵"+text);
    }

    void say(int a,String text){
        System.out.println("6666666"+a+text);
    }
}

常量

int a = 10;

final(最终的) 修饰符

经过final修饰的变量 ,就成了常量!  

常量的特点就是 值无法改变 !

经过final修饰的变量 只能 赋值一次 !


例如: 

    final int a = 0;

    a = 1;


    0--------------------


    final int a ;

    a = 10;

引用数据类型的默认值为null

引用数据类型,  尚未赋值时,  不可调用其方法与属性: 

    例如 : 


    Person p = null;

    p.say();


    出现了错误: NullPointerException


    例如: 

    Person p = new Person();

    p = null;

    p.say();

    出现了错误: NullPointerException