java方法总结（重载，构造方法，调用方法）
java方法
目录
方法的定义
方法的格式
调用方法的方式
返回值问题
重载的定义与格式
重载中的方法调用
构造方法
方法的定义
在java中称为‘方法’，在C中称为‘函数’
java方法是语句的集合
用于执行一个功能
包含于类和对象中
可以被引用
方法的格式
1.参数列表为静态参数（就是参数列表里有两个参数变量，调用时也要传两个值，一一对应的关系，你两个我也要两个，你几个我几个，要不然不行）
作者：xuebanub1
访问权限 [修饰符] 返回值类型 方法名(参数列表){
...
方法体
...
}
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。例如:private（私有）、default（默认）、public（公共）、 protected（被保护）
public和private控制方法能否在其他类中使用。
返回值类型 ：定义了方法返回值的数据类型，如果方法没有返回值，则为void。
方法名： 是方法的实际名称。方法名和参数表共同构成方法签名。
参数列表：方法的参数类型、顺序和参数的个数，多个参数之间用逗号隔开，参数类型定义了参数的数据类型。此方法被调用时，传递值给参数。（可有可无）
方法体：包含具体的语句，定义方法的功能。
public class Test {
public static void print() {
System.out.println("1111111111");
}//这就是个方法，名为：print
public static void main(String[] args) {
Test test=new Test();创建一个test变量
test.print();//对象test调用了方法print
Test.print();//变量test调用了方法print（推荐）
}
}
结果
1111111111
调用方法的方式
有两种情况
一、有无static修饰时的调用方式
如果方法有static修饰时（如上边的print方法），可以用“存储对象的变量名.方法名”或者“类名.方法名”（如上边的两种方式：test.print();和Test.print();）但是有static时推荐用“类名.方法名” 如果方法没有static修饰时，只能使用“存储对象的变量名.方法名”的方式修饰（如下边的这种情况）public class Test {
public void print() {
System.out.println("1111111111");
}
public static void main(String[] args) {
Test test=new Test();
test.print();
}
}
二、有无参数列表时的调用方式
上边就是没有参数列表时的调用方式，不用写参数 下边是有参数列表的调用方式（也分两种哦）1.参数列表为静态参数（就是参数列表里有两个参数变量，调用时也要传两个值，一一对应的关系，你两个我也要两个，你几个我几个，要不然不行）
public class Test {
public void print(int a,int b) {
System.out.println(a);
System.out.println(b);
}
public static void main(String[] args) {
Test test=new Test();
test.print(111,222);
}
}
结果
111
222
2. 参数列表为动态参数
动态参数的实质是数组 格式是：数据类型…参数名 参数名就是数组名 调用方法时传过来的参数就是数组的元素，就像下边的111和222都是数组a的元素 为什么叫动态参数呢，它和静态参数有什么不同呢？ 静态参数是一对一的关系，而动态参数是一对多的关系，一个数组对传过来的多个传值，所以传值可以无限个 一个方法中只能定义一个动态参数，动态参数只能定义在参数列表最后public class Test {
public void print(int ... a) {
System.out.println(a.length);
System.out.println(a[0]);
}
public static void main(String[] args) {
Test test=new Test();
test.print(111,222);
}
}
结果
2
111
常见错误
...
public void print(int ... a,int b){
...
}
...
test.print(111,222);
...
//我把上边的代码缩写了，只写了改动的部分，看起来不是很影响胃口。
如果这样写是错的，因为这个111和222都变成数组a的元素了，int b就没意义了，所以要是有多个参数类型，动态参数要写到最后，且一个方法里只能有一个动态参数。
返回值问题 上边讲的一直都是方法中没有返回值的情况，即void类型，接下来我讲讲有返回值的类型返回值类型的范围要>=返回值的类型的范围（是不是有点绕口，什么意思呢，往下看）
... | ...
public int print(int ... a){ | public long print(int ... a){
int b=12; | int b=12;
return b; | return b;
} | }
... | ...
//还是上边的代码，我又一次简化了，使问题突出化
分析
左右两种都可以，返回值b的类型是int型，方法定义的返回值类型是int（左边）和long（右边），int（左边）=int；long（右边）>int；所以都可以。如果返回值类型是引用型（如String类型）,则方法返回值类型要么与数据类型（如下边b的数据类型）相同，要么是数据类型的父类（object是所有类的父类）
object的直接子类有哪些:https://my.oschina.net/8824/blog/3001450
... | ...
public String print(int ... a){ | public object print(int ... a){
String b="LOL"; | String b="LOL";
return b; | return b;
} | }
... | ...
解析
左右都可以哦，其实和上边的那个>=相似 重载的定义与格式 定义：重复负载 方法名相同 参数列表不同（个数不同或者参数类型不同 但不考虑参数名）public class Test { | public class Test {
|
public int add(int a,int b){ | public int add(int a,int b){
return a+b; | return a+b;
} | }
public int add(int a,int b,int c){ | public double add(double a,double b){
return a+b+c; | return a+b+c;
} | }
} | }
解释
左右都是可以的，左边个数不同，右边参数类型不同
public class Test {
public int add(int a,int b){
return a+b;
}
public int add(int c,int d){
return c+d;
}
}
解释
这个就不行了，参数名不同是不影响的，这两个方法一样。
public class Test {
public int add(int a,int b){ //这是方法1
return a+b;
}
public int add(int a,int b,int c){ //这是方法2
return a+b+c;
}
public double add(double a,double b){ //这是方法3
return a+b;
}
public static void main(String[] args) {
Test test=new Test();
int result_1=test.add(1,2); //参数是两个int类型，调用方法1
System.out.println(result_1);
double result_2=test.add(1.0,2.0); //参数是两个double类型，调用方法2
System.out.println(result_2);
int result_3=test.add(1,2,3); //参数是三个int类型，调用方法3
System.out.println(result_3);
}
}
构造方法
格式：类名（参数列表）{ … }
位置：直接定义在类里边
调用方式：与普通方法的调用方式相同（就是和上边的一样）
特点
构造方法没有返回值部分，void不能有
特点：一个类中默认无参构造函数，当定义了一个有参数构造方法时，则默认无参构造方法隐藏。
构造方法不允许final和static修饰
一个类中可以定义多个构造方法，这是“重载”的体现
类中构造方法可以相互调用，通过 this（实参列表） 实现，但必须置于构造方法有效代码第一行
this在构造方法的方法体中只能出现一次！
public class Test {
Test(String a,int b,String c){
...
}//这个就是构造方法（构造函数）
public static void main(String[] args) {
...
}
}
解释
这个就是构造方法的格式和位置
...
Test(String a,int b,String c){
name=a;
age=b;
address=c;
}
...
...
Test(String a,int b,String c){
this(a,b);//必须置于构造方法有效代码第一行
address=c;
}
Test(String a,int b){
name=a;
age=b;
}
...
解释
上下两个是一样，这是多的参数个数调用少的，其实少的还可以调用多的（往下看）
Test(String a,int b,String c){
name=a;
age=b;
address=c;
}
Test(String a,int b){
this(a,b,null);//多出来数据赋个多出来的数据的数据类型的默认值，即多出来的String赋个null
}
解释
这个就是少参数的构造函数调用多参数的构造函数,多出来赋个
作者：xuebanub1
