学习java的第十天，简易计算器制作以及数组的学习

最新推荐文章于 2023-04-26 13:43:16 发布

寄给月亮.

最新推荐文章于 2023-04-26 13:43:16 发布

阅读量280

点赞数 1

分类专栏： java 文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/weixin_53830900/article/details/125133204

版权

java 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

一、简易计算器

结合先前所学的知识点，做了一个简易计算器出来，功能算是很简易，但是代码看起来却不简易，因为我使用到了for循环以及if的嵌套，用来判断输入是否有误以及跳转问题等情况，代码也是加了很多注释，方便大家能看懂

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);  //创建扫描器
            double a1 = 0 ; //用来存储用户的第一个数值
            double a2 = 0; //用来存储用户的第二个数值
            double sum = 0;  //用来存储计算结果的数值

        for (int i=1;i<2;i++){ //创建循环，用来控制是否重新计算！
            if (i==1){ //如果i等于1，则重新开始计算
        System.out.println("请输入您需要计算的第一个数值：");
        a1 = scanner.nextDouble(); //获取客户输入的第一个数值，数值为double类型
                for (int j = 1; j < 2; j++) { //创建循环，用来控制继续输入的数值！
                    if (j==1) {  //如果j等于1，则继续输入
                        System.out.println("请输入您需要计算的方式（+，-，*，/）：");
                        String Calcua = scanner.next(); //获取客户输入的计算方式，定义为String类型
                        //如果用户输入的符号等于以下四个，则输出需要运算的数值，否则提示不合规
                        if (Calcua.equals("+") || Calcua.equals("-") || Calcua.equals("*") || Calcua.equals("/")) {
                            System.out.println("请输入您需要" + Calcua + "的数值：");
                            a2 = scanner.nextDouble(); //获取客户输入的第二个值 ，数值为double类型
                            switch (Calcua) { //switch循环，用于计算
                                case "+":
                                    sum = add1(a1, a2); //sum值等于a1跟a2相加，然后返回结果给sum。以下也一样
                                    break;
                                case "-":
                                    sum = add2(a1, a2);
                                    break;
                                case "*":
                                    sum = add3(a1, a2);
                                    break;
                                case "/":
                                    sum = add4(a1, a2);
                                    break;
                            }
                            System.out.println("本次的结果计算为：" + sum);
                            System.out.println("请问您是否需要继续计算？（输入1继续计算，输入2重新开始计算，输入其他任意字符退出！）：");
                            String Sum2 = scanner.next(); //用来获取用户是否需要继续计算
                            if (Sum2.equals("1")) { //如果继续计算
                                System.out.println("当前的值为：" + sum);
                                    a1 = sum;  // 如果继续计算，那么a1现在的值跟sum 的值相同，也就是上面计算出来的结果赋值给了a1
                                    j = j-1;  // 执行j-1  也就是1-1 始终小于2！然后再次运行运算符那里的程序
                            } else if (Sum2.equals("2")) {
                                i = i - 1; //如果用户输入了2，要求重新计算，则i等于 1-1，然后重新进行循环计算获取新值
                            } else {
                                break;  //用户输入任意字符则退出程序！
                            }
                        } else { //这里是判断用户在输入字符时是否合规，如果不合规，则j-1，然后 重新回到输入运算符处
                            System.out.println("您的输入不合规，请重新输入(+,-,*,/)：");
                            System.out.println("-------------------------------------------------------");
                            System.out.println("当前的值为："+a1);
                            j=j-1;

                        }
                    }
                }

                scanner.close(); //关闭扫描器
            }
    }

    }
    public static double add1(double a,double b){ //创建加的方法
        return a+b;
    }
    public static double add2(double c,double d){ //创建减的方法
        return c-d;
    }
    public static double add3(double e,double f){ //创建乘的方法
        return e*f;
    }
    public static double add4(double g,double h){ //创建除的方法
        return g/h;
    }

总结：说实话，这个计算器做了我一个早上，因为各种修修补补，期间还参考了一下其他人做的，但都是比较靠前的知识，目前并没有掌握，整体思路就是：先创建加减乘除的方法类，然后调用scanner扫描器获取用户输入的数值，并且传递到初始的变量中，再使用switch控制语句去调用加减乘除的方法类，然后完成输出。

二、数组

1、数组的概述

数组是相同类型数据的有序集合！int[]
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成！
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们！（0~9）

数组的四个基本特点

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

2、数组声明创建

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

    public static void main(String[] args) {
        int[] nums; //1、定义数组
        int nums2[]; // 2、定义数组方法  不推荐使用，早些年为了c+程序员适应java使用的一种方式！
        nums = new int[10]; //这里可以存放10个int类型的数字！
        
    }

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

//数据类型[数组] 数组名 = new 数据类型[数组长度];
//这样可以直接进行创建！
 int[] add = new int[10];

总结：创建数组时，格式是：数据类型[] 数组名字 = new 数据类型[数组长度];
即：String[] add = new String[10];
就可以了，然后下面会讲到怎么使用

3、数组使用

（一）、计算所有元素的和

public static void main(String[] ages){
		int[] nums= new int[5]; //创建一个长度为5的数组
		nums[0] = 1;  //给数组内的0下标赋值为1
		nums[1] = 2;  //给数组内的1下标赋值为2...
		nums[2] = 3;
		nums[3] = 4;
		nums[4] = 5;
		int sum = 0; //新建一个变量sum，用来存放求和的数值
		// 获取数组长度:arrays.length
for(int i =0;i<nums.length;i++ ){
	sum = sum+nums[i];  //sum = sum加nums0,1，2,3，4....
	System.out.println("当前的总和为："+sum)
}
}

总结：数组的元素是通过索引访问的，数组索引从0开始！
获取数组长度：arrays.length

（二）、查找最大元素

    public static void main(String[] args) {
        // 静态数组初始化  创建+赋值！
        int[] add = {1,5,6,59,8,90};
            //动态的去输出所有静态的数组
        //查找最大元素
        int max = add[0];  //定义初始值，max等于add数组的0号元素即等于1
        for (int i = 0; i < add.length; i++) { //如果i<数组的长度，i++
            if (add[i]>max) {   //如果add的第i个数组值 > max，则add[i]的值赋值给max，并且保持数值不变
                max = add[i]; 
                System.out.println("当前的max的值是："+max);
            }
        }
        System.out.println("最大值是："+max);
        System.out.println("----------------------------");

（三）、3种初始化

静态数组和动态数组以及默认数组！

    public static void main(String[] args) {
        // 静态数组初始化  创建+赋值！
        int[] add = {1,5,6,9,8,30};
            //动态的去输出所有静态的数组
        for (int i = 0; i < add.length; i++) {
            System.out.println(add[i]);

        }
        System.out.println("----------------------------");
        //动态数组初始化  包含默认初始化！
        //默认初始化值  未定义数值的数组，在执行时将会被隐式初始化，即int分配0，字符串类型分配null！
        int[] add2 = new int[10];
        add2[2] = 10;
        for (int j = 0; j < add2.length; j++) {
            System.out.println(add2[j]);
        }
    }

下面做了几个数组的练习，可以尝试一下操作！

 public static void main(String[] args) {
        //创建静态数组
        int[] add = {50,20,30,5,6,90,50};
        Min(add); //调用Min方法中的数组
        Max(add); 
        age(add);
        sum(add);
        array(add);
    }
    //求出数组中的最小值
    public static void Min(int[] add){
        int Mins = add[0];
        for (int i = 0; i < add.length; i++) {
            if (add[i] < Mins ){
                Mins = add[i];
            }
        }
        System.out.println("最小值是："+Mins);

    }
    //求出数组中的最大值
    public static void Max(int[] add){
        int Maxs = add[0];
        for (int i = 0; i < add.length; i++) {
            if (add[i] > Maxs ){
                Maxs = add[i];
            }
        }
        System.out.println("最大值是："+Maxs);
    }
    //求出数组中的平均值
    public static void age(int[] add){
        int sum = 0;
        int ages = 0;
        int a =0;
        for (int i = 0; i < add.length; i++) {
            sum = add[i]+sum;
            a = i+1;
        }
        ages = sum/a;
        System.out.println("当前平均值是："+ages);
    }
    //求出数组中的和
    public static int sum(int[] add){
        int sum2 = 0;
        for (int i = 0; i < add.length; i++) {
            sum2 = add[i]+sum2;

        }
        System.out.println("数组中的和是："+sum2);
        return sum2;
    }

    //输出所有的元素
    public static void array(int[] add){
        for (int i = 0; i < add.length; i++) {
            System.out.print(add[i]+"\t");
        }

    }

（四）、反转输出数组的元素

    public static void main(String[] args) {
        //创建一个静态数组
        int[] Arrays= {2,5,6,7,8,9,30,50};

        System.out.println("\n"+"----------------------");
        int[] add = add(Arrays);
        //调用priArrayint方法中的数组
        priArrayint(add);
    }

    //反转输出
    // 创建一个int[]返回数组的类，取名add 形参是int数组，调用Arrays数组
    public static int[] add(int[] Arrays){
        //定义一个int数组，取名sum2，并且new一个对象，将该对象的初始值长度给sum2.
        int[] sum2 = new int[Arrays.length];
        //反转操作
        // i等于0，j=sum2的长度减一，则j等于7；i小于Arrays的长度，则执行以下代码
        for (int i = 0,j =sum2.length-1; i < Arrays.length; i++,j--) {
            //sum2的数组内容，等于Arrays数组的内容，即反转，i第一个长度下标，是0，j等于7，取i的第一个数给到sum2的第七个长度，即i的下标0=2，j的下标7=2，以此类推
            sum2[j] = Arrays[i];
        }
        return sum2;
    }

    //输出数组内的元素
    public static void priArrayint(int[] Arrays){

        for (int i = 0; i < Arrays.length; i++) {
            System.out.print(Arrays[i]+" ");
        }

    }