构造器（构造器不是方法也不是类的成员）
以前创建对象的方式，
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[]){
}
}
输出值为
来源：https://www.cnblogs.com/kinoliu/p/6423406.html