Java语言基础(9)

1 方法（二）

　　1) 不带参数没有返回值的方法：
　　　　案例：Demo1

public class Demo1 {
  static void show(){
	System.out.println("努力学习");
	System.out.println("努力工作");
	System.out.println("努力赚钱！");
  }
  public static void main(String[] args) {
	System.out.println("调用show()方法之前");
    show();
    System.out.println("调用show()方法之后");
  }
}
 
import java.util.Scanner;
public class Demo2 {
//编写一个没有返回值没有参数的方法add(),在add()中
//创建一个Scanner对象，从控制台输入任意的两个整数，
//执行加法运算，并输出运算的结果。
//在main方法中，调用add()方法。
  static void add(){
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入第1个整数：");
	int num1 = sc.nextInt();
	System.out.println("请输入第2个整数：");
	int num2 = sc.nextInt();
	int sum = num1 + num2;
	System.out.println("sum="+sum);
  }
  public static void main(String[] args) {
	add();
  }
}
 
public class Demo3 {
//编写一个没有参数没有返回值的方法f1(),在f1()方法中
//分别求出100~1000之间所有奇数累加之和和所有的偶数
//的累加之和，并分别输出。
//在main方法中，调用f1()方法。
  static void f1(){
	int sum1=0,sum2=0;
//sum1保存奇数累加之和，sum2保存偶数累加之和。
	for(int i=100;i<=1000;i++){
	  if(i%2!=0){//奇数
		sum1 = sum1+i;
	  }else{//i%2==0  偶数
		sum2 = sum2+i;
	  }
	}
	System.out.println("奇数累加之和："+sum1);
	System.out.println("偶数累加之和："+sum2);
  }
  public static void main(String[] args) {
	f1();
  }
}
 
public class Demo4 {
//编写一个没有返回值没有参数的方法f1(),在f1()方法
//中，求出公元1~2016之间所有的闰年并输出
//在main方法中，调用f1()
  static void f1(){
	for(int i=1;i<=2016;i++){
	  if((i%4==0&&i%100!=0)||i%400==0){
		System.out.println(i+"是闰年");
	  }
	}
  }
  public static void main(String[] args) {
	f1();
  }
}
 
import java.util.Scanner;
public class Demo5 {
  static void showYear(){
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入年份：");
	int year = sc.nextInt();
	if(year>=1){
	  for(int i=1;i<=year;i++){
		if((i%4==0&&i%100!=0)||i%400==0){
		  System.out.println(i+"是闰年");
		}else{
		  System.out.println(i+"不是闰年");
		}
	  }
	}else{//year<1
	  System.out.println("输入错误");
	}
  }
  public static void main(String[] args) {
	showYear();
  }
}

　　2) return：终止方法继续往下执行；return后面跟方法的返回值。当方法调用结束以后，通过return，把结果返回到调用的位置。
　　3) 不带参数带返回值的方法：
　　　　eg：
　　　　　　static int add(){
　　　　　　　　int num1=100,num2=200;
　　　　　　　　int sum = num1+num2;
　　　　　　　　return sum;
　　　　　　}
　　　　　　main(){
　　　　　　　　int result = add();
　　　　　　　　System.out.println("result="+result);
　　　　　　}
　　4) 带返回值的方法中声明的返回值类型，跟return后面的返回值的类型一致。最好能定义一个变量来接收返回的结果。
　　　　案例：Demo6

public class Demo6 {
//return: 终止方法继续往下执行;return的后面跟方法
//最终返回的结果。
//带返回的方法要求声明的返回值类型跟return后面的返回
//值的类型一致。最好能定义一个变量来接收返回的结果。
  static int add(){
	int num1=100,num2=200;
	int sum = num1+num2;
	return sum;
  }
  public static void main(String[] args) {
	int result = add();
	System.out.println("result="+result);
  }
}
 
import java.util.Scanner;
public class Demo7 {
//编写一个没有参数带int类型返回值的方法sub()方法，
//在sub()方法中，创建一个Scanner对象，从控制台
//输入任意的两个整数，执行减法运算，并返回最终运算
//的结果，返回到调用的位置
//在main方法中，调用sub()方法，并输出返回的结果。
  static int sub(){
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入第1个整数：");
	int num1 = sc.nextInt();
	System.out.println("请输入第2个整数：");
	int num2 = sc.nextInt();
	int result = num1-num2;
	return result;
  }
  public static void main(String[] args) {
	int result = sub();
	System.out.println("result="+result);
  }
}
 
public class Demo8 {
//编写一个带int类型返回值没有参数的方法f1(),在f1()
//求出1~200之间所有的偶数累加之和并返回到调用的位置
//在main()方法中，调用f1(),并显示运算的结果。
  static int f1(){
	int sum = 0;
	for(int i=1;i<=200;i++){
	  if(i%2==0){
		sum = sum + i;
	  }
	}
	return sum;
  }
  public static void main(String[] args) {
	int result = f1();
	System.out.println(result);
  }
}
 
import java.util.Scanner;
public class Demo9 {
//编写一个没有参数带一个int类型返回值的方法max(),
//在max()方法中，从控制台输入任意的两个整数，求出
//较大的整数的值，并返回到调用的位置。
//在main方法中，调用max()方法，并输出返回的结果。
  static int max(){
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入第1个整数：");
	int num1 = sc.nextInt();
	System.out.println("请输入第2个整数：");
	int num2 = sc.nextInt();
//	方法3
	if(num1>=num2){
	  return num1;
	}else{//num1<num2
	  return num2;
	}
 
/*	方法2
	int max=0;
	if(num1>=num2){
	  max = num1;
	}else{//num1<num2
	  max = num2;
	}
	return max;
        方法1
	int max = num1>=num2 ? num1 : num2;
	return max;
	*/
  }
  public static void main(String[] args) {
	int result = max();
	System.out.println("较大的整数是"+result);
  }
}
 
import java.util.Scanner;
public class Demo10 {
  static int f1(){
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入一个整数：");
	int num = sc.nextInt();
	if(num>=1){
	  int sum = 0;
	  for(int i=1;i<=num;i=i+2){//奇数
		sum = sum + i;
	  }
	  return sum;
	}else{//num<1
	  System.out.println("输入错误");
	  return 0;
	}
  }
  public static void main(String[] args) {
	int result = f1();
	System.out.println(result);
  }
}

　　5) 方法中的参数：
　　　　a) 形参(形式参数)：当方法被调用的时候，系统会临时为形参开辟存储空间，用来接收外界传入的数据，参与方法的执行，当方法执行结束以后，释放形参的存储空间（形参不存在了）。
　　　　b) 实参：当方法被调用的时候，把实参的值传递到形参中。
　　　　　　static void add(int num1,int num2){//形参
　　　　　　　　int sum = num1 + num2;
　　　　　　　　System.out.println("sum = "+sum);
　　　　　　}
　　　　　　main(){
　　　　　　　　int a=100,b=200;
　　　　　　　　add(a,b);//实参
　　　　　　}
　　　　　　实参和形参是一一对应的，把实参的值传递到形参中。
　　　　　　案例：Demo11

public class Demo11 {
//形参（形式参数）：当方法被调用的时候，为形参临时的
//开辟存储空间，用来接收外界传入的数据，参与方法的
//执行，当方法执行结束以后，释放形参的存储空间。
//实参：当方法被调用的时候，把实参的值传递到形参中。
//实参和形参必须是一一对应的。
  static void add(int num1,int num2){//形参
	int sum = num1 + num2;
	System.out.println("sum = "+sum);
  }
  public static void main(String[] args) {
	int a = 300, b = 900;
	add(a,b);//实参
  }
}
 
import java.util.Scanner;
 
public class Demo12 {
//编写一个没有返回值带两个int类型参数的方法add(),
//void add(int num1,int num2):执行加法运算，
//并输入运算的结果
//在main方法中，创建一个Scanner对象，从控制台输入
//任意的两个整数作为实参，调用add()方法。
  static void add(int num1,int num2){//形参
	int sum = num1 + num2;
	System.out.println("sum = "+sum);
  }
  public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入第1个整数：");
	int num1 = sc.nextInt();
	System.out.println("请输入第2个整数：");
	int num2 = sc.nextInt();
	add(num1,num2);//实参
  }
}
 
import java.util.Scanner;
 
public class Demo13 {
  static void f1(int num1){
	if(num1>=1){
	  int sum1=0,sum2=0;//sum1保存奇数累加之和;sum2保存偶数累加之和。
	  for(int i=1;i<=num1;i++){
		if(i%2!=0){//奇数
		  sum1 = sum1 + i;
		}else{//偶数
		  sum2 = sum2 + i;
		}
	  }
	  System.out.println("奇数累加之和"+sum1);
	  System.out.println("偶数累加之和"+sum2);
	}else{//num1<1
	  System.out.println("输入错误");
	}
  }
  public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入一个整数:");
	int num = sc.nextInt();
	f1(num);
  }
}

　　6）Java中永远是值的传递，把实参中的值传递到形参中，对形参的任何修改对实参没有影响。
　　　　案例：Demo14

public class Demo14 {
  static void updateNum(int num){//形参
	num = 2000;
	System.out.println("形参num="+num);
  }
  public static void main(String[] args) {
	int num = 100;
	System.out.println("调用updateNum()" +
			"方法之前，实参num="+num);
	updateNum(num);//实参
	System.out.println("调用updateNum()" +
			"方法之后，实参num="+num);
//在Java中，永远是值的传递。当方法调用的时候，把实参
//的值传递到形参中，对形参任何修改，对实参没有影响。
//所以实参num在调用updateNum()方法之前是100，调用
//了updateNum(num)方法以后，实参num的值还是100。
//形参的修改对实参没有影响。
  }
}

　　7）带返回值带参数的方法
　　　　eg:
　　　　　　static int add(int num1,int num2){//形参
　　　　　　　　int sum = num1 + num2;
　　　　　　　　return sum;
　　　　　　}
　　　　　　main(){
　　　　　　　　int num1=100,num2=200;
　　　　　　　　int result = add(num1,num2);//实参
　　　　　　　　System.out.println("result="+result);
　　　　　　}
　　　　　　案例：Demo15

import java.util.Scanner;
public class Demo15 {
  static int add(int num1,int num2){
	int sum = num1 + num2;
	return sum;
  }
  public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入第1个整数：");
	int num1 = sc.nextInt();
	System.out.println("请输入第2个整数：");
	int num2 = sc.nextInt();
	int result = add(num1,num2);
	System.out.println("result="+result);
  }
}
 
import java.util.Scanner;
 
public class Demo16 {
//编写一个带int类型返回值带两个int类型参数的方法
//sub(),int sub(int a,int b),在sub方法中，
//执行减法运算，并返回运算的结果。
//在main方法中，从控制台输入任意的两个整数作为实参，
//调用sub()方法，并输出返回的结果。
  static int sub(int a,int b){
	int result = a-b;
	return result;
  }
  public static void main(String[] args) {
	Scanner sc = new Scanner(System.in);
	System.out.println("请输入第一个整数：");
	int a = sc.nextInt();
	System.out.println("请输入第二个整数：");
	int b = sc.nextInt();
	int result = sub(a,b);
	System.out.println("result="+result);
  }
}