java 构造器学习笔记

构造器（构造器不是方法也不是类的成员）

以前创建对象的方式，

public class Constructor{

public static void main(String[] args){

person p = new Persen();

p.name = "李四“

p.age = 15

Person p2 = new Person();

p2 = "王五”;

p.age = 16；

public

class Persen{

String name;

int age;

}

}

1 每创建一个对象，都需要进行初始化。

2 创建于初始化是分离操作，这可能会导致创建对象后，忘记初始化。

构造器的声明

构造器名字与类名相同，并且没有返类型（没有返回类型与返回类型为void不同），访问权限与参数列表与普通方法相同，没有限制。

构造器会在new创建对象时执行（调用），每创建一个对象，构造器都会执行一次。

class Person{

String name;

int age;

publice Person()//构造器

{

System.out.println("我执行了");

}

}

通过含有参数的构造器可以实现更加灵活地实现初始化。

默认的构造器

如果我们现实的声明任何构造器。则编译器会自动的为我们生成一个构造器。默认的构造器访问权限与类的访问权限相同，参数列表为空。

如果我们显示声明了构造器，不管我们声明的构造器是什么样子，默认的构造器都将不复存在。

构造器重载

如果在一个类中声明了多个构造器，则多个构造器必定重载。

通过构造器重载，可以实现不同可以提供类的不同初始化方式。

与方法重载相同，构造重载时，应优先考虑使用一个构造器，调用另外一个构造器来实现，调用原则与方法重载的调用原则相同

public ConOverloard{

int x;

int y

public ConOverloard(int x, inty){

this.x = x;

this.y = y;

}

public ConOverload(){

this (0, 0);

}

public static void main (String[] args){

ConOverload c = new ConOverload();

ConOverload c2 = ner ConOverload(5, 3);

}

}

与方法重载相同

构造器调用的语法规则：

1 调用构造器不能通过构造器的名字来调用而是通过this来调用。（调用方式））

2 调用构造器必须在另一构造器之中通过this调用，不能再构造器至外地调用。（调用位置）

3 this 调用构造器必须是构造器的第一条语句。（调用语句）

关键词this使用

1 this用于任何实例方法内，指向当前对象

2 this 可以用来调用构造器

实例变量的初始化

1 在变量声明处初始化

2 使用初始化块（一对儿花括号“{}”是声明在类的内部不是方法中，有别于语句块。在创建对象时，初始化块会自动执行。

3 使用构造器

public class Init {

//变量声明出初始化
int x = 10;

//使用初始化块
{System.out.println("初始化块1");}

//使用构造器
public Init (){

System.out.println("构造器");}

{System.out.println ("初始化块2");}

public static void main(String[] args){
    new Init();

   }

}

输出为

初始化块1

初始化块2

构造器

因此初始化块在构造器之前执行

变量声明处初始化与初始化块根据在类中声明的顺序执行，谁先声明先执行谁。

可变参数方法

可变参数使用...表示。可以接受0至多个参数

可变参数类型底层是一个数组。

main方法的String[] args实际就是一个可变参数。因此，main方法也可以这样声明：

public static void main(String... args) {

}

可变参数类型必须作为参数列表的最后一个参数。这就意味着，一个方法至多只能有一个参数为可变参数类型。

以求和为例

public class VarParam{

//可以改为public static void main(String... args){

public stic void main(String[] args) {

VarParam v = new VarParam() ;

System.out.println(v.add(new int[]){2, 3});

}

//使用数组可行，能进行不定数值的求和，但是依然比较繁琐。

public int add (int[] x)

{ int sum = 0;

for (int i : x) {

sum += i;}

return sum;

}

}

}

应用可变参数求和

public class VarParam {
    public static void main(String... args) {
        VarParam  v = new VarParam();

System.out.println(v.add());
        System.out.println(v.add(1, 2, 3));
        System.out.println(v.add(1, 2, 3, 4, 5));
    }

public int add(int... x) {
        int sum = 0;
        //0个参数时System.out.println(x[0]);
        for (int i : x) {
            sum += i;
        }
        return sum;
    }
}

可变参数类型必须作为参数列表的最后一个参数，这意味着，一个参数列表中最多只能有一个可变参数。

可变参数参与重载

可变参数参与重载的时候可变参数的优先级低于非可变参数.这是因为可变参数是后来才加入java的，为了兼容以前的程序。

可变参数底层就是一个数组，因此相同类型的可变参数与数组不能构成重载。

public class VarOverloard {

public static void main(String[] args) {

VarOverloard v = new VarOverloard ();

v.f(10);

v.f(10, 9);

v.f(10, 9, 6);

}

public void f(int x){

      System.out.println("f(int x)");

}

public void f(int x, int y){

     System.out.println("f(intx, int y)");

}

//可变参数参与重载时不会影响，优先级低于费可变参数
public void f(int... x){

      System.out.println("f(int... x)");

}

//编译出现错误
/*public void f(int[]){
}

}

输出值为