JavaSE自学笔记Real_002

JavaSE自学笔记Real_002

一、方法的基础学习

public class Demo01 {
    public static void main(String @NotNull [] args) {
        //============================================================================
        //方法的基本定义
        //============================================================================
        /*
        Java的方法类似于其他编程语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义方法包含以下语法：
        方法包含一个方法头和一个方法体，下面是一个方法的所有部分：
        1、修饰符：是可选项，告诉编译器如何调用该方法，定义了该方法的访问类型。
        2、返回值类型：方法可能返回值，returnType是方法返回值的数据类型，有些方法执行所需的操作，但没有返回值，这种情况下使用void
        3、方法名：是方法的实际名称，方法名和参数表共同构成方法的签名
        4、参数类型：参数是一个占位符，当方法被调用时，传递值给函数。这个值被称为实参或变量，参数列表指方法的参数类型，顺序和参数的个数。
           参数是可选的，方法可以不包含任何参数
        5、方法体：方法体包含具体的语句，定义该方法的功能


        int num1 = 2;
        int num2 = 2;
        int Max = max(num1, num2);
        System.out.println(Max);
         */

        //==============================================================================
        //方法的重载
        //==============================================================================
        /*
        重载就是在一个类里面，有相同的函数名称，但是形参不同的函数
        方法重载的规则：
        1、方法名称必须相同
        2、参数列表必须不同（个数不同，或类型不同，参数列表的顺序不同）
        3、方法的返回值可以不同也可以相同
        3、仅仅返回值类型不同不足以称为方法的重载
        实现理论：
        方法名相同时，编译器会根据调用方法的参数个数、参数类型等逐个去匹配，已选择对应的方法，如果编匹配失败，则编译器会报错。
         */

        //=====================================================================
        //命令行传递参数（CMD）
        //=====================================================================
        //args.length 表示数组长度
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]:" + args[i]);
        }

        //=====================================================================
        //可变参数
        //=====================================================================
        //在方法声明中，指定参数类型后加上一个省略号（...）
        //一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通的参数必须在它之前声明
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});

        //=====================================================================
        //递归
        //=====================================================================
        /*
        利用递归就可以用加单的程序来解决一些比较复杂的问题。它通常把一个大型复杂的问题层层转换为一个与原问题相似的规模较小的问题来求解，
        递归策略秩序用少量的程序就可以描述出解题过程所需要的多次重复的计算，大大减少了程序的书写量，
        递归的能力在于用有限的语句来定义对象的无限集合。
        递归结构主要包括两个部分：
        1、递归头：什么时候不调用自身方法，如果没有头，将陷入死循环‘
        2、递归体：什么时候调用自身方法。
        */
    }
    //比较大小的函数
    public static int max(int num1, int num2){
        int Max = 0;
        if(num1 > num2){
            Max = num1;
        } else if (num2 > num1){
            Max = num2;
        }else{
            System.out.println("两个数相等");
        }
        return Max;
    }

    //排序
    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);
    }
}

例题：制作简易两个数之间的加减乘除计算器

import java.util.Scanner;

public class Calculater {
    public static void main(String[] args) {
        while(true){
            //初始化
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入第一个数值：");
            double a = scanner.nextDouble();
            System.out.println("请选择您要进行的运算\n1代表加法，2代表减法，3代表乘法，4代表除法");
            int b = scanner.nextInt();
            System.out.println("请输入第二个数值：");
            double c = scanner.nextDouble();
            double result = 0;

            //进行计算
            switch(b){
                case 1:{
                    result = Add(a, c);
                    break;
                }
                case 2:{
                    result = Sub(a, c);
                    break;
                }
                case 3:{
                    result = Mul(a, c);
                    break;
                }
                case 4:{
                    result = Div(a, c);
                }
            }

            //输出结果
            System.out.println("计算结果：" + result);
        }

    }

    //加法函数
    public static double Add(double num1, double num2){
        return (num1+num2);
    }

    //除法函数
    public static double Div(double num1, double num2){
        if(num2 == 0){
            System.out.println("输入的除数无意义");
            return 0;
        }else{
            return (num1/num2);
        }
    }

    //乘法函数
    public static double Mul(double num1, double num2){
        return (num1*num2);
    }

    //减法函数
    public static double Sub(double num1, double num2){
        return (num1-num2);
    }
}

二、数组的基础学习

import java.util.Arrays;

class ArraysBasic {
    public static void main(String[] args) {
        //=============================================================
        //数组的基本概念
        //=============================================================
        /*
        数组是相同类型数据的有序集合
        数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成
        其中，每一个数据称作数组的一个元素，每个数组元素可以通过一个下标来访问他们
         */

        //============================================================
        //数组的定义
        //============================================================
        //变量的类型 变量的名字 = 变量的值
        //1、声明一个数组
        int[] numbers;    //1、首选的定义
        int Numbers[];    //2、不建议的定义
        //定义一个数组
        numbers = new int[10];
        //3、给数组赋值
        numbers[0] = 1;
        numbers[1] = 1;
        numbers[2] = 1;
        numbers[3] = 1;
        numbers[4] = 1;
        numbers[5] = 1;
        numbers[6] = 1;
        numbers[7] = 1;
        numbers[8] = 1;
        numbers[9] = 1;
        //4、使用数组中的元素（例如计算所有元素的和）
        int sum = 0;
        for(int i = 0; i < numbers.length; i++){
            sum+=numbers[i];
            System.out.println(sum);
        }

        //=======================================================
        //数组的三种初始化方式
        //=======================================================
        //1、静态初始化
        int[] a1 = {1, 2, 3,4 ,5 ,6, 7, 8};
        //2、动态初始化
        int[] a2 = new int[10];
        a2[0] = 10;
        a2[1] = 9;
        //3、默认初始化
        //数组是引用类型，他的元素相当于类的实例变量，因此数组一经分配空间，
        // 其中的每个元素也被按照实例变量同样的方式被隐式初始化

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

        System.out.println("=========================================");
        //============================================================
        //增强型for循环的使用（for each）
        //============================================================
        int[] arrays = {1, 2, 3,4 ,5 ,6};
        for (int array : arrays) {
            System.out.println(array);
        }

        System.out.println("=========================================");
        //============================================================
        //二维数组
        //============================================================
        int[][] Arrs = {{1,2},{2,3},{3,4}};
        System.out.println(Arrs[0][1]);

        //============================================================
        //Arrays类
        //============================================================
        /*
        import java.util.Arrays
        常用以下功能：
        1、给数组进行赋值：fill
        2、对数组进行排序：sort 升序
        3、比较数组：equals比较数组中的元素值是否相等
        4、查找数组元素：binarySearch对数组可以进行二分查找法操作
         */

        System.out.println("=========================================");
        //===========================================================
        //稀疏数组
        //===========================================================
        /*
        当一个数组大部分为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
        处理方式：
        1、记录数组一共有几行几列，有几个不同的值
        2、把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
         */
        //1、常见一个二维数组11*11
        int[][] Arrays1 = new int[11][11];
        Arrays1[1][2] = 1;
        Arrays1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始的数组：");
        for (int[] ints : Arrays1) {
            for (int anInt : ints) {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        //2、利用稀疏数组进行保存
        //获取有效值的个数
        int sum1 = 0;
        for(int i = 0; i < Arrays1.length; i++){
            for(int j = 0; j < Arrays1[0].length; j++){
                if(Arrays1[i][j] != 0){
                    sum1++;
                }
            }
        }
        System.out.println("有效个数为："+sum1);
        //创建一个稀疏数组的数组
        int[][] Arrays2 = new int[sum1+1][3];
        Arrays2[0][0] = Arrays1.length;
        Arrays2[0][1] = Arrays1[0].length;
        Arrays2[0][2] = sum1;
        //遍历二维数组，将非零的值，存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < Arrays1.length; i++) {
            for (int j = 0; j < Arrays1[0].length; j++) {
                if(Arrays1[i][j]!=0){
                    count++;
                    Arrays2[count][0] = i;
                    Arrays2[count][1] = j;
                    Arrays2[count][2] = Arrays1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组：");
        for (int i = 0; i < Arrays2.length; i++) {
            System.out.println(Arrays2[i][0]+"\t"+Arrays2[i][1]+"\t"+Arrays2[i][2]+"\t");
        }
    }
}