java基础 -- 开篇简介

悠悠 2024-04-18 10:48 73阅读 0赞

### 基础 ###

*   *  java的语言入门
     *   *   *  java特点
             *  java的历史
             *  Java SE
     *  关于java开发环境的配置
     *   *   *  windows系统安装java环境
             *  环境变量配置
             *  测试JDK是否安装成功
             *  下载IDEA
     *  java基础 -- java实例程序
     *   *   *  前提知识补充必要理解
             *   *  基本数据类型：
             *  引用数据类型：
             *  访问修饰符
             *  非访问修饰符
             *  类与类之间的关键字
             *  java运算符
     *  实例小程序创建
     *   *   *  创建java工程
             *  选择jdk路径
             *  创建
             *  运行
             *  编码规范
     *  java基础 -- java 运行过程及跨平台原理，JDK,JVM,JRE区别
     *   *   *  Java为什么可以跨平台
             *  执行过程
             *  JDK,JVM,JRE区别
     *  java基础 -- 流程控制语句
     *   *   *  if 语句
             *  if-else 语句
             *  多条件 if-else-if 语句
             *  嵌套 if 的使用
     *  switch
     *   *   *  switch case
     *  实例代码
     *   *   *  区别
             *   *  switch实现计算星座功能
                 *  if-else 实现计算星座功能
     *  Java 基础 -- for循环，while循环
     *   *   *  For循环
             *  内嵌for循环
     *  While 循环
     *  do-while 语句
     *  补充说明 return break continue
     *  在这里插入图片描述
     *  break 和 continue
     *  总结
     *  前言
     *   *  关于变量
         *   *  关于内置数据类型
             *  关于引用数据类型
             *  \*\*java定义的常量\*\*
             *  类型之间的转换
     *  类装载器 ClassLoader
     *  前言
     *  正文
     *  代码部分
     *  前言
     *   *   *   *  \*\*关于线程的实现方法\*\*
                 *  关于基础线程机制方法

## java的语言入门 ##

> #### java特点 ####

`面向对象：`

*  与c++相比，java是纯面向对象的语言
 *  C++为了向下兼容C，保留了很多C里面的特性，而C，就是面向过程的语言，所有C++就成了一个混血儿；而JAVA语法在创建的时候考虑到这个问题，取消了C++里面对C的特性，比如取消了，结构，单元，指针等；所以JAVA就是一个纯面向对象的语言；

`可移植性`

*  与其他变成语言不同，JAVA 并生成可执行文件也就是。exe文件，而是生成一种中间字节码文件也就是。class文件
 *  这种文件，只需要又JVM虚拟机，就可以编译成java文件。所以只要机器可以安装虚拟机，就可以执行.class文件。
 *  所以java文件，可以在各个平台运行好比，以前开发程序都是生成文件，开始运行。现在是有一个平台运行，解耦了原始数据存储方式固定，避开移植时候的问题
 *  java的原始数据类型，大小都是固定的，比如，在任何机器上，整型都是32位，而C++里面的整型是依赖于目标机器的

`简单`

*  JAVA在语法上面与C++类似
 *  JAVA语法跟C++语法很接近，玩过C的知道，C++设计有点复杂，为了保留自身的特性，他没有设计一个根类，所以C++是可以多重继承的，多重继承有时候会使编译器非常复杂，并且效率也不是很高。而Java当时在设计的时候，为了简单方便，只允许一个根类，而用接口技术来实习C++的多重继承类似功能更加便于理解和实现

`多线程`

*  强大的多线程能力
 *  多线程可以使程序更好的交互和实时，并最大限度的利用多处理器系统，java有着强大的多线程能力，因为各个主流操作系统平台在多线程的实施方面有重大差异，所以java为不同的操作系统实现了专门的多线程机制

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

> #### java的历史 ####

*  1995 年本命年，java首次亮相，所以说java跟我还是有缘分的，95大会上，一种全新的浏览器，作为小型计算机语言，用于消费类的设备，比如电视机交换盒子等上面的编程语言出现，标志了java的诞生
 *  1996 年，Netscape对于java的支持后来陆续公司的加入支持，sun第一个版本java 1.02 。标志了开始流行
 *  1998 年，java1.2问世，它开始脱离局限小型程序的设计，功能更全面，扩展性更高。java正式进入被人们熟悉；

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

> #### Java SE ####

Java 发展至今， 可分为 3 个体系，即 Java SE、Java EE 和 Java ME。常用的为JavaSe标准版

Java SE（Java Platform Standard Edition，Java 平台标准版）以前称为 J2SE，它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java EE 提供基础，如 Java 语言基础、JDBC 操作、I/O 操作、网络通信以及多线程等技术

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

## 关于java开发环境的配置 ##

环境配置分为两种

*  windows上面安装开发环境
 *  Linux 上面安装开发环境

> #### windows系统安装java环境 ####

下载JDK

下载地址[.http://www.oracle.com/technetwork/java/javase/downloads/index.html  
][.http_www.oracle.com_technetwork_java_javase_downloads_index.html]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 1]  
这个是java12版本的，以往版本进行下拉，个人使用jdk8版本的，目前8版本的使用比较多，也比较稳定，因人而异

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 9]  
选择允许许可，选择64位的下载，下载完成后，允许就安装好了

JDK8以上的版本不需要配置环境变量，如果8版本以下的就需要配置环境变量

bin：提供 JDK 工具程序，包括 javac、java、javadoc、appletviewer 等可执行程序。
    	include：存放用于本地访问的文件。
    	jre：存放 Java 运行环境文件。
    	lib：存放 Java 的类库文件，工具程序实际上使用的是 Java 类库。JDK 中的工具程序，大多也由 Java 编写而成。
    	src.zip：Java 提供的 API 类的源代码压缩文件。如果需要查看 API 的某些功能是如何实现的，可以査看这个文件中的源代码内容。

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

> #### 环境变量配置 ####

计算机右击点击系统属性。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][20191113143837937.png]  
![在这里插入图片描述][20191113143843458.png]

> 变量名：JAVA\_HOME  
> 变量值：C:\\Program Files (x86)\\Java\\jdk1.8.0\_91  
> 要根据自己的实际路径配置,默认安装就是这个地址

> 变量名：CLASSPATH  
> 变量值：.;%JAVA\_HOME%\\lib\\dt.jar;%JAVA\_HOME%\\lib\\tools.jar; //记得前面有个"."

> 变量名：Path  
> 变量值：%JAVA\_HOME%\\bin;%JAVA\_HOME%\\jre\\bin;

1.  系统变量新建添加 JAVA\_HOME
2.  系统变量新建添加CLASSPATH
3.  找到系统变量Path，修改Path，前面加上变量值保存
4.  变量配置结束

> #### 测试JDK是否安装成功 ####

*  启动cmd

输入 java -version java 或者javac编译 如果有反应不报错，就说明配置成功了

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

> #### 下载IDEA ####

[IntelliJ IDEA 官网][IntelliJ IDEA].

## java基础 – java实例程序 ##

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

> #### 前提知识补充必要理解 ####

*  关键字 `public`： 表示访问说明符，表明该类是一个公共类，可以控制其他对象对类成员的访问。
 *  关键字 `class`： 用于声明一个类，其后所跟的字符串是类的名称。
 *  关键字`static`： 表示该方法是一个静态方法，允许调用 main() 方法，无须创建类的实例。
 *  关键字 `void`：表示 main() 方法没有返回值。
 *  `main()` ： 方法是所有程序的入口，最先开始执行。
 *  `“/*”` `*/”` ：之间的内容和以“//”开始的内容为 Java 程序的注释。
 *  `System.out.println("Hello World!");` `System.out.println（）`为输出方法 " “表示一个字符串对象。 意思是 系统输出括号， 字符串 hello world 如果是数字不需要加” "

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

> ##### 基本数据类型： #####

*  `byte`: 1个字节 8位最大值: 127 (有符号)
 *  `short`: 2个字节 16位 32767
 *  `int` : 4个字节 32位 2147483647
 *  `long`: 8个字节 64位 9223372036854775807
 *  `float`: 4个字节 32位 3.4028235E38
 *  `double`:8个字节 64位 1.7976931348623157E308

基本数据转换伐值为int 都放在int 转换，数据类型计算的时候，有时候会需要向上，向下转换。使用时建议使用赋值运算。

类型转换分为强制类型转换和隐式类型转换。

比如int a = Byte.MAX\_VALUE + 1; //隐式转换

*  `byte a = (byte) (Byte.MAX_VALUE + 1)`;//强制转换

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

> #### 引用数据类型： ####

*  `class` 类
 *  `interface` 接口
 *  数组\[ \]

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

> #### 访问修饰符 ####

*  `default` :(即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
 *  `private` : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
 *  `public` : 对所有类可见。使用对象：类、接口、变量、方法
 *  `protected` : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

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

> #### 非访问修饰符 ####

*  `static` 修饰符，用来修饰类方法和类变量表示成为公共资源。
 *  `final`修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
 *  `abstract`修饰符，用来创建抽象类和抽象方法。
 *  `synchronized` 修饰符，主要用于线程的编程。

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

> #### 类与类之间的关键字 ####

*  `implements` 实现一个借口
 *  `extends` 继承一个类

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

> #### java运算符 ####

算术运算符

public class Test { 
     
      public static void main(String[] args) { 
         int a = 10;
         int b = 20;
         int c = 25;
         int d = 25;
         System.out.println("a + b = " + (a + b) );
         System.out.println("a - b = " + (a - b) );
         System.out.println("a * b = " + (a * b) );
         System.out.println("b / a = " + (b / a) );
         System.out.println("b % a = " + (b % a) );
         System.out.println("c % a = " + (c % a) );
         System.out.println("a++ = " +  (a++) );
         System.out.println("a-- = " +  (a--) );
         // 查看 d++ 与 ++d 的不同
         System.out.println("d++ = " +  (d++) );
         System.out.println("++d = " +  (++d) );
      }
    }

自增自减运算符

public class selfAddMinus{ 
        public static void main(String[] args){ 
            int a = 3;//定义一个变量；
            int b = ++a;//自增运算
            int c = 3;
            int d = --c;//自减运算
            System.out.println("进行自增运算后的值等于"+b);
            System.out.println("进行自减运算后的值等于"+d);
    
    // int b = ++a; 拆分运算过程为: a=a+1=4; b=a=4, 最后结果为b=4,a=4
    
    // int d = --c; 拆分运算过程为: c=c-1=2; d=c=2, 最后结果为d=2,c=2
        }
    }

关系运算符

public class Test { 
     
      public static void main(String[] args) { 
         int a = 10;
         int b = 20;
         System.out.println("a == b = " + (a == b) );
         System.out.println("a != b = " + (a != b) );
         System.out.println("a > b = " + (a > b) );
         System.out.println("a < b = " + (a < b) );
         System.out.println("b >= a = " + (b >= a) );
         System.out.println("b <= a = " + (b <= a) );
      }
    }

位运算符

public class Test { 
      public static void main(String[] args) { 
         int a = 60; /* 60 = 0011 1100 */ 
         int b = 13; /* 13 = 0000 1101 */
         int c = 0;
         c = a & b;       /* 12 = 0000 1100 */
         System.out.println("a & b = " + c );
     
         c = a | b;       /* 61 = 0011 1101 */
         System.out.println("a | b = " + c );
     
         c = a ^ b;       /* 49 = 0011 0001 */
         System.out.println("a ^ b = " + c );
     
         c = ~a;          /*-61 = 1100 0011 */
         System.out.println("~a = " + c );
     
         c = a << 2;     /* 240 = 1111 0000 */
         System.out.println("a << 2 = " + c );
     
         c = a >> 2;     /* 15 = 1111 */
         System.out.println("a >> 2 = " + c );
      
         c = a >>> 2;     /* 15 = 0000 1111 */
         System.out.println("a >>> 2 = " + c );
      }
    }

逻辑运算符

public class Test { 
      public static void main(String[] args) { 
         boolean a = true;
         boolean b = false;
         System.out.println("a && b = " + (a&&b));
         System.out.println("a || b = " + (a||b) );
         System.out.println("!(a && b) = " + !(a && b));
    // &&称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。
    // | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。
    // ！称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。
    }
    
    }

赋值运算符

public class Test { 
        public static void main(String[] args) { 
            int a = 10;
            int b = 20;
            int c = 0;
            c = a + b;
            System.out.println("c = a + b = " + c );
            c += a ;
            System.out.println("c += a = " + c );
            c -= a ;
            System.out.println("c -= a = " + c );
            c *= a ;
            System.out.println("c *= a = " + c );
            a = 10;
            c = 15;
            c /= a ;
            System.out.println("c /= a = " + c );
            a = 10;
            c = 15;
            c %= a ;
            System.out.println("c %= a = " + c );
            c <<= 2 ;
            System.out.println("c <<= 2 = " + c );
            c >>= 2 ;
            System.out.println("c >>= 2 = " + c );
            c >>= 2 ;
            System.out.println("c >>= 2 = " + c );
            c &= a ;
            System.out.println("c &= a = " + c );
            c ^= a ;
            System.out.println("c ^= a = " + c );
            c |= a ;
            System.out.println("c |= a = " + c );
        }
    }

三目运算符

public class Test { 
       public static void main(String[] args){ 
          int a , b;
          a = 10;
          // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
          b = (a == 1) ? 20 : 30;
          System.out.println( "Value of b is : " +  b );
     
          // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
          b = (a == 10) ? 20 : 30;
          System.out.println( "Value of b is : " + b );
       }
    }

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

## 实例小程序创建 ##

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

> #### 创建java工程 ####

![在这里插入图片描述][2019111315183292.png]

> #### 选择jdk路径 ####

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

> #### 创建 ####

![选择jdk路径][jdk]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][20191113152138387.png]

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

> #### 运行 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 17]  
打印台输出结果

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

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

> #### 编码规范 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 19]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 20]

*  包的名称由一个小写字母序列组成。
 *  类的名称由大写字母开头，其他字母都由小写的单词组成。
 *  类的实例的名称由一个小写字母开头，后面的单词由大写字母开头。
 *  常量的名称都大写，并且指出完整含义。
 *  参数的名称无其他具体规定。
 *  数组的命名使用“类型 `[]` 数组名”的形式。
 *  另外，编码格式规定如下。  
    程序最开始编写导入包和类语句，即 `import`语句。`import`语句可以有多行，编写完 `import` 语句后空一行。
 *  定义`public` 类，顶格书写。类的主体左括号`{`不换行书写，右括号`}`顶格书写。
 *  定义`public`类中的变量，缩进书写。  
    定义方法用缩进书写，方法的左括号`{`不换行书写，右括号`}`和方法首行第一个字符对齐。方法体要再次缩进书写，最后一个变量定义和第一个方法定义之间、方法和方法之间最好空一行。
 *  提示：在单一的语句后有“;”，在一对括号`{}`之外无`;`。方法调用名和紧跟在其后的左括号`(`无空格，该左括号和其后的标识符之间无空格。多个参数之间的逗号和前一个参数紧靠，与后一个参数空一格。

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

## java基础 – java 运行过程及跨平台原理，JDK,JVM,JRE区别 ##

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

`编写期`： 是指在 Java 开发环境中进行程序代码的输入，最终形成后缀名为 `.java`的`Java` 源文件。

`编译期`： 是指使用 Java 编译器对源文件进行错误排査的过程，编译后将生成后缀名为`.class`的字节码文件

`运行`： 是指使用 `Java` 解释器将字节码文件翻译成机器代码，执行并在控制台显示结果。

一般idea创建的均为`.java`文件，在运行的时候自动编译为`.class`文件。并通过解释器翻译为机器代码，显示出来

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

> #### Java为什么可以跨平台 ####

java代码编写后后缀.java文件，如果运行，是需要进行编译的，编译为字节码文件 .class，而字节码文件是一种和任何具体机器环境及操作系统环境无关的中间代码。二进制文件。

大致如下图所示

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 22]  
这种代码一般机器和编程人员无法直接读懂，所以java提供了开发环境，虚拟机，以及运行环境。`统称为JDK`

它必须由专用的 Java 解释器来解释执行，Java 解释器负责将字节码文件翻译成具体硬件环境和操作系统平台下的机器代码，以便执行。因此 Java 程序不能直接运行在现有的操作系统平台上，它必须运行在被称为 Java 虚拟机的软件平台之上。Java 虚拟机`（JVM）`是运行 Java 程序的软件环境`（JRE）`开发环境`(JDK)`，

> #### 执行过程 ####

*  首先会启动`JVM，`
 *  然后编译为`.class`文件
 *  然后进行解释器，解释运行输出结果到控制台。

由于 Java 字节码程序只能运行于 `JVM`之上。这样利用`JVM` 就可以把`Java` 字节码程序和具体的硬件平台以及操作系统环境分隔开来。

只要在不同的计算机上安装了针对特定平台的 `JVM`，`Java` 程序就可以运行，而不用考虑当前具体的硬件平台及操作系统环境，也不用考虑字节码文件是在何种平台上生成的。

后面会根据虚拟机编译问题会涉及到类序列化，也就是文件编译为二进制，再编译到文件先提一下。

`所以总结为，只要安装了虚拟机和虚拟机运行环境，就可以去运行java文件。不管在什么环境上面，只需要又这个java服务支持就可以执行，实现了java的跨平台根本`

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

> #### JDK,JVM,JRE区别 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 23]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 24]

`JDK`=`JRE`\+多种Java开发工具

`JRE`=`JVM`\+各种类库

这三者的关系是一层层的嵌套关系。`JDK`>`JRE`>`JVM`

`综合所述，只需要安装JDK 便包含了JRE及虚拟机`

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

## java基础 – 流程控制语句 ##

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

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

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

> #### if 语句 ####

if (条件表达式) { 
        语句块;
    }

![在这里插入图片描述][20191114161906495.png]

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

public static void main(String[] args) { 
        System.out.println("请输入一个数字：");
        Scanner input = new Scanner(System.in);
        int num = input.nextInt(); // 接收键盘输入数据
        // 判断用户输入的数据是否大于100
        if (num > 100) { 
            System.out.println("输入的数字大于100");
        }
        // 判断用户输入的数据是否等于100
        if (num == 100) { 
            System.out.println("输入的数字等于100");
        }
        // 判断用户输入的数据是否小于100
        if (num < 100) { 
            System.out.println("输入的数字小于100");
        }
    }

public static void main(String[] args) { 
        int num1 = 50;
        int num2 = 34;
        if (num1 > num2) { 
            System.out.println("num1大于num2");
        }
        if (num1 == num2) { 
            System.out.println("num2等于num2");
        }
        if (num1 < num2) { 
            System.out.println("num1小于num2");
        }
    }

public static void main(String[] args) { 
        String username = "admin"; // 用户名
        String userpass = "123456"; // 密码
        String code = "0000"; // 验证码
        if (username != "admin" && userpass != "123456" && code != "0000") { 
            System.out.println("登录失败！");
            System.out.println("异常！");
        }
    }

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

> #### if-else 语句 ####

if (表达式) { 
        语句块1;
    } else { 
        语句块2;
    }

执行流程

![在这里插入图片描述][20191114162636463.png]

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

代码演示

public static void main(String[] args) { 
        int num1 = 50;
        int num2 = 34;
        // 如果num1等于num2
        if (num1 == num2) { 
            System.out.println("num1等于num2");
        }
        // 如果num1大于num2
        if (num1 > num2) { 
            System.out.println("num1大于num2");
        } else { 
            // 否则就是num1小于num2
            System.out.println("num1小于num2");
        }
    }

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

> #### 多条件 if-else-if 语句 ####

if(表达式1) { 
        语句块1;
    } else if(表达式2) { 
        语句块2;
    ...
    } else if(表达式n) { 
        语句块n;
    } else { 
        语句块n+1;
    }

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

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

public static void main(String[] args) { 
        int num1 = 50;
        int num2 = 34;
        if (num1 == num2) {  // 如果num1等于num2
            System.out.println("num1等于num2");
        } else if (num1 > num2) {  // 如果num1大于num2
            System.out.println("num1大于num2");
        } else {  // 否则就是小于
            System.out.println("num1小于num2");
        }
    }

public static void main(String[] args) { 
        System.out.println("请输入考试成绩：");
        Scanner input = new Scanner(System.in);
        int score = input.nextInt(); // 接收键盘输入数据
        if (score >= 90) {  // 考试成绩>=90
            System.out.println("优秀");
        } else if (score >= 80) {  // 90>考试成绩>=80
            System.out.println("良好");
        } else if (score >= 60) {  // 80>考试成绩>=60
            System.out.println("中等");
        } else {  // 考试成绩<60
            System.out.println("差");
        }
    }

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

> #### 嵌套 if 的使用 ####

if(表达式1) { 
        if(表达式2) { 
            语句块1;
        } else { 
            语句块2;
        }
    } else { 
        if(表达式3) { 
            语句块3;
        } else if(表达式4) { 
            语句块4;
        } else { 
            if(表达式n) { 
                语句块n;
            } else { 
                语句块n+1;
            }
        }
    }

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

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

public static void main(String[] args) { 
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入出行的月份：");
            int month = sc.nextInt();
            System.out.println("选择头等舱还是经济舱？数字1为头等舱，数字2为经济舱");
            int kind = sc.nextInt();
            double result = 60000; // 原始价格
            // 旺季的票价计算
            if (month <= 11 && month >= 4) { 
                if (kind == 1) {  // 旺季头等舱
                    result = result * 0.9;
                } else if (kind == 2) {  // 旺季经济舱
                    result = result * 0.8;
                } else { 
                    System.out.println("选择种类有误，请重新输入！");
                }
            }
            // 淡季的票价计算
            else if ((month >= 1 && month <= 3) || month == 12) { 
                if (kind == 1) {  // 淡季头等舱
                    result = result * 0.5;
                } else if (kind == 2) {  // 淡季经济舱
                    result = result * 0.4;
                } else { 
                    System.out.println("选择种类有误，请重新输入！");
                }
            } else { 
                System.out.println("日期选择有误，请重新输入！");
            }
            System.out.println("您选择的机票价格为：" + result);
        }
    }

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

## switch ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 30]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 31]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 32]

> #### switch case ####

switch(表达式) { 
        case 值1:
            语句块1;
            break;
        case 值2:
            语句块2;
            break;
        …
        case 值n:
            语句块n;
            break;
        default:
            语句块n+1;
        break;
    }

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

## 实例代码 ##

public static void main(String[] args) { 
        System.out.println("请输入座位号码：");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        switch (num) { 
        case 8:
            System.out.println("恭喜你，获得了三等奖！");
            break;
        case 88:
            System.out.println("恭喜你，获得了二等奖！");
            break;
        case 888:
            System.out.println("恭喜你，获得了一等奖！");
            break;
        default:
            System.out.println("谢谢参与！");
            break;
        }
    }

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

> #### 区别 ####

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

##### switch实现计算星座功能 #####

public static void main(String[] args) { 
        System.out.println("请输入您的出生年月（如 0123 表示 1 月 23 日）：");
        Scanner sc = new Scanner(System.in);
        int monthday = sc.nextInt();
        int month = monthday/100;
        int day = monthday%100;
        String xingzuo = "";
        switch (month) { 
    　　    case 1:
                xingzuo = day<21?"摩羯座":"水瓶座";
                break;
    　　    case 2:
                xingzuo = day<20? "水瓶座":"双鱼座";
                break;
    　　    case 3:
                xingzuo = day<21?"双鱼座":"白羊座";
                break;
    　　    case 4:
                xingzuo = day<21?"白羊座":"金牛座";
                break;
            case 5:
                xingzuo = day<22?"金牛座":"双子座";
                break;
    　　    case 6:
                xingzuo = day<22?"双子座":"巨蟹座";
                break;
    　　    case 7:
                xingzuo = day<23?"巨蟹座":"狮子座";
                break;
    　　    case 8:
                xingzuo = day<24?"狮子座":"处女座";
                break;
    　　    case 9:
                xingzuo = day<24?"处女座":"天秤座";
                break;
    　　    case 10:
                xingzuo = day<24?"天秤座":"天蝎座";
                break;
    　　    case 11:
                xingzuo = day<23?"天蝎座":"射手座";
                break;
    　　    case 12:
                xingzuo = day<22?"射手座":"摩羯座";
                break;
        }
        System.out.println("您的星座是：" +xingzuo);
    }

##### if-else 实现计算星座功能 #####

public static void main(String[] args) { 
        System.out.println("请输入您的出生年月（如 0123 表示 1 月 23 日）：");
        Scanner sc = new Scanner(System.in);
        int monthday = sc.nextInt();
        int month = monthday / 100;
        int day = monthday % 100;
        String xingzuo = "";
    
        if (month == 1) { 
            if (day < 21) { 
                xingzuo = "摩羯座";
            } else { 
                xingzuo = "水瓶座";
            }
        } else if (month == 2) { 
            if (day < 20) { 
                xingzuo = "水瓶座";
            } else { 
                xingzuo = "双鱼座";
            }
        } else if (month == 3) { 
            if (day < 21) { 
                xingzuo = "双鱼座";
            } else { 
                xingzuo = "白羊座";
            }
        } else if (month == 4) { 
            if (day < 21) { 
                xingzuo = "白羊座";
            } else { 
                xingzuo = "金牛座";
            }
        } else if (month == 5) { 
            if (day < 22) { 
                xingzuo = "金牛座";
            } else { 
                xingzuo = "双子座";
            }
        } else if (month == 6) { 
            if (day < 22) { 
                xingzuo = "双子座";
            } else { 
                xingzuo = "巨蟹座";
            }
        } else if (month == 7) { 
            if (day < 23) { 
                xingzuo = "巨蟹座";
            } else { 
                xingzuo = "狮子座";
            }
        } else if (month == 8) { 
            if (day < 24) { 
                xingzuo = "狮子座";
            } else { 
                xingzuo = "处女座";
            }
        } else if (month == 9) { 
            if (day < 24) { 
                xingzuo = "处女座";
            } else { 
                xingzuo = "天秤座";
            }
        } else if (month == 10) { 
            if (day < 24) { 
                xingzuo = "天秤座";
            } else { 
                xingzuo = "天蝎座";
            }
        } else if (month == 11) { 
            if (day < 23) { 
                xingzuo = "天蝎座";
            } else { 
                xingzuo = "射手座";
            }
        } else if (month == 12) { 
            if (day < 22) { 
                xingzuo = "射手座";
            } else { 
                xingzuo = "摩羯座";
            }
        }
        System.out.println("您的星座是：" + xingzuo);
    }

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

综合上诉，效率方面Switch显得要快一些，但是从实用性来说 如果否则，相对来说更加语义通用

## Java 基础 – for循环，while循环 ##

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

> #### For循环 ####

for 语句是一种在程序执行前就要先判断条件表达式是否为真的循环语句。假如条件表达式的结果为假，那么它的循环语句根本不会执行。如果为真执行代码块里面的语句

for(条件表达式1;条件表达式2;条件表达式3)
    { 
    //语句块;
    }

![Alt][]

![Alt][Alt 1]

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

public static void main(String[] args)
    { 
    int result=1;
    for(int i=1;i<=5;i++)
    { 
    result=i;
    System.out.print("当前i为："+result);   
    }
    
    }

流程执行，定义变量int数字类型，为1 ，进入循环为true，i小与5执行赋值，输出赋值结果

public static void main(String[] args)
    { 
    
    int i = 5;
    
    for(int result=1;;result<=i;result++)
    { 
    
    System.out.print("当前reult为："+result);   
    }
    
    }

流程执行，定义变量int数字类型，i为1 ，进入循环判断语句，定义result=1，rusult，int类型变量是否小于i，为true，执行，执行一次result++ 自增加一，输出结果。

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

> #### 内嵌for循环 ####

for(条件表达式1;条件表达式2;条件表达式3)
    	{ 
    			for(条件表达式1;条件表达式2;条件表达式3)
    			{ 
    					//语句块;
    		}
    		//语句块
    }

![Alt][Alt 2]

public static void main(String[] args)
    { 
    
    int i = 5;
    
    for(int result=1;result<=i;result++)
    { 
    for（int b =2;b<=result;b++{ 
    System.out.print("当前reult为："+result);   
    }
    System.out.print("不输出");   
    }
    
    }

流程执行，  
定义i为5int类型，  
进入循环，  
判断语句，  
定义result为1，  
result小于5为true，  
进入循环体，  
循环体里面  
内嵌了衣蛾循环，  
定义b为2int类型，  
b是否小鱼result。  
不小于为false。  
执行下面system.out.print 输出为不输出

流程执行而，  
result自增为2.进入循环体，  
循环体，  
b为2，  
为true执行，  
输出当前result=2。  
循环b++为3，  
3不小于2，  
为false，  
继续向下执行，  
执行系统system打印、  
输出 ：不输出

public static void main(String[] args) { 
        System.out.println("乘法口诀表：");
        // 外层循环
        for (int i = 1; i <= 9; i++) { 
            // 内层循环
            for (int j = 1; j <= i; j++) { 
                System.out.print(j + "*" + i + "=" + j * i + "\t");
            }
            System.out.println();
        }
    }

这一块可能有一些不理解，简单一点就是，循环外层进入，是否满足循环内层，满足后一直循环内层结束，再出来循环外层，再看是否满足循环内层，满足循环内成一直循环到不满足。周而复始到外层循环结束；

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

## While 循环 ##

while 语句是 Java 最基本的循环语句，是一种先判断的循环结构，可以在一定条件下重复执行一段代码。该语句需要判断一个测试条件，如果该条件为真，则执行循环语句（循环语句可以是一条或多条），否则跳出循环。

while(条件表达式) {
        语句块;
    }

![Alt][Alt 3]

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

public static void main(String[] args) { 
        int i = 1;
        int n = 1;
        while(i <= 10) { 
            n=n*i;
            i++;
        }
        System.out.println("10的阶乘结果为："+n);
    }
    
    10 的阶乘结果为：3628800

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

## do-while 语句 ##

先执行一次然后再判断 while 后面的条件表达式是否为 true，如果循环条件满足，循环继续执行，否则退出循环。while 语句后必须以分号表示循环结

格式

do {
        语句块;
    }while(条件表达式);

![在这里插入图片描述][20191115164755318.png]

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

public static void main(String[] args) { 
        int number = 10000,result = 10000;
        do { 
            result*=number;
            number++;
        }while(number <= 10);
        System.out.print("10阶乘结果是："+result);
    }
    
    10阶乘结果是：1874919424

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

## 补充说明 return break continue ##

所有的代码都是从上到下一行一行执行的

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 33]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 34]  
从图上可以看到，代码是从上到下一行一行执行；

但是java只有一个主方法，也就是main方法，是代码执行的入口。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 35]  
Void 是返回值，英文意思是空。 static上文已经说过是修饰符静态公有的。public是访问修饰符，公开的本项目都可以访问。  
![Alt][Alt 4]  
![Alt][Alt 5]  
代码是在方法里面运行的，如果返回值为空，void那么return默认是不写的。

所以return的意思是返回。返回一个东西。返回对象，返回值返回空就不需要写。

for (int i = 0; i < 5; i++) { 
                System.out.println("外循环进来了这是第" + i + "次");
                if (i == 2) { 
                    return;
                }
                System.out.println("外循环我执行结束了，执行了" + i);
    
            }
    
        }

## ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 36] ##

**return 总结**

所以不管你是在循环也好，判断语句也好，只要用了return程序就要返回出去。程序也就停止了；

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

## break 和 continue ##

**必要理解：** 在循环体内，如果要想对于本次循环在某一个地方跳过向下执行，使用continue，如果是跳出当前这个循环使用 break

public class dasd { 
    
        public static void main(String[] args) { 
    
    
            for (int i = 0; i < 5; i++) { 
                System.out.println("外循环进来了这是第"+i+"次");
                for (int j = 0; j <5 ; j++) { 
                    System.out.println("我是内循环进来了这是第"+j+"次");
                       if (j==2){ 
                           System.out.println("我是内循环我跳出了不执行了");
                           break;
                       }
                    System.out.println("我是内循环我执行结束了，执行了"+j);
    
                }
                System.out.println("外循环我执行结束了，执行了"+i);
    
            }
    
        }
    
    
    }

public static void main(String[] args) { 
        Scanner input = new Scanner(System.in); // 定义变量存储小明的回答
        String answer = ""; // 一圈100米，1000米为10圈，即为循环的次数
        for (int i = 0; i < 10; i++) { 
            System.out.println("跑的是第" + (i + 1) + "圈");
            System.out.println("还能坚持吗？"); // 获取小明的回答
            answer = input.next(); // 判断小明的回答是否为y？如果不是，则放弃，跳出循环
            if (!answer.equals("y")) { 
                System.out.println("放弃");
                break;
            }
            // 循环之后的代码
            System.out.println("加油！继续！");
        }
    }

public static void main(String[] args) { 
        // 外循环，循环5次
        for (int i = 0; i < 5; i++) { 
            System.out.print("第" + (i + 1) + "次循环：");
            // 内循环，设计为循环10次
            for (int j = 0; j < 10; j++) { 
                // 判断j是否等于3，如果是，则终止循环
                if (j == 3) { 
                    break;
                }
                System.out.print("内循环的第" + (j + 1) + "次循环\t");
            }
            System.out.println();
        }
    }

public static void main(String[] args) { 
        int score; // 每门课的成绩
        int sum = 0; // 成绩之和
        boolean con = true; // 记录录入的成绩是否合法
        Scanner input = new Scanner(System.in);
        System.out.println("请输入学生的姓名：");
        String name = input.next(); // 获取用户输入的姓名
        for (int i = 1; i <= 6; i++) { 
            System.out.println("请输入第" + i + "门课程的成绩：");
            score = input.nextInt();// 获取用户输入的成绩
            if (score < 0) {  // 判断用户输入的成绩是否为负数，如果为负数，终止循环
                con = false;
                break;
            }
            sum = sum + score; // 累加求和
        }
        if (con) { 
            System.out.println(name + "的总成绩为：" + sum);
        } else { 
            System.out.println("抱歉，分数录入错误，请重新录入！");
        }
    }

**continue**

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

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

## 总结 ##

*  break：表示跳出当前层循环
 *  continue：表示跳出本次循环，进入下一次循环
 *  return：跳出当前方法的循环返回出去结果或者返回空return；

## 前言 ##

本章复习一下java的基础数据类型

### 关于变量 ###

变量就是申请内存来存储数据，也就是当创建一个变量，比如int变量值，需要在内存开辟一个空间，内存管理器系统会根据变量的类型为这个变量来分配空间，分配的空间，只能用来存储这个类型的数据  
因此通过不同类型的变量，可以在内存当中存储

**整数，小数，单精度小数，双精度小数，或者是字符**

**java当中有两大数据类型**

*  内置的数据类型
 *  引用数据类型

#### 关于内置数据类型 ####

java提供了八种原始数据类型，六中为数字类型，一种为字符类型还有一种为布尔类型；

**byte**

*  byte数据类型为最小数据内置类型，8位，有符号的，以二进制的补码表示的整数
 *  最小值为-128
 *  最大值为127
 *  默认值为0

**short**

*  short数据类型是16位
 *  最小值为-2的15次方
 *  最大值为2的15次方-1
 *  默认为0

**int**

*  int比较常用，数据类型为32位
 *  最小值为-2的31位
 *  最大值为2的31次方-1
 *  默认为0

**long**

*  long数据类型为64位
 *  最大值是大家大家肯定猜到了-2的64-1位
 *  最小值为2的63位-1位
 *  默认值是0L

**float**

*  float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
 *  float 在储存大型浮点数组的时候可节省内存空间；
 *  默认值是 0.0f；

**double：**

*  double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
 *  浮点数的默认类型为double类型；
 *  double类型同样不能表示精确的值，如货币；
 *  默认值是 0.0d；

**boolean：**

*  boolean数据类型表示一位的信息；
 *  只有两个取值：true 和 false；
 *  这种类型只作为一种标志来记录 true/false 情况；
 *  默认值是 false；

**char：**

*  char类型是一个单一的 16 位 Unicode 字符；
 *  最小值是 \\u0000（即为0）；
 *  最大值是 \\uffff（即为65,535）；
 *  char 数据类型可以储存任何字符；

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>0L</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>0.0F</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>‘u0000’</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>null</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>0.0d</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>包装类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>String</td> 
   <td>String</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Bool</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
 </tbody> 
</table>

#### 关于引用数据类型 ####

在java中引用类型的变量

引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型

引用数据类型包括

*  类
 *  接口
 *  数组

例子：String s = new String("")。  
一个引用变量可以用来引用任何与之兼容的类型。  
所有引用类型的默认值都是null。

#### **java定义的常量** ####

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

> final int PI = 3

> final char P2=“ABC”  
> 虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

#### 类型之间的转换 ####

java在不同类型计算的时候，默认会转换到默认的一种类型进行计算，转换是由低级向高级进行转换

> byte,short,char—> int —> long—> float —> double

数据转换必须满足一下的规则：

*  不能对boolean类型进行类型转换
 *  不能对对象类型进行转换
 *  高数据类型比如long转换为抵数据类型比如int需要加强制转换

> int i = 123;  
> byte b = (byte)i；

*  转换过程当中有可能会丢失精度

> int i =128;  
> byte b = (byte)i;

当int 类型值为128的时候，强制转为byte类型的时候，byte类型最大值是127,值128就会溢出；

*  浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

> (int)23.7 == 23;

## 类装载器 ClassLoader ##

**工作机制**

定义：类装载器就是寻找类的字节码文件并构造出类，在 JVM 内部表现出来为对象的组件 。在 Java 中，类装载器把一个类装入 JVM 中，要经过以下步骤；

1.  装载：查找和导入 Class 文件；
2.  链接：执行校验、准备和解析步骤，其中解析步骤是可以选择的：
    
     *  校验：检查载入 Class 文件数据的正确性；
     *  准备：给类的静态变量分配存储空间；
     *  解析：将符号引用转成直接引用；
3.  初始化：对类的静态变量、静态代码块执行初始化工作。

类装载工作由 ClassLoader 及其子类负责，ClassLoader 是一个重要的 Java 运行时系统组件，它负责在运行时查找和装入 Class 字节码文件。JVM 在运行时会产生三个

ClassLoader：根装载器、ExtClassLoader（扩展类装载器）和 AppClassLoader（系统类装载  
器）。

其中，根装载器不是 ClassLoader 的子类，它使用 C++编写，因此我们在 Java 中看不到它，  
ExtClassLoader 和 AppClassLoader 都是 ClassLoader 的子类。

*  根装载器负责装载 JRE 的核心类库，如 JRE 目标下的 rt.jar、charsets.jar 等。
 *  ExtClassLoader 负责装载JRE 扩展目录 ext 中的 JAR 类包；
 *  AppClassLoader 负责装载 Classpath 路径下的类包。

这三个类装载器之间存在父子层级关系，即根装载器是 ExtClassLoader 的父装载器，  
ExtClassLoader 是 AppClassLoader 的父装载器。默认情况下，使用 AppClassLoader 装载应  
用程序的类，我们可以做一个实验

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 38]  
控制台打印如下  
![在这里插入图片描述][20190910095432966.png]  
根装载器在Java中访问不到，所以返回null

通过以上的输出信息，我们知道当前的 ClassLoader 是 AppClassLoader，父 ClassLoader是 ExtClassLoader，祖父 ClassLoader 是根类装载器，因为在 Java 中无法获得它的句柄，所以仅返回 null

JVM 装载类时使用“全盘负责委托机制”，

“全盘负责”是指当一个 ClassLoader 装载一个类的时，除非显式地使用另一个 ClassLoader，该类所依赖及引用的类也由这个ClassLoader 载入；

“委托机制”是指先委托父装载器寻找目标类，只有在找不到的情况下才从自己的类路径中查找并装载目标类。这一点是从安全角度考虑的，试想如果有人编写

了一个恶意的基础类（如 java.lang.String）并装载到 JVM 中将会引起多么可怕的后果。但  
是由于有了“全盘负责委托机制”，java.lang.String 永远是由根装载器来装载的，这样就避  
免了上述事件的发生。

**ClassLoader 重要方法**

ClassLoader 是一个抽象类，位于 java.lang 包中。下面对该类的一些重要  
接口方法进行介绍

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 39]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 40]

*  **loadClass(String name)**  
    name 参数指定类装载器需要装载类的名字，必须使用全限定类名，如 com.baobaotao.  
    beans.Car。该方法有一个重载方法 loadClass(String name ,boolean resolve)，resolve 参数告  
    诉类装载器是否需要解析该类。在初始化类之前，应考虑进行类解析的工作，但并不是所  
    有的类都需要解析，如果 JVM 只需要知道该类是否存在或找出该类的超类，那么就不需  
    要进行解析。

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

**- defineClass(String name, byte\[\] b, int off, int len)**

将类文件的字节数组转换成 JVM 内部的 java.lang.Class 对象。字节数组可以从本地文  
件系统、远程网络获取。name 为字节数组对应的全限定类名

**- findSystemClass(String name)**

从本地文件系统载入 Class 文件，如果本地文件系统不存在该 Class 文件，将抛出  
ClassNotFoundException 异常。该方法是 JVM 默认使用的装载机制

**- findLoadedClass(String name)**

调用该方法来查看 ClassLoader 是否已装入某个类。如果已装入，那么返回  
java.lang.Class 对象，否则返回 null。如果强行装载已存在的类，将会抛出链接错误

**- getParent()**

获取类装载器的父装载器，除根装载器外，所有的类装载器都有且仅有一个父装载器，  
ExtClassLoader 的父装载器是根装载器，因为根装载器非 Java 编写，所以无法获得，将返  
回 null

每一个类在 JVM 中都拥有一个对应的 java.lang.Class 对象，它提供了类结构信息的描  
述。数组、枚举、注解以及基本 Java 类型（如 int、double 等），甚至 void 都拥有对应的  
Class 对象。Class 没有 public 的构造方法。Class 对象是在装载类时由 JVM 通过调用类装  
载器中的 defineClass() 方法自动构造的

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

类实例，类描述对象及类装载器关系

总结，类装载器装载类，调用defineClass()把进制文件转为long类型class文件在虚拟机里面。  
三个装载器，分别是扩展类装载器，根装载器，以及系统装载器。

可以通过getParent()查看父类，findLoadedClass查看是否被装载。虚拟机在加载类装载器装载会进行判断，检验跟解析。loadClass放入全限定名称加载  
java依托于虚拟机，生成class文件，通过虚拟机的类加载器加载把二进制文件加载为java文件，并且有全盘全盘负责委托机制，除非找不到才会从自己的类路径中查找。增加了安全性。

## 前言 ##

写这篇文章的时候，其实我在写关于spring框架ioc的复习理解。使用框架还是比较多的，在平时项目中，参考资料也比较多。可能每个人的理解不同，工作中常用的也就注入用的比较多，所以ioc如果你想去理解，还是比较复杂的。

准备参考个例子来写，设计到了多态方面接口指向实现类，以及关于多态方面的父类指向子类，所以，我觉得应该先把多态先复习一下。我参考了一些资料掺杂在自己的理解汇总如下：

## 正文 ##

什么叫多态，就是不同类型在不同情况下的不同状态，这也是java核心的最后一个核心，封装，继承，多态，所以多态存在必需有三个条件：

*  要有继承；
 *  要有重写；
 *  父类引用指向子类对象。

那么多态有什么用呢？主要就是为了扩展方便，假设你做个东西，按人的正常逻辑实现，其实也就是java设计的逻辑。

人做事情正常是什么逻辑，很少有一个人把所有事情做完，最高效的，做一个大的东西，咱们都需要分工，分成模块，每个人做一样，最后汇总在一起。这东西就成了。每个人做的事情，专长基本都是不同的，每个人分工不同，所以造出的东西不同，这就是一个个对象。每个人拿到的图纸不同，就是一个个类，对象创建成功后，把对象放在一起，来实现一个大一点的功能。

一个产品被设计出来了，人们最先想到的就是封装，核心的东西不可能外传，再着就是继承，原有图纸不能丢，所有的设计围绕以前的设计图纸更新迭代为更好的产品。

那么问题来了，多态是什么，你产品设计完成了，比如说机器人，你迭代造了很多机器人，一个比一个完美，一个比一个高效，这些机器人各种各样的，你让他们去充电，你要给每个人一个个的发送指令，太累了。所以大家都喜欢统一管理东西，这样管理起来比较方便。也方便处理。

这些机器人可能各有不同，但是他们在设计的时候，都是根据第一个机器人设计的。比如第一个机器人，只有充电，前进功能。那么充电，和前进也就是后面新的迭代的机器人的原始指令。

为了方便管理，你需要唤醒他们的原始指令。

唤醒原始充电指令。父类指向子类。去充电，所有机器人后面没有改写充电方法的，就按原始方法充电，更新迭代了充电方法的，按子类自己的方法充电。这就是多态。也叫做向上转型。

既然有像上转型，自然有向下转型，充完电了，每个机器人要做自己的事情，但是他们现在在原始状态，只有充电前行。向下转型为个人状态，大家可以自己做自己的事情了。

无论接口也好，父类也罢。在设计的时候都喜欢用接口开发，毕竟在实战当中我们更喜欢用接口去做多态。

为什么？

接口是抽象的，比如说我下面有个机器人是给我倒水的实现类倒水接口，叫做张三机器人，还有一个李四机器人也实现了倒水接口，有倒水功能。我说给我倒水，张三如果坏了，我就让李四去倒。为什么呢，因为他们都实现了我倒水这个接口，实现了我这个接口，我不管他们方法重写后，是歪着脖子去倒，还是趴着去倒，都给我去倒水了。是不是根据很飘逸，你们爱怎么倒怎么倒，倒来就行。

但是如果是父类的话，张三李四不需要重写我倒水的方法，而是继承了，父类里面倒水比如是跪着倒。张三爆了，张四去倒，如果自己没有重写自己倒水的方法，只能跟父类的倒水方法，跪着去倒，太没有个性了，我不喜欢。

这就是两个多态的区别。白话文讲了这么多，上代码一目了然；

## 代码部分 ##

public interface Office { 
        // 定义一个打开方法，具体实现由实现类去做 
        String open();
    }

class 张三 implements Office{ 
    
        @Override
        public String open() { 
    
            return "歪脖子倒水";
        }
    }

class 李四 implements Office{ 
            @Override
            public String open() { 
                return "趴着倒水";
            }
        }

//老板来了
    public class  Boos { 
        public static void main(String[] args) { 
        创建一个机器人工作，让张三去
    Office oooooooooooooo  = new 张三（）;
     		控制台打印张三去倒水去了
     	String ok = 	oooooooooooooo .open;
     		突然张三坏了
    		没事
    Office oooooooooooooo  = new 李四（）;
    其他的都不需要动，虽然不能歪着脖子趴着倒也行
    		
        }
    }

基本就这样，如果你用父类其实也差不多，只不过可能都是跪着去倒，如果不重写的话。  
这就是多态了，统一管理

## 前言 ##

本章复习一下多线程知识。

##### **关于线程的实现方法** #####

有三种使用线程的方法：

*  实现 Runnable 接口；
 *  实现 Callable 接口；
 *  继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动Thread而执行的。

**实现 Runnable 接口**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 43]  
![在这里插入图片描述][20190910153849860.png]  
**继承Thread类**

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

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

**实现 Callable 接口**

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

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。

**总结：**

如上图所示，总结还是实现接口会更好一些，因为：

Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；

类可能只要求，可执行就行，继承整个 Thread 类开销会过大。

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

##### 关于基础线程机制方法 #####

**sleep()方法**

Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。也可以使用 TimeUnit.TILLISECONDS.sleep(millisec)。

sleep() 可能会抛出 InterruptedException。因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 46]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 47]  
**yield()**

对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。

**join()**

在线程中调用另一个线程的 join() 方法，会将当前线程挂起，直到目标线程结束。  
可以加一个超时参数。

**deamon**

守护线程（deamon）是程序运行时在后台提供服务的线程，并不属于程序中不可或缺的部分。  
当所有非后台线程结束时，程序也就终止，同时会杀死所有后台线程。  
main() 属于非后台线程。  
使用 setDaemon() 方法将一个线程设置为后台线程。

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

**线程之间的协作**

在操作系统中，有三个概念用来描述进程间的协作关系：

*  互斥：多个进程在同一时刻只有一个进程能进入临界区；
 *  同步：多个进程按一定顺序执行；
 *  通信：多个进程间的信息传递。

通信是一种手段，它可以用来实现同步。也就是说，通过在多个进程间传递信息，可以控制多个进程以一定顺序执行。

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

**线程生命周期**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 48]

1、新建状态（New）：创建了一个线程对象。  
2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法开启线程。  
3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。  
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止。直到线程重新进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

*  （一）、等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
 *  （二）、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
 *  （三）、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）

5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

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

**线程调度优先级**  
![在这里插入图片描述][20190917100155382.png]  
Java线程有优先级，优先级高的线程会获得较多的运行机会。

Thread类的\*\*setPriority()**和**getPriority()\*\*方法分别用来设置和获取线程的优先级。

每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM\_PRIORITY。

线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。

JVM提供了10个线程优先级

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f51ef68ad7f84b4395965e3b9f3b1275.png
[.http_www.oracle.com_technetwork_java_javase_downloads_index.html]: https://mp.csdn.net
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/7343e0271cf04e668baae350133eca7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/718cbf776aca49c8ac802df5cf648d1e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/841ea6d40b844ae1baa9728a6e47404f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/78023fcc406f4afe8c06b6480e6afe99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/c0a1752bb85641f9926432edd298e82f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8ccc4200ea6c4d758ced53f73e62e75f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2fa0bbbd0b684b249b7e191541d0c5c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e8cf5b7a37204a8f8042c82e84bf9855.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/4f926e7315dd4543b86f4e2a7911d721.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/fe2ba1968426486bb35e176790e04237.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/716ae7c57aa34c93b7c92b9cb500874a.png
[20191113143837937.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/1000d9ed4cce4f84a7cd171013c332a6.png
[20191113143843458.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/2aebd8d45fa34ad7bbf4e43f61f5ff10.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8e41ba2f2ed141cc9c092ca756abd218.png
[IntelliJ IDEA]: https://www.jetbrains.com/idea/
[2019111315183292.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9bce21b11d794e5abd0f6a69e65b3f8d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8bb02cb1bd224beaa2325501fe365428.png
[jdk]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a2a47a3b09a7462ab51fe709aef3d014.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/39f4ddb89c394062805e5ef582a4a0fc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e33cdb32931c4cd4b2a516a85645538e.png
[20191113152138387.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/71fdd13cc5744a9588bf3957146d53b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/645d4c65e92b4e49a9b2a17f744f6d44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/07a22dc0233b4a22b37503066b9e4069.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a160b4191540464ead7d7f6254c9e0ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/47794e4ea4ef4338b5036b0d2f181b35.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/01675d15cd7b42e29e59c641472066ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/83ba587fda354366831dbe9dfc14993b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 22]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f6f76b9544464e0795b2682f0ae9e976.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 23]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/7a4a44ea65b84841b77b96576c68280b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 24]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/75a96919673d40728efb15f696709e97.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 25]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/eb0e82cee3e3479797ce5a317fc0d29e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 26]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/6da1ddba9d1e4f308af2bf16a586031f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 27]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/6ff5ec2cf80643c796070c82300c7bc1.png
[20191114161906495.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/70e7e525b4c54fd88a4d2d52d96d57b7.png
[20191114162636463.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/95e5a53db9354a22b8b1a9795327dd2e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 28]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/85c1d42d731c4645a3f07825a6c3137a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 29]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/582e38ab3c7445a39bd7e0b212cfa07a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 30]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/eef2429531d4467fa7da8b46ed400120.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 31]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/83908b15328c4f2e95e37b1fdaf60c27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 32]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/e34e0f33fc4e4371ad70335088eec773.png
[Alt]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9650d210c38e463599513a2c3df6d302.png
[Alt 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/afe92c14a2cc46b1827313c7afdecb62.png
[Alt 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f02cb1193b00429aa3f0ffab05916f32.png
[Alt 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/c29886d855f644da9adc3b829f769fc7.png
[20191115164755318.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/8c844e94388a46c299dce1350501817c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 33]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/9c9917736d284fdba70f65da6848c637.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 34]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/13ae49dae6d3491e85ace9018dbf6089.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 35]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/911c7afbcfd64576926d7e93e16fc5fc.png
[Alt 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/629c2cc368984ec189562d0f1e8a961f.png
[Alt 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/375e224123e04e7f9ff05530a2c0b2a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 36]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f75480f213b545ab8798cce1fd156c9d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 37]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a8128727de8f4244a41c5ebd7d1434fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 38]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a8ded76a3fed4304a1f03d9c9004a7e1.png
[20190910095432966.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b61a482d8568406f8a74e65b42609efa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 39]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/09f6ecda2d1c4ca7b8644e3b051d1e92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 40]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/53dc6b42762c4f44ba2b343cff938a2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 41]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d8aec59b1db04d7b90c6662ea011e830.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 42]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/91b0da3a57a94c6b8932fbd58d2714a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 43]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b1741bcea4814254bda72a056420d300.png
[20190910153849860.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/ce5943ed8907448eb35031d3b6b251e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 44]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/f3062bb3b94c4093a4acc425f545e66a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 45]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/601b84481a2948088238c6cdbeff6c09.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 46]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/6fa6b76d3aad4fc8a277edb0d9e6b015.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 47]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/516b33e640e846179a44c6c216a215be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDU1MDQ5MA_size_16_color_FFFFFF_t_70 48]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/0276cd34108849ae94510b7f6cdce61f.png
[20190917100155382.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/dbe5124e20d94a9bbf89f297ce9c73aa.png