超详细Java基础语法之变量、标识符、数据的存储单位、数据类型！！【Java】

成功屬於永不放棄的人，只要堅持一段時間，你就會成功。

变量

变量就是程序运行过程中用来存储数据的“容器”，本质上是内存中的一块存储空间。

写法

• 声明变量：

// 1. 声明变量 （数据类型 变量名）   
String name;          

• 变量赋值

// 2. 变量赋值          
name = "zhangsan";  

• 声明变量的时候直接赋值

// 将1+2合并，声明变量的时候直接赋值 （数据类型 变量名 = 值）    
String username = "lisi"; 

• 使用变量

 // 3. 使用变量                                     
 System.out.println("Hello World, " + name);    
 System.out.println("Hello World, " + username);

• 注意：在使用变量之前进行变量初始化

// 在使用变量之前，必须要给变量赋值，这叫变量的初始化                               
String email;                                           
System.out.println(email);     // 变量 'email' 可能尚未初始化    

分类：

• 局部变量：方法里定义的，作用域在方法内。【方法里的临时数据】
• 成员变量：类里定义的，属于对象。【对象的状态数据】
• 静态变量：用 static 修饰，属于类，不依赖于对象。【整个类的共享数据】

public class VariableDemo {
    // 成员变量（属于对象）
    String name;  
    
    // 静态变量（属于类）
    static int count = 0;

    public void setName(String newName) {
        // 局部变量（属于方法，作用域仅在此方法内）
        int length = newName.length(); 
        name = newName;
        count++; // 统计创建对象的次数
        System.out.println("名字设置为: " + name + "，长度是: " + length);
    }

    public static void main(String[] args) {
        // 创建第一个对象
        VariableDemo v1 = new VariableDemo();
        v1.setName("Alice");  // 成员变量 name = "Alice"，静态变量 count = 1

        // 创建第二个对象
        VariableDemo v2 = new VariableDemo();
        v2.setName("Bob");    // 成员变量 name = "Bob"，静态变量 count = 2

        // 打印静态变量
        System.out.println("一共创建了 " + VariableDemo.count + " 个对象");
    }
}

输出结果：

名字设置为: Alice，长度是: 5
名字设置为: Bob，长度是: 3
一共创建了 2 个对象

标识符（标识数据的符号）

标识符就是 程序里各种命名的符号（变量名、类名、方法名等）。【标识符主要用于起名 】

规则

• 可以包含：字母、数字、下划线 _、美元符号 $。
• 不能以数字开头。
• 在大括号范围内，标识符不允许被重复。
• 不能用关键字（如 class, public）。
• 区分大小写。
• 标识符的命名要使用下划线命名法或者驼峰命名法

具体表现

• 英文拉丁字母

// 1. 英文拉丁字母             
String age = "18";       
String xingming = "张三";  

• 符号（@，#，%，$）标识符只能采用下划线和美元$符，其他符号不能使用，称之为特殊符号。 空格也属于特殊符号，所以能不能作为标识符使用。

// 2. 符号（@，#，%，$）标识符只能采用下划线和美元$符，其他符号不能使用，称之为特殊符号。        
// 空格也属于特殊符号，所以能不能作为标识符使用                                 
String _name = "zhangsan";                                
String $name = "zhangsan";                                
String $na_me = "zhangsan";                               
System.out.println(_name);                                
System.out.println($name);                                
System.out.println($na_me);                               

• 数字（不能作为开头） 标识符不能以数字开头，但是可以包含数字。数字如果在标识符的开头位置，会被识别为数字而不是标识符，所以会发生错误。

// 3. 数字（不能作为开头） 标识符不能以数字开头，但是可以包含数字      
// 数字如果在标识符的开头位置，会被识别为数字而不是标识符，所以会发生错误    
String name1 = "zhangsan";                
// String 1name = "zhangsan";    // 编译错误  

• 在大括号范围内，标识符不允许被重复

 // 4. 在大括号范围内，标识符不允许被重复  
 String name = "lisi";                             
 //String name = "zhangsan";       // 作用域中已定义变量 'name' 

• 标识符区分大小写

// 5. 标识符区分大小写                           
// 但是其实变量名【Name】不符合lowerCamelCase命名风格    
String Name = "zhangsan";  
String name = "zhangsan";                
System.out.println(Name);    
System.out.println(name);               

• java语言中预先定义好了一些标识符名称，成为关键字或者保留字

// 6. java语言中预先定义好了一些标识符名称，成为关键字或者保留字                                               
//String static = "zhangsan";                                                       
// 因为区分大小写所以这样可以使用，但是不推荐【并且变量名【Public】不符合lowerCamelCase命名风格】                      
// String Public = "zhangsan";                                                      

• 标识符的命名要见名知意 并且标识符的命名要使用下划线命名法或者驼峰命名法

 // 7. 标识符的命名             
 // （1. 标识符的命名要见名知意           
 // （2. 标识符的命名要使用下划线命名法或者驼峰命名法
 String userName = "zhangsan";

数据的存储单位

• 比特（bit位）：数据运算的最小存储单位 ，只有 0 或 1
• 字节（Byte）：8个比特位组成一个字节，占用空间1个字节【数据的最小存储单位】

常见换算：

 1byte = 8bit    
 KB，MB，GB，TB.... 
 1024 Byte => 1KB
 1024 KB => 1MB  
 1024 MB => 1GB  
 1024 GB => 1TB   

数据类型

基本数据类型

类型	占用字节	取值范围	示例值
byte	1 字节	-128 ~ 127	byte b = 10;
short	2 字节	-32768 ~ 32767	short s = 1000;
int	4 字节	-2³¹ ~ 2³¹-1	int n = 12345;
long	8 字节	-2⁶³ ~ 2⁶³-1	long l = 100000L;
float	4 字节	约 7 位小数	float f = 3.14f;
double	8 字节	约 15 位小数	double d = 3.14159;
char	2 字节	单个字符（Unicode）	char c = 'A';
boolean	1 bit（逻辑上）	true / false	boolean flag = true;

数值类型

• 整数类型：byte，short，int，long

// TODO 整数类型 
// byte: 8位  
byte b = 10; 
// short：16位 
short s = 10;
// int：32位   
int i = 10;  
// long：64位  
long l = 10; 

• 浮点类型：float，double 【默认情况下，小数点的数据会被识别为精度较高的双精度】

// TODO 浮点类型                           
// float：32位 【单精度浮点类型】                 
// 默认情况下，小数点的数据会被识别为精度较高的双精度double类型   
// float： 但精度浮点类型，数据需要使用F（f）结尾         
float f = 10.0f;                       
// double：64位 【双精度浮点类型】                
double d = 10.0;                       

字符类型

char 使用符号标识文字内容

// TODO 字符类型    
// (2.字符类型：char 
// 使用符号标识文字内容   
char c = 'a';   
char c1 = '@';  

布尔类型

true，false 【标识判断条件是否成立，成立为true，反之为false】

 // (3.布尔类型：boolean                                    
 // true，false 【标识判断条件是否成立，成立为true，反之为false】           
 boolean bln = true;                                   

数据类型的转换

byte -> short -> int -> long -> float -> double

 byte b1 = 10;   
 short s1 = b1;  
 int i1 = s1;    
 long lon1 = i1; 
 float f1 = lon1;
 double d1 = f1; 

java中范围小的数据可以直接转换为范围大的数据，反之不被允许

//int i2 = d1; // 错误                                                               

如果想要将范围大的数据转换为范围小的数据，那么需要使用小括号进行强制转换

int i2 = (int)d1;  

引用数据类型【可以被引用的数据类型】

• 类，String
• 接口
• 数组
• 枚举
• 特殊类型值：null

类 （class）

类是 Java 的核心，用来描述对象的属性和行为。

// 定义类
public class Person {
    String name; // 成员变量
    int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 成员方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
    }
}

// 使用类
public class TestClass {
    public static void main(String[] args) {
        Person p = new Person("Alice", 20); // 创建对象
        p.sayHello();
    }
}

输出

Hello, my name is Alice, I'm 20 years old.

String

String 是 Java 中使用最广的类型，虽然不是基本类型，但用得非常频繁。

public class TestString {
    public static void main(String[] args) {
        String s1 = "Hello";           // 字符串常量
        String s2 = new String("Java"); // 使用构造方法创建

        // 拼接
        String s3 = s1 + " " + s2;
        System.out.println(s3);

        // 方法
        System.out.println("长度: " + s3.length());
        System.out.println("是否包含 'Java': " + s3.contains("Java"));
        System.out.println("转大写: " + s3.toUpperCase());
    }
}

输出

Hello Java
长度: 10
是否包含 'Java': true
转大写: HELLO JAVA

接口（Interface）

接口定义了一组“规范”，实现接口的类必须实现接口中的方法。

// 定义接口
interface Animal {
    void makeSound(); // 接口里的方法默认是 public abstract
}

// 实现接口
class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

// 使用接口
public class TestInterface {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.makeSound();
    }
}

输出

Woof!

数组（Array）

数组是存放同一种数据类型的固定长度的容器。

public class TestArray {
    public static void main(String[] args) {
        // 定义并初始化数组
        int[] nums = {10, 20, 30, 40};
        
        // 遍历数组
        for (int i = 0; i < nums.length; i++) {
            System.out.println("索引 " + i + " 的值是: " + nums[i]);
        }
    }
}

输出

索引 0 的值是: 10
索引 1 的值是: 20
索引 2 的值是: 30
索引 3 的值是: 40

枚举（Enum）

枚举是一种特殊的类，用来定义常量集合。

// 定义枚举
enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class TestEnum {
    public static void main(String[] args) {
        Day today = Day.MONDAY;

        switch (today) {
            case MONDAY:
                System.out.println("今天是星期一，加油！");
                break;
            case FRIDAY:
                System.out.println("今天是星期五，快放假了！");
                break;
            default:
                System.out.println("今天是 " + today);
        }
    }
}

输出

今天是星期一，加油！

总结

• 类（Class） → 对象的蓝图（有属性 + 方法）。
• String → 特殊的引用类型，表示文本。
• 接口（Interface） → 规范，定义必须实现的方法。
• 数组（Array） → 存放相同类型的数据集合。
• 枚举（Enum） → 固定常量的集合。