Java基础--第六天

1：函数
　　(1)定义在类中，有特定功能的一段小程序。
　　(2)函数的格式：
　　　　修饰符 返回值类型 函数名(形参类型 形式参数1,形参类型 形式参数2...)
　　　　{
　　　　　　函数体;
　　　　　　reutrn 返回值;
　　　　}

/*
    函数定义：
        黑屏运行时，按任意键就可以退出；
        也可以使用exit命令退出
    函数的调用：
        单独调用--无返回值
        赋值调用--常用，返回值
        输出调用--演示
    函数的结束：
        函数其实是以return结束；
        函数执行完全，void类型函数默认，最后一行有return;语句
        
*/

class FuntionDemo 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
        //30;单独写个常数在程序中是不行的，编译不过
        System.out.println(max(10,20));  //输出调用
        System.out.println("-----------------------");

        int a = 20,b = 35;               //实际参数
        int c = getMin(a,b);             //赋值调用
        System.out.println("小值是："+c);//打印输出
        System.out.println("-----------------------");

        min(24,45);                      //单独调用，用常数直接做参数
        System.out.println("-----------------------");

        return;   //默认有写，不必重复[可省略]
    }
    public static int max(int a,int b)         //函数以及变量名命名规则
    {
        return(a>b?a:b);                       //三元运算符
    }

    public static int getMin(int a,int b)      //函数以及变量名命名规则
    {
        return(a<b?a:b);
    }

    public static void min(int a,int b)        //函数以及变量名命名规则
    {
        if(a>b)
            System.out.println("小值是："+a);  //打印输出
        else
            System.out.println("小值是："+b);
    }
}

　　　　A:修饰符 public static
　　　　B:返回值类型 程序最终结果的数据类型
　　　　C:函数名 其实就是函数的名称,方便我们调用。
　　　　D:参数
　　　　　　形参类型 数据类型
　　　　　　形式参数 就是接收实际参数的变量
　　　　　　实际参数 就是实际参与操作的变量(常量)
　　　　E:函数体 就是按照正常的逻辑完成功能的代码。
　　　　F:返回值 就是程序的最终结果
　　　　G:reutrn 返回值 哪里调用程序，return就把结果返回到哪里。
　　(3)函数的特点：
　　　　A:函数与函数之间是平级关系。不能在函数中定义函数。
　　　　B:运行特点 函数只有被调用才执行。
　　(4)案例：
　　　　有明确返回值的例子：

　　　　A:求两个数据的和
　　　　B:求两个数据的最大值
　　　　C:比较两个数是否相等

/*
    数组：
        new关键字：申请开辟内存
        数组初始化；
        数组排序；
        获取最值；
*/
class ArraryDemo {
    public static void main(String[] args) {
        int[] arrary = new int[5];    //第一种初始化
        for(int i=0;i<5;i++){
            arrary[i] = i+1;
        }
        printArr(arrary);

        int max = getMax(arrary);//获取最大值
        System.out.println("max = "+max);

        int[] arr1 = new int[]{8,3,6,2,1,9,5};//第二种初始化
        printArr(arr1);
        sort(arr1);//基本排序
        printArr(arr1);

        int[] arr2 = {2,4,6,8,9,7,5,3,1};//第三种初始化
        int min = getMin(arr2);
        System.out.println("min = "+min);
        printArr(arr2);
        bubbleSort(arr2);
        printArr(arr2);

        int[] arr = {};//编译可以通过
        //基本查找
        int index = basicSearch(arr2,7);
        System.out.println("index = "+index);
        if(index>=0)
            System.out.println("验证数据："+arr2[index]);
        index = basicSearch(arr2,17);
        System.out.println("index = "+index);
        if(index>=0)
            System.out.println("验证数据："+arr2[index]);
    }

    //获取最小值
    public static int getMin(int[] arr){
        int min = 0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]<arr[min])
                min = i;
        }
        return arr[min];
    }
    
    //获取最大值
    public static int getMax(int[] arr){
        int max = arr[0];
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max)
                max = arr[i];
        }
        return max;
    }

    //排序，基本排序
    public static void sort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]<arr[j])
                    changeLocation(arr,i,j);
            }
        }
    }
    
    //冒泡排序
    public static void bubbleSort(int[]arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1])
                    changeLocation(arr,j,j+1);
            }
        }
    }

    //交换位置
    private static void changeLocation(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    //打印数组
    public static void printArr(int[] arr)
    {
        System.out.print("[");
        for(int i=0;i<arr.length-1;i++){
            System.out.print(arr[i]+"	");
        }
        System.out.print(arr[arr.length-1]+"]");

        System.out.print("
");
    }

    //基本查找
    public static int basicSearch(int[] arr,int key){
        for(int x=0;x<arr.length;x++){
            if(arr[x]==key)
                return x;
        }
        return -1;//返回值是索引值，不存在-1，表示没有查到
    }
    
}

　　　　void类型例子：

　　　　A:nn乘法表
　　　　B:根据给定的行和列输出一个*组成的长方形
　　(5)函数的调用
　　　　A:有明确返回值
　　　　　　a:单独调用 一般没有意义。
　　　　　　b:输出调用 但是如果想拿结果继续操作，就有问题了。所以，不好。
　　　　　　c:赋值调用 推荐方式。

　　　　B:void类型
　　　　　　单独调用
　　(6)函数重载
　　　　A:函数名相同,参数列表不同(个数不同,对应的类型不同)。
　　　　　　与返回值类型无关。

　　　　B:举例：
　　　　　　public static int sum(int a,int b){...}
　　　　　　public static int sum(int a,int b,int c){...}
　　　　　　public static int sum(float a,float b){...}

2：数组
　　(1)数组是存储同一种类型的多个元素的容器。
　　(2)好处：数组中的元素会被自动从0开始编号，方便我们获取。
　　(3)格式：
　　　　A:int[] arr = new int[3];
　　　　B:int arr[] = new int[3];//不推荐，C++
　　　　C:int[] arr = new int[]{1,2,3};
　　　　D:int[] arr = {1,2,3};

　　　　推荐A和D。
　　(4)Java内存图：
　　　　A:栈 存储局部变量使用。
　　　　　　使用完毕，立马消失。

　　　　B:堆 所有new出来的都在堆里面。
　　　　　　a:每一个实体都有地址值
　　　　　　b:每一个实体内的内容都有默认值
　　　　　　　　整数：0
　　　　　　　　浮点数：0.0
　　　　　　　　字符：'u0000'
　　　　　　　　布尔：false
　　　　　　c:在垃圾回收器空闲的时候被回收。

　　　　C:方法区
　　　　D:本地方法区
　　　　E:寄存器
　　(5)操作：

　　　　　　数组的索引。
　　　　　　数组的长度。
　　　　　　数组名.length

　　　　A:数组的遍历

　　　　B:数组获取最值

　　　　C:数组的查找
　　(6)二维数组：
　　　　格式：
　　　　　　A:int[][] arr = new int[3][2];
　　　　　　B:int[][] arr = new int[3][];
　　　　　　C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

　　　　　　遍历：

　　　　　　应用：遍历求和。

/*
    二维数组的定义，初始化，应用---遍历
    三种定义方式：
        int[][] arr = new int[3][4];
        int[][] arr = new int[3][];
        int[][] arr = {{1,2,5,6},{1,2},{4,8,9}};
*/
class Arrary2Demo{
    public static void main(String[] args) {
        //定义
        int[][] arr1 = new int[3][4];
        int[][] arr2 = new int[3][];
        int[][] arr3 = {{1,2,5,6},{1,2},{4,8,9}};
        //应用--遍历输出
        int[][] arr4 = {{1,2,5},{1,2},{4,8,9},{8,9,7}};//初始化每个季度中的每个月薪资
        //第一应用：
        //计算每个季度薪资总和：
        int sum = 0;
        for(int x=0;x<arr4[0].length;x++){
            sum += arr4[0][x];
        }
        System.out.println("第一季度薪资总和："+sum);

        //整体遍历，计算一年所有薪资
        int salary = 0;
        for(int x=0;x<arr4.length;x++){
            for(int y=0;y<arr4[x].length;y++){
                salary += arr4[x][y];
            }
        }
        System.out.println("一年薪资总和："+salary);


        // byte  a=0,b=3; 
         //byte c =a+b;
         for(;;);
        // int other = (int) true;
    }
}