抽象与封装

面向对象的三大特点

继承

封装
多态
异常
集合框架
Oracle基础部分
Jdbc组件的用法
DAO模式

XML解析和IO

现实世界 概念世界 信息世界（代码层面）

   对象               实体                            类

   特征               属性(字段)               字段(成员变量)

  行为                方法                          方法

设计一个软件

思考的方法:抽象的思维

抽象的原则

找出知道的属性和行为。

保留与业务有关的属性和行为，舍去与业务无关的属性和行为。

1.属性

2.行为

3.区分哪些主要、哪些次要

面向对象设计步骤

1.找对象(分类)

2.特征行为(方法)

3.舍去次要的、保留主要的

4.写成员变量和方法

5.对代码优化（考虑继承、考虑该父类是否是抽象类、考虑该抽象类是否可以写成接口）

关于成员变量初始化

1.在声明的时候直接初始化

2.对象名.属性名=值

3.构造方法初始化

常量

1.普通的常量

final 数据类型  常量名（规范大写）=值；

使用时：对象名.常量名（只读）

2.静态常量

static final 数据类型  常量名（规范大写）=值；
使用时：对象名.常量名（只读）
提倡： 类名.常量名

构造方法

1.为什么需要构造方法？

构造方法可以给成员变量初始化，简化代码。

2.什么是构造方法？

访问修饰符   类名(可能有参数){
//初始化成员变量的代码
}

new 的含义

1.分配内存

2.调用匹配的构造方法

方法的重载

1.方法名相同、参数个数或参数类型不同，就是方法重载。

2.方法的返回值以及方法的修饰符无法区分方法重载

static(静态)关键字的用法

1.成员变量用了static，为静态变量或者是类变量，它可读也可写

访问修饰符  staic   数据类型  变量名；
使用的时候：对象名.变量名 
类名.对象名

2.一个方法用了static,那么该方法叫静态方法和类方法

访问修饰符  staic  返回值类型  方法名([参数]){

}
使用：对象名.方法名([实参])    类名..方法名([实参])

3.静态块

一段代码被放在static中，我们就称该代码块为静态块.***代码没有写在方法体

静态变量、静态方法、静态块的特点是：

对于一个类来讲，该类纵有千万个实例，但是内存里面只有一份静态的块、静态方法、静态变量

调用静态方法要注意的事项

1.静态方法不能调用普通方法，可以调用静态方法。可以使用静态变量,不可以使用实例变量

2.普通方法可以调用静态方法和静态变量

为什么需要封装？

只能通过规定方法访问
隐藏类的实现细节
方便修改实现
方便加入控制语句

封装的步骤

1.将成员变量写成private

2.添加get、set的方法。

继承

将重复代码抽取到父类中

方便修改代码

减少代码量

子类与父类是is-a关系

只能继承一个父类

继承设计的步骤：

1、如果多个类的共同代码抽取出来，写成一个新的类，这个新的类和原来的类有is a的关系。我们用继承。
2、先写父类（公共代码包括成员变量和成员方法）
3、写子类，在子类添加特有的属性和方法。并且让子类继承父类
语法：public class 类名 extends 父类{
//添加特有的字段
//添加特有的方法

}

什么时候用重写？

当父类中的方法不能满足子类的需要，我们需要在子类中对该方法进行重写。

父类的成员变量不能被重写，如果子类中有相同的成员变量.它是子类特有的，当我们调用子类的这个成员变量不会是父类中同名的那个成员变量。

java访问修饰符的可见性的结论

public        任何时候都可见
protected  同包   不同包，继承后在子类中可见
默认      同包
private       自己类本身可用

当父类中有空参的构造，至于父类中的构造是自己手工添加的空参构造，还是不写，由java虚拟机添加，子类中的构造都会在方法的第1句调用父类的构造方法。

当父类中，显示的写了构造方法，虚拟机就不会再给我们添加空参的构造。这个时候子类中的构造方法，一定要在第1句调用父类的构造.(当父类的构造是空参时可以省略不写，也可以用super()这种方式调用)

什么时候用抽象方法？

当父类的方法不能满足子类的需要，有2种方式解决问题
1)直接将父类的方法写成空的方法体，然后在子类中重写
2)直接将父类中的方法写成抽象方法，那么该类一定要加上abstract关键字，改写成抽象类。
3)抽象类不能被实例化，也就是不能new

将一个类设计成抽象类的其他情况

1）如果你写一个类，这个类你不想被用户实例化，就可以将给类写成抽象类。很多时候是因为这个类不写抽象类，直接实例化没有意思。这时更多体现的是一种设计理念。但是该类可以被其他类继承。
2）抽象类里面可以没有抽象方法，但是有抽象方法的类，一定是抽象类。

一、发现类、发现属性、方法方法
轿车Car
车牌号 no
品牌 brand
类型 type
日租金 price


方法：根据天数计算租金
public int CalcRent(int days){
//公式：日租金*天数
}

客车Bus
车牌号  no
品牌 brand
座位数  seatNum
日租金 price
方法：根据天数计算租金
public int CalcRent(int days){
//根据座位数的多少计算
}
二、优化
a)初步优化
MotoVehicle
车牌号 no
品牌 brand
日租金 price


public int CalcRent(int days){}


b)进一步优化
abstract MotoVehicle
public int CalcRent(int days);
三、编写测试类

*****接口*******

1、如果宠物生病，我们可以通过打针、吃药、喂食给予治疗。
Dog  打针、吃药    健康值：+15   亲密度:+10
Penguin 喂食  吃药 健康值：+20    亲密度：+15


Monkey  吃桃       健康值：30     亲密度：20


什么时候生病，就是健康值<60
2、当添加很多的类的时候
1）新的类继承Pet，然后去添加自己特有的属性、封装该属性
2）重写父类Pet里声明的抽象方法。
3）纠结处：
宠物管理类:PetManager里面会去重载很多的petCure(类型 对象名){}方法
优化的时候：将方法的参数的类型写成父类，传递实参用的是父类的子类。
3、为什么需要多态？
是因为有时候我们不用多态，可能造成频繁修改代码，代码可扩展性、可维护性差 
4、什么是多态？
同一个引用类型，使用不同的实例而执行不同操作
5、如何使用多态？
原则：如果是方法，方法的形参用父类，调用的时候实参用子类. 
1）定义父类（考虑该类是否写成抽象类、方法是否写成抽象方法）
2）子类继承父类，然后重写父类声明的方法。
3）测试类：构造的对象是父类，存储的（指向的）是子类对象，然后去调用方法
6、继承的时候方法的重写需要注意的事项
1）返回值的类型、名字、参数的和父类相同
2）访问修饰符的可见性，只能提升不能降低（最少要持平）


7、什么是向上转型？什么是向下转型？
1）向上转型
子类转换成父类,自动转换
2）先下转型
父类转换成子类
强制转换：
a)如果父类事先没有存储子类对象（没有指向子类对象），那么不会有编译错误，运行时会有


java.lang.ClassCastException，类型转换异常
b)如果事先父类存储了子类对象，然后再将父类转换成子类，没有任何问题。（只是恢复子类的本来面目）
对比S1强制类型转换，范围小的往范围大的转，自动转换（向上转型）
8、instanceof关键字
作用是：用来判断某个对象是否属于某种类型,它的返回值是boolean类型

接口

1、为什么需要接口？

当一个抽象类中的方法全部是抽象方法，没有任何其他的代码，我们这个时候可以有两种选择：
1）如果你要体现子类和它是继承关系，就用抽象类.(设计理念)
假设该子类由于需求的变更，除了要继承该抽象类外，还要继承其他的类。这个时候由于java是单继承。你只能将抽象类改写成接口。

2)要继承的类，需要实现抽象类中的所有方法，但是如果继承，该子类和抽象类之间又找不到is a的关系。那么只好将抽象类变成接口。

2、接口的组成
public interface  接口名{
//只有方法的声明，没有方法体
//常量，而且这里的常量都是静态常量
//枚举
}
注意：
1）方法体不能实现
2)所有的方法，都是public abstract 返回值  方法名([形参列表]);如果不写public和abstract关键字，java虚拟机会自动补全。
3)不能声明私有的和保护的方法
4）变量都是静态常量（public static final 数据类型 常量名=值).如果不写public、static和final关键字，java虚拟机会自动补全. 

3、一个类要实现多个接口，继承父类的语法
public class 子类名 extends 父类 implements 接口1,接口2，接口{
//实现体
}

4、接口在使用的时候
1）体现的是一种约定。当实HomeLetterImpl）体现的是一种能力。当实现类实现了接口，那么它一定会去实现接口中的方法，每个方法体现了一种能力.

面向对象的设计

一、找类

Player玩家类
Game类
Level关卡类
LevelParam关卡数组类

二、属性和方法
Player玩家类
属性:
int levelNo;玩家级别
int currScore;//玩家当前关卡的积分
long startTime;//玩家当前关卡开始时从1970年1月1日到现在的毫秒数
long elapsedTime;//玩家当前关卡玩游戏已经花费的秒数
方法：play()
Game类
属性：无
方法：public String autoBuildString();
     public void crossLevel(String s1,String s2);  
Level类
属性：
      int levelNo;关数
int perScore;每次输入正确获得的积分
int strLength; 字符串的长度
int strTime 字;符串出现的次数
int timeLimit;每关时间限制（秒）章

面向对象的设计原则

1、依赖、关联、聚合、组合它没有具体的语法,只是类和类之间又很微妙的语意上关系。
2、依赖：两个类之间具有临时、偶然的关系，非常脆弱。代码上是一个类的方法的参数是另外一个类。
3、关联
1）一对一
Employee
工号 姓名性别身份证号职位
IdentifiedNo
身份证号 姓名性别地址 出生日期
发证机关 有效期

2）一对多
用户
用户类型
3）多对多
学生
课程
这里的关联分方向：有单向和双向。

4、聚合
两个类之间是has a的关系。可以分离，他们的生命周期不一致。
在代码层面，成员变量的关系

5、组合
两个类之间是contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分间的关系，但此时整体与部分是不可分的，整体的生命周期结束也就意味着部分的生命周期结束.

6、面向对象的设计原则
1）开闭原则
对内封闭（代码不能修改），对外（功能）开发
2)里氏替换
采用多态来实现
3）单一原则
一个接口写一组和业务相关的方法

异常

1、什么是异常？
就是在程序的运行过程中所发生的不正常的事件，它会中断正在运行的程序2、异常的2、异常的分类？
1）错误
由java虚拟机处理，无法人为的通过代码干涉
2）异常
可以通过代码干涉
a)check异常
必须通过代码处理，否则程序报语法错误
b)运行时异常
不需要通过代码处理，虚拟机可以直接捕获

3、程序出现异常进行处理的两种方法
1)try   cacth   finally 人工捕获
try{
//可能出现异常的代码
}cacth(异常的类型 对象){
//对异常的处理代码
}finally{
//无论是否出现异常，都必须执行的代码
}

注意：try是必须的，catch和finally必须要有一个和try匹配,唯一有一种情况不执行finally代码块,如果在try里面或者是catch块中写了System.exit(1);
如果是多重catch，先写子类，再写父类


2)在方法中通过throws声明要抛出的异常，然后通过throw抛出异常
注意：哪个方法如果想抛出异常，就在方法体的前面throws 异常的类型，如果是要声明抛出多个异常，异常按照先子类，再父类的原则声明
谁调用该方法，谁处理。要么try...catch。要么继续抛异常,还有一种是try...catch处理，然后再catch，手工使用throw关键字抛出

集合框架

1、为什么需要集合框架？
数组也是一种集合，缺点是长度是固定的，不能动态的增长。集合可以动态增长。

2、List接口
不唯一（重复） 有序
1）ArrayList
遍历的速度快，插入和删除元素的效率低下
2)LinkedList采用链表存储方式。插入、删除元素时效率比较高,遍历效率低下

3、接口
Collection---List
ArrayList
LinkedList
4、Map接口
HashMap
1)键如果重复，就会用新的值替换原来的值
2)null可以作为集合的key
3)数据是以键值对的形式存储的
4）获得所有的值：对象.values（），这个集合是实现了Collection接口
5)获得所有键的集合:对象名.keySet().这个集合是实现了Set接口的
6)数据存储进去是无序的
7)取值是:get(key);

5、迭代器
什么是迭代器？
就是用于将元素从集合中一个一个取出来的一个对象。

6、 Iterator it=list.iterator();
//2、循环迭代遍历数据
while (it.hasNext()) {
Dog d=(Dog)it.next();
d.print();
}
注意： it.hasNext()是用来判断是否有下一个元素，并进行迭代
it.next();是获得迭代获得下一个元素。返回值的类型是Object


你只要实现了 Iterable接口，才可以有迭代器


7、有一种方式，可以指定集合元素里面只能放什么类型的元素，这种方式就是泛型。

8、使用泛型的优势：
可以不需要进行类型转换，加快元素的存取的速度。不用泛型可能该集合里面的元素的数据类型不一致。

9、泛型实际上是参数的类型可变的一种用法

JDBC

1、什么是jdbc?
是java 数据库连接技术的简称
2、为什么需要jdbc?
因为我们很多时候需要通过程序来对数据库进行交互。所以必须有一种方式来实现，sun公司提供了JDBC API来做这样的事情
3、jdbc的组成？
1）JDBC API
提供的类和接口来方便操作
2）DriverManager
管理驱动
3）JDBC 驱动
数据库的厂商提供的驱动，驱动就是代码,它把它打成了jar包
4、JDBC API介绍
DriverManager类：
getConnection();方法可以用来提供连接对象Connection
Connection接口：连接对象
C#:SqlConnection 
PreparedStatements(Statement)接口：命令对象
C#:SqlCommand
ResultSet 结果集对象
c#:SqlDateReader
5、jdbc连接数据库有两种方式
1）桥接方式jdbc-odbc(手上没有jdbc驱动包、用来测试开发)
1、建立odbc数据源，通过管理工具->ODBC数据源
2、代码去访问刚建立的数据源connstr
2)纯java驱动方法（平时用、部署）


导入第3方的jar包：
SQLSERVER2008:sqljdbc2008.jar
Oracle:classes12.jar
1、加载驱动，由Jdbc DriverManager去管理，程序员不干涉
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
2、建立连接对象,三个参数：1、URL 2、账号  3、密码
Connection connection=DriverManager.getConnection(URL,USER,PASSWORD);
SQL2008的URL写法:jdbc:sqlserver://localhost:1433;databaseName=epet
Oracle的URL的写法：jdbc:oracle:thin:@localhost:1521:ACCP
3、构建命令对象
PreparedStatement接口：它是Statement的子接口
Statement的写法：
stmt=connection.createStatement();
PreparedStatement接口的写法:
pstmt = conn.prepareStatement(sql); 提倡写后面的用法




采用Statement接口容易产生注入式攻击漏洞
4、
根据sql的操作方式，选择是否是否结果集
1)如果是非查询操作(也就是增、删、改)
stmt.executeUpdate()；
2)如果是查询操作用
ResultSet rs=stmt.executeQuery(sql);

通过循环的方式，获得每一条记录，然后获得每条记录中的每个字段的数据
while(rs.next()){
rs.getXXXX(数字);//不是索引,从1开始，1代表第1个字段，2代表第2个字段.（不提倡）
XXXX：是数据类型
rs.getXXXX("sql语句中查询的字段名");
}
5、关闭
注意：反向关闭
先关结果集rs
接着是命令对象Statement或者PreparedStatement
最后是连接connection

 Oracle入门

1、安装Oracle?
win7有自己的版本
10203_vista_w2k8_x86_production_db
winxp也有自己的版本
10204
2、使用Oracle的思维
1）不能用SqlSever2008的思考方法来思考oracle
2)安装Oracle管理系统-----（提示是否创建数据库  之后创建数据库）-------启动数据库实例（服务启动）-------Oracle管理系


统不能直接去建立表（依赖客户端工具）---启动客户端工具(命令行、SqlPlus、第三方的PLSQL Developer、isqlplus网页版的)
3）表空间存储表
3、使用Oracle的步骤
前台是启动Oracle的相关服务
1）一般是用system用户登录，机房里面用户名system,密码是accp
2)建立表空间
3）建立用户
4）给用户授权
5）用刚刚建立的用户登录
6）建立表、建立约束（只是数据类型的写法不同，其他和sqlserver2008一样）
7）插入数据
8）Oracle没有标识列。它是一个叫序列发生器的对象来生成标识列，这就告诉我们我们要使用类似标识列，就必须先建立一个序列


发生器。然后由序列发生器生产序列。一般一个序列对应一个表
4、如果安装的时候没有安装数据库，可以安装完毕后用Database Configuration Assistant数据库配置助手去安装数据库。
5、Net Configuration Assistant用来配置网络监听器,对应是listener.ora
6、Net Configuration Assistant用来配置本地Net服务名tnsnames.ora




7、各种客户端工具登录的方法
1）命令行
sqlplus system(用户名)/accp(密码)   system和普通用户登录
sqlplus sys/accp as sysdba(角色)    sys用户登录只能以sysdba的角色登录
登录后切换用户：connect 用户名/密码
查看用户名：show user

2)


8、将oracle脚本移植到其他机器的步骤
1）用system用户登录
2)建立表空间,表空间的名字要和原来的一样
3)建立用户，并授权
4）用新用户登录，到工具--导入，就可以完成了.


9、当建立用户的时候既有默认的表空间，又有临时表空间的时候，如果建立表的语法写成
create table 表名(


);这时，该表在默认表空间.

如果语法写成
create table 表名(


)
tablespace 临时表空间
 
  );
这时，该表在临时表空间.

Oracle应用

1、NVL(Name,'无名')
如果Name的值为NULL，那么就用字符串 "无名"来代替
2、Decode(stauts,0,'正常',1，'禁用')
如果stauts为0，返回值是字符串“正常”,如果是1,返回值是 "禁用"
3、to_char（）；
将其他类型的数据转换成字符串类型
4、当前时间在oracle中sql语句的写法
sysdate
5、日期类型在Oracle中字符串的默认格式
06-7月 -12   日  月  年
注意：默认的格式日期中的天如果是1位也要在前面加0，凑成2位，月份可以1位也可以2位，但是一定会在后面带上中午汉字“月”
举例说明：
当我们将字符串当做日期插入到日期类型的字段，字符串的写法写默认格式
insert into pet(id,masterid,name,typeid,health,love,adopttime,stauts)
values(3,1,'冰波',1,94,89,'06-7月-2012','0')
6、日期格式转换举例
select * from pet where adoptTime>'01-1月-2010'  --默认的格式
--将日期转换成字符串
select * from pet where to_char(adoptTime,'YYYY-MM-dd')>'2010-01-01' 
--将字符串转换成日期
select * from pet where adoptTime>to_date('01-1月-2010'); 
select * from pet where adoptTime>to_date('2010-01-01','YYYY-MM-dd'); 


7、将用户输入的日期格式字符串插入到数据库

1)第1种将字符串转换成Date格式
Date date=Date.valueOf(adoptTime);
adoptTime是字符串  格式输入：yyyy-mm-dd 天和月要写出2位
2)在sql语句中，用to_date（）函数将字符串转换成日期格式
String sql="insert into pet(id,masterid,name,typeid,health,love,adopttime,stauts) values


(?,1,?,1,100,98,to_date(?,'YYYY-MM-dd'),'0')";
pstmt.setString(3, adoptTime);
注意：输入的时候，要按照to_date(?,'YYYY-MM-dd')这里指定的格式输入，否则自能按照默认格式dd-mm月-YYYY输入


8、为什么需要索引？
当数据量很多的时候，查询数据会非常慢，有索引后会按照索引对数据进行排序，然后去选择合适的数据构成结果集
9、索引的类型
1）按照存储结构
a)B树索引
默认的索引（每条记录搜索的时间一样）
b)位图索引
如果有n条记录，但是n条记录中的某个字段它的取值范围（个数m）有限，m/n接近于0
c)反向键索引
正向取值没有规律，反向取值对于该字段有规律，我们建立反向键索引
2)按照唯一
a)唯一索引
b)非唯一索引
3)按照建立索引使用列的个数
a)单列索引
b)组合键索引
c)基于函数的索引
10、数据的导入和导出
1）dmp文件的导入导出 (命令行、PLSQL Developer)
特点是：二进制文件，无法看到内容
2）sql文件的导入导出(PLSQL Developer)
脚本
3)pde文件的导入导出(PLSQL Developer)
特点是：二进制文件，无法看到内容


导出数据：
1)dmp
命令 exp
2)导入dmp
命令 imp

注意：当导入sql脚本的时候，要注意：一定要让自己所在机器的表空间的名字为sql脚本中的表空间名

11、移植sql脚本的步骤
1）用记事本打开sql脚本，找到表空间的名字
2）在自己的机器上，建立表空间、建立用户（可以不一样）,并授权给用户
3)导入脚本

Dao模式

1、什么是持久化？
持久化是将程序中的数据在瞬时状态和持久状态间转换的机制内存中的数据是瞬时状态的保存在数据库、文件、xml文件中的数据是持久状态的

2、class数据
Person(类) 数据库(数据表)
id(int) id(number)
name(String) name(nvarchar2)
age age
phone phone


现在要解决的问题是：类和数据表之间的一一对应关系的处理
JDBC就是用来处理这类问题的一种方案(Y2  Hibernate\ibates)
类名-------表名
成员变量---字段
数据类型---数据类型

3、Dao是用来干什么的？
Data Access Object(数据存取对象),
位于业务逻辑和持久化数据之间,它实际上就是用来将实体类转换成数据库中的记录，或者（相反）

4、如何使用DAO模式的步骤？
一、建立工程
1）建立工程（工程名是小写字母）
2）建立包(公司网站的地址反转+工程名) 
com.accp.epet  
http://www.whhp.aptech.com         studentManager
com.aptech.whhp.studentManager
二、建立实体类
1)建包
工程的包名+.entity(bean)
2)在该包中建立类
类名:表名单数
成员变量的名字：字段名
成员变量的类型：要将数据库中的类型换成编程语言中的数据类型
对该类进行封装，就是将成员变量getXXX() 和setXXX(),然后添加空参的构造方法和全参构造
对该类序列化
三、建立接口
1）添加dao包
工程的包名+.dao
2)添加接口
表名单数+Dao
接口中的方法：
1)public void(boolean)  add(实体类名  对象);
2)public void delete(主键);
3)public void update(实体类名  对象);
4)public 实体类名  get实体类名(主键);  //查询单个
5)public List<实体类名>  get实体类名List();
6)public List<实体类名>  get实体类名ListBy外键名(外键);
////////////////////////通用方法/////////////////////////
根据具体的业务逻辑去添加合适的方法
四、编写实现类
1）添加包
工程的包名+.dao+.impl
2)添加类
接口名称+Impl
PetDaoOracleImpl
PetDaoSQLServerImpl


////核心////////
该类继承BaseDao，实现接口

xml解析和IO

1、为什么需要XML？
因为XML可以用来进行数据存储，数据交换，而且很多时候软件的配置信息采用的是XML。

2、什么是XML?
可扩展标记语言，它可以自己定义自己的标签。

3、XML的结构
1）XML的声明
<?xml version="1.0" encoding="UTF-8"?>
2）编写根节点，而且一个XML只能有一个根节点
3)可以在根节点里面嵌套子节点,子节点可以重复。

4、dtd和Schema是什么？
出现dtd和schem原因是为了让任何人写的xml里面的结构相同，比如说元素的名字、属性的名字、以及元素重复的次数都是一样。实际上它就是一种规范。
1)dtd
是自己本身有规范
2)schem
采用是xml编写的

5、如何编写DTD文件？
1)根据放的位置不同分为2种
a)内部dtd
<!DOCTYPE 根元素的名称 [
<!ELEMENT 元素 (子元素的名称列表)>
<!ELEMENT 子元素 (子元素的名称列表)>
        ]>

注意：?最多出现一次
     *可以出现多次，也可以不出现
     +至少出现一次

b)外部dtd
<!ELEMENT 元素 (子元素的名称列表)>
<!ELEMENT 子元素 (子元素的名称列表)>
注意:但是在xml页面中，导入
<!DOCTYPE 根元素的名称 SYSTEM "dtd名称" >

七、什么叫格式良好的xml？什么叫有效的xml？
1）格式良好，是说通过的xml解析器解析时，语法正确(这里面可以没有dtd),仅仅是嵌套关系正确。
2）有效的，是说xml解析器解析时，符合xml中的dtd规范。（有dtd或者schem）不仅是格式良好，而且要符合规范.

IO操作

1、文件的操作
1)字节流
处理二进制文件
FilterOutputStream
FilterInputStream  byte数组
2)字符流
1个字符等于2个字节
读写文本文件UTF-8编码

2、什么是输入，什么是输出？
有一个参考方向，一般我们是以内存为参考方向。将外部数据读到内存，就是输入，反之，将内存的数据写到文件是输出。

3、什么是流？
就是有序的、有方向的数据的集合

4、字符流
1）输入流
抽象类  Reader
FileReader

步骤：
1）构建输入流对象
2）构建中转站 char[] buffer
3)调用输入流对象的read()方法读取
4）关闭流
2)输出流
抽象类 Writter
FileWritter
步骤：
1）构建输出流
2）调用输出流的write（）写入数据
3)关闭流

1)将动态页面静态化
写一个模板，然后将内容用占位符占位，将数据库中 的数据读取后替换，有多少条数据，就用模板生成多少个页面


2)页面完全是静态页面,本身编写的时候就是.html，用JQuery将从后台获得的数据，直接绑定到页面（javascript）
JSP很重要的是Servlet，后台的程序都是Servlet，通过Servlet将数据转换成文本或者是JSON格式或者xml格式的数据发送到前台页面，前台用Jquery或者Javascript，来解析文本
或者JSON数据或者XML数据