java转移 u0019_0019 Java学习笔记-面向对象-方法

方法属于谁

方法要么属于类，要么属于对象

static修饰的方法属于类

没有static修饰的方法属于对象

方法只能定义在类里面，不能独立定义

不能独立的执行方法，要么通过类调用，要么通过方法调用

一个类里，一个方法调用另一个方法，看似没有调用者，实际上对于非static方法使用this调用，static方法使用类名调用

注意：static方法也可以通过对象调用，这符合语法，但不推荐

方法的参数传递

Java里，参数的传递方式只有一种：值传递，就是将实际参数的副本传给方法，而参数本身不受影响

示例：对于基本类型的参数

public class SwapTest {

public static void main(String[] args) {

int a=3;

int b=7;

System.out.println("主方法里面，用swap(a,b)交换前：a="+a+" b="+b);

swap(a,b);

System.out.println("主方法里面，用swap(a,b)交换后：a="+a+" b="+b);

}

public static void swap(int a,int b){

System.out.println("swap(a,b)方法内部，交换前：a="+a+" b="+b);

int temp;

temp=a;

a=b;

b=temp;

System.out.println("swap(a,b)方法内部，交换后：a="+a+" b="+b);

}

}

上面代码中，用swap()方法并没能对main方法的a和b实现交换，因为在调用swap方法时，栈内存中又开了个swap栈区，里面有两个变量a和b，这个ab跟main方法的ab毫无关系，接下来传递参数的值，也就是将main的3传给swap的a变量，将7传给b变量，然后swap方法内部将二者进行了交换，但这丝毫不影响main方法里的ab。这里的swap就像人睡觉一样，你在梦里中了500万，但这丝毫改变不了你的现实。

再看下面的代码，引用类型的参数：

public class T1 {

public static void main(String[] args) {

DataWrap dw=new DataWrap();

dw.a=3;

dw.b=7;

System.out.println("main方法里，交换前，dw.a="+dw.a+" dw.b="+dw.b);

swap(dw);

System.out.println("main方法里，交换后，dw.a="+dw.a+" dw.b="+dw.b);

}

public static void swap(DataWrap dw){

System.out.println("swap方法里，交换前，dw.a="+dw.a+" dw.b="+dw.b);

int temp;

temp=dw.a;

dw.a=dw.b;

dw.b=temp;

System.out.println("swap方法里，交换后，dw.a="+dw.a+" dw.b="+dw.b);

}

}

class DataWrap{

int a;

int b;

}

对于引用类型的参数而言，依然是采用的值传递方式。但这里容易存在一个假象：调用swap()方法时，传进去的是dw这个对象本身，并没有复制一个dw。实际上传进去的是dw这个对象的引用的复制，而不是复制了一个dw对象，也就是说调用swap()方法后，内存中有两个引用指向dw对象，一个main方法的dw变量，另一个是swap方法的dw变量。

形参个数可变的方法

如果要传入某类型的参数个数不能确定，那可以用下面这种方式

methodName(int a,float b,String...strings);

规则：

个数可变的形参只能放在参数列表的最后

一个方法只能有一个个数可变的形参

调用这种方法时，可以传入一个对应类型的数组

参数数组

个数可变的形参实际上就是个数组，下面的定义与上面的相同

methodName(int a,float b,String[] strings);

方法的重载

方法名+形参列表构成了方法签名

Java里，即使方法名相同，只要形参列表不想同，就是不同的方法

同一个类中，方法名相同，形参列表不同，这就叫做方法的重载，overload

在调用方法的时候，JVM会根据方法名和传入的参数的类型自动匹配对应的方法

重载方法中包含个数可变的形参，看示例代码：

public class Test {

public static void main(String[] args) {

test("A"); //输出：有一个String参数

test("B","C"); //输出：有两个String参数

test("D","E","F"); //输出：有三个String参数

test("G","H","I","J","K"); //输出：有很多个String参数

String[] str={"A"};

test(str); //输出：有很多个String参数

}

public static void test(String str){

System.out.println("有一个String参数");

}

public static void test(String str1,String str2){

System.out.println("有两个String参数");

}

public static void test(String str1,String str2,String str3){

System.out.println("有三个String参数");

}

public static void test(String...strs){

System.out.println("有很多个String参数");

}

}

从上面的代码可以看出，总是先匹配精确的个数，匹配不到再匹配个数可变的；

如果传入的是数组，直接匹配个数可变的

一般不推荐用个数可变的形参，意义不大，可读性差

递归方法

简单的说，递归方法就是在方法里面调用自身，然后可能产生循环调用，最后在某种条件下退出

使用原则：

向已知的方向递归

要设置某种条件能让递归调用退出来，

看下面的示例代码

public class T1 {

public static void main(String[] args) {

System.out.println("0~-50的和= "+sum(-50));

}

public static int sum(int num){

if (num==0){

return 0;

}else if(num>0){

return num+sum(num-1);

}else{

return num+sum(num+1);

}

}

}