javaSE基础大全--知识点总结
J2SE
1、Java简介
Java是SUN公司开发，后来被oracle收购。
Java之父，詹姆斯高斯林。
2、Java不同版本
J2SE：Java标准版
J2EE：Java企业版
J2ME：Java嵌入式
J2ME（Java2 Micro Edition，Java2平台的微型版），应用于移动、无线及有限资源的环境；
J2SE（Java 2 Standard Edition，Java 2平台的标准版），应用于桌面环境；
J2EE（Java 2Enterprise Edition，Java 2平台的企业版）
3、Java的特点
重点讲5个：可移植 面向对象 垃圾自动回收（GC） 鲁棒性 简单性
可移植性：一处编译，到处运行。
4、什么是JDK
JDK(Java Development Kit) 是 Java 语言的软件开发工具包(SDK)。
5、安装JDK
下载安装包，两个压缩包。
解压1.7，解压到任意一个路径，不要用中文的路径。
操作步骤：
打开cmd，输入java回车，看是否输出Java相关信息，在输入javac，看是否输出Java相关信息，如果两次都输出，那么说明配置正确。
6、第一个程序
注意：
1、修改文件后缀名，java文件
2、书写代码
public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello World !");
}
}3、文件的名字，一定要和class后面的名字一致。
4、在dos命令中写javac HelloWorld.java。是编译我们刚写好的代码。
5、在dos命令中写java HelloWorld，注意不要有.class或者.java，只有文件名。
7、Java程序运行原理
1、写好一个源文件（Java文件）
2、通过Java编译源文件，生成字节码文件（.class文件）
3、字节码文件运行在Java虚拟机上，Java虚拟机运行在操作系统上，这样就实现了一次编译到处运行的可移植性。
8、JDK
bin目录：这个目录是存放可执行程序的。
JRE目录：Java运行时环境
9、JRE
JRE（Java Runtime Environment，Java运行环境），运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。
10、JVM
JVM是Java Virtual Machine（Java虚拟机）完成加载、校验和执行三项任务
11、eclipse配置
设置编码集
设置view
快捷键：
快速复制选中代码：ctrl+alt+上下
移动选中代码：alt+上下
快速生成get/set方法：alt+shift+s，选择getter and setter
单行注释：ctrl+/
多行注释：ctrl+shift+/
重写方法：alt+shift+s，选择
12、注释
注释就是对代码的解释和说明，其目的是让人们能够更加轻松地了解代码。注释是编写程序时，写程序的人给一个语句、程序段、函数等的解释或提示，能提高程序代码的可读性。
注释就是跟人看话，不是给计算机看的。正式的代码是给计算机看的，注释中的东西不会被编译，不会影响程序。为了让维护这段代码获调用这段代码的人，更方便。
1、单行注释：//
2、多行注释：/* */
3、文档注释：/** */
文档注释是可以导出说明文档的，可以帮助开发人员开发。
13、标识符、关键字
标示符（IDentifier）是指用来标识某个实体的一个符号。在不同的应用环境下有不同的含义。
标识符的规则：
1、以数字、字母、下划线和美元符号（$）组成
2、数字不能作为开头
关键字
关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。
14、变量
变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。
15、数据类型
数据类型分两种：1、引用数据类型
2、基础数据类型
基础数据类型：
四类八种
1、整型
整型就是可以存储整数的数据类型，Java中所有的整型都分正负。整型直接运算一定得到整型。
整型在做运算时会被默认作为int数据类型运算，所以btye、short在运算时，注意，如果和整型常量运算，会被转化成int。
s1 = s1 + 1会报错，因为被默认转化成int运算了。
s1 += 1;这种写法不会报错，拓展运算符可以免去数据类型转换的问题。
1、byte
内存占1个字节，一个字节占8位
取值范围：-128~127
2、short
内存占2个字节，16位。
取值范围：负2的15次方~2的15次方-1
3、int（重点记忆）
内存占4个字节，32位
取值范围：负2的31次方~2的31次方-1 2147483647
4、long
内存占8个字节，64位
取值范围：负2的63次方~2的63次方-1
如果确认是long数据类型，那么在声明时一定要加一个L（可以用小写的l，但是建议用大写，因为小写和1比较相似，容易认错）
2、浮点型
存储小数的数据类型
因为0到1之间有无数多个小数，所以我们没有办法用有限的空间存储无限多的数。小数在计算机中都是以近似值存储。所以浮点型是有一个精度范围的。
浮点型中，double是默认的数据类型，float只有在数据后加一个f（F）才表示这是一个float数据类型。
1、float
内存占4个字节，32位
单精度浮点型，精度是7位（一共7位，包括整数部分和小数部分）
2、double（常用的存储小数的数据类型）
内存占8个字节，64位
双精度浮点型，精度是15（一共15位，包括整数部分和小数部分）
3、字符型
1、char
存储字符的数据类型
内存占4个字节，可以存储一个字符。
4、布尔型
1、boolean
表示真假的数据类型，只有两个值：true（真）、false（假）
内存占1个字节
5、数据类型转换
基础数据类型转换。
byte à short à int à long à float à double
直接赋值，因从小到大，不需要强制数据类型转换。
反方向要求必须强制数据类型转换
（要转换成成数据类型）变量
16、运算符
1）算数运算符==》重点讲解 ++，--，%和/的区别
1/2=?
在Java中，整型做算数运算一定会得到一个整型
浮点型运算才会得到浮点型
所以1/2=0；
% 取余
自加符号：++
int i = 10;
i++;//相对于表达式先赋值再自加10
++i;//相对于表达式先自加再赋值11
2）逻辑运算符==》&，|，！和 &&，|| ，重点讲解 & 和&&的区别
逻辑运算符是运算boolean数据类型的运算符。
&& || ！（短路与、或）
& | （不短路与、或）
以&和&&为例
（&&）如果第一个表达式是false，那么运算结果就是false，第二个表达式没有必要一定运行，这被称为短路。
（&）要将两个表达式计算结束之后，才会返回结果，也就是无论第一个表达式是什么结果，第二个表达式都会运行。
3）关系运算符==》>,<>=,<=,==,!=，
!=是不等号
4）扩展运算符==》+=，-=...重点讲他的好处
i = i + 1;
i += 1;
5）连接符==》 +
可以将两个字符串连接起来
6）赋值符号==》=
7）三目运算符==》 布尔表达式 ？值1：值2 重点讲解 好处
布尔表达式 ？值1：值2
如果布尔表达式为true，那么执行值1，如果是false，那么执行值2
public class Text {
public static void main(String[] args) {
int a = 5;
int b = 7;
/*
* 00000101
* 00000111
* | 00000111
* & 00000101
*/
System.out.println(a | b);
System.out.println(a & b);
System.out.println(1 + 2 + "a" + "b" + 5 + 3);
System.out.println(1 + 2 + "a" + "b" + (5 + 3));
/*
* 当执行到a时会转换成字符串运算，结果是3ab53
* 但是如果在加了一个括号，5+3就不会转换成字符串运算，结果3ab8
*
*/
}
}17、分支语句
1、if
如果（表达式）{
}
if(){
}
if语句中的表达式，必须是一个boolean类型的数据，或者是一个通过运算可以得到boolean类型数据的表达式。
2、if else
如果（表达式）{
}否则{
}
if(){
}else{
}
如果表达式为true，执行if中的代码，如果为false，执行else中的代码。
3、if else if else if …..else
如果s>=90则执行优秀，
否则如果s >= 80 则执行良好
…….
否则执行不及格
4、switch
switch(表达式){
case 表达式1: 语句1;
case表达式2: 语句2;
default 语句;
}
1、表达式是的值会依次和case中的表达式1、表达式2比较，如果相等，则执行对应后面的语句，都不相等会执行default中的语句。
2、switch有穿透性，如果表达式和表达式1相同，执行语句1后，会继续执行语句2，所以如果不希望穿透，那么用break打断。
3、表达式的规则
byte、short、int、char，
1.5之后可以用枚举类型
1.7之后可以用String类型
表达式是一个在运算时被转化成int数据类型运算的数据数据类型。
18、命名规范
1、遵守基本命名规范
类名首字母大写
变量首字母小写
2、遵守公司的命名规范
3、驼峰标识、见名知意
每个单词的首字母大写，其他全部小写（同时符合第一条）
看见这个变量名，就知道他是做什么用的。
19、循环语句
1、for
for(表达式1; 表达式2; 表达式3){
循环体
}
1、执行表达式1
2、通过表达式2的结果判断是否执行循环体内容。如果表达式2返回为true，则执行循环体中内容，如果表达式2返回false，则跳出循环，程序继续向下执行。
3、如果执行了循环体，那么在执行表达式3
4、如果执行了表达式3，那么继续执行表达式2，重复第2点
2、while
while(表达式){
循环体
}
1、如果表达式为true，则执行循环体
2、如果表达式为false，跳出循环，程序继续向下执行
3、do while
do{
循环体
}while(表达式);
1、先执行循环体
2、判断表达式如果为true，那么再次执行循环体
3、如果为false，那么跳出循环，继续向下执行
4、注意：do while循环，while括号后一定要有一个分号（;），没有报错
4、break
打断程序运行，除了可以打断switch，还可以打断循环
5、continue
让程序继续向下执行，如果程序执行到continue，那么将程序下面的语句跳过，使程序进入下一次循环。
6、注意事项
1、do while循环最后的分号
2、除特殊情况外，不要让程序出现死循环（一直循环，不结束）
3、break和continue经常和循环配合出题
20、数组
1、什么是数组
数组是内存中一段连续的存储空间。
2、定义数组
1、用数组中每个元素数据类型声明一个数组，数据类型名[] 变量名
int[] a = new int[10];
数据类型名 变量名[]
int a[] = new int[10];
2、取值
通过数组变量下角标取值 a[n]
a[n]取的是第n+1位置的数据，计算机中所有集合的开始都是从0开始的。
3、数组赋值
第一种通过遍历数组，给数组中的每一个数据赋值
第二种通过初始化的方式给数组中每个元素赋值
注意：数组只有在声明的时候可以通过初始化方式赋值
4、数组排序
int[] b = {0,1,2,3,4,5,6,7,8,9,10};
for(int i = 0; i < b.length; i++){
for(int j = i + 1; j < b.length; j++){
if(b[i] < b[j]){
int temp = b[i];
b[i] = b[j];
b[j] = temp;
}
}
for(int k = 0; k < b.length; k++){
System.out.print(b[k] + " ");
}
System.out.println();
}5、多维数组
多维数组定义：int[][] a = new int[长度1][长度2];
长度1必须要写，长度2可以暂时不写，在用的时候初始化
长度2不是必须相同的，可以是不同，如下图
21、main方法
main方法是主程序的入口，程序从main方法的第一行开始执行，一直执行到最后一行结束。
public：公共的
static：静态的
void： 空的
main方法就是一个公用的静态的没有返回的方法。
22、面向对象
1、什么是面向对象
例子1：
我开车去新疆
面向过程：
我要先造一辆汽车，再造一个宇宙、再造一个地球，再造一个新疆，然后开车去新疆。
面向对象：
我开着我买的兰博基尼，走在高速公路，到新疆。
汽车不用我造，新疆也不用我造，我只要会开车，知道新疆在哪就可以过去。
例子2：
我去饭店吃一份蛋炒饭
面向过程：
我到饭店，然后找到饭店里的鸡蛋，没有出去买，没有买的，需要找一只鸡生鸡蛋，没有鸡，我要找鸡蛋，孵出一只鸡，没单。。。。进入死循环
面向对象：
我到饭店，点菜蛋炒饭，饭店做好我吃。
2、应用面向对象
1、什么是类，什么是对象
类是对象的模板
电脑：类 这台电脑：对象
杯子：类 这个杯子：对象
2、如何创建一个类，如何创建一个对象
创建一个类：右键new à class à给class赋一个名字
创建一个对象：类名 变量名 = new 类名();
在创建一个类中：
名词性：属性 年龄、性别、姓名、家庭住址。。。。
动词性：方法 学习、听课、写作业、玩。。。。
3、如何定义方法
1、给方法选一个合适的名字
2、是否需要返回值，如果需要，返回的数据类型应该是什么
3、
权限修饰符 （其他修饰符）返回值数据类型（如果有，那么写这个类型，没有写void） 方法名（参数）{
}
权限修饰符：访问权限？？？？？？？
其他修饰符：static（静态）
返回值数据类型：void和数据类型
方法名：符合标识符规范，符合命名规范
参数：需要就写，不需要就不写。数据类型 形式参数名（见23.3.3）
3、面向对象三大特征
1、继承
2、封装
3、多态
（抽象）
23、成员变量和局部变量
1、成员变量
又叫做属性，也叫全局变量，是类的名词类属性
2、局部变量
局部变量是应用于一个部分的变量，他的作用范围只对应这个局部
3、注意事项
1、作用域
成员变量作用域是整个类，局部变量是离他最近的一对闭合大括号之间
2、初始化值
局部变量必须赋初始值才能用，成员变量不需要赋初值就可以用。
成员变量如果没有初始值，那么他们会有Java自动赋值
引用数据类型
初始化的值都是null
基础数据类型
byte、short、int、long 初始值都是0
float、double 初始值都是0.0
char 初始值是一个=0的字符
boolean 初始值是false
3、形式参数和实际参数
形式参数就是方法声明时的参数
实际参数是真正存放数据的那个变量
如果是基础数据类型：
形式参数改变的值是传递过来赋值给参数的值，也就是说改变的事形式参数的值，实际参数不会发生变化。
如果是引用数据类型：
修改形式参数的值会同时改变实际参数的值。Sting和基础数据类型的封装类是一个特殊的，和基础数据类型处理这个问题的方式相同。
基础数据类型是值传递、引用数据类型是引用传递。
24、构造函数
1、构造函数
又叫构造方法，又叫构造器
构造函数是用来创建一个对象的方法
如果类中没有构造方法，Java会帮助我们加一个默认的构造方法，默认的构造方法是一个没有参数的构造方法。
构造方法的几个特点：
1、不用声明出来的返回值类型
2、一定和类名一样
3、如果自定义了构造函数，并且有参数，那么无参的构造函数将被取消。
2、方法重载
在一个类（有继承关系的是方法的重写）中允许出现多个相同名字的方法，但是必须满足方法重载的要求。
1、方法名字一定相同
2、参数一定不相同（数据类型、个数、顺序）
3、返回值类型和权限修饰不作为方法重载的判断条件
25、this关键字
this关键字表示的是当前这个类，我们可以通过this调用类的属性和方法，如果出现形参和属性变量名相同时，要用this.属性名才可以调用到属性。
26、对象的初始化顺序
属性在构造方法之前初始化
27、static关键字
static表示静态，static可以修饰属性、方法、类、代码块
静态变量：static修饰的变量就是静态变量，静态变量又叫类的属性，如果这个类的任何一个对象修改了这个属性值，那么这个类的所有对象属性值都会发生变化。
操作静态变量时，总是用类名.静态属性名操作
静态方法：static修饰的方法是静态方法。
调用静态方法时，用类名.静态方法名
28、package
1、创建包
是包的意思，包对应文件管理器就是文件夹的意思。包可以帮助我们更好的管理代码，实现项目的拓展性。
包有自己的规范，这个规范非常重要，一定要按照规范创建包。
命名规范：公司域名倒叙写，全部小写
百度为例：http://www.baidu.com
com.baidu.描述
2、引用包
如果要用其他包中的类，需要通过关键字import引入这个包。
也可以用import org.jsoft.vo.*;但是这种写法比较少见，因为要索引具体类，快捷键不会提示。
29、继承
1、什么是继承
动物（animal）父类
狗（dog）子类
猫（cat）子类
猫也是动物，所以猫是从动物类继承过来的。
父类：被继承的那个类
子类：继承的类
超类：多次继承关系之前的类
2、特点
父类中的属性和方法，在子类中都可以用（权限修饰允许的前提下）
3、方法的重写
1、必须和父类方法完全一样，包括方法名和参数
2、如果想要调用父类方法和属性，需要用到super关键字
3、返回值类型一定要和父类相同
4、抛出异常也要相同（？？？？）
4、JavaBean
1、必须有一个pubic无参构造方法
2、所有的属性都要是private权限修饰
3、属性要求有get/set方法
30、访问权限
public多数用于修饰方法，private多数用于修饰属性。
protected一般在写底层代码时用的比较多，没有修饰符的用的是最少的，很少使用。
31、多态
1、Object
Object是所有类的超类，所有的类都直接或间接的继承了Object。每一个子类都会从父类继承属性或者方法，但是Java是一个单继承语言，子类除了可以用父类的东西，也可以从超类中获得，所有Object中所有的方法，子类都可以用。
2、特征
1、一定有继承关系
类与类要有继承关系才能体现多态，人和男人有继承关系，人和石头
2、有方法的重写（覆盖）
如果没有方法重写，那么不需要多态，直接调用方法即可，所以要用多态就要有方法重写。
3、父类引用指向子类对象
猫是动物，动物不是猫
带入公式
3、优点
降低耦合度，使程序拓展性更强。（高内聚低耦合）
32、封装
所有属性全部都是private修饰，给属性添加get/set方法。封装属性。
方法封装：
把重复使用的代码作为一个方法封装起来，这如果要改逻辑，只需要修改封装好的方法即可，不需要到处修改，这样提高了代码的维护性和可读性。
33、final
最后的、最终的
可以修饰属性、方法和类
修饰属性不能修改值，第一次赋值以后都不允许改变。不能改变，指的是引用不能变，但是对象的属性可以改变。
修饰的方法，不能重写。但是重载可以
修饰的类，不能被继承。
34、抽象类
1、语法
1、定义用abstract关键字修饰类名
2、特点：只能被继承不能被实现。
子类继承抽象类，必须实现抽象类中的所有抽象方法。
抽象类中比类可以多写一种方法：抽象方法。
2、应用场景
当需要统一调用一个方法时，每个子类对于这个方法的具体实现都不同，我们可以通过抽象出抽象类解决这个问题，具体方法实现交给子类实现，父类（抽象类）中统一调用。
35、接口
接口是编程规范规则的工具，interface就是接口。
通过USB接口来理解接口概念。
1、定义
用interface定义接口
2、语法
接口中只能有方法的声明，不能有方法的实现（即不能被new）。
接口中的方法都是抽象方法，都是public权限修饰，abstract和public关键字可以省略不写，JDK会帮助我们添加。
接口中可以声明常量，不可以声明变量。
接口不能被new，只能被implements。
在项目设计时先有接口后有实现类。
接口允许多实现，每个接口用逗号分隔
36、代码块
代码块是一对{}直接的代码，都属于同一个代码块
1、普通代码块
2、构造代码块
写在类中的代码块
3、静态代码块
在类中，用static修饰的代码块
4、执行顺序
静态代码块>构造代码块>构造方法，其中静态代码块只在第一初始化时执行，以后不再执行。
构造方法执行顺序
父类构造方法>子类构造方法
构造代码块执行顺序
父类构造代码块>子类构造代码块
总结：Cat继承了Animal
37、内部类
在类中的定义的类是内部类
1、普通内部类
在类中定义一个类，不能用public修饰。
2、匿名内部类
没有名字的内部类。定义方式和普通内部类比较相似。
其中IA是一个接口，接口是不可以被实现，但是上面的写是写了一个匿名内部类，这个匿名内部类是一个实现了IA接口的类
38、常用类
1、Math
abs：绝对值
pow（n,m）：n的m次方
random：生成随机数，范围是0.0~1.0，不包含1.0
sqrt（n）：n的平方根
2、Object
Object是所有类的超类，Java中所有类默认继承Object
Object中有一些方法可以重写
其中equals和toString两个方法比较常会重写。
如果需要有特殊情况判断两个对象是否相同，那么我们可以重写equals方法
如果输出对象时要有特殊的格式，那么我们可以重写toString方法
super：是超级，父类的意思
super.toString()调用的是父类的toString方法。
3、String
charAt(int)：返回指定索引处的char
endWith(Stirng)：是否是String结尾的字符串
equals(Object)：判断两个字符串是否内容相同，注意参数类型是Object数据类型。
和==的区别，==比较地址，equals方法比较值。
equalsIgnoceCase(String)：判断两个字符串不区分大小写内容是否相同。
indexOf(String)：返回String在字符串中第一次出现索引的位置。如果不包含，返回-1
length()：返回字符串长度
replaceAll(String1，String2)：将字符串中所有的String1替换成String2，注意替换后的字符串以返回值返回，不会修改String1。
split(String)：按照String拆分字符串，返回一个字符串数组。注意这个字符串是正则表达式。
substring(int1, int2)：截取字符串，从int1开始，到int2-1中间的所有字符串。注意int2不要超过字符串长度，不要小于int1。
4、StringBuffer
和String的区别
String对象地址会发生变化，StringBuffer地址不会发生变化。
当修改字符串内容，String会按照Java的字符串机制，创建新的对象，修改字符串的地址。StringBuffer不会按照String的机制，会在原地址基础修改字符串内容。
append(XXX)：在字符串末尾添加
StringBuffer最后一般都会转换成String数据类型操作，通过toString方法可以将StringBuffer转换成String。
StringBuffer是线程安全的。
5、Date
Date是Java中表示时间的对象，有多个构造方法，其中无参的构造方法和参数是long的构造方法用的最多，无参表示当前时间，long参数表示1970.1.1 00:00:00到现在的毫秒数。
toString()：返回日期的字符串格式
getTime()：得到当前时间的long值
日期格式转化：
39、异常
异常是程序中出现的问题，有些异常需要特殊处理，有些异常可以不做。
1、一个图
2、五个关键字
try、catch、finally、throw、throws
try、catch、finally经常配合使用
try代码块中的代码执行，如果发生异常，那么会进入catch代码块，最后一定会执行finally代码块，如果try代码块中没有异常，那么最后也一定会执行finally代码块
try可以配合多个catch使用，多个catch中的Exception不允许相同，先出现的catch异常一定不能是后出现catch异常的父类，因为通过多态，子类也可以被看做为父类，那么后面的异常讲不会执行，没有存在意义。
40、集合
Collection，List，Set，Map，Iterator
集合又是一种容器
5个接口直接关系
1、List
ArrayList
是以数组的原理实现链表功能，没有存储上限。元素可以重复。
常用方法：
get(int)：取int位置的元素
add(Object)：向集合中放置元素
size()：返回集合元素数量
remove(int)：移除int位置的元素
LinkedList
是以链表原理实现的链表功能，没有存储上限。元素可以重复。
get(int)：取int位置的元素
add(Object)：向集合中放置元素
size()：返回集合元素数量
remove(int)：移除int位置的元素
ArrayList因为数组实现，所以遍历快，插入和删除慢。
LinkedList因为是链表实现，所以插入和删除快，遍历慢。
2、封装类
Java中基础数据类型都有对应的封装类
jdk1.5开始封装类可以自动解封。
3、Map
是以键值对形式存储的，有键（Key），值（Value），通过key得到value。
HashMap
put(Object1,Object2)：存值，key是Object1，value是Object2，可以通过Object1获得Object2的值。
get(Object)：通过Object找到对应的value
size()：返回集合长度
注意：
1、key唯一，如果有相同的key存放，那么后存放的value值会覆盖先存放的value
2、value可以重复，重复多少次都可以，只有key不同
3、key和value都可以用null
4、map在存放数据时是没有顺序的
4、Iterator
迭代器，用来遍历集合。
遍历List
遍历Map
5、Set
是一个继承了Collection接口的集合，他和List是兄弟关系，和Map没有关系。
Set中元素不允许重复，Set中元素是无序的
HashSet
add()：添加元素
size()：集合长度
iterator()：迭代器
41、I/O流
输入输出流，就是I/O流。我们可以通过流来操作文件。
1、流的分类
按照方向分：输入流和输出流
按照功能分：节点流和处理流
按照单位分：字节流和字符流
2、File
File是文件类，他表示物理路径下的文件和程序中对象的关联，处理文件以为，他还可以关联文件夹。
常用方法：
3、文件输入输出流
1、FileInputStream
文件输入字节流
2、FileOutputStream
文件输出字节流
3、FileReader
文件输入字符流
4、FileWriter
文件输出字符流
4、高级流
大多数是带有Buffered修饰的流，这个是带有缓冲区的流，提供了一些更方便的方法。
public static void main(String[] args) {
Reader reader = null;
BufferedReader br = null;
BufferedWriter bw = null;
Writer writer = null;
try {
reader = new FileReader(new File("D:\\FTP\\50y\\HelloWorld.java"));
writer = new FileWriter(new File("D:\\FTP\\50y\\Hello.java"));
br = new BufferedReader(reader);
bw = new BufferedWriter(writer);
String str = "";
while(true){
String s = br.readLine();
if(s != null){
str += s + "\n";
System.out.println(s);
}else{
break;
}
}
bw.write(str);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(reader != null){
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(bw != null){
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(writer != null){
try {
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}注意事项：
1、创建高级流是需要节点流，所以我们要先创建节点流再创建高级流
2、关闭流时，要先关闭内部的流，再关闭外部的流
3、缓冲输出流再写完文件时，一定要关闭，否则可能导致文件不完整
42、1.5新特性
1、自动解包
基础数据类型都有封装类，如果在1.5之前，封装类和基础数据类型不能直接转换，需要特殊的方法，1.5之后，可以自己打包和解包。
2、增强for循环
优点：书写方便，提高开发效率，能够稍微提高循环的速度
缺点：没有原始在集合中位置的临时变量，也就是数组的下角标，如果需要，那么还是要用传统for循环
第一个是传统for循环，第二个是增强for循环
从sArr中取得第一个元素，赋值给临时变量s，然后执行循环体，再次进入循环时，又把下一个元素赋值给临时变量s。。。。。。最后没有下一个临时变量，跳出循环。
Map的增强for循环写法
3、可变参数
可变参数指的是方法中参数的个数可以变化，没有明确的限定。
1、一个方法中只允许有一个可变参数
2、可变参数一定是方法参数中的最后一个
3、方法中可以正常声明其他参数，这些参数的数据类型和可变参数的数据类型没有关系
4、可变参数在方法中是以数组形式存储的
5、用到可变参数时，一定要判断可变参数是否为空，是否长度为0
4、泛型
在Java中如果一个类中的数据类型根据实际情况会发生变化，那么我们可以用泛型来解决这个问题。
1、一个类可以声明多个泛型
2、泛型是相对于对象的，类知识对象的模板，泛型根据创建对象传入的决定
3、在类中，泛型会替换类型所有用到的地方（所有的E会被替换成String）
4、泛型如果不传，没有语法错误，只会出现警告，然后泛型会被默认成Object
5、枚举
枚举我们可以对照boolean来记忆，boolean只有两个值true/false，枚举只有几个值，具体有几个值由我们自己定义。
1、就是枚举所有的值，只有4个
2、上图是重写了枚举的构造方法，如果不需要，只定义枚举值即可。
*3、枚举在数据存储时，用的事int存储。
43、数据库
打开windows系统服务管理方式：
win键+R，然后输入services.msc
1、什么是数据库
数据库就是数据的仓库，用来持久性的存储数据；
2、增删改查SQL
SELECT name, price FROM book;
INSERT INTO book(name,price,id) VALUES ('Java从入门到精通', 100, 7);
DELETE FROM book WHERE id=1
UPDATE book SET name='Java从入门到放弃', price=200 WHERE id=7;
SELECT * FROM book WHERE id=2;
3、添加jar
选择要用的jar
