java基础语法第一部分

作为一名初次接触java的编程小白，也是初次学习总结，本文内容仅供参考
本文仅供个人学习记录，欢迎交流

chapter 1

1. 输出语句

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello,world");
    }

要点：

1. println表示输出并换行，而print只输出无换行
2. java的输出语法比较人性化，对于输出内容的拼接只需使用”+“号即可完成
   例如：

//      输出：这是我的第100杯苦咖啡
int count = 100;
System.out.println("这是我的第"+count+"杯苦咖啡");

//      于是我们在打印数组的时候可以利用添加空格去掉换行的方式，使得打印输出更直观
int[] arr = {1,2,3,4,5,6,7}
for(int i = 0;i < 7;i++){
    System.out.print(arr[i]+" "); //打印结果为在同一行：1 2 3 4 5 6 7 
}

2. 数据类型转换

public class codetype {
    public static void main(String[] args) {
//小精度向大精度转，属于自动类型转换
        byte a = 1;
        int b = 2;
        int c = a + b;
        System.out.println(c);
//浮点数大于整数
        int a2 = 1;
        float b2 = 2;
        float c2 = a2 + b2;
        System.out.println(c2);
//强制类型转换，大转小时使用，特点：小数会被舍去,导致数据的部分丢失
        int a3 = 20;
        byte b3 = (byte) a;
        System.out.println(b3);

        double a4 = 2.14;
        int b4 = (int)a4;
        System.out.println(b4);

        float a5 = 3.14f;
        int b5 = (int)a5;
        System.out.println(b5);

//加法运算从左到右，字符串同化水平最高，直接拼接；字符会直接转换成Asic码,变成数字运算
        System.out.println(1+2+"hello"+2+1);
        System.out.println("hello"+1+2);
        System.out.println(1+2+3+'a'+1+2);
        System.out.println('a'+1);

//取余，取模
        int num;
        num = 12345;
        int numFirst,numSecond,numThird_01,numThird_02,numThird_03,numThird_04;
        numFirst = num%10;
        numSecond = num/10%10;
        numThird_01 = num/10/10/10/10%10; //位数等于（n-1）位除+1位取余；
        numThird_02 = num/10/10/10/10;//位数等于（n-1）位除，但个位除外；
        numThird_03 = num/10000;
        numThird_04 = num/10/10/10/10/10; //错误，移位多
        System.out.println("num的个位数是"+numFirst);
        System.out.println("num的十位数"+numSecond);
        System.out.println("num的万位数是"+numThird_01);
        System.out.println("num的万位数是"+numThird_02);
        System.out.println("num的万位数是"+numThird_03);
        System.out.println("num的万位数是"+numThird_04);

//自增，自减
        int numAdd = 1;
        int numReduce = 2;
        int result_back = numAdd++;
        int result_front = --numReduce;
        System.out.println("result="+result_back);
        System.out.println("result="+result_front);
        System.out.println("numAdd="+numAdd);
        System.out.println("numRuduce="+numReduce);

/*
    自增自减在同一个完整的运算表达式中，是逐次变化的，逐项会变化
    a = 15 ,b = 15；
    表达式：a-- + ++b - a++；
    考试做法：[--（a=15）] + (b=16) - (a=14)  ; a = 15,b=16 ;
 */

//赋值运算符；扩展运算符自带类型转换，以原数据为准，原来是什么数据类型，运算后就是什么类型
        int x = 1;
        x += 1;
        int y = 2;
        y += 3.14;
        double z = 3.12;
        z += y;
        System.out.println("x的值是"+x);
        System.out.println(y);
        System.out.println(z);

//关系运算符：运行结果是boolean值：ture or false
        int resultBool_01 = 3;
        int resultBool_02 = 5;
        System.out.println(resultBool_01 > resultBool_02);
        System.out.println(resultBool_01 != resultBool_02);


    }
}

3. 三目运算符

//     类似条件语句，这句话是将num1和num2中较大的数字赋值给tempmax，我习惯用于小规模的比较大小，书写比较快捷
        int tempmax = num1 > num2? num1:num2;

//     值得注意的是，在选择结果时，用来接结果的变量数据类型要一致
        for(int i = 1; i <= 5; i++)
        {
            String result = i > 3? "大于":"小于";//String 首字母要大写，Java区分大小写
            System.out.println(result);
        }
    }

4. 输入语句

public class input {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入姓名");
        String name = sc.next();//输入数字的话，因为原类型是字符串不会越界
        System.out.println("我的名字是"+name);
        System.out.println("请输入年龄");//输入字符串的话会越界，因为字符串的字节数大于int
        int age = sc.nextInt();
        System.out.println("我的年龄是"+age);//如果在第二次输入出现错误，则程序中断
        System.out.println("请输入身份");
        String id = sc.next();
        System.out.println("我的身份是"+id);
    }
}

5. 逻辑运算符

    public static void main(String[] args) {

/*
    逻辑运算符：双&和双|会短路后面判断语句，单&和单|不会，仍然会执行后续运行，所以单存在性能问题；
    &&：与（并且） ；首个判断语句为flase的时候，会短路后面；
    ||: 或 ； 首个判断语句为ture时会短路后面；
    !: 非（取反）
    ^: 异或(对象不同为ture，一样为false)
*/
        int a = 1,b = 3,c = 5;
        boolean d = a > 2 || c >3;
        System.out.println(a > 0 && b > 2); //与运算，都为ture，输出ture
        System.out.println(d); //或运算，有真则为真，这里是第二个判断为真，所以不会出现短路情况
        System.out.println(!d);//否运算
        System.out.println(a > 1 ^ b < 5);//异或运算，不会短路，只有当语句全部判断完毕，结果不同，则输出ture
    }

6. 基本语句

1. switch语句

import java.util.Scanner;

// switch语句 不支持float double long ； case后面只能是常量，不能是变量，且不允许重复使用；
//float f = 10f;
//long l = 10;均会报错
//在没有遇到break时，会在第一次匹配条件成功后，执行剩下的全部语句并且输出，特例：在没有匹配的case后，会从default进入，并且执行default剩下的全部语句，可以理解为default是一个最后检查的备用选项，不一定能触发；
//使用Switch的穿透现象可以解决代码冗余的问题：将几个case同结果的代码写在最后一共case里

public class demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入今日是礼拜几");
        int day = sc.nextInt();
        switch (day){
            case 1:
                System.out.println("周一");
                break;
            case 2:
                System.out.println("周二");
                break;
                ```
            default:
                System.out.println("wrong");
                break;
        }
    }
}

2. for循环

 int sum = 0;
        for(int i = 1; i <= 10; i++){
            if (i % 2 == 1) {  //切记只能用if，使用while会进入无限循环，当出现一个匹配成功时，会无限sum+=i，所以while不能用于单纯判断语句，一定要添加出口；
                sum+=i;
            }
        }
        System.out.println("总和为"+sum);

3. do-while

double paper = 0.1;
        int count  = 0;
        while (paper < 8840600){
            paper *= 2;
            count++;
        }
        System.out.println(count+"次,"+"paper厚"+paper);

7. break和continue的区别

/*
break直接退出循环
continue退出当前趟的循环
死循环while一定要用break
*/
public class demo1 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入密码");
        while(true) {
            int key = sc.nextInt();
            if (key == 888) {
                System.out.println("您已经进入系统");
                break;
            }else {
                System.out.println("密码错误，请重新输入");
            }
        }
    }
}

8. 生成随机数

// 随着jdk版本升级，在随机数生成中我们可以自己选择生成范围的如99~199，但是之前的老版本没有支持，这里只介绍我的偏好，就是使用nextInt（bound：n），这里的n取的是你的数据个数，也可以理解为一个数组的长度（arr.length），比如你的数字是从1到10，一共十个数字，那么n就等于10，但由于该方法默认是从0作为起始数字，也就是你的实际随机数范围是从0~9，因此我们可以手动使用加法定位到想要的位置：
public class demo {
    public static void main(String[] args) {
        Random random = new Random();
        int i = 0;
        while (i < 10) {
            int number = random.nextInt(10)+1;//这样就是从1开始了
            System.out.println("随机数" + number);
            i++;
        }
    }
}

9. 数组

1. 静态初始化

public class demo1 {
    public static void main(String[] args) {
//        静态定义
//        变量实际是存储变量的地址，而不是数据本身。
//        对象：就是引用数据类型，在内存中存储的是地址
        int arr[] = new int[]{11,12,13,14,15};
        String arr2[] = {"1","2","3","nice","good","haibucuo"};
        System.out.println(arr);//直接打印数组的结果是第一个数据的内存地址；

//        数组的访问
        arr2[2] = "我是太白金星";
        System.out.println(arr2[2]);
        System.out.println(arr2.length);
    }
}

2. 动态初始化

//      动态初始化 int默认是0,double float是10.0,boolean是false，string是null；
public class demo_1 {
    public static void main(String[] args) {
        int[] arr = new int[4];
        arr[3] = 5;
        System.out.println(arr[0]);
        System.out.println(arr[3]);
    }
}

10. 方法

//      函数内的方法，如数组都是定义在栈内存内，数组的元素是定义在堆内存里；
public class demo06_inter_and_wide {

    public static void main(String[] args) {
        int[] arr = {11,22,33};
        test(arr);
        System.out.println(arr[1]);
    }
    public static void test(int[] arr) {
//        int[] arr_02 = arr;
        int[] brr = arr;
        arr[1] = 44;
        System.out.println(brr[1]);
    }
}

// 补充说明，我有遇到朋友说刚开始接触方法的时候，总觉着返回值和方法里传的参数是有息息相关的，其实这俩者间没有必然联系，他分不清的原因主要在于对方法的定义结构混淆了，总之作为初学者我们只需要记住下面基本格式即可

public static 返回值数据类型 方法名（传参数据类型 传参数据名称）{} ;

// 下面是在主函数里定义变量接收返回值的实例

public class demo07_test {
    public static void main(String[] args) {
        int[] score = {90,1 ,78,6586,80,79,88,67,46};
        int sum = getSum(score);//使用getSum方法获得总分，用sum接收方法传回的总分数
        getbest(score);
        double avg = sum/score.length;
        System.out.println("总分是"+sum);
        System.out.println("平均分是"+avg);
        System.out.println("最高分是"+score[0]);
        System.out.println("最低分是"+score[1]);
    }

    public static int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return  sum;
    }
//      将最大最小值和数组中的最后两个位置交换顺序，返回数组，这样的好处是我们不用写两个方法分别求最大最小值，而是利用数组下标，在一次返回中获得最大最小值，但本质上求最大最小值的思路都类似
    public static int[] getbest(int[] arr){
        int high = arr[0];
        int low  = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if(high < arr[i])
                high = arr[i];
            if (low > arr[i])
                low = arr[i];
        }
        arr[0] = high;
        arr[1] = low;
        return arr;
    }
}

11. 双色球问题

选择这道作为前一段时间的总结和对方法使用的巩固，目前看来是比较合适的，我在每个语句的后面争取都写了注释，以便于理解，同时方法的书写顺序，是由于我个人的习惯，习惯写到哪就在main函数后面书写，建议大家在阅读代码的时候可以按照main函数的执行过程去进行梳理

import java.util.Random;
import java.util.Scanner;

//      while写无限循环，while里面写条件语句，可以考虑优先将不符合的情况写出，这样排除掉多个可能的条件（主要是写符合条件需要满足多个要求，而写不符合的要求们可以拆开写），剩下的else就是符合的条件，添加break
public class day06_task_07second {
    public static void main(String[] args) {
//      第一步，是手动输入号码，这个方法设计时，我们要攻克三个基本问题：第一个是在输入时我们要解决红球多多次录入，所以我们需要scanner以及if语句去满足；第二个是越界和判重，因为红球的数字范围的限制和不能重复的限制，所以我们可以想到需要一个条件语句来确定他是否符合数字范围，不能重复，我们同样可以考虑用遍历数组的方式去确定里面有没有等值的项。第三个是关于如果输入错误，我们需要回溯到重新输入的那步，这时，在本段代码开始的部分我们已经介绍了利用while方法实现，不再赘述。
        int[] userSelectNumber = userSelectNum()
//      第二大块是随机数字，利用random我们可以很轻易的得到想要的随机数组，但是由于不能重复，因此我们同样需要借助第一步里的红球的思想，去避免重复（这里不用考虑越界的情况，因为我们的随机数已经给了范围“bound”了）
        int[] lucyNumber = lucyNumber();
//      我们在实现上述两个模块后，不妨试着打印这两个数组去查看，是否已经达到了我们想要的要求
        for (int i = 0; i < 7; i++) {
            System.out.print(userSelectNumber[i]+" ");
        }
        System.out.println();
        for (int i = 0; i < 7; i++) {
            System.out.print(lucyNumber[i]+" ");
        }
        System.out.println();
//      最后是根据两个数组的的对比情况去比对获奖情况，由于我们需要确定有几个红球相同，最后一个蓝球是否相同，可以考虑用循环去逐个比对，最后确定获奖所需要的数据。以上就是全部的思想框架，接下来我们要利用这些基本的工具去组装，得到题目的答案。
        moneyAward(userSelectNumber,lucyNumber);

    }
//      最后一步是判断类型，我们用两个for循环，将直接手动输入的数组元素逐个和随机生成的数据元素对比，并且用redcount和bluecount去记录，最后使用if语句逐一分类即可，此处随着写条件语句即可。
    public static void moneyAward(int[] userSelectNumber,int[] lucyNumber){
        int redCount = 0,blueCount = 0;
        for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 6; j++) {
                if(userSelectNumber[i] == lucyNumber[j])
                    redCount ++;
            }
        }
        if(userSelectNumber[6] == lucyNumber[6]) blueCount++;
        if(redCount == 6 && blueCount == 1){
            System.out.println("中奖1000万");
        }else if(redCount == 6 && blueCount == 0){
            System.out.println("中奖500万");
        }else if(redCount == 5 && blueCount == 1){
            System.out.println("中奖3000元");
        }else if(redCount == 5 && blueCount == 0 || redCount == 4 && blueCount == 1){
            System.out.println("中奖200元");
        }else if(redCount == 4 && blueCount == 0 || redCount == 3 && blueCount == 1){
            System.out.println("中奖10元~");
        }else if( redCount < 3 && blueCount == 1){
            System.out.println("中奖5元");
        }else {
            System.out.println("运气不行");
        }
    }
//      这里我们利用random实现随机数字生成，至于回溯到输入入口使用while，判重使用exis方法，都和红球一样，可以说将方法写出给予我们很大简便。
    public static int[] lucyNumber(){
        Random random = new Random();
        int[] lucyNumber = new int[7];
        for (int i = 0; i < 6; i++) {
            while (true){
                int redNumber = random.nextInt(33)+1;
                if(exist(redNumber,lucyNumber) == true){
                }else {
                    lucyNumber[i] = redNumber;
                    break;
                }
            }
        }
        int blueNumber = random.nextInt(16)+1;
        lucyNumber[6] = blueNumber;
        return lucyNumber;
    }

//      根据主函数，我们第一步应该实现手动输入双色球号码，在创建动态数组和输入器后，我们考虑使用for循环去实现为里面的前六个红球逐个添加号码，那么根据本题的前提提示，我们要实现在录入不合法时报错并且回溯到输入步骤，就要用到while语句，写一个死循环，并且利用if语句将正确的输入作为这个循环的唯一出口
    public static int[] userSelectNum(){
        int[] userNumber = new int[7];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 6; i++) {
            System.out.println("请输入第" + (i + 1) + "个红球，" + "范围在1到33之间,不能重复");
            while (true) {
//      输入语句，因为while是回溯到输入步骤，因此一定要写在里面
                int redNumber = sc.nextInt();
//      根据前期提要，我们先把不合法的情况写上，以便于我们最后设置输入正确的出口，“逃离”死循环
                if(redNumber < 1 || redNumber > 33){
                    System.out.println("您的输入有误，输入不在范围内");
//      判断是否存在，因为我们的if空间有限，但更重要的是为了提高代码的复用性，我们不妨把判重语句写在一个新的方法里，已调用就知道是否存在了，必然用返回值false表示数组里没有与之同值元素，true表示有，则输入错误；也可以使用返回int类型的数字1表示存在，输入不合法，0表示数组中不存在同值元素，输入合法
                }else if(exist(redNumber,userNumber) == true){
                    System.out.println("请重新输入与之前不重复的数字");
//      最后设置出口，我们将合法的数据更新到数据中，完成对数据的录入并且退出循环，至此，红球的录入结束
                }else {
                    userNumber[i] = redNumber;
                    break;
                }
            }
        }
        System.out.println("请输入蓝球号码，范围在1到16之间");
//      蓝球的思路同理红球，但因为只有一个，必然不可能重复，因此我们在条件判断中可以省去“重复”这一不成立情况，在理顺红球的思路后，蓝球就是照虎画猫
        while (true){
            int blueNumber = sc.nextInt();
            if(blueNumber > 16 || blueNumber <1){
                System.out.println("您的输入有误，输入不在范围内，请输入1~16之间的数字");
            }else {
                userNumber[6] = blueNumber;
                break;
            }
        }
        return userNumber;
    }

//      用新预备录入的数字去和已经录入的每一项去比，若都不一样则说明没有重复，数据符合要求。同时学有余力也可以考虑这种思维：建立一个全是false的数组，数组下标对应的就是我们要输入的数字大小，当有数字被录入时，我们修改对于下下标的元素为true，表示已经使用，下次遇到重复的数字时，我们只需检查该数字对应的数组下标中元素是否为false，若不为，则说明已录入，有点类似哈希查找，这里利用数组支持随机查找。
    public static boolean exist(int redNumber, int[] userNumber) {

        for (int i = 0; i < 6; i++) {
            if (userNumber[i] == redNumber) {
                return true;
            }
        }
        return false;
    }
}

// 如有疑问欢迎交流，如有错误感谢指正