一、数据类型（基本数据类型和引用数据类型）

（一）基本数据类型

基本类型	占用内存（字节）	默认值	表明范围	封装类
byte	1	(byte)0	-128 (-2^7) ~127 (2^7-1)	Byte
short	2	(short)0	-32768 (-2^15) ~32767 (2^15-1)	Short
int	4	0	-2147483648 (-2^31) ~2147483647 (2^31-1)	Integer
long	8	0L	-9223372036854775808 (-2^63) ~9223372036854775807 (2^63-1)	Long
float	4	0.0f	IEEE 754标准的单精度浮点数	Float
double	8	0.0d	IEEE 754 标准的双精度浮点数	Double
boolean	1 or 4	false	u0000 (0) ~ uffff (65535)	Booble
char	2	u0000(null)	true / false	Character

注：

1. int是基本数据类型，Integer是int的封装类，是引用类型。int默认值是0，而Integer默认值 是null，所以Integer能区分出0和null的情况。一旦java看到null，就知道这个引用还没有指向某个 对象，在任何引用使用前，必须为其指定一个对象，否则会报错。
2. 基本数据类型在声明时系统会自动给它分配空间，而引用类型声明时只是分配了引用空间， 必须通过实例化开辟数据空间之后才可以赋值。数组对象也是一个引用对象，将一个数组赋值给另 一个数组时只是复制了一个引用，所以通过某一个数组所做的修改在另一个数组中也看的见。
3. 虽然定义了boolean这种数据类型，但是只对它提供了超级有限的支持。在Java虚拟机中没有任何boolean值专用的字节码指令，Java语言表达式所操作的boolean值，在编译之后都使用Java虚拟机中的int数据类型来取代，而boolean数组将会被编码成Java虚拟机的byte数组，每个元素boolean元素占8位。这样我们可以得出boolean类型占了单独使用是4个字节，在数组中又是1个字节。 使用int的缘由是，对于当下32位的处理器（CPU）来说，一次处理数据是32位（这里不是指的是32/64位系统，而是指CPU硬件层面），具有高效存取的特点。

1. 基本类型间的转换

存储范围小的类型到存储范围大的类型： 自动转换
byte → short(char) → int → long → float → double

从存储范围大的类型到存储范围小的类型（使用强转，可能会损失精度）
double → float → long → int → short(char) → byte

（二） 引用数据类型

下面我们以String类型来进行解释

1. String 特性

(1)String类是final修饰的，不可以被继承。
(2)String类的底层是基于char数组的。
(3)String类被设计成不可变（immutable）类，所以它的所有对象都是不可变对象，线程安全，不会有并发问题

2. 第一，必须明确的一个概念是String不是基本的数据类型！！！

• String实则是个类，因此它属于引用数据类型；
• 基本数据类型的存储原理是:基本数据类型都是直接存储在内存中的内存栈上的,数据本身的值就是存储在栈空间的；
• 所有引用类型继承于Object类(也是引用类型),都是按照Java里面存储对象的内存模型来进行数据存储的,使用Java内存堆和内存栈来进行这种类型的数据存储；
• 引用是存储在内存栈上的,而对象本身是存储在内存堆上的；
• 8种基本类型在Java中都有对应的封装类型,也就是引用类型： 整数类型：Byte, Short, Integer, Long 浮点类型：Float, Double 字符型：Character 布尔类型：Boolean
• Java的引用类型有五种:类,接口,枚举,注解,数组；
• 引用类型的底层结构和基本类型的差别比较大,主要在创建对象上有所不同；
• 引用类型的数据创建对象时需要通过new创建对象,创建的对象会保存在堆中,然后将该对象赋值给一个引用,也就是这个引用将会指向对象堆中的地址,而这个引用则存储在栈中；
• String类型也可以不用new来创建,会在常量池中创建对象.String是一个比较特殊的类.

//String常见的方法
 
//1.String的构造方法
String(String original)                 //把字符串数据封装成字符串对象
String(char[] value)                    // 把字符数组的数据封装成字符串对象
String(char[] value,int index,int count)//把字符数组中的一部分数据封装成字符串对象,
//2.String类的获取功能
length()                                //获取字符串的长度,实则也就是个字符个数
charAt(int index)                       //获取指定索引处的字符
indexOf(String str)                    //获取str字串对象中第一次出现的索引
 
substring(int start)                    //从start开始截取字符串
 
String substring(int start, int end)    //从start开始,到end结束截取字符串,包括start,不包括end
//3.String判断功能
equals(Object obj)                     //比较字符串的内容是否一样
equalsIgnoreCase(String anotherString) //比较字符串的内容是否一样,忽略大小写
startsWith(String prefix)              //判断字符串对象是否以指定的字符开头(区分大小写)
endWith(String str):                   //判断字符串对象是否以指定的字符结尾
isEmpty()                              //判断字符串是否为空
 
//String类中的转化方法:
toCharArray()                           //把字符串转换为字符数组.
toLowerCase()                           //把字符串转换为小写字符串
toUpperCase()                           //把字符串转换为大写字符串
 
常用方法:
trim()去除字符串两端的空格
split()去除字符串中指定的字符,然后返回一个新的字符串
subSequence(int beginindex,int endIndex)截取字符串中指定位置的字符组成一个新的字符串
 
replace(char oldChar,char newChar)将指定字符替换成另一个指定的字符
replaceAll(String regex,String replasement):用新的内容替换全部旧的内容
lastIndexOf(String str)返回指定字符出现的最后一次下标
contains()查看字符串中是否包含指定的字符

（三）基本数据类型和引用数据类型的区别和联系：

1. 从概念方面来说

• 基本数据类型:变量名指向具体的数值
• 引用数据类型:变量名指向存数据对象的内存地址,即变量名指向hash值

2. 从内存构建方面来说

基本数据类型:变量在声明之后java就会立刻分配给他内存空间
int a; //声明变量a的同时，系统给a分配了空间  
a=12;
引用数据类型:它以特殊的方式(类似C指针)指向对象实体（具体的值），这类变量声明时不会分配内存，只是存储了一个内存地址。
MyDate today;  
today.day = 14; //错误！由于today对象的数据空间未分配
MyDate today;  
today = new Date(); //正确的方式

3. 从赋值方面来说

• 基本数据类型:使用时需要赋具体值,b = a；是把a的值传给b，存在b的内存空间内。该判断时使用“==”号
• 引用数据类型:使用时可以赋null,判断时使用equals方法，b = a；是把a的数据的地址传给b，即a和 b都存储的是一个地址，这个地址指向实际的数据。（与C++中的指针类似）

二、变量和常量以及标识符

在Java编程中，变量和常量是管理和存储数据的基本单元。理解它们的用法和区别是掌握Java语言的基础。j接下来我们将讨论Java中的变量和常量，讨论它们的定义、使用、以及它们在程序中的作用。

（一）变量

变量是一个存储数据的容器，在程序执行过程中可以改变其存储的值。变量必须在使用之前进行声明。变量的声明包括指定变量的类型和名称。

1. 变量的声明与初始化

在Java中，声明一个变量的基本语法如下：

数据类型 变量名;

例如：

int number;

这行代码声明了一个名为number的变量，其数据类型为int。声明之后，变量可以被赋值：

number = 10;

可以在声明的同时进行初始化：

int number = 10;

可以在一行代码中同时声明多个一样数据类型的变量，变量和变量之间使用逗号间隔。

int a = 100, b = 200, c = 300

Java 是强类型编程语言，要求所有的数据都要有明确的数据类型，以便于程序在运行过程中为这些数据被分配合适的内存空间。
举一个简单的例子，不同的数据类型就好比是不同大小的纸箱，装苹果和装西瓜所使用的箱子的大小是不一样的。

2. 变量的作用域

变量的作用域决定了变量的可访问性。Java中变量的作用域一般有以下几种：

• 局部变量：在方法、构造函数或块内部声明，只在其所在的代码块内可访问。
• 实例变量：在类中声明，不在任何方法内，没有static修饰符，属于类的每个对象。
• 类变量：用static修饰，在类中声明，所有对象共享同一个静态变量。

3. 示例

以下是一个简单的示例，展示了变量的声明、初始化和使用：

public class VariableExample {
    public static void main(String[] args) {
        // 局部变量
        int a = 5;
        double b = 3.2;
        char c = 'A';

        // 输出变量的值
        System.out.println("整数变量 a 的值: " + a);
        System.out.println("浮点变量 b 的值: " + b);
        System.out.println("字符变量 c 的值: " + c);
    }
}

（二）常量

常量是其值在程序执行期间不会改变的变量。Java中使用final关键字来定义常量。一旦初始化，常量的值就不能被修改。

下图是Java常见的关键字，这些关键字之后会逐个学习

1. 定义常量

常量的定义形式如下：

final 数据类型 常量名 = 值;

例如：

final int MAX_USERS = 100;

常量一般使用大写字母表明，以便于与变量区分。

2. 常量的优点

• 可读性：常量名一般能清晰地描述它所代表的意义，提升代码可读性。
• 可维护性：如果需要更改常量的值，只需在定义处修改一次即可。

3. 示例

以下示例展示了如何使用常量：

public class ConstantExample {
    public static void main(String[] args) {
        final double PI = 3.14159; // 定义圆周率常量
        double radius = 5.0;
        double area = PI * radius * radius; // 使用常量计算圆的面积

        System.out.println("圆的面积: " + area);
    }
}

（三）

1. 标识符的概述

标识符，就是我们给类、方法或变量起的名字。

2. 标识符的命名规则

• 可以由大小写字母、数字、_（下划线）、 $（美元符号）组成
• 不能以数字开头
• 不能使用 Java 中的关键字
• 严格区分大小写
  正例：HelloWorld、number、n1
  反例：n∗、0number、class

3. 标识符的命名规范

严格意义上讲，我们的标识符只要符合命名规则，随意起什么名都可以，Java 在语法上并没有对我们做过多的限制。

但是，要想写出可读性好并且易于维护的代码就必须要有一些命名的规范。否则每个人会都按照自己的想法随意命名，这对于团队开发来说是灾难性的。

小驼峰命名法：

第一个单词的首字母小写，其他单词的首字母大写。（给方法和变量命名）
举例：number、maxValue

大驼峰命名法:

所有单词的首字母都大写，其他字母小写。（给类命名）
举例： Student、HelloWorld

三、运算符（算术、赋值、自增自减、关系、逻辑、三元、位运算符等）

（一）运算符和表达式的概述：

运算符，对字面量或变量进行操作的符号叫做运算符。
表达式，使用运算符连接起来的式子叫做表达式。

运算符是编程语言中的基本元素，它们用于在表达式中操作数据。Java中提供了多种类型的运算符，以满足不同的编程需求。以下将详细介绍Java中的各种运算符，包括算术运算符、赋值运算符、自增自减运算符、关系运算符、逻辑运算符、三元运算符和位运算符。

（二）算术运算符

算术运算符用于对数值进行基本的算术操作。Java支持以下算术运算符：

运算符	描述	示例	结果
+	加法	5 + 3	8
–	减法	5 – 3	2
*	乘法	5 * 3	15
/	除法	5 / 2	2
%	取模（余数）	5 % 2	1

需要注意的是，除法运算符/在整数除法时会舍弃小数部分，返回整数结果。

（三）赋值运算符

赋值运算符用于将右侧表达式的值赋给左侧的变量。最常用的赋值运算符是=，除此之外还有复合赋值运算符：

运算符	描述	示例	结果
=	赋值	a = 5	a为5
+=	加后赋值	a += 3	a为8
-=	减后赋值	a -= 2	a为6
*=	乘后赋值	a *= 2	a为12
/=	除后赋值	a /= 3	a为4
%=	取模后赋值	a %= 3	a为1

（四）自增自减运算符

自增和自减运算符用于增加或减少变量的值。Java提供了前缀和后缀两种形式的自增（++）和自减（–）运算符：

运算符	描述	示例	结果
++a	前缀自增	a = 5; ++a;	a为6
a++	后缀自增	a = 5; a++;	a为6
–a	前缀自减	a = 5; –a;	a为4
a–	后缀自减	a = 5; a–;	a为4

前缀形式在增加或减少变量值后立即返回新的变量值，而后缀形式则在返回变量原值后再进行增加或减少。

（五）关系运算符

关系运算符用于比较两个操作数，并返回布尔值（true或false）。常用的关系运算符包括：

运算符	描述	示例	结果
==	等于	5 == 3	false
!=	不等于	5 != 3	true
>	大于	5 > 3	true
<	小于	5 < 3	false
>=	大于或等于	5 >= 3	true
<=	小于或等于	5 <= 3	false

（六）逻辑运算符

逻辑运算符用于连接多个布尔表达式。它们的结果也是布尔值：

1. 基本逻辑运算符

2. 短路逻辑运算符

基本逻辑运算符中的逻辑与（&）和逻辑或（|）必须执行表达式中的所有判断，但这实则是不必要的。
举例:

int x = 100;     
int y = 200;     
x > 300 & y < 300 // 在运算左边的判断时结果是 false，实则最终的结果已经确定，右边的判断执行了没有意义！ 

要提升逻辑判断的执行效率，可以使用 Java 提供的短路逻辑运算符。

（七）三元运算符

三元运算符（条件运算符）是Java中唯一的三元运算符，用于简化if-else结构。其语法形式为：

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

当条件表达式为true时，返回表达式1的值，否则返回表达式2的值。

示例：

int a = 5;
int b = 3;
int max = (a > b) ? a : b; // max为5

（八）位运算符

位运算符用于对整数类型的位进行操作。常用的位运算符有：

运算符	描述	示例	结果
&	按位与	5 & 3	1
I	按位或	5 I 6	7
^	按位异或	5 ^ 3	6
~	按位非	~5	-6
<<	左移	5 << 1	10
>>	右移	5 >> 1	2
>>>	无符号右移	5 >>> 1	2

位运算符用于更底层的操作，如与（&）、或（|）、异或（^）、非（~）以及位移操作（<<、>>、>>>）。

（九）总结

运算符在Java编程中起着至关重大的作用，它们是构建表达式和控制程序逻辑的基础。熟练掌握各种运算符的用法，可以协助开发者编写高效且易于维护的代码。通过结合不同类型的运算符，开发者能够创建复杂的逻辑和算法，以实现各种功能需求。

四、控制流语句（条件语句、循环语句、分支语句）

在编程中，控制流语句用于控制程序的执行流程。它们决定了程序如何选择执行不同的代码块，以及如何在满足某些条件时重复执行代码。Java提供了强劲的控制流语句，包括条件语句、循环语句和分支语句。本文将详细介绍这些控制流语句的用法。

（一）条件语句

条件语句用于根据特定条件的真假来决定是否执行某个代码块。在Java中，主要的条件语句有if、if-else和switch。

1. if语句

if语句用于在条件为true时执行特定代码块。

int number = 10;
if (number > 5) {
    System.out.println("Number is greater than 5");
}

2. if-else语句

if-else语句用于在条件为false时执行另一个代码块。

int number = 3;
if (number > 5) {
    System.out.println("Number is greater than 5");
} else {
    System.out.println("Number is less than or equal to 5");
}

3. if-else if-else语句

if-else if-else语句用于测试多个条件。

int number = 7;
if (number > 10) {
    System.out.println("Number is greater than 10");
} else if (number > 5) {
    System.out.println("Number is greater than 5 but less than or equal to 10");
} else {
    System.out.println("Number is 5 or less");
}

4. switch语句

switch语句用于根据某个表达式的值执行相应的代码块。适用于处理固定值的条件判断。

int day = 2;
switch (day) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    case 3:
        System.out.println("Wednesday");
        break;
    default:
        System.out.println("Invalid day");
        break;
}

（二）循环语句

循环语句用于重复执行某个代码块。Java中提供了for、while和do-while循环。

1. for循环

for循环用于在知道循环执行次数时使用。

for (int i = 0; i < 5; i++) {
    System.out.println("Iteration: " + i);
}

2. while循环

while循环在条件为true时反复执行代码块，适合用于条件控制的循环。

int i = 0;
while (i < 5) {
    System.out.println("Iteration: " + i);
    i++;
}

3. do-while循环

do-while循环先执行代码块，然后测试条件表达式。即使条件为false，代码块至少执行一次。

int i = 0;
do {
    System.out.println("Iteration: " + i);
    i++;
} while (i < 5);

（三）分支语句

分支语句用于在循环中改变控制流。Java中常用的分支语句包括break、continue和return。

1. break语句

break语句用于终止循环或switch语句，并跳出到下一个代码块。

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 终止循环
    }
    System.out.println("Iteration: " + i);
}

2. continue语句

continue语句用于跳过当前迭代的剩余代码，直接进入下一次循环迭代。

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue; // 跳过偶数
    }
    System.out.println("Iteration: " + i);
}

3. return语句

return语句用于从方法中返回结果，并结束方法执行。

public int add(int a, int b) {
    return a + b; // 返回结果并结束方法
}

（四）总结

控制流语句是编程语言中的关键部分，能够协助开发者控制程序执行的顺序和逻辑。通过使用条件语句、循环语句和分支语句，可以编写出更灵活和强劲的程序，来实现复杂的功能需求。掌握这些控制流语句，是编写高效Java代码的基础。