Java中的方法
语法格式:
访问修饰符 返回类型 方法名(参数列表){
方法逻辑
}
public static void main(String[] args){
System.out.println("Hello word!")
}
public static 访问修饰符<静态方法>
void 返回类型<不返回任何类型>
main 方法名
String[] args 参数列表<字符串类型>
访问修饰符:当前方法被访问的权限范围
- public
- 什么都不写
- protected
- private
返回类型:
- void 无返回
- int
- …
方法命名规则和变量命名规则一样
- 一单词小写
- 多单词,第一个单词小写,剩余单词首字母大写
参数:
- 可无参数
- 有参数类型个参数名组成
- 多类型参数可以用,隔开
没有参数和返回值的方法的定义和使用
import java.util.Scanner;
public class NoParametersNoReturn {
public static void main(String[] args) {
/* 在NoParametersNoReturn类中定义了方pringStar()
如果想要怕使用这个方法,
1.NoParametersNoReturn npnr = new NoParametersNoReturn(); 实例化对象npnr
2.npnr.printStar() 实例对象去调用方法
* */
String t;
Scanner sc = new Scanner(System.in);
NoParametersNoReturn npnr = new NoParametersNoReturn();
System.out.println("输入内容:");
t = sc.next();
npnr.printStar();
System.out.println(t);
npnr.printStar();
}
public void printStar() {
System.out.println("***********");
}
}
无参数有返回值的方法
public class NoParametersHaveReturn {
public int rectangularArea() {
// 求矩形的面积
int length = 10;
int width = 5;
return length * width;
}
public static void main(String[] args) {
//
NoParametersHaveReturn nphr = new NoParametersHaveReturn();
System.out.println("矩形面积:" + nphr.rectangularArea());
}
}
有参数无返回值的方法
public class HaveParametersNoReturn {
public void floatMax(float a, float b) {
if (a > b) {
System.out.println("最大值" + a);
} else if (a < b) {
System.out.println("最大值" + b);
} else {
System.out.println("相等");
}
}
public static void main(String[] args) {
//
HaveParametersNoReturn hpnr = new HaveParametersNoReturn();
float a = 10.0f;
float b = 10.1f;
hpnr.floatMax(a, b);
}
}
有参数有返回值的方法
public class HaveParametersHaveReturn {
public int factorial(int n) {
// n 的阶乘
int item = 1;
if (n == 0) {
return 0;
} else if (n == 1) {
return 1;
} else {
for (int i = 1; i <= n; i++) {
item *= i;
}
return item;
}
}
public static void main(String[] args) {
//
HaveParametersHaveReturn hphr = new HaveParametersHaveReturn();
int n = 4;
System.out.println(hphr.factorial(n));
}
}
方法重载
特点:方法名相同,当时参数[类型][数量]不同
public class MethodOverload {
public int plus(int x, int y) {
return x + y;
}
public double plus(double x, double y) {
return x + y;
}
public int plus(int[] arr) {
int sum = 0;
for (int i : arr) {
sum += i;
}
return sum;
}
public static void main(String[] args) {
//
int x = 5, y = 10;
int[] a = {1, 2, 3, 4, 5};
MethodOverload md = new MethodOverload();
System.out.println("int类型的和:" + md.plus(x, y));
System.out.println("double类型的和:" + md.plus(5.6, 4.4));
System.out.println("数组元素累加和:" + md.plus(a));
}
}
方法调用的值传递
public class ExchangeDemo {
public void swap(int a,int b){
int tmp;
System.out.println("交换前-a="+a+" b="+b);
tmp = a;
a = b;
b = tmp;
System.out.println("交换后-a="+a+" b="+b);
}
public void doSwap(){
/*
除了主方法需要实例对象去调用其他方法外
其他方法与其他方法之间可以直接调用
* */
int a = 4,b = 5;
System.out.println("调用方法前-a="+a+" b="+b);
swap(a,b);
System.out.println("调用方法后-a="+a+" b="+b);
}
public static void main(String[] args) {
// 主方法调用其他方法,需要实例对象
ExchangeDemo ed = new ExchangeDemo();
ed.doSwap();
}
}
结果为:
调用方法前-a=4 b=5
交换前-a=4 b=5
交换后-a=5 b=4
调用方法后-a=4 b=5
调用方法的时候,传递的数据只是a,b的值作为参数,值传递的方法中后,会在方法中
形成新的a,b对象,这个新对象是局部变量,不影响外部的a,b;所以最终的结果是,调用
方法后,对外部a,b的数据没有影响.
数组传值的结果有点不同:
public class ArrayDemo {
public void updateArray(int[] b) {
// 修改数组中某个元素的方法
b[3] = 0;
System.out.println("方法内,数组b的元素为:");
for (int i : a) {
System.out.print(i + " ");
}
System.out.println();
}
public static void main(String[] args) {
//
int[] a = {1,2,3,4,5};
ArrayDemo ad = new ArrayDemo();
System.out.println("调用前,数组a的元素为:");
for (int i : a){
System.out.print(i+" ");
}
System.out.println();
ad.updateArray(a);
System.out.println("调用后,数组a的元素为:");
for (int i : a){
System.out.print(i+" ");
}
System.out.println();
}
}
结果为:
调用前,数组a的元素为:
1 2 3 4 5
方法内,数组b的元素为:
1 2 3 0 5
调用后,数组a的元素为:
1 2 3 0 5
数组是引用数据类型,结果不同:
对方法外部的数组产生了影响,调用方法前,数组a指向数组的内存空间,调用方法,
方法中的b也指向了这片内存空间,也就是当前数组的内存空间被两个数组名a,b指向
同一个数组的内存空间,在方法内进行修改的时候会对共同的内存空间产生影响,所以
影响了主方法中的数组的元素;
可变参数列表
参数的类型可以确定,但是个数不能被确定
int... n
表示参数n是个参数列表,但是不知道一共有几个元素
public class DoAddDemo {
public void sum(int... n) {
int sum = 0;
for (int i : n) {
sum += i;
}
System.out.println("结果为:" + sum);
}
public static void main(String[] args) {
//
DoAddDemo dad = new DoAddDemo();
dad.sum(1,2,3,4,5);
}
}
既有可变参数列表,又有固定参数:
需要注意的是,可变参数放在不可变参数的后面
public class DoAddDemo {
public void search(int n, int... a) {
boolean flag = false;
for (int i : a) {
if (n == i) {
flag = true;
break;
}
}
if (flag) {
System.out.println("找到:" + n);
} else {
System.out.println("没找到:" + n);
}
}
public static void main(String[] args) {
//
DoAddDemo dad = new DoAddDemo();
dad.search(5, 1, 2, 3, 4, 5, 6);
}
}