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);
}
}
