第五章：方法的定义和调用

第五章：方法的定义和调用

• 方法的概念：方法是完成某个功能的一组语句，通常将常用的功能写成一个方法

• 注意：方法定义在类中

• 方法的作用：

  • 完成功能
  • 可以实现代码的重用。简化了程序的编写和维护工作。

• 方法的分类：

/**
 * 方法的分类：
 * 		无参无返回值
 * 		无参有返回值
 * 		有参无返回值
 * 		有参有返回值
 * @author Administrator
 *[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…){
    方法体
}

 */
public class Teacher {
//	 * 		无参无返回值
	/**
	 * void：该方法没有返回值
	 * public：访问修饰符
	 * getName:方法名
	 * 
	 */
	public void getName() {
		System.out.println("我是无参无返回值方法");
	}
	
//	 * 		无参有返回值
	/**
	 * int:标注着这个方法的返回值类型
	 * return：
	 * 		①return语句,表示一个方法的结束
	 * 		②如果一个方法有返回值必须有return
	 * 		③一个方法如果有返回值必须执行return语句而且return语句只会执行一次
	 * 		④return语句之后的代码会编译报错
	 * 0：返回值：返回值的数据类型必须和方法的返回值类型一致,返回值可以是变量也可以是常量
	 * 
	 * @return
	 */
	public int getAge() {
		System.out.println("无参有返回值");
		int age=10;
		return age;
//		System.out.println("hhaah");
	}
	
	public String[] getStrings() {
		String[] ss= new String[8];
		int age=20;
		if(10<age) {
			return ss;
		}else {
			return ss;
		}
//		return ss; not
	}
	
//	 * 		有参无返回值
	/**
	 * int ：参数类型,标注着调用该方法时传入的值的数据类型，可以是基本数据类型也可以是引用数据类型
	 * age：形式参数，一个变量
	 * 注意：当有参的方法被调用时，有多少个参数就要传多少个参数，数据类型必须匹配
	 *  	变量必须初始化之后才能使用
	 * @param age
	 */
	public void getAddress(int age) {
		System.out.println("有参无返回值"+age);
	}
	
	public void getSex(int age,String name) {
		System.out.println("有参无返回值"+age);
	}
	
//	 * 		有参有返回值
	public String getPhone(int phone) {
		System.out.println("有参无返回值");
		return "我爱你中国";
	}
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub

	}

• 方法的定义：方法声明或称为定义方法

[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…){
方法体
}

• 方法的调用

  • 方法必须被调用之后才起作用，某个方法如果没有被调用那么就不会执行其方法体中的代码

  /**
   * 方法的结束：
   * 		①遇到return语句
   * 		②方法体中的代码执行完毕
   * 成员方法可以直接调用成员方法
   * 
   * @author Administrator
   *  */
  public class Teacher {
  	//无参无返回值
  	public void getName() {
  		System.out.println("无参无返回值");
  		getAddress();
  	}
  	//无参有返回值
  	public String getAddress() {
  		getAge(10);
  		System.out.println("无参有返回值");
  		return "广州";
  		
  	}
  	//有参无返回值
  	public void getAge(int id) {
  		System.out.println("有参无返回值"+id);
  	}
  	public void getAge1(int id,String name) {
  		System.out.println("有参无返回值"+name);
  	}
  	//有参有返回值
  	public int getSex(int[] Y) {
  		System.out.println("有参有返回值");
  		return 0;
  		
  	}
  	public static void main(String[] args) {
  		Teacher t=new Teacher();
  		t.getName();
  	}
  	
  	/*public static void main(String[] args) {
  		Teacher t=new Teacher();
  		//通过"."运算符调用方法：引用.方法名
  		
  		 * 调用无参无返回值的方法
  		 
  		t.getName();
  //		System.out.println(t.getName()); not
  		System.out.println("哈哈");
  		
  		
  		 *调用无参有返回值:
  		 * ①有返回值的方法被调用后可以用相对应和方法返回值类型相同的变量去接收
  		 * ②什么情况下方法需要声明成有返回值的方法：调用者需要获得该方法的返回值并需对其返回值进行下一步操作时
  		 
  		String s=t.getAddress();
  		System.out.println(s);
  		System.out.println(t.getAddress());
  		
  		 *调用有参无返回值的方法 ：
  		 *	getAge(int id)
  		 *	① int id 是形参,1和age 是实际参数，实参可以是常量也可以是变量
  		 *	②实参的数据类型必须和方法中的参数类型一致,数量也要一致
  		 *
  		 
  		t.getAge(1);
  		int age=20;
  		t.getAge(age);
  		t.getAge1(1, "ZHANGSAN");
  		
  		
  //		int i=0;
  //		while(i<100) {
  //			System.out.println(i);
  //			i++;
  //			System.out.println("hahaha");
  //		}
  
  	}
  */
  

• 方法调用小案例

public class Ferrari {
	public  int youliang(int you) {
		return you;
	}
	
	public boolean engine(String key) {
		boolean flag=false;//一开始不能启动
//		判断字符串内容是否相等，使用equals方法
		if(key.equals("有")) {
			flag=true;
		}
		return flag;
		
	}
	
	public void start(int youliang,String key) {
		int you=youliang(youliang);
		boolean temp=engine(key);
		//如果有钥匙，还要油量达标(5L<油量)，发动机才能启动，发动机启动之后法拉利才能跑起来
		if(5<you && temp) {
			System.out.println("法拉利跑起来了");
		}else {
			System.out.println("法拉利跑不起来");
		}
	}

	public static void main(String[] args) {
//		如果有钥匙，还要油量达标(5L<油量)，发动机才能启动，发动机启动之后法拉利才能跑起来
		Ferrari f=new Ferrari();
		f.start(6,"有");
		

	}

• java中值传递
  

/**
 * java中只有值传递
 * 参数的传递：
 * 		基本数据类型：传的是内容
 * 		引用数据类型：传的是地址
 * 
 * 
 * @author Administrator
 *
 */
public class _java中的值传递 {
	public static void getX(int x) {
		x=x+10;
		
	}
	public static void getY(int[] y) {
		y[0]=y[0]+10;
//		System.out.println(y);//[I@7852e922
	}
	
	
	public static void main(String[] args) {
		int x=10;
		int[] y= {10};
		System.out.println("调用方法前x"+x);//调用方法前10
		getX(x);
		System.out.println("调用方法后x"+x);//调用方法后10
//		System.out.println(y);//[I@7852e922
		
		System.out.println("调用方法后y"+y[0]);//调用方法前10
		getY(y);
		System.out.println("调用方法后y"+y[0]);//调用方法后20


		
	}

• 方法的递归

/**
 * 方法的递归：一个方法体内调用它自身，这样的方法我们称之为方法递归。
 * 方法的循环调用
 * @author Administrator
 * 计算：n(n-1)(n-1)....
 * 
 * 优点：解决循环操作的问题
 * 缺点：运行速度慢，内存占用大
 */

public class _方法的递归 {
	public static int getResult(int i) {
		//递归结束条件
		if(i==1) {
			return 1;
		}
		return i*getResult(i-1); //5*4*3*2*getResult(1)
		
	}
	
	public static void main(String[] args) {
//		计算阶乘：
		Scanner sc=new Scanner(System.in);
		int a=sc.nextInt();
		int message=getResult(a);//5的阶乘   5*4*3*2*1
		System.out.println(message);
		
	}

• 方法的重载

/**
 * 方法的重载：同一个方法名在同一个类中出行多次
 * 		前提：必须在同一个类中
 * 
 * 规则：一同一不同
 * 		①方法名相同，参数列表不同(参数个数不同或者参数类型不同)
 * 		②返回值可以同可以不同
 * 
 * 
 * @author Administrator
 *
 */
public class Teacher {
	public void getName() {
		System.out.println("getName()");
	}
	//参数个数不同
	public void getName(int i) {
		System.out.println("getName()--重载的方法1"+i);
	}
//	public void getName(int x) {
//		System.out.println("getName()--重载的方法1"+i);
//	}
	//参数类型不同
	public void getName(String name) {
		System.out.println("getName()--重载的方法2"+name);
	}
	public void getName(String name,int age) {
		System.out.println("getName()--重载的方法2"+name+":"+age);
	}
//	返回值可以同可以不同
//	public int getName(String name,int age) {
//		System.out.println("getName()--重载的方法2"+name+":"+age);
//		return 1;
//	}
	
	public int getName(double d) {
		return 0;
	}
	public static void main(String[] args) {
		Teacher t=new Teacher();
		t.getName("zhangsan");
	}