【Java学习笔记】Java基础语法

已于 2022-02-25 23:03:21 修改
阅读量2k 收藏 1
点赞数 3
分类专栏： Java学习笔记 文章标签： java 学习 intellij-idea
于 2022-02-16 22:28:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52144018/article/details/122962280
版权

前言

目录

1. 注释

注释：在程序中对代码解释说明的文字，方便自己和其他人理解、查看，不会影响程序的正常执行

注释的分类

1. 单行注释

//注释内容，只能写一行

2. 多行注释

/*
	注释内容1
	注释内容2
	 ......
 */

3. 文档注释
一般用在类和方法上的注释，以后会讲解区别

/**
	目标：学会使用注释
    注释内容1
    注释内容2
    ......
*/

注释的特点

  • 注释不影响程序执行
    NoteDemo.java文件
/**
    目标：学会使用注释
    注释内容1
    注释内容2
    ......
 */
public class NoteDemo {
    public static void main(String[] args) {
        //注释内容，只能写一行
        //以下是一个打印语句，往控制台输出内容
        System.out.println("开始学习Java");
        /*
            注释内容1
            注释内容2
            ......
         */
        System.out.println("666");
    }
}

通过javac命令进行编译后NoteDemo.class文件

public class NoteDemo {
	public NoteDemo(){
	}
	
    public static void main(String[] args) {
        System.out.println("开始学习Java");
        System.out.println("666");
    }
}

可以看到程序最终执行的class文件中没有注释，因此不会影响程序执行

快捷键

IDEA注释快捷键功能效果
Ctrl + /单行注释
Ctrl + Shift + /选中代码进行多行注释

2. 字面量

字面量：计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式。

字面量分类

常用数据生活中的写法程序中的写法说明
整数666，-888666，-888写法一致
小数13.14，-5.2013.14，-5.20写法一致
字符A，b，我‘A’，‘b’，‘我’程序中必须使用单引号，有且只能有一个字符
字符串helloworld，程序员“helloworld”，“程序员”程序中必须使用双引号，内容可有可无
布尔值真，假true,false只有两个值：true代表真，false代表假
空值值为null一个特殊的值，空值（后面会讲解作用，暂时不管）

实例

public static void main(String[] args) {
        //1.整数
        System.out.println(666);
        //2.小数
        System.out.println(13.14);
        //3.字符，必须用单引号围起来，有且只能有一个字符
        System.out.println('A');
        System.out.println('6');
        System.out.println('鹏');
        // System.out.println('菜鹏');  报错
        System.out.println(' ');//空字符
        System.out.println('\n');//\n代表换行
        System.out.println('\t');//\t代表一个tab
        //4.字符串，必须用双引号围起来，里面的内容随意
        System.out.println("菜菜的大鹏");
        System.out.println(" ");
        System.out.println("      ");
        System.out.println("鹏");
        //5.布尔值，只有两个值，true和false
        System.out.println(true);
        System.out.println(false);
    }

字符、字符串的字面量格式要求

  • 字符必须单引号围起来，有且仅能一个字符。
  • 字符串必须用双引号围起来。
  • 布尔类型只有2个值：false 、true

3. 变量

变量就是用来存储一个数据的内存区域（可以理解成盒子），且里面存储的数据可以变化。

变量定义的格式

数据类型 变量名称 = 初始值

数据类型：强制限制盒子中存储数据的形式。例如：int（整数类型）、 double(小数类型)
变量名称：取名称，首字母建议小写，有意义。
初始值：存储的初始数据

实例

public static void main(String[] args) {
        //目标：学会使用变量
        //数据名称 变量 = 初始值
        double money = 6.0;
        System.out.println(money);//6.0
        //收钱（从=右往左看）
        money=money + 4.0;
        System.out.println(money);//10.0

        int age=21;
        System.out.println(age);//21
        age=25;
        System.out.println(age);//25
    }

变量使用注意事项
* 变量要先声明再使用.
* 变量声明后，不能存储其他类型的数据.
* 变量的有效范围是从定义开始到}结束，且在同一个范围内不能定义两个同名的变量.
* 变量定义的时候可以没有初始值，但是使用的时候必须给初始值.

实例

public static void main(String[] args) {
        //目标：理解变量使用的注意事项
        //1.变量要先声明再使用
        int a=20;
        System.out.println(a);
        //2.变量声明后，不能存储其他类型的数据
        // a=1.5;报错
        //3.变量的有效范围是从定义开始到}结束，且在同一个范围内不能定义两个同名的变量
        {
            int b=20;
            System.out.println(b);
            //int b=100; 报错
            b=100;//赋值可以，定义不可以
        }
        // System.out.println(b);报错
        //4.变量定义的时候可以没有初始值，但是使用的时候必须给初始值
        int c;
        //System.out.println(c);报错
    }

变量在计算机中的底层原理

二进制

  • 只有0，1，按照逢2进1的方式表示数据
十进制 二进制
0 ----- 0
1 ----- 1
2 ----- 01
3 ----- 11
4 ----- 100
5 ----- 101
6 ----- 110

十进制转二进制的算法

  • 除二取余法
    除二取余法

计算机中的数据的最小单位

  • 计算机最小的组成单元是：使用8个二进制位为一组，来保存数据，我们称之为一个字节（byte，简称B）
  • 其中每个二进制位称之为一位（bit，简称b），1byte = 8bit，简写1B = 8b
  • 因此6在计算机中的存储形式为 00000110

字符在计算机中是如何存储的

  • ASCII编码表：即美国信息交换标准编码，规定了现代英语、数字字符、和其他西欧字符对应的数字编号。
    ASCII码表

图片数据在计算机中是如何存储的

  • 图片就是由无数个像素点组成的
  • 每个像素点数据：用0~255 * 255 * 255表示其颜色（RGB）
    图片数据

声音数据在计算机中是如何存储的

  • 将声波转为二进制格式存储
    声音数据

4. 数据类型

数据类型的作用

  • 数据类型就是约束变量存储数据的形式

数据类型的分类

  • 引用数据类型（除基本数据类型之外的，如String，其他的后面学习）
  • 基本数据类型：4大类8种
数据类型关键字取值范围内存占用（字数）
整数byte-128~1271
short-32768~327672
int（默认）-2147483648~2147483647 (10位数)4
long-9223372036854775808 ~ 9223372036854775807 (19位数)8
浮点数float1.401298e-45 ~ 3.402823e+384
double（默认）4.9000000e-324 ~ 1.797693e+3088
字符char0 ~ 655352
布尔booleantrue，false1
实例 
public static void main(String[] args) {
        //目标：掌握使用基本数据类型定义不同的变量
        //1、byte字节型 占1个字节  -128 ~ 127
        byte number = 98;
        //byte number1 = 128; 报错

        //2、short短整型 占2个字节
        short money = 30000;

        //3、int整型 默认的类型 占4个字节（默认使用的类型）
        int it = 879813278;

        //4、long长整型 占8个字节
        long l1 = 879813278;
        //注意：随便写一个整数字面量默认是int类型的，89821499849虽然没有超过long的范围，但是它超过了本身int类型的表示范围。
        //如果希望随便写一个整数字面量当成long类型的，需要在其后面加l/L
        long l2 = 89821499849L;

        //5、float浮点型（小数）占4个字节
        //注意，随便写一个小数字面量默认是double类型的，如果希望随便写一个小数字面量是float类型的，需要在其后面加f/F
        float score = 98.5F;

        //6、double双精度 占8个字节
        double score2 = 666.66;

        //7、char字符类型 占2个字节
        char ch = 'A';
        char ch2 = '鹏';

        //8、boolean布尔类型 占1个字节
        boolean re = true;
        boolean rs1 = false;

        //引用数据类型String
        String name = "菜菜的大鹏";
        System.out.println(name);
    }

5. 关键字、标识符

关键字

  • Java自己保留的一些单词，作为特殊功能的，例如：public、class、byte、short、int、long、double…
  • 我们不能用来作为类名或者是变量名称，否则报错。
  • 注意：关键字很多，不用刻意去记。

标识符

  • 标志符就是由一些字符、符号组合起来的名称，用于给类，方法，变量等起名字的规矩。
  • 基本要求：由数字、字母、下划线(_)和美元符($)等组成
  • 强制要求：不能以数字开头、不能是关键字、区分大小写

命名指导规范

  • 变量名称：满足标识符规则，建议全英文、有意义、首字母小写，满足“驼峰模式”，例如：int studyNumber = 59。
  • 类名称： 满足标识符规则，建议全英文、有意义、首字母大写，满足“驼峰模式”，例如：HelloWorld.java。

6. 类型转换

自动类型转换

自动类型转换：类型范围小的变量，可以直接赋值给类型范围大的变量。

底层原理：

byte a = 12;//a: 00001100 (8位)
int b = a;//b: 00000000 00000000 00000000 00001100 (32位)

自动类型转换的其他形式：

byte -> short -> int -> long -> float -> double
		char  -> int

表达式的自动类型转换

  • 在表达式中，小范围类型的变量会自动转换成当前较大范围的类型再运算。

实例

public static void main(String[] args) {
        //目标：理解自动类型转换
        byte a = 20;
        int b = a;//发生了自动类型转换
        System.out.println(a);
        System.out.println(b);

        int age = 23;
        double db = age;//自动类型转换
        System.out.println(db);

        char ch = 'a';// 00000000 01100001
        int code = ch;// 00000000 00000000 01100001
        System.out.println(code);
    }

注意事项：

  1. 表达式的最终结果类型由表达式中的最高类型决定。
  2. 在表达式中，byte、short、char 是直接转换成int类型参与运算的。

实例

public static void main(String[] args) {
        //目标：掌握表达式的自动类型转换的规则
        byte a = 10;
        int b = 20;
        double c = 1.0;
        double rs = a + b + c;
        System.out.println(rs);

        double rs2 = a + b - 2.3;
        System.out.println(rs2);

        //面试题
        byte i = 110;
        byte j = 120;
        //byte k = i + j; 报错，在表达式中，byte、short、char 是直接转换成int类型参与运算的。
        //理解：110与120均不超过int范围，但两者相加很容易超过范围
        int k = i + j;
        System.out.println(k);
    }

强制类型转换

强制类型转换： 可以强行将类型范围大的变量、数据赋值给类型范围小的变量。
底层原理：

int a = 20;			//a: 00000000 00000000 00000000 00010100 (32位)
byte b = (byte)a;								//b:00010100 (8位)
System.out.println(b); // 20

int i = 1500;		//i: 00000000 00000000 00000101 11011100 (32位)
byte j = (byte)i;								//j:11011100 (8位)
System.out.println(j); // -36

注意事项:

  • 强制类型转换可能造成数据(丢失)溢出；
  • 浮点型强转成整型，直接丢掉小数部分，保留整数部分返回。

7.运算符

运算符：对字面量或者变量进行操作的符号。

基本算术运算符

符号作用说明
+加参考幼儿园
-减参考幼儿园
*乘参考小学，与“×”相同
/除与“÷”相同，注意：在Java中两个整数相除结果还是整数。
%取余获取的是两个数据做除法的余数。

案例：数值拆分

public static void main(String[] args) {
        //需求：拆分三位数，把个位、十位、百位分别输出
        int data = 123;

        //1、个位
        int ge = data % 10;
        System.out.println(ge);
        //2、十位
        int shi = data / 10 % 10;
        System.out.println(shi);
        //3、百位
        int bai = data / 100;
        System.out.println(bai);
    }

+符号做连接符

“+”符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串。

public static void main(String[] args) {
        int a = 5 ;
        System.out.println("abc" + 'a'); // abca
        System.out.println("abc" + a); // abc5
        System.out.println(5 + a); // 10
        System.out.println("abc" + 5 + 'a');//abc5a
        System.out.println(15 + "abc" + 15);//15abc15
        System.out.println(a + 'a');//102
        System.out.println(a + "" +'a');//5a
        System.out.println(a + 'a'+" caipeng ");//102 caipeng
        System.out.println("caipeng"+ a + 'a');//caipeng5a
        System.out.println("caipeng"+ ( a + 'a' ));//caipeng102
    }

记忆：能算则算，不能算就放一起

自增自减运算符

符号作用说明
++自增变量自身的值加1
- -自减变量自身的值减1

注意：

  • ++ 和 – 既可以放在变量的后边，也可以放在变量的前边。
  • ++ 、-- 只能操作变量，不能操作字面量的。

自增自减的使用注意事项：

  • 放在变量的前面，先对变量进行+1、-1，再拿变量的值进行运算。
int a = 10;
int rs = ++a;//rs == 11
  • 放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1
int b = 10;
int rs = b++;//rs == 10

案例：自增自减

public static void main(String[] args) {
        //++ --拓展案例
        int c = 10;
        int d = 5;
        //c:10 11 12 11
        //d:5 4 5
        //rs3:    10  + 12  - 4   -  5  + 1 + 12
        int rs3 = c++ + ++c - --d - ++d + 1 + c--;
        System.out.println(rs3);
        System.out.println(c);
        System.out.println(d);
    }

赋值运算符

基本赋值运算符：‘=’

int a = 10; // 先看“=”右边，把数据10赋值给左边的变量a存储。

扩展赋值运算符：

符号作用说明
+=加后赋值a+=b 等价于 a = (a的数据类型)(a+b); 将a + b的值给a
-+减后赋值a-=b 等价于 a = (a的数据类型)(a-b); 将a - b的值给a
*=乘后赋值a*=b 等价于 a = (a的数据类型)(a*b); 将a * b的值给a
/=除后赋值a/=b 等价于 a = (a的数据类型)(a/b); 将a / b的值给a
%=取余后赋值a%=b 等价于 a = (a的数据类型)(a%b); 将a % b的值给a

注意：扩展的赋值运算符隐含了强制类型转换。

关系运算符

关系运算符： 是对数据进行条件判断的符号，最终会返回一个比较的布尔结果（false,true）。

符号说明
==a==b，判断a和b的值是否相等，成立为true，不成立为false
!=a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>a>b， 判断a是否大于b，成立为true，不成立为false
>=a>=b，判断a是否大于等于b，成立为true，不成立为false
<a<b， 判断a是否小于b，成立为true，不成立为false
<=a<=b，判断a是否小于等于b，成立为true，不成立为false

注意：在做相等判断是，千万不要把 == 误写成 =

逻辑运算符

逻辑运算符：可以把多个条件的布尔结果放在一起运算，最终返回一个布尔结果。

符号介绍说明
&逻辑与必须都是true，结果才是true; 只要有一个是false，结果一定是false。
丨逻辑或只要有一个为true、结果就是true
!逻辑非你真我假、你假我真。 !true=false 、 !false= true
^逻辑异或如果两个条件都是false或者都是true则结果是false。两个条件不同结果是true。

短路逻辑运算符：

符号介绍说明
&&短路与判断结果与“&”一样。过程是左边为 false，右边则不执行。
丨丨短路或判断结果与“丨”一样。过程是左边为 true， 右边则不执行。

注意：

  • 逻辑与 “&”、逻辑或“|”: 无论左边是 false还是 true，右边都要执行。
  • 实际开发中、常用的逻辑运算符还是：&& 、 || 、 !

三元运算符

格式：

条件表达式 ? 值1 : 值2;

执行流程：首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2。

案例：求三个整数的最大值

public static void main(String[] args) {
        //需求：求三个整数最大值
        int i = 10;
        int j = 30;
        int k = 50;
        //找出两个整数的最大值
        int temp = i > j ? i : j;
        //拿临时变量与第三个变量的值继续比较
        int rsMax = temp > k ? temp : k;
        System.out.println(rsMax);
        //或者运用三元表达式的嵌套
        int rsmax1 = i > j ? (i > k ? i : k) : (j > k ? j : k);
        System.out.println(rsmax1);
    }

运算符优先级

优先级运算符
1()
2!、-、++、- -
3*、/、%
4+、-
5<<、>>、>>>
6<、<=、>、>=、instanceof
7==、！=
8&
9^
10丨
11&&
12丨丨
13?:
14=、+=、-=、*=、/=、%=、&=

实例

System.out.println(10 > 3 || 10 > 3 && 10 < 3); // true
System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false

8.案例：键盘录入技术

API

API （Application Programming Interface,应用程序编程接口）

  • Java写好的程序(功能代码)，咱们可以直接调用。
  • Oracle 也为Java写好的程序提供了相应的 API文档(技术使用说明书) 。

实现步骤

  1. 导包：告诉程序去JDK的哪个包中找扫描器技术
  2. 写一行代码代表得到键盘扫描器对象。
  3. 等待接收用户输入数据。
package com.dapeng.scanner;

import java.util.Scanner;

//1.导包操作（并不需要自己写，以后通过工具进行导入更加方便）
public class ScannerDemo {
    public static void main(String[] args) {
        //目标：学会使用键盘录入技术
        //2.得到一个键盘扫描器对象
        Scanner scanner = new Scanner(System.in);

        //3.调用scanner对象的功能等待接收用户输入的数据
        //这个代码会等待用户输入数据，直到用户输入完数据并按了回车键就会把数据拿到
        System.out.println("请输入您的年龄");
        int age = scanner.nextInt();
        System.out.println("您的年龄是 " + age);

        System.out.println("请输入您的名称：");
        String name = scanner.next();
        System.out.println("您的名字是 " + name);

    }
}

9.程序流程控制

流程控制语句：Java提供了一些流程控制语句，来控制程序的执行流程。

顺序结构

如果你没有写其他的结构，按照代码的先后顺序，依次执行程序中大多数的代码都是这样顺次执行的。

public class Test {
    public static void main(String[] args) {
        System.out.println("A");
        System.out.println("B");
        System.out.println("C");
    }
}

分支结构

if

if分支：根据判断的结果（真或假）决定执行某个分支的代码。
if分支有三种格式：

格式1：
if (条件表达式) {
	语句体;
}
执行流程： 首先判断条件表达式的结果，如果为true执行语句体，为 false 就不执行语句体。
注意： if 语句中，如果大括号控制的只有一行代码，则大括号可以省略不写。

格式2：
if (条件表达式) {
	语句体1;
} else {
	语句体2;
}
执行流程：首先判断条件表达式的结果，如果为true执行语句体1，为 false 就执行语句体2。

格式3：
if (条件表达式1) {
	语句体1;
} else if (条件表达式2) {
	语句体2;
} else if (条件表达式3) {
	语句体3;
} 
. . .
else {
	语句体n+1;
}
执行流程：
1.先判断条件1的值，如果为true则执行语句体1，分支结束；如果为false则判断条件2的值
2.如果值为true就执行语句体2，分支结束；如果为false则判断条件3的值
3....
4.如果没有任何条件为true，就执行else分支的语句体n+1。

实例

public static void main(String[] args) {
        //目标：学会使用if分支结构解决问题，理解其流程

        //需求：心跳60-100之间是正常的，否则系统提示进一步检查
        //格式1
        int heartBeat = 30;
        if(heartBeat < 60 || heartBeat > 100){
            System.out.println("您的心跳数据是："+heartBeat+",您可能需要进一步检查！");
        }
        System.out.println("检查结束！");

        //需求：发红包
        // 格式2
        double money = 5000;
        if(money >= 1314){
            System.out.println("发送成功！");
        }
        else{
            System.out.println("穷比~~");
        }

        //需求：绩效系统
        //格式3
        int score = 99;
        if(score >= 0 && score < 60){
            System.out.println("C");
        }
        else if(score >= 60 && score < 80){
            System.out.println("B");
        }
        else if(score >= 80 && score < 90){
            System.out.println("A");
        }
        else if(score >=90 && score <= 100){
            System.out.println("A+");
        }
        else{
            System.out.println("分数有误！");
        }
    }

switch

switch分支：也是匹配条件去执行分支, 适合做值匹配的分支选择，结构清晰，格式良好。

switch(表达式){
        case 值1:
        	执行代码...;
        	break;
        case 值2:
        	执行代码...;
        	break;
        …
        case 值n-1:
        	执行代码...;
        	break;
default:
        执行代码n;
}
执行流程：
1.先执行表达式的值，拿着这个值去与case后的值进行匹配。
2.匹配哪个case的值为true就执行哪个case，遇到break就跳出switch分支。
3.如果case后的值都不匹配则执行default代码。

实例

public static void main(String[] args) {
        String weekday = "周三";
        switch(weekday){
            case "周一":
                System.out.println("周一认真打麻将，杠开海底捞月");
                break;
            case "周二":
                System.out.println("周二认真打麻将，两杠清一色自摸");
                break;
            case "周三":
                System.out.println("周三认真打麻将，十二金钗");
                break;
            case "周四":
                System.out.println("周四认真打麻将，自摸清金钩钓");
                break;
            case "周五":
                System.out.println("周五认真打麻将，地胡");
                break;
            case "周六":
                System.out.println("周六认真打麻将，十八罗汉");
                break;
            case "周日":
                System.out.println("周日认真打麻将，天胡清三龙七对");
                break;
            default:
                System.out.println("输光了呜呜呜呜呜呜呜~~");
        }

if、switch分支各自适合做什么业务场景：

  • if其实在功能上远远强大于switch。
  • if适合做区间匹配。
  • switch适合做：值匹配的分支选择、代码优雅。

switch分支注意事项：

  1. 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String，不支持double、float、long。
  2. case给出的值不允许重复，且只能是字面量，不能是变量。
  3. 不要忘记写break，否则会出现穿透现象。

switch的穿透性

switch的穿透性：如果代码执行到没有写break的case块，执行完后将直接进入下一个case块执行代码（而且不会进行任何匹配），直到遇到break才跳出分支。
注意： 存在多个case分支的功能代码是一样时，可以用穿透性把流程集中到同一处处理，这样可以简化代码。

实例

public static void main(String[] args) {
        int month = 7;
        switch (month){
            case(1):
            case(3):
            case(5):
            case(7):
            case(8):
            case(10):
            case(12):
                System.out.println(month + "是31天！");
                break;
            case(2):
                System.out.println(month + "闰年29天，非闰年28天！");
                break;
            case(4):
            case(6):
            case(9):
            case(11):
                System.out.println(month + "是30天！");
                break;
            default:
                System.out.println("数据有误！");
        }

循环结构

for循环

控制一段代码执行很多次。

格式：
for (初始化语句; 循环条件; 迭代语句) {
	循环体语句(重复执行的代码);
}
案例：
// 输出3次HelloWorld
for (int i = 0; i < 3; i++) {
	System.out.println("Hello World");
}
执行的流程:
1.循环一开始，执行int i = 0 一次。
2.然后判断循环条件：0 < 3 返回true ,进入到循环体中执行输出 ：helloWorld ，然后执行迭代语句i++ , 此时i=1了。
3.然后判断循环条件：1 < 3 返回true ,进入到循环体中执行输出 ：helloWorld ，然后执行迭代语句i++ , 此时i=2了。
4.然后判断循环条件：2 < 3 返回true ,进入到循环体中执行输出 ：helloWorld， 然后执行迭代语句i++ , 此时i=3了。
5.然后判断循环条件：3 < 3 返回false, 循环立即结束！！

while循环

初始化语句;
while (循环条件) {
	循环体语句(被重复执行的代码);
	迭代语句;
}
案例：
int i = 0;
while (i < 3) {
	System.out.println("Hello World");
	i++;
}

什么时候用for循环，什么时候用while循环？

  • 功能上是完全一样的，for能解决的while也能解决，反之亦然。
  • 使用规范是：知道循环几次：使用for；不知道循环几次建议使用：while。

do while循环

先执行再判断循环条件。
do-while循环的特点：一定会先执行一次循环体。

初始化语句;
do {
	循环体语句;
	迭代语句;
} while (循环条件);
案例：
int i = 0;
do {
	System.out.println(“Hello World！");
	i++;
} while(i < 3);

死循环

死循环：一直循环的执行下去，如果没有干预不会停止下来。

//三种死循环
for(;;) {
	System.out.println("Hello World");
}

while(true) {
	System.out.println("Hello World");
}

do {
	System.out.println("Hello World");
} while (true);

循环嵌套

循环嵌套：循环中又包含循环。
特点：外部循环每循环一次，内部循环全部执行完一次。

for(int i = 0; i < 3; i++) {
	for(int j = 0; j < 5; j++) {
		System.out.println("Hello World");
	}
}

跳转关键字：break、continue

  • break : 跳出并结束当前所在循环的执行。
  • continue: 用于跳出当前循环的当次执行，进入下一次循环。

注意：
break : 只能用于结束所在循环, 或者结束所在switch分支的执行。
continue : 只能在循环中进行使用。

案例：随机数Random类

Random随机数技术：用于在程序中获取随机数的技术。

实现步骤

  1. 导包：告诉程序去JDK的哪个包中找随机数技术
  2. 写一行代码代表得到随机数对象
  3. 调用随机数的功能获取0-9的随机数

注意： nextInt(n) 功能只能生成: 0 至 n-1之间的随机数，不包含n。

public static void main(String[] args) {
        //1.导包
        //2.创建随机数对象
        Random random = new Random();
        //3.调用nextInt方法，返回一个整型随机数
        for (int i = 0; i < 5; i++) {
            int data = random.nextInt(10);//0 -- 9 不包含10
            System.out.println(data);
        }
        System.out.println("-------------------------------------");
        for (int i = 0; i < 5; i++) {
            int data = random.nextInt(6) + 7;//7 -- 12
            //减加法    7 -- 12  ==  (0 -- 5) + 7
            System.out.println(data);
        }
    }

猜数游戏

package com.dapeng.random;

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

public class RandomTest2 {
    public static void main(String[] args) {
        Random random = new Random();
        int lucknumber = random.nextInt(100) + 1;//幸运号码位于1 -- 100之间

        //使用死循环让用户不断去猜测
        Scanner scanner = new Scanner(System.in);
        while(true){
            System.out.println("让用户输入猜测的数据（1 -- 100）：");
            int guessnumber = scanner.nextInt();

            //判断这个号码与幸运号码的大小情况
            if(guessnumber > lucknumber){
                System.out.println("您猜测的数据过大！！");
            }else if(guessnumber < lucknumber){
                System.out.println("您猜测的数据过小！！");
            }else{
                System.out.println("恭喜您，猜中了！！");
                break;//直接跳出并接受死循环
            }
        }
    }
}

10.数组

数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）。

20, 10, 80, 60, 90
int[] arr = {20, 10, 80, 60, 90};
牛二, 西门, 全蛋
String[] names = {"牛二", "西门", "全蛋"};

数组的定义

静态初始化数组

定义数组的时候直接给数组赋值。

// 完整格式
数据类型[] 数组名 = new 数据类型[]{元素1，元素2 ，元素3… };
double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
int[] ages = new int[]{12, 24, 36}

// 简化格式
数据类型[] 数组名 = { 元素1，元素2 ，元素3，… };
int[] ages = {12, 24, 36};

数组的基本原理:
数组的基本原理

注意：数组变量名中存储的是数组在内存中的地址，数组是引用类型。

数组的访问:

数组名称[索引]
// 取值
System.out.println(arr[0]); // 12
// 赋值
arr[2] = 100;
System.out.println(arr[2]); // 100
// 获取数组的长度（就是数组元素的个数）
System.out.println(arr.length); // 3
//数组的最大索引
数组名. length – 1 // 前提：元素个数大于0

注意：

  1. “数据类型[] 数组名”也可以写成 “数据类型 数组名[] ”。
  2. 什么类型的数组存放什么类型的数据，否则报错。
  3. 数组一旦定义出来，程序执行的过程中，长度、类型就固定了。

动态初始化数组

定义数组的时候只确定元素的类型和数组的长度，之后再存入具体数据。

数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];//此时初始化各元素默认为0
//动态初始化数组的元素默认值：浮点型0.0，布尔型false，引用型null，整型0
// 后赋值
arr[0] = 10;
System.out.println(arr[0]); // 10
  • 当前已经知道存入的元素值，用静态初始化。
  • 当前还不清楚要存入哪些数据，用动态初始化。

数组的遍历

遍历：就是一个一个数据的访问。

int[] ages = {20, 30, 40, 50};
for (int i = 0; i < ages.length; i++) {
	System.out.println(ages[i]);
}

案例

数组元素求和

public static void main(String[] args) {
        //需求：数组元素求和
        int[] money = {21 , 11 , 15 , 33 , 74};
        int sum = 0;
        for (int i = 0; i < money.length; i++) {
            sum += money[i];
        }
        System.out.println(sum);
    }

数组求最值

public static void main(String[] args) {
    //需求：数组元素求最值
    int[] faceScore = {15 ,998 ,123 ,77 ,522 ,23};

    //定义一个变量用来存储最大值元素，建议使用第一个元素作为参考
    int max = faceScore[0];

    //遍历数组每一个元素，依次与最大值比较，若较大，则替换
    for (int i = 0; i < faceScore.length; i++) {
        if(faceScore[i] > max)
            max = faceScore[i];
    }

    System.out.println("数组的最大值为：" + max);
}

猜数字游戏

public static void main(String[] args) {
    //需求：5个1 - 20之间的随机数，让用户猜测，猜中要提示猜中，还要输出该数据在数组中第一次出现的索引，并打印数组内容
    //没有猜中继续
    int[] data = new int[5];

    Random random = new Random();
    for (int i = 0; i < data.length; i++) {
        data[i] = random.nextInt(20) + 1;
    }

    //使用死循环让用户猜测
    Scanner scanner = new Scanner(System.in);
    OUT: //也可以选择while(flag == 1)，当猜中时令falg = 1，并break
    while(true){
        System.out.println("请输入1 - 20之间的整数猜测：");
        int guessnumber = scanner.nextInt();

        //遍历整个数组，看是否有数据与猜测的数据相同，相同代表猜中了，给出提示
        for (int i = 0; i < data.length; i++) {
            if(data[i] == guessnumber){
                System.out.println("您已经猜中了！您猜中的数字索引是：" + i);
                break OUT;//结束整个死循环，游戏结束
            }
        }
        System.out.println("猜测数据在数组中不存在！请重新猜测！");
    }
    for (int i = 0; i < data.length; i++) {
        System.out.print(data[i] + "\t");
    }
}

随机排名

public static void main(String[] args) {
    //目标：键盘录入一组工号，将其乱序输出
    int[] codes = new int[5];

    //输入
    Scanner scanner = new Scanner(System.in);
    for (int i = 0; i < codes.length; i++) {
        System.out.println("请您输入第"+(i+1)+"个员工的工号");
        int code = scanner.nextInt();
        codes[i] = code;
    }

    //打乱顺序
    Random random = new Random();
    for (int i = 0; i < codes.length; i++) {
        //当前遍历的元素为codes[i]
        //随机一个索引值index
        int index = random.nextInt(codes.length);
        //交换元素位置
        int temp = codes[i];
        codes[i] = codes[index];
        codes[index] = temp;
    }

    //遍历数组
    for (int i = 0; i < codes.length; i++) {
        System.out.print(codes[i]+"\t");
    }
}

数组排序

数组排序：对数组中的元素，进行升序(由小到大)或者降序（由大到小）的操作。

数组排序的技术：

  • 冒泡排序
  • 选择排序
  • 快速排序
  • 插入排序
  • …

暂不多做讨论

数组的内存图

Java内存分配、数组内存图

Java内存分配介绍：

  • 方法区 : 字节码文件加载时进入的内存
  • 栈 : 方法运行时所进入的内存,变量也是在这里
  • 堆 : new 出来的东西会在这块内存中开辟空间并产生地址
  • 本地方法栈
  • 寄存器

示例：

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int[] arr = new int[]{11, 22, 33};
        arr[0] = 44;
        arr[1] = 55;
        arr[2] = 66;
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
    }
}

更改数组值时会直接更改堆内存中的值
请添加图片描述

两个变量指向同一个数组

示例：

public class Test2{
    public static void main(String[] args) {
        int[] arr1 = {11, 22, 33};
        int[] arr2 = arr1;
        System.out.println(arr1);
        System.out.println(arr2);
        arr2[1] = 99;
        System.out.println(arr1[1]);
        System.out.println(arr2[1]);
    }
}
输出：
[I@1d251891
[I@1d251891
99
99

最终指向的内存是同一片空间：
在这里插入图片描述

11.方法

方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用。

使用方法的好处:

  • 提高了代码的复用性。
  • 让程序的逻辑更清晰。

方法定义、调用

//方法定义的完整格式
修饰符 返回值类型 方法名( 形参列表 ){
	方法体代码(需要执行的功能代码)
	return 返回值;
}

//示例：使用方法对2个整数求和并返回。
//方法的修饰符 public static
//返回值类型 int
//add 方法名称
//int a,int b 形参列表
public static int add ( int a , int b ){
	int c = a + b;
	return c;
}

//方法必须调用才可以跑起来，调用格式：方法名(…);
int sum = add(10, 20);
System.out.println(sum);

方法格式：

  • 方法的修饰符：暂时都使用public static 修饰。
  • 方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据。
  • 形参列表可以有多个，甚至可以没有； 如果有多个形参，多个形参必须用“，”隔开，且不能给初始化值。

注意:

  • 方法不需要返回结果，则申明返回值类型为void；方法不需要参数，则形参列表可以不写。
  • 方法没有申明返回值类型，内部不能使用return返回数据。
  • 方法如果没有形参列表，调用的时候则不能传入参数值，否则报错。

方法使用的常见问题

  1. 方法的编写顺序无所谓。
  2. 方法与方法之间是平级关系，不能嵌套定义。
  3. 方法的返回值类型为void（无返回值），方法内则不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必
    须使用return返回对应类型的数据。
  4. return语句下面，不能编写代码，因为永远执行不到，属于无效的代码。
  5. 方法不调用就不执行, 调用时必须严格匹配方法的参数情况。
  6. 有返回值的方法调用时可以选择定义变量接收结果，或者直接输出调用，甚至直接调用；无返回值方法的调用只能直接调用。

方法案例

计算1-n的和返回

public static void main(String[] args) {
        //需求：使用方法计算1 - n的和并返回
        System.out.println("1 - 5的和为" + sum(5));
        System.out.println("----------------------");
        System.out.println("1 - 10的和为" + sum(10));
    }
    //因n不固定，故方法需要声明形参接收；要返回结果，还需申明返回值类型。
    public static int sum(int n){
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
        }
        return sum;
    }

判断整数是奇数还是偶数

public static void main(String[] args) {
        //需求：判断一个整数是奇数还是偶数
        check(5);
        System.out.println("---------------");
        check(12);
    }
    public static void check(int number){
        if(number%2 == 0)
            System.out.println(number + "是偶数");
        else
            System.out.println(number + "是奇数");
    }

数组求最值案例改方法实现

public static void main(String[] args) {
        //需求：使用方法，支持找出任意整型数组的最大值
        int[] arr = {13,22,456,111,266,333,941,44};
        System.out.println("数组最大值为" + max(arr));
    }
    public static int max(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max < arr[i])
                max = arr[i];
        }
        return max;
    }

方法调用的内存图

  • 方法没有被调用的时候，在方法区中的字节码文件中存放
  • 方法被调用的时候，需要进入到栈内存中运行
public class Test {
    public static void main(String[] args) {
        int sum = add(10, 20);
        System.out.println(sum);
    }
    public static int add(int a, int b ){
        int c = a + b;
        return c;
    }
}

在这里插入图片描述

  • main方法和add方法依次存放在方法区的字节码文件中
  • 随程序进行，首先执行main方法（将main方法压入栈），在执行过程中调用add方法（将add方法压入栈），执行完毕后，依次退栈。
  • 方法在栈中运行

方法的参数传递机制

Java的参数传递机制：值传递

  • 在传输实参给方法的形参的时候，并不是传输实
    参变量本身， 而是传输实参变量中存储的值，这
    就是值传递。

注意：
实参：如在方法内部定义的变量。
形参：如在定义方法时，“()”中所声明的参数。

基本类型的参数传递

public class Test {
    public static void main(String[] args) {
        int a = 10;
        change(a);//将实参a的值拷贝了一份赋值给了change方法中的形参a，两个a除同名外无任何关系
        System.out.println(a); // 10
    }
    public static void change(int a){
        System.out.println(a); // 10
        a = 20;
        System.out.println(a); // 20
    }
}

引用类型的参数传递

public class Test {
    public static void main(String[] args) {
        int[] arrs = new int[]{10, 20, 30};
        change(arrs);//将实参arrs存储的地址拷贝了一份赋值给了change方法中的形参arrs，在方法中访问的是与外部实参同样的地址，因此内容会更改
        System.out.println(arrs[1]); // 222
    }
    public static void change(int[] arrs){
        System.out.println("方法内部2："+arrs[1]); // 20
        arrs[1] = 222;
        System.out.println("方法内部2："+arrs[1]); // 222
    }
}

基本类型和引用类型的参数在传递时的区别

  • 都是值传递。
  • 基本类型的参数传输存储的数据值。
  • 引用类型的参数传输存储的地址值。

方法的参数传递案例

打印数组内容

public static void main(String[] args) {
        //需求：打印任意整型数组的内容
        int[] array = {12,14,22,55,32,45};
        printArray(array);
        System.out.println("----------------------");
        int[] number = {22,53,653,222,56,33,111,243,-142};
        printArray(number);
    }
    public static void printArray(int[] array){
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
//            if(i == array.length-1)
//                System.out.print(array[i]);
//            else
//                System.out.print(array[i]+",");
            System.out.print(i == array.length - 1 ? array[i] : array[i] + ",");
        }
        System.out.println("]");
    }

从数组中查询元素的索引返回

public static void main(String[] args) {
        //需求：从整型数组中查找某个数据的索引返回，若不存在则返回-1
        int[] arr = {11,24,44,253,44,234};
        int index = searchIndex(arr,24);
        System.out.println("您查找的数据的索引是" + index);
    }
    public static int searchIndex(int[] arr , int data){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == data)
                return i;
        }
        return -1;
    }

比较两个数组内容是否相等

public static void main(String[] args) {
        //需求：比较任意两个整型数组的内容是否一样，一样返回true，不一样则返回false
        int[] arr1 = {10,20,30};
        int[] arr2 = {10,20,30};
        System.out.println(compare(arr1,arr2));
    }
    public static boolean compare(int[] arr1,int[] arr2){
        if(arr1.length == arr2.length){
            for (int i = 0; i < arr1.length; i++) {
                if(arr1[i] != arr2[i])
                    return false;
            }
            return true;
        }else{
            return false;
        }
    }

方法重载

方法重载：同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。
实例

public class Test {
    /**（1）默认发一枚武器。*/
    public static void fire(){
        System.out.println("默认发射一枚武器给米国！");
    }
    /** （2）可以指定地区发射一枚武器。 */
    public static void fire(String location){
        System.out.println("给"+location+"发射一枚武器！");
    }
    /**（3）可以指定地区发射多枚武器。*/
    public static void fire(String location , int nums){
        System.out.println("给"+location+"发射"+nums+"枚武器！");
    }
}

注意：调用方法的时候,会通过参数的不同来区分调用的是哪个方法

方法重载的作用

可读性好，方法名称相同提示是同一类型的功能，通过形参不同实现功能差异化的选择，这是一种专业的代码设计。

方法重载的识别技巧

  • 只要是同一个类中，方法名称相同、形参列表不同，那么他们就是重载的方法，其他都不管！
    （如：修饰符，返回值类型都无所谓）
  • 形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。

补充知识：单独使用return关键字

return; —> 可以立即跳出并结束当前方法的执行; return关键字单独使用可以放在任何方法中。

public class Test {
    public static void main(String[] args) {
        System.out.println("开始");
        chu(10 , 0);
        System.out.println("结束");
    }
    public static void chu(int a , int b){
        if(b == 0){
            System.err.println("您的数据有误！！不执行！！");
            return; // 直接结束当前方法chu
        }
        int c = a / b;
        System.out.println("除法结果是："+c);
    }
}

如果要直接结束当前方法的执行，怎么解决？

  • return; 跳出并立即结束所在方法的执行。
  • break; 跳出并结束当前所在循环的执行。
  • continue; 结束当前所在循环的当次继续，进入下一次执行

12.Java基础部分案例训练

案例一：买飞机票

需求:

  • 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
  • 按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。

分析：

  • 定义一个方法可以进行键盘录入机票原价、月份和机舱类型。
  • 使用if判断月份是是旺季还是淡季，使用switch分支判断是头等舱还是经济舱。
  • 选择对应的折扣进行计算并返回计算的结果。
public class demo1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("机票原价：");
        double price = scanner.nextInt();
        System.out.println("月份：");
        int month = scanner.nextInt();
        System.out.println("仓位类型（头等舱经济舱）：");
        String type = scanner.next();

        double rs = calc(price,month,type);
        System.out.println("机票价格为："+rs);
    }
    //1.定义一个方法，形参（原价，月份，头等舱经济舱）返回值类型double
    public static double calc(double money, int month, String type){
        //判断月份是淡季还是旺季
        if(month >= 5 && month <= 10){
            //旺季
            switch(type){
                case "经济舱":
                    money *= 0.85;
                    break;
                case "头等舱":
                    money *= 0.9;
                    break;
                default:
                    System.out.println("您输入的仓位不正确！！");
                    money = -1;
            }
        }else if(month == 11 || month == 12 || month >=1 && month <= 4){

        }
        else{
            System.out.println("月份有问题！");
            money = -1;
        }
        return money;
    }

}

案例二：找素数

需求：

  • 判断101到200之间有多少素数，并输出所有素数

说明:

  • 素数：如果除了1和它本身以外，不能被其他正整数整除，就叫素数。

分析:

  • 101-200之间的数据可以采用循环依次拿到; 每拿到一个数，判断该数是否是素数。
  • 判断规则是：从2开始遍历到该数的一半的数据，看是否有数据可以整除它，有则不是素数，没有则是素数。
public class demo2 {
    public static void main(String[] args) {
        for (int i = 101; i <= 200; i++) {
            boolean flag = true;//信号位，一开始认为当前数是素数

            //判断当前数字是否是素数
            for (int j = 2; j <= i/2; j++) {//遍历2开始到该数的一半的数据去判断是否有整除它的
                if(i % j == 0){
                    flag = false;
                    break;
                }
            }
            if(flag == true){
                System.out.print(i + "\t");
            }
        }
    }
}

案例三：开发验证码

需求：

  • 定义方法实现随机产生一个5位的验证码，每位可能是数字、大写字母、小写字母。

分析：

  • 定义一个方法，生成验证码返回：方法参数是位数、方法的返回值类型是String。
  • 在方法内部使用for循环生成指定位数的随机字符，并连接起来。
  • 把连接好的随机字符作为一组验证码进行返回。
public class demo3 {
    public static void main(String[] args) {
        String code = createCode(5);
        System.out.println(code);
        
        System.out.println(createCode(10));
    }
    public static String createCode(int n){
        String code = "";
        Random random = new Random();
        for (int i = 0; i < n; i++) {
            int type = random.nextInt(3);
            switch (type){
                case 0:
                    //大写字符(A 65 ~ Z 65+25)(0 ~ 25) +65
                    char ch = (char)(random.nextInt(26) + 65);
                    code += ch;
                    break;
                case 1:
                    //小写字符(a 97 ~ z 97+25)(0 ~ 25) +97
                    char ch1 = (char)(random.nextInt(26) + 97);
                    code += ch1;
                    break;
                case 2:
                    //数字字符
                    code += random.nextInt(10);
                    break;
            }
        }
        return code;
    }
}

案例四：数组元素的复制

需求：

  • 把一个数组中的元素复制到另一个新数组中去。

分析：

  • 需要动态初始化一个数组，长度与原数组一样。
  • 遍历原数组的每个元素，依次赋值给新数组。
  • 输出两个数组的内容。
public class demo4 {
    public static void main(String[] args) {
        int[] arr1 = {10,22,53,333,11};

        int[] arr2 = new int[arr1.length];
        copy(arr1,arr2);
        printArray(arr2);
    }
    public static void copy(int[] arr1, int[] arr2){
        for (int i = 0; i < arr1.length; i++) {
            arr2[i] = arr1[i];
        }
    }
    public static void printArray(int[] array){
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            System.out.print(i == array.length - 1 ? array[i] : array[i] + ",");
        }
        System.out.println("]");
    }
}

案例五：评委打分

需求 :

  • 在唱歌比赛中，有6名评委给选手打分，分数范围是[0 - 100]之间的整数。选手的最后得分为：去掉最高分、最低分后的4个评委的平均分，请完成上述过程并计算出选手的得分。

分析：

  • 把6个评委的分数录入到程序中去 ----> 使用数组(int[] scores = new int[6]; )
  • 遍历数组中每个数据，进行累加求和，并找出最高分、最低分。
  • 按照分数的计算规则算出平均分。
public class demo5 {
    public static void main(String[] args) {
        int[] scores = new int[6];

        //录入六个评委的分数
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < scores.length; i++) {
            System.out.println("请您输入第"+(i+1)+"个评委的打分");
            int score = scanner.nextInt();
            scores[i] = score;
        }

        //遍历数组每个元素，找出最大最小值，计算总分
        int max = scores[0],min = scores[0],sum = 0;
        for (int i = 0; i < scores.length; i++) {
            if(scores[i] > max)
                max = scores[i];
            if(scores[i] < min)
                min = scores[i];
            sum += scores[i];
        }

        //统计平均分
        double result = (sum - max - min)*1.0/(scores.length - 2);
        System.out.println("选手最终得分为"+result);
    }
}

案例六：数字加密

需求：

  • 某系统的数字密码，比如1983，采用加密方式进行传输，规则如下：先得到每位数，然后每位数都加上5 , 再对10求余，最后将所有数字反转，得到一串新数。

分析:

  • 将每位数据存入到数组中去，遍历数组每位数据按照规则进行更改，把更改后的数据从新存入到数组中。
  • 将数组的前后元素进行交换，数组中的最终元素就是加密后的结果。
public class demo6 {
    public static void main(String[] args) {
        System.out.println("请输入需要加密的数字个数");
        Scanner scanner = new Scanner(System.in);
        int length = scanner.nextInt();
        int[] arr = new int[length];

        //录入需要加密的数字
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第"+(i+1)+"个数字");
            int number = scanner.nextInt();
            arr[i] = number;
        }

        //打印数组内容看一下
        printArray(arr);

        //进行加密
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (arr[i] + 5) % 10;
        }
        //进行反转
        for (int i = 0,j = arr.length - 1; i < j; i++,j--) {
            //直接交换两者位置即可
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        printArray(arr);


    }
    public static void printArray(int[] array){
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            System.out.print(i == array.length - 1 ? array[i] : array[i] + ",");
        }
        System.out.println("]");
    }
}

案例七：模拟双色球[拓展]

在这里插入图片描述

public class demo7 {
    public static void main(String[] args) {
        //生成随即号码
        int[] luckNumbers = createLuckNumber();
        //printArray(luckNumbers);
        //用户输入号码
        int[] userNumbers = userInputNumbers();
        //判断中奖情况
        judge(luckNumbers,userNumbers);
    }

    public static void judge(int[] luckNumbers, int[] userNumbers){
        //定义两个变量，分别存储红球命中个数与蓝球命中个数
        int redHitNumbers = 0,blueHitNumbers = 0;

        //判断红球命中了几个，开始统计
        for (int i = 0; i < userNumbers.length - 1; i++) {
            for (int j = 0; j < luckNumbers.length - 1; j++) {
                if(userNumbers[i] == luckNumbers[j]){
                    redHitNumbers++;
                    break;
                }
            }
        }

        //判断蓝球号码是否命中
        blueHitNumbers = luckNumbers[luckNumbers.length - 1] == userNumbers[userNumbers.length - 1] ? 1 : 0;

        System.out.println("中奖号码是：");
        printArray(luckNumbers);
        System.out.println("您的号码是：");
        printArray(userNumbers);
        System.out.println("您命中了几个红球：" + redHitNumbers);
        System.out.println("蓝球是否命中：" + (blueHitNumbers == 1 ? "是" : "否"));

        //判断中奖情况
        if(blueHitNumbers == 1 && redHitNumbers < 3){
            System.out.println("中5元");
        }else if(blueHitNumbers == 1 && redHitNumbers == 3 || blueHitNumbers == 0 && redHitNumbers == 4){
            System.out.println("中10元");
        }else if(blueHitNumbers == 1 && redHitNumbers == 4 || blueHitNumbers == 0 && redHitNumbers == 5){
            System.out.println("中200元");
        }else if(blueHitNumbers == 1 && redHitNumbers == 5){
            System.out.println("中3000元");
        }else if(blueHitNumbers == 0 && redHitNumbers == 6){
            System.out.println("中500万");
        }else if (blueHitNumbers == 1 && redHitNumbers == 6){
            System.out.println("中1000万");
        }
    }

    public static void printArray(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
    }

    public static int[] userInputNumbers(){
        int[] numbers = new int[7];
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < numbers.length - 1; i++) {
            System.out.println("请您输入第"+(i+1)+"个红球号码（1-33，要求不重复）：");
            int data = scanner.nextInt();
            numbers[i] = data;
        }
        System.out.println("请输入蓝球号码（1-16）：");
        numbers[numbers.length-1] = scanner.nextInt();
        return numbers;
    }

    public static int[] createLuckNumber(){
        int[] numbers = new int[7];
        Random random = new Random();

        //遍历前6个位置，生成六个不重复的红球号码，范围是1 - 33
        for (int i = 0; i < numbers.length - 1; i++) {
            while(true){
                int data = random.nextInt(33) + 1;//1 - 33

                //判断当前号码是否已经出现过，若出现过则随重新随机，直到出现新号码
                boolean flag = true;//默认未重复
                for (int j = 0; j < i; j++) {
                    if(data == numbers[j]){
                        flag = false;
                        break;
                    }
                }
                if(flag){
                    numbers[i] = data;
                    break;
                }
            }
        }

        //为第7个位置生成1个蓝球号码，范围是1 - 16
        numbers[numbers.length - 1] = random.nextInt(16) + 1;
        return numbers;
    }
}

Java基础部分完结

菜菜的大鹏
关注
专栏目录
java基础语法笔记
oldmonk
07-24 167
&#13; 这段时间看了一些java，急了一些笔记，记下一遍以后复习用！&#13; 2016-07-24 15:12:40&#13; java很多语法都跟C#类似，下面列举一些不同的地方******注意***** java中的系统方法首字母都是小写的，而C#中首字母都是大写的1、java中继承的用法 　　class children extends parent 　　{ 　　...
Java语法笔记
Naisu的各种笔记
10-20 574
以前做东西都赶时间需要什么百度什么，很多时候因为这种方式导致学的东西太片面，总体下来反而花了很多冤枉时间，在语法方面这个情况更加明显。这次趁着项目中再一次用到Java，就花点时间对相关语法做个记录，方便自己后期查阅。
Java语法学习笔记
Joker_xun的博客
02-27 242
1.final变量 ：在程序运行工程中一直不会改变的常量。 2.static 静态变量：静态变量的有效范围可以跨类，甚至可达到整个应用程序之中。 3.&amp;amp;amp;amp;amp;amp;amp;amp;amp;与&amp;amp;amp;amp;amp;amp;amp;amp;amp;&amp;amp;amp;amp;amp;amp;amp;amp;amp;的区别：使用逻辑运算符&amp;amp;amp;amp;amp;amp;amp;amp;amp;，
Java基础语法（笔记）
weixin_74774974的博客
04-01 305
关键字：都是小写的，jdk1.2多了strictfp(经准浮点型)，关键字 jdk1.4多了assert(断言)关键字，jdk1.5多了enum(枚举) 关键字。我们可以向数据类型的取值范围看作是一个圆，每多一个数据向前移动一个，当数据达到最大值时，我们再加 1，可以就会变成最小值，这就是数据的溢出。3、 类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写。throws 在方法后边声明异常，其实就是自己不想对异常做出任何的处理，告诉别人自己可能出现的异常，交给别人处理，让别人处理。
Java 语法学习笔记（一）
MLee 的博客
01-14 711
Java 语法学习笔记（一） Java 基础语法 文章目录Java 语法学习笔记（一）参考教程介绍基础语法类和对象源文件声明规则基本类型内置数据类型引用类型Java 常量Java 变量类型局部变量实例变量类变量（静态变量）Java 修饰符static 修饰符final 修饰符abstract 修饰符synchronized 修饰符transient 修饰符volatile 修饰符Java 运算符...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
狂神说Java学习笔记基础语法
07-16
"狂神说Java学习笔记基础语法"是一份详细的学习资源，涵盖了Java编程的基础概念和语法要点。这份资料包括了笔记、源代码示例以及相关的图片解释，帮助初学者深入理解和掌握Java编程。 1. **Java简介**： Java由Sun...
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性，成为跨平台应用开发的首选语言。Java的基础部分主要包括...
java学习笔记markdown
03-12
1. **Java基础**：介绍Java语言的基本语法，如变量、数据类型、运算符、控制流程（条件语句、循环）、数组、字符串以及异常处理。这些基础知识是理解和编写任何Java程序的基石。 2. **面向对象编程**：深入讲解Java...
《java学习》-java学习笔记.zip
最新发布
04-02
这份《java学习》笔记包含了多个核心主题，旨在帮助初学者和有经验的开发者深入理解和掌握Java技术。 1. **正则表达式（正则.md）**： 正则表达式在Java中用于文本匹配和搜索，是处理字符串的强大工具。Java提供了...
Java语法笔记-综合
未名
05-27 131
1. 初始化   instance variable：在声明时简单赋值，构造函数，initializer block（暂时不知道这种风格好不好），method（effective java提倡final method，暂时未看）。java编译器会把initializer block插入每个构造函数中      class variable： 用static block或者static...
Java基础语法笔记（个人笔记）
qq_44897467的博客
03-28 445
1.注释 //+ 注释内容 快捷键： Ctrl+/ 添加注释以及取消注释。 /* 注释内容 */快捷键：Ctrl+shift+/ 选中的行添加注释。 快捷键：Ctrl+shift+\ 作用是取消选中行的注释。 2.输出语句 System.out.println(要输出的内容);//内容结尾会加一个换行符。 System.out.print(要输出的内容);//不会换行。 快捷键：先输入sout，然后按Alt+/ 3.转义字符 4.数据类型的分类 5.类型转换 类型转换指的是...
Java的基本语法（笔记）
pp0919的博客
06-24 148
基本语法： 注意点： 1、大小写敏感 2、类名，首字母大写 3、方法名，首字母小写，后面的字母大写 4、源文件名：必须和类名相同，以“.java”作为后缀，如果类名和源文件名不同，会编译错误 5、主方法入口：所有的 Java 程序由 public static void main(String []args) 方法开始执行 其他人的笔记，可参考点： 一、命名规范 1、 项目名全部小写 2、 包名全...
java语法笔记_1
qq_44143877的博客
10-13 237
初学java-基本运算符 学习了c语言之后第一次接触java，感觉java在基本语法方面和c语言有很大的共同点。类比C语言的语法 1.HelloWorld HelloWorlds是学习语言的第一步 package com.imooc; public class HelloWorld { public static void main(String[] args){ System.ou...
Java基本语法笔记一
herry57的博客
03-07 232
一、基本语法 1、java大小写敏感。 2、类名首字母需要大写，若由若干个单词组成，则必须每一个单词首字母大写。 3、源文件名必须与类名相同，源文件名是xxx.java。（若不相同，则会出现编译时错误） 4、方法名须小写，若由若干个单词组成，则从第二个单词开始每一个单词首字母大写。 二、标识符（类名、方法名和变量名） 1、标识符第一个首字母不应该是数字，一般是大小写字母，$和_。 2...
Java初级语法笔记
Flappy BIrd
09-25 253
教程地址：https://www.runoob.com/java/java-tutorial.html 修饰符 访问控制修饰符 default 变量：public static final 方法：public public protect private 非访问类修饰符 static：静态方法 静态变量 final：变量 方法 类 abstract ...
JAVA基础语法笔记（黑马程序员系列）
qq_50822354的博客
04-17 1589
1. Java概述 1.1 Java语言发展史（了解） 语言：人与人交流沟通的表达方式 计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言 Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言 Java之父：詹姆斯·高斯林（James Gosling） 2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：https://www.oracle.com 1.2 Java语言跨平台原理（理解） Java程
Java学习笔记：基础语法与面向对象
"Java Record.pdf 是一份详细的Java学习笔记，包含十万字的文本内容和代码示例，旨在帮助读者深入理解Java编程语言的基础语法和面向对象特性。笔记内容层次分明，便于学习和参考。" 本笔记主要分为两个部分：Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

菜菜的大鹏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值