课程总结

1、不同数据类型的等级

byte、short、char -> int -> long -> float -> double

在进行数据类型转化的时候，等级低的会自动转化为上一级的数据类型，但是等级高的不能自动向等级低的转化，需要进行强制类型转化，否则就会导致溢出

2、关于算术运算符的使用

-10 % 3 = -1

10 % -3 = 1

-10 % -3 = -1

结果由被除数的符合决定

3、关于"&&"和"&"

&&：当第一个条件不成之后，后面的条件都不执行了

&：&则还是继续执行，直到整个条件语句执行完为止

4、关于“||”和"|"

相同点：二者都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false。

不同点：“||”：如果左边的表达式的值为true，计算机就不会去计算右边的表达式

          "|"：则必需打两边的结果都算出来。

5、this的用法

I、表示类中的属性

II、调用本类的构造方法

III、表示当前对象

6、static的用法

I、设置静态变量

II、设置静态方法

（注：static方法不能调用非static的方法或属性，且不能与this同时使用）

7、实例化String类对象

1）String类一经声明则不可改变

2）StringBuffer类则可以对声明内容进行改变

与String对应的是equals()方法，equals()的作用是将内容进行比较，而String实际上是通过内存地址的断开--连接来改变其对象内容，而字符串中的内容并没有发生改变。

除此之外我们还学了String类常用的操作方法

 

8、类的继承格式

Class 父类{}

Class 子类 extends 父类{}

9、 继承的限制

只允许多层继承，不能多重继承。

10、方法的重载与覆写的区别

序号	区别点	重载	覆写
1	单词	Overloading	Overriding
2	定义	方法名称相同，参数的类型或个数不同	方法名称、参数的类型、返回值类型全部相同
3		对权限没有要求	被覆写的方法不能拥有更严格的权限
4	范围	发生在一个类中	发生在继承类中

11、继承

在使用继承的时候也应该注意的是：子类是不能直接访问父类中的私有成员的，但是子类可以调用父类中的非私有方法,但是不能直接调用父类中的私有成员

12、抽象类的定义及使用规则

（1）包含一个抽象方法的类必须是抽象类

（2）抽象类和抽象方法都要使用abstract关键字声明

（3）抽象方法只需声明而不需要实现

（4）抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法

13、final关键字

（1）使用final声明的类不能有子类

（2）使用final声明的方法不能被子类覆写

（3）使用final声明的变量为常量，常量不可以修改

14、抽象类与接口的关系

 

 15、Object类

 

 16、对象的多态性

1）向上转型：子类对象 →父类对象（自动转换）
2）向下转型：父类对象 →子类对象（强制转换）注：首先要进行向上转型，然后在进行强制类型转换。

17、接口

1）接口的使用要通过子类，子类通过implements关键字实现接口

class 子类 implements 接口A,接口B,...{
    
}

2）接口的定义格式

interface 接口名称{
    全局常量；
    抽象方法；
}

需要注意的是在接口中的抽象方法必须定义成public的权限，这是绝不可改变的。

 18、接口的使用方法

1） 因为java不支持多重继承，所以有了接口，一个类只能继承一个父类，但可以实现多个接口，接口本身也可以继承多个接口。

2 ）接口里面的成员变量默认都是public static final类型的。必须被显示的初始化。

3 ）接口里面的方法默认都是public abstract类型的。隐式声明。

4 ）接口没有构造方法，不能被实例化。

5 ）接口不能实现另一个接口，但可以继承多个接口。

6 ）类如果实现了一个接口，那么必须实现接口里面的所有抽象方法，否则类要被定义为抽象类。

 19、抽象类的使用方法

1 如果将一个类声明为abstract，此类不能生成对象，只能被继承使用。

2  抽象方法必须存在于抽象类中。

3  抽象类中可以有一般的变量和一般的方法。

4 子类继承抽象类必须实现其中抽象方法，除非子类为抽象类。 
   

 private void print(){}；//此语句表示方法的空实现。 
    abstract void print()； //此语句表示方法的抽象，无实现。

20、接口和抽象类的区别

1 ）接口只能包含抽象方法，抽象类可以包含普通方法。 
2 ）接口只能定义静态常量属性，抽象类既可以定义普通属性，也可以定义静态常量属性。 
3 ）接口不包含构造方法，抽象类里可以包含构造方法。    

4）抽象类不能被实例化，但不代表它不可以有构造函数，抽象类可以有构造函数，备继承类扩充

5） 接口是核心，其定义了要做的事情，包含了许多的方法，但没有定义这些方法应该如何做。 
6） 如果许多类实现了某个接口，那么每个都要用代码实现那些方法 
7）如果某一些类的实现有共通之处，则可以抽象出来一个抽象类，让抽象类实现接口的公用的代码，而那些个性化的方法则由各个子类去实现。

所以，抽象类是为了简化接口的实现，他不仅提供了公共方法的实现，让你可以快速开发，又允许你的类完全可以自己实现所有的方法，不会出现紧耦合的问题。

21、对象的多态性

1）向上转型：子类对象 →父类对象（自动转换）
2）向下转型：父类对象 →子类对象（强制转换）注：首先要进行向上转型，然后在进行强制类型转换。

22、接口

1）接口的使用要通过子类，子类通过implements关键字实现接口

class 子类 implements 接口A,接口B,...{
}

2）接口的定义格式

interface 接口名称{
    全局常量；
    抽象方法；
}

需要注意的是在接口中的抽象方法必须定义成public的权限，这是绝不可改变的。

23、包装类

a、包装类

 

 b、Number

 

24、异常处理格式

try{
    //有可能出现异常的语句
}catch(异常类 异常对象){
    //编写异常的处理语句
}
finally {
    //一定会运行到的程序代码
}

25、throw与throws

1)throws

public 返回值类型 方法名称(参数列表)throws 异常类{
    
}

注：throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)

2）throw

public static void main(String[] args) { 
    String s = "abc"; 
    if(s.equals("abc")) { 
      throw new NumberFormatException(); 
    } else { 
      System.out.println(s); 
    } 
}

注：throw是语句抛出一个异常

3）throw与throws的区别

a、throws出现在方法函数头；而throw出现在函数体。
b、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
c、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

26、Exception与RuntimeException

1）Exception

在程序中必须使用try...catch进行处理

2）RuntimeException

可以不使用try...catch进行处理，但是如果有异常产生，则异常将由JVM进行处理

27、多线程

1）继承Thread

class 类名称 extends Thread{               //继承Thread类
    属性***；                              //类中定义属性
    方法***；                              //类中定义方法
    public void run() {                  //覆写Thread中的run方法，此方法是线程的主体
        线程主体； 
    }
}

2）实现Runnable接口

class 类名称 implements Runnable{             //继承Runnable类
       属性***；                              //类中定义属性
       方法***；                              //类中定义方法
       public void run() {                   //覆写Runnable中的run方法，此方法是线程的主体
        线程主体；
    }
}

3）Thread与Runnable的区别

a、继承Thread类不能资源共享

b、实现Runnable接口可以资源共享

4）启动线程

a、Thread

Test t = new Test();
Thread test = new Thread(t);
test.start();

b、Runnable

public class text1 {
 
    public static void main(String[] args) {
        
        MyThread my1 = new MyThread("线程A");//实例化Runnable子类对象
        MyThread my2 = new MyThread("线程B");//实例化Runnable子类对象
        
        Thread t1 = new Thread(t1);//实例化Thread子类对象
        Thread t2 = new Thread(t2);//实例化Thread子类对象
        
        t1.start();//启动线程
        t2.start();//启动线程

或者

public static void main(String[] args) {
                
        new Thread(t1,"线程A").start();
        new Thread(t2,"线程B").start();
        
        t1.start();//启动线程
        t2.start();//启动线程
} 

28、多线程

1）线程操作的主要方法

 

 2）线程的优先级

 

 (注:优先级高只是说明该线程优先执行的可能性较高)

3）同步和死锁

a、同步代码块

ynchronized(同步对象)
{
        需同步的代码；
}

b、同步方法

synchronized 方法返回值 方法名称(参数列表){
        //方法体
  }

29、Java IO

1）File类中的主要方法和常量

 

 2）RandomAccessFile类的常用操作方法

 

30、字节流

1）字节输出流：OutputStream

                                                                                                                           OutputStream类的常用方法

 

 注：要想使用以上方法，必须使用子类实例化，此时使用FileOutputStream子类，此类的构造方法如下：

public FileOutputStream(File file) throws FileNotFoundException 

2）追加新内容

public FileOutputStream(File file,boolean append) throws FileNotFoundException

注：在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容，反之覆盖。

3）字节输入流：InputStream

                                                                                                                            InputStream类的常用方法

 

 注：要想使用以上方法，必须使用子类实例化，此时使用FileInputStream子类，此类的构造方法如下：

public FileInputStream(File file) throws FileNotFoundException 

31、字符流

1）字符输出流：Writer

                                                                                                                Writer类的常用方法

 

 注：要想使用以上方法，必须使用子类实例化，此时使用FileWriter子类，此类的构造方法如下：

public FileWriter(File file) throws IOException

2）使用FileWriter追加文件的内容

public FileWriter(File file,boolean append) throws IOException 

注：在构造方法中，如果将append的值设置为true，则表示在文件的末尾追加内容，反之覆盖。

3)字符输入流：Reader

                                                                                                                                    Reader类的常用方法

 

  注：要想使用以上方法，必须使用子类实例化，此时使用FileReader子类，此类的构造方法如下：

public FileReader(File file) throws FileNotFoundException 

32、字节流与字符流的区别

字节流在操作的时候本身是不会用到缓冲区（内存）的，是与文件本身直接操作的。

字符流在操作的时候是使用到缓冲区的。

33、字节-字符转换流

在整个IO包中，实际上就是分为字节流和字符流，但是除了这两个流之外，还存在了一组字节流-字符流的转换类。

OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即：将一个字符流的输出对象变为字节流输出对象。

InputStreamReader：是Reader的子类，将输入的字节流变为字符流，即：将一个字节流的输入对象变为字符流的输入对象。

34、内存操作流

1）字节内存流

a、内存字节输入流：ByteArrayInputStream

                                                                                              ByteArrayInputStream类的主要方法

 

b、内存字节输出流：ByteArrayOutputStream

                                                                                                          ByteArrayOutputStream类的主要方法

 

35、管道流

管道流的主要作用是可以进行两个线程间的通讯，分为管道输出流（PipedOutputStream）、管道输入流（PipedInputStream），如果要想进行管道输出，则必须把输出流连在输入流之上，在PipedOutputStream类上有如下的一个方法用于连接管道：

public void connect(PipedInputStream snk) throws IOException 

36、打印流

在整个IO包中，打印流是输出信息最方便的类，主要包含：

字节打印流：PrintStream

字符打印流：PrintWriter

打印流提供了非常方便的打印功能，可以打印任何的数据类型，例如：小数、整数、字符串等等。

                    PrintStream类的常用方法

 

 37、使用打印流进行格式化

在JDK 1.5之后，JAVA又对PrintStream类进行了扩充，增加了格式化的输出方式，直接使用printf()方法就可以完成操作，但是在进行格式化输出的时候需要指定其输出的数据类型。

                                    格式化输出

 

 38、System对IO的支持

System表示系统类，实际上在java中System类也对IO给予了一定的支持。

                                  System类的常量

 

 39、输入、输出重定向

通过System类也可以改变System.in的输入流来源，以及System.out和System.err两个输出流的输出位置。

                              System类提供的重定向方法

 

40、图形用户界面（GUI）

图形用户界面(Graphical User Interface,GUI)编程主要有以下特征：

   图形界面对象及其框架(图形界面对象之间的包含关系)

   图形界面对象的布局(图形界面对象之间的位置关系)

   图形界面对象上的事件响应(图形界面对象上的动作)

Java图形界面开发有两种可以使用的技术:AWT、Swing

41、AWT

AWT大量的引入了Windows函数，称为重量级组件

AWT：大量使用Windows的系统函数

AWT(Abstract Windowing Toolkit)，抽象窗口工具包，是Java提供的用来建立和设置Java的图形用户界面的基本工具。

AWT中的所有工具类都保存在java.awt包中，此包中的所有操作类可用来建立图形用户界面(GUI)的类，这些类又被称为组件(components)。

AWT包中提供的所有工具类，主要分为以下三种：

• 组件:Component
• 容器:Container
• 布局管理器:LayoutManager

1）组件(Component)

•  在图形界面中，用户经常会看到按钮、标签、菜单等组件。
•  组件会在一个窗体上显示。
•  在整个AWT包中，所有的组件类都是从Component和MenuComponet扩展而来的，这些类会继承这两个类的公共操作。

 

 

 

2）容器(Container)

•  所有的AWT组件都应该放到容器之中。
•  在容器中，所有的组件都可以设置在容器中的位置、大小等。
•  所有的容器都是Component的子类。

 

3）布局管理器(LayoutManager)

•  使用布局管理器可以使容器中的组件按照指定的位置进行摆放。即使容器改变了大小，布局管理器也可以准确的把组件放到指定的位置，这样就可以有效的保证版面不会混乱。
•  在AWT中所有的布局管理器都是LayoutManager的子类。

42、Swing

 Swing：采用Java实现用户界面，可以在任意的系统平台上工作

•  Swing使用Java语言实现，是以AWT平台为基础构建起来的新组件，属于轻量级的图形界面组件，直接使用Swing可以更加轻松的构建用户界面。
• Swing保存在javax.swing包中，所有的组件都从JComponent扩展出来的
•  在Swing中的所有组件类实际上也都是Component的子类，与Component不同的是，所有的组件前都加上了一个"JXxxx"的形式。

 

43、基本容器：JFrame

 

44、Dimension类

•  在JFrame中设置窗体的大小，也可以使用Dimension类完成。
•  此类封装了组件的现实宽度和高度。

 

45、Point类

组件的显示位置也可以使用Point类指定，此类封装的是显示位置的X、Y坐标。

 

 46、标签组件-Jlabel

•  JLabel组件表示一个标签，本身是用于显示信息的，不能直接更改其显示内容。
•  创建完的Label对象可以通过Container类中的add()方法加入到容器中。

 

47、更改JLabel的文字样式

可以使用Component类中定义的方法更改使用的字体

public void setFont(Font f)

在设置的时候使用了java.awt.Font类来表示字体，Font类的常用方法和常量如下：

 

48、在JLabel中设置图片

使用Icon接口和ImageIcon子类即可将一个图像设置到JLabel之中。

 49、按钮组件---JButton

JButton组件表示一个普通的按钮，直接使用此类就可以在窗体中增加一个按钮。

 

50、布局管理器

使用布局管理器可以管理组件的显示位置，每当需要重新调整屏幕大小或重新绘制屏幕上任一项目时，都要用到布局管理器。

在Swing中使用的所有布局管理器都实现LayoutManager接口，在Swing中主要使用以下五种常见的布局管理器：

•  FlowLayout
•  BorderLayout
•  GridLayout
•  Cardlayout
• 绝对定位

1）流式布局管理器-----FlowLayout

FlowLayout属于流式布局管理器，使用此种布局方式，所有的组件会像流水一样一次进行排列,使用此种布局方式，所有的组件会像流水一样一次进行排列

 

 2）BorderLayout

BorderLayout将一个窗体的版面划分成东、西、南、北、中五个区域，可以直接将需要的组件放到这五个区域中即可。

 

 3)表格布局管理器-----GridLayout

•  GridLayout布局管理器是以表格的形式进行管理的
•  在使用此布局管理器的时候必须设置显示的行数和列数
• 且为行优先

 

4)卡片布局管理器-----CardLayout

•  CardLayout就是将一组组彼此重叠的组件进行布局，就像一张张卡片一样，这样每次只会展现一个界面

 

5)绝对定位

如果不在窗体中指定布局管理器，也可以通过设置绝对坐标的方式完成布局设置。

public void setBounds(int  x, int y, int width, int  height)

51、其他容器

1）JPanel容器

•  使用Jpanel可以完成各种复杂的界面显示。
•  在JPanel中可以加入任意的组件，之后直接将Jpanel容器加入到JFrame容器中即可显示。
• 可以将多个组件加入到JPanel中实现复杂的排列。
•  使用JPanel并结合LayoutManager可以方便地管理组件。
• 使用LayoutManager对多个Jpanel进行排列，而每个JPanel中也可以分别使用不同的LayoutManager管理组件，完成对组件进行复杂的排列。

 2）JSplitPane容器

• JSplitPane主要功能是分割面板，可以将一个窗体分为两个子窗体，可以是水平排列也可以是垂直排列                                                                                                                                                                                                                                   JSplitPane类的主要方法和常量

      

 3）JTabbedPane容器

• JTabbedPane是在一个面板上设置多个选项卡供用户选择
• 如果用户需要查看相关方面信息，直接点开选项卡即可浏览，通过这种方式可以方便的管理相关信息。                                                                                                                                                                                                                        JTabbedPane常用方法和常量                       

  

 3）JScrollPane容器

• 在一般的图形界面中如果显示的区域不够大，就会出现滚动条以方便用户浏览。
• 在Swing中JSCrollPane为显示的内容加入滚动条。

4）JScrollPane容器

JScrollPane主要由JViewPort和JScrollBar两部分组成。

• JViewPort:显示一个矩形的区域让用户浏览
• JScrollBar:形成水平或垂直的滚动条。

                                                               JScrollPane常用方法和常量

 

 5）JDesktopPane与JInternalFrame容器

• 在Swing中也可以完成内部窗体的显示，在一个窗体中可以显示多个子窗体，每一个子窗体都无法超出父窗体的区域。
• JDesktopPane规定了一个父窗口的基本形式。
• JInternalFrame规定了各个子窗体，JInternalFrame需要加入到JDesktopPane之中                                                             

                                        JDesktopPane常用方法

     

                                         JInternalFrame常用方法

 

 52、文本组件：JTextComponent

各软件系统中都存在文本输入框，以方便用户输入数据，在Swing中提供了几类文本输入框：

• 单行文本输入框：JTextField
• 密码文本输入框：JPasswordField
• 多行文本输入框：JTextArea

                           JTextComponent的常用方法

 

 1）单行文本输入框：JTextField

• JTextField组件可以实现单行文本输入，此类除了使用JTextComponet类的方法外，还可以使用以下的方法

 

2)密文输入组件：JPasswordField

• JText是使用明文方式进行数据显示的。
• 如果现在需要将显示的内容设置成其他字符，则可以使用JPasswordField类，常用方法如下：

 

 3）多行文本输入组件：JTextArea

• 如果要想输入多行文本，则可以使用JTextArea实现多行文本的输入，此类扩展了JTextComponent类

 

53、事件处理

1）事件和监听器

• 要想让组件发挥作用，必须对所有的组件进行事件处理。
• Java中使用事件表示一个对象的状态发生变化。例如当按钮按下时，实际上按钮的状态发生了变化，此时就会产生一个事件，如果要想处理此事件，就需要事件的监听者能不断的监听事件的变化，并根据这些事件进行相应的处理。
• 在Swing编程中，所有的事件类都是EventObject类的子类

 

2）Java事件处理流程

• 事件源：发生此事件的源对象。
• 事件监听器：事件的接收对象。
• 如果没有能够接收和处理事件的对象，图形界面程序所生成的一切事件都是无用的。
• 所有的事件监听器都是以接口的形式出现的，处理时只需要实现此接口。

 

 3）窗体事件

• WindowListener是专门处理窗体的事件监听接口，窗体的所有变化都可以使用这个接口进行监听。

 

 4）动作事件及监听处理

• 一个按钮想要让其变得有意义，就必须使用事件处理，在Swing的事件处理中，可以使用ActionListener接口处理按钮的动作事件。
• ActionListener接口只定义了一个方法。

 

54、事件和监听器

1）键盘事件及监听处理

•  在Swing的事件处理中也可以使用KeyListener接口对键盘的操作进行监听。

          此接口定义了如下方法：

 

如果想要取得键盘键入的内容，可以通过keyEvent取得，此类的常用方法如下：

 

 2）鼠标事件及其监听

如果想对一个鼠标的操作进行监听，例如，鼠标按下、松开等，则可以实现MouseListener接口

 

 3）MouseEvent

• 在每个事件触发后都会产生MouseEvent事件，此事件可以得到鼠标的相关操作

 

 4）鼠标拖拽事件及监听处理

• 在一般的图形界面中经常可以看到鼠标拖拽操作的情况，在Swing中可以使用MouseMotionListener接口完成鼠标的拖拽操作。

 

 55、单选钮：JRadioButton

• 单选钮就是在给出的多个显示信息中指定选择一个，在Swing中使用JRadioButton完成一组单选钮的操作。

                     JRadioButton类的常用方法

 

 56、增加单选按钮组

ButtonGroup group = new ButtonGroup();

group.add(this.jrb1);

group.add(this.jrb2);

group.add(this.jrb3);

 57、JRadioButton事件处理

• 单选按钮操作中，使用ItemListener接口进行事件的监听，接口定义如下的方法

 

     此方法中存在ItemEvent事件，此事件常用方法及常量如下所示：

 

 58、复选框：JCheckBox

程序可以通过JCheckBox实现复选框功能

 

 59、菜单组件

• 使用JMenu组件可以实现菜单。

JMenuBar组件的功能是用来摆放JMenu组件，当建立完多个JMenu组件之后，需要通过JMenuBar组件将JMenu组件加入到窗口中

1）菜单：JMenuBar

JMenuBar的常用方法

 

2)菜单栏：JMenu

JMenu的常用方法

 

 3)菜单项：JMenuItem

• JMenuItem继承AbstractButton类，因此JMenuItem可以理解为一种特殊的JButton组件，当选择某个菜单项时会触发ActionEvent事件

JMenuItem的常用方法

 

60、文件选择框

1）JFileChooser

• 在使用记事本或者word等软件的时候，可以通过文件选择框选择要打开或保存的文件。
• 在Swing中可以使用JFileChooser组件实现此功能。

JFileChooser常用方法

 

 2）文件选择框的三种返回状态

 

61、JDBC

        有了JDBC，向各种关系数据发送SQL语句就是一件很容易的事。换言之，有了JDBC API，就不必为访问Sybase数据库专门写一个程序，为访问Oracle数据库又专门写一个程序，或为访问Informix数据库又编写另一个程序等等，程序员只需用JDBC API写一个程序就够了，它可向相应数据库发送SQL调用。同时，将Java语言和JDBC结合起来使程序员不必为不同的平台编写不同的应用程序，只须写一遍程序就可以让它在任何平台上运行，这也是Java语言"编写一次，处处运行"的优势。

      Java数据库连接体系结构是用于Java应用程序连接数据库的标准方法。JDBC对Java程序员而言是API，对实现与数据库连接的服务提供商而言是接口模型。作为API，JDBC为程序开发提供标准的接口，并为数据库厂商及第三方中间件厂商实现与数据库的连接提供了标准方法。JDBC使用已有的SQL标准并支持与其它数据库连接标准，如ODBC之间的桥接。JDBC实现了所有这些面向标准的目标并且具有简单、严格类型定义且高性能实现的接口。

     Java 具有坚固、安全、易于使用、易于理解和可从网络上自动下载等特性，是编写数据库应用程序的杰出语言。所需要的只是 Java应用程序与各种不同数据库之间进行对话的方法。而 JDBC 正是作为此种用途的机制。

     JDBC 扩展了 Java 的功能。例如，用 Java 和 JDBC API 可以发布含有 applet 的网页，而该 applet 使用的信息可能来自远程数据库。企业也可以用 JDBC 通过 Intranet 将所有职员连到一个或多个内部数据库中(即使这些职员所用的计算机有 Windows、 Macintosh 和UNIX 等各种不同的操作系统)。随着越来越多的程序员开始使用Java 编程语言，对从 Java 中便捷地访问数据库的要求也在日益增加。

    MIS管理员们都喜欢 Java 和 JDBC 的结合，因为它使信息传播变得容易和经济。企业可继续使用它们安装好的数据库，并能便捷地存取信息，即使这些信息是储存在不同数据库管理系统上。新程序的开发期很短。安装和版本控制将大为简化。程序员可只编写一遍应用程序或只更新一次，然后将它放到服务器上，随后任何人就都可得到最新版本的应用程序。对于商务上的销售信息服务， Java 和JDBC 可为外部客户提供获取信息更新的更好方法。

JDBC的主要操作及接口

 

1）使用JDBC的步骤

加载JDBC驱动程序 → 建立数据库连接Connection → 创建执行SQL的语句Statement → 处理执行结果ResultSet → 释放资源

a.注册驱动 (只做一次)

方式一：Class.forName(“com.MySQL.jdbc.Driver”);
　　推荐这种方式，不会对具体的驱动类产生依赖。
　　方式二：DriverManager.registerDriver(com.mysql.jdbc.Driver);
　　会造成DriverManager中产生两个一样的驱动，并会对具体的驱动类产生依赖。

b.建立连接

Connection conn = DriverManager.getConnection(url, user, password);

URL用于标识数据库的位置，通过URL地址告诉JDBC程序连接哪个数据库，URL的写法为：

 

其他参数如：useUnicode=true&characterEncoding=utf8

c.创建执行SQL语句的statement

//Statement  
String id = "5";
String sql = "delete from table where id=" +  id;
Statement st = conn.createStatement();  
st.executeQuery(sql);  
//存在sql注入的危险
//如果用户传入的id为“5 or 1=1”，那么将删除表中的所有记录
//PreparedStatement 有效的防止sql注入(SQL语句在程序运行前已经进行了预编译,当运行时动态地把参数传给PreprareStatement时，即使参数里有敏感字符如 or '1=1'也数据库会作为一个参数一个字段的属性值来处理而不会作为一个SQL指令)
String sql = “insert into user (name,pwd) values(?,?)”;  
PreparedStatement ps = conn.preparedStatement(sql);  
ps.setString(1, “col_value”);  //占位符顺序从1开始
ps.setString(2, “123456”); //也可以使用setObject
ps.executeQuery();

d.处理执行结果(ResultSet)

ResultSet rs = ps.executeQuery();  
 While(rs.next()){  
     rs.getString(“col_name”);  
    rs.getInt(1);  
    //…
 } 

e.释放资源

//数据库连接（Connection）非常耗资源，尽量晚创建，尽量早的释放
 //都要加try catch 以防前面关闭出错，后面的就不执行了
try {
    if (rs != null) {
        rs.close();
    }
} catch (SQLException e) {
    e.printStackTrace();
} finally {
    try {
        if (st != null) {
            st.close();
        }
    } catch (SQLException e) {
        e.printStackTrace();
    } finally {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}