java高级开发 知识点总结

第九章 常用实用类

1.类与对象

2.Stirng类

其位于java.lang包中，是一个final类。

2.1构造String对象

String s=new String ("hello ");

String s="hello";

2.2 String类的常用方法

int length()

boolean equals(String s)

int compareTo(String s)

boolean startsWith(String s)

boolean endsWith(String s)

boolean contains(String s)

int indexOf(String s)

int lastIndexOf(String s)

String substring(int startpoint)

String trim()

2.3 String与基本数据类型的转化

String s="12";

int x=Integer.parseInt(s);

float f=Float.parseFloat(s);

double d=Double.parseDouble(s);

2.4 toString方法

所有类的默认父类Object，有toString方法。该方法返回一个字符串。这个字符串是对该类的描述，一般格式：类名@引用。类可以重写toString方法。

3.正则表达式

包含一些特殊字符（元字符）的字符序列。

3.1元字符

3.2中括号

[ ]括起来若干字符代表一个元字符。

如：[ABC]:A、B、C中的任何一个

[a-zA-Z]英文字母中的任何一个

3.3限定符

4.StringBuffer类，日期与时间，Math,BigInteger,Random

4.1 StringBuffer类

能创建可修改的字符序列。

4.1.1与String的区别

String对象不能修改、删除或替换字符序列中的某个字符。

4.1.2构造方法

StringBuffer(); //初始容量为16个字符

StringBuffer(int size); //初始容量为size个字符

StringBuffer(String s); //初始长度为s的长度+16

4.1.3常用方法

StringBuffer append(String s)

StringBuffer insert(int index,String str)

StringBuffer delete(int start,int end)

StringBuffer reverse()

StringBuffer replace(int start,int end,String str)

4.2日期与时间

LocalDate,LocalTime,LocalDateTime

4.3Math类

4.3.1静态常量

Math.E

Math.PI

4.3.2常用类方法

Math.pow(a,b);

Math.sqrt(a);

Math.ceil(a);

Math.floor(a);

Math.round(a);

Math.random();

Math.abs(a);

4.4BigInteger类

4.4.1构造方法

BigInteger one=new BigInteger("1");

4.5Random类

4.5.1构造方法

Random r=new Random();

4.5.2生成随机数

random.nextInt();

第十章 Java swing

1.窗口、菜单

1.1Java swing概述

容器类、组件类。

可以向容器添加组件。

容器本身也是组件，一个容器可以添加到另一个容器。

1.2窗口

用JFrame类或其子类可以实现窗口，它是一个等层容器。

JFrame的常用方法：

JFrame();

JFrame(String s);

void setVisible(true);
void setSize(960, 540);
void setLocation(300, 250);
void setBounds(300, 250, 960, 540);
void setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

1.3菜单

菜单条、菜单、菜单项。

菜单放在菜单条，菜单项放在菜单。

如：定义组件 JMenu menu;

                        JMenuItem i;

创建组件 menu=JMenu("a");

                i=new JMenuItem("b");

添加组件 menu.add(i);

2.常用组件、容器

2.1常用组件

(1)标签        JLabel

(2)文本框               JTextField

(3)按钮        JButton

(4)文本区        JTextArea

(5)复选框        JCheckBox

2.2常用容器

(1）面板        JPanel

(2)滚动窗格        JScrollPane

(3)拆分窗格        JSplitPane

(4)分层窗格        JLayeredPane

(5)选项卡        JTabbedPane

3.常用布局、ActionEvent事件

3.1常用布局

容器可使用方法 setLayout(布局对象)来设置布局

布局方式：（1）流式布局         FlowLayout

(2)边界布局        BorderLayout

(3)卡片布局        GardLayout

(4)网格布局        GridLayout

(5)盒式布局        BoxLayout

3.2ActionEvent事件

事件源：产生事件的对象。

事件：从一个事件源上产生的对象。

事件处理器：接收事件并对其进行处理的对象。

（1）确定事件源

（2）确定事件类型

（3）定义处理器类，创建对象

（4）事件源注册事件处理器对象

4.ItemEvent、DocumentEvent事件

4.1 ItemEvent事件

复选框、下拉列表都可触发ItemEvent事件。

4.2 DocumentEvent事件

文本区所维护的文档能触发DocumentEvent事件。

5.MouseEvent事件

任何组件上都可以发生鼠标事件。

6.FocusEvent事件、KeyEvent事件、WindowEvent事件

6.1 FocusEvent事件

组件可以触发焦点事件。

处理器类必须要实现FocusListener接口。

事件源.addFocusListener(处理器对象名);

6.2 KeyEvent事件

当一个组件处于激活状态时，敲击键盘上的一个键就导致了这个组件触发键盘事件。

6.3 WindowEvent事件

（1）适配器类

（2）匿名类

        Lambda表达式

（3）窗口做监视器

Window子类(JFrame)创建的对象都可以发生WindowEvent事件。

7.处理器类的其他写法

7.1适配器类

当一个类实现一个接口时，即使不准备处理某个方法，也必须给出接口中所有方法的实现。Java 提供了一个适配器类，***Adapter。我们只需创建适配器类的子类作为监视器，子类中重写所需的方法即可。.
class WindowPolice extends WindowAdapter {
@Overri de
public void windowClosing (WindowEvent arg0) {
System. out. print ln(" closing");
}
}

7.2匿名类

内部类:在一个类中声明另一个类，这样的类称为内部类，包含内部类的类称为外嵌类。内部类可以访问外嵌类的成员。内部类仅供它的外嵌类使用。
内部类的字节码文件的名字:外嵌类名$内部类名。
匿名类:没有类名。不能用匿名类声明对象，但可以用匿名类创建对象。
new 父类名(){
匿名类的类体
};
new 接口名(){
实现接口的匿名类的类体;.
};

7.3Lambda表达式

主要目的是在使用单接口(只有一个方法的接口)匿名类时，让代码更简洁。

  // Lambda作为处理器类，只有一个方法时适用
        button.addActionListener((ActionEvent e) -> {
            // TODO Auto-generated method stub
            a = r.nextInt(100); // 得到[0,100)间的随机数
            System.out.println(a);

        });

7.4窗口做监视器

如果系统不复杂，可以让组件所在窗口做监视器，能让事件的处理比较方便。

8.MVC结构

MVC结构：模型-视图-控制器(Model-View-Controller)

是一种软件的设计思想。

视图：用于显示数据

模型：用于存储数据

控制器：用于处理用户的信息，通过视图修改、获取模型中的数据，当模型中的数据变化时，让视图更新显示。

9.树组件与表格组件

9.1树组件

JTree类的对象称为树组件。

1. 树中只有一个根结点，除根之外，还有分支结点和叶结点。

2.TreeSelectionEvent事件

树组件可以触发TreeSelectionEvent事件。

注册监视器：

    事件源.addTreeSelectionListener(TreeSelectionListener listener)

接口方法：

    public  void valueChanged(TreeSelectionEvent e)

3.获取选中的结点

    getLastSelectedPathComponent()

9.2表格组件     

以行和列的形式显示数据。允许用户编辑数据。使用JTable创建表格组件。

常见的构造方法：

JTabel()：创建默认的表格模型。

JTable(int a,int b):创建a行，b列的表格

JTable (Object data[][],Object  columnName[]) 创建由data二维数组指定表格的值，列名由数组columnName指定的表格。

注意：

1.表格需放在滚动面板中，才能显示表头。

2.表格中输入或修改数据后，需按回车键或用鼠标单击表格的单元格确定修改结果。表格调用repaint方法刷新显示。

10.将按钮绑定到键盘

希望敲击键盘上的某个键和用鼠标单击按钮程序做出同样的反应。

假定：按钮是button，监视器是AbstractAction类的子类实例。

class **Police extends AbstractAction{}

**Police listener=new **Police();

步骤：

1.输入映射

InputMap  inputmap=button.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

//组件处于具有焦点的窗口中时 或者 按键发生、同时组件具有焦点时

inputmap.put(KeyStroke.getKeyStroke("A"),"move");

//将键盘上的某个键与字符串进行关联

2.活动映射

ActionMap actionmap=button.getActionMap();

actionmap.put("move",listener);

第十一章 对话框

1.JDialog、文件对话框

1.1JDialog类

（1）JDialog类和JFrame类二者的实例都是底层容器，二者的主要区别是，JDialog类创建的对话框必须要依赖于某个窗口。

通过创建JDialog类或其子类的对象就可以创建对话框。

对话框默认布局是BorderLayout。不需要将对话框添加到另一个容器中。

（2）对话框的模式：有模式和无模式。

有模式：当对话框处于激活状态时，不能再激活其他窗口。

无模式：当对话框处于激活状态时，可以再激活其他窗口。

（3）主要方法

JDialog()：构造一个无标题、初始不可见的对话框。

JDialog(JFrame owner)：构造一个无标题、初始不可见、无模式的对话框，owner是对话框所依赖的窗口。

JDialog(JFrame owner,String title)：构造一个有标题、初始不可见、无模式的对话框，owner是对话框所依赖的窗口。

JDialog(JFrame owner,String title,boolean modal)：构造一个有标题、初始不可见的对话框，owner是对话框所依赖的窗口，modal决定对话框的模式。

1.2文件对话框

JFileChooser类创建文件对话框，使用该类的构造方法JFileChooser()创建初始不可见的有模式的文件对话框。

然后文件对话框调用下述2个方法：

    showSaveDialog(Component a);

    showOpenDialog(Component a);

都可以使得对话框可见，只是呈现的外观有所不同。

方法的返回值依赖于单击了文件对话框上的“确定”按钮还是“取消”按钮。

返回值：

JFileChooser.APPROVE_OPTION   //单击确认按钮

JFileChooser.CANCEL_OPTION    //单击取消按钮

当单击了确认按钮时，可以使用JFileChooser类的getSelecedFile()得到文件对话框所选择的文件。

2.消息对话框、输入对话框、确认对话框

2.1消息对话框    

JOptionPane.showMessageDialog(Component parentComponent,

                                                        String message,

                                                        String title,

                                                        int messageType)

messageType取值：JOptionPane.WARNING_MESSAGE                           

messageType取值：JOptionPane.ERROR_MESSAGE                          

messageType取值：JOptionPane.INFORMATION_MESSAGE

   

messageType取值：JOptionPane.QUESTION_MESSAGE

messageType取值：JOptionPane.PLAIN_MESSAGE

2.2输入对话框  

JOptionPane.showInputDialog(Component parentComponent,

                                                        String message,

                                                        String title,

                                                        int messageType)

messageType取值：

JOptionPane.WARNING_MESSAGE      

JOptionPane.ERROR_MESSAGE

JOptionPane.INFORMATION_MESSAGE

JOptionPane.QUESTION_MESSAGE

JOptionPane.PLAIN_MESSAGE

如果单击“确定”按钮，将返回用户在文本框中输入的字符串(返回值是String类型)。

2.3确认对话框   

JOptionPane.showConfirmDialog(Component parentComponent,

                                                        String message,

                                                        String title,

                                                        int messageType)

messageType取值：

JOptionPane.YES_NO_OPTION

JOptionPane.YES_NO_CANCEL_OPTION

JOptionPane.OK_CANCEL_OPTION

返回值是int类型：

JOptionPane.YES_OPTION

JOptionPane.NO_OPTION

JOptionPane.CANCEL_OPTION

JOptionPane.OK_OPTION

3.颜色对话框

JColorChooser.showDialog(Component parentComponent,

                                           String title,

                                           Color initialColor)

第十二章 输入流与输出流

1.File类、文件字节流

1.1输入输出流
程序为了获得外部数据，可以在数据源(文件、内存、网络套接字)上创建一个输入流，用read()方法读取数据。也可以在数据源上创建一个输出流，用write()方法将数据写到输出流中。

按照处理数据的类型分，数据流可以分为：二进制流和文本流。

二进制流：也称字节流，处理信息的基本单位是字节。

文本流：也称字符流，处理信息的基本单位是字符。

1.2 File类 

主要用来表示物理磁盘上的实际文件或目录。

创建一个File对象的构造方法有3个：

File(String filename);

File(String directoryPath,Stringfilename);

File(File f, String filename);

例：

File file1=new File("e:\\","student.txt");             //对应文件
       File file2=new File("e:\\eclipse-workspace");         //对应目录

常用方法：

public boolean exists() 

public boolean createNewFile();     //创建文件

public boolean delete()     //删除文件

public String getName() 

public boolean canRead() 

public boolean canWrite()

public long length()

public String getAbsolutePath()

public boolean isFile()

public boolean isDirectory()

1.3文件字节流

文件字节输入流   ——用来读文件。

（1）创建文件字节输入流   

FileInputStream类创建的对象称为文件字节输入流。

（2）读文件

int read()        //读一个字节      到文件末尾，返回-1

int read(byte b[])    //读b.length个字节       文件为空，返回-1

int read(byte b[],int off,int len)     //读len个字节,存放到数组b中的第off个位置

文件字节输出流   —— 用来写文件

（1）创建文件字节输出流     

FileOutputStream类创建的对象称为文件字节输出流。

如果FileOutputStream流要写的文件不存在，该流会首先创建文件再写入。

（2）写文件

write(byte b[])         //写b.length个字节到文件

2.文件字符流、缓冲流

2.1文件字符流

文件字符输出流   ——写数据

（1）创建输出流

File f=new File("./src/d12/test.txt");

FileWriter out=new FileWriter(f);

（2）写文件

write(int n)       //写一个字符

文件字符输入流   ——读数据

（1）创建输入流

File f=new File("./src/d12/test.txt");

FileReader in=new FileReader(f);

（2）读文件

int read();        //读一个字符

2.2缓冲流 按行读写

实际应用中，经常需要读取一行数据，FileReader很难完成。

（1）缓冲输入流 BufferedReader ，它的源是FileReader   按行读文件

File file=new File("student.txt");

FileReader in=new FileReader(file);

BufferedReader bufferin=new BufferedReader(in);

（2）读一行

readLine()

（3）缓冲输出流 BufferedWriter 与FileWriter连接在一起

FileWriter out=new FileWriter("student.txt");

BufferedWriter bufferout=new BufferedWriter(out);

（4）写

write(String)

3.随机流、数据流、对象流

3.1随机流    

RandomAccessFile 既可以读也可以写

（1）构造方法：

RandomAccessFile(String name,String mode)

RandomAccessFile(File file,String mode)

参数mode取r（只读）或rw（可读写）

（2）读、写

方法：seek(long a)，可以定位RandomAccessFile流的读写位置，其中参数a确定读写位置距离文件开头的字节个数。

方法：getFilePointer()，可以获取流的当前读写位置。

3.2数据流 

DataInputStream、DataOutputStream类创建的对象称为数据输入流、数据输出流。它们允许程序按照与机器无关的风格读取Java原始数据。

DataInputStream通常以FileInputStream作为底层流。

DataOutputStream通常以FileOutputStream作为底层流。

3.3对象流

ObjectInputStream、ObjectOutputStream类创建的对象称为对象输入流、对象输出流。

ObjectInputStream以InputStream子类作为底层流，如FileInputStream

ObjectOutputStream以OutputStream子类作为底层流，如FileOutputStream。

主要方法：

writeObject(Object obj)方法 将一个对象obj写入到一个文件。

readObject()方法，读取一个对象。

3.4序列化

使用对象流读/写对象时，要保证对象是序列化的。

class Student implements Serializable{  //标记接口，没有方法

}

3.5克隆

某对象的“复制品”，该复制品的变化不会引起原对象的变化，这样的复制品就称为原对象的克隆。

使用对象流很容易获取一个对象的克隆，只需将该对象写入再读回就是原对象的克隆。

第十三章 泛型与集合框架

1.泛型

1.1泛型类   

                

                 

E是其中的泛型，代表一种数据类型，可以是类或接口，不能是基本数据类型。泛型可以作为类的成员变量的类型，方法的类型，局部变量的类型。

带有泛型的类称为泛型类。

使用泛型类声明对象

(1)用具体的类型代替E

(2)使用通配符？

Cone cone=new Cone(c);

//Geometry类或Geometry的子类或实现了Geometry接口的类

Cone cone;   //B类或者B的任何父类

Cone cone=new Cone(c);

1.2.泛型接口   

    interface Computer{
             void makeChorus(E x,F y);

    }

2.链表

2.1链表

是由若干个结点组成的一种数据结构，每个结点含有一个数据和一个(两个)引用，指向上一结点或下一结点。

2.2 LinkedList泛型类

该泛型类创建的对象以链表结构存储数据，常称为链表对象。

LinkedList mylist=new LinkedList();

public boolean add(E element) 

public void add(int index,E element) 

public void clear() 

public E remove(int index)  

public boolean remove(E element)   //删除首次出现的element

public E get(int index)  

public int indexOf(E element)  

public int lastIndexOf(E element)  

public E set(int index,E element)   //返回被替换的数据

public int size()  

public boolean contains(Object element)   

public void addFirst(E element)   

public void addLast(E element)   

public E getFirst()   

public E getLast()   

public E removeFirst()   

public E removeLast()   

public Object clone()   

2.3链表的遍历

使用iterator()方法获得Iterator迭代器，用迭代器遍历。

Iterator iter=mylist.iterator();
        while(iter.hasNext()) {
            String s=iter.next();
            System.out.println(s);
        }

3.堆栈、散列映射、树集

3.1堆栈

是一种“后进先出”的数据结构。只能从一端输入输出数据。使用Stack泛型类可以创建堆栈对象。

创建堆栈对象：

Stack stack=new Stack();

方法：

public E push(E item);    //入栈

public E pop();   //出栈

public boolean empty();   //判断堆栈是否为空

public E peek();  //获取堆栈顶端的数据，但不删除该数据。

public int search(Object data);  //获取数据在堆栈中的位置，最顶端的位置是１，向下依次增加，如果堆栈不含此数据，则返回-1。

3.2散列映射 

映射表(map)依照“键/值”对(key,value)来存储元素。映射表将键和值一起保存，一个键和它对应的值构成一个条目保存在映射表中。键不能重复，可以是任意类型的对象,每个键对应一个值。键又称搜索键，用来查找相应的值。

散列一般指哈希(hash),散列函数(哈希函数)是一种将键映射到表(map)中索引上的函数。散列函数从一个键获得索引，并使用索引来获得该键的值。散列就是一种无须执行搜索，即可通过键得到索引来获取值的技术。

HashMap 泛型类创建的对象称为散列映射。

HashMap hashmap=new HashMap();

常用方法：

public V put(K key,V value);   //添加键值对

public boolean containsKey(Object key)  

public boolean containsValue(Object value) 

public V get(Object key)  

public int size() 

遍历：

Collection collection=hashmap.values();
        Iterator iter=collection.iterator();
        while(iter.hasNext()) {
            Student stu=iter.next();
            System.out.println(stu.getName()+stu.getNumber());
        }

3.3树集  

树集采用树结构存储数据，树结点中的数据会按存放数据的“大小"顺序依次排列，在同一层中的结点从左到右从小到大的顺序递增排列，下一层比上一层小。

TreeSet泛型类创建的对象称为树集。

TreeSet tree=new TreeSet();

常用方法：

public boolean add(E o)　

public void clear()

public boolean contains(Object o)

public E first()

public E last()

注意：树集中的结点要能比较大小。

4.树映射、集合

4.1树映射 

称TreeMap对象为树映射。如：

TreeMap treemap=new TreeMap();

常用方法：public V put(K key,V value);

按key升序排列。

遍历：

Collection collection=treemap.values();
        Iterator iter=collection.iterator();
        while(iter.hasNext()) {
            Student stu=iter.next();
            System.out.println(stu.getName()+stu.getEnglish());
        }

4.2集合 

HashSet泛型类创建的对象称为集合。如：

HashSet set=new HashSet();

添加到集合中的数据称做集合的元素。集合不允许有相同的元素。

常用方法：

public boolean add(E o)

public void clear() 

public boolean contains(Object o) 

public boolean isEmpty() 

public boolean remove(Object o) 

public int size() 

Object[] toArray() 将集合元素存放到数组中，并返回这个数组

boolean containsAll(HanshSet  set)  判断当前集合是否包含参数指定的集合

集合的遍历

Iterator iter=set.iterator();
        while(iter.hasNext()) {
            Student stu=iter.next();
            System.out.println(stu.getName()+stu.getEnglish());
        }

4.3集合的运算

boolean retainAll(HashSet set)当前集合成为两个集合的交集。

boolean addAll(HashSet set)当前集合成为两个集合的并集。

boolean removeAll(HashSet set)当前集合成为两个集合的差集。

第十四章 JDBC与MySQL数据库

1. MySQL

2. JDBC、连接MySQL数据库

2.1 JDBC

     Java编写的程序不依赖于具体的数据库，通过JDBC访问数据库。JDBC（Java Data Base Connectivity）是Java程序访问数据库的标准接口，由一组类和接口组成。JDBC访问不同的数据库仅仅是连接方式上的差异而已，使用JDBC的应用程序一旦和数据库建立连接，就可以使用JDBC提供的API访问数据库。

使用JDBC访问数据库的步骤：

(1)加载驱动程序

(2)建立连接对象

(3)创建语句对象

(4)执行SQL语句，获得结果

(5)关闭建立的对象，释放资源

2.2连接MySQL数据库  

(1)从本课程资料中下载JDBC-MySQL数据库连接器(驱动器) mysql-connector-java-5.1.26-bin.jar，注意不能放到工程路径下。

(2)工程中导入驱动器jar包

工程名右键：import->General->FileSystem->点“Browser”,选中包含驱动器jar包的文件夹(注意这里看不见jar包)，点“选择文件夹”之后在右侧的方框中会看见jar文件->选中jar文件->Finish.

工程名右键:Build Path->Configure Build Path->Libraries->Add jars->选工程中的jar包

(3)加载驱动程序(JDBC-MySQL数据库连接器)

try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {          
            e.printStackTrace();
        }

(4)建立连接对象

Connection con=null;

String uri="jdbc:mysql://localhost:3306/book?characterEncoding=utf-8"; //book是数据库的名字
        String user="root";
        String password="";
        try {
            con=DriverManager.getConnection(uri,user,password);
        } catch (SQLException e) {           
            e.printStackTrace();
        }

3.查询

3.1顺序查询   

（1）加载驱动程序

（2）建立连接对象

Connection con=null;

con=GetDBConnection.connectDB("Book", "root","");

（3）创建语句对象

Statement stmt;

ResultSet rs;

try {
           stmt=con.createStatement();

    //（4）执行sql语句
            rs=stmt.executeQuery("select * from booklist");

} catch (SQLException e) {}

（5）查看结果

while(rs.next()) {
                String isbn=rs.getString(1);
                String name=rs.getString(2);
                float price=rs.getFloat(3);
                Date date=rs.getDate(4);
                System.out.println(isbn+" "+name+" "+price+" "+date);
            }

（6）关闭建立的对象，释放资源

rs.close();

stmt.close();

con.close();

顺序查询：结果集对象一次只能看到一个数据行，next()方法最初的查询位置，位于第一行的前面。

3.2控制游标  

如果需要在结果集中上下移动，必须创建可滚动结果集。

Statement stmt=con.createStatement(int type,int concurrency)

type的值：

ResultSet.TYPE_FORWORD_ONLY:只能向下滚动

ResultSet.TYPE_SCROLL_INSENSITIVE:上下滚动，数据库变化时，结果集不变

ResultSet.TYPE_SCROLL_SENSITIVE:上下滚动，数据库变化时，结果集同步改变

concurrency的值：

ResultSet.CONCUR_READ_ONLY:不能用结果集更新数据库

ResultSet.CONCUR_UPDATABLE：能用结果集更新数据库中的表

常用到的ResultSet的方法：

public int getRow():得到游标所指的行号，行号从1开始

public boolean absolute(int row):游标移到row指定的行。

3.3条件查询

select 字段 from 表名 where 条件

where name='java'

where price>28 and price<90

where year(chubanDate） between 2010 and 2020

where minute(shijian)>15

where name like '%程序%'

3.4排序

select * from 表名 where 条件 order by 字段名(列名)

4.添加、更新与删除

4.1添加

insert into 表(字段列表) values (对应的具体的记录)  或

insert into 表 values (对应的具体的记录)

insert into booklist values ('2-306-08465-7','春天', 35.8,'2020-3-20')

4.2更新 

update  表 set 字段 = 新值 where <条件子句>

如：update bookList set chubanDate = '2019-12-26' where name='大学英语'

4.3删除

delete from  表名 where <条件子句>

如：delete  from bookList where ISBN = '5-777-56462-9'

以上均使用：

Statement对象调用方法：public int executeUpdate(String sqlStatement);

5.预处理、事务

5.1预处理语句 

Statement stmt;

stmt=con.createStatement();

stmt.executeQuery(sql);

预先处理成可直接执行的命令，可以使用通配符代替字段的值。

PreparedStatement pstmt;

String sql="insert into booklist values(?,?,?,?)";

pstmt=con.prepareStatement(sql);

pstmt.executeUpdate();

5.2事务

一组SQL语句。

事务处理：应用程序保证事务中的SQL语句要么都执行，要么都不执行。

JDBC事务处理步骤：

1.用setAutoCommit(boolean b)方法关闭自动提交模式，参数为false

2.用commit()方法处理事务

3.用rollback()方法处理事务失败

第十五章 java多线程机制

1.线程的概念

1.1对比程序、进程、线程的概念

程序：是一段静态的代码。

进程：程序的一次动态执行过程。

线程：比进程更小的执行单位。

单线程：一个进程只有一条执行路径。

多线程：一个进程有多条执行路径。

1.2如何写线程

Thread类及其子类的对象表示线程。

class Cat extends Thread {

public void run() {} //重写 run()方法

}

启动线程

Cat cat=new Cat() ;

cat. start(); //启动线程.

1.3线程的状态

新建状态(New):        Cat cat=new Cat();

可运行状态(Runnable):        cat. start() ;

中断(BLOCKED) :        线程因为某种原因让出了cpu使用权

超时等待(TIMED_ WAITING) :        线程运行了sleep方法

等待(WAITING):        进入该状态的线程不会主动进入Runnable状态

死亡(Terminated) :         完成了全部工作

1.4线程的调度与优先级

Java虚拟机中的线程调度器负责管理线程，调度器把线程的优先级分为10个级别，用常数1-10来表示。

数越大优先级越高。

Thread. MIN_ PRIORITY:最小优先级

Thread. MAX_ PRIORITY:最大优先级

Thread. NORM_ PRIORITY: 普通优先级，数值是5.

方法setPriority(int) :调整优先级。

2.创建线程

2.1用Thread子类创建线程

用Thread类的子类创建线程，重写父类中的run()方法。

2.2用Runnable接口创建线程

class Bank impl ements Runnable{ }

Bank bank=new Bank() ;

Thread tl;

t1=new Thread (bank) ;

t1. start() ;

2.3 run ()方法中的局部变量

不同线程的run()方法中的局部变量互不干扰，一-个线程改变了自己的run()方法中局部变量的值不会影响其他线程的run()方法中的局部变量。

2.4在线程中启动其他线程

任何一个线程都可以启动其他线程。

3.线程的常用方法

start() :启动线程

run():定义了线程需要完成的任务，系统自动调用

sleep(int) :休眠一段时间,以毫秒为单位

isAlive() :是否存活。新建状态--false;被start以后，死亡之前--true 

currentThread() :当前正在使用CPU资源的线程

interrupt () :吵醒休眠的线程

4.线程的同步

4.1线程同步

当两个或多个线程同时访问同一个变量，并且至少一个线程需要修改这个变量时，应对这样的问题进行处理，否则可能发生混乱

4.2在同步方法中使用wait (), notify(), notifyA11()方法

当一个线程使用的同步方法中用到某个变量，而此变量又需要其他线程修改后才能符合本线程的需要，此时就需要调用wait()方法等待。

其他线程使用完同步方法后，用notify()或notifyAll()方法唤醒等待的线程。被唤醒线程从刚才中断处继续执行。

5.Timer、线程的联合、守护线程

当某些动作需要周期性的执行时可使用计时器类

5.1计时器线程

Timer类的构造方法:

Timer(int a, Object b) ;

a代表时间，b代表处理器。处理器必须实现了ActionListener接口。

Timer类的start()方法启动计时器。

Timer类的stop()方法停止计时器。

Timer类的restart ()方法重新启动计时器。

5.2线程的联合

一个线程A在占用CPU资源期间，可以让其他线程调用join()和本线程联合。

B. join();

线程A将立刻中断运行，一直等到它联合的线程B执行完毕，线程A重新排队等待CPU资源。

5.3守护线程

线程默认是用户线程，可以调用setDaemon(true) ;把自己设计为守护线程。

当所有用户线程都结束后，守护线程也会终止。

t1. setDaemon(true) ;//t1线程将自己设置为守护线程

第十六章 Java网络基础

1.URL类

java.net包中的URL类是对统一资源定位符的抽象，一个URL对象通常包含三部分信息，协议、地址和资源。

Internet上的主机可以用两种方式表示地址：IP地址、域名.

IP地址：电子设备（计算机）在网络中的唯一标识。

端口：应用程序在计算机中的唯一标识。0-65535

传输协议：规定了数据传输的规则

       基础协议：

       TCP：安全协议，三次握手。速度稍慢。

       UDP：不安全协议。速度快。

网络程序设计通常涉及一个服务器和一个或多个客户端。

服务器：从广义上讲，是指网络中能对其它机器提供某些服务的计算机系统.

客户端：向服务器发送请求，而服务器响应请求。

URL对象调用openStream()方法可以返回一个输入流，该输入流指向URL对象所包含的资源。通过该输入流可以将服务器上的资源信息读入客户端。

2. InetAddress类

2.1 InetAddress类  

Internet上的主机可以用下列两种方式表示地址：

域名：www.baidu.com

IP地址：202.108.35.210

2.2 InetAddress类的静态方法

getByName(String s);  s为域名，获得主机的IP地址

getLocalHost(); 获得本机的域名和IP地址

2.3 InetAddress类的实例方法

getHostName();获得域名

getHostAddress();获得IP地址

3.套接字

3.1套接字

IP地址用来标识计算机，端口号用来标识正在计算机运行的进程。

端口号是一个整数，范围0-65535，其中0-1023已被预先定义的服务通信占用，自己写的程序应该使用后面的端口号。

套接字：IP地址和端口号的组合。

3.2客户端套接字

客户端的程序使用Socket类建立负责连接到服务器的套接字对象。

Socket(String host,int port); host代表服务器的IP地址，port代表端口号。

Socket socket=new Socket("127.0.0.1",4331);

通过getInputStream()获得输入流，读取服务器传过来的数据。

通过getOutputStream()获得输出流，向服务器写数据。

3.3服务端套接字

服务端使用ServerSocket类创建对象，与客户端的套接字对象建立连接。

ServerSocket(int port);port必须与客户端呼叫的端口号相同

ServerSocket server=new ServerSocket(4331);

Socket client=server.accept(); 调用accept()方法等待客户端的连接

总结：

Socket网络编程可分为四个基本步骤：

A) 建立网络连接；

B)打开连接到Socket的输入/输出流；

C) 通过已打开的I/O流进行数据读/写操作；

D) 关闭已打开的I/O流和Socket

实例：

4.UDP数据报

4.1传输层协议

TCP：类似于打电话

UDP：类似于邮递信件

4.2基于UDP通信的基本模式

将数据打包，称为数据包，然后将数据包发往目的地

接收别人发来的数据包，然后查看数据包中的内容

4.3发送数据包

用DatagramPacket类将数据打包

DatagramPacket(byte[] data, int lenght,InetAddress address,int port)

该数据包将发送到地址是address，端口号是port的主机上

用DatagramSocket类创建数据包套接字

DatagramSocket mail_out=new DatagramSocket();
       mail_out.send(send_pack);

4.4接收数据包

byte[] data=new byte[100];                
       receive_pack=new DatagramPacket(data,data.length);
       DatagramSocket mail_in=new DatagramSocket(888);

mail_in.receive(receive_pack)

详细代码于各章节文章