我在VScode学Java（Java的介绍，数据结构，运算符，流程控制语句）

学习JAVA

• 零.前言
• • 一>Java的介绍
  • • 1.1）语言的发展
    • • 其他：
    • 1.2）JAVA的特点
    • 1.3）代码举例：
    • 1.4）Java工作机制
  • 二>Java的开发配置
  • • 2.1>安装JDK
    • 2.2>配置（扩展）
    • • 检测是否已经有了JDK
      • JDk可以做些什么
  • 三>利用记事本来写
  • 四>Java的简单的输入和输出
  • • 键盘录入介绍
    • • 注意事项：
• 壹.Java基础的语法
• • 一、必要点
  • • 【1】Java--标识符：
    • • 命名规则：
      • Java变量的作用域
      • 变量赋值
      • 注意事项：
    • 【2】Java--关键字：【所有字母都为小写、不能作为标识符】
    • 【3】Java--分隔符
    • 【4】Java--注释：（三种）
    • 【5】Java语句编写方式
    • • 空语句（Empty Statement）
      • 表达式语句
    • ==*常见的术语表达*==
  • 二、数据类型【这一节只有基本数据结构，引用数据结构是简单说明】
  • • 字符型（char）:
    • • 【1】Java的转义字符与C类似，其形式是16进制是使用了\uxxxx格式：
      • 【2】字符串类型【引用类型[^什么是引用类型]】：
      • 【3】字符串写法和常用的使用方法：
      • • (1)可以使用length()方法找到字符串的长度：
        • (2)‘+’可以拼接两个字符串
      • 【4】文本块：
      • • [1]在文本块内部，每一行的结尾都会自动添加一个换行符，因此如果不想换行，需要在行末添加反斜杠（\）来续行。
        • [2]文本块中保留前缀或后缀空白，则可以使用特殊的转义序列，如\s表示空格、\n表示换行符
      • 【5】空串与NULL串
      • • 区别：
      • 【6】构建字符串
    • 数值型（整数类型 and 浮点型）整数参与计算，结果只能得到整数
    • • 【0】介绍一种分隔符
      • • 进制转化：
        • printf的方法原型：
      • 【1】Java整数--byte （整型溢出知识点）
      • 【2】Java整数--short（整形提升知识点--显式/隐式类型转换
      • • • 显式/隐式类型转换：
      • 【3】Java整数--int 【Java语言默认的整型类型】：
      • 【4】Java整数--long :
      • 【5】Java浮点数--float 【储存大型浮点数组，可节省内存空间】 小数参与计算，结果有可能是不精确的，:
      • 【6】Java浮点数--double 【Java语言默认的浮点类型】【自动类型转换】：
    • 布尔类型boolean（true和false）
    • 空类型（void）
  • 局部变量：会遮蔽(shadow)同名的实例字段。
  • • 用var声明---->var关键字只能用于局部变量，不能用于成员变量、方法参数或返回类型的声明。
    • • 注意：
      • 什么是声明变量的类型：
      • var关键字在以下情况下不适用：
      • • == 不适用的情况示例==：
      • 可以在哪里用：
    • 代码:
  • 三、运算符[^什么是运算符]：
  • • 【1】Java语言关于运算符的简单介绍
    • 【2】Java语言和C语言/Python语言的运算符做对比
    • • （1）"+"运算符:除了做数值运算外；
      • • 注意事项
      • （2）‘-’运算符:除了做数值运算外：
      • （3）"*"运算符:除了做数值运算外
      • （4）"/"运算符:除了做数值运算外
      • （5）"%"运算符:除了做数值运算外
      • （6）"~"运算符:取反
      • （7） '!'运算符
      • • 转换成布尔类型
        • 转换成整数类型
      • （8）"++”和"--"运算符
      • （9）位运算运算符
      • （10）简捷运算符+=等：
      • （11）逻辑运算符
      • （12）三目运算符
      • （13）比较运算符：
      • （14）运算符优先级比较
    • ==常见的术语表达==
  • 四、Java的流程控制语句[^流程控制语句可以分为]
  • • 从结构化程序设计角度考虑：
    • • 流程控制语句和结构化程序设计角度看的异同点
      • 结构化和非结构化：
    • 三大结构：
    • • boolean数据类型：(ture)or(flase)
      • 顺序结构：
      • 分支结构
      • • 【1】分支结构与分支语句的关系
        • 【2】常见的分支语句：
        • （1）IF--else结构
        • • if语句
          • if--else 语句：非此即彼
          • 嵌套if语句
        • （2）Switch-case结构【break和】
        • • 注意事项：
          • 嵌套的Switch语句
        • （3）三目运算符：
        • 【3】Switch语句和IF语句的比较
        • 【4】有无语义直通：
      • 循环结构
      • • 【1】循环结构与循环语句的关系
        • 【2】常见的循环语句
        • • （1）while循环：“当型”循环【特点：先判断，再执行】。
          • （2）do-while循环：“直型”循环【特点：先执行，再判断】。
          • （3）while和do-while的关系
          • （4）for循环：
          • （5）foreach语句：
          • （6）注意事项
      • 跳转语句
      • • 【1】break语句
        • 【2】continue语句
        • Java语言中的break和continue的区别？
      • Java选择结构和循环结构
  • 五、牢记项目

零.前言

一>Java的介绍

1.1）语言的发展

1991年，James Gosling在SUN公司的工程师小组想要设计这样一种小型计算机语言。该语言主要用于像电视盒这样的消费类电子产品，由于不同的厂商选择不同的CPU和操作系统，后要求语言本身是中立的，也就是可以跨平台。

  有过渡版本
长期支持版本( LTS )

其他：

现在最常用的3个体系：即== Java SE【我现在在学习的】==、Java EE 和 Java ME。

Java SE 支持 Java Web 服务开发的类，并为 Java EE 提供基础，如 Java 语言基础、I/O 操作、网络通信以及多线程等技术。

Java EE 为企业版本帮助开发和部署可移植、健壮且安全的服务器端 Java 应用程序。

Java ME 在移动设备端和嵌入式设备，提供一个健壮灵活的环境。

1.2）JAVA的特点

1、多线程；2、分布式；3、健壮性；4、高性能；5、安全性；6简单性；7、解释执行；

对比C语言/C++语言来说，JAVA是没有指针的困扰；
Java具有强制类型的定义，不必为了类型转换过程中的遗忘干扰。
可以跨平台，windows,Linux，macOS等【是因为虚拟机实现的】

1.3）代码举例：

public class work {public static void main(String[] args) {System.out.println("**************");System.out.println("   welcome    ");System.out.println("**************");}
}

1.4）Java工作机制

Java是一种混合型语言，它既可以编译也可以解释【经过编译器先行编译为机器代码，之后再运行。】。

Java源代码首先被编译成字节码，然后在Java虚拟机（JVM）上解释执行。【Java 虚拟机只要是用来运行Java字节码文件的虚拟机。JVM真正运行Java程序的地方】
这种混合型的设计使得Java具有高度的可移植性和跨平台性。在执行Java程序时，JVM会将字节码转换为机器码，这种转换过程是实时的，因此Java程序的执行速度相对较慢。	【JVM 执行字节码时实际上还是要解释成具体操作平台的机器指令的。】
但是，由于Java程序可以在不同的操作系统和硬件上运行，因此Java成为了一种广泛使用的编程语言。

也就是生成以下：

这个.class的字节码的文件二进制的

二>Java的开发配置

jdk,JVM,JRE
JDK–>JRE–>JVM

2.1>安装JDK

我用的是VSCode这个集成开发环境¹，只需要管理好配置就可以了。

下载VSCode

鼠标滑到下面，找到这个点进去

左边栏选选择Java，下载适配编译包，我的是windows系统的，所以下载出来

所以下载出来

2.2>配置（扩展）

紫色那个：

添加关于Java的配置

我安装了以下配置环境：

检测是否已经有了JDK

打开cmd输入java -version

出现了java下载的版本数就说明成功了！

JDk可以做些什么

]DK是]ava开发工具包
JVM虚拟机: Java程序运行的地方核心类库: Java已经写好的东西，我们可以直接用
开发工具: javac编译工具 java 运行工具 jdb调试工具 jhat内存分析工具

三>利用记事本来写

上面说到了cmd那么我们就利用这个写一个简易的 hello world

首先我们需要将=文件扩展名展开=方法：
文件资源管理器–>上方的更多—>选项—>查看–>

• 隐藏已知文件类型的扩展名

反向取消；

在记事本里打一个HelloWorld：

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

将其文件扩展名由.txt改成.java最后图标改变

获取文本的绝对位置，右击属性：

在cmd里先打入cd 在加上Desktop【这个主要看每个人主机的或者自己保存的地方而言】

来一个万能选手 —>hello world

在cmd中的应用

根据文件所在盘服，及其且绝对位置下的，执行 java 文件名【public class 后的】。

四>Java的简单的输入和输出

输入
1. 使用System.in对象输入
2. 使用命令行参数：main()方法的String[]参数

输出
System.out.println()
System.out.print()

键盘录入介绍

Java帮我们写好一个类叫Scanner，这个类就可以接收键盘输入的数字

步骤一: 导包 ---Scanner这个类在哪

import java.util.Scanner;导包的动作必须出现在类定义的上边

步骤二：创建对象 --- 表示用Scanner这个类了---->[需要注意的是，只有 sc 是变量名，其他部分都是固定的语法，不能更改。]

Scanner sc = new Scanner(Svstem.in);

如果你想要使用不同的变量名，可以将 sc 替换为你想要的名称。
你可以使用以下代码创建一个名为 input 的 Scanner 对象：
Scanner input = new Scanner(System.in);

步骤三:接收数据 --- 真正开始干活了

int i = sc.nextInt(); 左面这个格式里面，只有i是变量名，可以变，其他的都不允许变

如果说，这个sc.nextInt();要是同样的整数的其他的整数输出入的话。
一定是左边的要大于等于右边的：我的意思是—>int 可以对应 sc.nextInt()； sc.nextshort()； sc.nextbyte()；
而 sc.nextLong();就是错的。

注意事项：

如：

package trystringjava;import java.util.Scanner;public class Helloworld {public static void main(String[] args) {Scanner sc = new Scanner(System.in);int i = sc.nextByte();System.out.println(i);sc.close();}`

在这其中 的 int i = sc.nextByte();的代码
需要注意的是，字节的范围比整数小，因此如果您输入的字节超出了字节的范围，可能会导致错误。]

壹.Java基础的语法

一、必要点

【1】Java–标识符：

我们在C语言命名的是，数字字母下划线【a z || A-Z || 0~9 || ‘_’】

到了Java的学习之路中，

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

    标识符是由字母、下画线、美元符号($)和数字组成，并且需要遵守以下的规则; 以及局部范围。

（标识符用来表示变量、常量、类、方法、数组、文件、接口、包等元素的名字。）

命名规则：

·包名：多单词组成的小写。如：my_writejava
·类名接口名：多单词拼接时，首字母需要大写（和驼峰命名法类似）：My_Check
·变量名和方法名：手个单词小写，第二个开始的单词首字母都大写（和小驼峰命名法是一样的）my_Fun
·常量名：所以字母都需要大写，对于多单词的来说需要用下划线来拼接：MY_LOVE_OJ

Java变量的作用域

全局变量（实例变量） (无 static 修饰) 【对象名.变量名】 只要对象被当作引用，实例变量就将存在
静态变量（类变量） (用 static 修饰 )【类名.变量名或对象名.变量名】 其生命周期取决于类的生命周期。类被垃圾回收机制彻底回收时才会被销毁

变量赋值

（1）声明时直接赋值；或者先声明、后赋值。
（2）多个同类型的变量可以同时定义或者初始化，但是多个变量中间要使用逗号分隔，声明结束时用分号分隔。

注意事项：

关键字不能用作标识符。
标识符是大小写敏感的。
首字符不可以让数字作为开始首字符之后可以是字母、下画线、美元符号($)。

【2】Java–关键字：【所有字母都为小写、不能作为标识符】

字母小写且常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观

class: 用于 (创建/定义) 一个类
类是Java最基本的组成单元

保留关键字（是关键字，但不能使用）：goto  const。在Java 的 null 不是关键字，与 true 和 false，属于是字面常量。用于定义数据类型的关键字：class、interface、enum、byte、short、int、long、float、double、char、boolean、void[class关键字表示定义一个类，后面跟随类名用于定义数据类型值的关键字：true、false、null用于定义流程控制的关键字：if、else、switch、case、default、while、do、for、break、continue、return用于定义访问权限修饰符的关键字：private、protected、public用于定义类、函数、变量修饰的关键字：abstract、final、static用于定义类和类之间关系的关键字：extends、ipplements

【3】Java–分隔符

空格
这里指广义的空格 (即白字符)包括空格、换行(\m)页(\f)符(\r)制符 (\t)种。连续的多个空格与一个空格的效果相同。

分隔符
()参数列表、控制语或强制型转换、高优先级O:
{}:初始化数据定语块、类、方法以及局部范围
[]: 用来声明数组的类型，也用来表示对数组的用
;:用来终止一个语句; for 控制语句
,了:分隔变量表中的各个变量; for控制语句。 也可以作为数字的分割符printf的那个输出
.调用引用变量或方法，引用数组的元素.

有些资料认为上述分隔符也是运算符，如点运算符。

【4】Java–注释：（三种）

注释是在程序指定位置添加的说明性信息简单理解，即对代码的一种解释。
分为
单行、多行、文档

public class HelloWorld {/* 我是第一个Java程序* 它将输出 Hello World* 我是一个多行注释的示例*/public static void main(String[] args){// 这是单行注释的示例【单行注释：和C语言一样的是‘//’】/* 这个也是单行注释的示例 */ 【多行注释，和C语言一样的是‘/*   */’】System.out.println("Hello World"); }
}

【5】Java语句编写方式

空语句（Empty Statement）

在程序中什么都不做，不具有实际性的语句。

空语句的语法格式如下：
; 

表达式语句

在Java的赋值表达式后面添加分号就成了独立的语句。

常见的术语表达

.class file (.class文件)
java file (java文件)
assembly language(汇编语言)
bit (比特)
block (块)
block comment(块注释)
bus (总线)
byte (字节)
bytecode (字节码)
central processing unit (CPU，中央处理器)class loader(类加载器)
comment (注释)
compiler (编译器)
console (控制台)
hardware(硬件)
high-levellanguage (高级语言)
Integreted Development Environment(IDE，集成开发境)
javac command (javac命令)
Java Development Toolkit (JDK，Java开发工具包)Java Virtual Machine (JVM，Java虚拟机)
keyword or reserved word (关键字或保留字)
line comment (行注释)
machine language (机器语言)
main method (main方法)
memory (内存)
Network Interface Card (NIC，网络接口卡)
Operation System (OS，操作系统)
pixel(像素)
program (程序)
programming(程序设计)
software(软件)
source code(源代码)
source file (源文件)
specificimport(明确导入)
storage devices (存储设备)
statement(语句)
java command (java命令)
indentation (缩进)

二、数据类型【这一节只有基本数据结构，引用数据结构是简单说明】

Java 变量
Java 中主要有如下几种类型的变量
局部变量
类变量（静态变量）
成员变量（非静态变量）

字符型（char）:

默认值： ‘u0000’ -------->单引号起来的有且只有一个字符
字符是–>单一的 16 位 Unicode 字符； 字符类型用关键字char来表示单个字符，常见的字符有：字母、数字、标点符号或其他符号。 在Java语言中使用 Unicode字符集，因此char类型的数据均是16位，不论是英文单字母还是中文的单个字，都占用两个字节的内存空间来储存。字符类型常量用一对单引号括起来，如’J’、‘a、‘7’、"爪’。也可以使用Unicode编码来表示字符值，用\u开头的4个十六进制数表示，如’\u0041表示’A。

1990年开始研发，1994年正式公布。统一码（Unicode），也叫万国码、单一码，是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，
以满足跨语言、跨平台进行文本转换、处理的要求。为每一个字符而非字形定义唯一的代码（即一个整数）统一码以一种抽象的方式（即数字）来处理字符。实现方式：包括：UTF-8、UTF-16、UTF-32。（“UCS Transformation Format”）【分别以BYTE、WORD、DWORD作为编码单位】

这Unicode 统一码和我们熟知的ascll编码值有什么区别
（1） ASCII编码是1个字节，而Unicode编码通常是2个字节。一个具有注脚的文本。²
（2）Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了一个具有注脚的文本。³ 但是用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算。

【1】Java的转义字符与C类似，其形式是16进制是使用了\uxxxx格式：

下面是从网络中找了一张图片完美的诠释了转移字符和Unicode码的关系和作用

\t 制表符
在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格

 public static void main(String[] args) {System.out.println("name" + '\t' + "age");System.out.println("tom" + '\t' + "18");}

【2】字符串类型【引用类型⁴】：

默认值：null

在Java语言中字符串String虽然不是语言的基本数据类型。
char类型只能表示一个字符。在实际问题解决过程中为了表示一串字符，我们就要使用一种被命名为String (字符串)的数据类型。例如下述代码将消息声明为一个字符串，其值为“My_WriteJava”:表示为 String First_JavaTxt ="My_WriteJava";

【3】字符串写法和常用的使用方法：

String 字符串名称="字符串内容"

(1)可以使用length()方法找到字符串的长度：

String a="asdasdas
System.out.println(a.length（）)

(2)‘+’可以拼接两个字符串

在 java 中，任何字符类型与字符串相加，结果都是拼接。

String a = "hello";
String b = "My_Java";
System.out.println(a + " " + b);

【4】文本块：

	Java 15及以上版本支持使用文本块，可以使用三个双引号（"""）来表示一个文本块。
【可以在Java源代码中更清晰、更易读地表示多行字符串，避免了使用转义序列的需要。】

例如：

String textBlock = """Hello,World!
""";
结果：
/*
Hello,
World!
*/

[1]在文本块内部，每一行的结尾都会自动添加一个换行符，因此如果不想换行，需要在行末添加反斜杠（\）来续行。

String prompt = """Hello,\World!""";System.out.println(prompt);

[2]文本块中保留前缀或后缀空白，则可以使用特殊的转义序列，如\s表示空格、\n表示换行符

 String prompt = """Hello,\nWorld!""";System.out.println(prompt);

和下面的代码对比

 String prompt = """\Hello,\nWorld!""";System.out.println(prompt);

【5】空串与NULL串

空串“”是长度为0的字符串：是Java的一个对象

if（str.length()==0)
或者：
if(str.equals(""))
或者：
isEmpty()方法

而Null是一个特殊的值

if(str==null)
if(str!=null&&str.length()!=0)

区别：

长度为0的字符串中虽然没有字符，但其仍然是一个有效字符串对象。
而null是一个对象没有被实例化，或者没有指向任何有效的内存地址

obj是需要判断的对象。如果obj为NULL，则执行do something中的代码。否则，不执行任何操作。
if (obj == null) {// do something
}

null串。这个对象可以是任何类型的对象，包括字符串、数组、类等等。当一个对象被赋值为null时，
它就不再指向任何对象，也就是说它不再引用任何对象，因此也就无法访问该对象的任何属性或方法。

【6】构建字符串

• stringbuilder str11=new stringbuilder();

数值型（整数类型 and 浮点型）整数参与计算，结果只能得到整数

Java给了六种数值类型，并定义它们的使用范围以及所占存储空间。
整数类型： byte、short、int、long
浮点类型：float、double
有根据Java基于JVM，则其所占字节是与机器无关的，这就与C语言的字节占用是有不一样的地方。

Java会默认进行整型提升。

	在Java中，当一个表达式中包含不同类型的数据时，会自动将较小的数据类型转换为较大的数据类型，
以便进行计算。这个过程被称为“自动类型转换”或“自动提升”。整数默认值均为0（特殊的long 是0L）
float  0.0f
double 0.0d

【0】介绍一种分隔符

System.out.printf("%,d\n", 1000000000 / 3);333,333,333System.out.printf("%,.2f", 1000000000.0 / 3.0);333,333,333.33

进制转化：

（1）任意进制转十进制:系数*基数的权次幂 相加。

系数:就是每一位上的数
基数:当前进制数
权:从右往左，依次为012345

（2）十进制转其他进制

除基取余法不断除以基数 (几进制基数就是几)得到余数直到商为0，再将余数倒着拼接即可

printf的方法原型：

public PrintStream printf(String format, Object... args)

第一个参数是格式化字符串，后面的参数是可变参数，可以传入任意数量的参数。格式化字符串中可以包含占位符，例如%d表示整数，%s表示字符串等等。

正数且智能有一个空格

   System.out.printf("% d\n", 123);System.out.printf("% d", -123);

【1】Java整数–byte （整型溢出知识点）

1字节（8bit）其中高位是符号位，其余位是数值位[-128-127即2^(-7)~ 2^(7)]
相信大家都看过下面的吧

包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127byte类型虽然在语义(逻辑)上是占用1字节，但实际上JVM中是将其当做int看的，也就是占用了32位（4字节）
所以其运算效率和int没区别，short一样。

上述中==“JVM中是将其当做int看的”==这是由于整型上升的原因。
Cursorcode给的对话

中文回答

虽然由于在JVM看来与int无任何差别，但是不同的数值关键字必然有着其范围和储存空间的能力。
如果超出一定会导致的结果就是整型溢出.⁵
引入一个概念溢出和下溢⁶

观察下面的代码（并用自己的编辑器编译–我用VScode）

int i = Integer.MAX_VALUE;
System.out.println(i);
i++;
System.out.println(i);

解决办法：
（1）将整形溢出的结果类型手动提升

byte a=128变成 int a=128只改变数据类型就好了
（2）就是把右值钱加上相对应的类型，也就是得到溢出的结果

在byte[]数组中，JVM存储的则是真的1字节，short[]2字节。
（但也有的JVM其byte[]数组也是4字节1位）

【2】Java整数–short（整形提升知识点–显式/隐式类型转换

2字节（16bit）其中高位是符号位，其余位是数值位[_-32768-32767即_{2^(-15) 2^(15)}]

short是一个16位有符号整数数据类型，与byte数据类型一样，short数据类型也容易发生整型溢出。
其最大值可以表示为Short.MAX_VALUE
short变量的默认值为0。short可以像其他基本数据类型一样在Java中声明和初始化。

包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767short变量可以像其他数字数据类型一样用于算术表达式。
在对short变量执行算术运算时，结果会自动提升为int类型。
这意味着，如果要将结果存储在short变量中，您需要将结果强制转换回short类型。

short a = 10;
short b = 20;
short c = (short) (a + b); // 需要将结果强制转换为short类型

上述代码是需要将结果强制转换为short类型的原因是因为：
在Java中，当两个short类型的值进行运算时，会自动将它们提升为int类型，然后再进行运算。（既然类型都被改变了，使用存储类型空间不对称就不可能切记一点Java语言是自动整型提升的，但会按照其存储范围）

（1）在Java中，int是32位有符号整数，而short是16位有符号整数。
当你将int转换为short时，值会被截断以适应较小的数据类型。
这意味着如果int值太大而无法适应short，则生成的short值将与原始int值不同。
但是，如果int值足够小以适应short，则转换将成功，生成的short值将与原始int值相同。（2）在C中，情况不同。当你尝试将int值分配给short变量时，如果int值太大而无法适应short，则编译器将发出警告或错误。
这是因为C不像Java那样自动截断值。相反，你需要显式地将int值转换为short才能执行转换。

在C中，情况不同。当你尝试将int值分配给short变量时，如果int值太大而无法适应short，则编译器将发出警告或错误。这是因为C不像Java那样自动截断值。相反，你需要显式地将int值转换为short才能执行转换。

在Java语言中，将低数据类型转换为高数据类型时，Java会自动将低数据类型提升为高数据类型。这是Java中的隐式类型转换。
区别于C语言，情况不同。当你将低数据类型转换为高数据类型时，C语言不会自动将低数据类型提升为高数据类型。
相反，你需要显式地将低数据类型转换为高数据类型才能执行转换。这是C语言中的显式类型转换。

显式/隐式类型转换：

Java可以显式类型转换【称为拓宽类型(widening a  type)】也可以隐式类型转换【为缩窄类型 (narrowing a type)】

（1）显式类型转换，也称强制类型转换，是指必须书写代码才能完成的类型转换。该类类型转换很可能存在精度的损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。
转换规则：从存储范围小的类型到存储范围大的类型。 【低类型---->高类型】

（2）隐式类型转换，也称自动类型转换，是指不需要书写代码，由系统自动完成的类型转换。由于实际开发中这样的类型转换很多，所以Java语言在设计时，没有为该操作设计语法，而是由JVM自动完成。
转换规则：从存储范围大的类型到存储范围小的类型。 【高类型---->低类型】

（3）强制类型转换通常都会存储精度的损失，所以使用时需要谨慎

显式类型转换和隐式类型转换都可能会导致精度或数据丢失。例如：将一个非常大的整数转换为浮点数时，可能会丢失精度。

隐式类型转换可能会导致精度或数据丢失。例如：整型溢出。

double x=9.8888;
int intX1=(int)x;
System.out.println(intX1);// 9int intX2=(int)Math.round(intX2);
System.out.println(intX2);// 10

【3】Java整数–int 【Java语言默认的整型类型】：

4字节（32bit）其中高位是符号位，其余位是数值位。范围[_{-2的31次方-2的31次方}]；
小心溢出或下溢⁶

包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647

如果两个int类型的变量相加的结果超出了int类型的范围，则会发生溢出。【防止溢出】

如果是在二分法一般是用[（left+right）/2]  ---->如果是两个大数必然导致的一种情况是溢出
但是如果选择  [left+(right-left)/2]

这个情况一般就是两数交换：

（1）引入第三个“瓶子”空间存储

int  a,b,c;
c=a; a=b;b=c;

(2) 加法
a = a + b; b = a - b; a = a - b;
(3)异或操作
a = a ^ b;
b = a ^ b;
a = a ^ b;

【4】Java整数–long :

8字节（64bit）其中高位是符号位，其余位是数值位。范围[_{-2的63次方-2的63次方}]；

默认值是 0L【"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。】
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807

【5】Java浮点数–float 【储存大型浮点数组，可节省内存空间】 小数参与计算，结果有可能是不精确的，:

4字节（32bit），单精度，符合IEEE 754标准的浮点数。写的时候数字后面加f/F(这是为了使得计算机明白我们用到是单精度浮点型，而Java给定的是double为默认的浮点类型）
如果需要更少的内存使用和更快的计算速度，则可以使用float。

包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
float能精确到后6位

浮点数在计算机中的表示方式是通过二进制的方式来表示的，而不是十进制。因此，有些十进制的小数无法精确地转换为二进制，这就会导致一些舍入误差

一般来说，当浮点数的小数部分中有16位及以上的数字时，就会出现舍入误差。这是因为在IEEE 754标准中，双精度浮点数（64位）的小数部分有53位，而单精度浮点数（32位）的小数部分有24位。因此，当小数部分的位数超过这个范围时，就会出现舍入误差。

【6】Java浮点数–double 【Java语言默认的浮点类型】【自动类型转换】：

8字节（64bit），单精度，写的时候数字后面不加f/F
它的默认值为0.0。
它可以用于数学运算，如加法、减法、乘法和除法。

包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
double能精确到后15位

Java语言和C语言与Python在double上的异同点:

到了这里我们已经将Java语言中的数据存储的关键字，那么我们就需要了解什么是自动类型转换⁷

布尔类型boolean（true和false）

布尔型常量只有两个true和false【它们是Java关键字（字面常量）】
不能用0或1表示布尔型的值
默认值：false

这个与条件语句常用就放到下面在细说

空类型（void）

表示没有类型，仅用于方法返回值类型的声明上。
注意：空（null）不是类型，是一个字面常量，它表示没有值，用于表示引用数据类型的值为空。

局部变量：会遮蔽(shadow)同名的实例字段。

用var声明---->var关键字只能用于局部变量，不能用于成员变量、方法参数或返回类型的声明。

var 关键字是在 Java 10 中引入的。它允许在声明变量时根据上下文自动推断变量的类型。使用 var 关键字可以简化代码并提高可读性。

var关键字只能用于局部变量，不能用于成员变量、方法参数或返回类型的声明。
此外，虽然类型可以通过推断得出，
但变量一旦被赋予了初始值，其类型就无法改变。

 public static void main(String[] args) {var number = " 42"; // Inferred as int typeSystem.out.println(getType(number));}private static String getType(Object variable) {return variable.getClass().getSimpleName();}

注意：

var 被错误地用于声明变量的类型，导致编译错误。在 Java 中，变量的类型必须明确指定，不能使用 var 来声明变量的类型

什么是声明变量的类型：

声明变量的类型 是指在编程语言中，明确指定变量的数据类型。在 Java 中，变量的类型决定了变量可以存储的数据的种类和范围。声明变量的类型是为了告诉编译器变量的数据类型，以便在编译时进行类型检查和类型推断。

在 Java 中，变量的类型可以是基本数据类型（如整数、浮点数、布尔值等）或引用数据类型（如字符串、数组、对象等）。声明变量的类型可以使用关键字（如 int、double、boolean 等）或类名（如 String、ArrayList 等）。
int age = 25;

var关键字在以下情况下不适用：

对于方法的参数和返回类型：var不能用于方法的参数声明和返回类型声明。方法的参数和返回类型必须显式地指定类型。

对于成员变量：var不能用于类的成员变量（字段）。类的成员变量必须显式地指定类型。

对于未经初始化的局部变量：var不能用于未经初始化的局部变量。var关键字要求变量在声明时必须同时进行初始化。

对于多个变量声明初始化的情况：var只能用于声明和初始化单个变量，无法用于同时声明和初始化多个变量。

== 不适用的情况示例==：

// 不适用的情况// 方法参数和返回类型需要显式指定类型
public void doSomething(var param) { // 错误// ...
}public var getSomething() { // 错误return something;
}// 成员变量需要显式指定类型
private var count; // 错误// 未经初始化的局部变量无法使用var
var x; // 错误// 同时声明和初始化多个变量无法使用var
var a = 1, b = 2; // 错误

可以在哪里用：

var 关键字可以用于任何可以使用局部变量的地方，例如方法内部、循环体内部等。

代码:

 public static void main(String[] args) {var number = 42; // Inferred as int typeSystem.out.println(getType(number));Scanner sc = new Scanner(System.in);int ddd = sc.nextInt();System.out.println(number == ddd);sc.close();}private static String getType(Object variable) {return variable.getClass().getSimpleName();}

在getType()方法中，我们将变量作为Object参数传递。通过在变量上调用getClass().getSimpleName()，我们可以获得它的数据类型作为一个String。最后，我们将数据类型作为结果返回。

请注意，getType()方法的返回类型已更改为String，以匹配getSimpleName()方法的数据类型。

这个修改后的代码将输出number变量的数据类型。

三、运算符⁸：

【1】Java语言关于运算符的简单介绍

基本的运算符包括算术运算符、赋值运算符、逻辑运算符和关系运算符等

在编程中，运算符可以根据其操作数的数量进行分类：

（1）一元运算符：例如，递增（++）和递减（--）运算符，以及按位补码（~）和逻辑非（!）运算符，都是一元运算符，因为它们只需要一个操作数。还有正号（+）和负号（-）表达的并非下面的含义时候
（2）二元运算符：例如，加法（+）、减法（-）、乘法（*）、除法（/）和取模（%）运算符，以及逻辑运算符（&&、||）和比较运算符（<、>、==）都是二元运算符，因为它们需要两个操作数。
（3）三元运算符：Java中唯一的三元运算符是条件运算符（?:），它需要三个操作数。

public static void main(String[] args) {int b = 12;int c = ~b;int d = b + 5;int e = b - 5;int f = b * 5;int g = b / 5;int h = b % 5;int i = b++;int j = b--;int k = ++b;int l = --b;System.out.println(c);System.out.println(d);System.out.println(e);System.out.println(f);System.out.println(g);System.out.println(h);System.out.println(i);System.out.println(j);System.out.println(k);System.out.println(l);}

加（+）、减（-）、乘（*）和除（/）\模运算(%)【其运算结果是整数除法的余数。】
~（按位取反运算符）：此运算符翻转操作数的位。请注意，它仅适用于整数类型，并且结果是与操作数相同类型的整数。还要注意，结果是有符号的，因此最高位（最左边的位）用于表示数字的符号。
+（加法运算符）：此运算符将两个操作数相加。它适用于数字类型（整数，浮点数）以及字符串（在这种情况下，它将它们连接起来）。请注意，如果其中一个操作数是字符串，则另一个操作数也将被转换为字符串。
-（减法运算符）：此运算符从第二个操作数中减去第一个操作数。它适用于数字类型。请注意，如果其中一个操作数是浮点数，则结果也将是浮点数。
*（乘法运算符）：此运算符将两个操作数相乘。它适用于数字类型。请注意，如果其中一个操作数是浮点数，则结果也将是浮点数。
/（除法运算符）：此运算符将第一个操作数除以第二个操作数。它适用于数字类型。请注意，如果两个操作数都是整数，则结果将是整数（小数部分将被截断）。还要注意，如果第二个操作数为零，则会发生运行时错误。
%（取模运算符）：此运算符返回第一个操作数除以第二个操作数的余数。它适用于整数类型。请注意，如果第二个操作数为零，则会发生运行时错误。
++（递增运算符）：此运算符将操作数加1。它适用于数字类型。请注意，它可以用作前缀或后缀，并且结果取决于使用哪个（前缀返回递增的值，后缀返回原始值）。
–（递减运算符）：此运算符将操作数减1。它适用于数字类型。请注意，它可以用作前缀或后缀，并且结果取决于使用哪个（前缀返回递减的值，后缀返回原始值）。

double rc = a - b * (int)(a / b);

【2】Java语言和C语言/Python语言的运算符做对比

运算符

对字面量或者变量进行操作的符号int a = 10;int b = 20；

表达式

用运算符把字面量或者变量连接起来符合java语法的式子就可以称为表达式不同运算符连接的表达式体现的是不同类型的表达式。int c = a + b

（1）"+"运算符:除了做数值运算外；

Java、C语言和Python语言都支持’+'运算符，但是它们在使用上有一些异同点：

1. Java中，'+'运算符可以用于数值类型、字符串和对象的相加操作。而在C语言和Python语言中，'+'运算符只能用于数值类型和字符类型的相加操作。
2. 在Java中，如果一个操作数是字符串类型，那么另一个操作数也会被转换为字符串类型，并且两个字符串会被连接起来。在C语言和Python语言中，如果一个操作数是字符类型，那么另一个操作数也必须是字符类型，否则会出现类型错误。
3. Java中，'+'运算符可以用于对象的相加操作，但是需要注意的是，这里的相加操作并不是数学意义上的相加，而是指将两个对象合并成一个新的对象。在C语言和Python语言中，'+'运算符不支持对象的相加操作。
4. 在Java中，'+'运算符也可以用于字符串的拼接，这个过程也被称为字符串连接。在C语言和Python语言中，字符串的拼接需要使用特定的函数库。##总的来说，Java中的"+"运算符更加灵活，可以用于连接任意类型的数据，而且会自动进行类型转换；C语言中需要使用专门的函数进行字符串拼接（《string.h》里面的）；Python中的"+"运算符可以直接将其他类型的数据转换为字符串类型。

（1）Java代码：

int a = 10;
int b = 20;
String str = "Hello";
Object obj = new Object();
// 数值类型相加
int sum = a + b;
// 字符串连接
String result = str + " World";
// 对象相加
Object newObj = obj + new Object(); // 合并成一个新的对象

（2）C语言代码：

int a = 10;
int b = 20;
char c = 'a';
char d = 'b';
// 数值类型相加
int sum = a + b;
// 字符类型相加
char result = c + d; // 注意：这里的加法是指字符编码的相加
// 字符串拼接
char str1[10] = "Hello";
char str2[10] = "World";
strcat(str1, str2); // 使用字符串库函数拼接字符串

（3）Python代码：

a = 10
b = 20
c = 'a'
d = 'b'
str = "Hello"
# 数值类型相加
sum = a + b
# 字符类型相加
result = c + d
# 字符串拼接
newStr = str + " World"

需要注意的是，Python中的字符串拼接可以使用’+'运算符，也可以使用字符串格式化等其他方式。

注意事项

• （1）数字进行运算时，数据类型不一样不能运算，需要转成一样的，才能运算
• （2）Java语言中连续进行”+“操作时，从左到右逐个执行，如果左边是数字先加就是加法，后面如果是字符就是拼接。即有字符串参与就是拼接
  System.out.print(a + b + "asdasd" + 1 + 21);//2asdasd121
• 【1】字符 + 字符；【2】字符 + 数字时，会把字符通过ASCI码表查询到对应的数字再进行计算。

（2）‘-’运算符:除了做数值运算外：

Java、C语言和Python都支持’-'运算符，它表示减法操作。它们在使用上也有一些异同点：

1. 在Java、C语言和Python中，'-'运算符都可以用于数值类型的相减操作。
2. 在Java和C语言中，'-'运算符也可以用于字符类型的相减操作，**这里的减法是指字符编码的相减。****在Python中，字符类型不支持相减操作。**
3. 在Java和Python中，'-'运算符也可以用于对象的相减操作，但是需要注意的是，这里的相减操作并不是数学意义上的相减，而是指两个对象之间的差异。在C语言中，'-'运算符不支持对象的相减操作。
4. 在Java和Python中，'-'运算符也可以用于日期类型的相减操作，用于计算两个日期之间的天数差、秒数差等。在C语言中，日期类型的相减需要使用特定的函数库。

以下是示例代码：
（1）Java代码：

int a = 12;
int b = 3;
char c = 'b';
char d = 'a';
Object obj1 = new Object();
Object obj2 = new Object();
Date date1 = new Date();
Date date2 = new Date();
// 数值类型相减
int dif1 = b - a;
// 字符类型相减
int dif2 = c - d; // 注意：这里的减法是指字符编码的相减
// 对象相减
int dif3 = obj1.hashCode() - obj2.hashCode(); // 两个对象之间的差异
// 日期相减
long dif4 = date2.getTime() - date1.getTime(); // 计算两个日期相差的毫秒数

（2）C语言代码：

int a = 10;
int b = 20;
char c = 'b';
char d = 'a';
// 数值类型相减
int dif1 = b - a;
// 字符类型相减
int dif2 = c - d; 

（3）Python代码：

a = 10
b = 20
c = 'b'
d = 'a'
date1 = datetime.datetime(2022, 5, 1)
date2 = datetime.datetime(2022, 6, 1)
# 数值类型相减
dif1 = b - a
# 日期相减
dif2 = date2 - date1

（3）"*"运算符:除了做数值运算外

在Java、C语言和Python中，'*'运算符都表示乘法操作。它们在使用上也有一些异同点：

1. 在Java、C语言和Python中，' * '运算符都可以用于数值类型的相乘操作。
2. 在Python中，' * '运算符还可以用于序列类型的重复操作，即将一个序列类型重复多次。
3. 在Java和Python中，' * '运算符也可以用于数组类型的初始化操作，即将一个数组初始化为相同的值。在C语言中，数组的初始化需要使用特定的语法（地址）。
4.在Python中，特殊的一点‘**’是幂运算  2**3==8

以下是示例代码：
（1）Java代码：

int a = 10;
int b = 20;
// 数值类型相乘
int product1 = a * b;
// 数组初始化
int[] arr1 = new int[5];
Arrays.fill(arr1, 0); // 将数组初始化为0
// 对象相乘
Object obj = new Object();
int num = 5;
Object newObj = obj * num; // 重复生成5个相同的对象

（2）C语言代码：

int a = 10;
int b = 20;
// 数值类型相乘
int product1 = a * b;

(3)Python代码：

a = 10
b = 20
str = "Hello"
# 数值类型相乘
product1 = a * b
# 字符串重复
newStr = str * 3 # 将字符串重复3次
# 数组初始化
arr1 = [0] * 5 # 将数组初始化为0

（4）"/"运算符:除了做数值运算外

在Java、C语言和Python中，'/'运算符都表示除法操作，但是它们在使用上也有一些异同点：

1. 在Java、C语言和Python中，'/'运算符都可以用于数值类型的相除操作。需要注意的是，在整数类型的除法中，如果除数为0会导致程序抛出异常或者运行错误。因此，为了避免这种情况，可以在除数前进行判断或者使用浮点类型的除法。
##C语言中的除法运算符将两个整数相除时截断小数部分，而Python中的除法运算符将返回一个浮点数。
2. 在Java和Python中，'/'运算符也可以用于日期类型的相除操作，用于计算两个日期之间的天数差、秒数差等。在C语言中，日期类型的相除需要使用特定的函数库《time.h》。
3.在python中，有两种表示除法‘/’和‘//’前者可能是浮点数，后者是向下取整

以下是示例代码：
Java代码：

int a = 10;
int b = 20;
int c = 0;
// 数值类型相除
if (b != 0) {int quotient1 = a / b;
}
double quotient2 = (double) a / b; // 使用浮点类型的除法
// 日期相除
Date date1 = new Date();
Date date2 = new Date();
long diff = date2.getTime() - date1.getTime(); // 计算两个日期之间的毫秒数
double days = diff / (1000 * 60 * 60 * 24.0); // 计算天数差

C语言代码：

int a = 10;
int b = 20;
// 数值类型相除
if (b != 0) {int quotient1 = a / b;
}
float quotient2 = (float) a / b; // 使用浮点类型的除法

Python代码：

a = 10
b = 20
date1 = datetime.datetime(2022, 5, 1)
date2 = datetime.datetime(2022, 6, 1)
# 数值类型相除
if b != 0:quotient1 = a / b
quotient2 = a / float(b) # 使用浮点类型的除法
# 日期相除
diff = date2 - date1
days = diff.total_seconds() / (60 * 60 * 24) # 计算天数差

需要注意的是，在Python 2.x版本中，整数类型的除法结果也是整数类型，即相当于向下取整，这可能会导致计算结果不准确。因此，在Python 2.x版本中，可以使用’//‘运算符进行整数类型的除法操作，而在Python 3.x版本中，’/'运算符已经默认进行了浮点类型的除法操作，因此不需要特别注意。

（5）"%"运算符:除了做数值运算外

Java在使用’%'运算符上与C语言和Python有一些异同点⁹，具体如下：

1. 相同点：
- Java、C语言和Python中的'%'运算符都表示取模运算，即求两个数相除后的余数。
- '％'运算符的结果与被除数的符号有关，如果被除数为正数，则取模运算的结果也为	正数；如果	被除数为负数，则取模运算的结果为负数或零。
2. 不同点：
- 在Java中，'%'运算符可以用于任何数字类型（包括整数类型和浮点类型），而在C语言和Python中，'%'运算符只能用于整数类型。
- 在Java中，如果被除数为负数，则'%'运算符的结果为负数或零，而在C语言和Python中，则根据具体实现而定，通常也是将结果向零取整。
- 在Java中，如果除数为0，则会抛出ArithmeticException异常[^Java中的ArithmeticException异常是什么] ，而在C语言和Python	中，则会导致程序错误或异常。总的来说，Java、C语言和Python的'%'运算符在基本功能上是相同的，但在具体实	现和一些细节上可能存在差异。
在使用'%'运算符时，需要根据具体编程语言的规范和	实现来进行使用。

以下是Java、C语言和Python的示例代码：
(1)Java,C语言代码：

int a = 10;
int b = 3;
int remainder1 = a % b; // 结果为1
int remainder2 = (-a) % b; // 结果为-1
int remainder3 = a % (-b); // 结果为1
int remainder4 = (-a) % (-b); // 结果为-1

(2)Python代码：

a = 10
b = 3
remainder1 = a % b # 结果为1
remainder2 = (-a) % b # 结果为2
remainder3 = a % (-b) # 结果为-2
remainder4 = (-a) % (-b) # 结果为-1

（6）"~"运算符:取反

在Java、C语言和Python中，'_{‘是一元位运算符，表示按位取反操作。它对一个二进制数的每一位取反，即把0变为1，把1变为0。需要注意的是，’}'运算符只能用于整数类型。

在Java和C语言中，'~'运算符的结果是一个整数类型，如果需要得到无符号的结果，则需要进行类型转换。
在Python中，'~'运算符的结果与操作数的类型有关，如果操作数为整数类型，则结果为整数类型；如果操作数为布尔类型，则结果为整数类型的True和False。

下面是Java ，c，python的代码
（1）在Java，C语言，Python中中，"~"运算符可以用于按位取反运算，例如：

int a = 5;
int b = ~a;
System.out.println(b);
// 输出：-6

（2）需要注意的是，在Java，C语言，Python语言中，按位取反运算是针对整数类型的，如果对其他类型进行按位取反运算，Java会将其转换为整数类型。例如：

char c = 'A';
int d = ~c;
System.out.println(d);
// 输出：-66

（3）需要注意的是，Python如果对其他类型进行按位取反运算，Python会抛出TypeError异常¹⁰。例如：

c = 'A'
d = ~c
# TypeError: bad operand type for unary ~: 'str'

（7） '!'运算符

在Java、C语言和Python中，'!'是一元逻辑运算符，表示逻辑非操作。它对一个布尔类型的操作数进行取反操作，即把true变为false，把false变为true。

以下是Java、C语言和Python的示例代码：

(1)Java代码
boolean a = true;
boolean b = !a; // b为false
Python代码：
a = True
b = not a # b为False

需要注意的是，在Java和C语言中，'!'运算符的操作数必须为布尔类型，否则会导致编译错误。在Python中，'!'运算符不是一个合法的语法，应该使用'not'关键字来表示逻辑非操作。

(2)逻辑非运算是针对布尔类型的,需要转换成布尔类型or整数类型

转换成布尔类型

需要注意的是，在Java,Python中，逻辑非运算是针对布尔类型的。如果对其他类型进行逻辑非运算，Java，Python会将其转换为布尔类型。例如：

int c = 5;
boolean d = !c;
System.out.println(d);
// 输出：false

c = 5
d = not c
print(d)
# 输出：False

转换成整数类型

C语言会将其转换为整数类型。

int c = 5;
int d = !c;
printf("%d", d);
// 输出：0

（8）“++”和”–"运算符

在Java、C语言和Python中，"++“和”–“运算符都是自增自减运算符，用于对变量进行加一或减一操作，没有字符串操作的功能。
(1)在Java中，”++“和”–“运算符可以用于对变量进行自增和自减操作.
需要注意的是，在Java中，”++“和”–"运算符可以用于前缀形式和后缀形式，前缀形式先自增或自减，后缀形式先使用原值再自增或自减。例如：

int c = 5;
int d = ++c;
System.out.println(c + "," + d);
// 输出：6,6
int e = 5;
int f = e--;
System.out.println(e + "," + f);
// 输出：4,5

(2)在C语言中，"++“和”–"运算符同样可以用于对变量进行自增和自减操作
【与Java不同的是，C语言中的’++‘和’–'运算符只能用于左值，即只能用于变量或数组元素等可以被赋值的表达式。】

(3)在Python中，"++“和”–"运算符不是合法的运算符，不能用于对变量进行自增和自减操作。需要使用赋值运算符和加减运算符实现自增和自减操作，例如：

a = 5
a += 1
print(a)
# 输出：6
b = 5
b -= 1
print(b)
# 输出：4

需要注意的是，在Python中，'++'和'--'运算符不是合法的语法，不能直接使用，
但是可以使用'+='和'-='运算符进行自增和自减操作。

（9）位运算运算符

	需要注意的是，位运算符==只能用于整数类型的值或表达式==，不能用于浮点数或其他类型的值或表达式。
在使用时需要注意数据类型的转换、符号位的处理和位数的溢出等问题。

在Java、C语言和Python中，位操作符用于对整数类型的值进行位运算。位运算是对二进制数进行的运算，包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移位（<<）和右移位（>>）。

"&"表示按位与运算符，表示两个二进制数的对应位都为1时才为1，否则为0。
"|"表示按位或运算符，表示两个二进制数的对应位只要有一个为1时就为1，否则为0。
"^"表示按位异或运算符，表示两个二进制数的对应位不同才为1，否则为0。
"~"表示按位取反运算符，表示对二进制数的每一位取反。例如：

int a = 5;  // 二进制表示为101
int b = 3;  // 二进制表示为011
int c = a & b;  // 二进制表示为001，即1
System.out.println(c);
// 输出：1
int d = a | b;  // 二进制表示为111，即7
System.out.println(c);
// 输出：7
int e = a ^ b;  // 二进制表示为110，即6
System.out.println(e);
// 输出：6
int f = ~a;  // 二进制表示为11111111111111111111111111111010，即-6
System.out.println(f);
// 输出：-6

"<<"表示左移位运算符，将一个二进制数的所有位向左移动指定的位数，低0。
">>"表示右移位运算符，将一个二进制数的所有位向右移动指定的位数，高位补0或1，取决于符号位。例如：

int a = 5;  // 二进制表示为101
int b = a << 2;  // 二进制表示为10100，即20
System.out.println(b);
// 输出：20
int c = a >> 2;  // 二进制表示为1，即1
System.out.println(c);
// 输出：1

Java和C语言都支持按位与运算符&，但Java中的&运算符还可以用于逻辑与运算。在C语言中，当&运算符用于两个整数或字符之间时，它将执行按位与操作。在Python中，&运算符不是按位与运算符，而是位运算中的“与”运算符，用于将两个二进制数的每个位进行“与”运算。

Java中的&运算符与C语言类似，但Java中还支持另外一个运算符&&，它用于逻辑与运算。Java中的逻辑与运算符&&具有短路特性，当第一个操作数为false时，第二个操作数不会被执行。而C语言中的&运算符不具有短路特性。

Python中没有逻辑与运算符，但可以使用and关键字进行逻辑与运算。与Java类似，Python中的逻辑与运算符and也具有短路特性，当第一个操作数为false时，第二个操作数不会被执行。但是，and关键字与&运算符不同，and关键字只能用于布尔类型的操作数。

Java示例：

int a = 10;
int b = 12;
int c = a & b; // 按位与运算
boolean d = (a > 5) && (b < 20); // 逻辑与运算

C语言示例：

int a = 10;
int b = 12;
int c = a & b; // 按位与运算
int d = (a > 5) & (b < 20); // 按位与运算

Python示例：

a = 10
b = 12
c = a & b # 按位与运算
d = (a > 5) and (b < 20) # 逻辑与运算
d = (a > 5) or (b < 20) # 逻辑或运算

需要注意的是，按位或运算符和逻辑或运算符的操作数类型不同。在Java和Python中，逻辑或运算符的操作数必须是布尔类型，而在C语言中，逻辑或运算符的操作数可以是任何类型。

（10）简捷运算符+=等：

在Java、C语言和Python中，“+=”、“-=”、“*=”、"/=“和”%="都是赋值运算符，【Java中都隐藏了一个强制类型转换】。

用于将运算结果赋值给左侧的变量¹¹

"+="表示将右侧的值加到左侧的变量上，并将结果赋值给左侧的变量。例如：
"-="表示将右侧的值减去左侧的变量的值，并将结果赋值给左侧的变量。例如：
"*="表示将右侧的值乘以左侧的变量的值，并将结果赋值给左侧的变量。例如：
"/="表示将左侧的变量的值除以右侧的值，并将结果赋值给左侧的变量。例如：
"%="表示将左侧的变量的值除以右侧的值的余数，并将结果赋值给左侧的变量。例

赋值运算符用于将一个值赋给变量，常见的赋值运算符有=、+=、-=、*=、/=、%=等。在Java、C语言和Python中都有支持。

int a = 5;
a += 3; // 等价于 a = a + 3;
a -= 2; // 等价于 a = a - 2;
a *= 4; // 等价于 a = a * 4;
a /= 2; // 等价于 a = a / 2;
a %= 3; // 等价于 a = a % 3;

赋值运算符可以简化代码，提高代码的可读性和可维护性。
但在使用时需要注意运算符的优先级的高低。和类型转换等问题。
需要注意的是，赋值运算符的左侧必须是一个变量，右侧可以是一个表达式或一个值。
在使用+=和-	=赋值运算符时，右侧的值可以为负数。
在使用/=赋值运算符时，右侧的值不能为0。

（11）逻辑运算符

在逻辑运算中，"与"、"或"、"非"是三种最基本的逻辑运算，也称为"逻辑与"、"逻辑或"和"逻辑非"。"与"（AND）运算符表示两个条件都为真时，整个表达式才为真，否则为假。在Java、C语言和	Python中，"&&"和"and"运算符都是逻辑与运算符。
"或"（OR）运算符表示两个条件中只要有一个为真时，整个表达式就为真，否则为假。在Java、C	语言和Python中，"||"和"or"运算符都是逻辑或运算符。
"非"（NOT）运算符表示对一个条件取反，即为真的变为假，为假的变为真。在Java、C语言和	Python中，"!"和"not"运算符都是逻辑非运算符。
需要注意的是，逻辑运算符可以用于布尔类型的值或表达式，也可以用于整数或其他类型的值或表达式。在C语言中，对于非布尔类型的值或表达式，0表示假，非0表示真。在Java和Python中，False	表示假，True表示真。

例如，在Java中：

boolean a = true;
boolean b = false;
int c = 5;
int d = 0;
boolean e = (a && b) || (c > d);
System.out.println(e);
// 输出：true

在Java中，逻辑与运算和逻辑或运算都是针对布尔类型的，如果对其他类型进行逻辑运算，Java会将其转换为布尔类型。

在C语言中：

int a = 1;
int b = 0;
int c = 5;
int d = 0;
int e = (a && b) || (c > d);
printf("%d", e);
// 输出：1

在C语言中，逻辑与运算和逻辑或运算同样是针对布尔类型的，如果对其他类型进行逻辑运算，C语言会将其转换为整数类型。

在Python中：

在Python中，"and"和"or"运算符可以用于逻辑与和逻辑或运算

a = True
b = False
c = 5
d = 0
e = (a and b) or (c > d)
print(e)
# 输出：True

在Python中，逻辑与运算和逻辑或运算同样是针对布尔类型的。如果对其他类型进行逻辑运算，Python会将其转换为布尔类型

总之，“与”、“或”、"非"是逻辑运算中的基本运算符，可以用于布尔类型和其他类型的值或表达式。在使用时需要注意数据类型的转换和运算符的优先级等问题。

（12）三目运算符

三目运算符的语法格式如下：其中，条件表达式的值为布尔类型，若其为true，则返回表达式1的值，否则返回表达式2的值。

通用格式：
条件表达式 ? 表达式1 : 表达式2

1. Java和C语言中的三目运算符语法相同，都使用"?“和”:"进行表示。Python中没有三目运算符，但是可以使用类似的表达式实现相同的功能。
2. Java和C语言中的三目运算符可以嵌套使用，但是需要注意嵌套的层数不要过多，以免影响代码的可读性。
   Python中使用if-else语句代替三目运算符，可以嵌套多层if-else语句。
3. Java和C语言中的三目运算符要求条件表达式的类型必须为布尔型，否则会出现编译错误。
   Python中使用if-else语句时，条件表达式可以为任意类型，只要能被转换为布尔型即可。
4. Java和C语言中的三目运算符只能返回一个值，而Python中使用if-else语句可以返回多个值，例如可以使用元组作为返回值。
5. 数据类型转换：Java的三目运算符不支持自动类型转换，因此如果value1和value2的类型不同，需要进行强制类型转换
   Python中的三目运算符支持自动类型转换，能够将不同类型的值自动转换为相同类型再进行比较。

int a = 10;
int b = 12;
int c = (a > b) ? a : b; // 如果a>b，返回a，否则返回b

C语言示例：

int a = 10;
int b = 12;
int c = (a > b) ? a : b; // 如果a>b，返回a，否则返回b

Python示例：

a = 10
b = 12
c = a if a > b else b # 如果a>b，返回a，否则返回b

需要注意的是，三目运算符的优先级较低，请在使用时使用括号来确定运算顺序。

（13）比较运算符：

Java、C语言和Python中的比较运算符在基本语法上是相同的，包括：等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）和小于等于（<=）。但是，在具体使用上还是存在一些异同点的，主要包括以下几点：

1. 数据类型转换：Java、C语言和Python中的比较运算符在处理不同类型的数据时会有不同的处理方式。
   Java中比较运算符可以处理不同类型的数据，但不同类型的数据进行比较时需要进行类型转换。
   C语言中比较运算符可以自动进行类型转换，但是也存在一些隐式类型转换的问题。
   Python中比较运算符同样可以自动进行类型转换，但是在处理字符串时需要注意。
2. 字符串比较：在Java和C语言中，字符串的比较需要通过调用特定的字符串比较函数来实现。例如，
   在Java中，可以使用equals()方法来比较两个字符串是否相等。
   在Python中，可以直接使用等于（==）和不等于（!=）运算符比较字符串，因为Python中字符串也是一种对象。
3. 浮点数比较：在Java和C语言中，由于浮点数是通过近似值来表示的，进行浮点数比较时可能会存在误差。为了避免误差需要使用特定的方法来进行浮点数比较。
   在Python中，可以直接使用等于（==）和不等于（!=）运算符进行浮点数比较，因为Python中的浮点数比较已经考虑了误差问题。

总的来说，Java、C语言和Python中的比较运算符在基本语法上是相同的，但在具体使用上还是存在一些差别的，需要根据具体情况进行选择和使用。
在使用比较运算符时，应该注意数据类型的转换问题、字符串的比较方式以及浮点数比较的误差问题。

（14）运算符优先级比较

Java

C语言

Python语言

常见的术语表达

·在计算机科学中，1970年1月1日午夜零点称为UNIX时间截
·程序设计错误可归纳为三类:语法错误、运行错误和逻辑错误。

algorithm (算法)
assignment operator (=) (赋值运算符)
assignment statement (赋值语句)
backslash (\) (反斜杠)
byte type (字节类型)
casting (类型转换)
char type (字符类型)
constant (常量)
data type (数据类型)
debugger (调试器)
debugging (调试)
declaration(声明)
incremental development and testing (递进式开发和测试)
int type (整数类型)
literal (直接量)
logic error (逻辑错误)
long type (长整型类型)
narrowing (of types) ((类型的)缩窄)
operator (操作符)
overflow (上溢)
pseudocode(伪代码)
primitivedata type(基本数据类型)
runtime error(运行错误)
decrement operator (–) (自减运算符)
short type (短整型类型)
double type (双精度类型)
encoding (编码)
final (final关键字)
float type (浮点类型)
floating-point number (浮点数)
expression(表达式)
syntax error(语法错误)
supplementary Unicode(补充统一码)
underflow (下溢)
Unicode (统一码)
UNIX epoch (UNIX时间戳)
variable (变量)
identifier(标识符)
widening (of types)((类型的) 拓宽)
increment operator (++) (自增运算符)
whitespace(空白符)

四、Java的流程控制语句¹²

流程控制语句是计算机语言中的基本构成部分，使程序能够按照设定的顺序和条件执行指定的操作。流程控制语句的存在帮助程序员实现复杂的逻辑控制，提高程序的可读性和可维护性，同时也提高程序的效率和性能。

从结构化程序设计角度考虑：

顺序结构、选择结构和循环结构。

流程控制语句和结构化程序设计角度看的异同点

从流程控制语句和结构化程序设计的角度来看，它们有以下异同点：

1. 相同点：它们都是用来控制程序的流程和执行顺序的。
2. 不同点：流程控制语句是编程语言提供的语法元素，用于控制程序的执行流程，包括条件语句、循环语句、分支语句等；而结构化程序设计是一种编程规范，提倡使用结构化语句来编写程序，通过模块化、顺序化、分支化等方式来设计程序结构。
3. 不同点：流程控制语句的使用需要符合语法规则，否则程序会出现错误；而结构化程序设计更注重程序的逻辑性和可读性，需要遵循一定的设计原则和规范。
4. 不同点：流程控制语句可以用于任何类型的程序，包括非结构化程序；而结构化程序设计只适用于结构化程序。
5. 不同点：流程控制语句的使用可以使程序的控制流程更加灵活，但可能会导致程序的逻辑难以理解；而结构化程序设计可以提高程序的可读性和可维护性，但可能会降低程序的执行效率。

综上所述：我们可以这样理解:
(1)流程控制是编程语言提供的用于控制程序的执行流程一种方式，包括条件语句、循环语句、分支语句等；
(2) 而结构化程序设计是一种编程方法，提倡使用结构化语句来编写程序，通过模块化、顺序化、分支化等方式来设计程序结构。
(3) 因此，流程控制和结构化程序设计是相互关联的概念，流程控制可以被应用到结构化程序设计中，而结构化程序设计也可以使用流程控制来控制程序的执行流程。

结构化和非结构化：

（1）结构化：顾名思义 ----> 说一不二，有清晰的逻辑和主线

结构化程序设计是一种编程方法，主要包括以下几个方面：
1. 模块化：将程序分解为若干个功能独立的模块，每个模块只负责自己对应的项目，使得程序的结构更加清晰，易于理解和维护。
2. 顺序化：按照执行顺序编写程序，程序的流程更加清晰，易于理解。【一般都不用goto语句跳转】
3. 分支化：使用条件语句（如 if 语句）或循环语句（如 for 语句）来处理程序的分支或循环问题，使得程序的逻辑更加清晰。
4. 抽象化：将程序中的重复部分提取出来，形成可重复使用的函数或子程序，提高程序的可重用性和可维护性。【就是调用库里面的函数，没有就手打】
结构化程序设计的目标是使得程序的结构清晰、易于理解和维护，减少程序中的错误，提高程序的可维护性和可重用性。尤其在大型软件系统的开发中，是必不可少的一种编程方法。

（2) 非结构化:

非结构化程序是指在编写程序时，未严格遵循结构化程序设计的原则和规范，使程序的控制流程变得混乱、难以理解和维护的程序。常常会出现如下情况：
1. 使用了过多的 goto 语句，使得程序的控制流程变得混乱，难以理解和维护【主要原因是如果程序出现问题，这个问题伴随沟通语句的存在结果，必然难以察觉】。
2. 嵌套层数过多的条件判断语句，使得程序的逻辑难以理解。
【if嵌套等等都是嵌套过多就难以理解的，或者说三目运算符的嵌套】
3. 函数或子程序的调用关系复杂，使得程序的控制流程不够清晰。
4. 过多的全局变量或全局函数，使得程序的模块化和可扩展性变得困难。
5.非结构化程序不仅使得程序的可读性和可维护性降低，还可能导致程序出现各种难以发现和修复的错误。
因此，在编写程序时，应该遵循结构化程序设计的原则和规范，合理地组织程序的结构，使得程序的控制流程更加清晰、易于理解和维护。

三大结构：

boolean数据类型：(ture)or(flase)

1 字节 ，用于判断真与假。它通常用于条件语句和循环中，以控制程序的流程
，以及表示比较操作的结果。

boolean isEqual = (a == b);
boolean isLessThan = (a < b);
boolean isGreaterThan = (a > b);

boolean keepLook = true;
while (keepLook) {System.out.println("Looping...");keepLook = false;
}

顺序结构：

只要是在程序中没有给出特别的执行目标，系统则默认自上而下一条一条的执行该程序中的语句，这类程序的结构就称为顺序结构。

我们所以的编程一定会涉及到顺序结构，这是绕不开的一个话题。
就算有分支，有跳转情况，也会直至整个程序生命线结束为止结束【或者说遇到会报错的地方】自上而下的运行程序

分支结构

【1】分支结构与分支语句的关系

总结一句：可以理解为分支结构是编写程序的一种方法，分支语句是实现的方式。

分支结构是一种程序设计的思想或方法，它指导程序员如何组织代码以实现不同的执行路径。
分支语句则是具体实现这种思想的语法结构，它在程序中执行不同的代码块，使程序在不同的条件下产生不同的结果。因此，分支结构和分支语句是密切相关的，分支语句是实现分支结构的具体手段。

【2】常见的分支语句：

在Java中，实现分支结构的方式主要有if语句和switch语句
（其实还有三目运算符的简洁写法也是分支语句中的一种，但因为其是if-else的一种特殊形式，有时会被忽略。）

简单概述
在Java中，实现分支结构的方式主要有以下几种：

1. if语句: if 语句使用布尔表达式或布尔值作为分支条件来判断分支，

if (条件表达式) {// 如果条件成立，执行的代码块
} else {// 如果条件不成立，执行的代码块
}

2. switch语句：switch 语句则用于对多个整型值进行匹配，用于实现分支控制。

switch (条件表达式) {case 值1:// 执行的代码块1break;case 值2:// 执行的代码块2break;...default:// 如果所有的条件都不满足，执行的代码块break;
}

3. 三目运算符

(条件表达式) ? 表达式1 : 表达式2

（1）IF–else结构

if语句

if(判断条件）{执行语句；}
单if语句

if (condition) {// code to execute if condition is true
}

int x = 5;
if (x > 3) {System.out.println("x > 3");
}

条件表达式可以是任何一种逻辑表达式
如果表达式值为true，则执行花括号的内容后；
如果条件判断的结果为false，则if语句内的代码将被跳过。
条件表达式必须用一对圆括号“()”括起来；
即使大括号内只有一条语句，推荐不省略省略大括号（）

多IF语句：

if (condition1) {// code block（语句块）
}if (condition2) {// code block
}if (condition3) {// code block
}

每个if语句都是各自成独立体系。如果满足多个条件，则将执行多个代码块。

if–else 语句：非此即彼

if (x > 5) {System.out.println("x大于5");
} else if (x < 5) {System.out.println("x小于5");
} else {System.out.println("x等于5");
}

if (condition1) {// code block
} else if (condition2) {// code block
} else if (condition3) {// code block
} else {// code block
}

举例：

if (x > 5) {System.out.println("x大于5");
} else if (x < 5) {System.out.println("x小于5");
} else {System.out.println("x等于5");
}

else会匹配最近的if的那条语句判断

嵌套if语句

if (条件1) {if (条件2) {// 如果条件1和条件2都为真，则执行此处的代码} else {// 如果条件1为真但条件2为假，则执行此处的代码}
} else {// 如果条件1为假，则执行此处的代码
}

下面是检查一个数字是否为正数、负数或零。

if (num > 0) {System.out.println("这是一个正数");
} else {if (num < 0) {System.out.println("这是一个负数");} else {System.out.println("这是零");}
}

注意条件的顺序。也应当避免嵌套太多if-else语句。增加代码可读和可维护的信。

（2）Switch-case结构【break和】

switch (expression) {case value1:// code blockbreak;case value2:// code blockbreak;default:// code block
}

注意事项：

（1）表达式会被计算一次并与每个case值进行比较。有匹配项，则执行相应的代码块。每个case值必须是唯一的且与表达式相同类型的常量表达式。

表达式必须是byte、short、int、char、String或枚举类型。

（2）break语句用于在执行代码块后退出switch语句如果在代码块后没有break语句，则代码将继续执行下一个代码块，直到遇到break语句或退出switch语句。
（3）如果没有case与表达式匹配，则执行default语句，且defalut是可有可无的。

嵌套的Switch语句

switch (variable1) {case value1:// do sthswitch (variable2) {case value2: // do sthbreak;case value3: // do sthbreak;default: // do sthbreak;}break;case value4: // do sthbreak;default: // do sthbreak;
}

在同一个 switch 语句中没有两个相同的 case 常量。
外部 switch 语句中的 case 常量可以和内部 switch 语句中的 case 常量相同。

（3）三目运算符：

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

具体参照上面的内容

【3】Switch语句和IF语句的比较

switch语句和if语句都是Java语言中常用的控制流语句

1. 条件类型：if语句的条件可以是任何布尔表达式，而switch语句的条件只能是整型、字符型或枚举类型，String（自Java7开始的）。

String dayOfWeek = "Monday";switch (dayOfWeek) {case "Monday":System.out.println("星期一");break;case "Tuesday":System.out.println("星期二");break;case "Wednesday":System.out.println("星期三");break;case "Thursday":System.out.println("星期四");break;case "Friday":System.out.println("星期五");break;case "Saturday":System.out.println("星期六");break;case "Sunday":System.out.println("星期日");break;default:System.out.println("难不成有星期八？？？");break;
}

2. 分支结构：if语句可以有多个分支，每个分支可以有多个条件，可以根据条件的不同执行不同的语句。而switch语句只有一个条件，可以有多个分支，每个分支只能有一个常量或常量表达式，可以根据条件的不同执行不同的语句。
3. 执行效率：一般情况下，switch语句的执行效率比if语句高，因为switch语句会先计算出条件值，然后根据条件值来匹配分支，而if语句需要逐个计算每个条件，直到匹配到满足条件的分支。
4. 可读性：if语句可以根据需要添加注释和空格等来提高可读性，switch语句由于其结构比较固定，可读性相对较差。
5. 使用场景：if语句适合处理复杂的条件判断，例如判断多个条件的组合、判断范围等。而switch语句适合处理单一条件的多分支情况，例如根据用户输入的命令执行不同的操作。

【4】有无语义直通：

注意 ->不要和：混用

  case '1' ->

循环结构

循环三要素
初始化部分：设置初始条件，一般只执行一次
终止部分：设置终止条件，它应该是一个布尔表达式，每次循环都要求值一次，用以判断是否满足终止条件
循环体部分：被反复执行的语句块

【1】循环结构与循环语句的关系

同样的总结一句：循环结构是编写程序的一种方法，循环语句是实现的方式。

【2】常见的循环语句

在Java语言中，实现循环结构有for循环，while循环，do-while循环。
【foreach循环语句是 for 语句的简化版】

（1）while循环：“当型”循环【特点：先判断，再执行】。

while(条件表达式) {执行语句;
}

int i = 0;
while (i < 10) {System.out.println(i);i++;
}

（2）do-while循环：“直型”循环【特点：先执行，再判断】。

do {语句块;
}while(条件表达式);//此处有分号

int i = 0;
do {System.out.println(i);i++;
} while (i < 10);

（3）while和do-while的关系

它们之间的主要区别在于先执行or先判断

while循环
while循环是一种前测试循环。如果条件为真，则执行循环体，并再次检查条件。这个过程会一直持续，直到条件变为假，此时循环终止。
do-while循环
do-while循环是一种后测试循环，这意味着在执行循环体之后检查条件。这保证了循环体至少会被执行一次，即使条件为假。

（4）for循环：

for(条件表达式1;条件表达式2;条件表达式3) {语句块;
}

初始化语句（在本例中为int i = 0）仅在循环开始时执行一次。
条件语句（在本例中为i < 10）在每次循环迭代之前进行评估。如果为false，则循环将退出。
更新语句（在本例中为i++）在每次循环迭代之后执行。
花括号{}用于分组将在循环内执行的代码。

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {System.out.println(numbers[i]);
}

使用for循环时的一些其他注意事项：
要确保条件语句最终将评估为false，以避免创建无限循环。
如果满足某个条件，可以使用break语句提前退出循环。
如果满足某个条件，可以使用continue语句跳过某个循环迭代。

for嵌套

	九九乘法表

for (int i = 1; i <= 9; i++) {// 内层循环for (int j = 1; j <= i; j++) {System.out.print(j + "*" + i + "=" + j * i + "\t");}System.out.println();

（5）foreach语句：

foreach 循环语句是 for 语句的特殊简化版本，主要用于执行遍历功能的循环。

for(类型 变量名:集合) {语句块;
}

String[] fruits = {"apple", "banana", "orange"};for (String fruit : fruits) {System.out.println(fruit);
}

（6）注意事项

for 和 while 的区别:
for循环中，控制循环的变量，因为归属for循环的语法结构中在for循环结束后，就不能再次被访问到了while循环中，控制循环的变量。
对于while循环来说不归属其语法结构中，在while循环结束后，该变量还可以继续使用

跳转语句

【1】break语句

（1）作用：
①终止switch语句与单循环语句的执行；
②对多重循环循环语句，可从内循环体跳到外循环体。
（2）格式：break;

【2】continue语句

（1）作用：
①在while或do while语句中执行到continue语句时，程序不执行continue后的语句，而转向条件表达式处，开始下一次循环。即所谓短路语句。
②在for语句中执行到continue语句时，程序不执行continue后的语句，而转向for语句中的第3表达式处，开始下一次循环。
（2）格式：continue;

Java语言中的break和continue的区别？

Java中break和continue的主要区别在于：
break语句用于跳出循环或switch语句（当满足某个条件时，提前跳出循环，避免执行多余的语句。）（当嵌套循环时，break语句可以跳出当前循环以及外层循环）；
而continue语句用于结束本次循环，进入下一次循环（当满足某个条件时，跳过本次循环中剩余的语句）（当嵌套循环时，而continue语句只能跳出当前循环。）。

当在循环或switch语句中遇到break时，程序将退出循环或switch语句，并继续执行其后的代码。

for (int i = 0; i < 10; i++) {if (i == 5) {break;}System.out.println(i);
}

当i等于5时，循环将终止，并且程序将继续执行循环后的任何代码。

另一方面，当在循环中遇到continue时，将跳过当前循环并继续执行下一次循环。

for (int i = 0; i < 10; i++) {if (i == 5) {continue;}System.out.println(i);
}

当i等于5时，将执行continue语句，并且循环将跳过当前迭代而不执行System.out.println(i)语句。

Java选择结构和循环结构

break：表示跳出当前层循环
continue：表示跳出本次循环，进入下一次循环
return：跳出当前方法的循环

五、牢记项目

project(项目)
module (模块)
package (包)
class (类)

---

1. 集成环境
   把代码编写，编译，执行，调试等多种功能综合到一起的开发工具 ↩︎

2. 常见的计算机的信息编码:
   (1)ASCII–美国信息互换标准代码(是现今最通用的单字节编码系统)。
   (2)GB2312–信息交换用汉字编码字符集·基本集(1981年5月1日实施，是中国国家标准的简体中文字符集)
   (3)GBK–扩展了繁体中文字的支持。
   【回归本条注脚在本文的来源：基本数据类型–字符型–char】 ↩︎

3. 解释为什么说Unicode编码是不会乱码的原因:
   如果是在C语言中的情况就是假定char ch='我'这样的中文字符就一定会报错，是因为C语言采用的是Ascll编码。同样的如果是在Java这类用Unicode 统一码编码的语言体系中char ch='我'是能够输出且不会报错的，这也是为什么能够被叫做万国码的原因。
   【回归本条注脚在本文的来源：基本数据类型–字符型–char】 ↩︎

4. 什么是引用类型：
   在Java中类型可分为两大类：值类型与引用类型。值类型就是基本数据类型（如int ,double float等），而引用类型,是指除了基本的变量类型之外的所有类型（如通过 class 定义的类型）。引用类型包括数组、类实例和接口实例。
   从某种意义上来说，引用类型变量就是一个指针，只是 Java 语言里不再使用指针这个说法。【它们本身是不存储值，而是指向内存中的某个对象。与其他类型相比，引用类型占用的内存较小，因为它们只存储对象的地址，而不是对象本身。】
   【回归本条注脚在本文的来源：基本数据类型–字符型–字符串类型】 ↩︎

5. 什么是整型溢出：
   整型溢出是指当一个整数的值超出了其数据类型所能表示的范围时发生的情况。在Java中，当一个整数的值超出了其数据类型的范围时，它会发生溢出并且结果可能是不可预测的。(大部分还是重新记数的）
   也就是说，不超出内定范围是好的。超出就看给的数据里面有多少个数据类型范围的个数减去，从最低端开始算。如byte（1字节_-128-127）我们给定一个数字是129这个一定是超过了127的且含有1个255【切记是有255种的数字，不是能够记到数字255】。超过了右值127有2位，所以就是-127了
   【回归本条注脚在本文的来源：基本数据类型–数值型-byte(整型溢出知识点)】 ↩︎

6. 什么是溢出和下溢：
   （1）Overflow是指操作的结果大于数据类型可以表示的最大值。在int的情况下，这意味着一个大于2,147,483,647的值。当发生溢出时，结果“环绕”到数据类型可以表示的最小值，即-2,147,483,648。
   （2）Underflow是指操作的结果小于数据类型可以表示的最小值。在int的情况下，这意味着一个小于-2,147,483,648的值。当发生下溢时，结果“环绕”到数据类型可以表示的最大值，即2,147,483,647。
   ~~【第一个回车回归本条注脚在本文的来源：基本数据类型–数值型–byte】~
   ~~【第二个回车回归本条注脚在本文的来源：基本数据类型–数值型–int】~ ↩︎ ↩︎

7. 什么是类型转换：
   整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算>
   (1)什么是自动类型转换 (byte,short,char)—> int —> long—> float —> double > 1. 不能对boolean类型进行类型转换> 2. 不能把对象类型转换成不相关类的对象。> 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。> 4. 转换过程中可能导致溢出或损失精度。> 5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入
   （2）强制类型转换：(type)value type
   （3）隐含强制类型转换：Java默认是int
   【回归本条注脚在本文的来源：基本数据类型–数值型–浮点数–double 】 ↩︎

8. 运算符用于执行程序代码运算，会针对一个以上操作数项目来进行运算。
   【回归本条注脚在本文的来源：运算符】 ↩︎

9. Java中的ArithmeticException异常是什么:
   (Exception)又称为例外,是一个在程序执行期间发生的事件,它中断正在执行程序的正常指令流ArithmeticException是出现异常的运算条件时，抛出此异常。 ↩︎

10. TypeError 也是一种经常出现的异常。当操作或函数应用于不适当类型的对象时引发，一个常见的例子是对整数和字符串做加法。 ↩︎

11. 什么是左值和右值
    以赋值符号 = 为界，= 左边的就是左值，= 右边就是右值。 L-value 的 L, 理解成 Location，表示定位，地址。将 R-value 的 R 理解成 Read，表示读取数据。变量名编译之后，会映射成内存地址。看看a = b的含义。其实就是 将 “b地址内存里面的数据”，放到"a地址内存"中。 ↩︎

12. 流程控制语句可以分为条件语句、循环语句和跳转语句等，通过这些语句提高程序的效率和性能。 ↩︎

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！