首页 > 其他分享 >方法概述

方法概述

时间：2024-12-05 13:54:36浏览次数：6  
标签：int System static 概述 方法 public out

方法概述

​ 方法（method）是程序中最小的执行单元

​ 开发中重复的代码,具有独立功能的代码可以抽取到方法中

​ 提高代码的复用性,提高代码可维护性

注意：

  • 方法必须先创建才可以使用，该过程成为方法定义
  • 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

​ Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法:

定义

方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
修饰符:

​ 修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型:

​ 方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
方法名:

​ 是方法的实际名称。方法名和参数表共同构成方法签名、
参数类型:

​ 参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的
参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

  • 形式参数:在方法被定义时括号中的变量，因此形式参数只在函数中有效，调用完成之后自动销毁了
  • 实际参数:调用方法时实际传给方法的数据，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

方法体:

​ 方法体包含具体的语句，定义该方法的功能。

修饰符 返回值类型 方法名(参数类型 参数名){
    方法体
    return 返回值；
}
------------------------------------------------
public static void main(String[] args) {
    //实际参数：方法调用时传递的参数	
    int sum = add(1,2);
    System.out.println(sum); // 202
}
	//形式参数：方法定义时
public static int add(int a, int b) {
    //执行加法
    return a + b;
}

static关键字

在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。

强调一下：

  • static修饰的成员变量和方法，从属于类

  • 普通变量和方法从属于对象

  • 静态方法不能调用非静态成员，编译会报错

static关键字的用途
一句话描述就是：方便在没有创建对象的情况下进行调用(方法/变量)。

显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

static可以用来修饰类的成员方法、类的成员变量，另外也可以编写static代码块来优化程序性能

static方法
static方法也成为静态方法，由于静态方法不依赖于任何对象就可以直接访问，因此对于静态方法来说，是没有this的，因为不依附于任何对象，既然都没有对象，就谈不上this了，并且由于此特性，在静态方法中不能访问类的非静态成员变量和非静态方法，因为非静态成员变量和非静态方法都必须依赖于具体的对象才能被调用。

虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法和静态成员变量。

无参数方法

定义和调用

  • 定义格式：

    public static void 方法名 (   ) {
	// 方法体;
}

  • 范例：

    public static void method (    ) {
	// 方法体;
}

  • 调用格式：

    方法名();

  • 范例：

    method();

  • 注意：

    ​ 方法必须先定义，后调用，否则程序将报错

练习

  • 需求：设计一个方法用于打印两个数中的较大数

  • 思路：

    ①定义一个方法，用于打印两个数字中的较大数，例如getMax()

    ②方法中定义两个变量，用于保存两个数字

    ③使用分支语句分两种情况对两个数字的大小关系进行处理

    ④在main()方法中调用定义好的方法

  • 代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法
        getMax();
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    public static void getMax() {
        //方法中定义两个变量，用于保存两个数字
        int a = 10;
        int b = 20;

        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

带参数方法

定义和调用

  • 定义格式：

    参数：由数据类型和变量名组成 - 数据类型 变量名

    参数范例：int a

    public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

  • 范例：

    public static void isEvenNumber(int number){
    ...
}
public static void getMax(int num1, int num2){
    ...
}

    注意：

    方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错

    方法定义时，多个参数之间使用逗号( ，)分隔

  • 调用格式：

    方法名(参数)；

方法名(参数1,参数2);

  • 范例：

    isEvenNumber(10);

getMax(10,20);

    方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错

形参和实参

  1. 形参：形式参数,方法定义中的参数

​ 等同于变量定义格式，例如：int number

  1. 实参：实际参数,方法调用中的参数

​ 等同于使用变量或常量，例如： 10 number

注意:方法调用时,形参和实参必须一一对应

练习

  • 需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数 }

  • 思路：

    ①定义一个方法，用于打印两个数字中的较大数，例如getMax()

    ②为方法定义两个参数，用于接收两个数字

    ③使用分支语句分两种情况对两个数字的大小关系进行处理

    ④在main()方法中调用定义好的方法（使用常量）

    ⑤在main()方法中调用定义好的方法（使用变量）

  • 代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法（使用常量）
        getMax(10,20);
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
        //getMax(30);
        //getMax(10.0,20.0);

        //在main()方法中调用定义好的方法（使用变量）
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    //为方法定义两个参数，用于接收两个数字
    public static void getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

带返回值方法

定义和调用

  • 定义格式

    public static 数据类型 方法名 ( 参数 ) { 
	return 数据 ;
}

  • 范例

    public static boolean isEvenNumber( int number ) {           
	return true ;
}
public static int getMax( int a, int b ) {
	return  100 ;
}

    注意：

    方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错

  • 调用格式

    //方法名 ( 参数 ) ;
getSum(10,20)
//数据类型 变量名 = 方法名 ( 参数 ) ;
int sum = getSum(10,20)
//
System.out.println("Enter number2: ");

  • 范例

    isEvenNumber ( 5 ) ;
boolean  flag =  isEvenNumber ( 5 );

    注意：

    方法的返回值通常会使用变量接收，否则该返回值将无意义

练习

练习1

需求：设计一个方法可以获取两个数的较大值，数据来自于参数

思路：

  • ①定义一个方法，用于获取两个数字中的较大数
  • ②使用分支语句分两种情况对两个数字的大小关系进行处理
  • ③根据题设分别设置两种情况下对应的返回结果
  • ④在main()方法中调用定义好的方法并使用变量保存
  • ⑤在main()方法中调用定义好的方法并直接打印结果

代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法并使用变量保存
        int result = getMax(10,20);
        System.out.println(result);

        //在main()方法中调用定义好的方法并直接打印结果
        System.out.println(getMax(10,20));
    }

    //定义一个方法，用于获取两个数字中的较大数
    public static int getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        //根据题设分别设置两种情况下对应的返回结果
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }
}

练习2

需求：定义一个方法，求一家商场每个季度的营业额。根据方法结果再计算出全年营业额。

代码示例：

package com.itheima.demo;

public class MethodDemo9 {
    public static void main(String[] args) {
        /*需求：定义一个方法，求一家商场每个季度的营业额。
        根据方法结果再计算出全年营业额。*/
        int sum1 = getSum(10, 20, 30);
        int sum2 = getSum(10, 20, 30);
        int sum3 = getSum(10, 20, 30);
        int sum4 = getSum(10, 20, 30);

        int sum = sum1 + sum2 + sum3 + sum4;
        System.out.println(sum);

    }

    //心得：
    //1.我要干嘛？  决定了方法体   每个季度的营业额
    //2.我干这件事情，需要什么才能完成？ 决定了形参 需要三个月的营业额 a b c
    //3.我干完这件事情，看调用处是否需要使用方法的结果。   决定了返回值
    //如果需要使用，那么必须返回
    //如果不需要使用，可以返回也可以不返回
    public static int getSum(int month1,int month2,int month3){
        int sum = month1 + month2 + month3;
        //因为方法的调用处，需要继续使用这个结果
        //所以我们必须要把sum返回
        return sum;
    }
}

练习3

需求：

​ 键盘录入两个圆的半径（整数），比较两个圆的面积。

代码示例：

import java.util.Scanner;

public class MethodDemo10 {
    public static void main(String[] args) {
        //需求：键盘录入两个圆的半径（整数），比较两个圆的面积。
        //键盘录入圆的半径
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入圆的半径");
        int radii1 = sc.nextInt();

        System.out.println("请输入第二个圆的半径");
        int radii2 = sc.nextInt();
        double area1 = getArea(radii1);
        double area2 = getArea(radii2);
        if(area1 > area2){
            System.out.println("第一个圆更大");
        }else{
            System.out.println("第二个圆更大");
        }
    }

    //心得：
    //1.我要干嘛？   求圆的面积
    //2.我干这件事情，需要什么才能完成？        半径
    //3.方法的调用处，是否需要继续使用方法的结果    要比较
    public static double getArea(int radii) {
        double area = 3.14 * radii * radii;
        return area;
    }
}

注意事项

return 关键字

​ 方法没有返回值:可以省略不写。如果书写，表示结束方法
​ 方法有返回值:必须要写。表示结束方法和返回结果

​ 跟循环没什么关系,跟方法有关,表示 结束方法 / 返回结果

​ 如果方法执行到了 return ,那么整个方法结束,里面的循环自然会结束

注意事项

  • 方法不调用就不执行
  • 方法的编写顺序和执行顺序无关,看调用顺序

  • 方法不能嵌套定义,方法与方法之间是平级关系

    示例代码：

    public class MethodDemo {
    public static void main(String[] args) {

    }

    public static void methodOne() {
		public static void methodTwo() {
       		// 这里会引发编译错误!!!
    	}
    }
}

  • void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

    示例代码：

    public class MethodDemo {
    public static void main(String[] args) {

    }
    public static void methodTwo() {
        //return 100; 编译错误，因为没有具体返回值类型
        return;	
        //System.out.println(100); return语句后面不能跟数据或代码
    }
}
  • return 语句下面,不能编写代码,因为永远无法执行,属于无效代码

通用格式

  • 格式：

    public static 返回值类型 方法名(参数) {
   方法体; 
   return 数据 ;
}

  • 解释：

    public static 修饰符，目前先记住这个格式

    返回值类型 方法操作完毕之后返回的数据的数据类型

    ​ 如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return

    方法名 调用方法时候使用的标识

    参数 由数据类型和变量名组成，多个参数之间用逗号隔开

    方法体 完成功能的代码块

    return 如果方法操作完毕，有数据返回，用于把数据返回给调用者

  • 定义方法时，要做到两个明确

    明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型

    明确参数：主要是明确参数的类型和数量

  • 调用方法时的注意：

    void类型的方法，直接调用即可

    非void类型的方法，推荐用变量接收调用

方法重载

方法重载概念

​ 在同一个类中，定义了多个同名的方法,这些同名的方法具有同种的功能。

​ 每个方法具有不同的参数类型或参数个数，这些同名的方法，构成了重载关系

  • 多个方法在同一个类中

  • 多个方法具有相同的方法名

  • 多个方法的参数不相同，类型不同或者数量不同

  • 与返回值无关

注意：

​ 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

​ 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

public class Demo1 {
    public static void main(String[] args) {
        int sum1 = add(1,2);
        int sum2 = add(1,2,3);
        double sum3 = add(1.0,2);
        System.out.println(sum1); //3
        System.out.println(sum2); //6
        System.out.println(sum3); //3.0
    }
    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;
    }
}

递归

A方法调用B方法很容易理解!

递归:

​ A方法调用A方法!就是自己调用自己利用

递归可以用简单的程序来解决一些复杂的问题。

​ 它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量

递归的能力在于用有限的语句来定义对象的无限集合。

不太建议使用递归，主要学习思想，如果碰到大基数调用次数过高，性能并不友好，使用别的算法方法来解决

递归结构包括两个部分:
递归头:什么时候不调用自身方法。如果没有头，将陷入死循环
递归体:什么时候需要调用自身方法

public class Demo3 {
    public static void main(String[] args) {
    //阶乘：
        //1!=1
        //2！=2*1
        //3! = 3*2*1
        System.out.println(fun(3));
        //fun(3)---->return 3 * fun(3-1)
        // ---->return 2 * fun(2-1)
        // ---->return 1
    }

    public static int fun(int n) {
        if(n==1){
            return 1;
        }else {
            return n * fun(n-1);
        }
    }
}

方法练习

比较两个整数是否相同

  • 需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）

  • 思路：

    ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数

    ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数

    ③定义所有的重载方法，两个byte类型与两个short类型参数

    ④完成方法的调用，测试运行结果

  • 代码：

    public class MethodTest {
    public static void main(String[] args) {
        //调用方法
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }

    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }

}

数组遍历

  • 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]

  • 思路：

    ①因为要求结果在一行上输出，所以这里需要一个新的输出语句

    ​ System.out.print(“内容”);

    ​ System.out.println(“内容”); 输出内容并换行

    ​ System.out.print(“内容”); 输出内容不换行

    ​ System.out.println(); 起到换行的作用

    ②定义一个数组，用静态初始化完成数组元素初始化

    ③定义一个方法，用数组遍历通用格式对数组进行遍历

    ④用新的输出语句修改遍历操作

    ⑤调用遍历方法

  • 代码：

    public class Test1 {
    public static void main(String[] args) {
      /*  //先打印数据，再进行换行
        System.out.println("aaa");
        //只打印不换行
        System.out.print("bbb");
        System.out.print("ddd");
        //不打印任何内容，只换行
        System.out.println();
        System.out.print("cc");*/
        //设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
        int[] arr = {1,2,3,4,5};
        printArr(arr);
    }
    //1.我要遍历数组
    //2.需要什么？  数组
    //3.调用处是否需要使用方法的结果。
    public static void printArr(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1){
                System.out.println(arr[i] + "]");
            }else{
                System.out.print(arr[i] + ", ");
            }
        }
    }
}

数组最大值

  • 需求：设计一个方法用于获取数组中元素的最大值

  • 思路：

    ①定义一个数组，用静态初始化完成数组元素初始化

    ②定义一个方法，用来获取数组中的最大值

    ③调用获取最大值方法，用变量接收返回结果

    ④把结果输出在控制台

  • 代码：

    public class MethodTest02 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {12, 45, 98, 73, 60};

        //调用获取最大值方法，用变量接收返回结果
        int number = getMax(arr);

        //把结果输出在控制台
        System.out.println("number:" + number);
    }

    //定义一个方法，用来获取数组中的最大值
    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMax(int[] arr) {
        int max = arr[0];

        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }
        return max;
    }
}

获取索引

需求：

​ 定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处，如果有重复的，只要获取第一个即可。

代码示例：

package com.itheima.demo;

public class Test4 {
    public static void main(String[] args) {
        //定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处
        //如果有重复的，只要获取第一个即可

        int[] arr = {1,2,3,4,5};
        int index = contains(arr, 3);
        System.out.println(index);
    }

    //1. 我要干嘛？判断数组中的某一个数是否存在
    //2. 需要什么？数组 数字
    //3. 调用处是否需要继续使用？返回
    //获取number在arr中的位置
    public static int contains(int[] arr, int number) {
        //遍历arr得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //拿着每一个元素跟number比较
            if(arr[i] == number){
                //如果相等，表示找到了
                return i;
            }
        }
        //当循环结束之后，如果还不能返回索引，表示数组中不存在该数据
        //可以返回-1
        return -1;
    }
}

复制数组

需求:
定义一个方法copyOfRange(int[] arr,int from, int to)
功能:
将数组arr中从索引from(包含from)开始。到索引to结束(不包含to)的元素复制到新数组中将新数组返回

//将数组arr中从索引from(包含from)开始
// 到索引to结束(不包含to)的元素复制到新数组中将新数组返回，
public class CopyArray {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] b = copyOfRange(a, 2, 7);
        //遍历新数组
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }
    }

    public static int[] copyOfRange(int[] arr, int from, int to) {
        //定义新数组,长度为 to - from
        int[] newArr = new int[to - from];
        //伪造索引
        int index = 0;
        for (int i = from; i < to; i++) {
            //赋值给新数组 数组名[索引] = 数据值;
            //newArr[i - from] = arr[i];
            newArr[index] = arr[i];
            //索引自增
            index++;
        }
        return newArr;
    }
}

标签：int,System,static,概述,方法,public,out
From： https://www.cnblogs.com/lingxiaoGIS/p/18588391

相关文章

  • windows远程桌面设置，windows远程桌面设置的方法
    对于需要在不同地点访问计算机的用户来说，Windows远程桌面是一个不可或缺的功能。通过正确配置远程桌面，您可以远程操作和管理计算机，甚至在遇到问题时进行故障排查。本文将带您了解如何设置Windows远程桌面以及如何解决在设置过程中可能遇到的挑战。一、服务管理器工具的添加方法......
  • iPhone批量删除照片的方法
    对于每一个iPhone用户来说，照片管理是一项日常而重要的任务。随着时间的积累，无数的照片快速填满了我们的存储空间，从美丽的风景到重要的家庭聚会，每一张照片都记录着我们生活中的瞬间。然而，当存储空间即将耗尽时，iPhone批量删除照片成为了必须要采取的措施。本文将介绍如何在iPhone......
  • 苹果手机可实现无需越狱，随意抹除、刷机的iOS群控操作方法
    每日讲述一个苹果iOS系统实现无需越狱的群控操作方法，通过电脑键盘和鼠标即可实现控制。该方法具有实用性和原生态，能够支持所有型号的苹果手机及iOS11至iOS16系统版本。操作环境纯净，不受环境监测影响，即使手机进行抹除或刷机，也能支持电脑开机后自动连接。群控效果展示免越......
  • 如何使用js去调用vscode-js-debugger的方法去调试网页？
    ......
  • 浅谈网页端IM技术及相关测试方法实践（包括WebSocket性能测试）
    本文由转转QA赵里京分享，原题“浅谈IM与相关测试方法”，下文进行了排版和内容优化。1、引言目前转转的所有业务都在快速增长，支撑其用户服务的客服系统也同样在快速发展，以承接用户每天大量的问题。最开始转转的客服系统体系如IM、工单以及机器人等都是使用第三方的产品。但第三......
  • Android基础的ListView适配器SimpleAdapter的使用方法，附带可修改模板
            本代码使用的Android版本：android-studio-2024.2.1.11-windows目录一、适配器的五个主要参数二、效果图：三、功能实现的代码（模板）：    1.Store主页面：2.item_commodity模板界面：四、结语        本文章还有使用自定义适配器来实现该功能......
  • Mysql基础——Gtid开启方法
    一、Gtid简介GTIDtransactionsareidentifiedbyaglobaltransactionidentifier(GTID)intheformUUID:NUMBER.EveryGTIDtransactioninalogisalwaysprecededbyaGtid_log_event.GTIDtransactionscanbeaddressedusingeithertheGTIDorusingthefile......
  • 元类，类，实例调用__call__方法
    实例可以调用双下划线call方法；类也可以调用双下划线call方法，但二者有大的差别；实例调用双下划线call方法是在实例及类内部查找，如果没有，直接报错TypeError类调用双下划线call方法会在实例中查找元类（type）内部具有__call__方法1. 类调用触发元类的__call__：• 类的调用行为（MyClas......
  • （面试常考）HashMap底层原理 和 Hash冲突的解决方法
    HashMapHashMap底层数据结构底层数据结构：hash表数据结构，即数组+链表|红黑树往HashMap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标存储时，当出现hash相同的key如果key相同，则覆盖原始值如果key不相同（hash冲突），则将当前数据放入链表或红黑树中......
  • 写一个方法实现自定义右键菜单的功能
    functioncreateCustomContextMenu(menuItems){//隐藏浏览器默认右键菜单document.addEventListener('contextmenu',(event)=>{event.preventDefault();});//创建自定义菜单元素constcontextMenu=document.createElement('div');contextM......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99