黑马程序员——2.2.基础语法（函数、重载、数组、内存划分，进制转换）

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

函数：

函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法。

函数格式：

    修饰符 返回值类型 函数名(参数类型 形式参数1；参数类型 形式参数2)
    {
        执行语句;
        return 返回值;
    }

1. 返回值类型：函数运行后的结果的数据类型
2. 参数类型：是形式参数的数据类型
3. 形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数
4. 实际参数：传递给形式参数的具体数值
5. return：用于结束函数
6. 返回值：该值会返回给调用者

函数的特点

1. 定义函数可以将功能代码进行封装。
2. 便于对该功能进行复用。
3. 函数只有被调用才会被执行。
4. 函数的出现提高了代码的复用性。

P.S.

1. 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写，或者写上return;。
2. 函数中只能调用函数，不可以在函数内部定义函数。否则，编译时期就会报错。
3. 定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的重载：

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

重载的好处：
方便于阅读，优化了程序设计。

P.S.

1. 重载与返回值类型无关，只看参数列表。
2. java是严谨性语言，如果函数调用出现不确定性，会编译失败。

class FunctionDemo{
       public static void main(String[] args){
             System.out.println(add(3,4));
             System.out.println(add(3.0,4.0));
             System.out.println(add(3,4,5));
      }

       //加法运算，两个整数的和
       public static int add(int a, int b){
             return a + b;
      }

       //加法运算，两个小数的和
       public static double add(double a, double b){
             return a + b;
      }

       //加法运算，三个整数的和
       public static int add(int a, int b,int c){
             return add(a,b) + c;
      }
}

数组

数组就是同一种类型数据的集合。其实，数组就是一个容器。

数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：需要一个容器，但是不明确容器的具体数据。
    元素类型[] 数组名 = new 元素类型[元素个数];

格式2：需要一个容器，存储已知的具体数据。
    元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

内存的划分：

1. 寄存器。
2. 本地方法区。
3. 方法区。
4. 栈内存。
5. 堆内存。

栈内存：
同于存储局部变量、基本类型的变量和对象的引用变量，数据使用完会自动释放所占空间。
一个函数分配一个栈内存空间，该栈内存空间中数据可以共享。

堆内存：
数组和对象，通过new建立的实例都存放在堆内存中，每一个实体都有内存地址值，实体中的变量都有默认初始化值，实体不再使用时，会在不确定的时间内被垃圾回收器回收

方法区：
存放的是整个程序中唯一的元素，如class和静态变量，代码、函数的解析也是在此进行

数组的引用放在栈内存中，实体数据存储在堆内存中。引用指向实体数据。

数组排序：

选择排序：

使用嵌套循环的方式，让头角标上的元素按顺序分别与后面的元素进行比较，符合条件就调换位置，使得头角标始终为较小或较大的元素，这为第一圈，第一圈完成后最值位于头角标处。

第二圈由第二位的元素与后面的元素进行比较，第二圈完成后第二最值位于第二位置上……以此类推循环直到只剩下最后位，排序完成。

选择排序最值在头位。

public static void selectSort(int[] arr)
{   
    for (int x=0; x<arr.length-1 ; x++)//第(x+1)圈循环
    {   
        for(int y=x+1; y<arr.length; y++)//在第(x+1)圈时让第x角标位上的元素分别与后面元素进行比较
        {   
            if(arr[x]>arr[y])//符合条件就调换位置
            {
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y]= temp;
            }
        }
    }
}

冒泡排序：

也是使用嵌套循环的方式，先让头角标的元素与第二位元素进行比较，符合条件则换位，接着第二位元素与第三位元素进行比较，符合条件则换位……到达末尾时最值存在于末位上，第一圈完成。

第二圈也是从头角标开始，到达倒数第二位，此时第二最值位于倒数第二位……以此类推，到只剩下头位元素时循环结束，排序完成。

冒泡排序最值在末尾。

public static void bubbleSort(int[] arr)
{   
    for(int x=0; x<arr.length-1; x++)//第(x+1)圈循环
    {   
        for(int y=0; y<arr.length-x-1; y++)//在第(x+1)圈时让0角标位元素开始与相邻元素进行比较，到（数组长度-x-1）角标处结束
        {   
            if(arr[y]<arr[y+1])//符合条件就调换位置
            {   
                int temp = arr[y];
                arr[y] = arr[y+1];
                arr[y+1] = temp;
            }
        }
    }
}

实际开发中，有Arrays.sort(arr)可以直接进行数组排序

折半查找：

提高效率，但是必须要保证该数组是有序的数组。

思路：

1. 设置三个变量记录角标：min、max、mid。min初始值为0，max为数组最大角标，mid为（max+min）/2。
2. 查看mid角标的元素是否与待查找的值相等，如果相等，则直接返回角标值，程序终止执行。
3. 如果待查找的值小于角标为mid的元素值，那么说明待查找的元素的位置可能在min与mid角标之间。设置max = mid - 1，mid = (max + min)/2，重复第1、2步的操作。
4. 如果待查找的值大于角标为mid的元素值，那么说明待查找的元素的位置可能在mid与max角标之间。设置min = mid + 1，mid = (max + min)/2，重复第1、2步的操作。
5. 如果数组中不存在待查找的元素，那么按照如上流程，最终min角标值会大于max角标值，此时返回-1。

class ArrayDemo{
       public static void main(String[] args) {
         int[] arr= {13,15,19,28,33,45,78,106};
         int index = binarySearch(arr,78);
         System.out.println("index = " + index);
      }

      public static int binarySearch(int[] arr, int key){
            int max,min,mid;
            min = 0;
            max =arr. length - 1;
            mid = (max + min)/2;

             //判断中间值是否为要找的数
             while(arr[mid] !=key){

                   //不是的话，判断key在哪个区域
                   if(key > arr[mid])
                        min = mid + 1;
                   else if (key < arr[mid])
                        max = mid - 1;

                   //如果max<min，说明key不存在于数组中，返回-1
                   if(max < min)
                         return -1;

                  //再找出该区域的中间值
                  mid = (max + min)/2;
            }
            return mid;
     }
}

int x = Arrays.binarySearch(arr,190);//java提供好的一个进行折半查找的功能。开发时使用这个。

进制转换：

十进制转十六进制

查表法：

public static void toHex(int num)
{
    //定义一个临时容器。
    char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

    char[] arr = new char[8];
    int pos = arr.length;

    while(num!=0)
    {   
        //&15得到最后4个二进制位的值
        int temp = num & 15;
        //System.out.println(chs[temp]);

        //4个二进制位刚好是1个十六进制位，可以得到十六进制位的最后一位
        arr[--pos] = chs[temp];

        //把数右移4位，再得到接下来的值
        num = num >>> 4;
    }
    System.out.println("pos="+pos);

    //存储数据的arr数组遍历。
    for(int x=pos;x<arr.length; x++)
    {   
        System.out.print(arr[x]+",");
    }
}

二维数组：

二维数组[][]

格式1：
int[][] arr = new int[3][2];

1. 定义了名称为arr的二维数组。
2. 二维数组中有3个一维数组。
3. 每一个一维数组中有2个元素。
4. 一维数组的名称分别为arr[0], arr[1], arr[2]。
5. 给第一个一维数组第一个脚标位赋值为78写法是：arr[0][1] = 78;。
6. arr存储的是二维数组的初始地址，arr[0]、arr[1]、arr[2]存储的是一维数组的初始地址。

class Array2Demo
{
     public static void main(String[] args){
        int[][] arr = new int[3][2];

         //直接打印二维数组
        System.out.println(arr);

         //直接打印二位数组中的角标为0的一维数组
        System.out.println(arr[0]);

         //直接打印二维数组中的角标为0的一维数组的角标为0的元素
        System.out.println(arr[0][0]);
    }
}

格式2：
int[][] arr = new int[3][];

二维数组中有3个一维数组，每个一维数组都是默认初始化值null，可以对这个三个一维数组分别进行初始化。
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];

格式3：
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

定义一个名称为arr的二维数组，二维数组中的有三个一维数组，每一个一维数组中具体元素也都已初始化。
第一个一维数组 arr[0] = {3,8,2};，第二个一维数组 arr[1] = {2,7};，第三个一维数组 arr[2] = {9,0,1,6};。
第三个一维数组的长度表示方式：arr[2].length;。

/*
求二维数组所有元素的和
*/

class Array2Demo
{
    public static void main(String[] args){
        int sum = 0;
        int[][] arr = {{3,1,7},{5,8,2,9},{4,1}};

        for(int x = 0; x < arr.length; x++){
            for(int y = 0; y < arr[x].length; y++){
                sum += arr[x][y];
            }
        }
        System.out.println("sum = " + sum);
    }
}