数据类型与变量

Java 标识符

Java 所有的组成部分都需要名字。

类名、变量名和方法名都被称为标识符。

关于 Java 标识符，有以下几点需要注意：

• 所有的标识符都应该以字母A-Z 或 a-z 、美元符$ 或 下划线_开始
• 首字符之后可以是字母A-Z 或 a-z 美元符$ 、下划线_ 或数字的任何字符组合
• 关键字不能用作标识符
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary （非合法开头）

Java 基本数据类型

在 Java 中，数据类型主要分为两大类：基本数据类型（Primitive Data Types）和引用数据类型（Reference Data Types）。下面为你详细介绍这两种类型。

Java 有 8 种基本数据类型，它们可以进一步分为 4 类：整数类型、浮点类型、字符类型和布尔类型。

整数类型

用于表示整数数值，不同的整数类型有不同的取值范围和占用的存储空间。

数据类型	位数	取值范围	默认值	示例
byte	8 位	-128 到 127	0	byte b = 10;
short	16 位	-32768 到 32767	0	short s = 100;
int	32 位	-2147483648 到 2147483647	0	int i = 1000;
long	64 位	-9223372036854775808 到 9223372036854775807	0L	long l = 10000L;（注意：定义 long 类型的变量时，数值后面需要加 L 或 l）

浮点类型

用于表示带小数部分的数值，分为单精度 float 和双精度 double。

数据类型	位数	取值范围	默认值	示例
float	32 位	大约 ±3.40282347E+38F（有效位数 6 - 7 位）	0.0f	float f = 3.14f;（注意：定义 float 类型的变量时，数值后面需要加 F 或 f）
double	64 位	大约 ±1.79769313486231570E+308（有效位数 15 位）	0.0d	double d = 3.14159;（double 类型数值后面的 d 或 D 可以省略）

字符类型

char 类型用于表示单个字符，占用 16 位（2 个字节），采用 Unicode 编码。

数据类型	位数	取值范围	默认值	示例
char	16 位	‘\u0000’ 到 ‘\uffff’（即 0 到 65535）	‘\u0000’	char c = 'A';

布尔类型

boolean 类型只有两个值：true 和 false，用于逻辑判断。

数据类型	位数	取值范围	默认值	示例
boolean	未明确规定（通常 1 位）	true 或 false	false	boolean flag = true;

引用数据类型

引用数据类型指向一个对象，而不是存储实际的数据值。常见的引用数据类型包括：

类（Class）

自定义的类或者 Java 提供的类，例如 String 类用于表示字符串。

// 创建一个 String 对象
String str = "Hello, World!";

接口（Interface）

接口是一种抽象类型，它定义了一组方法的签名，但没有实现。

// 定义一个接口
interface MyInterface {
    void myMethod();
}

// 实现接口的类
class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("实现接口方法");
    }
}

// 创建实现类的对象
MyClass obj = new MyClass();

数组（Array）

数组是相同类型数据的有序集合，前面已经详细介绍过数组的声明、构造和初始化。

// 创建一个整型数组
int[] intArray = {1, 2, 3, 4, 5};

基本数据类型和引用数据类型的区别

• 存储方式：基本数据类型直接存储数据值，而引用数据类型存储的是对象的引用（内存地址）。
• 默认值：基本数据类型有各自的默认值，而引用数据类型的默认值是 null。
• 使用方式：基本数据类型可以直接进行赋值和运算，而引用数据类型需要通过引用调用对象的方法和属性。

Java 数据类型转换

Java数据类型转换
java数据类型的转换一般分三种,分别是:

一. 简单数据类型之间的转换

在Java中整型、实型、字符型被视为简单数据类型，这些类型由低级到高级分别为：

(byte，short，char) —— int—-–long——float——double

简单数据类型之间的转换又可以分为：

• 低级到高级的自动类型转换
• 高级到低级的强制类型转换
• 包装类过渡类型能够转换

低级变量可以直接转换为高级变量，笔者称之为自动类型转换,例如，下面的语句可以在Java中直接通过：

byte b;
int i=b;
long l=b;
float f=b;
double d=b;

如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

char c='c';
int i=c;
System.out.println("output:" i);
//输出：output:99;

对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99;
char c=(char)i;
System.out.println("output:" c);
//输出：output:c;

将高级变量转换为低级变量时，情况会复杂一些，你可以使用强制类型转换。即你必须采用下面这种语句格式：

int i=99;
byte b=(byte)i;
char c=(char)i;
float f=(float)i;

二. 字符串与其它数据类型的转换

前置：包装类

1. 什么是 Float 类型的对象

   在 Java 中，数据类型分为基本数据类型和引用数据类型。float 是基本数据类型，用于表示单精度浮点数，而 Float 是 float 对应的包装类，属于引用数据类型。Float 类型的对象就是 Float 类的实例。

   包装类存在的意义主要有以下几点：

   • 对象操作：基本数据类型不具备对象的特性，不能调用方法。而包装类可以将基本数据类型封装成对象，这样就能调用一些方法，如 Float 类的 doubleValue() 方法可以将 Float 对象转换为 double 类型的值。
   • 数据处理：在一些数据处理和传递过程中，可能需要使用对象而不是基本数据类型。
   • 泛型支持：Java 的泛型只能使用引用类型，不能使用基本数据类型。例如，List<float> 是不合法的，而 List<Float> 是合法的。

下面是一个创建 Float 类型对象的示例：

// 使用构造函数创建 Float 对象
Float floatObj1 = new Float(3.14f);
// 使用静态方法 valueOf 创建 Float 对象
Float floatObj2 = Float.valueOf("3.14");

字符串转换类型

⑴其它类型向字符串的转换

• 调用类的串转换方法：X.toString()
• 自动转换：X+""
• 使用``String的方法：String.volueOf(X)`

⑵字符串作为值，向其它类型的转换

1. 先转换成相应的封装器实例,再调用对应的方法转换成其它类型。例如，字符中“32.1”转换double型的值的格式为:

   new Float("32.1").doubleValue()：

   也可以用：

   Double.valueOf("32.1").doubleValue()：Double.valueOf("32.1").doubleValue() 这行代码会先把字符串 "32.1" 转成 Double 类型的对象，接着再把这个 Double 对象转成 double 类型的基本数据类型值。

2. 静态parseXXX方法

   String s = "1";
   byte b = Byte.parseByte( s );
   short t = Short.parseShort( s );
   int i = Integer.parseInt( s );
   long l = Long.parseLong( s );
   float f = Float.parseFloat( s );
   double d = Double.parseDouble( s );

   在 Java 里，Float 类型的对象属于包装类对象。下面为你详细介绍 Float 类型对象以及 Float 首字母大写的缘由。

   public class Main {
       public static void main(String[] args) {
           String s = "3.14";
           double d = Double.parseDouble( s );
           System.out.println(d);
       }
   }
   //输出3.14

Java 变量

在 Java 里，变量按其作用域、声明位置和生命周期等因素，可分为局部变量、类变量（静态变量）和成员变量（非静态变量）这三种主要类型。

局部变量

• 定义：在方法、构造方法或者语句块中定义的变量被称为局部变量。它只在定义它的方法、构造方法或语句块内部可见，当这些代码块执行完毕，局部变量就会被销毁。
• 特点
  • 声明在方法、构造函数或代码块内部。
  • 必须在使用前初始化，否则会编译错误。
  • 作用域仅限于声明它的代码块。
• 示例：

public class LocalVariableExample {
    public void testMethod() {
        // 声明一个局部变量
        int localVar = 10; 
        System.out.println("局部变量的值: " + localVar);
    }

    public static void main(String[] args) {
        LocalVariableExample example = new LocalVariableExample();
        example.testMethod();
        // 下面这行代码会编译错误，因为 localVar 超出了作用域
        // System.out.println(localVar); 
    }
}

类变量（静态变量）

• 定义：使用 static 关键字修饰的变量被称为类变量，也叫静态变量。它属于类本身，而不是类的某个实例，一个类的所有实例共享同一个类变量。
• 特点
  • 用 static 关键字声明，通常在类中方法外部声明。
  • 可以在类加载时初始化，如果没有显式初始化，会有默认值（如数值类型为 0，布尔类型为 false，引用类型为 null）。
  • 可以通过类名直接访问，也可以通过类的实例访问。
• 示例：

public class StaticVariableExample {
    // 声明一个类变量
    static int classVar = 20; 

    public static void main(String[] args) {
        // 通过类名直接访问类变量
        System.out.println("通过类名访问类变量的值: " + StaticVariableExample.classVar); 

        StaticVariableExample obj1 = new StaticVariableExample();
        StaticVariableExample obj2 = new StaticVariableExample();

        // 通过实例访问类变量
        System.out.println("通过 obj1 访问类变量的值: " + obj1.classVar); 
        System.out.println("通过 obj2 访问类变量的值: " + obj2.classVar);

        // 修改类变量的值
        obj1.classVar = 30;
        System.out.println("修改后通过 obj2 访问类变量的值: " + obj2.classVar); 
    }
}

成员变量（动态变量）

• 定义：在类中但方法、构造方法和语句块之外声明的变量被称为成员变量，也叫实例变量。每个类的实例都有自己独立的一份成员变量副本。
• 特点
  • 声明在类中，方法外部。
  • 如果没有显式初始化，会有默认值（如数值类型为 0，布尔类型为 false，引用类型为 null）。
  • 必须通过类的实例来访问。
• 示例：

public class InstanceVariableExample {
    // 声明一个成员变量
    int instanceVar; 

    public InstanceVariableExample(int value) {
        this.instanceVar = value;
    }

    public static void main(String[] args) {
        InstanceVariableExample obj1 = new InstanceVariableExample(40);
        InstanceVariableExample obj2 = new InstanceVariableExample(50);

        // 每个实例有自己独立的成员变量副本
        System.out.println("obj1 的成员变量值: " + obj1.instanceVar); 
        System.out.println("obj2 的成员变量值: " + obj2.instanceVar); 
    }
}