JAVA学习日志:第二章基础篇

真摸鱼的大学生

已于 2025-04-16 11:26:52 修改

阅读量1.2k

点赞数 17

文章标签：学习

于 2025-02-21 22:53:07 首次发布

本文链接：https://blog.youkuaiyun.com/sj1174656735/article/details/145785850

版权

一.内容介绍

(1)java特性

1.面向对象的（oop）

2.健壮性

3.强制类型进制

4.异常处理

5.垃圾自动收集

6.跨平台性

7.解释型语言

解释型:java编译后.class文件不能直接在系统上直接运行,需要解释器来执行

编译型(c语言):编译后的二进制文件可以在系统上直接执行

二.快速入门

idae入门操作:idae入门操作-优快云博客

(1)写出第一个程序HelloWorld

//class表示一个类 HelloWordld表示的是类的名字
public class HelloWorld { //HelloWorld类的开始
        public static void main(String[] args){
        System.out.println("HelloWorld");
    }
} //HelloWorld类的结束

主方法在idae中还有一个快捷写法psvm

(2)编译和运行

1.文本编辑的编译和运行

在java文件目录下输入cmd

编译

后在dos命令台输入

javac java文件名.java

运行

在到dos命令台输入

java java文件名

2.idae的编译运行

idae可以直接右击选择Run

这个可以直接编译运行程序

(3)运行过程

1.源文件（java文件）

我们写的代码就是源文件

2.编译

我们编写的java文件计算机不能直接执行

需要将源文件转换为字节码文件(class文件)

而这个过程叫编译

3.字节码文件

java文件编译后的字节码文件

4.运行

将字节码文件装载到JAVA虚拟机(JVM)里面

虚拟机将字节码文件翻译成计算机可执行的语言

然后dos将可执行语言打印在输出在控制台里

这个过程叫运行

(4)JAVA跨平台原理

1.java程序是如何执行的

java编写的语言计算机无法执行，需要通过java编译器(javac)，将java文件编译成class文件，在提供一个java虚拟机（jvm）来装载class文件翻译成计算机能识别的指令

2.如何跨平台

依靠java的运行环境，java环境中包括java虚拟机，虚拟机装载class文件翻译成相应操作系统能够识别的指令

这些平台包括:windows unix linux maoc

(5)注释

1.注释介绍

作用

注释代码是为了长久没动过的代码还很容易忘记，注释可以回忆会更快一些（此笔记也是为了忘了时可以回顾快一点写的），而且可以方便别人接受你的工作时候可以更快理解代码作用

使用细节

注释内容不会被jvm虚拟机执行

2.单行注释

写法:（该斜杠是正斜杠）

//System表示系统的意思，out表示系统输出，println按一行一行的打印
//"双引号括起来的内容都是字符串"
System.out.println("HelloWorld");//;分号代表一行代码结束

功能:可在单号内描述代码作用

3.多行注释

写法:

/*
   *public static void main(String[] args)表示一个主方法，即程序入口
   *
   *public表示公开
   *static表示静态
   *void表示执行该方法无返回结果
   *mian表示方法的名字
   *()表示main方法的参数列表
   *String[] args 表示方法的参数列表类型
*/ 
public static void main(String[] args){ }

功能:在星号的范围都可以描述代码作用

注意:

多行注释范围内不能在多行注释

其原因是因为/*这个符号会找第一个*/符号，因此多个多行注释会多剩下一个*/符号

3.文档注释

写法:

/** 
*@author 标识作者名
*/

功能:让jdk提供的工具javadoc解析后可以让注释代码以网页文件显示该说明

注意:

*@author是一个标签，标签都有自己意义

可以在Java 文档注释 |菜鸟教程查看标签大全

(6)开发细节

1.源文件以java为扩展名，源文件的基本组成部分为class，如刚刚创建的HelloWorld类

2.java应用的执行入口是main()方法

固有的写法就是:public static void main(String[] args){};

3.java严格区分大小写

如刚刚的System.out.println("HelloWorld");

改成system.out.println("HelloWorld");

只是第一个字母变成小写那么运行结果就会出错

4.每次写完一条语句后需要用;分号结束语句

5.{}花括号成对出现缺一不可

6.一个源文件中只允许有一个public类

在我们写的java文件中可以有多个类

但是public类型的类只能有一个

并且每有一个类编译后都会输出相应的字节码文件

7.public类名和源文件名必须相同

比如我们的public类名是HelloWorld，那么我们的源文件则一定是HelloWorld.java

8.public类只能有一个其他类不限制，并且其他类中也可以写main方法

这种情况运行只要点class star01左边的三角形即可以编译运行star01类

三.数据类型与变量

(1)JAVA的数据类型

1.数据的概念

数据就是信息的符号的表示

如:我打车到河北省要77.7元

其中就有字符类型数据和数字类型

2.数据的类型

JAVA中的的数据类型分为基本上数据类型与引用数据类型

基本的数据类型概况

字节是计算机存储数据的基本类型，计算机最小单位是位(Bit)，1Byte(字节) =8bit

(2)变量的定义与使用

1.变量的概念

变量是程序程序基本组成部分

变量有三要素分为:类型名称值

变量会电脑会在内存生成一个空间用与存放值

变量的值可在同数据类型的情况下随意变化

内存分为栈内存与堆内存两大块

2.声明变量

语法

数据类型 变量名称;

变量名称 = 值；

数据类型变量名称 = 值；

第一种变量声明

//数据类型 变量名称;
//变量名称 = 值 ；
byte a;
a = 10;

在栈的上开辟一个字节大小为1的空间，并将该空间命名为a
将整数值的10放进去开辟好的a空间中

第二种变量声明

//数据类型 变量名称 = 值；
short b = 10;

在栈的上开辟一个字节大小为2的空间，并将该空间命名为b
将整数值的15放进去开辟好的b空间中

赋值

int c = 20;
//斌值
c = 25;

将25整数值放入名为c的内存空间中，并将20整数值覆盖掉

赋值这个操作其实从右往左的，也就是说把是值赋予到c的空间，而不是让c空间等于该值

浮点数变量声明

float d = 10.0f;
double e = 66.6;

Java中浮点数默认为双精度,而float是单精度浮点数类型
需要在浮点数后面加上f,将值改为单精度

布尔类型变量声明

boolean score = true;

Java中布尔类型的变量，在编译完成后就不存在了

因为Java是在C++的基础上开发的，C++中用 0 和非0表示假和真

而JVM是java程序场所，在JVM中有明确说明单个boolean类型变量

在编译过程中会被翻译为int类型变量此时为占4字节空间
boolean类型的数组，在编译的过程中会被翻译为byte类型的数组，此时每个变量占1字节空间

char变量声明

char sex = '男';

char可以存储汉字,因为java采用的Unicode编码，而Unicode编码收录的汉字占用的是2字节java的char类型也是占用2字节的空间，因此Unicode编码中收录的汉字可以用char类型存储
而Unicode编码中未收录汉字，不一定可以存储在char类型中

3.变量的命名规则

JAVA中的变量名字必须是唯一的

同空间内不能出现两个完全一致的变量名

变量名的开头只能以字母、下划线和&符号开头，其余部分可以用字母、数字、下划线和$组成

变量名不能是JAVA中的关键字

详情查看该地址:Java中的关键字有哪些？「Java中53个关键字的意义及使用方法」_java关键字-优快云博客

4.变量名的规范

JAVA中变量名采用驼峰命名法，变量名第一个单词的首字母小写，其余单词首字母大小

String myName = "张三";
String xingMing = "李四";

(3)运算符

更详细运算符资料:Java 运算符 | 菜鸟教程

1.使用变量注意事项

使用变量时候先要斌值

变量在声明后只是空的内存空间里面没有值，所以不能直接使用该变量

所以你要使用变量前要先声明变量在给变量斌值

同时声明多个变量

int a,b;

2.常规运算符+ - * /

加法 +

int a = 5,b = 10;
int c = a + b;
System.out.println("a + b =" + c);

加法在两边都是数字类型时候会把两边数值相加

在有一边是字符串的时候加法会成拼接符，会把两个不同类型变量拼接成字符串

减法 -

int d = c - a;
System.out.println("c - a =" + d);

乘法 *

int e = d * c;
System.out.println("d * c =" + e);

除法 /

double f = e / 2.2;
System.out.println("e / 2.2 =" + f);

除法在类型为浮点数情况下会保留小数

在类型为整数的时候会直接去除小数（不会保留）

3.取余 %

10 / 3 ?= 1

int a = 10 % 3;
System.out.println("10 % 3" + a);

当你想求一个除法的余数时候可以使用%

余法的用处

int b = 567 % 10;
System.out.println("567 % 10" + b);

当余数为10的时候可以取出个位的数

一串数字中单个取出个十百位数

int b = 567;
int ge = b % 10;
int shi = b / 10 % 10;
int bai = b / 100 % 10;
System.out.println("个" + ge);
System.out.println("十" + shi);
System.out.println("百" + bai);

利用整数除法不会剩下小数的特性

使得567 / 10 变成 56 在% 10 变成 6

4.自增自减符 -- ++

自增自减后缀运算符

int a = 10;
int b = a;
a++;
System.out.println("单个的a++ =" + b);
b = a;
System.out.println("使用斌值符后的a++ =" + b);

后缀运算符在没有其他运算符的情况下不会改变其值

如果在使用后缀运算符情况下在使用其他运算符则会加使值+1

自增自减前置运算符

int c = ++a;
System.out.println("单个的++a =" + c);

前置运算符会在其他运算符前直接将值+1

5.复合运算符 += -= *= /= %=

int a = 10;
a = a + 10;
a += 10;

复合运算符可以同时把加法和赋值同时进行

所以 a = a + 10; 同等于 a += 10;

这个复合运算符也可以和减乘除余配合使用

除此外复合运算符还有数据类型功能下章在讲

(4)数据类型转换

1. 自动类型转换

相互兼容的多种数据类型在运算时，小转大即为自动类型转换。

//此时这个数会变成double类型的10.5
double a = 10 + 0.5;

把小字内存的空间和值变成与大的字节相同的内存空间和值

2. 强制类型转换

相互兼容的多种数据类型在运算时，大专小即为强制类型转换。

从大空间转变为小空间就叫强制类型转换

强制类型转换语法：

(目标数据类型)变量名

但直接把大空间的值斌值给小空间则会报错

//这里b的空间字节大小只有4但是把这个double类型8字节空间值赋值给了b这写法的错误的
double a = 0.5;
int b = 10;
b = 10 + a;

double a = 0.5;
int b = 10;
b += a;

复合运算有强制转换功能会把b转成int类型所以不会报错

3.小作业

小明考试的时候考了59分，小明感觉很憋屈，于是奋发图强，然后下一次考试比上一次考试多考了1.5分，请问小明本次考试考了多少分？

package variable.grammar;

public class demo06 {
    public static void main(String[] args){
        double grades = 59.5;
        //自动类型转换
        grades += 1;
        System.out.println(grades);
        //强制类型转换
        int dGrades = (int)grades + 1;
        System.out.println(dGrades);
    }
}

(5)Scanner的基本使用

1.Scanner的作用

提供一种与用户交互的方式，用户可以在控制台输入一些数据，程序来获取这些数据

2.常用方法

固定写法

import java.util.Scanner; //应该写在类外面
Scanner sc = new Scanner(System.in); //写在main方法里面

使用Scanner前应该加上这两句语句

接受类型

int a= sc.nextInt();

不同变量应该使用不同的接受方式

3.小作业

从控制台输入3位学生的成绩，然后计算平均分

package variable.grammar;
import java.util.Scanner;

public class demo06 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入张三成绩:");
        double zhangShan = sc.nextDouble();
        System.out.print("请输入李四成绩:");
        double liSi = sc.nextDouble();
        System.out.print("请输入王五成绩:");
        double waWu = sc.nextDouble();
        System.out.println((zhangShan + liSi + waWu) / 3);
    }
}

四.选择结构

(1)关系运算符和逻辑运算符

1.关系运算符

关系运算符包含 > < >= <= != ==

boolean result = 2 > 3;
boolean result = 1 == 3;

2.逻辑运算符

逻辑运算符包含

逻辑与 &&：

boolean result = 2 > 3 && 5 > 4; //结果为false

主要用来衔接多个条件，表示这些条件必须要同时满足时结果才为真(只要衔接的条件有一个为假，结果为假)

逻辑或 || ：

boolean result = 2 > 3 && 5 > 4 ;//结果为true

主要用来衔接多个条件，表示这些条件必须要同时不满足时结果才为假（只要衔接的条件有一个为真，结果为真）

逻辑非 !：

boolean result = !(2 > 3);//结果为true

主要用于单个条件的取反

(2)流程图

1. 什么是流程图

流程图就是使用统一的标准图形来描述程序执行的过程

2. 为什么要使用流程图

流程图简单直观，能够很方便的为程序员编写代码提供思路

3. 流程图的基本元素

(3)if选择结构

1. 基本if选择结构

语法

if(条件){ //如果条件满足，则执行代码块
//代码块
}

案例

从控制台输入一个整数，如果该数字小于10，则输出10与该数字的差值。

流程图

代码实现

public class demo01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数:");
        int number = sc.nextInt();
        if(number < 10){
            int difference = 10 - number;
            System.out.println("10与该数字的差是:"+ difference);
        }
    }
}

2. if-else选择结构

语法

if(条件){ //如果条件满足，则执行代码块1
    //代码块1
 } else { //否则，执行代码块2
    //代码块2
 }

案例

从控制台输入一个整数，如果该数字是偶数，则输出输入的数字"是偶数"，否则输出输入的数字"是奇数"。

流程图

代码实现

public class dome02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入一个整数:");
        int number = sc.nextInt();
        if(number % 2 == 0){
            System.out.println("是偶数");
        }else{
            System.out.println("是奇数");
        }
    }
}

3.三元一次运算符（条件 ? 表达式1 : 表达式2）

? 表示的意思是询问前面的条件是否满足，如果满足，则使用表达式1。：表示否则，即条件不满足，使用表达式2

代码实现

System.out.println((number % 2 == 0) ? "是偶然" : "是奇数");

4.嵌套if选择结构

语法

if(条件1){//如果条件1满足，则执行其后大括号中的代码块
    if(条件2){ //在满足条件1的基础上再满足条件2
        //代码块
    } else {//该结构可以省略不写，表示其他情况不做任何处理
        //代码块
    }
 } else {//该结构可以省略不写，表示其他情况不做任何处理
    if(条件3){ //在不满足条件1的基础上再满足条件3
        //代码块
    } else {//该结构可以省略不写，表示其他情况不做任何处理
        //代码块
    }
 }

案例

在半决赛中，如果取得胜利，则可以进入决赛。否则，输出"已被淘汰"。如果是男子，则输出"进入男子组决赛"；否则，输出"进入女子组决赛"

流程图

代码实现

public class dome03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入Y或N表示胜利:");
        String victory = sc.next();
        if("Y".equals(victory)){
            System.out.print("输入胜利者的性别:");
            String gender = sc.next();
            if("男".equals(gender)){
                System.out.println("男子组胜利");
            }else{
                System.out.println("女子组胜利");
            }
        }else{
            System.out.println("已淘汰");
        }
    }
}

比较字符的语法

"字符".equals(字符)

5.多重if选择结构

语法

if(条件1){//如果条件1满足，则执行代码块1
    //代码块1
 } else if(条件2){ //如果条件2满足，则执行代码块2。这样的结构可以有多个
    //代码块2
 } //else if结构可能有多个
else {//否则，执行代码块3。该结构可以省略不写，表示其他情况不做任何处理
    //代码块3
 }

案例

小明去买了1注彩票，如果中了一等奖，则可以领取500万；如果中了二等奖，则可以领取100万；如果中了三等奖，则可以领取1000块；如果中了四等奖，则可以领取10块；如果中了五等奖，则可以领取5块；否则，没有奖励。

流程图

代码实现

public class demo05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入中奖等级(1-5):");
        int number = sc.nextInt();
        if(number == 1){
            System.out.println("中了一等奖获得500万！");
        }else if(number == 2){
            System.out.println("中了二等奖获得100万！");
        }else if(number == 3){
            System.out.println("中了三等奖获得1000块！");
        }else if(number == 4){
            System.out.println("中了四等奖获得10块！");
        }else if(number == 5){
            System.out.println("中了五等奖获得5块！");
        }else{
            System.out.println("没中奖");
        }
    }
}

6. 逻辑短路

逻辑与短路：&&

使用逻辑与衔接的多个条件中，只要其中一个条件为假，那么该条件之后的所有条件将得不到执行，从而形成逻辑与短路。

如: boolean result1 = 5 > 4 && 2 > 3 && 7 < 9

在上面语句中2 > 3为假，则7 < 9不会执行

逻辑或短路：||

使用逻辑或衔接的多个条件中，只要其中一个条件为真，那么该条件之后的所有条件将得不到执行，从而形成逻辑或短路

如: boolean result1 = 5 > 4 || 2 > 3 || 7 < 9

在上面语句中5 > 4 为真，则后面的语句都不会执行

(4)switch选择结构

1.switch概念

switch表示开关的意思，为了帮助理解，下面以线路为例，进行解释说明

上图中表示一条带有多个开关的线路，当开关打开时，该开关所控制的灯即被点亮

2.语法规则

 switch(表达式){ //作用在表达式的结果上
   case 常量1: //如果表达式的结果为常量1，表示该开关被打开，那么代码块1将被执行
        //代码块1
        break;//表示开关已经做完事情，跳出switch
   case 常量2://如果表达式的结果为常量2，表示该开关被打开，那么代码块2将被执行
        //代码块2
        break;//表示开关已经做完事情，跳出switch
   case 常量3://如果表达式的结果为常量3，表示该开关被打开，那么代码块3将被执行
        //代码块3
        break;//表示开关已经做完事情，跳出switch
   default://如果表达式的结果不在常量1、常量2、常量3中，表示该开关被打开，那么代码块4将被执行
        //代码块4
        break;//表示开关已经做完事情，跳出switch
 }

3.switch支持的数据类型

byte short int char Enum String

switch选择结构从JDK1.7开始才支持String类型

4. 案例

某公司在年终决定对研发部工作人员根据职位级别进行调薪，调薪信息如下：

1级 +500

2级 +800

3级 +1200

4级 +2000

请从控制台输入员工当前薪水和职位级别，并计算出年终调薪后的薪资。

流程图

public class demo07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("输入你当前薪资:");
        int pay = sc.nextInt();
        System.out.print("输入你当前等级:");
        int grade = sc.nextInt();
        switch(grade){
            case 1:
                pay += 500;
                break;
            case 2:
                pay += 800;
                break;
            case 3:
                pay += 1200;
                break;
            case 4:
                pay += 1500;
                break;
            default:
                System.out.println("输入的等级超过范围");
                break;
        }
        if(grade > 0 && grade < 5){
            System.out.println("你目前薪资是"+pay);
        }
    }
}

5. 常见误区

break跳出当前结构

switch(变量)只是找到switch语句中的相应变量的case，如果case下面没有break语句则会执行下一个case不会跳出switch语句

case的值不能重复,如第一个case值为1,则同一个switch不能出现另一个case为1的跳转点

(5)Scanner输入验证

1.思考

当需要用户输入一个整数时，用户输入了一个字符串，如何处理这类似的问题？

2.语法

sc.hasNextInt();

可以判定Scanner接收到的下一个数据是否是整数

sc.nextInt();

取出Scanner中的下一个整数

3. 案例

public class demo09 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number;
        System.out.print("请输入一个整数:");
        //sc.hasNextInt判定Scanner中的下一个数据是否是整数
        if(sc.hasNextInt()){//同理可以也判定其他值只需要更改hasNext后面相应数据类型
            //如果判定是整数则sc.hasNextInt()会返回ture
            //这时候需要sc.nextInt()接收这个值赋值给number
            number = sc.nextInt();
            System.out.println(number);
        }else{
            //如果判定不是整数则sc.hasNextInt()会返回false
            //这时候可以打印提示信息或做其他操作
            System.out.println("你输入的不是整数");
        }
    }
}

五.循环结构

(1)程序调试

1. 什么是程序调试

当程序出现问题时，我们希望程序能够暂停下来，然后通过调试一行一行操作使代码逐行执行，观察整个过程中变量的变化是否按照我们设计程序的思维变化，从而找问题并解决问题，这个过程称之为程序调试

2. 如何进行程序调试

首先在有效的代码上下断点

在代码区左边的区域，选择要查看代码行数左键点击

然后以DEBUG模式启动程序程序启动后，通过操作使程序代码逐行执行，观察变量的值的变化，从而找出问题并解决问题

在代码区右击选择Debug

3.Debug区域操作

第一个为F8可以将代码检查移动到下一行

(2)循环结构

1. 什么是循环

循环就是同样的事情反复做多次

2. 为什么要使用循环

思考如下代码存在什么问题？

public class Example1{
 
  public static void main(String[] args){
         System.out.println("Hello World");//1
         System.out.println("Hello World");//2
         System.out.println("Hello World");//3
         System.out.println("Hello World");//4
         System.out.println("Hello World");//5
         System.out.println("Hello World");//6
         System.out.println("Hello World");//7
         System.out.println("Hello World");//8
         System.out.println("Hello World");//9
         System.out.println("Hello World");//10
     }
    }

重复的编码出现多次，在Java中，这样的情况我们称之为代码冗余。那么如何减少这种重复的冗余代码？这就需要使用到循环结构了。

 public class Example2{
 
  public static void main(String[] args){
      int i=0;
      while (i < 10){
          System.out.println("Hello World");
          i++;
      }
   }
 }

对比之前的代码，冗余部分已经完全被去掉了，但是实现的功能却完全是一样的

3. 循环三要素

定义循环变量并赋初值

循环条件

循环变量的更新

(3)while循环

1. 语法

while(循环条件){
 //循环操作
}

2.流程图

3. 案例

打印0-9之间的所有整数

4. 代码实现

public class demo01 {
    public static void main(String[] args) {
        //定义循环变量并赋初值
        int i = 0;
        //循环条件
        while(i < 10){
            System.out.println(i);
            //循环变量的更新
            i++;
        }
    }
}

5. 总结

while 循环的特征就是先判断，后执行。如果一开始条件就不满足，那么 while 循环可能一次也不执行

(4) do-while 循环

1. 语法

 do {
 //循环操作
} while(循环条件);

2. 流程图

3. 案例

从控制台录入学生的成绩并计算总成绩，输入0时退出

4. 代码实现

public class demo04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int grade = 0,sum = 0;
        System.out.println("输入学生的分数(整数)计算总分数输入0结束:");
        do{
            if(sc.hasNextInt()){
                grade = sc.nextInt();
                sum += grade;
            }else{
                System.out.println("输入的不是分数");
            }
        }while (grade != 0);
        System.out.println("总分是:"+sum);
    }
}

5. 总结

do-while 循环的特征就是先执行，后判断。do-while 循环最少会执行一次

(5)for 循环

1. 语法

for(定义循环变量并赋初值;循环条件;循环变量的更新){
 //循环操作
}

2.流程图

3. 案例

求1~10的累加和

4. 代码实现

public class demo06 {
    public static void main(String[] args) {
        int sum = 0 ;
        for(int i = 1; i <= 10 ; i++){
            sum += i;
        }
        System.out.println(sum);
    }
}

5. 总结

for 循环的特征是先判断，后执行；如果一开始条件就不满足，那么 for 循环可能一次也不执行。循环次数确定的情况下，通常使用 for 循环；循环次数不确定的情况下通常使用 while 循环和 do-while 循环

(6)流程控制

1. break关键字

应用场景

break只能应用于 while 循环、do-while 循环、for 循环和 switch 选择结构

作用

break 应用在循环结构中时，表示终止 break 所在的循环，执行循环结构下面的代码，通常与 if 选择结构配合使用

break 应用在 switch 选择结构时，表示终止 break 所在的 switch 选择结构

案例

获取一个10以内的随机整数，然后从控制台输入一个整数，如果输入的整数与随机整数不相等，则重新输入，直到输入的整数与随机整数相等为止

要求：使用break

代码实现

public class demo09 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number = (int)(Math.random() * 10), inputNumber;
        System.out.println("已生成一个0-9的随机数");
        while(true){
            System.out.print("请输入一个数判定是否正确：");
            inputNumber = sc.nextInt();
            if(inputNumber == number) break;
        }
        System.out.println("恭喜答对了!随机是"+number);
    }
}

2. continue关键字

应用场景

continue只能应用在循环结构中（while循环、do-while循环和for循环）

作用

表示跳过本次循环，进入下一次循环，通常与if选择结构配合使用

案例

打印1~10之间的所有偶数(要求使用continue)

代码实现

public class demo10 {
    public static void main(String[] args) {
        int i = 1;
        while(i <= 10){
            if(i % 2 == 1){
                i++;
                continue;
            }
            System.out.println(i);
            i++;
        }
    }
}

六.多重循环

(1)二重循环

1. 什么是二重循环

二重循环就是一个循环结构中又包含另外一个循环结构

while(外层循环条件){
 //外层循环操作
    while(内层循环条件){
     //内层循环操作
}
 //外层循环操作
}
while(外层循环条件){
   //外层循环操作
    for(循环变量初始化;内层循环条件;循环变量更新){
     //内层循环操作
    }
   //外层循环操作
}
//省略其他循环结构组合

这种循环会先执行一次外循环，然后执行内循环直到内循环条件为假退出内循环，才会在执行一次外循环，然后一直到外循环的条件为假时候才能终止两个循环

2. 应用场景

打印乘法表

分析

a. 乘法表需要打印9行

b. 每一行中的列数都是跟行号一致，如第一行只打印一列

代码实现

public class demo01 {
    public static void main(String[] args) {
        for(int i = 1 ; i <= 9 ; i++){
            for(int j = 1 ; j <= i ; j++){
                System.out.print(j +" x "+ i + " = " + i * j +"\t");
            }
            System.out.println();
        }
    }
}

已知需要打印9行，则外循环的范围应该设置为[1,9]

而且列数跟行数一致，不要让列数超过行数，则内循环的范围应该等于外循环i值

打印矩形

分析

a. 矩形一共打印4行

b. 每一行都有10列

代码实现

public class demo02 {
    public static void main(String[] args) {
        for(int i = 0 ; i < 4 ; i++){
            for(int j = 0 ; j < 10 ; j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印空心矩形

分析

a. 矩形一共打印4行

b. 每一行都有10列

c. 矩形的第一行和最后一行都是'*'，第一列和最后一列也是'*'

代码实现

public class demo03 {
    public static void main(String[] args) {
        int iMax = 4,jMax = 10;
        for(int i = 1 ; i <= iMax ; i++){
            for(int j = 1 ; j <= jMax ; j++){
                if(i > 1 && i < iMax && j > 1 && j < jMax)
                    System.out.print(" ");
                else
                    System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印4行10列

除第一列跟最后一列和第一行和最后一行需要全部打上星号

其余位置需要补上空格

打印三角形

分析

a. 三角形一共5行

b. 三角形的第一行的星星列数与三角形的行数一致

c. 三角形的每一行的空白数量 = 三角形的总行数 - 行号（第一行4个空格，总行数为5）

d. 三角形的每一行的'*'数量 = (行号 - 1) * 2 + 1(除去第一行，每一行都会两个增加两颗星)

代码实现

public class demo04 {
    public static void main(String[] args) {
        int row = 5;
        for(int i = 1 ; i <= row ; i++){
            for(int j = 1 ; j <= row - i ; j++){
                System.out.print(" ");
            }
            for(int j = 1 ; j <= ( i - 1 ) * 2 + 1; j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

打印倒三角形

分析

a. 三角形一共5行

b. 三角形最后一行的空白数量 = 行号 - 1 （第一行空格为0，第五行空格为行数 - 1）

c. 最后一行的'*'数量 = （总行数 - 行号）* 2 + 1 （行数最大值为5,第一行的为9颗星，即最大行数-1在乘2，而最后一行只有一颗星，也就是每次外循环后内循环都需要减两颗星，直到剩下一颗星为止）

打印菱形

分析

a. 菱形的总行数一定是奇数

b. 三角形分为两个步打印，第一行步上打印上三角行，第二步打印下三角

c. 上三角形行数 = 总行数 / 2 + 1，下三角形行数 = 总行数 / 2

d. 上三角形空格 = (上总行数 - 当前行数) ，下三角行数 = 当前行数

e.上三角形星号 = (当前行数 - 1) * 2 + 1 ，下三角形星号 = (下总行数 - 当前行数) * 2 + 1

public class demo06 {
    public static void main(String[] args) {
        int row = 15;
        int up = row / 2 + 1;
        //上三角形
        for(int i = 1 ; i <= up ; i++){
            for(int j = 1 ; j <= up - i ; j++){
                System.out.print(" ");
            }
            for(int j = 1 ; j <= (i - 1) * 2 + 1 ; j++){
                System.out.print("*");
            }
            System.out.println();
        }
        //下三角形
        int below = row / 2;
        for(int i = 1 ; i <= below ; i++){
            for (int j = 1 ; j <= i ; j++){
                System.out.print(" ");
            }
            for (int j = 1 ; j <= (below - i) * 2 + 1; j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

2025.4.14有时间回来继续更新

(2)Java 中的标号

1. 语法规则

标号名称: 循环结构

2. 作用

标号的作用就是给代码添加一个标记，方便后面使用。通常应用在循环结构中，与break语句配合使用

3. 应用场景

根据下面的图片，打印出这样文字菜单，且实现其中返回主菜单的功能

4. 代码实现

public class demo08 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(true){
            System.out.println("1.学生成绩管理");
            System.out.println("2.学生选课管理");
            System.out.println("3.退出系统");
            int select01 = sc.nextInt();
            if(select01 == 3){
                System.out.println("已退出系统！");
                break;
            }else if(select01 == 2){

            }else if(select01 == 1){
                sign:while (true){
                    System.out.println("1.添加成绩");
                    System.out.println("2.查看成绩");
                    System.out.println("3.修改成绩");
                    System.out.println("4.删除成绩");
                    System.out.println("5.返回主菜单");
                    int select02 = sc.nextInt();
                    switch(select02){
                        case 1:
                            System.out.println("你选择了添加成绩");
                            break;
                        case 2:
                            System.out.println("你选择了查看成绩");
                            break;
                        case 3:
                            System.out.println("你选择了修改成绩");
                            break;
                        case 4:
                            System.out.println("你选择了删除成绩");
                            break;
                        case 5:
                            break sign;
                        default:
                            break;
                    }
                }
            }
        }
    }
}

总结:利用标号特性在while右边添加了标号,然后在switch选择5让while可以退出死循环

七.数组运用

(1).数组

1. 数组的概念

数组是编程语言中的一种常见的数据结构，能够存储一组相同类型的数据。

2. 数组的作用

存储一组相同类型的数据，方便进行数理统计（求最大值、最小值、平均值以及总和），也可以进行信息的展示

3. 数组的定义

语法

数据类型[] 数组名;

数组名 = new 数据类型[数组的长度];

数组名 = new 数据类型[]{元素1, 元素2, ..., 元素n};

数据类型[] 数组名 = new 数据类型[数组的长度];

数据类型[] 数组名 = {元素1, 元素2, ..., 元素n};

内存模型

代码演示

public class demo01 {
    public static void main(String[] args) {
        //1.定义
        String name; //只能存储一个名字
        String names[]; //能存储一堆名字

        //2.斌值
        name = "JOJO";
        names = new String[10];

        //3.组合定义
        int number = 1;
        int[] numbers = new int[5];

        //4.数组初始斌值
        int[] numbers02 = {1,2,4,5,6}; //这个初始化
        int[] numbers03 = new int[]{1,2,4,5,6}; //和这个初始化有什么区别
    }
}

不同类型的数组中存储的元素是不一样的

双精度浮点数数组中的默认值为0.0，单精度浮点数数组中的默认值为0.0f。boolean类型数组默认元素为false。char类型数组中的默认元素为'\u0000'，整形数组默认元素为0

数据类型[] 数组名 = {元素1, 元素2, ..., 元素n} 与数据类型[] 数组名 = {元素1, 元素2, ..., 元素n} 有什么区别

第一种类型初始化 : 只能初始化的时候斌值，后续不能在斌值

第二种类型初始化 : 可以先不输入元素，后续可以通过数组名在给堆空间存储元素

如下面代码展示

int[] numbers03 = new int[]；
numbers03 = {1,2,4,5,6};

4. 数组的基本要素

标识符

也就是数组的名称，只是在数组中的一个专业术语，本质就是一个变量名

数组元素

也就是数组中的每一块空间存储的数据

元素类型

也就是数组存放的数据类型

元素下标

数组中每一个元素所处的位置就是数组元素的下标，数组元素下标从0开始，因此，数组元素下标的最大值为数组长度 - 1

5. 数组的特性

数组的长度一旦定义就不能发生改变，除非给数组重新赋值，才能改变数组的大小

如下这个数组长度一开始为5，这之后除非你在new int[]数组重新创建一个新的numbers03，不然数组长度就不会改变

 int[] numbers03 = new int[]{1,2,4,5,6};
numbers03 = new int[]{1,2,4,5,6,7}; 
//这种操作相当于在堆空间重新申请一个空间，然后把地址重新传给numbers03栈空间

(2)数组操作

1. 遍历数组

数组的遍历是指将数组中的元素全部查看一遍

案例

从控制台录入5个你最喜欢的人的名字，然后使用随机数来获取一个下标并根据下标输出你可能喜欢的人的名字

代码实现

public class demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] names = new String[5];
        for(int i = 0 ; i < names.length ; i++){
            System.out.print("输入一个喜欢的名字:");
            names[i] = sc.next();
        }
        int random = (int)(Math.random() * 5);
        System.out.println("你最的喜欢人是"+names[random]);
    }
}

总结:在数组名后面加.length可以得到数组长度，依靠长度遍历输入数组，在用随机值*5调出数组中随机的名字

2.求最值

求出新建一个数组存放54,38,79,65,30,83,62的然后求数中的最大值

public class demo03 {
    public static void main(String[] args) {
        int[] nambers = new int[]{54,38,79,65,30,83,62};
        int Max = nambers[0];
        for (int i = 1 ; i < nambers.length ; i++){
            if(Max < nambers[i]) Max = nambers[i];
        }
        System.out.println("数组中的最大值是"+Max);
    }
}

总结:假设第一个元素为最大值,遍历数组如果有比最大值还大的元素，将元素赋值进最大值中

3.修改数组中的元素

案例

现有数列10,12,17,32,39,50，要求将该数列中所有能够被3整除的元素进行平方，然后再放回该元素所处位置

分析

a. 首先应该将数组中的所有元素全部查看一遍

b. 查看过程中，验证每一个元素是否能够被3整除

c. 如果能够被3整除，则将该元素平方，然后放入该元素所处的位置

代码实现

public class demo04 {
    public static void main(String[] args) {
        int[] numbers = new int[]{10,12,17,32,39,50};
        System.out.print("原数组:");
        for (int i = 0 ; i < numbers.length ; i++){
            System.out.print(numbers[i]+" ");
        }
        System.out.println();
        System.out.print("遍历完后:");
        for (int i = 0 ; i < numbers.length ; i++){
            if(numbers[i] % 3 == 0){
                numbers[i] *= numbers[i];
            }
            System.out.print(numbers[i]+" ");
        }
    }
}

总结:遍历数组时候把可以被3整除的数，把它自己乘上自己

4. 向数组中添加元素

案例

在某机票代售点有A、B、C、D、E 5人正排队购票，B的好朋友F现在也来排队购票，发现B正在排队，于是插队至B的后面，请使用数组的相关知识完成程序设计。

分析

a. 构建一个字符串数组存储ABCDE5人

b. F来插队，插队到B的后面，那么B后面的人所处位置相当于往后挪动一位

代码实现

public class demo05 {
    public static void main(String[] args) {
        String[] team = new String[]{"A","B","C","D","E"};
        int index = 2;
        String[] team02 = new String[team.length+1];//新数组
        for (int i = 0 ; i < index ; i++){//插入前的元素
            team02[i] = team[i];
        }
        team02[index] = "F";//要插入元素
        for (int i = index + 1 ; i < team02.length ; i++){//原数组剩下元素
            team02[i] = team[i - 1];
        }
        System.out.print("更新后的数组:");
        for (int i = 0 ; i < team02.length ; i++){
           System.out.print(team02[i] + " ");
        }
    }
}

总结：如果要更改数组长度,那么要新建一个数组长度为原数组长度+1,添加元素要分为三个部分,一是插入前元素,二是要插入元素，三是原数组剩下元素,把这三个元素统统赋值到新数组

5. 删除数组中的元素

案例

在前面的案例中，购票人C因为中途有事而离开，排队的人员减少了一个。请使用数组的相关知识完成程序设计。

分析

a. 使用数组存储目前排队的人ABFCDE

b. C离开后，排队的人员减少了1个，C后面的人向前挪动一位

代码实现

public class demo06 {
    public static void main(String[] args) {
        String[] team = new String[]{"A","B","F","C","D","E"};
        String[] team02 = new String[team.length-1];
        int index = 3;
        System.out.print("删除元素的数组:");
        for(int i = 0 ; i < team02.length ; i++){
            if(i < index){
                team02[i] = team[i];
            }else{
                team02[i] = team[i+1];//到了C的位置后从D开始赋值
            }
            System.out.print(team02[i] + " ");
        }
    }
}

总结：同上题更改数组要新建一个数组长度为原来的长度-1，找到要删除元素在斌值时候跳过这个元素，直接斌这个元素后面的值

6. 数组拷贝

语法

System.arrayCopy(原数组, 拷贝的开始位置, 目标数组, 存放的开始位置, 拷贝的元素个数);

案例

用这个实现第4题

public class demo07 {
    public static void main(String[] args) {
        String[] team = new String[]{"A","B","C","D","E"};
        int index = 2;
        String[] team02 = new String[team.length+1];
        System.out.print("排队前数组:");
        for (int i = 0 ; i < team.length ; i++){
            System.out.print(team[i]+ " ");
        }
        System.out.println();
        System.arraycopy(team,0,team02,0,index);//这里index是数组元素个
        team02[index] = "F";//而这里表示的是下标
        System.arraycopy(team,index,team02,index+1,team.length-index);
        System.out.print("排队后数组:");
        for (int i = 0 ; i < team02.length ; i++){
            System.out.print(team02[i]+ " ");
        }
        System.out.println();
    }
}

总结:和正常遍历增加元素操作一样，要注意的是System.arrayCopy第五个选项是要数组长度，你写多少就会拷贝多少元素，所以上面代码System.arrayCopy只拷贝两个元素，而team02[index]本身是从0开始所以这时候赋值的是第三个元素

7. 数组扩容

语法

数据类型[] 标识符 = Arrays.copyOf(原数组, 新数组的长度);

支持

import java.util.Arrays;

内存图示

可以看的出这个操作本质上就是栈新建一个新的元素空间，然后把元素的地址传回栈空间存储元素地址空间，这个元素的空间根据你输入长度而变化，除了原数组默认元素新增空间会存储这个数据类型的默认值

案例

在第4题的数组后新增F,G,H三名成员

代码实现

public class demo08 {
    public static void main(String[] args) {
        String[] team = new String[]{"A","B","C","D","E"};
        String[] team02 = Arrays.copyOf(team,team.length+3);
        team02[team.length] = "F";
        team02[team.length+1] = "G";
        team02[team.length+2] = "H";
        System.out.print("数组扩容后:");
        for(int i = 0 ; i < team02.length ; i++){
            System.out.print(team02[i] + " ");
        }
    }
}

番外一些常用的操作

1.Math.random()获取浮点数

获取一个1-0的浮点数,能取到0取不到1区间是[0,1)

获取到的浮点数可以乘10,取值区间会变成[0,10)

加10可以让取值区间变成[10,20)

int number =  (int)(Math.random() * 10);

JAVA学习日志:第二章 基础篇

一.内容介绍

(1)java特性

二.快速入门

(1)写出第一个程序HelloWorld

(2)编译和运行

1.文本编辑的编译和运行

2.idae的编译运行

(3)运行过程

1.源文件（java文件）

2.编译

3.字节码文件

4.运行

(4)JAVA跨平台原理

1.java程序是如何执行的

2.如何跨平台

(5)注释

1.注释介绍

2.单行注释

3.文档注释

(6)开发细节

3.java严格区分大小写

4.每次写完一条语句后需要用;分号结束语句

6.一个源文件中只允许有一个public类

7.public类名和源文件名必须相同

三.数据类型与变量

(1)JAVA的数据类型

1.数据的概念

2.数据的类型

(2)变量的定义与使用

1.变量的概念

2.声明变量

3.变量的命名规则

4.变量名的规范

(3)运算符

1.使用变量注意事项

2.常规运算符+ - * /

3.取余 %

4.自增自减符 -- ++

(4)数据类型转换

1. 自动类型转换

2. 强制类型转换

(5)Scanner的基本使用

1.Scanner的作用

2.常用方法

四.选择结构

(1)关系运算符和逻辑运算符

1.关系运算符

2.逻辑运算符

(2)流程图

1. 什么是流程图

2. 为什么要使用流程图

3. 流程图的基本元素

(3)if选择结构

1. 基本if选择结构

2. if-else选择结构

3.三元一次运算符（条件 ? 表达式1 : 表达式2）

4.嵌套if选择结构

5.多重if选择结构

6. 逻辑短路

(4)switch选择结构

1.switch概念

2.语法规则

3.switch支持的数据类型

5. 常见误区

(5)Scanner输入验证

1.思考

五.循环结构

(1)程序调试

1. 什么是程序调试

2. 如何进行程序调试

3.Debug区域操作

(2)循环结构

1. 什么是循环

2. 为什么要使用循环

3. 循环三要素

(3)while循环

(4) do-while 循环

(5)for 循环

(6)流程控制

JAVA学习日志:第二章基础篇