java基础（三）

方法的定义

• Java的方法类似其它的函数，是一段用来完成特定的功能的代码片段

• 方法包含一个方法头和一个方法体。

  1.修饰符：这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

  2.返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。

  在这种情况下，returnValueType是关键字void。

  3.方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

  4.参数类型：参数像是一个占位符，当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的

  参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

  1. 形式参数：在方法被调用于接收外界输入的数据。
  2. 实参：调用方法时实际传给方法的数据。

  5.方法体：方法体包含具体的语句，定义该方法的功能

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RxP2IQVt-1596903552706)(C:\Users\10560\AppData\Roaming\Typora\typora-user-images\image-20200806171612443.png)]

方法的重载

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数。

• 方法的重载的规则：

• • 方法名必须相同。
  • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
  • 方法的返回类型可以相同也可以不相同。
  • 仅仅返回类型不同不足以成为方法的重载。

• 实现理论

  • 方法名称相同时，编译器会根据调用方法的参实个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

可变参数

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

java内存分析

• 堆

  • 存放new的对象和数组
  • 可以被所有的线程共享，不会存放别的对象引用

• 栈

  • 存放基本变量类型（会包含这个基本类型的具体数值）
  • 引用对象的变量（会存放这个引用在堆里面的具体地址）

• 方法区

  • 可以被所有的线程共享
  • 包含了所有的class和static变量

数组

• 静态初始化

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,lenght-1],如果越界就会报错；

public static void main(String[] args) {
    int[] a = new int[2];
    sout(a[2]);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VJonL0Zx-1596903552708)(C:\Users\10560\AppData\Roaming\Typora\typora-user-images\image-20200806231053041.png)]

• 小结：
  • 数组是相同数据类型（数据类型可以任意类型）的有序集合
  • 数组也是对象。数组元素相当对象的成员变量
  • 数组长度的确定的，不可变的。如果越界，则报： ArraylndexOutofBounds

//反转数组 arrays数组
	//正常 main方法调用 int[] reverse = reverse();
public static int[] reverse(int[] arrays){
    int[] result = new int[arrays.lenght];
    //反转操作
    for(int i = 0,j=result.lenght-1; i < arrays.length; i++,j--){
        result[j] = arrays[i];
    }
    
    return result;
}
//打印数组元素
public static void printArray(int[] arrays){
    for(int i = 0; i < arrays.lenght; i++){
        sout(arrays[i]+" ")
    }
}

多维数组就是一堆数组 TCP/IP

冒泡排序 八大排序

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+1] < array[j]）{
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
                flag = true;
            }
        }
        if(flag == false){
            break;
        }
    }
    return array;
}

稀疏数组

///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("=======================");

        //转换为了稀疏数组保存
        //获取有效值的个数
        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.创建一个稀疏数组的数组 3的意思是  行 列 值
        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.给其中的元素还原它的值 因为1开始 少了一层
        for(int i = 1;i < array2.length; i++){
            array3[array2[i][0]][array2[i][0]] = array2[i][2];
        }

        //3.打印
        System.out.println("输出还原的数组");

        for(int[] ints : array3){
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }