Java基础知识（DOS命令、注释、关键字、常量、数据类型、变量、标识符、类型转换、运算符、数据输入、选择结构、循环结构、Random）

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量1.7k 收藏
点赞数 2
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50648720/article/details/121228427
版权
本文详细介绍了Java编程的基础知识，包括Java的概念、DOS命令、HelloWorld案例、基础语法如注释、关键字、常量、数据类型、变量、标识符、类型转换、运算符以及数据输入。此外，还讲解了选择结构如if语句和switch语句，以及循环结构如for、while和do...while循环。内容深入浅出，适合初学者学习。
摘要由CSDN通过智能技术生成

Java基础知识


tips： 下一篇基础知识请点击链接

Java的概念

  1. Java是一个面向对象的高级编程语言。Java代码看起来很容易理解，像人类的自然语言。
  2. Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件（class文件），然后由Java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现Java程序的跨平台。
  3. Java适合做互联网web相关项目。（京东、淘宝等）
  4. JDK、JRE、JVM各自的作用和关系：
    : JVM（Java Virtual Machine），Java虚拟机，真正运行Java程序的地方。
    : JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心运行类库。
    : JDK（Java Development Kit）称为Java开发工具集，包含了JRE和开发工具。
    : 我们想要运行一个已有的Java程序，那么只需安装JRE即可，我们想要开发一个全新的Java程序，那么必须安装JDK。三者关系：JVM<JRE<JDK。

常用的DOS命令

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

  1. 打开命令行窗口的方式：按下Windows+R键盘库，打开运行窗口，输入cmd回车，进入到DOS的操作窗口。
  2. 常用DOS命令：
操作说明
盘符名称：盘符切换。E：回车，表示切换到E盘 。
dir查看当前路径下的内容。
cd 目录进入单级目录。
cd …回退到上一级目录。
cd目录1\目录2…进入多级目录。
cd \回退到盘符目录。
cls清屏。
exit退出命令提示符窗口。

HelloWorld案例

  1. Java程序开发运行流程
    开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。
  2. HelloWorld案例的编写
    : 新建文本文档文件，修改名称为HelloWorld.java。
    : 用记事本打开HelloWorld.java文件，输写程序内容。
public class HelloWorld{
	public static void main(String[] args){
		System.out.println("HelloWorld");
	}
}
  1. HelloWorld案例的编译和运行
    存文件，打开命令行窗口，将目录切换至java文件所在目录，编译java文件生成class文件，运行class文件。
    : 编译：javac 文件名.java
    : 范例：javac HelloWorld.java
    : 执行：java 类名
    : 范例：java HelloWorld
  2. 关于main方法
    : 固定格式不能写错。
    : 称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序，JVM在运行的时候，都会从main方法这里开始执行。

Java基础语法

注释

注释是对代码的解释和说明文字，可以提高程序的可读性，因此在程序中添加必要的注释文字十分重要。Java中的注释分为三种：

  1. 单行注释。单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释文字。每个单行注释只能注释一行注释信息。
// 这是单行注释文字
  1. 多行注释。多行注释的格式是使用/和/将一段较长的注释括起来。多行注释可以注释多行注释信息。
/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
  1. 文档注释。文档注释以/*开始。以/结束。文档注释也可以注释多行信息。
/** 描述
* @author xxx
* @version x.x
*/

关键字

  1. 关键字是指被java语言赋予了特殊含义的单词。
  2. 关键字的特点：
    : 关键字的字母全部小写。
    : 常用的代码编辑器对关键字都有高亮显示，比如现在我们能看到的public、class、static等。

常量

  1. 在程序运行过程中，其值不可以发生改变的量。
  2. 常量分为：整数常量、小数常量、字符常量、字符串常量、布尔常量、空常量。
类型含义数据举例
整数常量所有的整数0，1，567，-9
小数常量所有的小数0.0，-0.1，2.55
字符常量必须用单引号引起来，有且只有一个字符‘a’，’ '，‘好’
字符串常量必须用双引号引起来，多个或不写“A”，“你好”，" "
布尔常量只有两个值true，false
空常量只有一个值null

数据类型

计算机存储单元

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称为“比特位”，通常用小写的字母“b”表示。而计算机最基本的存储单元叫“字节（byte）”，通常用大写字母“B”表示，字节是由连续的8个位组成。除了字节外还有一些常用的存储单位，其换算单位如下：
1B（字节）= 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

Java中的数据类型

  1. Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。
  2. Java中的基本数据类型：
数据类型关键字内存占用取值范围
整数byte1负的2的7次方～2的7次方-1（-128～127）
short2负的2的15次方～2的15次方-1（-32758～32767）
int4负的2的31次方～2的31次方-1
long8负的2的63次方～2的63次方-1
浮点数float41.401298e-45～3.402823e+38
double84.9000000e-324～1.797693e+308
字符char20-65535
布尔boolean1true，false

说明：
e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
在java中整数默认是int类型，浮点数默认是double类型。

变量

变量的定义

  1. 变量：在程序运行过程中，其值可以发生改变的量。从本质上讲，变量是内存中的一小块区域，其值可以在一定范围内变化。
  2. 变量的定义格式：
数据类型 变量名 = 初始化值;  // 声明变量并赋值
int age = 18;
System.out.println(age);

或者

// 先声明，后赋值（使用前赋值即可）
数据类型 变量名;
变量名 = 初始化值;
double money;
money = 55.5；
System.out.println(money);

还可以在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。

int a = 10, b = 20;  // 定义int类型的变量a和b，中间使用逗号隔开
System.out.println(a);
System.out.println(b);

int c,d;  // 声明int类型的变量c和d，中间使用逗号隔开
c = 30;
d = 40;
System.out.println(c);
System.out.println(d);
  1. 变量的使用：通过变量名访问即可。

使用变量时的注意事项

  1. 在同一对花括号中，变量名不能重复。
  2. 变量在使用之前，必须初始化（赋值）。
  3. 定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。
  4. 定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型时double，double的取值范围是大于float的，类型不兼容。

标识符

标识符的定义

标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。

Java中表示符的组成规则

  1. 由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
  2. 不能使用java中的关键字作为标识符。
  3. 标识符对大小写敏感（区分大小写）。

Java中标识符的命名约定

  1. 小驼峰式命名：变量名、方法名。首字母小写，从第二个单词开始每个单词的首字母大写。
  2. 大驼峰式命名：类名。每个单词的首字母都大写。
  3. 另外，标识符的命名最好可以做到见名知意，例如：username、studentNumber等。

类型转换

类型转换的定义

在Java中，一些数据类型之间是可以相互转换的。分为两种情况：自动类型转换和强制类型转换。

自动类型转换

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。例如：

double num = 10;  // 将int类型的10直接赋值给double类型
System.out.println(num);  // 输出10.0

强制类型转换

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。强制类型转换格式：目标数据类型 变量名 = （目标数据类型）值或者变量;。例如：

double num1 = 5.5;
int num2 = (int) num1;  // 将double类型的num1强制转换为int类型
System.out.println(num2);  // 输出5（小数位直接舍弃）

// 表示数据范围从小到大
byte ===> short 
				===> int ===> long ===> float ===> double
          char

说明

  1. char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，‘a’对应97。
int a = 'a';
System.out.println(a);  // 将输出97
  1. 整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为：
int nun = b1 + b2;
// 或者：
byte b3 = (byte)(b1 + b2);
  1. boolean类型不能与其他基本数据类型相互转换。

运算符

算术运算符

运算符和表达式
  1. 运算符：对常量或者变量进行操作的符号。
  2. 表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。举例说明：
int a = 10;
int b = 20;
int c = a + b;
// +：是运算符，并且是算术运算符。
// a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。
算术运算符
符号作用说明
+加+
-减-
*乘x
/除÷
%取余获取的是两个数据做除法的余数

注意：

  1. /和%的区别：两个数据做除法，/取结果的商，%取结果的余数。
  2. 整数操作只能得到整数，要想得到小数，必须有浮点数参与运算。
int a = 10;
int b = 3；
System.out.println(a / b);  //输出结果3
System.out.println(a % b);  //输出结果1
字符的"+"操作
  1. char类型参与算术运算，使用的是计算机底层对应的十进制数值。需要记住三个字符对应的数值：
    ‘a’ - - 97，a-z是连续的，所以’b’对应的数值是98，'c’是99，依次递加
    ‘A’ - - 65，A-Z是连续的，所以’B’对应的数值是66，'C’是67，依次递加
    ‘0’ - - 48，0-9是连续的，所以’1’对应的数值是49，'2’是50，依次递加
// 可以通过使用字符与整数做算术运算，得出字符对应的数值是多少
char ch1 = 'a'
System.out.println(ch1 + 1); // 输出98，97 + 1 = 98
char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66，65 + 1 = 66
char ch3 = '0';
System.out.println(ch3 + 1); // 输出49，48 + 1 = 49

算术表达式中包含不同的基本数据类型的值的时候，整个算术表达式的类型会自动进行提升。

  1. 提升规则：
    : byte类型，short类型和char类型将被提升到int类型，不管是否有其他类型参与运算。
    : 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型。
    : 等级顺序：byte,short,char --> int --> long --> float --> double
    例如：
byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2;  //该行报错，因为byte类型参与算术运算会自动提示为int，int赋值给byte可能损失精度
int i3 = b1 + b2;  // 应该使用int接收
byte b3 = (byte)(b1 + b2);  // 或者将结果强制转换为byte类型
-----------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2;  // 使用double接收，因为num1会自动提升为double类型
  1. tips：正是由于上述原因，所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符，而使用字符串类型，更不会使用char类型做算术运算。
字符串的"+"操作
  1. 当"+“操作中出现字符串时，这个”+"是字符串连接符，而不是算术运算。
System.out.println("hello" + 666);  // 输出：hello666
  1. 在"+“操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行”+"操作时，从左到右逐个执行。
System.out.println(1 + 994 + "年");  // 输出：1994年
System.out.println(1 + 2 + "你" + 3 + 4);  // 输出：3你34
// 可以使用小括号改变运算的优先级
System.out.println(1 + 2 + "你" + (3 + 4));  // 输出：3你7

赋值运算符

  1. 赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。
符号作用说明
=赋值a=10，将10赋值给变量a
+=加后赋值a+=b，将a+b的值给a
-=减后赋值a-=b，将a-b的值给a
*=乘后赋值a*=b，将axb的值给a
/=除后赋值a/=b，将a÷b的商给a
%=取余后赋值a%=b，将a÷b的余数给a
  1. 注意：扩展的赋值运算符隐含了强制类型转换。
short s = 10;
s = s + 10;  // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
s += 10;  // 此行代码没有问题，隐含了强制类型转换，相当于s = (short)(s + 10);

自增自减运算符

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

注意事项：

  1. ++和- -既可以放在变量的后边，也可以放在变量的前边。
  2. 单独使用的时候，++和- -无论是放在变量的前边还是后边，结果是一样的。
  3. 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者- -。
  4. 参与操作的时候，如果放在变量的前边，先拿变量做++或者- -，后拿变量参与操作。
  5. 最常见的用法：单独使用。
int i = 10;
i++;  // 单独使用
System.out.println("i:" + i);  // i:11

int j = 10;
++j;  // 单独使用
System.out.println("j:" + j);  // j:11

int x = 10;
int y = x++;  // 赋值运算，++在后边，所以是使用x原来的值赋值给y，x本身自增1
System.out.println("x:" + x + ",y:" + y);  // x:11，y:10

int m = 10;
int n = ++m;  // 赋值运算，++在前边，所以是使用m自增后的值赋值给n，m本身自增1
System.out.println("m:" + m + ",m:" + m);  // m:11，m:11

关系运算符

  1. 关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。
符号说明
==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
  1. 注意事项：
    : 关系运算符的结果都是boolean类型，要么是true，要么是false。
    : 千万不要把“= =”误写成“=”，“= =”是判断是否相等的关系，"="是赋值。
int a = 10;
int b = 20;
System.out.println(a == b);  // false
System.out.println(a != b);  // true
System.out.println(a > b);  // false
System.out.println(a >= b);  // false
System.out.println(a < b);  // true
System.out.println(a <= b);  // true

// 关系运算的结果肯定是boolean类型，所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag);  // 输出false

逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是true或false。

符号作用说明
&逻辑与a&b，a和b都是true，结果为true，否则为false
｜逻辑或a｜b，a和b都是false，结果为false，否则为true
^逻辑异或a^b，a和b结果不同为true，相同为false
!逻辑非!a，结果和a的结果正好相反
//定义变量
int i = 10;
int j = 20;
int k = 30

//& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true

//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true

//^ “异或”，相同为false，不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false

//! “非”，取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false，,输出true
短路逻辑运算符
符号作用说明
&&短路与作用和&相同，但是有短路效果
｜｜短路或作用和｜相同，但是有短路效果

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

  • 逻辑与&，无论左边真假，右边都要执行。
  • 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
  • 逻辑或｜，无论左边真假，右边都要执行。
  • 短路或 | |，如果左边为假，右边执行；如果左边为真，右边不执行。
int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5));  // 两个表达式都会运算
System.out.println(x);  // 4
System.out.println(y);  // 5

System.out.println((x++ > 4) && (y++ > 5));  // 左边已经可以确定结果为false，右边不参与运算
System.out.println(x);  // 4
System.out.println(y);  // 4

三元运算符

语法格式
关系表达式 ? 表达式1 : 表达式2;
  • 解释：问号前面的位置是判断的条件，判断结果为boolean型，为true时调用表达式1，为false时调用表达式2。其逻辑为：如果条件表达式成立或者满足则执行表达式1，否则执行第二个。
  • 举例：
int a = 10;
int b = 20;
int c = a > b ? a : b;  // 判断 a > b 是否为真，如果为真取a的值，如果为假，取b的值
案例

需求：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

public class OperatorTest01 {
	public static void main (String[] args) {
		// 1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
		int weight1 = 180;
		int weight2 = 200;
		// 2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则返回false。
		boolean b = weight1 == weight2 ? true : false;
		// 3：输出结果
		System.out.println("b:" + b);
	}
}

运算符优先级

描述运算符
括号()、[ ]
正负号+、-
自增自减 ，非++、- -、!
乘除，取余*、/、%
加减+、-
大小关系>、>=、<、<=
相等关系==、!=
按位与&
按位异或^
按位或｜
逻辑与&&
逻辑或｜｜
条件运算?
赋值运算=、+=、-=、*=、/=、%=

数据输入

我们可以通过Scanner类来获取用户的输入。使用步骤如下：

  1. 导包。Scanner类在java.util包下，所以需要将该类导入。导包的语句需要定义在类的上面。
import java.util.Scanner;
  1. 创建Scanner对象。
Scanner sc = new Scanner(System.in); // 创建Scanner对象，sc表示变量名，其他均不可变
  1. 接收数据
int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回

示例：

import java.util.Scanner;
public class ScannerDemo {
	public static void main (String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);
		// 接收数据
		int x = sc.nextInt();
		// 输出数据
		System.out.println("x:" + x);
	}
}

tips：sc.next();只能获取输入的从开头到最近一个空之前的内容。获取的字符串是不包含空格的；sc.nextLine();获取包含空格在内的字符串，会获取从头到尾一行的数据。

选择结构

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。流程控制语句分类：顺序结构、分支结构（if，switch）、循环结构（for，while，do…while）。

顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

// 顺序结构执行流程图：
开始 -> 语句A -> 语句B -> 语句C -> 结束

分支结构

if语句
if语句格式1
格式：
if (关系表达式) {
	语句体;
}
  • 执行流程：
  1. 首先计算关系表达式的值
  2. 如果关系表达式的值为true就执行语句体
  3. 如果关系表达式的值为false就不执行语句体
  4. 继续执行后面的语句内容
  • 示例：
public class IfDemo {
	public static void main (String[] args) {
		System.out.println("开始");
		// 定义两个变量
		int a = 10;
		int b = 20;
		// 需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
		if(a == b) {
			System.out.println("a等于b");
		}
		// 需求：判断a和c的值是否相等，如果相等，就在控制台输出：a等于c
		int c = 10;
		if(a == c) {
			System.out.println("a等于c");
		}
		Sysytem.out.println("结束");
	}
}
if语句格式2
格式：
if (关系表达式) {
	语句体1;
} else {
	语句体2;
}
  • 执行流程：
  1. 首先计算关系表达式的值
  2. 如果关系表达式的值为true就执行语句体1
  3. 如果关系表达式的值为false就执行语句体2
  4. 继续执行后面的语句内容
  • 示例：
public class IfDemo02 {
	public static void main (String[] args) {
		System.out.println("开始");
		// 定义两个变量
		int a = 10;
		int b = 20;
		b = 5;
		// 需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，否则，在控制台输出：a的值不大于b
		if (a > b) {
			System.out.println("a的值大于b");
		} else {
			System.out.println("a的值不大于b");
		}
		System.out.println("结束");
	}
}
if语句格式3
格式：
if (关系表达式1) {
	语句体1;
} else if (关系表达式2) {
	语句体2;
}
...
else {
	语句体n+1;
}
  • 执行流程：
  1. 首先计算关系表达式1的值
  2. 如果值为true就执行语句体1；如果值为fasle就计算关系表达式2的值
  3. 如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
  4. 。。。
  5. 如果没有任何关系表达式为true，就执行语句体n+1
  • 示例：
import java.util.Scanner;
public class IfDemo03 {
	public static void main(String[] args) {
		System.out.println("开始");
		// 需求：键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个星期数(1-7)：");
		int week = sc.nextInt();
		if(week == 1) {
			System.out.println("星期一");
		} else if(week == 2) {
			System.out.println("星期二");
		} else if(week == 3) {
			System.out.println("星期三");
		} else if(week == 4) {
			System.out.println("星期四");
		} else if(week == 5) {
			System.out.println("星期五");
		} else if(week == 6) {
			System.out.println("星期六");
		} else {
			System.out.println("星期日");
		}	
		System.out.println("结束");
	}
}
switch语句
  • 格式
switch (表达式) {
	case 1 :
		语句体1;
		break;
	case 2 :
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}
  • 执行流程：
  1. 首先计算出表达式的值
  2. 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
  3. 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
  • switch匹配的类型：（因为switch在设计的时候就是匹配一些固定值）
  1. byte，short，char，int
  2. 枚举（jdk1.5）
  3. 字符串（jdk1.7）
  • case的穿透性：
    当匹配上一个case后，会穿过其他的case，直到遇到break才会停止。注意：开发中尽量不要使用穿透，流程的控制比较难。
  • if和switch的区别：
  1. if：通常用于一定范围的判断
  2. switch：通常用于固定值的判断

循环结构

for循环
for循环结构
  • 循环：
    循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。
  • for循环格式：
for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}
  • 格式解释：
  1. 初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
  2. 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
  3. 循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
  4. 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去
  • 执行流程
  1. 执行初始化语句
  2. 执行条件判断语句，看其结果是true还是false。如果是false，循环结束；如果是true，继续执行。
  3. 执行循环体语句
  4. 执行条件控制语句
  5. 回到2继续
for循环练习
输出数据

需求：在控制台输出1-5和5-1的数据

public class ForTest01 {
    public static void main(String[] args) {
		//需求：输出数据1-5
        for(int i=1; i<=5; i++) {
			System.out.println(i);
		}
		System.out.println("--------");
		//需求：输出数据5-1
		for(int i=5; i>=1; i--) {
			System.out.println(i);
		}
    }
}
求偶数和

需求：求1-100之间的偶数和，并把求和结果在控制台输出

public class ForTest03 {
    public static void main(String[] args) {
		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
		int sum = 0;
		//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
		for(int i=1; i<=100; i++) {
			//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
			if(i%2 == 0) {
				sum += i;
			}
		}
		//当循环执行完毕时，将最终数据打印出来
		System.out.println("1-100之间的偶数和是：" + sum);
    }
}

本题要点：

  • 今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
  • 求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的
统计水仙花数个数

需求：统计“水仙花数”一共有多少个，并在控制台输出个数

public class ForTest05 {
    public static void main(String[] args) {
		//定义变量count，用于保存“水仙花数”的数量，初始值为0
		int count = 0;
		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
		for(int i=100; i<1000; i++) {
			//在计算之前获取三位数中每个位上的值
			int ge = i%10;
			int shi = i/10%10;
			int bai = i/10/10%10;
			//在判定水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
				count++;
			}
		}
		//打印输出最终结果
		System.out.println("水仙花共有：" + count + "个");
    }
}

本题要点：

  • 今后如果需求带有统计xxx，请先想到计数器变量
  • 计数器变量定义的位置，必须在循环外部
while循环
while循环结构
  • while循环完整格式：
初始化语句;
while (条件判断语句) {
	循环体语句;
	条件控制语句;
}
  • while循环执行流程：
  1. 执行初始化语句
  2. 执行条件判断语句，看其结果是true还是false。如果是false，循环结束；如果是true，继续执行。
  3. 执行循环体语句
  4. 执行条件控制语句
  5. 回到2继续
  • 示例代码：
public class WhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
		//for循环实现
		for(int i=1; i<=5; i++) {
			System.out.println("HelloWorld");
		}
		System.out.println("--------");
		//while循环实现
		int j = 1;
		while(j<=5) {
			System.out.println("HelloWorld");
			j++;
		}
    }
}
while循环练习

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

public class WhileTest {
    public static void main(String[] args) {
		//定义一个计数器，初始值为0
		int count = 0;
		//定义纸张厚度
		double paper = 0.1;
		//定义珠穆朗玛峰的高度
		int zf = 8844430;
		//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
		//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
		while(paper <= zf) {
			//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
			paper *= 2;
			//在循环中执行累加，对应折叠了多少次
			count++;
		}
		//打印计数器的值
		System.out.println("需要折叠：" + count + "次");
    }
}
do…while循环
do…while循环结构
  • 完整格式：
初始化语句;
do {
	循环体语句;
	条件控制语句;
} while (条件判断语句);
  • 执行流程：
  1. 执行初始化语句
  2. 执行循环体语句
  3. 执行条件控制语句
  4. 执行条件判断语句，看其结果是true还是false。如果是false，循环结束；如果是true，继续执行
  5. 回到2继续
  • 示例代码
public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
		//for循环实现
		for(int i=1; i<=5; i++) {
			System.out.println("HelloWorld");
		}
		System.out.println("--------");
		//do...while循环实现
		int j = 1;
		do {
			System.out.println("HelloWorld");
			j++;
		}while(j<=5);
    }
}
补充说明
三种循环的区别
  • 三种循环的区别
  1. for循环和whlie循环先判断条件是否成立，然后决定是否执行循环体（先判断后执行）
  2. do…while循环先执行一次循环体，然后判断条件是否成立，是否继续执行循环体（先执行后判断）
  • for循环和while的区别
  1. 条件控制语句所控制的自增变量，因为归属for循环的语法结构中，在for循环结束后，就不能再次被访问到了
  2. 条件控制语句所控制的自增变量，对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用
  • 死循环（无限循环）的三种格式
  1. for (;😉 { }
  2. while (true) { }
  3. do { } while (true)
跳转控制语句
  • 跳转控制语句（break）
    跳出循环，结束循环
  • 跳转控制语句（continue）
    跳过本次循环，继续下次循环
  • 注意：
    continue只能在循环中进行使用！
嵌套循环

所谓嵌套循环，循环中还有循环，一般都是for循环中嵌套一个for循环。

  • 格式：
for (初始化语句;条件判断语句;条件控制语句) {
	外循环;...
	for (初始化语句;条件判断语句;条件控制语句) {
		内循环;...
	}
}
  • 执行流程：
    外循环执行一次，内循环执行完
  • 总次数：
    外循环次数 X 内循环次数
  • 示例：
public static void main(String[] args) {
	//外循环控制小时的范围，内循环控制分钟的范围
	for (int hour = 0; hour < 24; hour++) {
		for (int minute = 0; minute < 60; minute++) {
			System.out.println(hour + "时" + minute + "分");
		}
		System.out.println("--------");
	}
}

Random

Random产生随机数

  • 概述：
    Random类似Scanner，也是java提供好的API，内部提供了产生随机数的功能。
  • 使用步骤：
  1. 导入包
    import java.util.Random;
  2. 创建对象
    Random r = new Random();
  3. 产生随机数
    int num = r.nextInt(10);
    解释：10代表的是一个范围，如果括号写10，产生的随机数就是0-9，括号写20，参数的随机数则是0-19
  • 示例代码：
import java.util.Random;
public class RandomDemo {
	public static void main(String[] args) {
		//创建对象
		Random r = new Random();
		//用循环获取10个随机数
		for(int i=0; i<10; i++) {
			//获取随机数
			int number = r.nextInt(10);
			System.out.println("number:" + number);
		}
		//需求：获取一个1-100之间的随机数
		int x = r.nextInt(100) + 1;
		System.out.println(x);
	}
}

Random练习

需求：
程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？当猜错的时候根据不同情况给出相应的提示：
A. 如果猜的数字比真实数字大，提示你猜的数据大了
B. 如果猜的数字比真实数字小，提示你猜的数据小了
C. 如果猜的数字与真实数字相等，提示恭喜你猜中了

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

public class RandomTest {
	public static void main(String[] args) {
		//要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
		Random r = new Random();
		int number = r.nextInt(100) + 1;
		
		while(true) {
			//使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
			Scanner sc = new Scanner(System.in);
			
			System.out.println("请输入你要猜的数字：");
			int guessNumber = sc.nextInt();
			
			//比较输入的数字和系统产生的数据，需要使用分支语句。
             //这里使用if..else..if..格式，根据不同情况进行猜测结果显示
			if(guessNumber > number) {
				System.out.println("你猜的数字" + guessNumber + "大了");
			} else if(guessNumber < number) {
				System.out.println("你猜的数字" + guessNumber + "小了");
			} else {
				System.out.println("恭喜你猜中了");
				break;
			}
		}
		
	}
}
荞澳
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java的注释、关键字、标识符、变量常量、数据类型、运算符、流程控制等
fighting
05-26 403
java基础1（注释、关键字、标识符、 变量常量、数据类型、运算符、流程控制） 1. java概述 1.1 java的技术体系 Java SE：是Java的标准版，提供了完整的java核心API。 Java E...
Java中的理论知识（DOS命令、关键字、标识符、常量、变量、注释、数据类型、进制、运算符）
Mufeng7797的博客
10-26 266
DOS命令行中常用命令 Windows键+r键：打开DOS命令行 E: / e: ：盘符切换（大小写都可以） cd 文件名：进入单级目录 cd … ：返回上一级目录 cd / ：回退根目录 dir：罗列某个盘符下所有文件及文件夹名称 md 文件夹名：创建文件夹 rd 文件夹名：删除文件夹（只能删除空文件夹） rd /s 文件夹名：询问删除 rd /s /q 文件夹名：暴力删除（不询问删除，不建议...
JAVA入门基础知识常用DOS指令、注释、常量、数据类型、运算符等
weixin_48003696的博客
05-25 2438
1.常用DOS命令 1.1 按下win+R，输入cmd，按下回车。 1.2 盘符切换，D： 查看当前路径下内容，dir 进入单级目录，cd 目录 退回上一级，cd … 进入多极目录，cd 目录1\目录2 退回盘符目录，cd 清屏，cls 退出命令提示符窗口，exit ...
java语言基础一（计算机常用基础知识，JDK的下载安装，注释关键字标识符以及常量变量运算符）
Liyuehahaha的博客
05-28 273
java 第一天之学到辽~ 1 .1 键盘功能键和快捷键 键盘功能键 Tab Shift Ctrl Alt 空格 Enter Window 上下左右键 键盘快捷键 Ctrl+A 全选 Ctrl+C 复制 Ctrl+V 粘贴 Ctrl+X 剪切 ...
Java知识体系最强总结(2021版)
热门推荐
ThinkWon的博客
12-18 110万+
更新于2019-12-15 10:38:00 本人从事Java开发已多年，平时有记录问题解决方案和总结知识点的习惯，整理了一些有关Java的知识体系，这不是最终版，会不定期的更新。也算是记录自己在从事编程工作的成长足迹，通过博客可以促进博主与阅读者的共同进步，结交更多志同道合的朋友。特此分享给大家，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。 文章目录...
计算机基础知识、常量、变量、数据类型转换、运算符、流程控制语句
YuanGuoHong的知识库
07-31 517
计算机常识 计算机只识别0和1。 所有的数据（文本文件、视频、图片、音频）在内存中存储都是0和1组成。 所有数据在传输过程中都是以0和1进行传输(二进制)。 数据的本质：二进制。 计算机语言的进化史： 机器语言（只有0和1） ----------&gt;汇编语言---------------&gt;高级语言 编码：将字符转换对应的二进制数据的过程。 解码：将二进制数据转换...
java基础知识核心要点之变量与数据类型（第一课），养成良好的编码习惯很重要
巴胡子
09-06 457
1、标识符：用来给包，类，方法，变量等起名字的符号 组成规则： （1）unicode字符 数字字符，英文大小写字母 （2）下划线_ （3）美元符$ 注意事项： （1）不能以数字开头 （2）不能是Java中的关键字命名 2、48个关键字： abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、doub...
JAVA第二课：关键字，标识符，数据类型，运算符
爱思考的小伙
10-27 638
文章目录1. 常用DOS命令2. 关键字3. 标识符4. 注释5.常量 1. 常用DOS命令 Win + R，输入: cmd，调出Dos窗口 项目 Value d: 回车 盘符切换 dir(directory) 列出当前目录下的文件以及文件夹 md (make directory) 创建目录 rd (remove directory) 删除目录 cd (change directory) 改变指定目录(进入指定目录) cd… 退回到上一级目录 cd\ 退回到根目录
Java概述、helloworld案例、工具安装 、配置环境变量、注释、关键字、常量、变量、数据类型、标识符
weixin_42366273的博客
03-13 129
第1章 Java概述 1.1 Java语言发展史和平台概述 A:Java语言发展史 詹姆斯·高斯林（James Gosling）1977年获得了加拿大卡尔加里大学计算机科学学士学位，1983年获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sherida...
Java基础 SE
07-09
6. Java关键字：关键字是Java语言中已赋予特定意义的词，如class、public、static等，它们是语言的组成部分，不能用作变量名或其他标识符。 7. Java标识符：标识符是程序员为类、方法、变量等定义的名称。Java语言...
黑马程序员：轻松精通Java学习路线基础篇!JAVA语言
03-26
5. 数据类型：掌握 Java 语言的数据类型，如基本数据类型和引用类型。 6. 运算符：熟练掌握 Java 中的运算符：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、三目运算符。 7. 流程控制语句：了解什么...
Java基础语法(HelloWorld、常识、常量、变量和数据类型、数据类型转换、运算符、方法、流程控制语句、数组、开发工具)
jxstudy的博客
06-27 491
HelloWorld、常识、常量、变量和数据类型、数据类型转换、运算符、方法、流程控制语句、数组、开发工具
万字文肝Java基础知识(一)
Amo Xiang的博客
07-05 6359
目录一、 前言、入门程序、常量1.1 Java 语言开发环境搭建1.2 常用 DOS 命令的使用1.3 环境变量 JAVA_HOME 的配置二、HelloWorld 入门程序2.1 程序开发的步骤2.2 HelloWorld 案例的编写编译运行2.3 初学者编写 HelloWorld 常见问题2.4 Notepad++ 软件的安装和配置三、注释和关键字3.1 注释3.2 关键字3.3 标识符四、常量与变量4.1 常量的概念和分类4.2 打印不同类型的常量4.3 变量和数据类型【重要】4.4 数据类型转换4.
01【计算机基础、Java概述】
緑水長流*z
07-30 9972
01【计算机基础、Java概述】 一、计算机的基础 1.1 计算机基础 1.1.1 计算机基础概述 Java是一门编程语言，语言有英语、法语、俄罗斯语等，仅我们国家就有汉语、藏语、满语等，但不管是什么语言，都是用来沟通的介质。其表达意思的本质都是一样的，程序员编程的本质就是让计算机去工作，而编程语言就是程序员与计算机沟通的介质程序员要想让计算机工作，必须知道计算机能干什么，怎么干的，这也就是我们必须学习计算机基础的原因； 程序员用编程语言写程序，最终开发出的结果就是一个软件，这些软件必须运行在操作系统
spring事务详细讲解-深入浅出
小电玩
09-08 397
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1407
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 1337
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
Java集合——Stack详解
最新发布
yang_brother的博客
09-10 270
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值