基本数据类型与引用数据类型的区分
-
存储内容：
- 基本数据类型：直接存储实际的数据值，如整数、浮点数、字符等。
- 引用数据类型：存储对象的引用（内存地址），而不是对象本身。
-
内存分配：
- 基本数据类型：存储在栈（Stack）内存中。
- 引用数据类型：对象存储在堆（Heap）内存中，而引用变量存储在栈内存中。
-
默认值：
- 基本数据类型：每种类型都有默认值（例如，int的默认值是0，boolean的默认值是false）。
- 引用数据类型：默认值是null，表示没有引用任何对象。
-
内存管理：
- 基本数据类型：由程序直接管理，创建和销毁速度较快。
- 引用数据类型：由垃圾回收器（Garbage Collector, GC）管理，自动回收不再使用的对象。
-
性能：
- 基本数据类型：访问速度通常比引用类型快，因为它们存储在栈上，且操作更简单。
- 引用数据类型：访问速度可能较慢，因为需要通过引用间接访问数据。
-
类型转换：
- 基本数据类型：可以自动转换（如从int到long）或需要显式转换（如从float到int）。
- 引用数据类型：需要通过强制类型转换（casting）来转换对象的类型。
-
垃圾回收：
- 基本数据类型：不会被垃圾回收，因为它们不是对象。
- 引用数据类型：可以被垃圾回收，当没有引用指向它们时。
-
封装：
- 基本数据类型：虽然Java为每个基本数据类型提供了封装类（如Integer、Double等），但基本类型本身不是对象。
- 引用数据类型：是对象，可以使用所有面向对象的特性，如继承、封装和多态。
-
操作：
- 基本数据类型：可以直接进行操作，不需要通过方法调用。
- 引用数据类型：通常需要通过方法调用来操作对象的状态或行为。
基本数据类型：
- 基本数据类型是Java语言预定义的，它们代表了最基本的数据单元。
- 包括以下几种：
boolean：逻辑类型，只有两个可能的值：true和false。byte：8位有符号整数，取值范围从 -128 到 127。short：16位有符号整数，取值范围从 -32,768 到 32,767。int：32位有符号整数，默认的基本整数类型，取值范围从 -2^31 到 2^31-1。long：64位有符号整数，取值范围从 -2^63 到 2^63-1。在数值后加上L或l来表示。float：32位单精度浮点数。在数值后加上F或f来表示。double：64位双精度浮点数，是默认的浮点数类型。char：16位Unicode字符，可以存储任何字符。
基本数据类型直接存储它们的值，当变量被声明为基本数据类型时，它们直接在栈上分配内存。
引用数据类型：
- 引用数据类型指向内存中的一个对象，它们是通过引用变量来访问的。
- 包括以下几种：
- 类（Class）：用户自定义的类，如
String、Integer等。 - 数组（Array）：一种容器对象，可以包含多个元素。
- 接口（Interface）：定义了类必须实现的方法的集合。
- 枚举（Enum）：固定数量的常量集合。
- 类（Class）：用户自定义的类，如
引用数据类型在Java堆上分配内存，而引用变量（在栈上）存储的是对象在堆上的内存地址。
数据的声明、定义与使用
数据声明（Declaration）
数据声明是指告诉编译器变量的类型和名称。在Java中，变量的声明必须指定其数据类型，并在程序的某个作用域内进行。
基本语法：
数据类型 变量名;
例如：
int age; // 声明一个整数变量 age
String name; // 声明一个字符串变量 name
数据定义（Definition）
数据定义通常与声明一起发生，意味着在声明变量的同时赋予其一个初始值。
基本语法：
数据类型 变量名 = 初始值;
例如：
int age = 25; // 声明并定义一个整数变量 age 并初始化为 25
String name = "John Doe"; // 声明并定义一个字符串变量 name 并初始化为 "John Doe"
数据使用（Usage）
数据使用是指在程序中访问和操作变量。
示例：
age = 30; // 使用变量 age，为其赋新值 30
System.out.println(name); // 使用变量 name，将其值输出到控制台
类型转换（Type Casting）
在Java中，你可能需要在不同的数值类型之间进行转换。这可以分为自动类型转换（小范围类型到大范围类型）和强制类型转换（大范围类型到小范围类型）。
自动类型转换示例：
int i = 100;
long l = i; // 自动转换 int 到 long
强制类型转换示例：
double d = 3.14159;
int i = (int) d; // 强制转换 double 到 int，可能会有精度损失
变量的作用域（Scope）
变量的作用域是指变量可以被访问的代码区域。在Java中，变量可以有以下几种作用域：
- 局部变量：在方法、构造方法或代码块中定义，只在这些区域内可见。
- 实例变量：在类中且不在任何方法内定义，属于对象，随对象的创建而存在。
- 类变量：用
static关键字声明，在类中定义，不属于任何实例，由类的所有实例共享。
变量的生命周期（Lifetime）
变量的生命周期是指变量在程序执行期间存在的时间。局部变量的生命周期仅限于声明它们的方法或代码块。实例变量和类变量的生命周期与对象或类的加载和卸载相关。
访问控制（Access Control）
Java中的访问控制修饰符决定了类、方法和变量的可见性。主要有public、protected、private和包访问级别（无修饰符）。
经典运算符的使用
算术运算符
+加法：int sum = a + b;-减法：int difference = a - b;*乘法：int product = a * b;/除法：double quotient = a / b;%求余：int remainder = a % b;
自增/自减运算符
++自增：int x = 5; x++;（x变为6）--自减：int y = 5; y--;（y变为4）
关系运算符
==等于：if (a == b) {...}!=不等于：if (a != b) {...}>大于：if (a > b) {...}<小于：if (a < b) {...}>=大于等于：if (a >= b) {...}<=小于等于：if (a <= b) {...}
逻辑运算符
&&逻辑与：boolean flag = (a > 0) && (b < 10);||逻辑或：boolean flag = (a > 0) || (b < 10);!逻辑非：boolean flag = !condition;
位运算符
&按位与：int result = a & b;|按位或：int result = a | b;^按位异或：int result = a ^ b;~按位取反：int result = ~a;<<左移：int result = a << n;>>右移（有符号）：int result = a >> n;>>>右移（无符号）：int result = a >>> n;
赋值运算符
=简单赋值：int x = 5;+=加后赋值：int x = 5; x += 3;（等价于x = x + 3;）-=减后赋值：int x = 5; x -= 3;*=乘后赋值：int x = 5; x *= 2;/=除后赋值：double x = 10; x /= 2;%=求余后赋值：int x = 10; x %= 3;
条件运算符（三元运算符）
? :条件表达式：int max = (a > b) ? a : b;
实例代码
public class OperatorsExample {
public static void main(String[] args) {
int a = 10, b = 20;
int sum = a + b; // 加法
int difference = a - b; // 减法
double quotient = (double) a / b; // 强制类型转换以进行浮点除法
int remainder = a % b; // 求余
boolean isEqual = (a == b); // 比较是否相等
boolean isNotEqual = (a != b); // 比较是否不等
boolean isGreater = (a > b); // a是否大于b
boolean isLess = (a < b); // a是否小于b
int bitwiseAnd = a & b; // 按位与
int bitwiseOr = a | b; // 按位或
int bitwiseXor = a ^ b; // 按位异或
int bitwiseComplement = ~a; // 按位取反
int leftShifted = a << 2; // 左移两位
int rightShifted = b >> 2; // 右移两位（有符号）
int unsignedRightShifted = b >>> 2; // 右移两位（无符号）
int result = a + b; // 赋值运算符
a += 5; // a = a + 5
boolean condition = (a < 10) ? true : false; // 三元运算符
}
}
在Java中，位运算符和逻辑运算符都是用来对数据进行操作的运算符，但它们的作用和应用场景有所不同。
位运算符、逻辑运算符的区别与应用
位运算符
位运算符直接对操作数的二进制位进行操作。Java中支持的位运算符包括：
- 按位与
&：两个操作数中相对应位都为1时，结果位才为1。 - 按位或
|：两个操作数中相对应位至少有一个为1时，结果位就为1。 - 按位异或
^：两个操作数中相对应位不同则结果位为1，都相同则结果位为0。 - 按位取反
~：翻转操作数的每一位，即把1变成0，把0变成1。 - 左移
<<：将操作数的各个位向左移动指定位数，右边空出的位填充0。 - 右移
>>：将操作数的各个位向右移动指定位数，左边空出的位用符号位填充（正数填充0，负数填充1）。 - 无符号右移
>>>：将操作数的各个位向右移动指定位数，左边空出的位无论原数值的符号如何都填充0。
位运算符通常用于底层系统编程、性能优化、加密算法等场景。
逻辑运算符
逻辑运算符用于处理布尔逻辑值（true或false），Java中支持的逻辑运算符包括：
- 逻辑与
&&：两个操作数都为true时，结果才为true。 - 逻辑或
||：两个操作数中至少有一个为true时，结果就为true。 - 逻辑非
!：反转操作数的布尔值，true变成false，false变成true。
逻辑运算符常用于控制程序的流程，如条件判断和循环。
区别与应用示例
-
位运算符示例：
int a = 0b1101; // 二进制表示的13 int b = 0b1011; // 二进制表示的11 int andResult = a & b; // 按位与，结果为0b1001，即9 int orResult = a | b; // 按位或，结果为0b1111，即15 int xorResult = a ^ b; // 按位异或，结果为0b0110，即6 int leftShiftResult = a << 2; // 左移两位，结果为0b110100，即52 int rightShiftResult = a >> 1; // 右移一位，结果为0b01110，即6 int unsignedRightShiftResult = a >>> 1; // 无符号右移一位，结果为0b01110，即6 -
逻辑运算符示例：
boolean condition1 = true; boolean condition2 = false; boolean andResult = condition1 && condition2; // 结果为false boolean orResult = condition1 || condition2; // 结果为true boolean notResult = !condition1; // 结果为false
位运算符和逻辑运算符虽然都可以用于处理布尔逻辑，但位运算符是按位进行操作，而逻辑运算符是对整个布尔值进行操作。
变量
在Java中等号=叫做赋值运算符,和数学中的等于号不同(这一点非常重要)。Java中的=表示将等号右边的值赋值给左边的变量。
变量赋值也叫做变量初始化。变量在使用之前必须赋值,没有赋值的变量是不能使用的,否则会报错(变量未初始化):
public class test {
public static void main (String[] args) {
int x;//声明变量x,但为赋值
x=5;//为变量赋值(初始化)
int b=10;//声明变量b,并赋值
int c, d = 6, e;//可以同時命名多個变量
int a;//变量名严格区分大小写
//变量名不能重复
int A;
}
}
int ca = 1;//正确
int c a=1;//错误,变量名不能包含空格
int char=1;//错误,char是关键字,变量名不能是关键字
int c _= 1;//正确,可以带下划线
int c2=1;//正确,可以带数字
int 2c=1;//错误,不能以数字开头
int $c=1;//正确,可以包含$
int c#=1;//错误,符号只能包含$和_不能有#
符合语法规范的不一定符合开发规范
//变量名、方法名由小写字母开头,不包含$和_。
int age= 10;//规范
int age$=10;//不规范,不能包含$和_。
//如果变量名或方法名由多个单词组成,从第二个单词开始,每个单词的首字母大写。
int personAge =20;//规范
int personage =20;//不规范,从第二个单词开始,每个单词的首字母大写。
int PersonAge=20;//不规范,第一个单词首字母小写
//常量(一旦赋值就不能再改变)全部由大写字母组成,多个单词由下划线_分割
int PERSON_AGE=20;//规范,并且此常量的值不能再改变
int person_age=20;//不规范,常量都大写,变量应该是personAge
//类名每个单词的首字母都大写(驼峰命名)
public class TestDemo {}//规范
public class Test_Demo {}//不规范,不能有下划线
public class testDemo {}//不规范,每个单词首字母应大写
public class testdemo {}//不规范,每个单词首字母应大写
byte a= 10;//正确
byte b=129;//错误,超出byte范围
short c = 129;//正确
int d = 12345;//正确
int e=12345678910;//错误,超出int范围
long f=12345678910L;//long后面要加L
int g=0b11;//0b开头,代表2进制,这是数字3
int h=011;//数字0开头,代表8进制,这是数字9
int i=0x11;//0x开头,代表16进制,这是数字17
float a=3.14;//错误,默认是double型
float b=3.14F;//正确
double c=3.14F;//正确
double d=3.14;//正确
double e=3.14E2;//正确,科学计数法,相当于3.14x10的2次方,即314.0
char类型的值声明有三种形式：
1.用单引号括起来
2.使用Unicode码
3.使用转义字符
char a='c';//正确
char b = '中';//正确
char c = '?' ;//正确
char d ='中文’;//错误,char类型只能表示1个字符
char e=中;//错误,没有单引号
char f="中";//错误,必须是单引号
char g=65;//正确 等同于'A' 0~65535对应Unicode码
char h='\u0041';//正确 等同于'A',Unicode码
System.out.println(h);
char i =65536;//错误,超出范围
char j='\'';//正确,转译字符,值是一个单引号
char a='c';//正确
char b = '中';//正确
char c = '?' ;//正确
char d ='中文’;//错误,char类型只能表示1个字符
char e=中;//错误,没有单引号
char f="中";//错误,必须是单引号
char g=65;//正确 等同于'A' 0~65535对应Unicode码
char h='\u0041';//正确 等同于'A',Unicode码
System.out.println(h);
char i =65536;//错误,超出范围
char j='\'';//正确,转译字符,值是一个单引号
byte byteNum = 1;
short shortNum =byteNum;//正确
int intNum= byteNum;//正确
long longNum =intNum;//正确
float floatNum = shortNum;//正确
double doubleNum= 3;//正确,int转double
int num=3.14;//错误,3.14是double类型
char c = byteNum;//错误,byte类型不能转成char
字符串的拼接
public class Test02 {
public static void main (String[] args) {
int a=1;//声明变量a并赋值为1
int b=2;//声明变量b并赋值为2
int c =a+b;//结果是3
int d=10 *3;//结果是30
int e = 21 % 4;//商5余1
int f=9f2;//只保留整数
System.out.println(f);
double g = 9.0 / 2;//4.5
System.out.println(g) ;
}
}
比较运算符只能用来比较两个基本数据类型的值，
并且判断大小只能比较数值类型的值，
比较运算符的左右两端必须是同一种数据类型的
关系运算符的优先级大于逻辑
-5右移一位(-5>>>1)得到2147483645（一个很大的正数）
int num = 3;
System.out.print(num+"是”);
System.out.print(num% 2 == 0?“偶数”:"奇数”);
![[JS]函数](https://img-blog.csdnimg.cn/img_convert/2eee47b8be645062e83916f06c288b89.png)
