Java基础回顾_Java方法详解

发布于 2021-5-13 10:44
浏览
0收藏

Java基础回顾_Java方法详解


何谓方法?

 

  • Java方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建,在其它地方被引用


设计方法的原则:方法的本意是功能块,就是实现某个功能的语句块的集合。我们设计方法的时候,最好保持方法的原子性,就是一个方法只能完成一个功能,这样利于我们后期的发展。

 
个人随笔:

 

  1. 方法命名遵循 小驼峰原则
  2. main方法尽量保持简洁、干净
  3. 方法其实就是C语言里的函数,方法遵循原子性,即一个方法只完成一件事
  4. 有些方法没有return返回值,于是方法体就不需要写返回值类型,这个时候就要用 void 替代 返回值类型
  5. 有参数的方法一定要有return返回值,没有参数的方法即void方法就不需要return返回值
  6. 参数类型这里得注意:参数类型分为形式参数 和 实参(或称为变量)。

 

​ 形式参数:形参就是创建方法的时候我个人定义的像 int a, int b 这样的,没有实际值,等着调用的时候再往里传具体值的参数,相当于占位符,先把位置占着,用的时候再给它其他的值;

 

​ 实参(或称为变量):方法在被调用的时候直接给参数赋值,像add( 1, 2);这种里面的 1和2 就是实参。
 
代码格式:

​ 修饰符 + 返回值类型 + 自定义方法名 + ( 参数类型 + 参数名--->”参数可以定义一个或者多个“ ){

//执行的代码语句,即方法体

​ return + 返回值;

}

例如:下面的add方法(加法):

​ public int add( int a, int b ){

​ return a+b;

}

个人随笔:

 

1、有时候用return 0;去终止方法。
2、方法的带你用:用对象名去点方法名,例如:对象名.方法名(实参列表)
拓展了解:值传递和引用传递

Java都是值传递!只有值传递!

 
方法的重载


个人练习:

 

结合Scanner对象,完成手动输入两个整数打印最小值;以及直接注入三个整数然后得到三个整数中最小的那个。

这两个方法的方法名都是min,但是它们的参数列表不一样,一个是两个变量(实参),一个是3个变量(实参)!!!!妙啊!!!

public class Demo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请依次输入要比较的两个整数:");
        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int min = min(a, b);
        System.out.println("输入的两个整数中较小的那个整数是:"+min);
        int min1 = min(6, 8, 3);
        System.out.println("三个整数中最小的整数是:"+min1);
    }
    public static int min(int a,int b){
        int minNumber;
        if (a<b){
            minNumber = a;
        }else {
            minNumber = b;
        }
        return minNumber;
    }
    //重载的取最小值的方法,但是参数列表不一样,多了一个参数
    public static int min(int a,int b,int c){
        int minNumber;
        if (a<b){
            minNumber = a;
        }else {
            minNumber = b;
        }
        if(minNumber<c){
            return minNumber;
        }else {
            minNumber=c;
        }
        return minNumber;
    }
}

Java基础回顾_Java方法详解-开源基础软件社区

方法重载的规则:

 

1、方法名称必须一模一样
2、参数列表必须不同,即参数的个数不同、或参数的类型不同、或参数的排列顺序不同等
3、方法的返回值类型可以相同,也可以不相同,但是仅仅只有返回值类型不同也不行


个人随笔:

 

当编写了重载的方法的时候,再去调用这些方法名相同的方法的时候,编译器它自己会根据参数列表的差异去一个方法一个方法的找,知道找到对应的方法,如果找不到,它就会报错!

 
命令行传参(不经常使用)


有时候你希望运行一个程序的时候,再传递给它消息。这个时候就要靠传递命令行参数给main()函数去实现。
 
可变参数


什么是可变参数?

 

有时候根据实际需求,可能需要用方法重载去编写 几十个甚至上百个 方法名相同,参数链表不同 的方法,这样也太离谱了,这时候就诞生了可变参数 这种东西,它解决了上述问题!妙啊!!!!!!

用法:在参数列表中的参数声明的参数类型后面加上一个省略号,例如:

利用可变参数,自定义任意的数据传入方法,取得最大值!

public class Demo01 {
    public static void main(String[] args) {
        printMax(1,5,3,4,6,8,2,3,9,6,4);
        printMax(new double[]{1,2,3});
    }
    public static void printMax(double... numbers){
        if (numbers.length == 0){
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];

        //排序!
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The max Value is " + result);
    }
}

Java基础回顾_Java方法详解-开源基础软件社区

递归(重点)


递归就是:A方法调用A方法,即自己调用自己!递归是一种思想!

递归结构包括两个部分:

  1. 递归头: 就是有一串可以停止调用方法(函数)的 代码,让程序不会无限循环运行!
  2. 递归体:
    友情提示:能不用递归就不用递归,因为如果调用方法次数过多,会非常占用资源,影响性能!

 
个人练习:

写一个计算器,要求实现加减乘除功能,并且能循环接收新的数据,通过用户交互实现(即Scanner对象)

用到了 while循环 switch语句,实现了数据的循环输入并计算!!!!妙啊!!!!

import java.util.Scanner;

public class Calculator{
    public static void main(String[] args) {
        //创建对象用来调用对象里的方法
        Calculator calculator = new Calculator();
        //调用computer方法
        calculator.computer();
    }
    //第一步:加减乘除四个方法(因为要循环计算,每次传入一个数字,所以参数列表应该只有一个参数)
    //加法
    public static double add(double a){
        System.out.println("请输入一个数:");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a+b;
    }
    //减法
    public static double subtract(double a){
        System.out.println("请输入一个数:");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a-b;
    }
    //乘法
    public static double multiply(double a){
        System.out.println("请输入一个数:");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a*b;
    }
    //除法
    public static double divide(double a){
        System.out.println("请输入一个数:");
        Scanner scanner3 = new Scanner(System.in);
        double b = scanner3.nextDouble();
        return a/b;
    }

    //第二步:完成循环输入数据的功能(while(true)+switch),必须创建一个方法完成这一步
    public void computer(){
        System.out.println("请输入一个数:");
        Scanner scanner1 = new Scanner(System.in);
        double a = scanner1.nextDouble();

        while(true){
            Scanner scanner2 = new Scanner(System.in);
            System.out.println("你可以输入的操作有:加(+)减(-)乘(*)除(/)清零(小写的c)结束(小写的end)--->");
            String str = scanner2.nextLine();
            switch (str){
                case "+":
                    a = add(a);
                    System.out.println("="+a);
                    break;
                case "-":
                    a = subtract(a);
                    System.out.println("="+a);
                    break;
                case "*":
                    a = multiply(a);
                    System.out.println("="+a);
                    break;
                case "/":
                    if (a == 0){
                        System.out.println("除法分子不能为零,请重新输入:");
                        break;
                    }
                    a = divide(a);
                    System.out.println("="+a);
                    break;
                case "c":
                    computer();
                    break;
                case "end":
                    System.exit(-1);
                    break;
                default:
                    System.out.println("输入的字符有误!");
            }
        }
    }

}

Java基础回顾_Java方法详解-开源基础软件社区

Java基础回顾_Java方法详解-开源基础软件社区

 

数组


什么是数组 ?

数组是相同类型 数据的有序组合。

数组的声明创建
首先必须声明数组变量,才能在程序中使用数组。

int[] nums;//建议选择这种声明数组变量的格式;
int nums2[];//不建议使用这种格式;这是c和c++里的格式,早些年为了程序员能快速掌握Java所以也有这种声明数组变量的格式

 

创建一个数组

int[] nums;//建议选择这种声明数组变量的格式;
int nums2[];//不建议使用这种格式;
nums = new int[10];//这里可以存放10个int类型的元素

//创建数组,一步到位
double[] nums3 = new double[10];
System.out.println(nums3.length);//输出nums3的数组长度

数组的内存分析
略...

 
数组的三种初始化:

静态初始化----------------------------->在声明数组的时候就直接给数组赋值------>int[] a = {1,2,3,4,5};
动态初始化----------------------------->在声明数组之后,再给数组赋值------>int[] a = new int[5]; a[0]=1; a[1]=2; a[2]=3; a[3]=4; a[4]=5;
数组的默认初始化-------------------->在声明数组之后,数组里的元素默认为0------>int[] a = new int[5];//a= {0,0,0,0,0}
 
数组的四个基本特点


数组被创建之后,长度就不能改变了;
数组中所有的元素必须是同一数据类型;可以是任意数据类型,包括基本类型和引用类型;
数组中的变量属于引用类型,我们用的时候就去点它,数组也可以看成是对象,其中的没个元素都相当于是该对象的成员变量;
数组本身就是对象,Java中的对象都在堆中,所以数组对象本身是在堆中的。
 
数组边界


数组下标从0开始到数组长度减一,如果下标超了,就会报错:ArrayIndexOutofBounds--------->数组下标越界异常

 
数组使用


For-Each 循环
数组当作参数传入方法中
数组当作返回值返回

 

多维数组

int[][] a = {{1,2},{3,4},{8,9}};//这是一个二维数组

个人理解:多维数组就是不停的套娃!妙啊!!!!!!!!!!!

 
Arrays类


Arrays.toString(数组名称);//可以打印出数组所有数组元素;
Arrays.sort(数组名称);//可以对数组排序:升序(从小到大)
Arrays.fill(数组名称,想要填充的值);//可以对数组进行填充:所有元素都会被想要填充的值给替换
Arrays.fill(数组名称,3,8,想要填充的值);//只有数组下标为3到8的元素被替换
 
八大排序


个人理解:

冒泡排序:比较数组中两个相邻的元素,如果右边的元素比左边的小,则它们交换位置,达到左边的元素永远比右边的元素小的效果;从右往左比较,这样每个数都能被比较到,由于每次都将较小的移到了左边,所以每比较完一轮,下一轮又从最右边往最左边比较的时候,就可以少比较一次(比如有5个元素,每次比较两个元素的话,一轮就需要比较4次,第二轮就只需要比较3次,第三轮就只需要比较2次,第四轮就需要比较1次,然后就排好顺序了);--------------->时间复杂度为O(n的2次方)。

public class Demo01 {
    public static void main(String[] args) {
        int[] array2 ={1,4,8,3,5,9,2};
        System.out.println(Arrays.toString(fun1(array2  )));
    }
    //编写一个给数组冒牌排序的方法,参数为数组
    public static int[] fun1(int[] array1){
        //声明一个用来给两个相邻元素交换位置的变量
        int t = 0;

        for (int i = 0; i < array1.length-1; i++) {
            for (int j = 0; j < array1.length-1-i; j++) {
                if (array1[j+1]<array1[j]){
                    t = array1[j];
                    array1[j] = array1[j+1];
                    array1[j+1] = t;
                }
            }
        }
        return array1;

 

稀疏数组


创建一个数组,打印出它的稀疏数组,并通过稀疏数组打印出原数组!!!!!!

public class Demo01 {
    public static void main(String[] args) {
        //二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;

        for (int[] ints : array) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
        //将上面的二维数组转换为稀疏数组保存起来
        //获取有效值的个数
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i][j] != 0){
                    count ++;
                }
            }
        }
        System.out.println("该二维数组中有效值的个数为:"+ count);

        //稀疏数组
        //第一步:创建一个二维数组,称之为稀疏数组
        int[][] array1 = new int[count+1][3];//有效值+1就是稀疏数组的行数,列固定为3列
        //第二步,给这个稀疏数组加入第一行应该展示的数据;
        array1[0][0] = array.length;//原数组的行数
        array1[0][1] = array.length;//原数组的列数
        array1[0][2] = count;//原数组中有效值 的个数

        //第三步:给稀疏数组赋值
        int count1 = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    count1++;
                    array1[count1][0] = i;
                    array1[count1][1] = j;
                    array1[count1][2] = array[i][j];

                }
            }
        }
        //第四步:打印输出数组
        System.out.println("原数组array的稀疏数组array1如下所示:");
        //遍历输出稀疏数组array1
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
//        for (int i = 0; i < array1.length; i++) {
//            System.out.println(array1[i][0]+"\t"+array1[i][1]+"\t"+array1[i][2]);
//        }

        System.out.println("将稀疏数组还原成原数组:");
        //将稀疏数组还原成原数组
        //第一步:用稀疏数组中第一行的值去创建一个二维数组,用来显示原数组
        int array2[][] = new int[array1[0][0]][array1[0][1]];//确定数组为几行几列
        //确认数组的大小后,就要通过稀疏数组中描述的原数组的有效值传入array2中
        for (int i = 1; i < array1.length; i++) {
            array2[array1[i][0]][array1[i][1]] = array1[i][2];
        }
        //第二步:打印array2数组
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.print("\n");
        }
    }

}

将上面的代码写为两个方法:数组转稀疏数组的方法,和,稀疏数组转原数组的方法:

public class Demo01 {
    public static void main(String[] args) {
        //二维数组
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
        System.out.println("数组array的稀疏数组为:" );
        sparseArray(array);

        int[][] array1 = new int[3][3];
        array1[0][0] = 11;array1[0][1] = 11;array1[0][2] = 2;
        array1[1][0] = 1;array1[1][1] = 2;array1[1][2] = 1;
        array1[2][0] = 2;array1[2][1] = 3;array1[2][2] = 2;

        System.out.println("稀疏数组array1的原数组为:" );
        sparseArrayToArray(array1);

    }

    /**
     * 数组 转为 稀疏数组
     * @param array
     */
    public static void sparseArray(int[][] array){
        //将上面的二维数组转换为稀疏数组保存起来
        //获取有效值的个数
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if(array[i][j] != 0){
                    count ++;
                }
            }
        }
        //稀疏数组
        //第一步:创建一个二维数组,称之为稀疏数组
        int[][] array1 = new int[count+1][3];//有效值+1就是稀疏数组的行数,列固定为3列
        //第二步,给这个稀疏数组加入第一行应该展示的数据;
        array1[0][0] = array.length;//原数组的行数
        array1[0][1] = array.length;//原数组的列数
        array1[0][2] = count;//原数组中有效值 的个数

        //第三步:给稀疏数组赋值
        int count1 = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if(array[i][j] != 0){
                    count1++;
                    array1[count1][0] = i;
                    array1[count1][1] = j;
                    array1[count1][2] = array[i][j];

                }
            }
        }
        //第四步:打印输出数组

        //遍历输出稀疏数组array1
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.print("\n");
        }
    }

    /**
     * 稀疏数组 转为 数组
     * @param sparseArray
     */
    public static void sparseArrayToArray(int[][] sparseArray){

        //将稀疏数组还原成原数组
        //第一步:用稀疏数组中第一行的值去创建一个二维数组,用来显示原数组
        int array2[][] = new int[sparseArray[0][0]][sparseArray[0][1]];//确定数组为几行几列
        //确认数组的大小后,就要通过稀疏数组中描述的原数组的有效值传入array2中
        for (int i = 1; i < sparseArray.length; i++) {
            array2[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
        }
        //第二步:打印array2数组
        for (int[] ints : array2) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.print("\n");
        }
    }

}

 

果断就会白给,犹豫就会败北,坚持才是胜利!!!

已于2021-5-13 10:44:09修改
1
收藏
回复
举报
回复
添加资源
添加资源将有机会获得更多曝光,你也可以直接关联已上传资源 去关联
    相关推荐