本篇文章为你整理了Java方法（java方法的使用）的详细内容，包含有java方法重载 java方法的使用 java方法重写和方法重载的区别 java方法怎么写 Java方法，希望能帮助你了解 Java方法。
设计原则: 方法本意是功能块(类似C语言的函数), 就是实现某个功能的语句块集合,设计方法最好保持方法的原子性,就是一个方法只完成1个功能,这样有利于后期的扩展
//System.out.println(add(1, 2));
System.out.println("======================================");
//调用test
test();
//加法 形式参数
public static int add(int a, int b) {//有返回值需要int等类型
return a + b;//返回值
//方法2
public static void test() {//返回值为空void
//while循环输出1~1000之间被5整除的数,并且3个每行
int i_1 = 0;
while (i_1 = 1000) {
++i_1;
if (i_1 % 5 == 0) {
System.out.print(i_1 + "\t\t");//不要加ln
} //println输出后会自动换行
if (i_1 % (5 * 3) == 0) {
System.out.println();
//此段代码不显示图片, 自身去试试代码
**修饰符: **是可选的, 让编译器知道如何调用方法, 并且定义了方法的访问类型
返回值类型: 方法会有返回值, return ValueType是方法返回值的数据类型;,修饰符中需要使用static; 倘若方法无需返回值, 需要使用关键字void
**方法名: **方法的实际名称, 方法名和参数表共同构成方法签名
**参数类型: **参数类似一个占位符, 当方法需要调用时, 传递给参数, 这个值被称为实参或者变量;参数列表是指方法的参数类型、顺序和参数的个数; 参数是可选的,意思就是方法名可以不包含任何参数
形式参数: 在方法被调用时用于接收外界输入的数据(类似add(int a, int b)中的a与b)
实参: 调用方法的时实际传递给方法的数据(类似add(1, 2)中的1与2)
System.out.print("Input Number_1: ");
Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
int Number_1 = Input.nextInt();//用next方法接收
//nextInt()接收int类型的数值
System.out.print("Input Number_2: ");
Scanner Input2 = new Scanner(System.in);//创建一个名字"Input"的扫描器
int Number_2 = Input2.nextInt();
System.out.println("\t两个数中这个最小: " + Max(Number_1, Number_2));
System.out.println("============================================");
System.out.println("比谁小");
System.out.print("Input Number_3: ");
Scanner Input_Num3 = new Scanner(System.in);//创建一个名字"Input"的扫描器
int Number_3 = Input.nextInt();//用next方法接收
//nextInt()接收int类型的数值
System.out.print("Input Number_4: ");
Scanner Input_Num4 = new Scanner(System.in);//创建一个名字"Input"的扫描器
int Number_4 = Input2.nextInt();
System.out.println("\t两个数中这个最小: " + Min(Number_3, Number_4));
//两个数比大小,输出大的
public static int Max(int a, int b) {
if (a == b) {
System.out.println("\tNumber_1 == Number_2");
//return 0; //终止方法
return a;
} else if (a b) {
System.out.println("\t两个数中Number_1最大");
return a;
} else {
System.out.println("\t两个数中Number_2最大");
return b;
//两个数比大小,输出小的
public static int Min(int x, int y) {
if (x == y) {
System.out.println("\tNumber_3 == Number_4");
return x;
} else if (x y) {
System.out.println("\t两个数中Number_3最小");
return x;
} else {
System.out.println("\t两个数中Number_4最小");
return y;
重载就是在一个类中,有相同函数名称, 但形参不同的函数
方法名必须相同
参数列表必须不同(个数, 类型, 参数排列顺序不同等)
方法返回的类型可相同也可不通
仅仅返回类型不同不足以成为方法重载
实现理论: 方法名称相同时,编译器会根据调用方法的参数个数,参数类型等逐个匹配, 以选择对应的方法,如果匹配失败,则编译器报错
重载与返回值无关(返回类型可相同也可不同)
package Method;
import java.util.Scanner;
public class Demo_1 {
public static void main(String[] args) {
//System.out.println("比谁大");
//System.out.print("Input Number_1: ");
//Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
//int Number_1 = Input.nextInt();//用next方法接收
////nextInt()接收int类型的数值
//System.out.print("Input Number_2: ");
//int Number_2 = Input.nextInt();
//System.out.println("\t两个数中这个最小: " + Max(Number_1, Number_2));
//Input2.close();
//Input.close();
//System.out.println("==============================================");
//System.out.println("比谁小");
//System.out.print("Input Number_3: ");
//Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
//int Number_3 = Input.nextInt();//用next方法接收
////nextInt()接收int类型的数值
//System.out.print("Input Number_4: ");
//int Number_4 = Input.nextInt();
//System.out.println("\t两个数中这个最小: " + Min(Number_3, Number_4));
//Input_Num3.close();
//Input_Num4.close();
///////////////////
System.out.println("比谁大");
System.out.print("Input Number_1: ");
Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
double Number_1 = Input.nextDouble();//用next方法接收
//nextInt()接收int类型的数值
System.out.print("Input Number_2: ");
double Number_2 = Input.nextDouble();//若nextDouble变为nextInt不会出崔,但最后结果会跟随最开头的Double
System.out.println("\t两个数中这个最小: " + Max(Number_1, Number_2));
Input.close();
Input2.close();
public static double Max(double a, double b) {//针对Max()方法的重载;返回double类型
if (a == b) {
System.out.println("\tNumber_1 == Number_2");
//return 0; //终止方法
return a;
} else if (a b) {
System.out.println("\t两个数中Number_1最大");
return a;
} else {
System.out.println("\t两个数中Number_2最大");
return b;
注释了的代码可全部解开, 试试输入的double类型和int类型的,最后输出若有.0就是double类型;注意更改我代码中Scanner等变量
for (int i = 0; i args.length; i++) {
System.out.println("args[" + i + "] = " + args[i]);
在java文件的所在路径下编译java文件
cd ../回退上一级文件夹(可以体会下在其他文件下引用自己写的java文件)
运行编译好的java文件(为何没有输出, 因为我们的java代码是需要将参数输出, 我并没有参数输入)
再一次运行java文件, 在java Method.CmdTran输入四个参数I am your Father
输出了四个刚刚输入的参数(数组下标由0开始)
一个方法中只能指定一个可变参数, 它必须是方法的最后一个参数; 任何普通的参数必须在它之前声明
在一开始写方法时,会有很多不确定变量, 我们需要写多种方法(方法重载), 而每种方法都是只实现一个功能,依次针对不同情况
public static void main(String[] args) {
ChangeData cd = new ChangeData();//创建类的对象
cd.test(1.5F, 222, 3, 2);//创建一个对象cd, 并使用类中的test方法
} //x:1.5 i:222, 3, 2
public void test(float x, int... i) {
//不知道要传入多少参数
System.out.println(x + " " + i[0] + " " + i[2]);
变长参数是 Java 的一个语法糖，本质上还是基于数组的实现：
package Method;
public class ChangeData {
public static void main(String[] args) {
printMax(21, 25, 2, 56);
printMax(new double[]{1, 2, 5, 6, 7, 8, 9});//本质是数组因此可以用数组形式
public static void printMax(double... number) {
if (number.length == 0) {//当数组长度=0
System.out.println("No argument passed");
return;
double max = number[0];//初始化
//找出最大值
for (int i = 1; i number.length; i++) {
if (number[i] max) {
max = number[i];
System.out.println("The Max value is " + max);
A方法调用A方法! 自己调用自己
思想: 简单程序解决复杂问题; 把大型复杂的问题层层转化为一个与原问题相似的规模较小问题来求解
递归结构: 递归头就是啥时候不调用自己,如果没有就陷入死循环
递归结构: 递归体就是啥时候调用自身方法
虽然代码量简单且少,但会占用很多空间
package Method;
public class InterJava {
public static void main(String[] args) {
InterJava inter = new InterJava();
// 没有递归头, 写会错误(栈溢出)
System.out.println(inter.f(5));
//5! = 1*2*3*4*5
public static int f(int n) {
if (n == 1) {//递归头
return 1;
} else {//递归体
return n * f(n - 1);
递归: 本质就是当我调用时, 只要我调用方法时没用到递归头的条件我就必须使用递归体语句从而不断缩小了问题的本质, 当进行递归体语句时,就可以将递归体语句的结果不断返回上去
public static void main(String[] args) {
//计算器,实现加减乘除,并能循环接收新数据,通过交互实现
写4个方法:
加减乘除
利用循环+ switch进行用户交互
传递需要操作的两个数
输出结果
Scanner scanner = new Scanner(System.in);//创建输入
String m = "Y";//初始化循环条件
while (m.equals("Y")) {
System.out.print("请输入第一个数:");//输入数值
int x = scanner.nextInt();
System.out.print("请输入运算符:");//输入运算符,作为switch条件
String o = scanner.next();
System.out.print("请输入第二个数:");//输入数值
int y = scanner.nextInt();
int result = 0;//初始化结果变量
switch (o) {//根据运算符变量,选择一个case
case "+":
result = Add(x, y);
break;
case "-":
result = Sub(x, y);
break;
case "*":
result = Mul(x, y);
break;
case "/":
result = Div(x, y);
break;
default:
System.out.print("输入错误");
System.out.println(x + o + y + "=" + result);
System.out.print("是否继续下一组计算(Y/N): ");
m = scanner.next();//重新定义循环条件;输入N就跳出while
scanner.close();//关闭IO
System.out.println("老子写的计算器牛逼吧!!!");
//加减乘除的方法定义
public static int Add(int a, int b) {
return a + b;
public static int Sub(int c, int d) {
return c - d;
public static int Mul(int e, int f) {
return e * f;
public static int Div(int g, int h) {
return g / h;
计算器可以对其数据类型更改为double类型, 让其除法运算有更高的精度;
对加减乘除方法进行编写
思考利用什么条件来对switch条件进行判断运算选择(利用运算符)
由于条件需要循环不断接收数值, 所以利用while语句的判定, 并且在一次循环结尾重新定义while语句的判定,判断是否再一次进行二元运算
以上就是Java方法（java方法的使用）的详细内容，想要了解更多 Java方法的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。