第七章：Java继承

一、继承的概念

         1.一个父类派生出一个子类的机制称为继承。

2.承是重用程序代码的有力手段，当多个类之间存在相同的属性和方法时，可以从这些类中抽象出父类。

         3.们只需要在父类中定义这些属性和方法，而子类无须重新定义这些属性和方法，直接从父类继承即可。

         4.通过继承，子类就会自动的拥有在父类中定义的属性和方法。

         5.两个或多个类的成员中存在一部分相同的情况，通过继承机制，可以利用现有的类来创建新的类。

         6.子类不但拥有父类的成员，还可以定义新的成员。

         7.可以提高软件的可重用性和可扩展性。

二、父类和子类

         1.父类：基类或超类

         2.子类：派生类或衍生类

三、继承的实现

         使用extends关键字。

四、访问控制

         Java语言设定了访问控制规则，限制从外部类使用类的成员

注意：父类中用private修饰的属性和方法对子类是透明的，不能被继承。

五、继承中的构造方法

         1.父类的构造方法不能被子类继承

         2.子类在执行自己的构造方法之前必须要先调用父类的构造方法，调用分为两种：

                   a.显示调用：在子类的构造方法中的第一句使用super关键字来指定调用父类的哪个构造方法

                   例如：super()//调用父类无参数的构造方法

                              super(参数列表)//调用父类带参数的构造方法

                   b.隐式调用：如果没有显示调用，则自动调用父类无参数的构造方法，相当于显示调用super()，也就是说当调用父类默认的构造方法时，可以省略super()

         特别注意：

1.子类构造方法的调用顺序为，先调用父类的构造方法，在调用子类的构造方法

2.当父类中有默认构造方法，子类构造方法可以省略对父类构造方法的显示调用

3.当父类中只有带参数的构造方法时，子类的构造方法中必须要使用super关键字显示调用父类的构造方法

六、类的层次结构

         1.Java语言中不支持多继承，即一个类只能直接继承一个类。

         2.一个类可以有多个间接父类。

         3.所有的Java类都直接或间接的继承了java.lang.Object类

         4.Object类是所有Java类的祖先，在Object类中定义了所有Java对象都具有的相同的行为

七、默认继承

         1.在定义一个类时，没有使用extends关键字，那么这个类就直接继承自Object类

第八章：Java多态

一、多态概念

         官方定义：多态性是指对类的成员方法的调用将形成不同的实现方式

         个人理解：父类引用指向子类对象

         多态必须存在于继承的环境中，也就是说继承是多态的前提条件，是面向对象程序设计的核心，利用多态可以有效的提高程序的可扩展性

         多态分为两种：

                   静态多态：方法重载

                   动态多态：建立在继承和方法重写的基础上

         动态多态也叫做动态绑定，通常我们说多态一般是指动态多态。

二、方法重写

         如果在子类中定义一个方法，其名称、返回值类型和参数列表正好与父类中的某个方法完全匹配，我们就可以说子类的方法重写了父类的方法。

         特别注意：

         1.方法重写一定要有继承关系为前提条件

         2.子类的方法名称、返回值类型以及参数列表必须和父类的方法相同

         3.子类的方法不能缩小父类方法的访问权限

         4.在同一个类中，方法只能重载，不能重写

三、多态应用

         当一个父类的引用指向子类对象，通过该引用调用方法，总是调用子类重写之后的方法

         子类的对象赋给父类的引用，这种行为称为“向上转型”，可以隐式转换

父类的引用转换回子类的引用，这种行为称为“向下转型”，需要强制转换

         特别注意：当父类的引用指向子类对象，对方法的调用是动态解析的，即根据对象的实际类型来动态选择，称为动态绑定

四、Object类

         Object类是所有Java类的父类或间接父类，根据多态特性，我们可以使用Object类的引用指向任何对象

         注意：如果能够确定Object所引用的对象的具体类型，可以进行向下转型(强制转换)

五、equals方法

         equals方法的目的是用于检测两个对象是否相等

         Object类所提供的equals方法的实现是：检测两个对象的内存地址是否在同一区域（内存地址是否相等）

         通常来说我们需要对equals方法进行重写，目的是为了重新定义规则来判断两个对象是否相等。

         个人理解：equals方法就是自定义游戏规则，按照我们的需要来制定对象相等的条件

六、toString方法

         toString方法返回一个描述该对象的字符串(直接使用对象进行输出时必须重写该方法)

         个人理解：简化输出对象信息的过程，重写后可以直接输出对象

七、final关键字

         final关键字可以用于修饰类、方法和变量，final表示不可变

         1.当final修饰类时：表示该类不允许被其他类继承

         2.当final修饰方法时：表示该方法不允许被子类重写

         3.当final修饰变量时：表示该变量是一个常量

         注意：使用final修饰的常量必须显示进行初始化

第九章：抽象类和接口

一、抽象类概念

         从下向上看类的继承关系图，我们发现类逐渐变得更通用，也更抽象。

         由于类变的通用，我们将无法为类中的方法创建有意义的实现过程。

         有时候我们需要一个父类，此父类只定义可被其所有的子类共享的一般形式，而让每个子类来补充实现的细节，这样的类我们称为抽象类。

         注意：包含抽象方法的类一定是抽象类，抽象类中可以包含属性和非抽象方法。

二、抽象方法

         在定义Java方法时，可以只定义出方法的声明部分，而不必写出方法体（即方法的实现细节），这样的方法称为抽象方法。

         注意：抽象方法必须使用abstract关键字类修饰。

三、特别注意

         è抽象类和抽象方法都必须使用abstract关键字修饰

         è抽象方法没有方法体，也没有一对大括号，在参数列表后一定要有分号

         è如果类中包含抽象方法，那么这个类一定是抽象类，但相反的，抽象类中却不一定包含抽象方法。

         è抽象类是不能够实例化的（即不能创建抽象类的对象）

         è抽象类中可以声明static方法

四、抽象类的使用

         既然抽象类不能创建对象，所以我们只能通过继承来使用抽象类。（支持多态）

         注意：

                   1.如果子类继承了一个抽象类，那么子类就必须重写父类中所有的抽象方法

                   2.如果一个抽象类继承了另一个抽象类，那么子类就不需要重写父类中的抽象方法

五、抽象类总结

         抽象类主要是由子类继承，再由其子类来发挥作用，那么抽象类的作用主要表现在以下两个方面：

         1.代码重用（表面现象）

         2.规划其子类行为（重点理解）

         用一句话来总结抽象类：抽象类就是对类的抽象

六、接口概念

         在Java中不支持多继承，但提供了强大的接口支持

         接口：把不相关的，但具有相同行为的类中的方法规定出来，不需要考虑类之间的继承关系

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

         接口（interface）是抽象方法和静态常量的集合，从本质上讲，接口是一种特殊的抽象类，这种抽象类只能包含抽象方法和静态常量的定义，没有变量和方法的实现

七、特别注意

         因为接口中定义的方法一定是抽象方法，所以在接口中定义抽象方法时可以将public、abstract关键字省略

         因为接口中定义的变量一定是静态常量，所以在接口中定义静态常量时可以将public、static、final关键字省略

八、接口的使用

         同继承的关系类似，Java类可以实现（implements）接口，实现类必须重写接口中的所有抽象方法

         一个实现类可以实现多个接口，每个接口中间用逗号隔开，一个接口也可以被多个类实现

         接口同样支持使用多态进行编程：接口引用指向实现类对象

         接口之间可以有继承关系，并且支持多继承

九、接口总结

         用一句话来总结接口：接口是对行为（即方法）的抽象

十、接口和抽象类的比较

         1.相同之处：

                   a.接口是一种特殊的抽象类

                   b.都不能创建对象

                   c.都可以包含抽象方法

         2.不同之处：

                   a.抽象类可以包含非抽象方法，而接口不可以

                   b.如果向抽象类中添加一个非抽象方法，不会对子类造成任何影响，但对于接口，一旦创建就不应该改变了

                   c.一个类只能继承一个抽象类，但一个类可以实现多个接口

十一、预定义接口Comparable

         在java.util包中有一个Arrays类，该类的sort方法可以对一个对象数组进行排序操作，但有一个前提条件就是数组中的对象必须是实现了Comparable接口的

第一章：异常处理

一、异常概念

         异常（Exception）是指程序运行期间发生的事件，该事件可以中断程序指令的正常执行

         在Java语言中，异常可以分为两类：

                   错误（Error）：是指JVM系统内部错误，资源耗尽等严重情况

                   异常（Exception）：因编程错误或偶然的外在因素导致的一般性问题，例如对负数开平方，空指针访问，试图读取不存在的文件以及网络连接中断问题

         Java语言提供了一套完整的异常处理机制，正确的运用这套机制，有助于提高程序的健壮性

         注意：Exception和Error有一个共同的父类Throwable

二、处理机制

         Java程序执行过程中出现异常，系统会自动检测到并生成一个相应的异常类对象，然后再将它交给运行时系统

         运行时系统再寻找相应的代码来处理这一异常，如果运行时系统找不到任何可以处理该异常的代码，则运行时系统将终止，相应的Java程序也将退出

         程序员没有处理Error的能力，一般情况下只能处理Exception

三、异常处理特点

         对异常情况进行分类，用Java类来表示异常，具有可扩展性和可重用性

         异常流程的代码和正常流程的代码分离，提高了程序的可读性

         可捕获异常立即处理，也可以抛给上一层来处理，具有灵活性

四、Exception类

         Exception分为两个分支

         1.运行时异常：如类型转换异常，数组索引越界异常，空指针异常等

         2.编译时异常：SQL语句执行异常，读取不存在的文件异常等

五、常见的异常类型

六、异常处理的宗旨

         è返回到一个安全和已知的状态

         è能够让用户执行其他命令

         è如果可能，保存所有的工作

         è如果有必要，可以退出以避免造成进一步的危害

         è异常只能用于非正常的情况，不能用异常来控制程序的正常流程

         è避免过于庞大的try块代码，try块代码越庞大，出现异常的地方就越多，分析异常原因就越困难

七、使用异常处理

         Java提供了try-catch-finally语句来支持异常处理

         try块：可能产生异常的代码

         catch块：当产生异常时的处理代码

         finally块：无条件执行代码（通常用来释放资源）

         注意：通常当程序产生异常进入到catch语句块中的时候，程序员可以使用printStackTrace方法将异常信息输出到控制台上

八、声明抛出异常

         声明抛出异常是Java异常处理的第二种方式，如果一个方法中的代码在运行时可能产生某种异常，但在本方法中不必，或者不能确定该如何处理此类异常时，则可以使用throws关键字声明抛出异常，此时方法中将不对此类异常进行处理，而是由该方法的调用者进行处理

第三章：集合框架

一、集合概述

         Java数组在创建时必须要指定数组的长度，数组一旦创建，其长度就不能再改变

         在很多实际情况中，数组的长度是不固定的，因此Java语言中提供了更高级的容器即集合框架来解决相关的问题

         所有的Java集合都位于java.util包中

二、集合概念

         集合就是将若干用途、性质相近或相同的“数据”组合而成的一个整体

         从体系上讲，Java中基本的集合可以分为以下3种：

         列表（List）：

                   List集合区分元素的顺序，并且允许重复元素

         集（Set）：

                   Set集合不区分元素的顺序，不允许重复元素

         映射（Map）：

                   Map集合保存成对的“键-值”信息，键不允许重复，每个键最多只能映射一个值

三、集合中的元素

         Java集合中只能保存引用数据类型数据（即对象），实际上集合中存放的是对象的引用，而非对象本身，集合中的元素相当于引用类型变量

四、Collection接口

         java.util.Collection接口是描述Set和List集合类型的父接口，其中定义了有关集合操作的普遍性方法

         常用方法：

                   boolean add(Object o)

                   boolean remove(Object o)

                   int size()

                   boolean isEmpty()

                   boolean contains(Object o)

                   void clear()

                   Iterator iterator()

                   Object[] toArray()

五、List接口

         List接口为Collection接口的子接口

         List接口规定使用者可以对列表元素的插入位置进行精确控制，并添加了根据索引来访问元素等功能，接口中新添加了相应的方法

         void add(int index,Object element)

         Object get(int index)

         Object set(int index,Object element)

         int indexOf(Object o)

         Object remove(int index)

六、ArrayList

         java.util.ArrayList类实现了List接口，用于表述长度可变的数组列表

         ArrayList允许取值为null，默认容量为10，除了实现了List接口定义的所有功能外，还提供了一些方法来操作ArrayList容量的大小

         public ArrayList()

         public ArrayList(int capacity)

七、迭代器

         java.util.Iterator接口描述的是以统一方式对各种集合元素进行遍历的工具，称为迭代器

         boolean hasNext()

         Object next()

八、泛型

         泛型（Gernerics）机制自JavaSE 5.0开始引入，其实是将原本确定不变的类型参数化

         泛型的好处：

                   1.作为对原有java类型体系的扩充，使用泛型可以提高java应用程序的类型安全，可维护性和可靠性

                   2.可以解决集合中的数据造型问题

         使用方法：

                   创建集合容器时规定其允许保存的元素类型，然后由编译器负责添加元素的类型合法性检查，在取用集合元素时不必再进行造型处理

         总结：数据类型参数化

九、HashSet类

         java.util.HashSet类实现了java.util.Set接口，描述典型的Set集合结构

         HashSet中不允许出现重复元素，不保证集合中元素的顺序

         HashSet中允许包含null值元素，但只能有一个null元素

十、TreeSet类

         java.util.TreeSet类也实现了java.util.Set接口，它描述的是Set的一种变体，可以实现排序功能的集合

         在将对象元素添加到TreeSet集合中时，会自动按照某种比较规则将其插入到有序的对象序列中，以保证TreeSet集合元素组成的对象序列时刻按照“升序”排列

         TreeSet类支持两种排序方式：自然排序（默认）和自定义排序

         使用自然排序时，集合中的元素必须实现Comparable接口，TreeSet调用对象的compareTo方法对元素进行排序

         JDK类库中有一部分类实现了Comparable接口，如：Integer、Double、String等

十一、List集合和Set集合的遍历

         List类型集合：可以使用普通for循环，超级for循环和迭代器进行遍历

         Set类型集合：可以使用超级for循环和迭代器进行遍历

         注意：由于Set类型集合没有索引，因此不能用普通for循环遍历

十二、Map（映射）

         Map是一种把键对象进行映射的集合，它的每一个元素都包含两个对象（键对象和值对象）

         典型的Map类型集合有HashMap和TreeMap

         添加元素方法：put(Object key,Object value)

         通过键对象获取值对象：get(Object key)

         注意：Map中键对象不允许重复，值对象可以重复

十三、TreeMap类

         TreeMap类实现了SortedMap接口，因此TreeMap可以根据键对象进行排序，但前提条件是所存放的键对象必须实现了Comparable接口

十四、Map集合遍历

         由于键对象不能重复，所以可以将所有的键对象看成是一个Set类型的集合

         通过Map集合的keySet()方法获取到这个Set类型集合

         遍历这个由所有键对象组成的Set集合

         在遍历过程中每取到一个键对象即可取到一个值对象

第四章：IO

一、概述

         绝大部分的编程工作都涉及到数据的传递控制（输入/输出）

         Java中的IO采用流的方式来实现，即将数据的传递看作为数据的目的和源之间的流动

         IO类库位于java.io包中，对各种常见的输入和输出流进行了抽象

二、流的分类

         按照IO处理数据的不同分为：字节流和字符流

         按照功能的不同分为：数据流和操作流

         按照实现方式的不同分为：底层流和高层流

三、字节流

         将字节作为最小传输单元

         由相应的数据流和操作流构成

         字节输入流抽象父类：InputStream

         字节输出流抽象父类：OutputStream

         数据流（底层流）：负责搭建字节数据传输的通道，负责字节数据的传输，只提供了基本的字节数据访问的方法。InputStream和OutputStream是所有字节流类的父类，都是抽象类，不能实例化，通过定义了若干的方法来规范子类的行为，如：IO流结束后必须关闭

         InputStream/OutputStream

         FileInputStream/FileOutputStream

         操作流（高层流）：不从IO设备中读取或写入数据，仅从其它流中读取或写入数据，提供了普通流所没有提供的方法来简化编程或提高IO的效率。操作流利用了“装饰器”设计模式，本身继承了InputStream类，加入了大量的方法，用来“装饰”其他数据流类，避免了大量创建新的功能类。

         BufferedInputStream/BufferedOutputStream

四、字符流

         字符输入流抽象父类：Reader

         字符输出流抽象父类：Writer

数据流（底层流）：

         Reader/Writer

         FileReader/FileWriter

         操作流（高层流）：

         BufferedReader/BufferedWriter

五、字节字符桥接流

         InputStreamReader：采用适配器设计模式，把InputStream类型转换为Reader类型

         OutputStreamWriter：采用适配器设计模式，把OutputStream类型转换为Writer类型

六、File类的基本概念

         File类：表示文件和目录路径名的抽象表示形式。

         File类可以实现文件的创建、删除、重命名、得到路径、创建时间等等，是唯一与文件本身有关的操作类。

第六章：线程

         线程是一个程序内部的顺序控制流

一、线程和进程

         1.每个进程都有独立的代码和数据空间，进程切换的开销大

         2.线程是轻量级的进程，同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器，线程切换开销小

         3.多进程：在操作系统中能同时运行多个任务（程序）

         4.多线程：在同一应用程序中有多个顺序流同时执行

二、创建线程

         Java的线程是通过java.lang.Thread类来实现的，每个线程都是通过某个特定的Thread对象所对应的run方法来完成其操作的，run方法称为线程体。

         在Java语言中创建线程有两种方式：

         A.实现Runnable接口

                   1.创建一个类并实现Runnable接口

                   2.重写Runnable接口中的run方法

                   3.创建实现类的对象

                   4.创建一个线程对象并将实现类对象传入

                   5.调用start方法启动线程

         B.继承Thread类

                   1.定义一个类直接继承Thread类创建线程

                   2.重写Thread类中的run方法

                   3.创建线程对象

                   4.调用start方法启动线程

三、两种创建线程的比较

         è使用Runnable接口创建线程

                   可以将CPU，代码和数据分开，形成清晰的模型

                   实现类还可以从其他类继承一些有用的属性和方法

                   有利于保持程序风格的一致性

         è直接继承Thread类创建线程

                  Thread子类无法再从其他类继承

                   编写简单，run方法的当前对象就是线程对象，可以直接操作

四、其他概念

         1.后台处理（Background Processing）：让步给其他的程序，趁着CPU有空闲，当没有更高优先级和更紧迫的任务需要处理的时候才能够运行的任务，例如：打印文档操作等

         2.后台线程（Background Thread/Daemon Thread）：以后台的方式运行的，通常是给其他的线程提供服务的一些次要的线程，例如：JVM中垃圾回收线程

         3.用户线程（User Thread）：用户创建的或者系统为用户创建的线程

         4.主线程（Main Thread）：应用程序运行的主线索，是用户线程的一种

         5.子线程（Sub Thread）：在一个正在运行的线程中所创建的新的线程

五、后台线程

         Thread类提供的相关方法：

                   public final boolean isDaemon()//判断一个线程是否是后台线程

                   public final boolean setDaemon(boolean flag)//将一个线程设置为后台线程

         注意：当一个应用程序的所有用户线程都已经停止运行的时候，无论是正常退出还是运行出错提前终止，JVM都将会退出，可以理解为后台线程是不受重视的，是服务于用户线程的

六、线程的生命周期

         新建状态：新创建的线程对象

         就绪状态：当调用了start方法后进入就绪状态

         运行状态：由JVM的线程调度器来控制

         阻塞状态：当发生导致线程暂停的事件时，将由JVM的线程调度器调整为阻塞状态，比如在线程中进行IO操作或者等待键盘输入的数据等事件

         终止状态：当run方法中的程序都执行完毕，该线程将进入到终止状态

         特别注意：禁止将已经终止的线程再次启动，一个线程也不允许被多次启动

七、线程优先级

         Java线程的优先级用数字来表示，范围从1到10

         主线程的默认优先级为5，子线程的优先级默认和其父线程的优先级相同

         Thread类提供的相关方法

         public final int getPriority()//获取线程的优先级

         public final void setPriority(int newPriority)//设置线程的优先级

         相关的静态整型常量：

         Thread.MIN_PRIORITY=1

         Thread.MAX_PRIORITY=10

         Thread.NORM_PRIORITY=5

         特别注意：在程序开发中不能依赖于线程优先级来控制线程执行的先后顺序

八、线程休眠

         暂停执行当前运行中的线程，使之进入阻塞状态，待经过指定的“延迟时间”后再醒来并转入到就绪状态

         Thread类提供的相关方法：

         public static void sleep(long millis)

         public static void sleep(long millis,int nanos)

         注意：1秒=1000毫秒，1毫秒=100万纳秒

九、线程让步

         让运行中的线程主动放弃当前获得的CPU处理机会，但不是使该线程阻塞，而是使之转入就绪状态

         Thread类提供的相关方法：

         public static void yield()

十、线程挂起和恢复

         挂起：暂停当前运行中的线程，使之转入到阻塞状态，并且不会自动恢复运行

         恢复：使一个已经挂起的线程恢复运行

         Thread类提供的相关方法：

         public final void suspend()//线程挂起

         public final void resume()//线程恢复

十一、线程同步和死锁

         1.多线程共享数据：在多线程的操作中，多个线程有可能同时处理同一个资源，这就是多线程中的共享数据。

         2.线程同步：解决数据共享问题，必须使用同步，所谓同步就是指多个线程在同一个时间段内只能有一个线程执行指定代码，其他线程要等待此线程完成之后才可以继续执行。

         线程进行同步，有以下两种方法：

         （1）同步代码块

                   synchronized(要同步的对象){

                            //要同步的操作

}

         （2）同步方法

                   public synchronized void method(){

                            //要同步的操作

}

         3.同步准则：当编写synchronized块时，有几个简单的准则可以遵循，这些准则在避免死锁和性能危险的风险方面大有帮助：

                   （1）使代码块保持简短。把不随线程变化的预处理和后处理移出synchronized块。

                   （2）不要阻塞。如用户输入等操作。

                   （3）在持有锁的时候，不要对其他对象调用同步方法。

         4.线程死锁：过多的同步有可能出现死锁，死锁的操作一般是在程序运行的时候才可能出现。

         注意：多线程中要进行资源的共享，就需要同步，但同步过多，就可能造成死锁。

第七章：Socket网络编程

一、什么是计算机网络

         把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使更多的计算机可以方便的互相传递信息，共享硬件、软件和数据等资源

二、Socket编程

         两个进程间可以通过一个双向的网络通信连接实现数据交换，这种通信链路的端点被称为“套接字”（Socket）

         Socket通常用来实现Client-Server连接

         在java.net包中定义了两个类Socket和ServerSocket，分别用来实现双向连接的client和server

三、Socket编程的基本步骤

         1.建立网络连接

         2.打开连接到Socket的输入/输出流

         3.通过已打开的IO流进行数据读/写的操作

         4.关闭已打开的IO流和Socket对象

补充内容一：图形用户界面

         图形用户界面（GUI-graphics user interface）为用户和程序进行可视化交互提供了更符合人性的便捷操作方式，因此设计一个图形用户界面的应用程序必须具备其特征要素，如菜单、工具栏、控件等。

         Java为设计图形用户界面应用程序提供了基于GUI组件的快速应用开发手段，并提供了大量的可用组件，支持事件驱动开发。

一、Swing和AWT

         AWT：早期的Java包含一个抽象窗口工具箱（Abstract Window Toolkit，即AWT）的类库，用于基本的GUI编程，例如Button、Checkbox、List等，这些类均为Component类的子类

         AWT组件被认为是重量级组件，因为它们依赖于本地系统来支持绘图与显示，每个AWT组件在本地窗口系统里都有一个相关的组件

         Swing组件是用纯Java代码编写的，被称为轻量级组件，它不依靠本地组件来支持它的显示，而是完全由Java代码来绘制并显示的，所以比通常的AWT组件效率要高得多

         Swing：Swing库要新一些，为了避免重名，所有的Swing组件类都以大写字母J开头。绝大多数的Swing组件都是JComponent类的子类

二、窗体容器

         JFrame（窗体）：顶层应用程序窗口

         JDialog（对话框）：收集用户输入的模式和无模式对话框

         JPanel（面板）：容纳部分界面的小型容器

补充内容二：JDBC

一、概述

         大多数开发语言都提供了数据库的访问

         JDBC是由sun公司提供的一组接口和类，被封装在java.sql包中，用于访问数据库

         数据库厂商所提供的第三方驱动程序和类包，可以访问特定的数据库

二、JDBC

         JDBC（Java Database Connectivity）Java数据库连接，支持Java应用程序连接数据库

         基本功能：

                   1.支持基本SQL语句，在Java程序中实现数据库操作的功能并简化操作过程

                   2.提供多样化的数据库连接方法

                   3.为各种不同的数据库提供统一的操作界面

三、操作步骤

         1.做好操作某种数据库的准备工作

                   引入必要的包和类

                   加载JDBC驱动程序

                   标识数据源

         2.建立与数据库的连接渠道

                   分配一个Connection对象

         3.开始诉求，说明自己要做什么

                   编写sql语句

                   分配一个Statement对象

                   使用该Statement对象执行sql语句

         4.得到想要的结果，并对结果进行处理

                   从返回的ResultSet对象中查询数据

         5.处理完成后，做好收尾工作

                   关闭相关对象，释放资源

四、相关类和接口

         java.sql.DriverManager类

         驱动程序管理，提供了对不同的数据库驱动程序的管理功能

         java.sql.Driver接口

         数据库的驱动程序，软件驱动

         java.sql.Connection接口

         连接到特定数据库的连接对象

         java.sql.Statement接口

         操作数据库的对象

         java.sql.ResultSet接口

         多行多列的集合

五、驱动程序

         驱动程序：为了让计算机操作系统能够操作某种硬件或软件所提供的一种接口程序

         数据库驱动程序：应用程序操作某种数据库所需要的代码集合，可以理解为介绍应用程序和数据库相互认识的软件模块

枚举：

         枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则编译器就会报错，枚举可以让编译器在编译时就可以控制源程序赋给的非法值，使用普通变量的方式在开发阶段无法实现这一目标。

         在JDK1.5之后，使用关键字enum定义一种新的类型，称为枚举类型。

         使用enum关键字定义的枚举类，实际上就相当于定义了一个类，此类继承了Enum类而已。

JAVA基础笔记（很实用）继承-多态-抽象类-接口-异常-集合-IO-线程-Socket