Java面向对象-方法

1.定义及简单使用

（1）无参的方法

public class Student {
	
	public void speak() {
		System.out.println("我是张三");
	}
	
	public static void main(String[] args) {
		Student zhangsan=new Student();
		zhangsan.speak();
	}
}

（2）有参的方法

public class Student {
	
	public void speak(String name) {
		System.out.println("我是"+name);
	}
	
	public static void main(String[] args) {
		Student zhangsan=new Student();
		zhangsan.speak("张三");
	}
}

还可以有多个参数，用逗号隔开

public class Student {
	
	public void speak(String name,int age) {
		System.out.println("我是"+name+",我今年"+age+"岁");
	}
	
	public static void main(String[] args) {
		Student zhangsan=new Student();
		zhangsan.speak("张三",18);
	}
}

参数还可以不固定个数

public class Student {
	//String...hobbies类似于一个String类型的hobbies数组
	public void speak(String name,int age,String...hobbies) {
		System.out.println("我是"+name+",我今年"+age+"岁");
		for (String hobby : hobbies) {
			System.out.print(hobby+" ");
		}
	}
	
	public static void main(String[] args) {
		Student zhangsan=new Student();
		zhangsan.speak("张三",18,"唱歌","跳舞");
	}
}

（3）有返回值的方法

public class Student {
	//String...hobbies类似于一个String类型的hobbies数组
	public int speak(String name,int age,String...hobbies) {//返回int类型
		System.out.println("我是"+name+",我今年"+age+"岁");
		for (String hobby : hobbies) {
			System.out.print(hobby+" ");
		}
		return hobbies.length;
	}
	
	public static void main(String[] args) {
		Student zhangsan=new Student();
		int b=zhangsan.speak("张三",18,"唱歌","跳舞");//接收爱好的个数
		System.out.println("共有"+b+"个爱好");
	}
}

2.方法的值传递和引用传递

（1）方法的值传递
值传递 在方法里改变变量的值 作用范围仅仅是方法里，对外面不影响

public class Student {

	public static void speak(int age) {
		System.out.println("我今年"+age+"岁");
		age=20;// 作用范围是方法里
	}
	public static void main(String[] args) {
		Student zhangsan=new Student();
		int age=23;
		zhangsan.speak(age);
		System.out.println(age);
	}
}

运行结果

（2）方法的引用传递
引用传递，传递的是地址，对象里的属性在方法里值修改，对外面有影响，我们通过对象.属性可以获取到最新的数据

class SanWei{
	int b; // 胸围
    int w; // 腰围
    int h; // 腿围
}
public class Student {

	 public void speak(int age,SanWei sanwei) {
		System.out.println("我今年"+age+"岁了，我的三围是："+sanwei.b+","+sanwei.w+","+sanwei.h);
		 sanwei.b=80; // 胸围改成80
	}
	public static void main(String[] args) {
		Student zhangsan=new Student();
		SanWei sanwei=new SanWei();
		int age=23;
		sanwei.b=90;
		sanwei.w=60;
		sanwei.h=90;
		// age传递的是值 ，sanWei是对象，传递的是引用(地址,c里叫指针)
		zhangsan.speak(age,sanwei);
		System.out.println(sanwei.b);
	}
}

运行结果

3.方法的重载
类里面有两个或者多个重名的方法，但是方法的参数个数、类型、顺序至少有一个不一样，这时候就构成方法重载

public class test1 {
	public static int add(int a,int b) {
		return a+b;
	}
	//参数个数引起的重载
	public static int add(int a,int b,int c) {
		return a+b+c;
	}
	//参数类型引起的重载
	public static double add(double a,int b) {
		return a+b;
	}
	//参数顺序引起的重载
	public static double add(int b,double a) {
		return a+b;
	}
	public static void main(String[] args) {
		System.out.println(add(1,2));
		System.out.println(add(1,2,3));
		System.out.println(add(1.0,2));
		System.out.println(add(1,2.0));
	}
}

注：如参数个数和类型一样，返回值不一样，不能算重载。

4.静态方法与普通方法
静态方法：static修饰的方法，使用时 一般用类名.方法调用，也可以用对象.方法 调用。
普通方法：无static修饰的方法，使用时用对象.方法 调用。

public class test2 {
	public void add() {
		System.out.println("普通方法");
	}
	public static void add1() {
		System.out.println("静态方法");
	}
	public static void main(String[] args) {
		test2 t=new test2();
		t.add();//普通方法只能对象名调用
		
		test2.add1();//类名调用静态方法
		t.add1();//对象名调用静态方法
	}
}

注：普通方法中可直接调用静态方法，静态方法中不可直接调用普通方法

5.递归
所谓递归，也就是方法自己调用自己

如下面求阶乘的代码

public class test3 {
	public static int digui(int n) {
		if(n==0||n==1) {//递归出口
			return 1;
		}else {//递归体
			return n*digui(n-1);
		}
	}
	public static void main(String[] args) {
		int a=digui(5);//求5的阶乘
		System.out.println(a);
	}
}

注：递归非常的耗时，不建议使用，一般用循坏代替。

上面求阶乘用循环实现如下

public class test4 {
	public static int xunhuan(int n) {
		int result=1;
		for (int i = 1; i <=n; i++) {
			result*=i;
		}
		return result;
	}
	public static void main(String[] args) {
		int a=xunhuan(5);
		System.out.println(a);
	}
}