java高级

CH01

一、    如何做自我介绍？

1、      去你女朋友家：家庭情况、做什么工作、性格

2、      面试时：大学、专业、姓名、经验、会什么、为什么应聘

3、      自己：五官、四肢、睡觉、吃饭、学习、写代码、打游戏

或者是介绍一个陌生的事物：

属性和行为：描述属性和行为的时候，要是别人关心的，跟当前环境有关的。

二、    对象

明星的出现，会引起一堆人的追捧，追捧明星的这群人称为什么粉，每一个喜欢这个明星的人都是一个实实在在的个体，这个个体就是对象。

对象是有具体的属性值和行为的一个实际存在的个体。

例如：学生类—就是一个抽象的概念，在这个类里我们就约定学生应该有的属性和行为，但是没有具体数值。

具体到叫张三的这个学生，就是对象了，因为他有了具体的属性值，所以对象具有唯一值。

三、    什么是类

具有相同属性和行为的一类事物的总称，是概念上的定义。

四、    类和对象的关系

在现实的世界中是先有对象的，人们会根据一堆事物的特点总结出它们具有的属性和行为，然后进行分类。

在计算机世界，你就是女娲，先创造类，然后由类创建对象。

一个类可以有多个对象，如果这个类只有一个对象，那么这个类就称为单态类。

五、    抽象类（面向对象的设计过程）

抽象就是说把现实世界中的事物描述到计算机里，同类事物应该写为类，这类事物的属性抽为成员变量，这事物的行为抽为成员方法。

1、      给这类事物起个名字：即类名，为名词，首字母大写。

2、      找出这类事物的属性（客户关心的）：即成员变量，为名词，首字母小写，其余单词的首字母大写，符合驼峰原则。

3、      找出这类事物的行为（客户关心的）：即成员方法，为动名词，命名符合驼峰原则。

注意：所有的起名都能见名知意，

例：public void insertStudent(Student[] stu)

六、    构造方法

public 类名（数据类型 参数1，数据类型 参数2……）{

this.成员属性1 = 参数1；

this.成员属性2 = 参数2；

…

}

1、      作用：用来创建对象，并且可以为对象的属性赋值

2、      特点

①  构造方法的名字与类名相同

②  构造方法没有返回值，也没有void关键字

③  构造方法是通过new关键字来调用的，普通方法是通过对象名.方法名（）来调用。

④  如果你的类没有写构造方法，jvm会提供一个无参的构造方法供你使用，一旦你显示定义了任何构造方法，那么jvm就不再提供这个无参的构造方法，如果你还需要用无参构造方法的话，需要自己显示定义出来，sun建议为每一个类建立一个无参构造方法。一般至少有一个无参的构造方法，一个全参的构造方法。

3、      分类：

隐式的是说，如果一个类你没有写构造方法，那么JVM会给你提供默认的无参的构造方法。

显式的构造方法就是你自己在类中明确定义的构造方法，一旦你明确定义了构造方法后，JVM不再提供无参的构造方法。想用的话必须自己显式定义出来。

 

七、    this关键字

代表当前的，这个，在this出现的方法里，谁调用这个方法，就代表谁。

1、      当局部变量和成员变量同名时，我们需要在成员变量前加this，如果不同名时，this可以省略。

2、      如果需要在一个构造方法里调用另外的构造方法时，需要在此构造方法的第一行写this（实参列表）；this（）代表本类的其他构造方法。

3、      this他的本意是这个，当前的，一般代表当前对象

八、    static关键字

他代表类级别的，静态的，可以修饰成员变量，可以修饰方法。

class DBconn{

//public void getConn(){};//得到数据库的链接

public static void getConn(){};

}

class StudentDao{

//DBconn conn = new DBconn();

//数据库连接 = conn.getConn();

数据库连接 = DBconn.getConn();

}

class TeacherDao{

DBconn conn = new DBconn();

数据库连接 = conn.getConn();

}

class ScoreDao{

DBconn conn = new DBconn();

数据库连接 = conn.getConn();

}

还有很多类，需要用到DBconn的连接数据库的方法，我们不想每次用到getConn时都先创建对象，那么我们可以把getConn声明为类级别的静态的方法，让它随着DBconn一起加载到，我们在任何地方想用的时候都可以直接通过DBconn.getConn()就可以得到数据库连接。

1、      static修饰成员会随着类一起被加载到内存，我们在用到对象的时候才用类去创建，可以通过类名直接调用。他的存在早于对象。

2、      被static修饰的成员，类的所有对象共享，一个对象改变了static修饰的值，那么通过其他对象调用的话，结果是改变后的值。

3、      static不能修饰局部变量

4、      在普通方法里可以访问static修饰的成员变量，但是被static修饰的方法不能访问普通的成员变量。

九、    方法的重载

同一类中的出现的同名的方法，这种现象称为方法的重载。

1、      方法名相同

2、      参数列表不同，包括参数的个数和参数的数据类型以及参数的顺序。

3、      与方法的返回值无关

十、    final关键字

最终的，最后的，不可改变的，可以修饰类、属性、方法

1、      修饰成员变量时，必须赋初值

2、      修饰局部变量可以没有初值，但是一旦赋值后，值不可再改变。

3、      项目中一般是用他和static来定义常量

public static final String FAMILY = “谢”；

十一、面向对象的三大特征之一：封装

涉及到访问修饰符也称为访问权限或者说 透明度

public：公共的，任意的都可见

protected：受保护的，同包中，不同包中子类可见

friendly：同包中可见

private：私有的，只有自己可见

要求：

类的属性必须私有化：保护数据

对属性提供get和set方法来进行取值赋值

类必须有无参的构造方法和全参的构造方法。

 

封装是一种数据的保护，封装是把属性私有化，我的属性只有我自己能看能改，但是为了与外界沟通，我提供公有的方法，在项目中方法都是公有的。

封装的步骤：

1、      用private关键字修饰成员变量，可见度只在本类中。

2、      用public修饰对成员变量设置和取值的set和get方法。

3、      可以在set或者get方法里对成员变量进行业务控制。

注意：

private：私有的，可见度在本类中

public：公有的，可见度是任意地方

默认的：它的可见度是同包中。

CH02

三、面向对象的三大特征：封装、继承、多态，必须具备三者才能是面向对象的。

四、继承关系的确定，继承的关键词是extends

1、当项目中或者在多个类中看到大量的相同的属性和方法时，我们就要考虑抽象出一个父类，父类里放共同的属性和方法，子类里放自己特有的属性和方法。

2、比如一个系统里出现大量的什么是什么时，我们要考虑继承关系。继承是一种IS A的关系。

3、继承可以在很大程度上减少代码的冗余，提高代码的复用度，也方便代码的维护。

五、理解继承

1、继承来源于生活，又高于生活。

2、生活中一个人只有一个父亲，代码中一个类只有一个父类

3、代码中一个类可以有多个子类

4、JAVA语言是单继承的语言。

六、有个游戏系统，他对用户是采用国籍分类（Chinese、Japan、American）的，那么对于每个国籍的人，他

关心属性：姓名、性别、年龄、学历，

关心行为：游戏得分，吃饭，说话

七、super关键字

1、super代表父类，

2、在子类中，我们可以使用super访问父类的非私有的成员

3、super用的最多的地方是在子类的构造方法里访问父类的构造方法super（实参列表），这句话必须在子类构造方法的第一句。

4、Object类，JAVA类的基类，根类，祖宗类。如果你自己的类没有显示继承来自某个类的话，JVM都默认你继承来自这个类。

八、继承的特点

1、子类继承了父类所有的属性和方法，私有的也被继承了，但是不可见。

2、子类可以拥有自己特有的属性和方法。

3、子类可以覆盖即重写父类的方法，因为父类的这个方法实现的功能满足不了子类的需求了。

4、构造方法不能继承

九、重写override

方法的组成：方法的声明和方法体

其中方法的声明包括：修饰符、返回值类型、方法名、参数列表

方法体：实现方法具体功能的代码

出现的原因：父类的方法满足不了子类的需求了，所以需要在子类中重写方法的功能。

出现的位置：有继承关系的子类中。

特点：方法的声明和父类一样，方法体不同。

十一、         继承的应用

public void buyPet（Pet pet）{

//我只是想买一个宠物，但是不知道具体买什么类型的宠物，所以方法的参数写宠物的父类

}

1、      父类出现的地方，子类都可以出现

2、      声明父类，创建子类。=号左边的都是声明，对于引用类型来说，=右边的是创建。

3、      子类展现出来的行为是它重写的

十一、存在继承关系的构造方法的执行顺序

先执行父类，在执行子类，在执行子类的构造方法。

十二、抽象类

1、      为什么有抽象类：项目中的一些类，我们没有必要用它来创建对象，那么我们就可以把它设计为抽象的，抽象类不能被实例化（不能用new关键字来创建对象），他被用来继承，这样我们就可以声明抽象类，创建其子类。

2、      抽象类的内容都是约定好的，共同的一些东西。

3、      用abstract修饰的类就是抽象类。

十三、抽象方法

只有方法的声明，没有方法体，他就是约定了一个功能；

public abstract void Son（）；

1、      含有抽象方法的类，一定是抽象类

2、      抽象类，可以没有抽象方法

3、      继承自抽象类的子类必须实现父类的抽象方法，如果实现不了，请把自己变为抽象类。

CH05

一、    什么是面向对象的思想？

世间万物皆对象，一切从现实的角度来考虑问题。

例：你想去西藏，你该怎么办？

需要交通工具，比如一辆车

去买车

需要一个司机，你怎么办？

你招聘司机，符合你要求的司机到位后，接下来你干什么？

需要水和食物，直接去超市买现成的水和食物对象

GO

二、    面向对象的特征：

1、      封装

保护数据，把属性私有化，提供对外的公有的方法，方法的执行过程也是被封装起来的，外界只能看到方法的最终的功能

2、      继承

①  JAVA是单继承的语言，即一个子类只有一个父类，但是一个父类可以有多个子类

②  从一个类派生出一个新类，原有的类称为父类，派生的类称为子类。

③  子类拥有父类的属性和方法，子类也可以拥有自己特有的属性和方法。子类还可以重写从父类继承过来的方法。

④  在创建子类时，先调用父类的构造方法，再调用子类的构造方法。

3、      多态

①  同一个事物的不同形态，体现在方法的重载和重写这两方面。

②  子类重写父类的方法，那么在程序中可以声明父类，然后用子类去创建对象，那么调用重写后的方法，就体现出不同的形态。

注意：面向对象语言的优点：

减少了代码的冗余，提高了代码的复用度，方便了代码的维护，易于代码的扩展。

三、    重载和重写的特点

四、    问题：你父亲有个愿望买宝马，你母亲也有个愿望买个别墅。

五、    抽象类的特点

1、      用abstract修饰的类，不能被实例化，只能被继承。如果一个类没有必要创建对象，只用来被继承，那么我们一般把他变为抽象类。

2、      抽象类可以没有抽象方法，但是如果一个类有抽象方法，那么他必须是抽象类

六、    抽象方法的特点：

用abstract修饰的方法，只有方法的声明，没有方法体

七、    为什么要有接口

1、为了解决多继承的问题，因为在类的世界只有单继承。

2、为了让设计和实现分离，接口是设计程序有什么功能，架构程序模块。

3、让程序具有了更好的可扩展性。

八、接口的语法

public interface 接口名{

public static final 数据类型 常量名 = 常量值；

public abstract 方法的返回值 方法名（参数列表）；//抽象函数

}

类如果想实现接口：

public Class 类名 implements 接口名{

重写接口名中的方法；

}

注意：接口中的方法默认的都是 public abstract的，常量前的修饰默认是public static final，他们都可以不写。

九、接口的理解

1、接口是一种约定。

设计USB接口的人，不关心将来谁用这个接口，他只关心用我这个接口的设备是否实现了我的约定。

设计USB接口的人，也不关心你将来用这个接口干什么

实现USB接口的设备，展现的功能各不相同。

2、接口是一种能力

你实现了父母的愿望，说明你有这个能力，路人实现了你父母的愿望，他也有这个能力，父母本身关心你怎么实现的吗？不关心实现的细节，只关心结果。

3、      面向接口的编程

不考虑实现，只做约定

关心实现类有何能力，不关心实现细节。

十、抽象类和接口的比较

1、抽象类中可以有自己的成员数据，也可以有非抽象方法。而接口中一般不定义成员数据，所有的方法都是抽象方法。

2、一个类只能继承一个父类，但是可以实现多个接口

3、抽象类体现的是继承关系，是一种 IS A关系，父类和子类直接在本质上是同一种事物。而接口，并不要求实现类和接口有任何的关系，实现类仅仅是实现了接口的约定而已。

十一、关于接口

1、      接口是一系列方法的声明。

2、      接口是继承体系之外的，用于功能的扩展，想扩展就实现，不想扩展就不实现。

3、      接口中的成员可以不写public，默认就是公有的。、

4、      接口不能有构造方法，因为接口只能被类来实现。

5、      实现接口，必须实现接口的所有方法，方法体例可以没有具体的内容。如果没有全部实现接口的方法，那么必须声明自己为抽象类。

6、      类只能有一个父类，但是可以实现多个接口

7、      类与类直接存在的是继承关系，类与接口是实现关系

8、      接口可以继承接口，一个接口可以继承多个接口

CH07

一、    JAVA中的异常处理机制

1、      异常：程序中发生了bug，终止了正常的执行

2、      如果总有程序员处理异常的话，一是代码会非常繁琐，二是人为考虑的不全面。

3、      Sun公司提供了非常强大的异常处理机制。

4、      JAVA的异常处理有5个关键字

二、    try包含可能发生的异常代码

Try{

把可能发生的异常的代码包含进来

}

三、    Catch逮住发生的异常

Catch（异常类   异常对象名）{

对异常的处理，一般打印异常信息

}

四、    try-catch的运行情况

1、      try里的代码没有发生异常，程序会正常执行完毕

2、      Try里的代码发生的异常，被Catch住，程序毁正常执行完毕

3、      Try里的代码发生的异常，没有被Catch住，程序会在异常处终止

4、      try里的代码可以发生多种异常，所以try后面可以跟多个catch，发生的异常被一个catch住后，其他的catch不再匹配，因此，我们要把最个性的异常处理放在前面，即先放子类，再放父类。

五、    finally，最后要被执行的，无论发生什么情况，被我包含的代码都可以被执行，除非之前用了System exit（1）--（退出JAVA虚拟机）。

将来的作用：用来回收系统中的资源。

六、    throws，在方法声明处声明这个方法要抛出的异常，可以扔出多个，用逗号隔开。

方法内部的代码不做异常处理，把异常通过方法的声明扔给调用者，有调用者来处理，如果调用者还不处理，继续向外扔。

七、    throw，在方法体内扔出一个自定义的异常。

throw new Exception（“对异常的描述”）

八、    异常的分类

Object

     |---throwable

         |--Error：系统级别的严重错误，一旦发生不可修复

         |--Exception：代码中的异常，程序员可以处理

              |--RuntimeException运行时异常：可以处理可以不处理

              |--编译时异常：必须处理，否则程序通不过编译

九、    常见分类

—RuntimeException

ArrayIndexOutOfBoundsException：数组下标越界

NullPointerException：空指针异常

InputMismatchException：输入类型不匹配

ArithMeticException：除数为0

把数字字符串转换为数字

String s = “123”;

int i = Interger.valuesOf(s);

double.valuesOf(s);

ClassCastException：强制类型转换异常

NumberFormatException:把数字字符串转换为数字时发生异常，即字符串里含有非字符

String str = “abc”;

int i = Interger.valuesOf(str);

SQLException：数据库异常—编译时异常

ClassNotFoundException：类找不到—编译时异常

IOException：文件读写异常—编译时异常

十、    日志记录工具，来记录异常，比较好的工具log4j

CH08

一、    数据在电脑中的存储方式

1、      内存：内存条，以及cpu里的缓存

2、      外存：硬盘、U盘、光盘、网络等等。

说明：我们可以形象的内存和外存称为容器，数据如何从一个容器进入另一个容器？

二、    I/O

1、      JAVA语言提供了强大的IO机制来读取数据

2、      I是输入操作：把外存中的数据读取到内存中。

3、      O是输出操作：把内存中的数据读取到外存中。

三、    数据流

数据在电脑中上传输就像水管里的水一样，从一端流向另一端。

数据流是一串连续不断地数据的集合，流淌在IO水管中。

input stream：从外界（硬盘、文件、网络等）流向内存称为输入流，写进电脑。

output stream：从内存流向外界（显示器、网络、打印机、文件）称为输出流。

四、    数据流分类

字节流：一个字节一个字节的读取数据（一个字节占8位）

InputStream，OutputStream

字符流：一个字符一个字符的读取数据，JAVA采用的Unicode编码方式，一个字符占2个字节。

Reader，Writer

五、    标准的输入输出

System.out：向标准的输出设备（一般是显示器或者打印机）输出数据print 和println.

System.in：读取标准的输入设备（一般是键盘）输入的数据。

System.err：向标准的输出设备输出错误信息。

六、    file文件类

他就是用来描述目录或者文件信息的，并且提供了各种办法对文件进行管理。

构造方法：

File f = new File(“test”);

在当前目录下创建文件对象f

File f = new File(“\\root”);在当前程序所在盘的根目录下创建文件夹对象f

File f = new File(“dir”,”test”);

在指定目录dir（必须实际存在）下创建文件对象f

常用方法：

boolean exists();判断文件或目录是否物理存在，存在未true，否则为false。

boolean isFile();判断是否是文件

Boolean isDirectory（）；判断是否是目录

File[]  listFile（）；返回带完整路径的文件对象

String[] list();返回只有文件名的字符串数组

String getName();返回文件或者目录名

String getPath();返回文件或者目录的路径

long length();获取文件的长度。

CH09

一、    数组的特点：

1、      数组的长度是固定的，定义了多少空间，只能放这么多的数据，越界就异常。

2、      数组只能放同种类型的数据。

二、    类和对象

在面向对象的思想里，进行数据通信的载体是对象，对象的属性可以是不同的数据类型，对象本身就保存了大量的数据。

三、    集合类

Java的其他机制：

GC垃圾回收机制，跨平台机制，异常处理机制，泛型机制

集合类：是Sun公司提供的用来存储大批量数据的，并且存储数据的空间会根据数据的多少自动分配，同一个集合类里可以放各种数据类型的数据，他提供了丰富的方法操作数据，在添加方法中add(Object obj)里的参数是Object，那么父类出现的地方子类都可以出现，所以集合类可以放任意数据类型。

四、    集合类的分类

Collection接口

     |--List接口：存放的有序的，可以重复的数据

          |--ArrayList：动态数组，底层是以数组的方式存储数据。

          |--LinkedList：底层是以链表的方式存放数据。

     |--Set接口：存放无序的，不可重复的数据

         |--HashSet：底层是以哈希表的方式存储数据

         |--TreeSet：有序的Set集合。

Map接口：以键Key值Values对的方式来存储数据。

     |--HashMap：键可以为NULL，但只能有一个NULL值，但是值可以有多个NULL。

     |--TreeMap：有序的Map集合

     |--Hashtable：Key和Value都不可以是NULL

五、    List集合的常用方法。

add（Object）：向集合中添加元素

remove（int index）、remove（Object o）：删除集合中的元素，可以根据集合的下标（从0开始）亦可根据元素的值。

set（int index，Object o）：修改下标index 位置的元素o

get(int index)：得到下标为index的元素

size（）：得到集合元素的个数

isEmpty（）：判断集合是否为空

clear（）：清空集合中的元素

contains（Object o）：判断集合中是否包含o元素

六、    LinkedList的特有方法

addFirst（Object 0）：在集合的开头添加数据

addLast（Object 0）：在集合的末尾添加数据

removeFirst（）：删除第一个元素

removeLast（）：删除最后一个元素

getFirst（）：得到第一个元素

getLast（）：得到最后一个元素

七、    Set集合：无序的，不重复的数据。遍历时因为无序，所以只能用遍历器Iterator

八、    遍历器（迭代器）Iterator

Collection接口中有个得到Iterator对象的方法，Collection下面的实现类都实现了这个方法，所以他的下面的每一个集合都可以得到一个遍历器。

1、得到遍历器的代码：

Iterator<E> it = 集合对象.iterator();

2、遍历的方法：

hasNext（）：判断是否还有下一个元素

next（）：取出当前元素

3、具体代码：

while（it.hasNext（））{

数据类型 对象 = it.next（）；

}

九、    泛型机制

泛型机制是为了保障数据安全，他的出现，规定了在同一个集合里存放同类型的数据，一旦给集合用上了泛型，那么取数据的时候就避免了强制类型转换。

语法：

集合类名或者集合接口名后加<要放的数据类型> = new集合类名<要放的数据类型>();

1、      约定了在集合中存放的数据类型

2、      避免了取数据时的强制类型转换

十、    遍历集合的三种方式：

1、      for循环：只能遍历list集合

2、      迭代器，可以遍历所有的集合

3、      foreach循环，可以遍历所有的集合

for（数据类型  变量名：存放数据的集合对象名）

遍历数组（String必须是泛型约定过的）

String[] arr = {“a”,”bbb”,”ccc”,”ddd”};

for(String s:arr){

  syso—(s);

}

十一、Map接口：里面的数据都是成对出现的，以Key和Value的方法表示，Key相对于Value的索引。

常用方法：

put.(key,value)：以键值对的方式存放数据

remove(key)：删除此键值对应的元素

get(key)：得到此键值对应的value值

size()：得到map集合的长度

keySet()：得到集合中所有的键，返回值为set集合

values()：得到集合中所有的值，返回值为Collection接口

containsKey(key)：判断集合中是否包含此键值

containsValue(value)：判断集合中是否包含此值。

十二、Collections类，是一个工具类，提供了很多静态的方法来操作集合。

常用的方法有：

Collections.sort();排序

Collections.reverse();反转

Collections.cop(List m, List n):把n拷贝到m中

十三、final，finally，finalize的区别？

final：最终的，不可改变的，可以修饰类，此类不可被继承；可以修饰方法，此方法不可被重写；可以修饰变量，变量不可二次赋值。

finally：异常机制中的一个关键字，用来做资源的回收，即不管是否发生异常，被finally包含的代码都会执行。

finalize：GC垃圾回收机制的一个方法，在回收没有引用的对象时被JVM自动调用。

十四、Collection和Collections的区别？

Collection是一个接口，包括子接口List和Set。其中List接口是用来存放有序的、可重复的元素；Set接口用来存放无序的、不可重复的元素。List接口有两个实现类，分别是ArrayList类和LinkedList类。Set接口有两个实现类，分别是HashSet类和TreeSet类。

Collections是一个工具类，常用的方法有：

Collections.sort();

Collections.reverse();

Collection.cop(List m, List n);

CH10

一、    问题：

如何保存程序中的数据？目的地：数据库

程序中的数据是瞬时状态，我们要把瞬时数据转化为持久化数据。

二、    怎么在程序中连接数据库

IT界有很多数据库厂商：SQL SEVER,ORACLE,MY SQL

在Java语言 使用，Java要指定连接数据库的规范（接口），告诉各个数据库厂商，你们只要实现了我的规范，程序员就可以在程序中使用你们的数据库。

三、    JDBC规范（Java database connection）

Java语言制定的连接数据库的规范，是一组标准的Java接口和类，这些接口的实现类叫数据库驱动程序，数据库驱动程序有各个数据库厂商提供。

四、    必须要知道的接口和类

1、      驱动程序

有数据库厂商提供的，Oracle的classes12.jar，classes14.jar，ojdbc6.jar

加载驱动的字符串：oracle.jdbc.driver.OracleDriver

2、      DriverManager类：Sun公司的管理各个数据库驱动程序的类。

3、      Connection接口：负责连接数据库，并承担传输数据库的任务，通过DriverManager.getConnection(url,username,pwd)得到。

4、      Statement接口：用于执行静态的sql命令，得到他通过conn.createStatement();

5、      PreparedStatement接口：是Statement的子接口，用来执行动态的sql命令，也称为预编译sql命令。得到：conn.prepareStatement(sql);

在创建它的时候必须提供sql命令，在创建它的同时就把这个sql命令预编译了。

6、      ResultSet接口：用于得到查询结果，即结果集。

五、    Statement接口

这是一个执行静态sql命令的对象，所谓静态的sql语句是说这个sql必须是完整的命令。

使用它的时候是：

1、      先得到这个对象Statement st = conn.createStatement();

2、      调用它的方法来执行sql语句

|--execute(sql)：可以执行所有的sql命令，但是，它的返回值是Boolean类型的，所以我们一般不用他来执行select命令。

|--executeQuery(sql)：用来执行SELECT命令，返回值是ResultSet类型

|--executeUpdate(sql)：用来执行insert，update，delete命令，返回值是int类型，代表了这条sql命令插入了几条数据，更新了几条数据，删除了几条数据。

七、PreparedStatement接口：他是Statement的子接口。

这是一个执行动态sql命令的对象，所谓的动态sql语句是说这个sql在程序运行期间，你可以为他添加参数。

使用它的时候是：

1、      先要把sql命令写好

2、      得到这个对象ps = conn.prepareStatement(sql)，在创建这个对象的时候就要把sql预编译进去。

3、      为sql命令中的占位符设置值，根据数据表中的字段的类型来调用相应的方法

number(7):ps.setInt(占位符在sql语句中的位置，要插入的数值)

number(6,5):ps.setDouble(占位符在sql语句中的位置，要插入的数值)

varchar2(20):ps.setString(占位符在sql语句中的位置，要插入的数值)

date:ps.setDate(占位符在sql语句中的位置，要插入的数值)

注意：占位符的位置是自左向右从1开始

4、      执行sql命令

|--execute()

|--executeQuery():执行sql命令

|--executeUpdate():执行insert into，delete，update，返回值为int

注意：因为在创建ps的时候已经把sql预编译进去了，所以在执行相应的方法时，不需要传参数。

八、ResultSet结果集

得到她是通过ps的executeQuery()方法

遍历结果集需要他的next（）方法

String sql = “select tname,sex,address from teacher”

ps = conn.prepareStatement(sql);

rs = ps.executeQuery();

while(rs.next()){//一是取当前记录，二是向下移动记录，移动后可以判断后面是否还有记录

     rs.getString(“tname”);//可以用字段在你写的sql命令中自左向右的位置，但是一般不用

     rs.getString(“sex”);//rs.getString(2);

     rs.getString(“address”);

}

CH11

一、    数据的状态

瞬时的：程序用来存放数据的变量，随着程序运行的结束就消亡了，没有二次保存或者查看数据的功能。

持久的：保存在某种介质上的，可以长期的被使用。

二、    持久化操作

把数据在瞬时状态与持久化状态转化的机制称为持久化。

例：

瞬时数据：Teacher t = new Teacher(“谢静”,”女”,“1990-09-09”，“济南”)；

持久化数据：数据库表中的一条记录1，谢静，女，1990-09-09，济南

把瞬时数据t保存为数据库表中的一条记录

把持久化数据读取为一个Teacher对象

三、    对数据库中的数据所做的操作有哪些？

增删改查

四、    DAO（data access object）：数据访问对象

我们把承载对数据进行增删改查操作的对象成为DAO

实际上把增删改查操作封装在一个类里，这个类的对象成为DAO

五、    DAO组成

1、      实体类：对应数据库中的一张表，一般实体类名为表名。表中的字段为实体类的成员属性（属性名和字段名保持一致），数据类型保持一致。这种实体类被称为pojo简单的Java类，纯净的Java类

2、      DAO接口：约定程序对实体类对应着的这张表的操作，操作的对象是表，在程序中是实体类。

3、      DAO实现类：根据需求或者具体的数据库，来完成DAO约定的功能，方法只有sql操作，不能有任何其他的业务逻辑。

4、      数据库工具类BaseDao：封装了连接数据库和关闭资源的操作。

六、    项目中的分层

数据访问层：即DAO层，这一层只和数据库打交道，它可以被其他层调用。

显示层：向用户展示信息，并且会收集用户信息，与用户进行各种交互，将来的项目有HTML或者jsp来承担。

业务逻辑层：进行各种业务逻辑的处理，连接了显示层和数据访问层。

显示层è业务逻辑层è数据访问层

/数据访问层è业务逻辑层è显示层

七、    项目中的各个包的作用，以及类的存放位置

1、      entity包：放实体类，实体类名同表名

2、      dao包：数据访问接口，实体类名+ DAO，例StudentDao

3、      dao.impl包：数据访问接口的实现类，实体类名 + DAO + Impl，例StudentDaoImpl

4、      biz包：业务逻辑接口实体类名 + biz，例StudentBiz，在有的项目中把这个包定义为service

5、      biz.impl包：业务逻辑接口实现类，实现类名 + Biz + Impl例StudentBizImpl

6、      util包：工具类包，放项目中通用的类，有的项目组把这个包叫做tools或者common

7、      test包：因为现在是Java项目，没有前端，这里定义的程序的入口