2021-09-29

Java方法

Java方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用
  设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样有利于后期扩展。

---

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段。一般情况下，一个方法包含以下语法：
方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

• 修饰符:修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
• 返回值类型:方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下，returnValueType 是关键字void.
• 方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
• 方法体：方法体包含具体的语句，定义该方法的功能。
• 参数类型:参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指
  方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
  • 形式参数：在方法被调用时用于接收外界输入的数据。
  • 实参：调用方法时实际传给方法的数据。

修饰符 返回值类型 方法名（参数类型 参数名）{
	...
	方法体
	...
	return 返回值；
}

案例：

package com.wang.method;

public class Demo01 {
    public static void main(String[] args) {
        int num=max(5,8);
        System.out.println(num);
    }

    //比大小
    public static int max(int a,int b){
        int maxnum = 0;
        if(a==b){
            System.out.println("两个数相等");
            return 0;  //终止方法
        }else if(a>b){
            maxnum=a;
        }else{
            maxnum=b;
        }
        return maxnum;
    }
}

方法调用

调用方法:对象名.方法名(实参列表)
◆Java支持两种调用方法的方式，根据方法是否返回值来选择。
◆当方法返回一个值的时候，方法调用通常被当做一个值。例如:

int larger = max(30，40);

◆如果方法返回值是void,方法调用一定是一条语句。

System. out . println( "Hello, world!");

◆值传递和引用传递：

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。
◆方法的重载的规则:

• 方法名称必须相同。
• 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
• 方法的返回类型可以相同也可以不相同。
• 仅仅返回类型不同不足以成为方法的重载。
  实现理论:方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

可变参数

JDK 1.5开始，Java支持传递同类型的可变参数给一个方法。
在方法声明中，在指定参数类型后加一个省略号(…)的
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它
之前声明。

package com.wang.method;

public class Demo02 {
    public static void main(String[] args) {
        Demo02 demo02=new Demo02();
        demo02.test(1,2,3,4,6,7,9);
    }

    public void test(int x,int... i){
        System.out.println(x);
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
    }
}

递归（重难点）

◆A方法调用B方法，我们很容易理解!
◆递归就是: A方法调用A方法!就是自己调用自己
◆利用递归可以用简单的程序来解决一些复杂的问题。 它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。
◆递归结构包括两个部分:
◆递归头:什么时候不调用自身方法。如果没有头，将陷入死循环。
◆递归体:什么时候需要调用自身方法。

数组

数组的定义

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] array;//首选的方法
或
dataType array[];//效果相同，但不是首选方法

Java语言使用new操作符来创建数组，语法如下：

dataType[] array=new dataType[arraySize];

数组的元素是通过索引访问的，所以数组索引从0开始。

获取数组长度：

array.length

例子：

package com.wang.array;

public class Demo01 {
    //变量类型  变量名字 = 变量的值;
    public static void main(String[] args) {
        int[] nums;  //1.定义
        nums=new int[10];  //2.创建一个数组，这里面可以存放10个int类型的数字
        //3.给数组元素中赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
        //System.out.println(nums[0]);
        //计算所有元素的和
        int sum=0;
        for (int i = 0; i <nums.length ; i++) {
            sum+=nums[i];
        }
        System.out.println(sum);
    }
}

三种初始化及内存分析

内存分析

Java内存分析：

三种初始化

静态初始化：创建+赋值

int[] a={1,2,3};Man[] mans={new Man(1,1),new Man(2,2)};

动态初始化：包含默认初始化

int[] a=new int[2];a[0]=1;a[1]=2;

数组的默认初始化

​ 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

数组的四个基本特点+数组边界

四个 基本特点：

◆其长度是确定的。数组一-旦被创建，它的大小就是不可以改变的。
◆其元素必须是相同类型,不允许出现混合类型。
◆数组中的元素可以是任何数据类型，包括基本类型和引用类型。
◆数组变量属引用类型，数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型,数组对象本身是在堆中的。

数组边界：

下标的合法区间：[0，length-1]，如果越界就会报错；

ArrayIndexOutOfBoundsException :数组7下标越界异常!

小结

数组是相同数据类型(数据类型可以为任意类型)的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度的确定的，不可变的。如果越界，则报: ArrayIndexOutofBounds

数组使用

普通for循环

For-Each循环

数组作方法入参

数组作返回值

package com.wang.array;

public class Demo02 {
    public static void main(String[] args) {
        int[] arrays={1,2,3,4,5};

        //增强for循环，遍历数组
        /**
        for (int array : arrays) {
            System.out.println(array);
        }
         */
       // printArray(arrays);
        int[] reverse=reverse(arrays);
        printArray(reverse);
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.println(arrays[i]+" ");
        }
    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result=new int[arrays.length];
        for (int i = 0,j=result.length-1; i <arrays.length ; i++,j--) {
            result[j]=arrays[i];
        }
        return result;
    }
}

多维数组

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

二维数组：

int a[][]=new int[2][5];

解析：以上二维数组a可以看成是一个两行五列的数组。

多维数组的使用

package com.wang.array;

public class Demo03 {
    public static void main(String[] args) {
        int[][] array={{1,2},{2,3},{3,4},{4,5}};
       // printArray(array[0]);
        //System.out.println(array[2][1]);
        for (int i = 0; i <array.length ; i++) {
            for (int j = 0; j <array[i].length ; j++) {
                System.out.print(array[i][j]+" ");
            }
        }
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
}

Arrays类

◆数组的工具类java.util.Arrays
◆由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使
用,从而可以对数据对象进行一-些基本的操作。
◆查看JDK帮助文档
◆Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用,而"不
用"使用对象来调用(注意:是"不用"而不是"不能")
具有以下常用功能:
给数组赋值:通过fill方法。
◆对数组排序:通过sort方法,按升序。
◆比较数组:通过equals方法比较数组中元素值是否相等。
◆查找数组元素: 通过binarySearch方法能对排序好的数组进行二分查找法操作。

package com.wang.array;

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        int[] a={1,2,3,4,78676,43,565,43,3436,6767,38};
        //System.out.println(a);  //[I@5fd0d5ae
        //打印数组元素Arrays.toString
       //System.out.println(Arrays.toString(a));
        //printArray(a);

        Arrays.sort(a);  //数组重新排序:升序
        System.out.println(Arrays.toString(a));

        //Arrays.fill(a,0);
        //System.out.println(Arrays.toString(a));

        Arrays.fill(a,2,4,0);
        System.out.println(Arrays.toString(a));
    }
    //打印数组元素
    public static void printArray(int[] a){
        for (int i = 0; i <a.length ; i++) {
            if (i==0) {
                System.out.print("[");
            }
            if(i==a.length-1){
                System.out.print(a[i]+"]");
            }else {
                System.out.print(a[i]+",");
            }
        }
    }
}

冒泡排序

排序算法总共有八大排序，冒泡排序的代码相对简单，两层循环，外层冒泡轮数，里层依次比较，该算法的时间复杂度为O(n2)。

设置flag进行优化

package com.wang.array;

import java.util.Arrays;

//冒泡排序
//1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，则交换两个数位置
//2.每一次比较，都会产生一个最大或者最小的数字
//3.下一轮则可以少一次排序
//4.依次循环，直到结束
public class Demo05 {
    public static void main(String[] args) {
        int[] a={34,34,45,12,456,12,676,3,56,7,44,788};
        int[] sort=sort(a);
        System.out.println(Arrays.toString(sort));
    }

    public static int[] sort(int[] array){
        //临时变量
        int temp=0;
        //外层循环，判断要走多少次
        for (int i = 0; i <array.length-1 ; i++) {
            boolean flag=false;  //通过flag标识位减少没有意义的比较
            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置
            for (int j = 0; j <array.length-1-i ; j++) {
                if(array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
        return array;
    }
}

稀疏数组

需求：编写五子棋游戏中，有存盘退出和续上盘的功能。

分析：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。

解决方法：稀疏数组

稀疏数组介绍

◆当- 个数组中大部分元素为0,或者为同- -值的数组时，可以使用稀疏数组来保存该数组。
◆稀疏数组的处理方式是:
◆记录数组一共有几行几列，有多少个不同值
◆把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
◆如下图:左边是原始数组，右边是稀疏数组

package com.wang.array;

public class Demo06 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11   0：没有棋子，1：黑棋，2：白棋
        int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("-------------------------------------");
        //转换为稀疏数组保存
        //1.获取有效值的个数
        int sum=0;
        for (int i = 0; i <11 ; i++) {
            for (int j = 0; j <11 ; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数"+sum);
        //2.创建一个稀疏数组的数组
        int[][] array2=new int[sum+1][3];
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
        //遍历二维数组，将非0的值存放在稀疏数组中
        int count=0;
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1[i].length ; j++) {
                if(array1[i][j]!=0){
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i <array2.length ; i++) {
            System.out.println(array2[i][0]+"\t"+array2[i][1]+"\t"+array2[i][2]+"\t");
        }
        System.out.println("-------------------------------------");
        System.out.println("还原稀疏数组");
        //1.读取稀疏数组
        int[][] array3=new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i <array2.length ; i++) {
            array3[array2[i][0]][array2[i][1]]=array2[i][2];
        }
        //3.打印
        System.out.println("输出还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
    }
}```