1.3（java学习笔记）构造方法及重载

构造方法，用于对象的初始化，在创建对象时被自动调用的特殊方法。构造方法名称与类名一致，通过new调用。

下面通过代码来详细讲解

 public class Point {
     int x, y;
     public Point(int _x, int _y){
         x = _x;
         y = _y;
     }

     public double getDistance(Point p){
         return Math.sqrt(Math.pow((double)(p.x), 2) + Math.pow((double)(p.y), 2));
     }

     public static void main(String args[]){
         Point n = new Point(3, 4);
        System.out.println(n.getDistance(p));
     }
 }

首先构造方法与类名一致，主要用于对象初始化用new调用，构造方法会自动返回对象，故最后不能加return （对象）。

这里大家可能会有疑问

1.这个和之前创建好了一个类（public class point{....}），然后直接Point n = new Point(); 的区别，

2.构造方法和类名称相同创建类的时候到底是哪一个？

这里要补充一点

如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加。

下面代码来说明这个问题

 public class Point {
     int x, y;
     Public Point();                              //这时我们平常创建类及对象的形式，没有定义构造方法，编译器会自动定义一个无参的构造函数。
                                                   //这里面隐含了一个构造函数，是编译器自动添加的，只是不显示出来。
     public static void main(String args[]){
         Point p = new Point();

     }
 }

所以我们如果在里面我们自己在类里面添加了一个有参的构造方法，那么对象初始化时使用的就是那个有参的构造方法。

可能这里大家会问，那我初始化时用那种无参的方法初始化可不可以，答案是不行的，因为之前说了“如果我们没有定义构造器，则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加。”，我们在里面定义了一个有参的构造方法，所以编译器不会帮我们自动添加无参的构造方法。这时如果你想用无参的构造方法初始化则需要再定义一个无参的构造方法。

例如

 public class Point {
     int x, y;
     public Point(int _x, int _y){
         x = _x;
         y = _y;
     }
     public Point(){

     }

     public double getDistance(Point p){
         return Math.sqrt(Math.pow((double)(p.x), 2) + Math.pow((double)(p.y), 2));
     }

     public static void main(String args[]){
         Point p = new Point(3, 4);
         Point n = new Point();
         System.out.println(n.getDistance(p));
         System.out.println(p.getDistance(p));
     }
 }

这样就既可以创建有参也可以创建无参的，大家这里可能又会有疑问，这里面有两个构造方法名称都相同，初始化时到底是哪一个方法？

这里就涉及到另外一个概念“重载”，重载就是编译器会根据函数参数的个数，类型自动选择合适方法。

上图代码中的对象p的初始化方法中有两个参数，编译器会在两个Point方法中寻找合适的方法去执行，同样对n进行初始化的方法没有参数，编译器也会根据参数类型，个数去选择合适的方法。

java中函数的重载和这类似

构成重载的条件

方法名相同，参数个数不同，构成重载。
方法名相同，参数类型不同，构成重载。

方法名相同，参数类型相同，参数个数相同，返回值不同，不构成重载。

简而言之，就是编译器根据参数个数类型，寻找对应方法时应具有唯一性。