【笔记-java】java工程师-入门必学

待我称王封你为后i 2023-02-20 04:58 1030阅读 0赞

<table> 
 <thead> 
  <tr> 
   <th>路径</th> 
   <th>目录</th> 
   <th>子目录</th> 
   <th>重点</th> 
   <th>课程名</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>java工程师</td> 
   <td>入门必学</td> 
   <td>语法基础</td> 
   <td>环境搭建、开发工具使用、基础语法</td> 
   <td><a rel="nofollow">java入门第一季</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td>面向对象</td> 
   <td>继承、封装、多态</td> 
   <td><a rel="nofollow">java入门第二季</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td>常用工具类</td> 
   <td>异常、字符串、包装类、集合</td> 
   <td><a rel="nofollow">java入门第三季</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td>文件操作</td> 
   <td>进制转换、IO操作、XML读写</td> 
   <td>二进制基础</td> 
   <td>20200708：课程已下架</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td><a rel="nofollow">文件传输基础-Java IO流</a></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td><a rel="nofollow">Java眼中的XML—文件读取</a></td> 
   <td>20200708：现在已经用json，不用xml了</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td></td> 
   <td>Java眼中的XML文件写入</td> 
   <td>20200708：现在已经用json，不用xml了</td> 
  </tr> 
 </tbody> 
</table>

# <table>   <tbody>    <tr>     <td> 20170425-20171012：《imooc-java入门第一季》</td>    </tr>   </tbody>  </table>  <table></table> #

地址：https://www.imooc.com/learn/85  
类目：入门必学-语法基础

观看记录：  
1、20170425-20171012  
2、20200623-20200705

### 第01章 java初体验 ###

##### 01-01 java简介 #####

一、主要内容  
1、java平台应用。  
2、核心概念：jvm，jdk、jre  
3、搭建java开发环境。  
4、使用工具开发java程序。  
二、java包括java SE ,java EE, java ME.  
三、基础核心：java SE  
1、包括java最基础的一些结构，包括java面向对象的一些特性，api、jvm…  
2、java SE是整个java的基础和核心。  
四、java EE：java的企业版，主要用于大型企业的应用开发  
1、包括jsp,ejb,service服务…  
五、java ME：主要用于嵌入式开发。  
1、包括移动设备，游戏，通信…等的开发。  
六、JVM（java virtual machine):java虚拟机，是整个java技术的核心。  
七、字节码文件（.classs）与平台（linux，windows）无关,java的跨平台就是通过jvm实现的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70]  
八、jdk、jre、jvm  
如果安装了jdk，就包括了jre和jvm  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 1]

##### 01-02 java开发环境搭建 #####

一、java开发环境搭建  
1、安装jdk，下载地址:http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html  
java在本机的文件夹：系统-资源库-java (mac)  
二、配置环境变量  
1、java\_home：配置jdk安装路径。  
path：配置jdk命令文件的位置，就是bin目录。  
classpath：配置类库文件的位置。  
2、windows下的配置： 打开控制面板-系统-高级-环境变量-系统变量  
（1）java\_home 默认没有，新建 变量名一般都是大写。  
（2）path 选择path变量，点击编辑，在最前面指定jdk配置文件的目录。  
（3）classpath 默认没有，新建 lib目录  
.(表示当前路径)  
;(把路径隔开）路径  
三、验证配置环境（windows）  
1、开始-cmd-java 下面会出现java的提示  
2、javac 也出现用法提示。 如果出现了提示，则表示java环境配置没有问题。

##### 01-03 使用记事本编写java程序 #####

一、.java文件默认是不能执行的  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 2]  
二、执行字节码文件的时候，不能跟上字节码文件的后缀。不然在cmd中运行java HelloWorld.class会出现提示：错误：找不到或无法加载主类HelloWorld.class。即应该把.class去掉。

javac HelloWorld.java
    java HelloWorld

##### 01-05 使用eclipse开发java程序 #####

一、集成开发环境（IDE）是一类软件 将程序开发环境和程序调试环境集合在一起，提高开发效率。 eclipse下载地址：http://www.eclipse.org/downloads  
二、开发步骤。  
1、创建java项目。 图片、视频、脚本、源代码，通过工程将其连接在一起。  
项目名：imooc  
2、创建程序包。创建包是为了便于程序的管理，便于源代码文件的管理，可以将不同的源代码文件放到指定的包下面，避免重名问题。  
src右击，new-package, name设为com.imooc  
3、编写java源程序。 右击刚才创建的包package，new-class，name设置为HelloWorld。  
4、运行Java程序。  
三、IDE自动将源文件转换为字节码文件。  
HelloWorld.java

package com.imooc {
    	public class HelloWorld { // HelloWorld得和文件名一致，文件名是HelloWorld.java
    		public static void main(String[] args) {
    			System.oute.println("I love imooc!")
    		}
    	}
    }

四、  
1、public是类的修饰符，定义为公有的。  
2、class:类名  
3、HelloWorld要与文件名一致，文件名是HelloWorld.java  
4、public static void main()\{\} 是固定的，是整个程序的入口。  
5、System.out.printIn()输出，输出括号中的内容，即输出HelloWorld.

##### 01-06 myeclipse的使用简介 #####

一、myeclipse  
myeclipse是对eclipse的扩展，是一个十分优秀的用于开发java，javaEE的eclipse插件集合。  
下载地址：htttp://www.my-eclipse.cn/  
二、  
1、new java project.名字为imooc.  
2、new class, pacakge为com.imooc, name为HelloWorld. 这样就自动创建包，并且创建了一个代码文件。

##### 1-09 经验技巧分享 #####

一、经验分享  
1、多练  
2、多问  
3、自己动手，调试错误。  
4、复习和总结。

### 第02章 变量和常量 ###

##### 02-01 java中的关键字 #####

一、java语言中有一些具有特殊用途的词被称为关键字。关键字对java的编译器有着特殊的意义，在程序中应用时一定要慎重哦。  
二、java中常用关键字。  
`abstract` `boolean` `break` `byte` `case` `catch` `char` `class` `continue` `default` `do` `double` `else` `extends` `false` `final` `finally` `float` `for` `if` `implements` `import` `instanceof` `int` `interface` `long` `native` `new` `null` `pacakge` `private` `protected` `public` `return` `short` `static` `super` `switch` `synchronized` `this` `throw` `throws` `transient` `true` `try` `void` `volatile` `while`  
三、java关键字是区分大小写的。

##### 02-02 认识java标识符 #####

一、标识符就是用于给java程序中变量、类、方法等命名的符号。  
`package com.imooc;` // com.imooc是标识符  
`public class Demo02{ }` // Demo02是标识符  
二、使用标识符，需要遵守的规则  
1、标识符可以由字母、数字、下划线（`_`）、美元符（`$`）组成，但不能包含@、%、空格等其它特殊字符，不能以数字开头。譬如：123name就是不合法的。  
2、标识符不能是java关键字和保留字（java预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用void作为标识符，但是Myvoid可以。  
3、标识符是严格区分大小写的。所以，一定要分清楚imooc和Imooc是两个不同的标识符。  
4、标识符的命名最好能反映出其作用，做到见名知意。

##### 02-04 变量是什么 #####

一、在java中，我们通过三个元素描述变量：变量类型、变量名、变量值。  
二、

public class Demo03 { 
    	public static void main(String[] args) { 
    		String love="imooc"; 
    		System.out.println("变量love的内容是："+love); 
    		love="I love imooc"; 
    		System.out.println("重新赋值后变量love的内容是："+love); 
    	}
    }

`String love=“imooc”;` // String：变量类型，love：变量名，imooc：变量值

##### 02-05 如何命名java变量 #####

一、  
变量名=首字母（1、字母。2、下划线`_`。3、`$`符号。）+其余部分（任意多的：1、数字。2、字母。3、下划线`_`。4、`$`符号。）。  
二、好的习惯。  
1、变量名由多单词组成时，第一个单词的首字母小写，其余单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法），如myAge.  
2、变量命名时，尽量简短且能清楚地表达变量的作用，做到见名知意。如：定义变量名stuName保存：“学生姓名”信息。  
3、java变量名的长度没有限制，但java语言是区分大小写的。

##### 02-06 java中的数据类型 #####

一、java语言是一种强类型语言。通俗点说就是，在java中存储的数据都是有类型的，而且必须在编译时就确定其类型。  
二、java中有2类数据类型：

数据类型

基本数据类型

数值型

整数类型 byte short int long

浮点类型 float double

字符型 char

布尔型 boolean

引用数据类型

类 class

接口 interface

数组

三、在java的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的空间地址。说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应。  
四、常用的基本数据类型：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>说明</th> 
   <th>字节</th> 
   <th>应用</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int</td> 
   <td>整型</td> 
   <td>4</td> 
   <td>用于存储整数，如年龄、个数</td> 
   <td>int age=21;</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>双精度浮点数</td> 
   <td>8</td> 
   <td>用于存储小数，如商品价格，成绩平均分</td> 
   <td>double price=15.5;</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>单精度浮点数</td> 
   <td>4</td> 
   <td>用于存储小数，如身高</td> 
   <td>float height=178.5f</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>字符型</td> 
   <td>2</td> 
   <td>用于存储单个字符，如性别“男”，“女”</td> 
   <td>char sex=‘男’;</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>布尔型</td> 
   <td>1</td> 
   <td>表示“真”或“假”，取值只能为true或false</td> 
   <td>boolean flag=true;</td> 
  </tr> 
 </tbody> 
</table>

##### 02-07 java中变量的使用限制 #####

一、java中变量的使用规则  
1、java中的变量需要先声明后使用。  
2、变量使用时，可以声明变量的同时进行初始化。也可以先声明后赋值。  
3、变量中每次只能赋一个值，但可以修改多次。  
4、main方法中定义的变量必须先赋值，然后才能输出。  
5、虽然语法中没有错误提示，但在实际开发中，变量名不建议使用中文，容易产生隐患，譬如后期跨平台操作时出现乱码等。

##### 02-08 练习题 #####

二、string不初始化默认值为null，int必须初始化，不初始化没有默认值。

##### 02-09 java中的自动类型转换 #####

一、自动类型转换时需要满足特定的条件的：  
1、目标类型能与源类型兼容，如double型兼容int型，但是char型不能兼容int类型。  
2、目标类型大于源类型，如double类型长度为8字节，int类型为4字节，因此double类型的变量里直接可以存放int类型的数据，但反过来就不可以了。  
二、double型变量avg1，int型变量rise可以直接完成相加操作，得到double型avg2

public class HelloWorld{
        public static void main(String[] args) {
    		double avg1=78.5;
    		int rise=5;
    		double avg2=avg1+rise;
    		System.out.println("考试平均分："+avg1);
    		System.out.println("调整后的平均分："+avg2);
    	}
    }

##### 02-10 java中的强制类型转换 #####

一、double类型转换成Int类型：

doble avg1=75.8;
    int avg2=(int)avg1; // 将double类型强制转换为int类型
    System.out.println(avg1);  // => 75.8
    System.out.println(avg2); // => 75

二、强制类型转换可能会造成数据的丢失。

##### 02-11 java常量的应用 #####

一、所谓常量，我们可以理解为时一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变。  
语法：final 常量名=值;  
`final String MALE = '男';`  
二、程序中使用常量可以提高代码的可维护性。  
三、常量名一般使用大写字符。  
四、char定义单个字符时，使用单引号’’。当需要定义多个字符（字符串）时，需要使用String，而且要使用双引号"".

#### 02-12 如何在java中使用注释 ####

一、注释：  
单行注释：`//`  
多行注释：`/* */`  
文档注释：`/** */`  
二、可以通过javadoc命令从文档注释中提取内容，生成程序的API帮助文档。

### 第03章 常用的运算符 ###

##### 03-01 什么是运算符 #####

一、运算符是一种“功能”符号，用以通知java进行相关的运算。  
二、java语言中常用的运算符可分为以下几种：

*  算术运算符。
 *  赋值运算符。
 *  比较运算符。
 *  逻辑运算符。
 *  条件运算符。

三、在java中，加法运算符用“+”表示。

##### 03-02 java中的算术运算符 #####

一、java中常用的算术运算符：

<table> 
 <thead> 
  <tr> 
   <th>算术运算符</th> 
   <th>名称</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>加法</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减法</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘法</td> 
  </tr> 
  <tr> 
   <td><code>/</code></td> 
   <td>除法</td> 
  </tr> 
  <tr> 
   <td><code>%</code></td> 
   <td>求余</td> 
  </tr> 
  <tr> 
   <td><code>++</code></td> 
   <td>自增1</td> 
  </tr> 
  <tr> 
   <td><code>--</code></td> 
   <td>自减1</td> 
  </tr> 
 </tbody> 
</table>

二、`++`和`--`既可以出现在操作数的左边，也可以出现在右边。  
`int b=++a; //先自增，后赋值`  
`int b=a++; //先赋值，后自增`  
三、自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量。如`5++`，`8--`等写法都是错误的。  
四、%用来求余，也称为取模运算符。

##### 03-03 java中的赋值运算符 #####

一、赋值运算符  
赋值运算符是指为变量或常量指定数值的符号。如可以使用“=”将右边的表达式结果赋给左边的操作数。  
二、java自持的常用赋值操作符，

##### 03-04 java中的比较运算符 #####

一、比较计算符用于判断两个数据的大小。例如：大于、等于、不等于。比较的结果是一个布尔值（true或false）.  
二、java中常用的比较运算符如下：

<table> 
 <thead> 
  <tr> 
   <th>比较运算符</th> 
   <th>名称</th> 
   <th>举例</th> 
   <th>结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&gt;</td> 
   <td>大于</td> 
   <td>a=5,b=2,a&gt;b</td> 
   <td>true</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>小于</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>&gt;=</td> 
   <td>大于等于</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>小于等于</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>==</td> 
   <td>等于</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td><code>!=</code></td> 
   <td>不等于</td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

三、  
1、> 、<、>=、<=只支持左右两边操作数是数值类型  
2、==、`!=`两边的操作数既可以是数值类型，也可以是引用类型

##### 03-05 java中的逻辑运算符 #####

一、逻辑运算符主要用于进行逻辑运算。java中常用的逻辑运算符如下表所示：

<table> 
 <thead> 
  <tr> 
   <th>逻辑运算符</th> 
   <th>名称</th> 
   <th>举例</th> 
   <th>结果</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>&amp;&amp;</td> 
   <td>与</td> 
   <td>a&amp;&amp;b</td> 
   <td>如果a与b都为true，则返回true</td> 
  </tr> 
  <tr> 
   <td>||</td> 
   <td>或</td> 
   <td>a||b</td> 
   <td>如果a与b任一为true,则返回true</td> 
  </tr> 
  <tr> 
   <td>！</td> 
   <td>非</td> 
   <td>!a</td> 
   <td>如果a为false，则返回true，即取反</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>异或</td> 
   <td>a^b</td> 
   <td>如果a与b有仅只有一个为true，则返回true</td> 
  </tr> 
 </tbody> 
</table>

##### 03-07 java中的条件运算符 #####

一、条件运算符（？：），也称为“三元运算符”  
语法形式：布尔表达式？表达式1：表达式2  
运算过程：如果布尔表达式的值为true，则返回表达式1的值，否则返回表达式2的值

##### 03-08 java中运算符的优先级 #####

一、

级别1的优先级最高，级别11的优先级最低。  
二、两个整型相除结果为整型。

##### 03-10 练习题 #####

表达式(11 + 3 \* 8) / 4 % 3的结果是2  
3 \* 8 = 24  
11 + 24 = 35  
35 / 4 = 8 // 取整  
8 % 3 = 2 // 取余

### 第04章 流程控制语句 ###

##### 04-01 java条件语句之if #####

一、需要先判断条件，条件满足后才执行的情况，就可以用if条件语句实现。  
if(条件)\{  
条件成立时执行的代码  
\}  
二、如果if条件成立时的执行语句只有一条，是可以省略大括号滴！但如果执行语句有多条，那么大括号就是不可或缺的。  
三、one%2==0，可以用来判断one是否是偶数。

##### java条件语句之嵌套if #####

一、if  
1、if语句是根据条件判断之后再做处理的一种语法结构。  
2、关键字if后小括号里面条件表达式的值必须为布尔类型。  
3、if后小括号里的表达式值为true时，程序需要执行后面大括号里的语句，为false时则不执行。  
4、if语句可以和else 一起使用。

##### 04-06 java条件语句之switch #####

一、switch  
1、执行过程：当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；如果没有匹配的 case 语句则执行 default 块的代码。

var num=1;
    switch(num){
     case 1:
      System.out.println('1');
     case 2:
      System.out.println('2');
     case 3:
      System.out.println('3');
    }

2、switch 后面小括号中表达式的值必须是整型或字符型  
3、 case 后面的值可以是常量数值，如 1、2；也可以是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a \* 2  
4、 case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束.  
5、可以把功能相同的case语句合并起来。

case 1：
    case 2：
    System.out.println('奖励一台ipad');

6、default块可以出现在任意位置，也可以省略。

##### 04-07 java循环语句之while #####

一、java常用的3种循环：while、do…while、for。  
二、while

while(判断条件) {
    	循环操作
    }

1、特点：先判断，后执行

##### 04-08 java循环语句之do…while #####

一、do…while

do{
      循环操作
    }while(判断条件)

1、先执行一遍循环操作，然后判断循环条件是否成立。  
2、如果条件成立，继续执行1，2步，直到循环条件不成立位置。  
3、特点：先执行，后判断。

##### 04-09 java循环语句之for #####

一、for循环

for(循环变量初始化；循环条件；循环变量变化){
      循环操作
    }

1、执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次。  
2、进行循环条件的判断，如果条件为true，则执行循环体内代码；如果为false，则直接退出循环。  
3、执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断。  
4、依次重新执行2、3、4，直到退出循环。  
二、特点：相比while和do…while语句，结构更加简洁易读。  
三、注意点：  
1、for关键字后面括号中的三个表达式必须用“;”隔开，三个表达式都可以省略，但“;”不能省略。  
（1）省略“循环变量初始化”，可以再for语句之前由赋值语句进行变量初始化操作，如：

int i=0;//循环变量i在for语句之前赋值
    for(;i<10;i++){//省略初始化变量
     System.out.println('i love imooc'):
    }

（2）省略“循环条件”，可能会造成循环将一直执行下去，也就是我们常说的“死循环”现象，如：

for(int i=0;i++){//省略循环条件
     System.out.println('i lover imooc');
    }

在编程过程中要避免“死循环”的出现，因此，对于上面的代码可以在循环体中使用break强制跳出循环（关于break的用法会在后面介绍）。  
（3）省略“循环变量变化”，可以在循环体中进行循环变量的变化，如：

for(int i=0;i<10;){
     System.out.println('i love imooc'):
     i++;
    }

2、for循环变量初始化和循环变量变化部分，可以是使用“,”同时初始化或改变多个循环变量的值，如：

for(int i=1,j=5;i<=5;i++,j--){
     System.out.println(i+"+"+j+"="+(i+j));
    }

3、循环条件部分可以使用逻辑运算符组合的表达式，表示复杂判断条件，但一定注意运算的优先级，如：

for(int i=1;i<10&&i!=5;i++){
     System.out.println(i):
    }

##### 04-11 java循环跳转语句之break #####

public static void main(String[] args) {
    	for (int i = 1; i <= 10; i++) {
    		// 判断i  > 2且为3的倍数
    		if ((i > 2) &&( i % 3 == 0)) {
    			break; // 通过break结束循环，执行循环后的语句
    		}
    	}
    }

一、可在循环体内和switch语句体内使用break语句

##### 04-12 java循环跳转语句之continue #####

一、continue的作用是跳过循环体中剩余的语句执行下一次循环。

// 打印1-10之间所有的偶数。
    for(int i=1;i<=10;i++){
     //判断i是否是偶数
     if(i%2!=0){
      continue;//通过continue结束本次循环，直接进行下一次循环
     }
    System.our.println(i);
    }

运行结果：  
2  
4  
6  
8  
10  
二、循环跳转：  
break：作用是结束整个循环。  
continue：作用是结束当前循环，执行下一个循环。

##### 04-14 java循环语句之多重循环 #####

一、循环体中包含循环语句的结构成为多重循环。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是二重循环。在二重循环中，外层循环每执行一次，内层循环要执行一圈。  
1、

while（循环条件1）{
     循环操作1
     while(循环条件2){
      循环操作2
     }
    }

2、

do{
     循环操作1
     do{
      循环操作2
     }while(循环条件2)
    }while(循环条件1)

3、

for(;循环条件1；){
     循环操作1
     for(; 循环条件2；){
      循环操作2
     }
    }

4、各种循环可以互相嵌套

while(循环条件1){
     循环操作1；
    for(;循环条件2；){
     循环操作2
    }
    }

### 第05章 阶段练习 ###

##### 05-02 编程练习解析 #####

一、alt + / 快捷键：代码提示

##### 05-03 编程练习优化 #####

1、`System.out.println`输出信息后换行。  
`System.out.print`输出信息后不会换行。

##### 05-04 使用eclipse调试程序 #####

一、调试：IDE工具提供的断点调试。  
1、代码行数前双击，出现实心原点，说明在此设置了断点。

##### 05-05 进阶练习 #####

一、经验总结  
1、通过分析，明确需求。  
2、整理相关知识点。  
3、梳理实现流程。  
4、借助“断点跟踪”解决问题。

### 第06章 数组 ###

##### 06-01 什么是数组 #####

一、数组  
数组里可以按顺序存放多个类型相同的数据。  
`int[] scores={96,83,92}`

##### 06-03 如何使用java中的数组 #####

一、java操作数组需要4个步骤：声明数组 -> 分配空间 -> 赋值 -> 处理数组中的数据  
1、声明数组：  
语法：`数据类型[] 数组名`；  
或者 `数据类型 数组名[]`；  
其中，数组名可以使任意合法的变量名，如：  
`int[] scores;`  
`double height[];`  
`String[] names;`  
2、分配空间。  
（1）简单地说，就是指定数组中最多可存储多少个元素。  
（2）语法：数组名=new 数据类型 \[数组长度\];  
其中，数组长度就是数组中能存放元素的个数。  
`scores=new int[5]; //长度为5的整数数组`  
`height=new double[5]; //长度为5的浮点型数组`  
我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：  
`int[] scores=new int[5]`  
3、赋值  
分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的，例如向scores数组中存放学生成绩  
`scores[0]=89;`  
`scores[1]=79;`  
4、处理数组中数据  
我们可以对赋值后的数组进行操作和处理，如获取并输出数组中元素的值。  
`System.out.println("scores数组中第一个元素的值："+scores[0]);`  
5、java还提供了一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成，如：  
`int[] scores={78,91,84,68}; //创建一个长度为4的整型数组`  
等价于：`int[] scores=new int[]{78,91,74,68} //[]里面必须为空，不能指定长度。`

##### 06-07 使用Arrays 类操作java中的数组 #####

一、Arrays类是java中提供的一个工具类，在java.util包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。  
1、排序  
语法：`Arrays.sort(数组名);`  
（1）`import java.util.Arrays;//使用Arrays类时必须添加此行，导入包`

public class HelloWorld{
     public static void main(String[] args){
      //定义一个整型数组
      int[] scores={78,93,97};
      Arrays.sort(scores);
     }
    }

2、将数组转换为字符串  
语法：`Arrays.toString(数组名);`  
（1）可以使用toString()方法将一个数组转换为字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间用逗号和空格隔开。

int[] nums=new int[]{ 25, 7, 126, 53, 14, 86 };
    Arrays.toString(nums);

得到：\[25, 7, 126, 53, 14, 86\]

##### 06-08 使用foreach操作数组 #####

一、使用foreach操作数组  
1、foreach不是java中的关键字，是for语句的特殊简化版本，在遍历数组、集合时，foreach更简单便捷。  
2、语法：  
`for(元素类型 元素变量：遍历对象)；`  
3、

Sring[] hobbys = {"imooc", 'i', 'love', 'imooc.com'}
    
    // 使用for循环输出数组中的元素
    for(int i=0;i<hobbys.length;i++){
     System.out.println(hobbys[i]);
    }
    
    // 使用forEach循环输出数组中的元素
    for(String hobby:hobbys){
     System.out.println(hobby);
    }

##### 06-09 java中的二维数组 #####

一、二维数组  
二维数组，可以简单地理解为是一种“特殊”的一堆数组，它的每个数组空间中保存的是一个一维数组。  
1、声明数组并分配空间  
（1）

数据类型[][] 数组名=new 数据类型[行的个数][列的个数]；

（2）

数据类型[][] 数组名；
    数组名=new 数据类型[行的个数][列的个数]

2、赋值  
（1）

数组名[行的索引][列的索引]=值；

（2）  
也可以在声明数组的同时为其赋值

数据类型[][] 数组名={
       {值1，值2...},{值11，值22...},{值21，值22...}};

如

//给第1行第1列的元素赋值
    num[0][0]=12;

3、处理数组  
二维数组的访问和输出同一维数组一样，只是多了一个下标而已，在循环输出时，需要里面再内嵌一个循环，即使用二重循环来输出二维数组中的每一个元素。

//定义一个两行三列的二维数组并赋值
    int[][] num={
       {1,2,3},{4,5,6}};
    //定位行
    for(int i=0;i<num.length;i++){
     //定位每行的元素
    for(int j=0;j<num[i].length;j++){
     //依次输出每个元素
     System.out.println(num[i][j]);
    }
    //实现换行
    System.out.println();
    }

二、在定义二维数组时，也可以只指定行的个数，然后再为每一行分别指定列的个数。如果每行的列数不同，则创建的是不规则的二维数组。

int[][] num=new int[3][];//定义一个三行的二维数组
    num[0]=new int[2];//为第一行分配两列
    num[1]=new int[3];//为第二行分配三列
    num[0][0]=1;//第一行第一列赋值为1
    num[1][1]=2;//第二行第二列赋值为2

### 第07章 方法 ###

##### 07-01 如何定义java中的方法 #####

一、如何定义java中的方法  
1、方法：用来解决一类问题的代码的有序组合，是一个功能模块。  
2、一般情况下，定义一个方法的语法是：

访问修饰符  返回值类型 方法名（参数列表）{
     方法体
    }

其中，  
①访问修饰符：方法允许被访问的权限范围，可以是public、protected、private甚至可以省略，其中public表示该方法可以被其他任何代码调用。  
②返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为void；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用return语句返回值。  
③方法名：定义的方法的名字，必须使用合法的标识符。  
④参数列表：传递给方法的参数列表，参数可以有多个，多个参数间可以用逗号隔开，每个参数由参数类型和参数名组成，以空格隔开。  
根据方法是否带参、是否带返回值，可将方法分为四类：  
1）无参无返回值方法  
2）无参带返回值方法  
3）带参无返回值方法  
4）带参带返回值方法

##### 07-02 java中无惨返回值方法的使用 #####

一、方法的使用  
方法的使用分两步：  
1、定义方法  
下面代码定义了一个方法名为show，没有参数，且没有返回值的方法，执行的操作为输出“welcome to imooc”，

public(aSuncat:访问修饰符) void(aSuncat:返回值类型) show(aSuncat:方法名){
     System.out.println("welcome to imooc");(aSuncat:方法体)
    }

注意：  
①方法体放在一对大括号中，实现特定的操作。  
②方法名主要在调用这个方法时使用，需要注意命名的规范，一般采用小驼峰命名。  
2、调用方法  
当需要调用方法执行某个操作时，可以先创建类的对象，然后通过对象名.方法名()；来实现。

public class HelloWorld{
     public static void main(String[] args){
      //创建对象，对象名为hello
      HelloWorld hello = new HelloWorld();
      //通过对象名.方法名()的形式调用方法
      hello.show();
     }
     //定义方法
     public void show(){
      System.out.println("welcome to imooc");
     }
    }

##### 07-03 java中无参带返回值方法的使用 #####

一、方法  
下面的方法，定义了一个方法名为calSum,无参数，但返回值为int类型的方法，执行的操作为计算两数之和，并返回结果。

public int(aSuncat:返回一个整型值) calSum(){
     int a=5;
     int b=12;
     int sum=a+b;
     return sum;（aSuncat:使用return 返回值）
    }

二、注意点：  
1、如果方法的返回类型为void,则方法中不能使用return返回值  
public void showInfo()\{  
return “Java”;（aSuncat:错误）  
\}  
2、方法的返回值最多只能有一个，不能返回多个值  
public int getInfo()\{  
int score1=94;  
int score2=87;  
return score1, score2;(aSuncat:错误)  
\}  
3、方法返回值的类型必须兼容，例如，如果返回值类型为int，则不能返回String型值  
public int getInfo()\{(aSuncat:错误)  
String name = “imooc”;  
return name;  
\}

##### 07-05 java中带参无返回值方法的使用 #####

一、可以通过在方法中加入参数列表接收外部传入的数据信息，参数可以是任意的基本类型数据或引用类型数据。  
二、调用带参方法与调用无参方法的语法类似，但在调用时必须传入实际的参数值  
对象名.方法名（实参1，实参2，…，实参n）  
我们把定义方法时的参数成为形参，目的是用来定义方法需要传入的参数的个数和类型；把调用方法时的参数成为实参，是传递给方法真正被处理的值。  
三、注意  
1、调用带参方法时，必须保证实参的数量、类型、顺序与形象一一对应

public class HelloWorld{
     public static void main(String[] args){
      HelloWorld hello = new HelloWorld();
      hello.show(25.6);(aSuncat:错误。实参与形参类型不一致)
     }
     public String show(String name){
      return "欢迎您，" + name + ";";
     }
    }

2、调用方法时，实参不需要指定数据类型，如  
`hello.show("爱慕课");`  
3、方法的参数可以是基本数据类型，如int、double等，也可以是引用数据类型，如String、数组等。

import java.util.Array;
    public class HelloWorld {
     public static void main (String[] args) {
      HelloWorld hello = new HelloWorld();
      int[] scores = {84,91,74,62};
      hello.print(scores);(aSuncat:实参为整型数组)
     }
     public void print(int[] scores){（aSuncat：参数为整型数组）
      System.out.println(Array.toString(scores));（aSuncat：使用Array类的toString()方法将数组转换为字符串并输出）

4、当方法参数有多个时，多个参数间以逗号分隔。

##### 07-06 java中带参带返回值方法的使用 #####

一、带参带返回值方法的使用

public String show(String name){
     return "欢迎你," + name + "!";
    }

##### 07-08 java中方法的重载 #####

一、什么是方法的重载？  
如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则成为方法的重载，也可称该方法被重载了。  
二、如何区分调用的是哪个重载方法呢？  
当调用被重载的方法时，java会根据参数的个数和类型判断应该调用哪个重载方法，参数完全匹配的方法将被执行。  
三、判断方法重载的依据：  
1、必须是在同一个类中。  
2、方法名相同。  
3、方法参数的个数、顺序或类型不同。  
4、与方法的修饰符或返回值没有关系。

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

# <table>   <tbody>    <tr>     <td> 20190708-20190710：《imooc-java入门第二季》</td>    </tr>   </tbody>  </table>  <table></table> #

地址：https://www.imooc.com/learn/124  
类目：入门必学-面向对象

观看记录：  
20190708-20190710  
20200706-20200708

### 第01章 类和对象 ###

##### 01-01 什么是类和对象 #####

一、类  
1、类是模子，确定对象将会拥有的特征（属性）和行为（方法）。  
2、类的特点  
（1）类是对象的类型  
（2）具有相同属性和方法的一组对象的集合  
二、对象的属性  
1、属性：对象拥有的各种特性。  
2、每个对象的每个属性都拥有特定值。  
三、对象的方法  
1、方法-对象执行的操作  
四、类和对象的关系  
1、类是抽象的概念  
2、对象是你能看得到、摸得着的具体实体。

##### 01-02 如何定义java中的类 #####

一、类  
1、类的重要性：所有的java程序都以类class为组织单元  
2、类的组成：属性和方法  
3、定义一个类的步骤  
（1）定义类名  
`public class 类名 {}`  
①class是声明类的关键字  
（2）编写类的属性  
（3）编写类的方法

public class 类名 { // 如 public class Telphone {
    	 // 定义属性部分（成员变量）
    	 属性1的类型 属性1; // 如float screen
    	 属性2的类， 属性2；
    
    	// 定义方法部分
    	方法1； 如 void call { System.out.println("Telphone有打电话的功能"); }
    	方法2；
    }

②定义类的时候，首字母要大写。

###### 01-03 如何使用java中的对象 ######

一、使用对象的步骤  
1、创建对象  
（1）类名 对象名 = new 类名();  
`Telphone phone = new Telphone();`  
2、使用对象  
（1）引用对象的属性：对象名.属性  
`phone.screen = 5; // 给screen属性赋值5`  
（2）引用对象的方法：对象名.方法名()  
`phone.sendMessage(); // 调用sendMessage()方法`  
二、类是对象的类型  
三、float类型变量赋值时需要加f，否则默认浮点数是double型

##### 01-05 java中的成员变量和局部变量 #####

一、成员变量和局部变量  
1、成员变量  
在类中定义，用来描述对象将要有什么  
2、局部变量  
在类的方法中定义，在方法中临时保存数据。  
3、成员变量和局部变量区别  
（1）作用域不同  
①局部变量的作用域仅限于定义它的方法  
②成员变量的作用域在整个类内部都是可见的。  
（2）初始值不同  
①java会给成员变量一个初始值  
②java不会给局部变量赋予初始值。  
（3）  
①在同一个方法中，不允许有同名局部变量；在不同的方法中，可以有同名局部变量。  
（4）就近原则  
①两类变量同名时，局部变量具有更高的优先级。  
4、默认的成员变量值是0。

##### 01-06 java中的构造方法 #####

一、构造方法  
1、使用new + 构造方法，创建一个新的对象。  
2、构造方法是定义在java类中的一个用来初始化对象的方法。  
3、构造方法与类名相同，没有返回值。  
4、  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 3]  
二、无参构造方法、有参构造方法  
1、如果没有指定无参构造方法，系统会帮我们自动生成一个无参构造函数。  
2、无参构造方法、有参构造方法，是可以共存的。

package com.imooc;
    public class InitailTelphone {
    	public statis void main(String[] args) {
    		// 通过无参的构造方法可以创建对象
    		Telphone phone = new Telphone();
    		// 通过有参的构造方法也可以创建对象，并给对象中的实例变量赋值
    		Telphone phone2 = new Telphone(5.0f, 1.4f, 2.0f);
    	}
    }

3、有参构造方式，是为了给初始变量赋值的。  
4、当有指定构造方法，无论是有参、无参的构造方法，都不会自动添加无参的构造方法。  
5、构造方法的重载：方法名相同，但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。  
6、构造方法不但可以给对象的属性赋值，还可以保证给对象的属性赋一个合理的值。（避免有参构造方法，传值不安全的问题）。

package com.imooc;
    
    public class Telphone {
    	private float screen;
    	public Telphone(float newScreen) {
    		if (newScree < 3.5) {
    			System.out.println('您输入的参数有问题，自动赋值3.5');
    			screen = 3.5f;
    		} else {
    			screen = newScreen;
    		}
    		System.out.println('有参的构造方法执行了！');
    	}
    }

三、当我们创建对象的时候，执行的其实是无参构造方法。  
四、构造方法  
1、无参构造方法的使用  
2、带参构造方法的使用

main():
    	Telphone phone2 = new Telphone(4.0f, 2.0f, 2.0f);
    class Telphone:
    	public Telphone(float newScreen, float newCpu, float newMem) {
    		screen = newScreen;
    		cpu = newCpu;
    		mem = newMem;
    	}

##### 01-07 java中的static使用之静态变量 #####

一、static  
1、Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问  
2、使用 static 可以修饰变量、方法和代码块。  
3、静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收  
4、eg  
定义公有的静态变量num

public static int num = 100;

##### 01-09 java中的static使用之静态方法 #####

一、static  
1、使用 static 修饰方法，称为静态方法或类方法。  
2、注意：  
（1） 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。  
①如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量

// 在静态方法中调用非静态变量
    public static void print() {
    	String name = "爱慕课"; // 非静态变量name
    	static String hobby = "imooc"; // 静态变量hobby
    	// 创建类的对象
    	HelloWorld hello = new HelloWorld();
    	// 通过对象来实现在静态方法中调用非静态变量
    	System.out.println("欢迎您：" + hello.name + "!");
    	System.out.println("爱好：" + hobby + "!");
    }

（2）在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。

String name = "I love imooc"; //非静态变量name
    static String hobby = "imooc"; // 静态变量hobby
    
    // 普通成员方法可以直接访问非静态变量和静态比纳灵
    public void show() {
    	System.out.println("欢迎您：" + name + "!");
    	System.out.println("爱好" + hobby + "!");
    }

（3） 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

// 普通成员方法
    public void show() {}
    // 静态方法
    public static void print() {}
    public static void main(String[] args) {
    	// 普通成员方法必须通过对象来调用
    	HelloWorld hello = new HelloWorld();
    	hello.show();
    	// 可以直接调用静态方法
    	print();
    }

##### 01-10 java中的static使用之静态初始化块 #####

一、java中可以通过初始化快进行数据赋值

public class HelloWorld {
    	String name; // 定义一个成员变量
    	// 通过初始化块为成员变量赋值
    	{
    		name = "love imooc";
    	}
    }

1、在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用static修饰初始化块，就称为静态初始化块。  
2、静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。  
3、程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。

### 第02章 封装 ###

##### 02-01 什么是java中的封装 #####

一、面向对象三大特性：封装、继承、多态  
二、封装  
1、概念：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。  
2、好处：  
（1）只能通过规定的方法访问数据。  
（2）隐藏类的实例细节，方便修改和实现。  
三、  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 4]  
四、函数如果不需要返回值，用void关键字

##### 02-02 使用包管理java中的类 #####

一、java中的包  
1、包的作用  
管理java文件  
解决同名文件冲突  
2、定义包：package 包名  
注：必须放在java源程序的第一行  
包名间可以使用“.”号隔开  
eg: com.imooc.MyClass  
3、系统中的包  
（1）java.(功能).(类）  
（2）java.lang.(类) 包含java语言基础的类  
（3）java.util.(类) 包含java语言中各种工具类  
（4）java.io.(类) 包含输入、输出相关功能的类  
4、包的使用  
（1）可以通过import 关键字，在某个文件使用其他文件中的类  
`import com.imooc.music.MyClass;`  
（2）java中，包的命名规范是全小写字母拼写  
（3）使用的时候不但可以加载某个包下的所有文件  
`eg: com.imooc.*`  
也可以加载某个具体子包下的所有文件  
`eg:com.imooc.music.*`  
二、在一个包下面不能创建相同名称的类

##### 02-03 java中的访问修饰符 #####

一、访问修饰符  
访问修饰符-可以修饰属性和方法的访问范围  
二、访问修饰符的总结

<table> 
 <thead> 
  <tr> 
   <th>访问修饰符</th> 
   <th>本类</th> 
   <th>同包</th> 
   <th>子类</th> 
   <th>其他</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>private</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>默认</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>public</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
 </tbody> 
</table>

##### 02-04 java中的this关键字 #####

一、this  
1、this关键字代表当前对象  
this.属性 操作当前对象的属性  
this.方法 调用当前对象的方法  
2、封装对象的属性的时候，经常会使用this关键字。

##### 02-05 什么是java中的内部类 #####

一、内部类  
1、定义  
内部类（Inner Class）就是定义在另外一个类里面的类，与之对应，包含内部类的类被称为外部类。  
2、作用  
（1）内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类。  
（2）内部类的方法可以直接访问外部类的所有数据，包括私有的数据。  
（3）内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。  
3、内部类的种类  
（1）成员内部类  
（2）静态内部类  
（3）方法内部类  
（4）匿名内部类

##### 02-06 java中的成员内部类 #####

一、内部类最常见的就是成员内部类，也成为普通内部类。  
二、注意：  
1、外部类不能直接使用内部类的成员和方法。  
2、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用this关键字。

// 外部类Outer
    public class Outer {
    	private int a = 99; // 外部类的私有属性
    	// 内部类Inner
    	public class Innter {
    		int b = 2; // 内部类的成员属性
    		public void test() {
    			System.out.println("访问外部类中的a:" +  a);
    			System.out.println("访问内部类中的b:" + b);
    		}
    	}
    	// 测试成员内部类
    	public static void main(String[] args) {
    	Outer o = new Outer; // 创建外部类对象，对象名为o
    	Inner i = o.new Inner(); // 使用外部类对象创建内部类对象，对象名为i
    	i.test(); //调用内部类对象的test方法
    	}
    }

##### 02-07 Java中的静态内部类 #####

一、静态内部类是static修饰的内部类，这种内部类的特点是：  
1、静态内部类不能直接访问外部类的非静态成员，但可以通过`new 外部类().成员` 的方式访问  
2、如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员。  
3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建`内部类 对象名 = new 内部类()`；

public class SOuter {
    	private int a = 99; // 外部类的私有变量
    	static int b = 1; // 外部类的静态变量
    	// 静态内部类
    	public static class SInner {
    		int b = 2; // 内部类的变量
    		public void test() {
    			System.out.println("访问外部类中的b:" + SOuter.b);
    			System.out.println("访问内部类中的b:" + b);
    		}
    	}
    	// 测试静态内部类
    	public static void main(String[] args) {
    		SInner si = new SInner(); // 直接创建内部类的对象
    		si.test(); // 调用test方法
    	}
    }

##### 02-08 java中的方法内部类 #####

一、方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。  
二、由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和static修饰符。

// 外部类
    public class MOuter {
    	// 外部类中的方法
    	public void show() {
    		final int a = 25; // 常量
    		int b = 13; // 变量
    		// 方法内部类
    		class MInner {
    			int c = 2; // 内部类中的变量
    			public void print() {
    				System.out.println("访问外部类的方法中的常量a:" + a);
    				System.out.println("访问内部类中的变量c:" + c);
    			}
    		}
    		MInner mi = new MInner(); // 创建方法
    	 }
    }

### 第03章 继承 ###

##### 03-01 java中的继承 #####

1、继承的概念  
继承是类与类的一种关系，是一种“is a” 的关系  
注： java中的继承是单继承  
2、继承的好处  
（1）子类拥有父类的所有属性和方法，private修饰的无效。  
（2）实现代码复用  
3、语法规则

class 子类 extends 父类

（1）eg：`class Dog extends Animal {}`

##### 03-02 java中的方法重写 #####

一、方法的重写  
如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法  
2、语法规则  
（1）返回值类型  
（2）方法名  
（3）参数类型及个数  
都要与父类继承的方法相同，才叫方法的重写。

##### 03-04 java中的继承初始化顺序 #####

一、继承的初始化顺序  
1、初始化父类再初始子类  
2、先执行初始化对象中属性，再执行构造方法中的初始化。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 5]

##### 03-05 java中的final的使用 #####

一、final关键字  
使用final关键字做标识有“最终的”含义，不可修改，不可变化  
二、final可以修饰类、方法、属性和变量  
1、final修饰类，则该类不允许被继承。  
2、final修饰方法，则该方法不允许被覆盖（重写）  
3、final修饰属性  
（1）则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）  
（2）或在构造函数中赋值（但只能选其一）  
4、final修饰变量，则该变量的值只能赋一次值，即变为常量。

##### 03-07 java中的super的使用 #####

一、super关键字  
在对象的内部使用，可以代表父类对象。  
1、访问父类的属性 `super.age`  
2、访问父类的方法 `super.eat()`  
二、super的应用  
1、子类的构造的过程当中必须调用其父类的构造方法。  
2、如果子类的构造方法中没有显式调用父类的构造方法，则系统默认调用父类无参的构造方法。  
3、如果显式地调用构造方法，必须在子类的构造方法的第一行。  
4、如果子类构造方法中既没有显式调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。

##### 03-08 java中的Object类 #####

一、Object类  
1、Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。  
2、Object类中的方法，适合所有子类。  
二、方法  
1、toString()方法  
（1）在Object类里面定义toString()方法的时候，返回的对象的哈希code码（对象地址字符串）  
即，没有重写toString方法的情况下直接用print打印对象，输出的是此对象的地址。  
（2）可以通过重写toString()方法表示出对象的属性。  
2、equals()方法  
（1）比较的是对象的引用是否指向同一块内存地址  
（2）一般情况下比较两个对象时，比较他的值是否一致，所以要进行重写。

package com.imooc;
    public class Initail {
    	Dog dog = new Dog();
    	dog.age = 15;
    	Dog dog2 = new Dog();
    	dog2.age = 15;
    	if (dog.equals(dog2)) {
    		System.out.println("两个对象是相同的");
    	} else {
    		System.out.println("两个对象是不相同的");
    	}
    }

输出"两个对象是不相同的"  
三、2个基本类型的值是否相同用==，  
2个引用类型的值是否相同用equals  
四、hashcode，唯一标识一个值。  
五、想判断两个对象的值是否相同，重写equals方法

@Override
    public boolean equals(Object obj) {
    	if(this == obj) return true; // 判断两个引用的值是否相同，引用的值判断的是两个引用的地址是否相同。如果两个引用的值相同，说明指向同一个对象，那么这两个对象，肯定是相同的
    	if (obj == null) return false; // 如果有一个对象是空值，返回false
    	if (getClass() != obj.getClass()) return false; // getClass()可以得到一个类对象，当我们new一个对象，得到的是类的对象。类对象可以判断两个对象的类型是否相同
    	Dog other = (Dog) obj;
    	if (age != other.age) return false;
    	return true;
    }

五、obj.getClass()：类对象描述的是类的代码信息  
obj：类的对象，关注的是类的属性值的信息，或者说类的对象数据信息。  
![在这里插入图片描述][202007071314040.png]

### 第04章 多态 ###

##### 04-01 java中的多态 #####

一、多态：对象的多种形态  
1、引用多态  
（1）父类的引用可以指向本类的对象  
`Animal obj1 = new Animal();`  
（2）父类的引用可以指向子类的对象  
`Animal obj2 = new Dog();`  
（3）不能用子类的引用指向父类的对象  
`Dog obj3 = new Anima(); // 错误`  
2、方法多态  
（1）创建本类对象时，调用的方法为本类方法

Animal obj1 = new Animal();
    obj1.eat();

（2）创建子类对象时，调用的方法为子类重写的方法或者继承的方法。

// 子类重写的方法
    Animal obj2 = new Dog();
    obj2.eat();
    // 继承的方法
    Animal obj3 = new Cat(); // 继承Animal，但是里面没有写任何方法，所以继承父类的方法
    obj3.eat();

（3）不能通过父类的引用调用子类独有的方法

Animal dog = new Dog(); // 父类的引用指向子类的对象
    dog.watchDoor(); // 报错，watchDoor是子类Dog独有的方法

二、继承是多态的实现基础

##### 04-02 多态中的引用类型转换 #####

一、引用类型转换  
1、向上类型转换（隐式/自动类型转换），是小类型到大类型的转换。 // 无风险  
2、向下类型转换（强制类型转换），是大类型到小类型。 // 有风险

Dog dog = new Dog();  // 创建1个子类对象，子类的引用执行对象
    Animal animal = dog; // 一个父类的引用指向子类对象。自动类型转换 / 向上类型转换
    Dog dog2 = (Dog)animal; // 一个父类引用转换成子类引用。强制类型转换 / 向下类型转换
    Cat cat = (Cat)animal; // 子类的引用转换成父类的引用。animal是Dog类型。编译时 Cat类型 （不会报错）；运行时 Dog类型（会报错）

3、`instanceof`运算符，来解决引用对象的类型，避免类型转换的安全性问题。

if (animal instanceof Cat) {
    	Cat cat = (Cat)animal;
    } else {
    	System.out.println("无法进行类型转换");
    }

输出"无法进行类型转换"

##### 04-03 java中的抽象类 #####

一、语法定义  
抽象类使用abstract关键字修饰，则该类为抽象类。  
二、抽象类应用场景  
1、在某些情况下，某个父类只是知道子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。  
2、从多个具有相同特性的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。  
三、抽象类作用  
1、限制规定子类必须实现某些方法，但不关注实现细节  
四、抽象类使用规则  
1、abstract定义抽象类，顺序为`abstract class`  
2、abstract定义抽象方法，只有声明，不需要实现。  
抽象方法没有方法体，以分号结束。  
`public abstract void call();`  
3、包含抽象方法的类是抽象类。  
4、抽象类中可以包含普通的方法，也可以没有抽象方法。  
5、抽象类不能直接创建，可以定义引用变量。  
五、IDEA按住alt+enter,能选择抽象类。  
Telphone.java

package com.imooc;
    public abstract class Telphone {
    	public abstract void call();
    	public abstract void message();
    }

Cellphone.java

package com.imooc;
    public class Cellphone extends Telphone {
    	@Override
    	public void call() {
    		System.out.println("通过键盘来打电话");
    	}
    	@Override
    	public void message() {
    		System.out.println("通过键盘来发短信");
    	}
    }

##### 04-05 java中的接口 #####

一、接口  
1、接口概念  
（1）接口可以理解为一种特殊的类，由全局变量和公共的抽象方法所组成。  
（2）类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。  
（3）和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。  
2、接口定义的基本语法：

[修饰符] interface 接口名 [extends 父接口1，父接口2...] {
    	零个到多个常量定义...
    	零个到多个抽象方法的定义...
    }

（1）接口就是用来被继承、被实现的，修饰符一般建议用public。  
注意：不能使用private和protected修饰接口  
3、接口定义  
（1）常量：接口中的属性是常量，即使定义时不添加`public static fianl` 修饰符，系统也会自动加上。  
（2）方法：接口中的方法只能是抽象方法，总是使用，即使定义时不添加`public abstract`修饰符，系统也会自动加上。  
4、使用接口  
（1）一个类可以实现一个或多个接口，实现接口使用implements关键字。java中的一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。  
（2）接口使用过程中，还经常与匿名内部类配合使用。  
①匿名内部类：没有名字的内部类，多用于关注实现而不关注实现类的名称  
语法格式

Interface i = new Interface() {
    	public void method() {
    		System.out.println("匿名内部类实现接口的方式");
    	}
    }

5、继承父类实现接口的语法

[修饰符] class 类名 extends 父类 implements 接口1，接口2...
    {
    	类体部分 // 如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
    }

（1）如果要继承父类，继承父类必须在实现接口之前。  
（2）实现一个接口，就必须实现接口里要求的方法。  
SmartPhone.java

package com.imooc;
    public class SmartPhone extends Telphone implements IPlayGame {
    	@Override
    	public void call() {
    		System.out.println("通过语音打电话");
    	}
    	@Override
    	public void message() {
    		System.out.println("通过语音发短信");
    	}
    	@Override
    	public void playGame() {
    		System.out.println("具有了玩游戏的性能");
    	}
    }

IPlayGame.java

package com.imooc;
    public interface IPlayGame {
    	public void playGame();
    }

Psp.java

package com.imooc;
    public class Psp implements IPlayGame {
    	@Override
    	public void playGame() {
    		System.out.println("具有了玩游戏的功能")	
    	}
    }

Initial.java

package com.imooc;
    
    public class Initial {
    	IPlayGame ip1 = new SmartPhone();
    	ip1.playGame();
    	IPlayGame ip2 = new Psp();
    	ip2.playGame;
    
    	// 匿名内部类
    	IPlayGame ip3 = new IPlayGame() {
    		@Override
    		public void playGame() {
    			System.out.println("使用匿名内部类的方式实现接口")
    		}
    	}
    	ip3.playGame();
    
    	// 匿名内部类
    	new IPlayGame() {
    		public void playGame() {
    			System.out.println("使用匿名内部类的方式实现接口2")
    		}
    	}.playGame();
    }

##### 04-07 UML #####

一、UML  
1、Unified Modeling Language(UML)，又称统一建模语言或标准建模语言。  
是一个支持模型和和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持。。  
2、常用UML图  
（1）用例图（The Use Case Diagram）  
用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及待定的用户需求等信息。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 6]  
（2）序列图（The Sequence Diagram）  
序列图用于按照交互发生的一系列顺序，显示对象之间的这些交互。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 7]  
（3）类图（The Class Diagram）  
UML类图、业务逻辑和所有支持结构一同被用于定义全部的代码结构。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 8]  
3、UML建模工具  
visio、rational rose 、powerDesign 三种建模工具应用最广。  
（1）rational rose，是IBM的  
http://www.uml.org.cn/RequirementProject/200604043.htm  
（2）microsoft office visio，是microsoft的。  
http://www.microsoft.com/china/office/xp/visio/default.asp  
（3）powerDesigner  
http://www.uml.org.cn/UMLTools/powerDesigner/powerDesignerToolIntroduction.htm

### 第05章 阶段练习 ###

##### 05-01 阶段练习 #####

一、里面有这门课程的实际应用分析，可以再听听。

### 第06章 项目实战 ###

##### 06-01 综合练习 #####

一、项目背景  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 9]  
二、项目分析：数据模型分析、业务模型分析、显示和流程分析  
三、数据模型分析  
1、通过对现实世界的事与物主要特征的分析、抽象，为信息系统的实施提供数据存取的数据结构以及相应的约束。  
2、数据结构组成：操作（方法）、属性。  
（1）  
![在这里插入图片描述][20200708091436566.png]  
（2）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 10]  
四、业务模型分析  
1、在设计应用程序之前，应该明确该应用程序必须执行哪些任务。  
2、分析业务需求是应用程序开发中最重要的步骤之一。  
3、确认业务需求的目的在于创建一个能同时满足零售商和消费者需要的解决方案。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 11]  
五、显示和流程分析  
1、显示：用户可以看到的信息提示界面。  
2、流程：显示信息的执行过程、步骤。

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

# <table>   <tbody>    <tr>     <td> 20190821-20200309：《imooc-java入门第三季》</td>    </tr>   </tbody>  </table>  <table></table> #

地址：https://www.imooc.com/learn/110  
类目：入门必学-常用工具类

观看记录：  
20190821-

### 第01章 异常与异常处理 ###

##### 01-01 java异常简介 #####

一、阻止当前方法或作用域继续执行的问题，称之为异常。  
二、Throwable  
1、Error：①虚拟机错误：VirtualMachineError。②线程死锁：ThreadDeath。  
2、Exception: 编码、环境、用户操作输入出现问题。  
①非检查异常：RuntimeException:  
a. 空指针异常：NullPointException。引用了一个空对象的属性和方法  
b. 数组下标越界异常：ArrayIndexOutOfBoundsException。数组访问越界  
c. 类型转换异常：ClassCastException。错误的类型转换  
b. 算术异常：ArithmeticException。算术方面：整数整除0  
②检查异常  
a. 文件异常：IQException  
b.SQL异常：SQLException

##### 01-02 java中使用try…catch…finally #####

一、异常处理try-catch以及try-catch-finally  
1、按先小后大的顺序写异常

try {
    
    } catch {
    
    } finally {
    
    }

二、catch块跟在try语句后面，它可以是一个或多个  
三、catch块有一个参数，该参数是某种异常类的对象  
四、多重catch语句汇总，异常类型必须子类在前父类在后。

##### 01-05 java中的异常抛出以及自定义异常 #####

一、java中的异常抛出  
1、throw  
将产生的异常抛出（动作）  
2、throws  
声明将要抛出何种类型的异常（声明），public void 方法名（参数列表）,  
throws 异常列表 \{  
throws 异常列表 \{  
// 调用会抛出异常的方法或者：  
throw new Exception();  
\}  
\}

public void divide(int one, int two) throws Exception {
    	if (two == 0) {
    		throw new Exception("两数相除，除数不能为0！")
    	} else {
    		System.out.println("两数相处，结果为" + one/two);
    	}
    }

二、自定义异常  
1、

class 自定义异常类 extends 异常类型 {
    }

2、自定义异常的父类可以是Exception

##### 01-07 java中的异常链 #####

一、新的异常中包含原始异常的所有信息  
新一场调用initCause去引用了原始异常，从而实现了异常链的功能。  
二、Exception的父类是Throwable  
三、可以使用throw语句抛出异常。

##### 01-09 经验总结 #####

一、实际应用中的经验与总结  
1、处理运行时异常，采用逻辑去合理规避同时辅助try-catch处理。  
2、在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常。  
3、对于不确定的代码，也可以加上try-catch，处理潜在的异常。  
4、尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出。  
5、具体如何处理异常，要根据不同的业务需求和异常类型去决定。  
6、尽量添加finally语句块去释放占用的资源。

### 第02章 认识java中的字符串 ###

##### 02-01 什么是java中的字符串 #####

一、在java中，字符串被作为String类型的对象处理。String类位于java.lang包中。默认情况下，该包被自动导入所有的程序。  
二、创建String对象的方法：

String s1 = "imooc";
    String s2 = new String();
    String s3 = new String("imooc");

##### 02-02 java中字符串的不变性 #####

一、String对象创建后则不能被修改，是不可变的，所谓的修改其实是创建了新的对象，所指向的内存空间不同。

String s1 = "爱慕课";
    String s2 = "爱慕课";
    String s3 = new String("爱慕课");
    String s4 = new String("爱慕课");
    // 多次出现的字符串常量，java编译程序只创建一个，所以返回true
    System.out.println(s1 == s2);
    // s1和s3是不同的翠香，所以返回false
    System.out.println(s1 == s3);
    // s3和s4是不同的翠香，所以返回false
    System.out.println(s3 == s4);
    
    s1 = "欢迎来到：" + s1;
    System.out.println(s1);

1、通过String s1 = “爱慕课”，声明了一个字符串对象，s1存放了到字符串对象的应用，在内存中的存放引用关系如下图所示：  
![在这里插入图片描述][20190822142340107.png]  
然后通过s1 = “欢迎来到” + s1;改变了字符串s1,其实质是创建了新的字符串对象，变量s1指向了新创建的字符串对象，如下图所示  
![在这里插入图片描述][20190822142437516.png]  
2、如果需要一个可以改变的字符串，我们可以使用StringBuffer或者StringBuilder  
（1）StringBuffer是线程安全的，而StringBuilder没有实现线程安全功能，所以新能略高。因此一般情况下，如果需要创建一个内容可变的字符串兑现个，应优先考虑使用StringBuilder类。  
(2)在需要频繁对字符串进行修改操作时使用 StringBuilder 的效率比 String 要高.  
StringBuilder > StringBuffer > String  
3、每次new一个字符串就是产生一个新的对象，即使两个字符串的内容相同，使用“==”比较时也为“false”，如果只需比较内容是否相同，应使用“equals()”方法。

###### 02-03 java中的String类常用方法I ######

一、String方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int length()</td> 
   <td>返回当前字符串的长度</td> 
  </tr> 
  <tr> 
   <td>int indexOf(int ch)</td> 
   <td>查找ch字符在该字符串中第一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>int indexOf(String str)</td> 
   <td>查找str子字符串在该字符串中第一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(int ch)</td> 
   <td>查找ch字符在该字符串中最后一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>int lastIndexOf(String str)</td> 
   <td>查找str子字符串在该字符串中最后一次出现的位置</td> 
  </tr> 
  <tr> 
   <td>String substring(int beginIndex)</td> 
   <td>获取从beginIndex位置开始到结束的子字符串</td> 
  </tr> 
  <tr> 
   <td>String substring(int beginIndex, int endIndex)</td> 
   <td>获取从beginIndex开始到endIndex位置的子字符串</td> 
  </tr> 
  <tr> 
   <td>String trim()</td> 
   <td>返回去除了前后空格的字符串</td> 
  </tr> 
  <tr> 
   <td>boolean equals(Object obj)</td> 
   <td>将该字符串与指定对象比较，返回true或false</td> 
  </tr> 
  <tr> 
   <td>String toLowerCase()</td> 
   <td>将字符串转换为小写</td> 
  </tr> 
  <tr> 
   <td>String toUpperCase()</td> 
   <td>将字符串转换为大写</td> 
  </tr> 
  <tr> 
   <td>char charAt(int index)</td> 
   <td>获取字符串中指定位置的字符</td> 
  </tr> 
  <tr> 
   <td>String[] split(String regex, int limit)</td> 
   <td>将字符串分给为子字符串，返回字符串数组</td> 
  </tr> 
  <tr> 
   <td>byte[] getBytes()</td> 
   <td>将该字符串转换为byte数组</td> 
  </tr> 
 </tbody> 
</table>

##### 02-04 java中的String类常用方法 #####

一、"`==`" 和equals()有什么区别呢  
1、"`==`"：判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象  
equals()：比较存储在两个字符串对象中的内容是否一致  
二、字节  
1、字节是计算机存储信息的基本单位，1 个字节等于 8 位， gbk 编码中 1 个汉字字符存储需要 2 个字节，1 个英文字符存储需要 1 个字节。  
2、汉字转换为字节后超过 127，如果超过就会溢出，以负数的形式显示。

###### 02-06 java中的StringBuilder类的常用方法 ######

一、StringBuilder类的常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>StringBuilder append(参数)</td> 
   <td>追加内容到当前StringBuilder对象的末尾</td> 
  </tr> 
  <tr> 
   <td>StringBuilder insert(位置，参数)</td> 
   <td>将内容插入到StringBuilder对象的指定位置</td> 
  </tr> 
  <tr> 
   <td>String toString()</td> 
   <td>将StringBuilder对象转换为String对象</td> 
  </tr> 
  <tr> 
   <td>int length()</td> 
   <td>获取字符串的长度</td> 
  </tr> 
 </tbody> 
</table>

二、字符串是对象。

### 第03章 java中必须了解的常用类 ###

##### 03-01 java中的包装类 #####

一、为了让基础数据类型也具备对象的特性，java为每个基本数据类型提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。

<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>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

二、Integer包装类的构造方法

<table> 
 <thead> 
  <tr> 
   <th>Integer(int value)</th> 
   <th>构建一个integer对象，表示指定的this值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Integer(String)</td> 
   <td>创建一个Integer对象，表示String参数所指示的int值</td> 
  </tr> 
 </tbody> 
</table>

三、Integer包装类的常用方法

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>byteValue()</td> 
   <td>将该Integer转为byte类型</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>doubleValue()</td> 
   <td>转为double类型</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>floatValue()</td> 
   <td>转为float类型</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>intValue()</td> 
   <td>转为long类型</td> 
  </tr> 
  <tr> 
   <td>static int</td> 
   <td>parseInt(String s)</td> 
   <td>将字符串转换为int类型</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>toString()</td> 
   <td>转为字符串类型</td> 
  </tr> 
  <tr> 
   <td>static Integer</td> 
   <td>valueOf(String s)</td> 
   <td>将字符串转为Integer类型</td> 
  </tr> 
 </tbody> 
</table>

##### 03-02 java中基本类型和包装类之间的转换 #####

一、装箱：把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱

int i = 10; // 定义一个int基本类型值
    Integer x = new Integer(i); // 手动装箱
    Integer y = i ; // 自动装箱

二、拆箱：和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱

Integer j = new Integer(8); // 定义一个Integer包装类对象，值为8
    int m = j.intValue(); // 手动拆箱为int类型
    int n = j; // 自动拆箱为int类型

##### 03-04 java中基本类型和字符串之间的转换 #####

一、基本类型转换为字符串有3种方法  
1、使用包装类的toString()方法  
2、使用String类的valueOf()方法  
3、用一个空字符串加上基本类型，得到的就是基本类型数据对应的字符串

// 将基本类型转换为字符串
    int c = 10;
    String str1 = Integer.toString(c); // 方法1
    String str2 = String.valueOf(c); // 方法2
    String str3 = c + ""; // 方法三

二、将字符串转换成基本类型的方法  
1、调用包装类的parseXxx静态方法  
2、调用包装类的valueOf()方法转换为基本类型的包装类，会自动拆箱。

// 将字符串转换为基本类型
    String str = "8";
    int d = Integer.parseInt(str); // 方法1，如果是double的话，就是Double b = Double.parseDouble(str);
    int e = Integer.valueOf(str); // 方法2

三、包装类都在java.lang中

##### 03-06 使用Date和SimpleDateFormat #####

一、日期  
1、调用SimpleDateFormat对象的parse()方法时可能会出现转换异常，即ParseException，因此需要进行异常处理。  
2、使用Date类时需要导入java.util包，使用SimpleDateFormat时需要导入java.text包  
二、日期转换  
1、使用format()方法将日期转换为指定格式的文本

// 创建Date对象，表示当前时间
    Date d = new Date();
    // 创建SimpleDateFormate对象，指定日期格式
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    // 调用format()方法，格式化时间，转换为指定格式字符串
    String today = sdf.format(d);
    // 输出转换后的字符串
    System.out.println(today);

2、使用parse()方法将文本转换为日期

// 创建日期格式的字符串
    String day = "2014年02月14日 10:30:25";
    // 创建SimpleDateFormate对象，指定字符串的日期格式
    SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    // 调用parse()方法，将字符串转换为日期
    Date date = df.parse(day);
    // 输出转换后的时间
    System.out.println("当前时间：" + date);

三、使用Date类的默认无参构造方法创建出的对象就代表当前时间  
`Date d = new Date();`

##### 03-07 Calendar类的应用 #####

一、Date类主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用Calendar类进行事件和日期的处理。  
二、java.util.Calendar类是一个抽象类，可以通过调用getInstance()静态方法获取一个Calendar对象，此对象已由当前日期时间初始化，即默认代表当前时间，如Calendar c = Calendar.getInstance();

Calendar c = Calendar.getInstance(); // 设置Calendar对象
    int year = c.get(Calendar.YEAR); // 获取年
    int month = c.get(Calendar.MONTH); // 获取月份，0表示1月份
    int day = c.get(Calendar.DAY_OF_MONTH); // 获取日期
    int hour = c.get(Calendar.HOUR_OF_DAY); // 获取小时
    int minute = c.get(Calendar.MINUTE); // 获取分钟
    int second = c.get(Calendar.SECOND); // 获取秒
    System.out.println("当前时间：" + year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second);
    // 运行结果： 2019-08-23 09:36:28

调用Calendar类的getInstance()方法获取一个实例，然后通过调用get()方法获取日期时间信息，参数为需要获得的字段的值，Calendar.Year等为Calendar类中定义的静态变量。  
三、Calendar类提供了getTime()方法，用来获取Date对象，完成Calendar和Date的转换，还可通过getTimeInMillis()方法，获取此Calendar的时间值，以毫秒为单位。

Date date = c.getTime(); // 将Calendar对象转换为Date对象
    Long time = c.getTimeInMillis(); // 获取当前毫秒数
    System.out.println("当前时间：" + date);
    System.out.println("当前毫秒数：" + time);

运行结果：  
当前时间：Wed Jun 11 11:26:59 CST 2014  
当前毫秒数：1402457219381

##### 03-08 使用Math类操作数据 #####

一、Math类位于java.lang包中，包含用于执行基本数学运算的方法，Math类的所有方法都是静态方法，所以使用该类中的方法时，可以直接使用类名.方法名，如：Math.roung();

<table> 
 <thead> 
  <tr> 
   <th>返回值</th> 
   <th>方法名</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>long</td> 
   <td>round()</td> 
   <td>返回四舍五入后的整数</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>floor()</td> 
   <td>返回小于参数的最大整数</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>ceil()</td> 
   <td>返回大于参数的最小整数</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>random()</td> 
   <td>返回[0,1)之间的随机浮点数</td> 
  </tr> 
 </tbody> 
</table>

二、题目

// 定义一个整型数组，长度为10
    int[] nums = new int[10];
    
    // 产生10以为的随机数
    int x = (int)(Math.random() * 10);
    
    // 使用foreach循环输出数组中的元素
    for(int num: nums) {
    }

### 第04章 java中的集合框架（上） ###

##### 04-01 java中的集合框架概述 #####

一、集合  
1、java中的集合类：是一种工具类，就像是容器，存储任意数量的具有共同属性的对象  
2、集合的作用  
（1）在类的内部，对数据进行组织。  
（2）简单而快速地搜索大数量的条目。  
（3）有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速地插入或者删除有关元素。  
（4）有的集合接口，提供了映射关系，可以通过关键字（key）去快速查找到对应的唯一对象，而这个关键字可以是任意类型。  
二、集合、数组对比  
1、数组的长度固定，集合长度可变。  
2、数组只能通过下标访问元素，类型固定，而又的集合可以通过任意类型查找所映射的具体对象。  
三、java集合框架体系结构  
1、Collection  
（1）List：序列  
实现类：ArrayList（数组序列）、LinkedList（链表）  
（2）Queue：队列  
实现类：LinkedList（链表）、  
（3）Set：集  
实现类：HashSet（哈希集）  
2、Map  
实现类：HashMap（哈希表）  
key,value键值对存储

##### 04-02 Collection接口 & List接口简介 #####

一、Collection接口  
1、定义了可用于操作List、Set和Queue的方法-增删改查  
二、List接口及其实现类-ArrayList  
1、List是元素有序并且可以重复的集合，被称为序列。  
2、List可以精确得控制每个元素的插入位置，或删除某个位置元素。  
3、ArrayList-数组序列，是List的一个重要实现类  
4、ArrayList底层是由数组实现的。  
三、不能直接实例化Set,因为Set是一个接口，hashSet去对接口进行实例化。

##### 04-04 学生选课-添加课程I #####

一、通过Arrays工具类将数组转换成集合  
`Arrays.asList(course)`  
二、

public class ListTest {
    	// 给ListTest添加构造方法
      public ListTest() {
        this.coursesToSelect = new ArrayList();
      }
     }

三、当一个元素被添加到集合中的时候，对象存入集合都变成Object类型，取出时需要类型转换。

// 创建一个课程对象，并通过调用add方法，添加到备选课程List中
    Course cr1 = new Course("1", "数据结构");
    coursesToSelect.add(cr1);
    Course temp = (Course)coursesToSelect.get(0);
    System.out.println("添加了课程" + temp.id + ":" + temp.name);

##### 04-06 学生选课-课程查询 #####

一、Iterator  
1、返回此collection的元素上进行迭代的迭代器，关于元素返回的顺序没有任何保证（除非此collection是某个能提供顺序的类实例）。  
2、指定者：接口Iterable中的iterator。  
3、在此collection的元素上进行迭代的Iterator。  
二、Iterator只是用来遍历集合中元素的，不存储数据。  
三、forEach是迭代器方法的一种简便写法

for (Object obj: coursesToSelect) {
    }

##### 04-07 学生选课-课程修改 #####

一、set(int index, element);  
1、用指定元素替换列表中指定位置的元素（可选操作）。  
2、参数  
index - 要替换的元素的索引  
element - 要在指定位置存储的元素  
3、返回  
以前在指定位置的元素

##### 04-08 学生选课-课程删除 #####

一、remove  
1、remove(int index)  
（1）移除列表中指定位置的元素（可选操作）  
（2）参数  
index - 要移除的元素的索引  
（3）返回  
以前在指定位置的元素  
2、remove(Object o)  
（1）从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。  
如果列表不包含元素，则不更改列表，更确切地讲，移除满足（o==null ? null : o.equals(get(i))）的最低索引i的元素（如果存在这样的元素）。如果此列表已包含指定元素（或者列表由于调用而发生更改），则返回true。  
（2）参数  
o - 要从该列表中移除的元素，如果存在的话  
（3）返回  
如果列表包含指定的元素，则返回true  
二、removeAll  
1、从列表中异宠指定collection中包含的其所有元素（可选操作）。  
2、参数：  
o - 包含从此列表中移除的元素的collection

##### 04-09 学生选课-应用泛型管理课程 I #####

一、泛型  
1、集合中的元素，可以是任意类型的对象（对象的引用）。  
如果把某个对象放入集合，则会忽略他的类型，而把他当做Object处理。  
2、泛型则是规定了某个集合只可以存放特定类型的对象。  
会在编译期间进行类型检查。  
可以直接按指定类型获取集合元素。  
二、泛型集合中，不能添加泛型规定的类型及其子类型以外的对象，否则会报错  
三、已经规定了泛型Course，每次循环把元素作为Course类型取出来，就不用再把元素作为Object类型取出来再进行转换。

for (Course cr: courses) {}

##### 04-10 学生选课-应用泛型管理课程II #####

一、泛型集合  
1、泛型类型、泛型的子类型  
二、泛型集合中的限定类型，不能使用基本数据类型。  
可以通过使用包装类限定允许存入的基本数据类型  
int - Integer  
long - Long  
boolean - Boolean

##### 04-11 学生选课 - 通过set集合管理课程 #####

一、Set接口及其实现类 - HashSet  
二、Set接口及其实现类-HashSet  
1、Set是元素无序并且不可以重复的集合，被称为集。  
2、HashSet - 哈希集， 是Set的一个重要实现类。  
三、Set可以传null

### 第05章 java中的集合框架（中） ###

##### 05-01 Map & HashMap简介 #####

一、Map接口  
1、Map提供了一种映射关系，其中的元素是以键值对（key-value）的形式存储的，能够实现根据key快速查找value  
2、Map中的键值对以entry类型的对象实例形式存在  
![在这里插入图片描述][20190827095702184.png]  
3、键（key值）不可重复，value值可以。  
4、每个键最多只能映射到一个值。  
5、Map接口提供了分别返回key值集合，vlaue值集合以及Entry(键值对)集合的方法  
6、Map支持泛型，形式如：Map<K, V>  
二、HashMap类  
1、HashMap是Map的一个重要实现类，也是最常用的，基于哈希表实现。  
2、HashMap中的Entry对象是无序排列的。  
3、Key值和value值都可以为null，但是一个HashMap只能有一个key值为null的映射（key值不可重复）。  
三、通过keySet方法，返回Map中所有"键"的Set集合

// 通过keySet方法，返回Map中所有"键"的Set集合
        Set<String> keySet = students.keySet();
        // 取得students的容量
        System.out.println("总共有：" + students.size() + "个学生！");
        // 遍历kewSet，取得每一个键，再调用get()方法，取得每个键对应的value
        for (String stuId: keySet) {
          Student st = students.get(stuId);
          if (st != null) {
            System.out.println("学生：" + st.name);
          }
        }

四、接口可以像普通类一样，定义接口的引用，接口的引用指向的是实现了接口方法的类的实例化对象，该引用可以调用接口中的方法，但是不能像类一样进行实例化

Set keySet = new Set(); // 错误，接口不能实例化
    Set keySet; // 该变量是Set集合接口的引用，可以使用接口中的方法

##### 05-03 学生选课-删除map中的学生 #####

一、entrySet返回的是entry集合，entry本身也是带有泛型的，跟定义Map时的泛型一模一样。  
二、getValue返回的类型和泛型规定的类型是一样的

##### 05-04 学生选课-修改Map中的学生 #####

一、put  
1、将指定的值与此映射中的指定键关联（可选操作）。如果此映射以前包含一个该键的映射关系，则用指定值替换旧值（当且仅当m.containsKey(k)）返回true时，才能说映射m包含键k的映射关系。  
2、参数  
key - 与指定值关联的键  
value - 与指定键关联的值  
3、返回  
以前与key关联的值，如果没有针对key的映射关系，则返回null。（如果该值实现支持null值，则返回null也可能表示次映射以前将null与key关联）

### 第06章 java中的集合框架（下） ###

##### 06-01 学生选课-判断List中课程是否存在 #####

一、思考  
1、在课程序列中，如何判断是否包含某门或者某几门课程？  
2、如果课程序列包含某门课程，如何判断该课程的索引位置？  
3、在学生映射表中，如何判断是否包含某个学生ID？  
4、又该如何判断是否包含某个学生对象？  
5、如果想把课程或者学生对象，按照课程名称或者学生姓名排序又该怎么办？按照ID排序呢？  
二、contains  
如果此列表中包含指定的严肃，则返回true。  
更确切地讲，当且仅当此列表包含至少一个满足（onull?enull : o.equals(e)）的元素e时，则返回true。  
1、参数  
测试此列表中是否存在的元素  
2、返回  
如果此列表包含特定的元素，则返回true  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 12]

@Override
    public boolean equals(Object obj) {
    	if(this == obj)
    		return true;
    	if (obj == null) 
    		return false;
    	if(!(obj instanceof Course)) 
    		return false;
    	Course course = (Course) obj;
    	if(this.name == null) {
    		if(course.name == null) 
    			return true;
    		else
    			return false;
    	} else {
    		if(this.name.equals(course.name))
    			return true;
    		else
    			return false;
    	}
    }

三、containsAll  
如果列表包含指定collection的所有元素，则返回true  
1、参数  
要在列表中检查其包含性的collection  
2、返回  
如果列表包含指定collection的所有元素，则返回true  
3、抛出  
（1）ClassCastException：如果指定collection中的一个或多个元素的类型和此列表不兼容（可选）  
（2）NullPointerException：如果指定的collection包含一个或多个null元素并且此列表不允许null元素（可选），或者指定的collection为null

##### 06-02 学生选课-判断Set中课程是否存在 #####

一、  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 13]  
二、Object中，除了定义了equals(Object obj)方法，还定义了hashCode()方法，返回对象哈希码的值。  
三、我们调用hashSet() 的contains(obj)方法的时候，是先调用每个元素的hashCode()方法来返回哈希码，如果哈希码相等的情况下，再调用equals(obj)方法去判断是否相等。只有在这两个方法相等的情况下，hashSet()才返回相等。

##### 06-03 学生选课-获取List中课程的位置 #####

一、indexOf()  
二、lastIndexOf()

##### 06-04 学生选课-判断Map中是否包含指定的key值 #####

一、在Map中，用containsKey()方法，来判断是否包含某个Key值。  
二、在Map中，用containsValue()方法，来判断是否包含某个Value值  
1、和List中的contains()方法一样，Map中的containsValue()方法也需要调用每一个value值的equals()方法去和参数对象比较，如果匹配成功，那么返回结果为true.

##### 06-05 应用Collections.sort()实现 #####

一、Arrays类  
`java.util.Arrays`：包含操作数组的各种静态方法  
二、Collections工具类  
`java.util.Collections`  
1、是java集合框架中，用来操作集合对象的工具类  
2、也是java集合框架的成员。  
三、sort()排序方法  
1、根据元素的自然顺序对指定列表按升序进行排序。列表中的所有元素都必须实现Comparable接口。此外，列表中的所有元素都必须是可相互比较的（也就是说，对于列表中的任何e1和e2元素，e1.compareTo(e2)不得抛出ClassCastException。  
2、public statis void sort(List list, Comparator<? super T> e)  
根据指定比较器产生的顺序对指定列表进行排序。  
四、

package com.imooc.collection;
    /*
    * 1、通过Collections.sort()方法，对Integer泛型的List进行排序；
    * 2、对String泛型的List进行排序；
    * 3、对其他类型泛型的List进行排序，以Student为例。
    */
    public class CollectionsTest {
    	/**
    	* 1、通过Collections.sort()方法，对Integer泛型的List进行排序；
    	* 创建一个Integer泛型的List，插入十个100以内的不重复随机整数
    	* 调用Collections.sort()方法对其进行排序
    	*/
    	public void testSort1() {
    		List<Integer> integerList = new ArrayList<Integer>(); // 不能使用基本类型作为泛型，如果非要使用基本类型，就必须使用它们的包装类（int:基本类型，integer:包装类）
    		// 插入十个100以内的不重复随机整数
    		Random random = new Random();
    		Integer k;
    		for(int i = 0; i < 10; i++) {
    			do {
    				k = random.nextInt(100);	
    			} while(integerList.contains(k));
    			integerList.add(k);
    			System.out.println("成功添加整数：" + k);
    		}
    		System.out.println("-------排序前------");
    		for(Integer integer:integerList) {
    			System.out.println("元素：" + integer);
    		}
    		Collections.sort(integerList);
    		System.out.println("------排序后------");
    		for(Integer integer:integerList) {
    			System.out.println("元素：" + integer);
    		}
    	}
    	public static void main(String[] args) {
    		CollectionsTest ct = new CollectionsTest();
    		ct.testSort1();
    	}
    }

四、排列顺序：  
数字：0-9  
大写字母：A-Z  
小写字母：a-z

##### 06-07 Comparable & Comparator简介 #####

一、Comparable： 默认比较规则  
Comparator: 临时比较规则  
二、Comparable接口-可比较的  
1、实现该接口表示：这个类的实例可以比较大小，可以进行自然排序  
2、定义了默认的比较规则。  
3、其实现类需实现comparaTo()方法  
4、comparaTo()方法返回正数表示大，负数表示小，0表示相等。  
三、Comparator接口-比较工具接口  
1、用于定义临时比较规则，而不是默认比较规则。  
2、其实现类需要实现compare()方法  
3、Comparator和Comparable都是java集合框架的成员。  
四、Java集合框架：Collection接口，Collections工具类，Map接口、Comparable接口、Comparator接口

##### 06-08 学生选课-实现学生序列排序 #####

一、接口Comparator  
1、类型参数：此Comparator 可以比较的西乡类型  
强行对某个对象collection进行整体排序的比较函数。可以将Comparator传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。  
二、Collection, Map  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 14]  
二、Collections工具类  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 15]

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

# <table>   <tbody>    <tr>     <td> 20200709-20020709：《imooc-文件传输基础-java io流》</td>    </tr>   </tbody>  </table>  <table></table> #

地址：https://www.imooc.com/learn/123  
类目：入门必学-文件操作

### 第01章 文件的编码 ###

##### 01-01 文件的编码 #####

一、gbk编码中文占用2个字节，英文占用1个字节。  
二、utf-8编码中文占用3个字节，英文占用1个字节。  
三、java是双字节编码， utf-16be  
四、ut-16be编码，中文占用2个字节，英文占用2个字节。  
五、当你的字节序列是某种编码时，这个时候想把字节序列变成字符串，也需要用这种编码方式，否则会出现乱码。  
六、如果我们在中文机器上直接创建文本文件，那么该文本文件只认识ansi编码

### 第02章 File类的使用 ###

##### 02-01 File类常用API介绍 #####

一、java.io.File类用于表示文件（目录）  
File类只用于表示文件（目录）的信息（名称、大小等），不能用于文件内容的访问。  
二、方法  
1、`exists()`：判断文件/文件夹是否存在  
2、`midir()`：创建文件夹  
3、`delete()`：删除文件夹  
4、`File.separator`： 设置分隔符  
5、`file.isDirectory()`：判断是否是一个目录  
6、`file.isFile()`：判断是否是一个文件  
7、`createNewFile()`: 创建文件

### 第03章 RandomAccessFile类的使用 ###

##### 03-01 RandomAccess基本操作 #####

一、RandomAccessFile  
1、java提供的对文件内容的访问，既可以读文件，也可以写文件。  
2、RandomAccessFile支持随机访问文件，可以访问文件的任意位置。  
二、java文件模型  
在硬盘上的文件是byte byte byte存储的，是数据的集合。  
三、打开文件  
1、有两种模式：`rw`:读写，`r`：只读。  
2、`RandomAccessFile raf = new RandomAccessFile(file, "rw");`  
3、文件指针，打开文件时，指针在开头`pointer = 0;`  
四、写方法  
raf.write(int) —> 只写一个字节（后8位），同事指针指向下一个位置，准备再次写入  
五、读方法  
int b = raf.read() —> 读一个字节  
六、文件读写完成以后一定要关闭（Oracle官方说明）

### 第04章 字节流 ###

##### 04-01 字节流之文件输入流FileInputStream-1 #####

一、IO流（输入流、输出流）  
二、字节流、字符流  
1、字节流  
（1）InputStream、OutputStream  
InputStream抽象了应用程序读取数据的方式  
OutputStream抽象了应用程序写出数据的方式  
（2）EOF = End 读到-1就读到结尾  
（3）输入流基本方法  
int b = in.read(); 读取一个字节无符号填充到int低八位。 -1是EOF  
in.read(byte\[\] buf) 读取数据填充到字节数组buf  
in.read(byte\[\] buf, int start, int size) 读取数据到字节数组buf，从buf的start位置开始存放size长度的数据。  
（4）输出流基本方法  
out.write(int b) 写出一个byte到流，b的低8位  
out.write(byte\[\] buf) 将buf字节数组都写入到流  
out.write(byte\[\] buf, int start, int size) 字节数组buf从start位置开始写size长度的字节到流  
（5）FileInputStream --> 具体实现了在文件上读取数据  
（6）FileOutputStream 实现了向文件中写出byte数据的方法  
（7）DataOutputStream / DataInputSteam 对”流“功能的扩展，可以更加方面地读取int, long，字符等类型数据DataOutputStream  
writeInt() / writeDouble() / writeUTF()  
（8）BufferedInputStream&BufferedOutputStream  
这两个流类位IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种留模式提高了IO的性能。  
①从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中：  
FileOutputStream --> write()方法相当于一滴一滴地把水”转移“过去  
DataOutputSteam --> writeXxx(）方法会方便一些，相当于一瓢一瓢把水”转移“过去  
BufferedOutputSteam --> write方法更方便，相当于一瓢一瓢先放入桶中，再从桶中倒入到另一个缸中（性能提高）  
三、byte类型8位，int类型32位，为了避免数据转换错误，通 过&0xff将高24位清零

##### 04-03 字节流输出流FileOutputStream #####

// 如果该文件不存在，则直接创建，如果存在，删除后创建
    FileOutputStream out = new FileOutputStream("demo/out.dat");
    // 如果该文件不存在，则直接创建，如果存在，则在文件内容后追加
    FileOutputStream out = new FileOutputStream("demo/out.dat", true);

##### 04-04 字节流之数据输入输出流 #####

// 采用utf-8编码写出
    dos.writeUTF("中国");
    // 采用utf-16be编码写出
    dos.writeChars("中国");

### 第05章 字符流 ###

##### 05-01 字节字符转换流 #####

一、字符流  
1、编码问题  
2、认识文本和文本文件  
java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）  
文件是byte byte byte…的数据序列  
文本文件是文本（char）序列按照某种编码方案（utf-8, utf-16be, gbk）序列号为byte的存储结果。  
3、字符流（Reader Writer) --> 操作的是文本文本文件  
字符的处理，一次处理一个字符。  
字符的底层仍然是基本的字节序列。  
（1）字符流的基本实现  
InputStreamReader 完成byte流解析为char流，按照编码解析。  
OutputStreamWriter 提供char流到byte流，按照编码处理。  
4、FileWriter  
FileReader  
5、字符流的过滤器  
BufferedReader -> readLine 一次读一行  
BufferedWriter / PrintWriter -> 写一行

### 第06章 对象的序列化和反序列化 ###

##### 06-01 序列化基本操作 #####

一、对象的序列化，反序列化  
1、对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化  
2、序列化流（ObjectOutputStreeam)，是过滤流 – writeObject  
反序列化流(ObjectInputStream) – readObject  
3、序列化接口（Serializable)  
对象必须实现序列化接口，才能进行序列化，否则将出现异常。  
这个接口，没有任何方法，只是一个标准  
二、transient关键字 // 该元素不会进行jvm默认的序列化，也可以自己完成这个元素的序列化。

private void writeObject(java.io.ObjectOutputStream s)
    	throws java.io.IOException
    private void readObject(java.io.ObjectInputStream s)
    	throws java.io.IOException, ClassNotFoundException

三、分析ArrayList源码中序列化和反序列化的问题。  
四、一个类实现了序列化接口，那么其子类都可以进行序列化。  
五、对子类对象进行反序列化操作时，如果其父类没有实现序列化接口，那么其父类的构造函数会被调用。

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

# <table>   <tbody>    <tr>     <td> 20200708：《imooc-java眼中的xml-文件读取》</td>    </tr>   </tbody>  </table>  <table></table> #

地址：https://www.imooc.com/learn/171  
类目：入门必学-文件操作  
aSuncat：现在都用json，不用xml，所以不看了。

### 第01章 xml的初次邂逅 ###

一、节点名称区分大小写

<?xml version="1.0" encoding="UTF-8">
    <bookstore>
    	<book></book>
    </bookstore>

### 第02章 应用DOM方式解析XML ###

##### 02-01 如何进行XML文件解析前的准备工作 #####

一、四种解析方式  
DOM、SAX、DOM4J、JDOM  
1、DOM、SAX：解析时不需要额外的jar包  
2、DOM4J、JDOM：解析时需要额外的jar包

##### 02-03 使用DOM解析XML文件的节点名和节点值 #####

<table> 
 <thead> 
  <tr> 
   <th>节点类型</th> 
   <th>NodeType</th> 
   <th>Named Constant</th> 
   <th>nodeName的返回值</th> 
   <th>nodeValue的返回值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Element</td> 
   <td>1</td> 
   <td>ELEMENT_NODE</td> 
   <td>element name</td> 
   <td>null</td> 
  </tr> 
  <tr> 
   <td>Attr</td> 
   <td>2</td> 
   <td>ATTRIBUTE_NODE</td> 
   <td>属性名称</td> 
   <td>属性值</td> 
  </tr> 
  <tr> 
   <td>Text</td> 
   <td>3</td> 
   <td>TEXT_NODE</td> 
   <td>#text</td> 
   <td>节点内容</td> 
  </tr> 
 </tbody> 
</table>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190705090217863.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190705101318481.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190705104156925.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2019070817024290.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20190709121708337.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200707110004401.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[202007071314040.png]: https://img-blog.csdnimg.cn/202007071314040.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200708083713741.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200708083728369.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200708084106950.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/2020070809150834.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[20200708091436566.png]: https://img-blog.csdnimg.cn/20200708091436566.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20200708091711142.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/20200708091905582.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[20190822142340107.png]: https://img-blog.csdnimg.cn/20190822142340107.png
[20190822142437516.png]: https://img-blog.csdnimg.cn/20190822142437516.png
[20190827095702184.png]: https://img-blog.csdnimg.cn/20190827095702184.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20200708161845351.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/20200708171409204.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20200709111013888.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/20200709111044869.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FTdW5jYXQ=,size_16,color_FFFFFF,t_70