java 方法体 out 参数_JAVA方法

一、何谓方法

1. 定义

System.out.println() //这是什么？

//System 系统的类

//out 对象-输出对象

//println 方法

Java方法是语句的集合、在一起执行一个功能

解决一类问题的步骤的有序组合

包含于类或对象中

在程序中被创建，在其他地方被引用

设计方法的原则

方法本意为功能块

即实现某个功能的语句块的集合

最好保持方法的原子性

即一个方法只完成一个功能，有利于后期的拓展

命名规则

首字母小写+驼峰原则

例1

public class Demo01 {

//main方法

public static void main(String[] args) {

int sum = add(1,2);

System.out.println(sum);

}

//加法

public static int add(int a, int b){ //public为修饰符 int返回值类型 static类变量

return a+b;

}

}

debug调试

设置断点，sum没有值

获取了a、b的值

返回给sum

输出sum值

例2

public class Demo01 {

//main方法

public static void main(String[] args) {

test();

}

public static void test() { //void 没有返回值

for (int i = 1; i <= 1000; i++) {

if (i % 5 == 0) {

System.out.print(i + "\t");

}

if (i % 15 == 0) {

System.out.println();

}

}

}

}

二、方法的定义及调用

1. 定义方法的语法

包含一个方法头和一个方法体

//修饰符 返回类型 方法名(参数类型 参数名){

...

方法体

...

return 返回值

}

public void main testDemo01(int a){

sum = a++;

return sum //有返回值一定要有return

}

1.1 修饰符

告诉编译器如何调用该方法，定义了该方法的访问类型

修饰符不是必须有的

1.2 返回值类型

returnValueType是方法的返回值的数据类型

有些方法执行所需操作，没有返回值，这种情况returnValueType是关键词void

1.3 方法名

是方法的实际名称

方法名与参数表共同构成方法签名

1.4 参数类型

形参

在方法被调用时，用于接收外界输入的数据

实参

方法被调用时，传递值给参数

public void main testDemo01(int aaaa){ //int aaaa 形式参数，不影响最终结果

sum = aaaa++;

return sum //sum 实际参数，传递值

}

1.5 方法体

包含的具体语句，即该方法的功能实现

2. 方法的调用

2.1有返回值

方法调用通常被当作一个值

int larger = max(30,40);

2.2 无返回值

调用的一定是一条语句

System.out.println("Hello,World!");

2.3 值传递和引用传递

三、方法重载

在一个类中，有相同的函数名称，但形参不同的函数

1.1 引例

public class Demo02 {

public static void main(String[] args) {

double max = max(10.1,11.1);

System.out.println(max);

}

//整数比大小

public static int max(int num1,int num2){

int result = 0;

if (num1==num2){

System.out.println("num1=num2");

return 0;//终止方法

}

if (num1>num2){

result = num1;

}else {

result = num2;

}

return result;

}

//小数比大小

public static double max(double num1,double num2){

double result = 0;

if (num1==num2){

System.out.println("num1=num2");

return 0;//终止方法

}

if (num1>num2){

result = num1;

}else {

result = num2;

}

return result;

}

}

1.2 重载的规则

方法名必须相同

参数列表必须不同(个数，类型，参数排列顺序)

方法返回类型可以相同也可以不同

仅仅返回类型不同不足以构成方法的重载

四、命令行运行

有时候你希望运行一个程序时候再传递给它消息，这要靠传递命令行参数给main()函数实现

1. 例子

package com.shelton.method;

public class Demo03 {

public static void main(String[] args) {

//args.length 数组长度

for (int i = 0; i < args.length; i++) {

System.out.println("args[" + i + "]: "+args[i]);

}

}

}

在命令行中用javac编译

class文件要找到包的路径才可以运行，不能直接运行

package com.shelton.method

五、可变参数

public class Demo04 {

//main方法

public static void main(String[] args) {

}

//method方法，由于参数类型不同不需要很多个method方法重载

public void method(){}

public void method(int i){}

public void method(int i1,int i2){}

public void method(int i,double i2){}

}

JDK1.5开始，java支持传递同类型的可变参数给一个方法

在方法声明中，在指定参数类型后加一个省略号

一个方法只能由一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

package com.shelton.method;

public class Demo04 {

public static void main(String[] args) {

Demo04 demo04 = new Demo04();

demo04.test(9,1,2,3,4);

}

public void test(int x,int ...i){//在指定参数类型后加一个省略号,一个方法只能由一个可变参数，它必须是方法的最后一个参数

System.out.println(i[0]);

}

}

/*

1

*/

1. 例子

package com.shelton.method;

public class Demo05 {

public static void main(String[] args) {

//调用可变参数的方法

printMax(34,3,3,2,56,6);

printMax(new double[]{6,8,9});

}

public static void printMax(double...numbers) {

if (numbers.length ==0) {

System.out.println("No argument passed");

return;

}

double result = numbers[0];

//排序

for (int i = 1; i < numbers.length; i++) {

if (numbers[i] > result) {

result = numbers[i];

}

}

System.out.println("The max value is "+ result);

}

}

/*

The max value is 56.0

The max value is 9.0

*/

六、递归※

A方法调用A方法——即自己调用自己

package com.shelton.method;

public class Demo06 {

public static void main(String[] args) {

Demo06 A = new Demo06();//类型 变量名 = 变量值

A.test();//变量A中的test方法调用

}

public void test(){

test();

}

}

/*

Exception in thread "main" java.lang.StackOverflowError

*/

利用递归可以用简单的程序来解决一些复杂的问题，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量，递归能力在于用有限的语句来定义对象的无限集合

1. 递归结构

递归头

什么时候不调用自身方法，如果没有头，将陷入死循环。

递归体

什么时候需要调用自身方法

2. 例子

package com.shelton.method;

public class Demo07 {

//求5! 5*4*3*2*1

public static void main(String[] args) {

System.out.println(f(5));

}

//n=1 f(1)=1

//n=2 2*f(1)

//n=3 3*f(2)*f(1)

public static int f(int n) {

if (n==1){

return 1;//返回结果

}else {

return n*f((n-1));//返回方法

}

}

}

/*

120

*/

两个阶段

前阶段

返回阶段 n*(n-1)

java使用栈机制，每调用一个方法压一层栈，main方法执行完栈就空了

嵌套层次过多会导致栈空间压满

能不用递归就不用递归

递归可以很轻易地实现计算公式

小计算可以用递归

大计算用其他算法，用递归会影响机器性能

3. 作业

写一个计算器，要求实现加减乘除功能，并且能够循环接受新的数据，通过用户交互实现

思路推荐

写四个方法：加减乘除

利用循环+switch进行用户交互

传递需要操作的两个数

输出结果

package com.shelton.method;

import java.util.Scanner;

public class Demo08 {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int key = 0;

while (key==0){

calc();

System.out.println("是否要进行新的运算？(Y/N)");

String str = scanner.next();

if (str.equals("Y")||str.equals("y")){//不能使用if(str=="Y")，因为在java中字符串的值是不可改变的，相同的字符串在内存中只会存一份，所以a和b指向的是同一个对象

key = 0;

}else if (str.equals("N")||str.equals("n")) {

key = 1;

}else {

illegalInput();

}

}

scanner.close();

}

//运算输入与操作

public static void calc(){

Scanner scanner1 = new Scanner(System.in);// 不能scanner1.close();

double num1 = 0;

double num2 = 0;

double result = 0;

System.out.println("请输入两个数字");

if (scanner1.hasNextDouble()){

num1 = scanner1.nextDouble();

}else {

illegalInput();

}

if (scanner1.hasNextDouble()){

num2 = scanner1.nextDouble();

}else {

illegalInput();

}

System.out.println("请输入运算方式+ - * /");

String calcWay = scanner1.next();

switch (calcWay){

case "+":

result = add(num1,num2);

break;

case "-":

result = minus(num1,num2);

break;

case "*":

result = mul(num1,num2);

break;

case "/":

result = division(num1,num2);

break;

default:

illegalInput();

}

System.out.println("运算结果为"+result);

}

//加法

public static double add(double a,double b){

double result = a + b;

return result;

}

//减法

public static double minus(double a,double b){

double result = a - b;

return result;

}

//乘法

public static double mul(double a,double b){

double result = a * b;

return result;

}

//除法

public static double division(double a,double b){

double result = a / b;

return result;

}

//非法输入

public static void illegalInput(){

System.out.println("非法输入");

System.exit(0);

}

}

/*

请输入两个数字

3

w

非法输入

*/

/*

请输入两个数字

3

5

请输入运算方式+ - * /

*

运算结果为15.0

是否要进行新的运算？(Y/N)

Y

请输入两个数字

6

5

请输入运算方式+ - * /

-

运算结果为1.0

是否要进行新的运算？(Y/N)

n

*/