酷酷是懒虫

这个屌丝很懒，什么也没留下！

热门标签

Java SE全套笔记_javase笔记

作者：酷酷是懒虫 | 2024-06-25 12:17:51

踩

javase笔记

Java SE

1. Java概述

1.1 Java语言背景介绍（了解）

语言：人与人交流沟通的表达方式

计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言

Java语言是美国Sun公司（Stanford University Network）在1995年推出的计算机语言

Java之父：詹姆斯·高斯林（James Gosling）

2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可：https://www.oracle.com

java语言的三个版本：

JavaSE: Java 语言的（标准版），用于桌面应用的开发，是其他两个版本的基础

JavaME: Java 语言的（小型版），用于嵌入式消费类电子设备

JavaEE: Java 语言的（企业版），用于 Web 方向的网站开发

1.2 Java语言跨平台原理（理解）

Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。

1.3 JRE和JDK（记忆）

JVM（Java Virtual Machine），Java虚拟机

JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（Java API）

JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

总结：我们只需安装JDK即可，它包含了java的运行环境和虚拟机。

1.4 JDK的下载和安装（应用）

1.4.1 下载

通过官方网站获取JDK

http://www.oracle.com

注意：针对不同的操作系统，需要下载对应版本的JDK。

1.4.2 安装

傻瓜式安装，下一步即可。但默认的安装路径是在C:\Program Files下，为方便统一管理建议修改安装路径，将与开发相关的软件都安装到一个目录下，例如：E:\develop。

注意：安装路径不要包含中文或者空格等特殊字符（使用纯英文目录）。

1.4.3 JDK的安装目录介绍

目录名称	说明
bin	该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。
conf	该路径下存放了JDK的相关配置文件。
include	该路径下存放了一些平台特定的头文件。
jmods	该路径下存放了JDK的各种模块。
legal	该路径下存放了JDK各模块的授权文档。
lib	该路径下存放了JDK工具的一些补充JAR包。

2. 第一个演示程序

2.1 常用DOS命令（应用）

在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。

1、打开命令行窗口的方式：win + r打开运行窗口，输入cmd，回车。

2、常用命令及其作用

操作	说明
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd 目录	进入单级目录。cdithuipu
cd …	回退到上一级目录。
cd 目录1\目录2…	进入多级目录。cdithuipu\JavaSE
cd \	回退到盘符目录。
cls	清屏。
exit	退出命令提示符窗口。

2.2 Path环境变量的配置（应用）

2.2.1 为什么配置环境变量

开发Java程序，需要使用JDK提供的开发工具（比如javac.exe、java.exe等命令），而这些工具在JDK的安装目录的bin目录下，如果不配置环境变量，那么这些命令只可以在该目录下执行。我们不可能把所有的java文件都放到JDK的bin目录下，所以配置环境变量的作用就是可以使bin目录下的java相关命令可以在任意目录下使用。

2.3 HelloWorld案例（应用）

HelloWorld案例是指在计算机屏幕上输出“HelloWorld”这行文字。

各种计算机语言都习惯使用该案例作为第一个演示案例。

2.3.1 Java程序开发运行流程

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。

2.3.2 HelloWorld案例的编写

1、新建文本文档文件，修改名称为HelloWorld.java。

2、用记事本打开HelloWorld.java文件，输写程序内容。

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("HelloWorld");
	}
}
1
2
3
4
5

2.3.3 HelloWorld案例的编译和运行

存文件，打开命令行窗口，将目录切换至java文件所在目录，编译java文件生成class文件，运行class文件。

编译：javac 文件名.java

范例：javac HelloWorld.java

执行：java 类名

范例：java HelloWorld

2.4 HelloWorld案例详解（理解）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cR44cqHy-1683971924370)(img\图片1.jpg)]

2.5 HelloWorld案例常见问题（理解）

2.5.1 BUG

在电脑系统或程序中，隐藏着的一些未被发现的缺陷或问题统称为bug（漏洞）。

2.5.2 BUG的解决

1、具备识别BUG的能力：多看

2、具备分析BUG的能力：多思考，多查资料

3、具备解决BUG的能力：多尝试，多总结

2.5.3 HelloWorld案例常见问题

1、非法字符问题。Java中的符号都是英文格式的。

2、大小写问题。Java语言对大小写敏感（区分大小写）。

3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。

4、编译命令后的java文件名需要带文件后缀.java

5、运行命令后的class文件名（类名）不带文件后缀

3、数据类型

3.1、注释

单行注释：//
多行注释：/* */
文档注释：/** */

class Demo{ //class 代表一个类
	public void static main(String[] args) { //main函数是java的入口，入门程序
        System.out.println("Hello World"); //打印输出，在括号中写的东西--就会输出
    }
}
/*
	这是一个Java的入门程序
	这是一个多行注释
*/
1
2
3
4
5
6
7
8
9

3.2、关键字

Java赋予特殊含义的字段

特点：

全部都是小写 class public void main 虽然不是关键字，但是比关键字更为重要
在高级记事本中，关键字会高亮显示
起名的时候必须避免与关键字冲突（类名、变量名、方法名）

3.3、常量

定义：在程序的运行过程中，其值不会发生改变的

Java中的常量的分类：

字符串的常量(String)：被双引号括起来的任何内容都是字符串常量。“Hello World” “1234”
整数常量(int)：1，123，2134
小数常量(float)：1.2，3.14
字符常量(chat)：‘10’就不可以 ‘李’、‘华’、‘0’ ：就可以
布尔常量(boolean): 其中只有真(true)和假(false)
空常量：null，是一个特殊的值，不能单独的输出

class Demo{
    public void static main(){
        System.out.println("Hello World!"); //字符串常量值
        System.out.println(1);//整数常量
        System.out.println(1.1);//小数常量
        System.out.println('3');//字符常量
        System.out.println(true);//布尔常量
        System.out.println("null");//null
    }
}
1
2
3
4
5
6
7
8
9
10

3.4、变量

定义：在程序的于行过程中，其值可以发生变化（在内存中存存储数据）

本质：在内存中存储数据

变量的定义格式：

数据类型变量名 = 变量值 int num = 10;

变脸名：起一个名字（最好是见名知意）
变量值：给变量赋予的值
数据类型：为内存中村属的数据添加一个限制（不同的数据类型占用的空间是不一样的）

3.5、数据类型

计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫"位(bit)“，又称为比特位，通常用小写的b表示。热计算机中最基本的存储单元叫"字节”（byte），通常用大写的B表示，字节是由8个位组成：

1B(字节) = 8bit

1kb = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

位（bit） b
字节 B 8个字节
Java是强类型编程语言，给变量必须声明他的一个数据类型

3.5.1、基本数据类型（四类八种）

整数类型：（默认的数据类型是 int）

整数类型内存占用取值范围
byte 1字节 -128 ~ 127
short 2字节 -32768 ~ 32787
int 4字节 -2147483648 ~ 2147483647
long 8字节 -2的63次方到2的63次方-1
总结：
1. 整数类型默认是int类型。
2. 如果整数类型超过int类型就使用long （建议加一个大写的L这样更符合java的规范）

整数类型	内存占用	取值范围
byte	1字节	-128 ~ 127
short	2字节	-32768 ~ 32787
int	4字节	-2147483648 ~ 2147483647
long	8字节	-2的63次方到2的63次方-1

class Demo{
    public void static main(String[] args) {
        // 1、定义整数类型变量
        int i = 10;
        System.out.println("i = " + i);
        System.out.println("sout = " + 10);
        // 2、定义一个long类型的变量
        long m = 25; 
        /* 25 是一个整数类型（int）m long 不会报错 它会有一个类型的转换（隐式转换）可以添加一个大写的L */
        long l = 100L;
        System.out.println("l = " + l);
        System.out.println("m = " + m);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

浮点数：（默认的数据类型是 double）

浮点数（小数）	内存占用	取值范围
float(单精度)	4字节	……
double(双精度)	8字节	……

class Demo{
    public void static main(String[] args) {
        System.out.println("常量 = " + 12.4);
        // 定义 double
        String piStr = 4.14;
        System.out.println("double = " + pi);
        //定义 float
        float piFat = 3.14F;
        System.out.println("float = " + pifat);
    }
}
1
2
3
4
5
6
7
8
9
10
11

总结
1. 小数（浮点型）默认类型是double 类型
2. 在定义float类型的小数时添加（f | F）即可

字符类型：（char）

字符类型	字节	取值范围（对应Unicode表）
char	2字节	0 ~ 65535

class Demo {
 	public void static main(String[] args) {
        // 定义字符
        char c = '1';
        System.out.println(c);
    }   
}
1
2
3
4
5
6
7

布尔类型：（boolean）

布尔类型	字节	取值范围
boolean	1	true、false

class Demo {
 	public void static main(String[] args) {
        // 定义布尔类型
        boolean b = true;
        System.out.println(b);
    }   
}
1
2
3
4
5
6
7

引用数据类型：
- 类、接口、数组……

3.6、变量的应用

// 1、变量的生命：数据类型 变量名 = 变量值;
	int num = 10; // 声明并且赋值
// 2、先声明再赋值
	double money;
	money = 10.3;
// 3、扩展
	int a = 10,b = 20;
	int o,p;
	//o = 10,p = 10;
	0 = 10;
	p = 20;
// 4、变量的修改
	int sum = 10;
	sum = 20; //会在内存地址中覆盖原来的值
/*
	5、注意事项	
		1.在同一个方法内，变量名不能重复
		2.变量在使用之前必须初始化（必须进项赋值）
		3.定义long类型的时候可以给数值添加L（建议是大写，小写的像1不太明确）
		4.定义float类型的小数的时候必须加 F | f（否则会编译报错，小数类型默认是double，告诉jvm这是一个float类型）
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3.6.1、键盘输入（Secanner）：

获得键盘输入对象的时候：

导包：import java.utli.Scanner;
创建对象：Scanner myScanner = new Scanner(System.in);
接收数据：int num = mySecanner.nextInt(); // 表示将数据赋值给 num

import java.utli.Scanner;

class MyScannerTest{
	public void static main(String[] args) {
		Scanner myScanner = new Scanner(Syatem.in);
        System.out.println("请输入一个整数：");
        int num = myScanner.nextInt();
        System.out.println(num);
    }	
}
1
2
3
4
5
6
7
8
9
10

3.7、标识符

标识符：就是给变量、方法、类起的名字。

Java中标识符的组成规范：

由数字、字母、下划线_、美元符号$组成】也不能以数字开头
严格区分大小写 int Num = 10; int num = 10;
Java中不能使用关键字和保留字

Java中标识符的命名规范：

驼峰命名
1. 小驼峰（两个或者多个单词构成，第一个单词全都小写，从第二个开始第一个首字母都大写）：方法名、变量名
2. 大驼峰（所有单词首字母都大写）：类名
3. 起的名字必须有意义（见名知意）：userName、passWord等。

4、基础语法

4.1、类型转换

Java的开发中，数据的数据类型是可以相互转换的.分两种

自动类型转换（隐式转换）
强制类型转换

int i = 10;
double sum = i + 12.9;
1
2

隐式转换

定义：将数值范围小的数或者变量赋值给一个数值范围大的变量：由小到大隐式转换

class Demo{
    public void static main(String[] args) {
        // 定义int类型的变量
        int m = 10;
        // 赋值
        double d = m; //int --> double
        System.out.println(d); //10.0
    }
}
1
2
3
4
5
6
7
8
9

隐式转换的细节：

基本数据类型：byte —> shoat —> int —>long —float —> double
小类型于大类型参与运算的话，小类型会自动提升为大类型然后再参与运算
byte shoat char 这三个类型参与运算的话，会自动提升为int类型

常量的优化机制

定义：在编译的时候，整数常量的计算会自动计算出来，查看在没在对应的数据类型取值范围

案例：

byte a = 3;
byte b = 4;
byte c = (byte) (a + b);
byte d = 3 + 4;
1
2
3
4

4.2、强制类型转换

定义：将数值范围大的一个数（变量），赋给取值范围小的变量：由大到小

强制类型转换的格式：目标的数据类型变量名 = (目标数据类型) 值或者变量

//定义一个大类型
double m = 10.5;
//强制转换 -- 目标数据类型 变量名 = (目标数据类型) 值或者变量
int i = (int) m;
System.out.println(i);//10
1
2
3
4
5

4、运算符

4.1、类型转换

Java的开发中，数据的数据类型是可以相互转换的.分两种

自动类型转换（隐式转换）
强制类型转换

int i = 10;
double sum = i + 12.9;
1
2

隐式转换

定义：将数值范围小的数或者变量赋值给一个数值范围大的变量：由小到大隐式转换

class Demo{
    public void static main(String[] args) {
        // 定义int类型的变量
        int m = 10;
        // 赋值
        double d = m; //int --> double
        System.out.println(d); //10.0
    }
}
1
2
3
4
5
6
7
8
9

隐式转换的细节：

基本数据类型：byte —> shoat —> int —>long —float —> double
小类型于大类型参与运算的话，小类型会自动提升为大类型然后再参与运算
byte shoat char 这三个类型参与运算的话，会自动提升为int类型

常量的优化机制

定义：在编译的时候，整数常量的计算会自动计算出来，查看在没在对应的数据类型取值范围

案例：

byte a = 3;
byte b = 4;
byte c = (byte) (a + b);
byte d = 3 + 4;
1
2
3
4

4.2、强制类型转换

定义：将数值范围大的一个数（变量），赋给取值范围小的变量：由大到小

强制类型转换的格式：目标的数据类型变量名 = (目标数据类型) 值或者变量

//定义一个大类型
double m = 10.5;
//强制转换 -- 目标数据类型 变量名 = (目标数据类型) 值或者变量
int i = (int) m;
System.out.println(i);//10
1
2
3
4
5

4.3、运算符

4.3.1、运算符和表达式

运算符：对常量和变量操作的符号 = + - &

表达式：常量与变量运算符拼接起来的式子 int a = 10 (= 是运算符) int b = 30; int c = a + b +10;

4.3.2、算术运算符（应用）

符号	作用
+	加
-	减
*	乘
/	除
%	取余

class Demo {
    public void static main(Stringp[] args) {
        /*
        	算术运算符 + - * / %
			System.out.println(1 + 1);
	         System.out.println(10 - 3);
		*/
		//定义变量
         int a = 10;
         int b = 30;
         int c0 = a + b; //40 
         int c1 = a - b; //-20
         int c2 = a * b; //300
         int c3 = a / b; //0
         int c4 = a % b; //3
         System.out.println(c0);        
         System.out.println(c1);
         System.out.println(c2);
		System.out.println(c3);
         System.out.println(c4); 
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//键盘录入一个三位数，分别获得这个数的个位，十位，百位
/*
	思路分析
	1、创建键盘输入对象
	2、输入一个任意三位数
		个位 --- % 10
		十位 --- / 10 % 10
		百位 --- / 100 % 10
		千位 --- / 1000 % 10
*/
import	java.util.Scanner;
class ScannerDemo01 {
    public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
        System.out.println("请示入一个任意的三位数：");
        int num = sc.nextInt();
    	int ge = num % 10;
        int shi = num / 10 % 10;
        int bai = num /100 % 10;
        System.out.println("个位 = " + ge);
        System.out.println("十位 = " + shi);
        System.out.println("百位 = " + bai);
    } 
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4.3.3、自增与自减

自增(+ +)，自减(- -)需要和变量结合起来，自增(每次加一)，，自减(每次减一)

自增与自减的单独使用

单独使用，+ + | - -，放到变量之前与之后，没有区别

自增于自减可以放在变量之前也可以放在变量之后

自增于自减参与运算

++ | - -，参与运算

++ 或者- -在变量之前，参与运算：先自增(自减)，然后再参与运算；

++ | - - 在变量之后，参与运算：先运算在（自增）（自减）

案例：

int a = 10; //11 -> 12
int b = 5;//6 -> 5
int sum = ++b + ++a + b-- + a++ + b++; //11+6+6+11+5
System.out.println("a = " + a);//12
System.out.println("b = " + b);//6
System.out.println("sum = " + sum); //39
1
2
3
4
5
6

4.4、赋值运算符

赋值运算符就是给变量赋值，将=右边的值赋给等号左边

例： = += -= *= /= %=

int a = 10;

a += 10; // a = a + 10;（不能直接这样写表达式）(a += 10; 暗含了数据类型的强转)

class Demo{
    public static void main(String[] args){
        int a = 10;
        a += 10;//等价于 a = a + 10;
        System.out.println("a += 10 :" + a);
        a *= 10;//等价于 a = a* 10;
        System.out.println("a *= 10 : " + a);
    }
}
1
2
3
4
5
6
7
8
9

4.5、关系运算符

>= <= != > < ==(相当于JS中的全等)

class Demo{
    public void static main(String[] args) {
        int a = 10;
        int b = 11;
        System.out.println(a > b); //f
        System.out.println(a < b); //t
        System.out.println(a != b); //t
        System.out.println(a <= b); //t
        System.out.println(a >= b); //f
        System.out.println(a == b); //f
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

4.6、逻辑运算符

逻辑运算符：

&: 与

|: 或

!: 非

^：异或

目的：用来连接多个比较运算的表达式 —>最后返回boolean类型的结果

在数学中 1 < m < 10 这样写是正确的，但是在Java中是不允许这样写的。

m > 1 & m < 10 (m 必须大于 > 1 并且 & < 小于10 )

class Demo{
    public void static main(String[] args) {
        int a = 10;
        int b = 20;
        // &: (与)连接多个关系表达式 并且条件都得成立
        System.out.println(a > b & a < b); //f : t = f
        System.out.println(a > b & a > b); //f : f = f
        System.out.println(a < b & a < b); //t : t = t
        System.out.println(a > b & a > b); //t : f = f
        // |: (或) 两边只需要有一个成立 一个为 t 就为 t
        System.out.println(a > b | a < b); //f : t = f
        System.out.println(a > b | a > b); //f : f = f
        System.out.println(a < b | a < b); //t : t = t
        System.out.println(a > b | a > b); //t : f = f
        // !: (非) t为f；f为t
        System.out.println("-------------\n" + !true);
        System.out.println(!!true);
        // ^：(异或) 相同f; 不同t
        System.out.println(a > b ^ a < b); //f : t = t
        System.out.println(a > b ^ a > b); //f : f = f
        System.out.println(a < b ^ a < b); //t : t = f
        System.out.println(a > b ^ a > b); //t : f = r
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4.7、短路与的逻辑运算

&&：短路与：遇到 false 直接跳出

||：短路或：遇到 true 直接跳出，表达式为 true

功能：与 & 和 | 一样；但是，&&与|| 具有短路的效果！

class Demo{
    public void static main(String[] args){
        int a = 10;
        int b = 20;
        boolean b1 = (a > 11) & (++b >10);
        boolean b2 = (a > 11) && (++b >10);
        System.out.println(b);
    } 
}
1
2
3
4
5
6
7
8
9

4.7、三元运算符

格式：关系表达式？表达式1 ：表达式2

执行流程：

先判断关系表达式的结果(true | false)；如果为true 返回表达式1的值，如果为false返回表达式2的值

三元运算符最终必须返回一个值，必须要有变量接收。

class Demo{
    public void static main(String[] args) {
        int a = 10;
        int b = 20;
        //输出最大值
        int flag = a > b ? a : b;
        System.out.println("最大值为：" + flog);
    }
}
1
2
3
4
5
6
7
8
9

5、循环

5.1、流程控制语句

控制程序执行的流程

目的：获得我们想要的效果

顺序结构
分支结构：(if,switch)
循环结构: (for,while,do…while)

5.2、分支结构-if

####分支结构的语法1：

/*
if (关系表达式) {
	代码体;
}
*/
//案例：判断年龄是否可以上网（大于18）
//定义年龄
int age = 10;
if(age >= age){
    System.out.println("可以上网！");
}
1
2
3
4
5
6
7
8
9
10
11

执行流程：

判断关系表达式的结果
如果为true-进入循环体，执行
如果为false，不进入循环体

分支结构if语法结构2：

if(关系表达式){

循环语句1

}else{

循环语句1

}

执行流程：

判断辨析表达式的结果：t | f
如果是t，就执行循环语句1
如果是f，就执行循环语句2

int age = 10;
if(age >= age){
    System.out.println("可以上网！");
} else{
    System.out.println("不可以上网！");
}
//判断奇偶数   % ==0
//1、定义一个变量
int num = 100;
//2、判断
if(num % 2 == 0){
    System.out.println(num + "是哦数");
} else {
 	System.out.println(num + "不是偶数");   
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

分支结构if语法结构3：

多条件判断

if(条件表达式1){
    代码快1;
}else if(条件表达式2){
    代码块2;
}
...
else{
    代码块3;
}
1
2
3
4
5
6
7
8
9

案例需求：对班级的成绩进行分类

90 — 100 ：A

70 — 90(不包含90)：B

60 — 70 (不包含70)：C

60 以下：D

import java.util.Scanner;

class Demo{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩（0 ~ 100）：");
        int score = sc.nextInt();
        if(score >= 0 && score <=100){
            if(score >= 90 && score <= 100){
                System.out.println("A");
            } else if(score >= 70 && score < 90) {
                System.out.println("B");
            } else if(score >= 60 && score < 70) {
                System.out.println("C");
            } else {
                System.out.println("D");
            }
        } else {
            System.out.println("请输入有效成绩~~~");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

执行流程：

先判断条件表达式1：如果结果为 t 执行代码快1；然后直接结束if分支结构
如果为false在判断条件表达式2，如果结果为 t 执行代码快2；如果为 f 就判断条件表达式3.。。
如果以上条件都不够，直接执行else中的代码块

5.3、分支结构-switch

语法结构；

switch(条件表达式|变量){

case 值1:

代码块;

break;

case 值2:

代码块;

break;

…

default:

代码块;

break;

}

格式说明：

表达式 | 变量 byte、short、char、int、枚举、字符串
case: 后面的值需要和switch后面的值进行匹配
break: 结束switch语句
default: 以上所有的值都没有匹配成功就会执行default 类似于if中的else

执行流程：

先获取switch后面的值
与case后面的值进行匹配；
匹配成功执行下方的代码块，然后执行break，结束switch循环

如果都没有匹配成功就会执行default语句块中的内容；

/*
	需求:键盘录入星期数，显示今天的减肥活动
	减肥计划：
	周一：跑步
	周二：游泳
	周三：慢走
	周四：动感单车
	周五：拳击
	周六：爬山
	周日：好好吃一顿！！！
*/

import java.util.Scanner;
class Demo{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入星期：");
        int week = 0;
        switch(week){
                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:
                	System.out.println("周五：拳击");
                	break;
            	case 6:
                	System.out.println("周六：爬山");
                	break;
            	case 7:
                	System.out.println("周日：好好吃一顿！！！");
                	break;
                default :
                	System.out.println("请输入正确的星期：");
                	return;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

switch–case的穿透去掉case中的break，那么程序不会结束，会继续向下执行，知道default

5.4、循环-for

循环：重复的做一件事；for循环、 do…while循环、 while循环

5.4.1、for循环

格式：

for(初始化语句;条件判断;控制条件) {

循环体；

}

for循环执行流程图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4iQ4Uo0U-1684429487403)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230519004452498.png)]

for的拆分

初始化语句：for循环的初始条件,int i = 1;
条件判断语句：循环的执行与结束条件
循环体：重复的做某件事；
控制条件：控制执行的次数！！！

for循环的执行流程：

先执行初始化语句，并且只会执行一次
执行条件判断语句：boolean
如果条件是：false—> 循环就直接结束
如果条件是：true —> 才会进入循环体中执行循环体

执行控制条件 ++ | - -

class Demo{
    public static void main(String[] args){
        for(int i = 0;i < 5:i++){
            System.out.println("HelloWord!!!");
        }
        
        //案例：求1-5之和
        int sum = 0;
        for(int i = 0;i < 5:i++){
            sum += i;
        }
        System.out.println(sum);
    
        sum = 0;
    	for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                sum += i;
            }
        }
        System.out.println(sum);
        
        //优化
        for(int i = 0;i <= 100;i+=2) {
            sum += i;
        }
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

5.4.2、for循环案例（获取水仙花数）

/*
	所谓水仙花：1、三位数 2、个位十位百位的立方和等于它本身
	里：153 = 1*1*1 = 5*5*5 + 3*3*3
	需求:打印所有的水仙花数
	思路分析：
	1、抽取自然数中所有的三位数 
		for(int i = 100; i < 1000;i++){
			判断个位的立方	+ 十位的立方 + 百位的立方 = 本身
		}
	2、取余每一位数
	3、输出
*/
class TheNumberOfDaffodilsDemo{
    public static void main(String[] args) {
        for(int i = 100;i < 1000) {
            int sum = 0;
            int best = i /100 % 10;
            int ten = i / 10 % 10;
            int num = i % 10;
            if((best * best * best + ten * ten * ten + num * num * num) == i) {
                System.out.println("水仙花数有：" + i);
                sum += i;
            }
        }
        System.out.println("一共有" + sum + "个水仙花");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5.4.3、for循环总结

写for循环一般来说：都会声明结束条件（i < 100）
看到求和或者求统计数….
1、在循环外边定义求和变量 | 统计变量 //在循环外面进行输出

###5.5、循环-while

格式：

初始条件；

while(条件判断){

循环体；

控制条件；

}

执行流程：

加载初始条件
获得条件判断结果（true | false）
如果及如果为false循环结束
如果结果为true执行循环体的内容
执行控制变量；– 继续进行条件判断

总结：执行流程就是1，2，3，4，5 —> 2,3,4,5 —> 2,3,4,5…

//案例：使用while循环输出5便 helloworld

class demo{
    public static void main(String[] args){
        int i = 1;//初始条件
        while(i <= 5){//判断
            System.out.println("HelloWorld");//循环体
            i++;//控制变量
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

####5.5.1、while的案例：

需求：世界上的最高峰是珠穆朗玛峰（8844.43米 = 8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米，请问我这多少次，可以折成珠穆朗玛峰的高度。

/*
	案例分析：
		1、定义一个初始条件：double paper = 0.1;统计变量 int count = 0; 
		2、循环的终止条件(paper <= 8844430){循环体;count++;控制语句paper *= 2;}
		3、sout输出
*/

double paper = 0.1;
int count = 0;
while(paper <= 8844430) {
    count++;
    paper *= 2;
}

System.out.println(count + "次等于珠穆朗玛峰的高度;");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.6、do…while循环

结构：

初始条件 do{
循环体；
控制变量
}while(条件判断);

执行流程：

执行初始化条件
执行循环体
执行控制变量
条件判断（true | false）
为true回到2继续执行；false就直接退出循环

//使用do...while输出5遍HelloWorld
int i = 1;
do{
    System.out.println("HelloWorld");
    i++;
} while(i <= 4);
1
2
3
4
5
6

6、方法（method）

6.1、方法的概述

方法：是具有独立功能的代码快组成一个整体，使其具有特殊功能的代码集。

方法：具有独立功能的代码块

目的：提高代码的复用性

方法需要先定义，才能调用

6.2、方法的定义和调用

6.2.1、无返回值方法的定义

定义方法的通用格式：

修饰符返回值类型方法名(参数列表) {

方法体;

return 返回值:

}

6.2.2、无参无返回值方法

//格式
/*
	修饰符 void 方法名(){
		方法体;
	}
*/
public static void printArray(){
    方法体;
}
1
2
3
4
5
6
7
8
9

public static void 固定写法
方法名 — 标识符（见名知意）
方法体 — 代码块

方法定义完，需要调用，才会输出

在带有static关键字时直接调用方法名

public static void main(String[] args) {
        testStudy();
    }

    //定义一个学习方法
    public static void testStudy(){
        System.out.println("我在学习，请勿打扰");
        testEct();
    }

    //定义一个吃饭的方法
    public static void testEct(){
        System.out.println("我在吃饭，劝你善良");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

main方法与自定义方法是平级关系，所以方法不能嵌套
main方法是程序主入口，所以我们在main方法中调用其他方法

方法练习：

案例：判断奇偶数

public class Exercise01 {
    public static void main(String[] args) {
        testEventNumber(22);
    }

    public static void testEventNumber(int num){
        System.out.println(num % 2 == 0 ? "偶数" : "奇数");
    }
}
1
2
3
4
5
6
7
8
9

6.2.3、带参数的方法定义与调用

public static void 方法名 (参数1) {
	方法体;
}
public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}
1
2
3
4
5
6

参数列表：

参数的类型
参数的个数
参数的顺序

public static void print(int a,boolean b) {
    方法体;
}
//调用有参数的方法
方法名(参数);
print(10,true)
1
2
3
4
5
6

6.2.4、形参与实参

形参：方法定义传递的参数 — 形式参数

实参：方法调用传递的参数 — 实参(10，a(必须是已经赋值了的变量))

//打印 x - y 之间所有的奇数
/*
    1、根据格式定义方法，方法名printOddNumber
    2、定义方法的形参（参数列表）两个 int x y
    3、方法体 for -- x --y
    4、判断 对 !(2 % == 0) 奇数
    5、在main方法中调用此方法
 */
public class MethodTest002 {
    public static void main(String[] args) {
        printOddNumber(1 ,100);
    }

    public static void printOddNumber(int x,int y){
        for (int i = x; i < y; i++) {
            if (!(i % 2 == 0)) {
                System.out.print(i + " ");
                if (i % 9 == 0) {
                    System.out.println();
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

####6.2.5、带返回值的方法的定义

定义格式：

public static 返回值的数据类型方法名（形参） {

方法体；

return 返回值；

}

返回值的数据类型：就是return后面跟的数据对印的数据类型（隐式转换）
形参：1.参数据数据类型、2.参数的个数、3.参数据先后顺序
return：关键字，用于返回方法的结果，还可以结束方法

//实例：
public static int getSum(int a,int b){
    int sum = a + b;
    return sum;
}
    getSum(20,40);//没有实质性的意义
//有返回值的方法，建议使用变量接收
1
2
3
4
5
6
7

/*
获取两个数的最大值（方法）

思路分析：
1、定义一个方法并且带有返回值int求出最大值 testMax()
2、定义形参 int num1，int num2
3、if 进行比较 获取到最大值
4、main方法调用

 */
public class Exercise02 {
    public static void main(String[] args) {
        System.out.println("请输入一个数");
        int num1 = new Scanner(System.in).nextInt();
        System.out.println("请输入一个数");
        int num2 = new Scanner(System.in).nextInt();
        int max = testMax(num1, num2);
        System.out.println(max);
    }

    public static int testMax(int num1, int num2) {
        /*if (num1 > num2) {
            return num1;
        } else {
            return num2;
        }*/
        int max = num1 > num2 ? num1 : num2;
        return max;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

6.2.6、方法(method)的细节

方法的通用格式
- public static 返回值类型方法名（参数列表） {
  
  方法体;
  
  return 返回值；
  
  }
  1. public static 关键字，它的作用就是修饰它的访问范围
  2. 返回值类型
    - 方法有返回值，就需要定义返回值类型
    - 没有返回值的方法就是void
  3. 方法名（标识符）：起的名字要见名知意，遵循小驼峰getNum() getName()
  4. 参数列表：
    1. 参数的数据类型
    2. 参数的个数
    3. 参数的位置
  5. 方法体：完成该功能的代码块
  6. return：用于返回方法的结果
定义方法须知两个明确
1. 明确返回值的数据类型
  - 有就写对应的数据类型，有就写没有就写viod
  - 有返回值必须写return
2. 明确方法的参数列表（形参）
  - 参数的数据类型
  - 参数的个数
  - 参数的位置
调用方法
1. 没有返回值的方法(void) –>直接就是方法名();
2. 有返回值的方法 —> 定义变量来接收方法的返回结果
方法不能嵌套
- main方法是一个方法，自定的方法也是方法，是平级关系
- main方法是程序的主入口，需要在main方法调用其他方法
return
- 有返回值必须写return（编译报错）
- 没有返回值，没有强制编写return，（一般不写）
- 卸载return后面的代码一般视为无效

6.2.7、方法的重载

方法重载：

在同一个类中
存在同名的方法
参数列表不同

方法重载的优势：不需要记住大量的、繁琐的方法名字

/*
    需求：使用方法重载，设计比较两个整数是否相同的方法，减轻哦那个全整数类型（byte,short,int,long）

    思路分析：
        1、确定返回值类型 boolean
        2、参数列表  两个不同数据类型
 */
public class ExerciseMethod01 {
    public static void main(String[] args) {
        System.out.println(testCompare((byte) 10, (byte) 10));
        System.out.println(testCompare((short) 10, (short) 10));
        System.out.println(testCompare(10, 10));
        System.out.println(testCompare(10L, 10L));
    }

    public static boolean testCompare(byte b1,byte b2){
        System.out.println("---byte---");
        return b1 == b2;
    }
    public static boolean testCompare(short s1,short s2){
        System.out.println("---short---");
        return s1 == s2;
    }
    public static boolean testCompare(int i1, int i2){
        System.out.println("---int---");
        return i1 == i2;
    }
    public static boolean testCompare(long l1,long l2){
        System.out.println("---long---");
        return l1 == l2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

6.2.8、方法参数的传递

回顾：

定义的方法：形参
- 基本数据类型：不会改变实际的参数结果。
  - 原因：每个方法都有独立的栈，方法运行完就会被回收
- 引用数据类型：引用数据类型 –> 会改变实际参数据结果。
  - 原因：引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是修改过后的结果。
调用方法：实参是调用方法时传递的参数（1、常量 2、初始化之后的变量）

6.4.9、方法的可变长参数

可变长参数的引出

定义一个2数之和；定义一个3数之和；定义一个4数之和；定义一个5数之和 …

参数列表太繁琐。。。不利于代码的健壮性

直接在参数列表放一个(int…arr)可变长参数 … 大大降低了代码的冗余

public static int testSum(int...arr){
    //1、定义求和
    int sum = 0;
    //2、遍历数组
    for(int i = 0;i < arr.length;i++) {
        sum += arr[i];
    }
    //3、返回总和
    return sum;
}
1
2
3
4
5
6
7
8
9
10

可变长参数，可以不写参数，也可以写多个
也可以当作方法的重载
可变参数与方法的形参数组是一致的，不能同时声明，可变参数的本质就是一个数组
一个方法的形参只能声明一个可变参数
作为方法的形参，可变参数必须放在形参的最后位置上

7.3、方法总结

方法
- 具有独立功能的代码块{}，目的：提高复用性

定义方法：

public static 返回值类型 方法名(参数列表|形参){
    方法体;
    return 返回值;
} 
1
2
3
4

使用方法
- 没有返回值的方法(void)–直接使用方法名
- 有返回值的方法–一般使用一个变量接收
方法细节
- 方法之间是平级关系，不能嵌套方法
- 有返回值写返回值类型，没有返回值就直接使用void
- 有返回值必须使用return，没有返回值一般不写；
方法的形参与实参
- 方法的形参：定义方法的时候写的就是形参（形式参数列表）—1、接受传递的实参 2、约束数据类型
- 方法的实参：调用方法时传递的参数，（1、常量 2、初始化之后的变量）
方法的重载（条件）
- 必须在同一个类中
- 方法名一致
- 形参列表不同
  - 数据类型不同
  - 数据的位置不同
  - 参数的个数
- 优势：不用记大量的方法名
参数传递
- 形参是基本数据类型，修改形参，不会影响实参
- 形参使用用来型数据，修改形参，会改变实参

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/756153