【Java基础系列】2- Java的变量与数据类型

秒速五厘米 2022-09-10 06:18 214阅读 0赞

## 1. 内存 ##

存储器的种类很多，按其用途可分为主存储器和辅助存储器，主存储器又称内存储器（简称内存），辅助存储器又称外存储器（简称外存）。

### 1.1 什么是内存 ###

内存指的就是主板上的存储部件，CPU直接与之沟通，并用其存储数据的部件，存放当前正在使用的（即执行中的）数据和程序，它的物理实质就是一组或多组具备数据输入输出和数据存储功能的集成电路，内存只用于暂时存放程序和数据，一旦关闭电源或发生断电，其中的程序和数据就会丢失。

言而总之，内存即是一块瞬时状态的存储空间，有一定的容量；

特点：内存处理速度快、存储容量小、断电后信息丢失；

### 1.2 什么是外存 ###

外存包括软盘、硬盘和光盘，存放在其中的数据靠磁来维持，因此可永久保存数据。

外存处理速度慢、存储容量大、信息永久保存；

### 1.3 内存与硬盘的区别 ###

*  内存的造价比较高，整个的计算机硬件资源是比较稀缺的；（所以内存得省着点用）
 *  工业上的瓶颈，多数大容量的内存都是由多个内存条组成的；

### 1.4 计算机给`java`程序多大的内存空间 ###

*  `java` 虚拟机（`java`程序），默认分配的物理内存容量是计算机 `1/8`；（省着点使用）

### 1.5 计算机存储容量的基本单位 ###

*  `bit` 位 （`8bits = 1 Byte`）
 *  `Byte` 字节 （`1024 Byte = 1KB`）
 *  `KB - MB - GB - TB - PB - EB - ZB - YB - BB - NB - DB - CB - XB` （1024进制）

## 2. 变量 ##

### 2.1 变量的概念 ###

*  概念：计算机内存中的一块存储空间，是存储数据的基本单元
    
     *  整个内存就像是酒店，当中包含了多个房间；
     *  房间的容量大小不同，比如：单人间、双人间…
     *  每个房间都有一个唯一的门牌号；
 *  酒店的房间 — 变量的组成
    
     *  房间的类型 — 数据类型
     *  房间的门牌号 — 变量名
     *  房间的住客 — 值

### 2.2 变量的定义流程 ###

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

*  变量的定义流程
    
     *  声明
        
        数据类型 变量名;
        
        int money; >>> 开辟整数变量空间
     *  赋值
        
        变量 = 值; （= 即为赋值运算符）
        
        money = 100; >>> 将整数值赋给变量
    
    代码如下：
    
        public class TestVariable {
              
        	public static void main(String[] args) {
              
        		
        		// 声明变量，语法：数据类型 变量名;
        		int money; // 在内存中开辟了一块整数空间
        		
        		// 赋值，语法：变量名 = 值;
        		money = 100; // 将100赋值给 money 变量空间
        		
        		System.out.print(money);
        		System.out.println("money");
        		
        		System.out.println("print 与 println 的区别：自动换行");
        		
        		System.out.println(money); // 打印变量中的值
        		System.out.println("money"); // 双引号：打印文本
        	}
        }
    
    在`.java` 文件的当中目录下打开`cmd`编译：
    
    ![在这里插入图片描述][e608246813cc457cb11d69f52bed0b94.png_pic_center]
 *  注意
    
    `.java`是强类型语言，变量的类型必须与数据的类型一致；也就是说，当`money`被声明为整数`int`，赋值的时候就只能赋值为整数，不能赋值其他的数据类型，不能会抛出，转换为`int`会有损失的异常；

### 2.3 赋值运算符 ###

*  概念：为变量进行赋值
 *  变量名 = 值; 即将等号右边的值，赋值给等号左边的变量（存值）

### 2.4 不同类型的编程语言 ###

*  强类型编程语言：变量的类型必须与数据的类型一致；（比如：`java、c++、c#`）
 *  弱类型编程语言：变量的类型无需与数据的类型一致；（比如：`JavaScript`）

### 2.5 变量的多种定义方式 ###

*  声明变量的三种方式：
    
     *  先声明，再赋值：
        
        数据类型 变量名;
        
        变量名 = 值;
     *  声明并赋值：
        
        数据类型 变量名 = 值;
     *  多个同类型变量的声明与赋值：【了解】
        
        数据类型 变量1 , 变量2 , 变量3 = 值3 , 变量4 , 变量5 = 值5;
    
    举个例子：
    
        public class TestVarDefined{
              
        	
        	public static void main(String[] args){
              
        		
        		// 声明并赋值
        		
        		int age = 10; // 将声明的语法与赋值的语法合二为一
        		
        		System.out.println(age);
        		
        		// 同时声明多个同类型的变量
        		int a, b, c, d = 44, e = 55;
        		
        		a = 11;
        		b = 22;
        		c = 33;
        		
        		System.out.println(a);
        		System.out.println(b);
        		System.out.println(c);
        		System.out.println(d);
        		System.out.println(e);
        	}
        }
    
    打开`cmd`完成编译以及运行，如下图：
    
    ![在这里插入图片描述][5a5781e0ecdb48c69f2ccf0bbcd7feb8.png_pic_center]

## 3. 数据类型 ##

*  `Java` 中的变量具有严格的数据类型区分。（强类型语言）
 *  在`Java`语言中，任何一个值，都有其对应类型的变量；
    
     *  java中的数据类型
        
         *  基本数据类型（8种）
            
             *  整数 - 4
             *  小数 - 2
             *  布尔 - 1
             *  字符 - 1
         *  引用数据类型
            
             *  字符串
             *  数组
             *  对象

### 3.1 基本数据类型（整数） ###

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字节</th> 
   <th>取值范围（二进制）</th> 
   <th>取值范围（十进制）</th> 
   <th align="left">数量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>1字节</td> 
   <td>-2^7 ~ 2^7-1</td> 
   <td>-128 ~ 127</td> 
   <td align="left">256</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>2字节</td> 
   <td>-2^15 ~ 2^15-1</td> 
   <td>-32768 ~ 32767</td> 
   <td align="left">65536</td> 
  </tr> 
  <tr> 
   <td>int（Integer ）</td> 
   <td>4字节</td> 
   <td>-2^31 ~ 2^31-1</td> 
   <td>-2147483648 ~ 2147483647</td> 
   <td align="left">42亿左右</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>8字节</td> 
   <td>-2^63 ~ 2^63-1</td> 
   <td>-9223372036854775808 ~ 9223372036854775807</td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

注意：`int` 为整数的默认类型，如需为`long`类型赋值较大整数时（超过`int`类型的取值范围），需在值的后面追加`L`或者小写`l`；

/**
    	基本数据类型（整数）
    */
    public class TestType{
        
    	public static void main(String[] args){
        
    		
    		// 数据类型 变量名 = 值;
    		
    		byte b = -128; // -128 ~ 127 （共计256个整数）>>> 超过取值范围会抛出异常
    		System.out.println(b);
    		
    		short s = -32768; // -32768 ~ 32767 （共计65536个整数）
    		System.out.println(s);
    		
    		int i = -2147483648; // -2147483648 ~ 2147483647 （共计42亿多个整数）
    		System.out.println(i);
    		
    		// Java中所有的“整数字面值”的默认类型是int，当整数字面值超过int的取值范围时，则提醒“过大的整数”
    		// 那么什么是整数字面值呢
    		// 如上面声明的变量中，等号右边的值即为字面值
    		long l = -9223372036854775808L; // 显示告知JVM，此值为long类型 -9223372036854775808 ~ 9223372036854775807
    		System.out.println(l);
    		
    	}
    }

![在这里插入图片描述][3f54969723384c4da69a8f0e78ab6481.png_pic_center]

`int`类型的取值范围包含`byte、short`，为什么还要有`byte`以及`short`呢？

因为内存是稀缺的，使用`byte`存得下的时候，用`byte`赋值时最合适的；

而又考虑到应用的高频性，我们不做太严格的区分，又或者说不做这样的内存节省，将来可以通过其他方式来进行优化和调整，也是可以将其这一块的内存节约出来；`int`类型比较常用；

### 3.2 基本数据类型（小数/浮点数） ###

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字节</th> 
   <th>负数取值范围</th> 
   <th>正数取值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>float</td> 
   <td>4字节</td> 
   <td>-3.4E+38 ~ -1.4E-45</td> 
   <td>1.4E-45 ~ 3.4E+38</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>8字节</td> 
   <td>-1.7E+308 ~ -4.9E-324</td> 
   <td>4.9E-324 ~ 1.7E+308</td> 
  </tr> 
 </tbody> 
</table>

*  浮点型数值采用科学计数法表示：
    
     *  2E3 等价于 2 \* 10 ^ 3（结果：2000.0）
     *  3E5 等价于 3 \* 10 ^ 5（结果：300000.0）

注意：`double`为浮点数的默认类型，如需为`float`类型赋值时，需要在值的后面追加“F”

举个例子：

/**
    	基本数据类型（小数/浮点数）
    */
    public class TestType2{
        
    	public static void main(String[] args){
        
    		
    		// float 单精度浮点型，double 双精度浮点型
    		
    		double d = 1.2;
    		System.out.println(d);
    		
    		double d2 = 1;
    		System.out.println(d2);
    		
    		float f = 1.5F; // 任何“小数字面值”默认类型都是double，如果要存储到float变量中，需显示追加“F”
    		System.out.println(f);
    		
    		// 科学计数法
    		double d3 = 2E3; // 2 * 10 ^ 3
    		System.out.println(d3);
    		
    		double d4 = 2E7; // 2 * 10 ^ 7 20000000.0
    		System.out.println(d4);
    		
    		float f2 = 5E4F; // 5 * 10 ^ 4 追加F代表float
    		System.out.println(f2);
    		
    		// 取值范围的差异
    		
    		// float正数取值范围：0.0000000000000000000000000000000000000000000014F ~ 340000000000000000000000000000000000000.0F
    		
    		float floatMin = 0.0000000000000000000000000000000000000000000014F;  // float的最小正数 小数点右边44个0
    		
    		float floatMax = 340000000000000000000000000000000000000.0F; // float的最大正数
    		
    		System.out.println(floatMin);
    		System.out.println(floatMax);
    		
    		// float负数取值范围：-340000000000000000000000000000000000000.0F ~ -0.0000000000000000000000000000000000000000000014F
    		
    		float floatMin2 = -340000000000000000000000000000000000000.0F; // 计数单位：个、十、百、千、万、亿、兆、京、垓、秭、穰、沟、涧、正、载、极、恒河沙、阿僧祇、那由他
    		
    		float floatMax2 = -0.0000000000000000000000000000000000000000000014F;
    		
    		System.out.println(floatMin2);
    		System.out.println(floatMax2);
    		
    		// double 正数取值范围
    		double doubleMin = 4.9E-324;
    		
    		double doubleMax = 1.7E308;
    		
    		System.out.println(doubleMin);
    		System.out.println(doubleMax);
    		
    		
    	}
    	
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

### 3.3 基本数据类型（布尔） ###

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字节</th> 
   <th>取值范围</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>boolean</td> 
   <td>1字节</td> 
   <td>true/false</td> 
   <td>仅可描述“真”或者“假”</td> 
  </tr> 
 </tbody> 
</table>

*  可直接赋值 `true` / `false`
 *  也可赋值一个结果为 `true` / `false` 的表达式
 *  注意：`Java`中的`boolean` 不能参与算数运算；

举个例子：

public class TestType3{
        
    	public static void main(String[] args){
        
    		
    		boolean b1 = true;
    		System.out.println(b1);
    		
    		boolean b2 = false;
    		System.out.println(b2);
    		
    		boolean b3 = 5 > 4;
    		System.out.println(b3);
    	}
    }

![在这里插入图片描述][3e89ae7a9f9d4ddfbaab1f8eb655fa99.png_pic_center]

### 3.4 基本数据类型（字符） ###

#### 3.4.1 ASCII 编码 ####

前置知识：

*  `ASCII`（American Standard Code for Information Interchange）美国信息交换标准代码
 *  基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言
 *  `ASCII`是最通用的信息交换标准，为英文字符设定了统一并且唯一的二进制编码

ASCII编码对照表：[http://ascii.911cha.com/][http_ascii.911cha.com]

#### 3.4.2 Unicode 编码 ####

前置知识：

*  `Unicode`（万国码）是计算机科学领域里的一项业界标准，包括字符集、编码方案
 *  它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求（其中包含了`ASCII`编码）

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

我们使用`jsons.cn`在线工具网站 `http://www.jsons.cn/unicode/` 转换一下：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]

#### 3.4.3 基本数据类型（字符） ####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>字节</th> 
   <th>取值范围</th> 
   <th>字符编码</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>char</td> 
   <td>2字节</td> 
   <td>0 ~ 65535</td> 
   <td>Unicode 字符集（万国码）</td> 
  </tr> 
 </tbody> 
</table>

*  `Unicode` 中每个字符都对应一个二进制整数，可以使用多种方式赋值
    
     *  字符赋值： `char c1 = 'A';` // 通过`''`描述为字符赋值
     *  整数赋值： `char c2 = 65;` // 通过十进制数65在字符集中对应的字符赋值
     *  进制赋值： `char c3 = '\u0041'` // 通过十六进制数41在字符集中所对应的字符赋值

举个例子：

public class TestType4{
        
    	public static void main(String[] args){
        
    		
    		char c1 = 'A'; // 字符赋值，原生、基本的赋值方式（常用）
    		System.out.println(c1);
    		
    		char c2 = 65; // 整数赋值（十进制）
    		System.out.println(c2);
    		
    		char c3 = '\u0041'; // 进制赋值（十六进制）
    		System.out.println(c3);
    	}
    }

![在这里插入图片描述][43b5579593ed417c9ac3ca0d2e111918.png_pic_center]

#### 3.4.4 转义字符 ####

如果需要在程序中输出一个单引号字符，该如何完成？

错误用法如下：

package demo;
    
    public class TestChar {
        
        public static void main(Stringp[] args){
        
            char c = ''';
        }
    }

编译以上的代码，将会抛出未结束的字符文字；

那么，为了解决这一问题，`java`采用了转义字符来表示单引号和一些特殊符号；

举个例子：

public class TestSign{
        
    	public static void main(String[] args){
        
    		
    		char c1 = '\'';
    		System.out.println(c1);
    		
    		System.out.println("\"");
    		
    		System.out.println("Hello\tWorld"); // \t 制表符
    		
    		System.out.println("Hello\nWorld"); // \n 换行符
    		
    		System.out.println("\\");
    		
    		System.out.println("u0041");
    		
    		System.out.println("\u0041"); // 加了 \ 即转换为十六进制
    	}
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]

### 3.5 引用数据类型（字符串） ###

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>取值范围</th> 
   <th>字符编码</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>String</td> 
   <td>任何 “” 之间的字面值</td> 
   <td>Unicode 字符序列</td> 
  </tr> 
 </tbody> 
</table>

*  String 类型的字面取值
    
     *  String str1 = “你好”;
     *  String str2 = “Hello”;
     *  String str3 = “测试架构师”;
     *  String str4 = “Test Engineer”;

举个例子：

public class TestString{
        
    	public static void main(String[] args){
        
    		
    		String str1 = "HelloWorld";
    		
    		System.out.println(str1);
    		System.out.println("HelloWorld");
    		
    		String str2 = "Hello Everyone";
    		
    		System.out.println(str2);
    	}
    }

![在这里插入图片描述][83bab5a310524f399988569a6f402952.png_pic_center]

## 4. 类型转换 ##

### 4.1 自动类型转换 ###

*  自动类型转换（满足以下两种条件，才会自动转换成功，编译通过）：
    
     *  两种类型相互兼容
     *  目标类型大于源类型

例如：

package demo;
    
    public class TestAutoConvert {
        
        public static void main(String[] args){
        
            short s = 123;
            int i = s;
        }
    }

举个例子：

public class TestAutoConvert{
        
    	
    	public static void main(String[] args){
        
    		
    		// 整数 >> 整数
    		
    		short s = 123;
    		
    		int i = s; // 将源类型值存入到目标类型变量中（自动类型转换）
    		
    		System.out.println(i);
    		
    		byte b = 100;
    		
    		short s2 = b; // 自动类型转换
    		
    		System.out.println(s2);
    		
    		// 小数 >> 小数
    		float f = 100.0F;
    		
    		double d = f;
    		
    		System.out.println(d);
    		
    		// 小数 >> 整数
    		
    		int i2 = 100;
    		
    		double d2 = i2;
    		
    		System.out.println(d2);
    		
    		
    		// 字符 >> 整数
    		
    		char c = 'A';
    		
    		int i3 = c; // 自动类型转换
    		
    		System.out.println(i3);
    		
    		
    		// 字符 >> 小数
    		
    		char c2 = 'a';
    		
    		double d3 = c2;
    		
    		System.out.println(d3);
    		
    		// boolean 无法与其他类型进行转换
    		
    		// boolean bool = true; // true|false
    		
    		// int i4 = bool; // 不兼容的类型
    	}
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]

### 4.2 强制类型转换 ###

*  强制类型转换
    
     *  两种类型相互兼容
     *  目标类型小于源类型

例如：

package demo;
    
    public class TestForceConvert {
        
        public static void main(String[] args){
        
            short s = 123;
            byte b = s; // 将一个较大的数据类型放进一个较小的数据类型，自动转换失败，编译错误
        }
    }

将一个较大的数据类型放进一个较小的数据类型，自动转换失败，编译错误，可以使用强制转换，代码如下：

package demo;
    
    public class TestForceConvert {
        
        public static void main(String[] args){
        
            short s = 123;
            byte b = (byte)s; //强制类型转换：(目标类型)值
        }
    }

*  强制类型转换规则：
    
     *  整数长度足够，数据完整
        
        例： int i = 100; byte b = (byte)i; // b =100
     *  整数长度不够，数据截断
        
        例：int i = 10000; byte b = (byte)i; // b = 16（符号位变化，可能变为负数）
     *  小数强转整数，数据截断
        
        例： double d = 2.5; int i = (int)d; // i = 2（小数位舍掉）
     *  字符整数互转，数据完整
        
        例：char c = 65; int i = c; // i = 65
     *  boolean 的取值为`true`/`false`，不可与其他类型转换

举个例子：

public class TestForceConvert {
        
        public static void main(String[] args){
        
    		
    		// 长度足够，数据完整
    		
            short s = 123;
    		
            byte b = (byte)s; //强制类型转换：(目标类型)值
    		
    		System.out.println(b);
    		
    		// 长度不够，数据截断
    		
    		short s2 = 257;
    		
    		byte b2 = (byte)s2; // 强制类型转换（数据截断）
    		
    		System.out.println(b2);
    		
    		short s3 = 130;
    		
    		byte b3 = (byte)s3;
    		
    		System.out.println(b3);
    		
    		// 小数 强转 整数
    		
    		double d = 2.999;
    		
    		int i = (int)d;
    		
    		System.out.println(i);
    		
    		// 字符 强转 整数
    		
    		char c = 'A';
    		
    		int i2 = c; // 自动类型转换
    		
    		System.out.println(i2);
    		
    		char c2 = (char)i2; // 强制类型转换
    		
    		System.out.println(c2);
    		
    		// 字符与整数转换的注意事项
    		
    		short s4 = 97; // 两个字节的存储空间 取值范围 -32768 ~ 32767
    		
    		char c3 = (char)s4; // 强制类型转换
    		
    		System.out.println(c3);
    		
    		// 当我们把一个整数强转为一个char类型时，如果希望它可以正常呈现出字符内容，一定要保证它的整数是一个正数，它才能在我们的ASCII或者Unicode编码当中查找到对应的字符，并且保存在char的变量中加以正确的呈现
    		
    		short s5 = -1; // 它（-1）在ASCII编码中没有对应的字符，呈现出来的内容将会被替代为问号（无法识别）
    		
    		
    		char c4 = (char)s5; 
    		
    		System.out.println(c4);
    		
    		
    		
        }
    }

打开`cmd`并编译运行：

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]

如上图，`b2`和`b3` 的值经过强制类型转换之后，为什么会变成`1` 和 `-126`呢？

根据一个十进制数的组成写出其二进制，一个32位系统低八位的值分别是128,64,32,16,8,4,2,1.从大往小选择，选择可以组成该数的数字，相应的位置上写1，其余位全为0；

在我们的二进制表现形式上，每个格子下，如果有1的话，就意味着是有这个值（格子里面的值）的，如果每个值相加等于的就是我们现在的二进制的表现形式的整数；

符号位>> 0：代表正数；1：代表负数

`short`类型的`257` 强制转换为`byte`类型，由于长度不够，发生高位截断（保留128、64、32、16、8、4、2、1），因为截断之后的符号位为0，所以结果为正数1；

`short`类型的`130` 强制转换为`byte`类型，由于长度不够，发生高位截断（保留128、64、32、16、8、4、2、1），因为截断之后的符号位为1，所以结果为正数-126；

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]

字符与整数转换的注意事项：

当我们把一个整数强转为一个`char`类型时，如果希望它可以正常呈现出字符内容，一定要保证它的整数是一个正数，它才能在我们的`ASCII`或者`Unicode`编码当中查找到对应的字符，并且保存在`char`的变量中加以正确的呈现；如果`char`类型的变量接收的整数为负数，在`ASCII`编码中没有对应的字符，呈现出来的内容将会被替代为问号（无法识别）；

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: /images/20220829/dd0513bd0e904e86893368d80e000162.png
[e608246813cc457cb11d69f52bed0b94.png_pic_center]: /images/20220829/41a0b9408d664e33b42391336104af5a.png
[5a5781e0ecdb48c69f2ccf0bbcd7feb8.png_pic_center]: /images/20220829/d6c5172af54f41fda5d82818aa052fdb.png
[3f54969723384c4da69a8f0e78ab6481.png_pic_center]: /images/20220829/9b0d690140624c7a8843fdb1fe882195.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: /images/20220829/c54bad30b5ba4d0b880e1ad32e7a6b7b.png
[3e89ae7a9f9d4ddfbaab1f8eb655fa99.png_pic_center]: /images/20220829/1f6be580571040d1b207ae29a8259bba.png
[http_ascii.911cha.com]: http://ascii.911cha.com/
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: /images/20220829/cba7e3dabb9248faafd7b3036ea9b8f0.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: /images/20220829/006e72cbaada4c1f88ccb4ed174d0787.png
[43b5579593ed417c9ac3ca0d2e111918.png_pic_center]: /images/20220829/a17477f67a4f4ed3bbad90c71b4ba5dc.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]: /images/20220829/9ee86c9a95234f84bae4b52be65ef949.png
[83bab5a310524f399988569a6f402952.png_pic_center]: /images/20220829/c729c7f9dd4b4ec19afa5bf24ae78181.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]: /images/20220829/e63094989c0d4df6894b3215c5888d86.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]: /images/20220829/7c1b97c75e8c43febce00c01bba14059.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASW1vYnM_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]: /images/20220829/edd09c497ad046d7bdbe9e9cde029c0d.png