目录
1. 什么是方法?
System.out.println()
-
调用系统类里的标准输出对象out中的方法println
-
类.对象.方法
Java方法是语句的集合,他们在一起执行一个功能
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建,在其他地方被引用
设计方法的原则:
方法的本意是功能块,就是实现某个功能的语句块集合。我们设计方法的时候,最好保持方法的原子性, 就是一个方法只完成一个功能,这样利于我们后期的拓展。
修饰符 返回值类型 方法名(参数类型1 参数名1,参数类型2 参数名2,...){
...
方法体
...
return 返回值;
}
public class Demo01 {
//mian()方法
public static void main(String[] args) {
int sum=add(6,9);
System.out.println(sum);
}
//加法
public static int add(int a,int b){
return a+b;
}
}
2. 方法的定义及调用
-
调用方法:对象名.方法名(实参列表)
-
Java支持两种调用方法的方式,根据方法是否返回值来选择。
-
当方法返回一个值的时候,方法调用通常被当作一个值。例如:
int larger=max(30,40);
-
如果方法返回值是void,方法调用一定是一条语句。
System.out.println("Hello!");
//两数比较大小
public class Demo02 {
public static void main(String[] args) {
int big=max(4,4);
System.out.println(big);
}
public static int max(int a,int b){
int big;
if(a>b){
big=a;
}else if(a==b){
System.out.println("a=b");
return 0;//终止方法
}else{
big=b;
}
return big;//返回值语句放在最后
}
}
- 值传递(Java)和引用传递?
3. 方法重载
- 方法名称必须相同
- 参数列表必须不同(个数,类型,排列顺序)
- 方法的返回值类型可以相同也可以不同
- 仅仅返回值类型不同不足以称为方法的重载
- 方法都在同一个类里
public class Demo01 {
//mian()方法
public static void main(String[] args) {
double sum=add(6.3,9.1);
System.out.println(sum);
}
//加法
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,double b){
return a+b;
}
public static double add(int a,double b){
return a+b;
}
}
- 实现理论:
- 方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错。
4. 命令行传参
C:\Java\idea\code\JavaSE\基础语法\src\method>javac Demo03.java
C:\Java\idea\code\JavaSE\基础语法\src\method>java Demo03
错误: 找不到或无法加载主类 Demo03
原因: java.lang.NoClassDefFoundError: method/Demo03 (wrong name: Demo03)
C:\Java\idea\code\JavaSE\基础语法\src\method>cd ../
C:\Java\idea\code\JavaSE\基础语法\src>cd ../
C:\Java\idea\code\JavaSE\基础语法>cd src
C:\Java\idea\code\JavaSE\基础语法\src>java method.Demo03
C:\Java\idea\code\JavaSE\基础语法\src>java method.Demo03 this is tony
args[0]this
args[1]is
args[2]tony
5. 可变(长)参数 /不定项参数
- JDK1.5开始,Java支持传递同类型的可变参数给一个方法。
- 在方法声明中,在指定参数类型后加一个省略号(…)。
package method;
public class Demo04 {
public static void main(String[] args) {
Demo04 demo04=new Demo04();
demo04.method(12,9,5,4,1,0,36,9,97);
}
public void method(int ... i){//可变长参数
for (int j = 0; j <i.length; j++) {
System.out.print(i[j]+" ");
}
}
}
输出:
- 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数都必须在它之前声明。
package method;
public class Demo04 {
public static void main(String[] args) {
Demo04 demo04=new Demo04();
demo04.method(6.9,9,5,4,1,0,36,9,97);//自动默认第一个是double
}
public void method(double a,int ... i){//可变长参数
···
···
}
}
找出这一堆参数中的最大值
public class Demo04 {
public static void main(String[] args) {
Demo04 demo04=new Demo04();
demo04.methodMax(9,5,4,1,0,36,9,97);
}
public void methodMax(int ... i){//可变长参数
if (i.length==0){
System.out.println("error");
}else{
int max=i[0];
for (int j = 0; j <i.length; j++) {
if (i[j]>max) {
max = i[j];
}
}
System.out.print(max);
}
}
}
6. 递归(自己调用自己)
能不用就不用!多数据会卡死!
递归结构包括两个部分:
- 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。
- 递归体:什么时候需要调用自身方法。
//递归求阶乘
public class Demo05 {
public static void main(String[] args) {
System.out.println(f(5));//5!
}
public static int f(int n){
if(n==1){
return 1;
}else{
return n*f(n-1);//不停的调用f(n)这个方法
}
}
}
Java都是使用的栈机制
调用一次压一层,方法结束消失一层。
案例:简易计算器
只要不出错,可无限输入。
import java.util.Scanner;
public class Demo05_1 {
public static void main(String[] args) {
while (true){//死循环
Scanner scanner = new Scanner(System.in);
double a = scanner.nextDouble();
Scanner scanner1 = new Scanner(System.in);
String x= scanner1.nextLine();
Scanner scanner2 = new Scanner(System.in);
double b = scanner2.nextDouble();
switch (x){
case "+":
System.out.println(add(a,b));
break;
case "-":
System.out.println(subtract(a,b));
break;
case "*":
System.out.println(multiply(a,b));
break;
case "/":
System.out.println(divide(a,b));
break;
default:
System.out.println("匹配失败!");
}
}
}
public static double add(double a,double b){
return a+b;
}
public static double subtract(double a,double b){
return a-b;
}
public static double multiply(double a,double b){
return a*b;
}
public static double divide(double a,double b){
return a/b;
}
}