方法：用来解决一类问题的代码的有序组合，是一个功能模块
方法的声明和调用
语法格式：
访问修饰符 返回类型 方法名(参数列表){
方法体
}
访问修饰符：public，private，protected，默认，static
返回类型：返回值可以是void以及任何数据类型
参数列表可以省略
根据方法是否带参数、是否返回值，可分为四类：
-无参无返回值方法
注意：方法在类的内部定义！
//打印输出星号的方法
public void printStar() {
System.out.println("************");
}
public static void main(String[] args) {
//创建一个FloatDemo类的对象myFloatDemo
FloatDemo myFloatDemo=new FloatDemo();
//使用对象名.方法名()去调用方法
myFloatDemo.printStar();
System.out.println("欢迎来到java世界");
myFloatDemo.printStar();
}
-无参带返回值方法
// 求长方形面积的方法
public int area() {
int length=10;
int width=5;
int getArea=length*width;
return getArea;//返回语句
}
public static void main(String[] args) {
Rectangle rc=new Rectangle();
System.out.println("长方形的面积为："+rc.area());
}
-带参无返回值方法
//求最大值的方法
public void max(float a,float b) {
float max;
if(a>b) {
max=a;
}else {
max=b;
}
System.out.println("两个数"+a+"和"+b+"的最大值为："+max);
}
public static void main(String[] args) {
MaxDemo maxDemo=new MaxDemo();
int a=5,b=3;
maxDemo.max(a, b);//不定义a，b会报错，a，b的有效范围只在max方法中
float m=5.6f,n=8.9f;
maxDemo.max(m, n);//float可以自动转换为double
maxDemo.max(9.8f, 12.8f);
}
-带参带返回值方法
//方法不能嵌套定义
//求阶乘的方法
public int fac(int n) {
int s=1;
for(int i=1;i<=n;i++) {
s*=i;
}
return s;
}
public static void main(String[] args) {
FacDemo facDemo=new FacDemo();
int fac=facDemo.fac(3);
System.out.println("3!="+fac);
//求1!+2!+3!+4!+5!
int sum=0;
for(int i=1;i<=5;i++) {
fac=facDemo.fac(i);
sum=sum+fac;
}
System.out.println("1!+2!+3!+4!+5!="+sum);
}
//数组作为方法参数
//打印输出数组元素的值
public void printArray(int[] arr) {
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
int[] arr={10,20,30,40,50};
ArrayMethod am=new ArrayMethod();
am.printArray(arr);//数组名称本身就是一个对象
}
主方法main就是以数组作为方法参数的，又叫做命令行参数，命令行参数可以在执行Java程序的时候接收字符串类型的数据
//查找数组元素值的方法
public boolean search(int n,int[] arr) {
boolean flag=false;//默认是没找到
for(int i=0;i<arr.length;i++) {
if(arr[i]==n) {
flag=true;//找到了
break;
}
}
return flag;
}
public static void main(String[] args) {
int arr1[]= {10,20,30,40,50,60};
Scanner sc=new Scanner(System.in);
System.out.println("请输入要查找的数据：");
int n1=sc.nextInt();
ArraySearch as=new ArraySearch();
boolean flag=as.search(n1, arr1);
if(flag) {
System.out.println("找到了");
}else {
System.out.println("没找到");
}
}
方法的重载
方法名相同，参数列表不同
参数列表不同包括，参数的个数和类型不同，如果只有参数名不同，不能算作方法重载
//求两个int类型数的和
public int plus(int m,int n) {
return m+n;
}
//求两个double类型数的和
public double plus(double m,double n) {
return m+n;
}
//求数组元素的累加和
public int plus(int[] arr) {
int sum=0;
for(int i=0;i<arr.length;i++) {
sum=sum+arr[i];
}
return sum;
}
public static void main(String[] args) {
int m=5,n=10;
int[] arr= {1,2,3,4,5,6};
MathDemo mathDemo=new MathDemo();
System.out.println("int类型的和："+mathDemo.plus(m, n));
System.out.println("double类型的和："+mathDemo.plus(5.6, 7.8));
System.out.println("数组元素的累加和："+mathDemo.plus(arr));
}
圆周率可以用Math.PI表示
//基本数据类型的传值
//交换方法
public void swap(int a,int b) {
int temp;
System.out.println("交换前：a="+a+",b="+b);
temp=a;a=b;b=temp;
System.out.println("交换后：a="+a+",b="+b);
}
public static void main(String[] args) {
int m=4,n=5;
ExchangeDemo ed=new ExchangeDemo();
System.out.println("交换前：m="+m+",n="+n);
ed.swap(m, n);
System.out.println("交换后：m="+m+",n="+n);
}
2.
//基本数据类型的传值
//交换方法
public void swap(int a,int b) {
int temp;
System.out.println("交换前：a="+a+",b="+b);
temp=a;a=b;b=temp;
System.out.println("交换后：a="+a+",b="+b);
}
public void swapTest() {
int m=4,n=5;
//不需要新建对象
System.out.println("交换前：m="+m+",n="+n);
swap(m, n);//直接调用方法，不需要写对象
System.out.println("交换后：m="+m+",n="+n);
}
public static void main(String[] args) {
ExchangeDemo ed=new ExchangeDemo();
ed.swapTest();
}
3.
public void add(int n) {
n++;
System.out.println("方法中n="+n);
}
public static void main(String[] args) {
int n=10;
System.out.println("方法调用前n的值："+n);
ExchangeDemo1 ed1=new ExchangeDemo1();
ed1.add(n);
System.out.println("方法调用后n的值："+n);
}
4.
//数组作为方法参数的传值问题
//定义一个用于修改某个数组元素值的方法
public void updateArray(int[] a) {
a[3]=15;
System.out.println("数组a的元素为：");
for(int n:a) {
System.out.print(n+" ");
}
System.out.println();
}
public static void main(String[] args) {
ArrayDemo ad=new ArrayDemo();
int[] a1= {1,2,3,4,5};
System.out.println("方法调用前数组a1的元素为：");
for(int n:a1) {
System.out.print(n+" ");
}
System.out.println();
ad.updateArray(a1);
System.out.println("方法调用后数组a1的元素为：");
for(int n:a1) {
System.out.print(n+" ");
}
System.out.println();
}
当在主方法中定义的a1将数据元素传值给方法updateArray()时，数组a和a1都指向了同一片内存空间，一旦在方法中改变数组元素的值，数组a1的值将发生改变，究其根本，是因为数组是引用数据类型，而上文中提及到的基本数据类型则不会发生改变。
可变参数列表（参数个数不确定**）**
public void sum(int... n){}
//求和
public void sum(int... n) {
int sum=0;
for(int i:n) {
sum=sum+i;
}
System.out.println("sum="+sum);
}
public static void main(String[] args) {
ArgsDemo ad=new ArgsDemo();
ad.sum(1);
ad.sum(1,2);
ad.sum(1,2,3);
}
参数列表中如果有两个以上的参数，可变参数一定是在最后的
方法调用时可以传入0个或多个参数，传入数组也可以
//查找
//search(int n,int... a)==search(int n,int[] a)--方法重载会报错
//一个方法中只能有一个可变参数
public void search(int n,int... a) {
boolean flag=false;
for(int a1:a) {
if(n==a1) {
flag=true;
break;
}
}
if(flag) {
System.out.println("找到了！"+n);
}else {
System.out.println("没找到！"+n);
}
}
public static void main(String[] args) {
ArgsDemo1 ad1=new ArgsDemo1();
ad1.search(3, 1,2,3,4,5);
int[] a= {1,2,3,4,5};
//可以将数组传递给可变参数列表
//数组作为参数时，是不能将多个值（可变参数列表）传递给数组的
ad1.search(3, a);
}
可变参数列表作为方法参数的重载问题
//可变参数列表所在的方法是最后被访问的
public int plus(int a,int b) {
System.out.println("不带可变参数的方法被调用！");
return a+b;
}
public int plus(int... a) {
int sum=0;
for(int n:a) {
sum=sum+n;
}
System.out.println("带可变参数的方法被调用！");
return sum;
}
public static void main(String[] args) {
ArgsDemo3 ad=new ArgsDemo3();
System.out.println("和为："+ad.plus(1,2));
}
文档注释 /** **/
关于javadoc命令
1.打开命令行，转到存储目录下，输入命令：javadoc -d doc ArgsDemo3.java
2.到存储目录-doc下，打开index.html即可看到生成的文档内容
方法的调试
按F5可以跳到方法内部执行
按F7由方法内部返回调用处
