2.数据类型与变量 —— Java SE

柔情只为你懂 2023-09-29 11:04 12阅读 0赞

**目录**

1.字面常量

2.数据类型

3.变量

3.1 变量的概念和语法格式

3.2 整形变量

3.2.1 整型变量（int）

3.2.2 长整型变量（long）

3.2.3 短整型变量(short)

3.2.4 字节型变量(byte)

3.3 浮点型变量

3.3.1 单精度浮点型(float)

3.3.2 双精度浮点型(double)

3.4 字符型变量(char)

3.5 布尔型变量（boolean）

3.6 类型转换

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

3.6.2 强制类型转换（显式类型转换）

3.6.3 分析一个题

3.7 类型提升

4.字符串类型

--------------------

## 1.字面常量 ##

**常量即程序运行期间，固定不变的量**

> **字面常量的分类：**
> 
> 1.  字符串常量：由 "" 括起来的，比如 “12345” 、 “hello” 、 “ 你好 ” 。 
> 
> 2.  整形常量：程序中直接写的数字 ( 注意没有小数点 ) ，比如： 100 、 1000 
> 
> 3.  浮点数常量：程序中直接写的小数，比如： 3.14 、 0.49 
> 
> 4.  字符常量：由 单引号 括起来的当个字符，比如：‘A’、 ‘1’ 
> 
> 5.  布尔常量：只有两种 true 和 false 
> 
> 6.  空常量： null( 后面了讲 )

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

## 2.数据类型 ##

Java的数据类型主要分为两类：**基本数据类型和引用数据类型**

（1）基本数据类型分为四类八种：

四类：整型，浮点型，字符型，布尔型

八种分为：

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>关键字</th> 
   <th>内存占用</th> 
   <th>范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字节型</td> 
   <td>byte</td> 
   <td>1字节</td> 
   <td>-128~127</td> 
  </tr> 
  <tr> 
   <td>短整型</td> 
   <td>short</td> 
   <td>2字节</td> 
   <td>-32768~32767</td> 
  </tr> 
  <tr> 
   <td>整型</td> 
   <td>int</td> 
   <td>4字节</td> 
   <td>-2^31~ 2^32-1</td> 
  </tr> 
  <tr> 
   <td>长整型</td> 
   <td>long</td> 
   <td>8字节</td> 
   <td>-2^63~ 2^63-1</td> 
  </tr> 
  <tr> 
   <td>单精度浮点数</td> 
   <td>float</td> 
   <td>4字节</td> 
   <td>有范围，一般不关注</td> 
  </tr> 
  <tr> 
   <td>双精度浮点数</td> 
   <td>double</td> 
   <td>8字节</td> 
   <td>有范围，一般不关注</td> 
  </tr> 
  <tr> 
   <td>字符型</td> 
   <td>char</td> 
   <td>2字节</td> 
   <td>0 ~ 65535（Unicode）</td> 
  </tr> 
  <tr> 
   <td>布尔型</td> 
   <td>boolean</td> 
   <td>没有明确规定</td> 
   <td>true / false</td> 
  </tr> 
 </tbody> 
</table>

(2) 引用数据类型

数组，String，类，接口，枚举 ... ...

## 3.变量 ##

### 3.1 变量的概念和语法格式 ###

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

变量就相当于是一个小箱子，这个箱子里面可以放东西，箱子有大有小的

**包装类：每个基本数据类型，都会对应个类类型，这个类类型就是包装类**

定义变量的语法格式为：

> 数据类型 变量名 = 初始值；

### 3.2 整形变量 ###

#### 3.2.1 整型变量（int） ####

> 1.大小：**int是4字节(可移植型强**，无论是在32或64位系统下都是4字节)；
> 
> 表示范围（-2^31 ~ 2^31-1）
> 
> 2.包装类：**int的包装类型为 Integer**
> 
> 3.在Java里面，int 没有所谓的无符号数，所以，**int既能表示正数，也能表示负数**

public class TestDemo {
        public static void main(String[] args) {
            //1.在定义时给出初始值
            int a = 10;
            System.out.println(a);
    
            //2.在定义时没有给初始值，但使用时必须设置初始值
            int b;
            b = 10;
            System.out.println(b);
    
            //3.int 型变量的表示范围
            System.out.println("最大值"+Integer.MAX_VALUE);
            System.out.println("最小值"+Integer.MIN_VALUE);
    
            //4.在定义int 性变量时，所赋值不能超过int的范围
            int d = 1234566702334;//编译时报错，初值超过int的范围
    
        }
    }

#### 3.2.2 长整型变量（long） ####

> 1.大小：long不论在哪种操作系统下，都**占8个字节**
> 
> 表示范围（-2^63 ~ 2^63-1）
> 
> 2.长整型变量的**初始值后面加L或l**
> 
> 3.包装类：long的**包装类型为Long**

public calss TestDemo{
       public static void main1(String[] args) {
            //1.long 为了区分int和long,一般给long类型变量的初始值之后加上L或l
            long a = 10L;
            System.out.println(a);
            //2.long类型表示的范围
            System.out.println("最大值"+Long.MAX_VALUE);
            System.out.println("最小值"+Long.MIN_VALUE);
        }
    }

#### 3.2.3 短整型变量(short) ####

> 1.大小：short在任何系统下都**占2个字节**
> 
> 表示范围（-2^15 ~ 2^15-1）
> 
> 2.没有无符号的，short可以**表示正数或负数**
> 
> 3.包装类类型：short的**包装类类型是Short**

public class TestDome{
    public static void main(String[] args) {
    
        short a = 10;
        System.out.println(a);
    
        //short型表示的范围
        System.out.println("最大值"+Short.MAX_VALUE);
        System.out.println("最小值"+Short.MIN_VALUE);
    }
    }

#### 3.2.4 字节型变量(byte) ####

> 1.大小：byte在任何系统下都占1个字节
> 
> 范围（-2^7-1 ~ 2^7，即-128~127）
> 
> 2.包装类类型：byte包装类类型为Byte

public class TestDome{
    public static void main(String[] args) {
        
        byte b = 10;
        System.out.println(b);
        
        //byte型所表示的范围
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
    }
    
    }

### 3.3 浮点型变量 ###

#### 3.3.1 单精度浮点型(float) ####

> 1.大小：float在任何大小的系统下都**占用4个字节**
> 
> 2.包装类类型：float的**包装类类型为Float**
> 
> 3.float变量的**初始值后面加F或f**

public class TestDome{
        public static void main(String[] args) {
            
            float num = 1.0F;
            System.out.println(num);
        }
    }

#### 3.3.2 双精度浮点型(double) ####

> 1.大小：double在任何系统下都**占8个字节**
> 
> 2.包装类类型：double的**包装类类型为Double**
> 
> 3.double类型遵循内存布局IEEE754标准，**浮点数是一个近似值，并不是精确值**

public static void main4(String[] args) {
        
        double d = 3.14;
        System.out.println(d);
        
    }

下面来分析两个有趣的例子

>     2.例子一
>     int a = 1;
>     int b = 1;
>     System.out.println(a/b);//会输出0.5吗
> 
> 答案显然是不会输出0.5，因为在Java中，int除以int的值还是int，会直接把小数那部分舍弃。所以要想计算出0.5，就要使用double类型来计算
> 
>     double a1 = 1.0;
>     double b1 = 2.0;
>     System.out.println(a/b);//输出0。5
> 
> --------------------
> 
> 2.例子二
> 
>     double num = 1.1;
>     System.out.println(num*num);//会输出1.21吗
> 
> ![2294e448e483414097d23aacf86507bf.png][]
> 
> 很显然不是1.21，这是因为double遵循IEEE754标准，所以double只能是近似值。

### 3.4 字符型变量(char) ###

> 1.大小：char在任何大小的系统下，都**占用2个字节，并且不能表示负数**
> 
> 2.C语言中使用ASCII表示字符，而在J**ava中使用Unicode表示字符**
> 
> 因此，表示的种类更多（0~65535），包括了很多语言中文，拉丁文等等
> 
> 3.包装类类型：char的**包装类类型为Character**

public static void main(String[] args) {
        
        char ch = 'a';
        char ch2 = '高';
        char ch3 = '1';
        System.out.println(ch);
        System.out.println(ch2);
        System.out.println(ch3);
    }

### 3.5 布尔型变量（boolean） ###

> 1.Boolean类型的变量只有两种取值，true表示真或false表示假
> 
> 2.Java的boolean类型和int类型不能相互转换，不存在1表示true，0表示false
> 
> 3.包装类类型：boolean的包装类类型为Boolean
> 
> 4.Java的虚拟机中，并没有明确规定Boolean占几个字节，

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

### 3.6 类型转换 ###

#### 3.6.1 自动类型转换（隐式类型转换） ####

> 自动类型转换即： **代码不需要经过任何处理，在代码编译时，编译器会自动进行处理** 。特点： **数据范围小的转为数据范围大的时会自动进行** 。
> 
> 也就是 小范围-》大范围 可以
> 
>  大范围-》小范围 不可以

public class TestDome{
       public static void main(String[] args) {
            System.out.println(1024);//整型情况下默认为int
            System.out.println(3.14);//浮点型情况下默认为double
            
            int a = 100;
            long b = 10L;
            
            b = a;//a是int 小范围，b是long 大范围 ，把小范围赋给大范围，会自动将a提升为大范围也就是long类型
            
            a =b;//这样反过来的话就是 大范围-》小范围 会有数据丢失不安全
            
            float f = 3.14F;
            double d = 5.12;
            
            d = f;//小范围-》大范围，可以，f会自动转化为double
            
            f = d;//大范围-》小范围，不可以，会有数据丢失不安全
            
            byte b1 = 100;//编译通过
            byte b2 = 257;//编译失败，257超过byte的数据范围，有数据丢失
        }
    }

#### 3.6.2 强制类型转换（显式类型转换） ####

> 强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点： **数据范围大的到数据范围小的。**
> 
> 即
> 
> **强制类型转换发生的情况时：大范围-》小范围**

public class TestDome{   
    public static void main(String[] args) {
    
            int a = 10;
            long b = 100L;
            b = a;//小范围-》大范围   可以
            a = (int)b;//大范围-》小范围 需要强制转化
    
            float f = 3.14F;
            double d = 5.12;
            d = f;//小范围-》大范围   可以
            f = (float)d;// 大范围-》小范围  需要强制转化
    
            a = d;//报错，类型不兼容
            a = (int)d;//大范围-》小范围 ，需要强转，小数点之后全部丢弃
    
            byte b1 = 100;//100默认为int，隐式转换后，没有超过byte范围
            byte b2 = (byte)257;//257默认为int，超过了byte范围，需要强制转化
            
            boolean flag = true;
            a = flag;//编译失败
            flag = a;//编译失败 类型不兼容
        }
    }

> 注意：
> 
> 1.小范围-》大范围 隐式转化
> 
> 2.大范围-》小范围 必须强转，否则会编译失败，并且也可能精度丢失
> 
> 3.将一个字面值常量进行赋值时，Java会自动针对数字范围进行检查
> 
> 4.强制转化不一定成功，不想干的类型不能相互转化

#### 3.6.3 分析一个题 ####

int i = 10;
    float f = 19.9F;
    i = f;//会报错吗

会报错，因为虽然 i 和 f 都是4字节的，但float能表示的数据宽度，除了整数部分，还有小数部分，把整数部分给了int 那小数部分怎么办？

### 3.7 类型提升 ###

**1.当两种不一样的数据类型进行运算时，会把其中的一个较小的数据类型，转换为较大的参与运算**

int a = 10;
    long b = 20;
    
    int c = a + b;//编译失败 a+b->int+long->long+long 赋值给int会丢失数据
    long d = a + b;//编译通过 赋值给long就可以

**2.小于4字节的类型，运算都会先提升为int，再参与运算**

byte a = 10;
    byte b = 20;
    byte c = a + b;
    system.out.printfln(c);//编译失败，从a+b-》提升为 int+int-》byte 可能会有损失
    
    byte c = (byte)(a + b);
    system.out.printfln(c);//编译通过，将int强制转化为byte

## 4.字符串类型 ##

**在Java中使用String类定义字符串类型，**

**和C有点不一样，没有‘\\0’结尾，根本没有这个说法**

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);//s1+s2表示：s1和s2进行拼接
    }

在有些情况下，需要将字符串和整形数字之间进行转换：

**1.int转成String**

int num = 10;
        String str1 = num + "";//法1
        String str2 = String.valueOf(num);//法2

**2.String转成int**

String str = "100";
        int num = Integer.parseInt(str);

--------------------

[2294e448e483414097d23aacf86507bf.png]: https://img-blog.csdnimg.cn/2294e448e483414097d23aacf86507bf.png