Java中的数据类型与变量

引言：

哈喽，各位读者老爷们大家好呀,long time no see!这里是小堇Java小课堂，在本课堂中我们将继续分享Java中的数据类型与变量，标识符，关键字等知识，那我们启程咯！

数据类型与变量

1.字面变量

在上一篇博客当中，System.out.println("hello world");语句不论程序何时运行，输出的都是"hello world",其实"hello world"就是所说的字面变量。

常量即程序运行期间，固定不变的量称为常量。看下列代码示例：

public class Main{
    public static void main(String[] args){
        System.out.println("100");
        System.out.println("10.5");
        System.out.println("ok");
        System.out.println("true");
    }
}

这里我们输出的这些结果都称为字面变量。

字面变量分型：

1.字符串常量：使用" "包含起来的一切内容

2.整形常量：没有小数点的数，包括负数

3.浮点数常量：带有小数点的数

4.布尔常量：true与false

5.字符常量：使用' '包含起来的单个字符

6.空常量：null

注意：字符串，整形，浮点型，字符型，布尔型在Java中都成为数据类型

2.数据类型

在Java中数据类型分为两类：基本数据类型与引用数据类型

基本数据类型有四类八种：

1.四类：整形，浮点型，字符型以及布尔型。

2.八种：

数据类型	关键字	内存占用	范围
字节型	byte	1字节	-128——-127
短整型	short	2字节	-32768——32767
整形	int	4字节	-2^31——2^31-1
长整形	long	8字节	-2^63——2^63-1
单精度浮点数	float	4字节	范围不关注
双精度浮点数	double	8字节	范围不关注
字符型	char	2字节	0——65535
布尔型	boolean	未明确规定	true和false

注意：

1.不论是64位系统还是32位系统int都占用4个字节的大小，long都占用8个字节的大小

2.整形和浮点数都是带有符号的

3.整形默认是int型，浮点数默认为double

4.字符串属于引用数据类型，后面会单独出一篇博客讲解

3.变量

3.1变量概念

在程序中除了那些不会改变的量之外，有一些量可能经常会改变，对于这些经常改变的内容，Java中称为变量，而数据类型就是用来定义不同种类的变量的。

3.2语法格式

数据类型变量名 = 初始值

eg:

public class Main {
    public static void main(String[] args) {
        int n = 10;
        int m=30.7;
        double a=10.3;
        byte b=9;
        short c=88;
        boolean d=true;
        
    }
}

3.3整形变量

public class Day13 {
   public static void main(String[] args) {
        //方式一：在定义时给定初值
        int a=10;
        System.out.println(a);
        //方式二：在定义时没有给初始值，但使用前必须设置初值
        int b;
        b=20;
        System.out.println(b);
        //int型能表示的最大范围表示：
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.MAX_VALUE);
        //注意：在定义数据时，不要定义一个超过int范围的值
        int c=100000000000000000000000000;//程序报错
        long d=10L;//long定义的长整形变量
        byte e=1;
        short f=10;
        
    }
}

注意事项：

1.int不论在何种系统下都是四字节

2.推荐使用方式一来定义数据

3.在定义设置初值时不要超过了int范围

4.变量在使用前需要赋初值
5.int的包装类型为Integer

6.长整形变量在使用时初值一般在末位加上'L'或'l'

7.long的包装类型是Long

8.short的包装类型是Short

9.byte的包装类型是Byte

3.4浮点数变量

public class Main {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        System.out.println(a/b);//0

        double c=1.0;
        double d=2.0;
        System.out.println(c/d);//0.5

        double num=1.1;
        System.out.println(num*num);//1.2100000000000002

        float e=1.0f;
        float f=2.3F;
        System.out.println(e+f);//3.3
    }
}

注意事项：

1.double在任何系统下都占8个字节

2.浮点数与整数在内存中存储方式不同，不能单纯使用2^n来计算

3.double的包装类型为Double

4.double类型的内存分布遵守IEEE754标准，尝试使用有限的空间表示可能无限的小数，势必会存在一些误差，因此浮点数是一个近似值而不是精确值

5.float占用四个字节一般工程上使用到浮点数都优先使用double

6.float的包装类型为Float

3.5字符型变量

public class Main{
    public static void main(String[] args) {
        char c1='a';//小写字母
        
        char c2='A';//大写字母
        
        char c3='9';//数字
        
        char c4='帅';
    }
}

注意事项：

1.Java中使用单引号加单个字母的形式表示字符字面值

2.计算机中的字符本质上是一个整数，C语言中使用ASCLL表示，在Java中使用Unicode表示字符，因此一个字符占用两个字节，字符类型也包括中文

3.char的包装类型为Character

在执行javac时可能会出现未结束的字符文字这一错误，我们在javac运行时加上-encoding UTF-8即可，javac-encoding UTF-8 Test.java。

3.6布尔型变量

布尔类型常量用来表示真假，在Java中有着很广泛的使用，其中true表示真，false表示假，这里需要与传统的C/C++区分开（在C/C++中非0为真，0为假）。

public class Main {
    public static void main(String[] args) {
        boolean c=true;
        System.out.println(c);
        c=false;
        System.out.println(c);
    }
}

注意事项：

1.boolean的取值只有两种，true表示真和false表示假

2.Java中的boolean类型不能与int类型相互转换，不能用数字形式表示真假

3.在Java虚拟机中未明确表示boolean有几个字节，在Oracle公司的虚拟机实现中，boolean占1个字节

4.boolean的包装类型为Boolean

3.7类型转换

Java作为一个强类型编程语言，当不同类型之间的变量互相赋值的时候，会有较为严格的校验。

public class Main {
    public static void main(String[] args) {
    long a=10;
    int b=20;
    a=b;//可以通过编译
    b=a;//编译失败
    }
}

3.7.1自动类型转换（隐式转换）

自动类型转换：代码不需经过任何处理，在代码编译时，编译器会自动进行处理。

特点：数据范围小的数转化为数据范围大的数会自动进行。

public class Main {
    public static void main(String[] args) {
    long a=10;
    int b=20;
    a=b;//可以通过编译，a的范围比b更大，编译时会将b的类型提升为long
    b=a;//编译失败
        
    double f=3.14;
    float f2=4.5F;
    f=f2;//可以通过编译，f的范围比f2更大，编译时会将f2的类型提升为double
    f2=f;//编译失败

        byte d=10;
        int e=20;
        e=d;//可以通过编译，e的范围比d更大，编译时会将d类型提升为int
        d=e;//编译失败    
    }
}

3.7.2强制类型转换（显示转换）

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。

特点：数据范围大的到数据范围小的

public class Main {
    public static void main(String[] args) {
    long a=10;
    int b=20;
    a=b;//可以通过编译，a的范围比b更大，编译时会将b的类型提升为long
    b=(int)a;// 强制转换a为int型

    double f=3.14;
    float f2=4.5F;
    f=f2;//可以通过编译，f的范围比f2更大，编译时会将f2的类型提升为double
    f2=(float) f;//强制转换f为float型
        
        byte d=10;
        int e=20;
        e=d;//可以通过编译，e的范围比d更大，编译时会将d类型提升为int
        d=(byte) e;//强制转换e为byte型
    }
}

注意事项：

1.不同数字类型之间赋值，只能将数据范围小的类型隐式转换为数据范围较大的数据

2.如果将数据范围大的数赋值给小的需要强制类型转换，但可能发生极度丢失

3.将一个字面值常量进行赋值的时候，Java会主动针对数字范围进行检查

4.强制类型转换不一定成功，不相干的类型不能相互转换

3.8类型提升

不同数据类型之间进行相互运算，数据类型小的会被提升到数据类型大的。

1.int与long之间运算，int会被提升为long

public class Main {
    public static void main(String[] args) {
        long a = 10;
        int b = 20;
        long c = a + b;//编译成功，b自动转换为long类型参与运算
        int d = a + b;//编译失败    
    }
}

2.byte与byte之间的运算

public class Main {
    public static void main(String[] args) {
        byte a=10;
        byte b=20;
        byte c=a+b;//编译失败
        int d=a+b;//编译成功
    byte e=(byte)(a+b);//编译成功
    }
}

原因：byte和byte虽然是同类型，但他们在进行运算的时候都会被默认提升为int类型，再进行计算，得到的结果也是int型，这时候使用byte来接受就会编译失败。

另外，short，byte在进行运算时都会被提升为int型

4.字符串类型

在Java中使用String类定义字符串类型，比如：

public class Main {
    public static void main(String[] args) {
        String s1="hello";
        String s2="world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1+s2);
    }
}

4.1int转成String

public class Main {
    public static void main(String[] args) {
        int num=10;
        //方法一：
        String s1=num+"";
        //方法二：
        String s2=String.valueOf(num);
    }
}

4.2String转成int

public class Main {
    public static void main(String[] args) {
        String s="100";
        int num=Integer.parseInt(s);
    }
}

5.标识符·

在Java中，标识符是用来标识变量、方法、类等程序元素的名称。标识符必须遵循以下规则：

只能包含字母、数字、下划线和美元符号：标识符可以由字母（大小写均可）、数字、下划线（_）和美元符号（$）组成。标识符的第一个字符不能是数字。
不能以数字开头：标识符的第一个字符不能是数字。
不能是 Java 的保留关键字：不能使用Java的保留关键字（例如：public、class、static等）作为标识符。
区分大小写：Java是大小写敏感的语言，因此大写字母和小写字母被视为不同的标识符。
没有长度限制：Java标识符的长度理论上没有限制，但通常会有一些约定俗成的规范，比如一些编码规范建议标识符长度不要超过某个特定的字符数。

一些常见的命名约定包括：

使用有意义的名称：标识符应该能够清晰地表达其所代表的含义，使得代码易于理解和维护。
遵循驼峰命名法：在驼峰命名法中，除了第一个单词外，其余单词的首字母大写，例如：myVariable、calculateTotal。
类名通常以大写字母开头，方法和变量名通常以小写字母开头，常量名通常全部大写。

使用良好命名的标识符可以使代码更易读、易懂，并且有助于减少错误和提高代码的可维护性。

6.关键字

在Java中，关键字是预定义的具有特殊含义的单词，它们被用于定义语法结构、控制程序流程以及实现特定功能。关键字在编程中有着特殊的作用，不能被用作标识符（例如变量名、方法名等）。

以下是Java中的一些主要关键字及其作用：

abstract: 用于定义抽象类和抽象方法。抽象类是不能被实例化的类，抽象方法是只有方法声明而没有实现的方法，需要在子类中实现。
assert: 用于在代码中插入断言，用于测试条件是否为真。在开发和调试阶段用于检查代码中的假设。
boolean: 用于定义布尔类型，表示逻辑上的真或假。
break: 用于在循环语句（如for、while、do-while）和switch语句中跳出当前循环或者switch语句。
byte, short, int, long: 用于定义整数类型的数据。分别表示不同范围的整数。
case, default: 用于在switch语句中定义分支条件。
catch, finally: 用于异常处理，catch用于捕获异常并处理，finally用于无论是否发生异常都会执行的代码块。
char: 用于定义字符类型的数据。
class: 用于定义类。
const（已废弃）: 用于定义常量。在Java 1.0版本中引入，但从Java 1.1开始被废弃。
continue: 用于跳过循环中的剩余代码，并继续下一次循环的执行。
default: 用于switch语句中的默认分支。
do, while: 用于实现do-while循环。
double, float: 用于定义浮点数类型的数据。
else, if: 用于在条件语句中定义分支。
enum: 用于定义枚举类型。
extends, implements: 用于类的继承和接口的实现。
final: 用于声明常量、类的最终实现或者方法的最终实现。
finally: 用于异常处理中的最终执行代码块。
float: 用于定义单精度浮点数类型的数据。
for: 用于实现for循环。
goto（不建议使用）: 用于跳转到代码中的标签处。在Java中不推荐使用。
if: 用于实现条件判断。
implements: 用于实现接口。
import: 用于导入其他包中的类或者整个包。
instanceof: 用于判断一个对象是否是指定类的实例。
int: 用于定义整数类型的数据。
interface: 用于定义接口。
long: 用于定义长整型数据。
native（不常用）: 用于标识方法的实现是由本地代码（如C或C++）实现的。
new: 用于创建对象或者数组。
package: 用于定义包。
private, protected, public: 用于定义访问权限。
return: 用于从方法中返回值。
short: 用于定义短整型数据。
static: 用于定义静态成员，静态方法，静态代码块。
strictfp: 用于确保浮点运算的结果在不同平台上保持一致。
super: 用于引用父类的成员。
switch: 用于实现多分支选择结构。
synchronized: 用于实现同步代码块或者方法，确保在多线程环境中的线程安全。
this: 用于引用当前对象。
throw: 用于抛出异常。
throws: 用于声明方法可能抛出的异常。
transient: 用于修饰不希望被序列化的成员变量。
try: 用于定义可能发生异常的代码块。
void: 用于定义方法的返回类型，表示该方法不返回任何值。
volatile: 用于标识变量可能会被多个线程同时访问，确保线程安全。
while: 用于实现while循环。

这些是Java中的一些关键字，它们具有特殊的语法含义，对于构建Java程序来说是必不可少的。