Java语言的基础知识（笔记）—简单方法、(参数、返回值)有无对比、方法重载

最新推荐文章于 2023-03-29 16:41:49 发布

Williams10

最新推荐文章于 2023-03-29 16:41:49 发布

阅读量283

点赞数

分类专栏： java 语言基础

本文链接：https://blog.csdn.net/Williams10/article/details/106219784

版权

java 语言基础专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一、复习简单方法的使用：
1、定义格式：public static void 方法名称() {
方法体
}
2、调用格式：方法名称 ();
3、注意事项：(1)不考虑方法定义的先后顺序。
(2) 方法定义必须是挨着的，不可以在一个方法的内部定义另一个方法。
(3)方法定义后无法自行执行，需要进行方法的调用后方执行。

  public static void main(String[] args) {
            for (int j=0;j<5;j++) {
                 for (int i=0;i<20;i++) {
                         System.out.prin("*");
                 }
                    System.out.println ();
                 }
}

二、方法：
1、方法的定义格式：
1)方法：若干语句的功能集合；
方法如同一个工厂；
牛奶工厂：原料、奶牛、饲料、水、产出物、奶制品；
2)返回值（产出物）：从方法中出来的数据；
3)参数（原料）：冲方法中出来的数据；
定义方法的完整格式：
修饰符返回值类型方法名称（参数类型参数名，~~~·）{
方法体
return 返回值；
}
注释：（1）修饰符：public static （固定写法）
（2）返回值类型：最终产出的数据结果是什么类型；
（3）参数类型：进入方法的数据是什么类型；
（4）参数名称：进入方法的数据对应的变量名称（PS：参数如果有多个，使用逗号将其进行分隔）
（5）方法体：方法需要做的事，若干行代码；
（6）return：有两个作用（1、停止当前方法‘2、将后面的返回值还回调用处）；
（7）返回值：方法体执行后最终产生的数据结果；
注意：return后的“返回值”，必须与方法名称前的“返回值类型”保持对应。
定义一个两个int数字相加的方法。三要素：
返回值类型:int;
方法名称：sum;
参数列表：int a,int b；

public static void(String[] args)  {
System.out.println(result);
}
public static int sum(int a,int b) {
int result=a+b;
return result;
}

2、方法的三种调用格式：
1）单独调用：方法名称(参数);
2）打印调用：System.out.println(方法名称(参数))；
3）赋值调用：数据类型变量名称=方法名称(参数);
注意：此前学习的方法，返回类型固定写为void，这种方法只能进行单独调用，无法进行打印调用或赋值调用。

public static void main(String[] args) {
//单独调用
sum(a:10,b:15);
System.out.println("========");
//打印调用
System.out.println(sum(a:10,b:15)); // 25
System.out.println("========");
// 赋值调用
int number=sum(a:15,b:10);
System.out.println("变量的值："+number);
}

在这里插入图片描述
3、有参数与无参数的区别：
1）有参数：小括号中有内容，当一个方法需要一些数据条件才能完成任务时，就是有参数；
eg:两个数字相加必须知道各自的数值，才能相加。
2）无参数：小括号中留空，一个方法不需要任何的数据条件，可以独立完成任务时，就是无参数；
eg:定义一个方法，打印固定的8次China。

public static void main(String[] args) {
method(a:8,b:12);
System.out.println("===========");
method2();
}
// 两个数字做乘法时，必须知道各自的数值为多少，否则无法运算
// 有参数
public static void method(int a,int b) {
int result=a*b;
System.out.println("结果为"+result);
}
// 打印输出固定8次文本字符串
public static void method2() {
for(int i=0;i<8;i++) {
System.out.println("China !"+i);
}
}

4、有无返回值的区别：
1）有返回值：你帮我算，算完后将结果告诉我；
2）五返回值：你独立运算，算完后你负责显示结果，无需告诉我；
注意事项：
（1）对于有返回值的方法三种调用方法均可使用；
（2）对于五返回值的方法，只能使用单独调用；

 public  static void main(String[] args) {
 // 我是main方法 ，我调用你。
 //我调用你，你帮我算，将结果告诉num变量
 int  num=getSum(a:10,b:15);
 System.out.println("返回值为："+num);
 System.out.println("============");
 printSum(a:100，b:300);
 System.out.println("============");
 System.out.println(getSum(a:2,b:4));
 getSum(a:4,b=6);//返回子没有用到
 System.out.println(“============");
 //对于void中没有返回值的方法只能进行单独调用；
 // System.out.println(printSum(2,4));//错误写法
 // System.out.println(void);
 // int num2=printSum(10,15); //错误写法
 // int num3=void;
 // void num4=void;
 }
 // 我是一个方法，我负责 a与b相加；
 // 我有返回值int,谁调用我，我就把计算结果给谁；
 public static void getSum(int a,int b) {
 int result=a+b;
 return result;
 }
 // 我是一个方法，我负责a与b相加；
 // 我没有返回值，结果自己留着，自己进行打印输出；
 public static void printSum(String[] args) {
 int result =a+b;
 System.out.println("结果为 ："+result);
}

在这里插入图片描述
练习一、比较两个数字

public static void main(String[] args) {
        System.out.println(isSame(10,20));
    System.out.println(isSame(20,20));
    }
    /* 三要素：
     返回值类型：boolean
     方法名称：isSame
     参数列表：int a,int b*/
    public static boolean isSame(int a,int b) {
        /*boolean same;
        if (a==b) {
            same=true;
        } else same=false;*/
        //boolean same=a==b?true:false;
        boolean same=a==b;
        return  a==b;
    }

练习二、求出1到100之间所有数字的和值；

 public static void main(String[] args) {
        System.out.println("结果是："+getSum());
    }
    /* 三要素：
    返回值：有返回值，计算结果为int型数字
    方法名称：getSum
    参数列表：数据范围已确定，是固定的，因此不需要任何条件，不需要参数
    */
    public static int getSum() {
        int  sum=0;
        for (int i=0;i<=100;i++) {
            sum+=i;
        }
        return sum;
    }

练习三、打印指定次数的HelloWorld；

 public static void main(String[] args) {
      printCount(10);
    }
    /* 三要素：
       返回值类型：仅进行打印操作，没有进行计算，无需将结果告诉调用处
       方法名称：printCount
       参数列表：需要进行打印多少次，这个需要知道，否则无法进行打印操作。 次数：int
    */
    public static void printCount(int num) {
        for (int i=1;i<=num;i++) {
            System.out.println("HelloWorld!"+i);
            }
  }

5、使用方法的注意事项：
1）方法定义在类当中，但不能在方法当中再去定义方法，不能进行嵌套；
2）方法定义时前后顺序不做要求；
3）方法定义后不会直接执行，需要其执行时一定要进行调用；
4）当方法有返回值时，必须写上“return 返回值;”；
5）return后的返回值数据必须与方法的返回值类型对应起来；
6）对于一个void没有返回值的方法，不可以写return后的返回值，只能写return 自己；
7）对于void方法中最后一行的return值可以忽略不写；
8）一个方法中可以有多个return语句，但必须保证仅有一个语句会被执行，且两个return不可以连写；

public static int method() {
    return 10;
}
public static void method2() {
  //  return 10; // 错误！方法没有返回值，return后不可以写返回值。
    return; //没有返回值，仅结束方法的执行。
}
public static void method3() {
    System.out.println("Flower!");
    System.out.println("Spring!");
    // return; //最后一行的return可以忽略不写。
}
public static int getMax(int a,int b){
  /*   int max;
     if (a>b) {
         max=a;
     }
     else {
         max=b;
     }
     return max;*/
    if (a > b) {
    return a;
    }
    else {
        return b;
    }
}

三、方法重载：
1、定义：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。（多个方法的名称相同，但参数列表不同）；
2、优点：只需记住唯一一个方法名称即可实现类似的多个功能；
3、注意：
（1）与方法重载有关的因素：
1）参数个数不同；
2）参数类型不同；
3）参数的多类型顺序不同；
（2）与方法重载无关的因素：
1）参数的名称；
2）方法的返回值类型；

  public static void main(String[] args) {
        System.out.println(sum (1,2)); // 执行成功！
        System.out.println(sum(1,2,3)); // 执行成功！
        System.out.println(sum(1,2,3,4)); // 执行成功！
        // System.out.println(sum(1,2,3,4,5)); //错误，找不到任何方法进行匹配。
    }
    public static int sum(int a,int b,int c) {
        System.out.println("执行成功！");
        return a+b+c;
    }
    public static int sum(int a,int b,int c,int d) {
        System.out.println("执行成功！");
        return a+b+c+d;
    }
    public static int sum(int a,double b) {
        return(int) (a+b);
    }
    public static int sum(double a,int b) {
        return (int) (a+b);
    }
    public static int sum(int a,int b) {
        System.out.println("执行成功！");
        return a+b;
    }
    /*public static double sum(int a,int b) {
        return a+b+0.0;
    } //错误，预防的的返回值类型无关 */
    /* public static int sum(int x,int y) {
        return x+y;
    } //错误，与参数的名称无关 */

练习一、比较两个数据是否相等。参数类型分别为两个 byte 类型，两个 short 类型，两个 int 类型，两个 long 类型，并
在 main 方法中进行测试：

public static void main(String[] args) {
        byte a=1;
        byte b=2;
        short c=2;
        short d=2;
        int e=1;
        int f=1;
        long g=2;
        long h=1;
        System.out.println(isSame(a,b));
        System.out.println(isSame(c,d));
        System.out.println(isSame(e,f));
        System.out.println(isSame(g,h));
    }
    public static boolean isSame(byte a,byte b) {
            System.out.println("byte类型执行成功！");
            boolean same;
            if (a==b) {
                same=true;
            }
            else {
                same=false;
            }
            return same;
        }
        public static boolean isSame(short a,short b ) {
            System.out.println("short类型执行成功！");
            boolean same=a==b?true:false;
            return same;
        }
        public static boolean isSame(int a,int b) {
            System.out.println("int类型执行成功！");
            return a==b;
        }
        public static boolean isSame(long a,long b) {
            System.out.println("long类型执行成功！");
            if (a==b) {
                return true;
            }
            else {
                return false;
            }
        }

练习二、判断哪些方法是重载关系：
注意：与参数名称无关。

public static void open(){} //正确重载；
public static void open(int a){} //正确重载；
static void open(int a,int b){} //错误，与第八行发生冲突；
public static void open(double a,int b){}//正确重载；
public static void open(int a,double b){} //错误，与第六行发生冲突
public void open(int i,double d){} //错误 ，与第五行发生冲突
public static void OPEN(){} //代码正确，但是不能有效重载，因为函数名称不同。
public static void open(int i,int j){} //错误，与第三行发生冲突

练习三、模拟输出语句中的 println 方法效果，传递什么类型的数据就输出什么类型的数据，只允许定义一个方法名println ：
注意：在调用输出语句时，println方法进行了多种数据类型的重载形式。

 public static void main(String[] args) {
       myPrint(100);
       myPrint("change");
    }
    public static void myPrint(byte num) {
        System.out.println(num);
    }
    public static void myPrint(short num) {
        System.out.println(num);
    }
    public static void myPrint(long num) {
        System.out.println(num);
    }
    public static void myPrint(int num) {
        System.out.println(num);
    }
    public static void myPrint(double num) {
        System.out.println(num);
    }
    public static void myPrint(char num) {
        System.out.println(num);
    }
    public static void myPrint(String str) {
        System.out.println(str);
    }
    public static void myPrint(boolean same) {
        System.out.println(same);
    }
    public static void myPrint(float num) {
        System.out.println(num);
    }

Williams10

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java语言的基础知识（笔记）—简单方法、(参数、返回值)有无对比、方法重载

一、复习简单方法的使用：1、定义格式：public static void 方法名称() {方法体}2、调用格式：方法名称 ();3、注意事项：(1)不考虑方法定义的先后顺序。(2) 方法定义必须是挨着的，不可以在一个方法的内部定义另一个方法。(3)方法定义后无法自行执行，需要进行方法的调用后方执行。 public static void main(String[] args) { for (int j=0;j<5;j++) {
复制链接

扫一扫