专门做任务的网站/软文发布系统

9、网络通信协议

/*
InetAddress类的常用方法
1、getLocalHost()public static InetAddress getLocalHost() throws UnknownHostException返回本地主机的地址。 这是通过从系统检索主机的名称，然后将该名称解析为InetAddress 。2、getByName()public static InetAddress getByName(String host) throws UnknownHostException参数 host - 指定的主机，或 null 。 结果 返回给定主机名的IP地址。 
3、getHostAddress()public String getHostAddress()返回文本显示中的IP地址字符串。 
4、getHostName()public String getHostName()获取此IP地址的主机名。 5、isReachable()public boolean isReachable(int timeout) throws IOException测试该地址在timeout秒内是否可达。timeout - 呼叫中止之前的时间（以毫秒为单位）
*/public class Example01{public static void main(String[] args)throws Exception{//获取IP地址对象InetAddress localAddress = InetAddress.getLocalHost();//返回当前主机的IP地址对象（获取IP地址和主机名的方法）InetAddress remoteAddress = InetAddress.getByName("www.itcast.cn");//返回指定主机名称的IP地址System.out.println("本机的IP地址："+localAddress.getHostAddress());//调用以字符串形式输出的方法System.out.println("itcase的IP地址："+remoteAddress.getHostAddress());//调用以字符串形式输出的方法System.out.println("itcase3秒是否可达本机:"+remoteAddress.isReachable(3000));System.out.println("itcase的主机名为："+remoteAddress.getHostName());}
}

1、UDP网络程序

UDP是无连接通信协议，在数据传输时，发送端和接收端不建立逻辑关系，简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据，因此通常用于音频，视频，普通数据的传输，当传输重要数据的时候会发生数据丢失，在传输重要数据的时候，不建议用UDP网络程序。
一、Class DatagramPacket，该类主要是发送/接受数据包1、常见的构造方法：1.DatagramPacket(byte[] buf, int length)构造一个 DatagramPacket用于接收长度的数据包 length 。只能用于接收端，用来接受数据，不能用来发送端，发送端需要发送端口号和IP地址等信息。2.DatagramPacket(byte[] buf, int length, InetAddress address, int port) 构造用于发送长度的分组的数据报包 length指定主机上到指定的端口号。常用于发送端2、常见的方法；1. InetAddress getAddress() 返回该数据报发送或接收数据报的计算机的IP地址。2. int getLength() 返回要发送的数据的长度或接收到的数据的长度。 3. int getPort() 返回发送数据报的远程主机上的端口号，或从中接收数据报的端口号。  4、byte[] getData() 返回将要接收或者是要发送的数据。返回缓冲区的数据。二、Class DatagramSocket 该类的实例化对象可以发送和接受DatagramPacket数据包。1、常见的构造方法：1. DatagramSocket() 该构造方法主要用于创建 发送端 的DatagramSocket对象，在创建DatagramSocket对象时，没有指定端口号，系统会其分配一个没有其它网络程序使用的的端口号。2. DatagramSocket(int port) 该构造方法用于创建接收端的DatagramSocket对象，又可以创建发送端的DatagramSocket对象，在创建接收端DatagramSocket对象时，必须要指定一个端口号，这样就可以监听指定的端口。3. DatagramSocket(int port, InetAddress laddr) 该构造方法在创建DatagramSocket对象不仅指定了端口号，还制定了IP地址，2、常见的方法：1. void close()  关闭当前的Socket,通知驱动程序释放这个Socket保留的资源。2. void send(DatagramPacket p)  该方法主要用于发送DatagramPacket数据包，发送的数据包中包含将要方法的数据，数据的长度，远程主机的IP地址和端口号。3. void receive(DatagramPacket p)  该方法主要用于接收到数据填充到DatagramPacket数据包中，在所接收到数据包之前一直除于堵塞状态，只有接收到数据包时，该方法才会返回。

/*
发送端
*/
public class Sender{public static void main(String[] args){//1.创建DatagramSocket对象，指定发送端程序的端口号DatagramSocket ds = new DatagramSocket(3000);//2.准备要发送的数据String str = "hello world";byte[] buf = str.getBytes();//3.创建一个DatagramPacket对象，用来封装要发送的数据//数据包含：要发送的数据、数据的长度、接收端的IP地址，接收端的端口号DatagramPacket dp = new DatagramPacket(buf, buf.length,InetAddress.getByName("localhost"),8954);//4.发送数据包ds.send(dp);//释放资源ds.close();}
}/*
接收端
*/
public class Receiver{public static void main(String[] args){//1、指定一个DatagramSocket对象，指定接受的端口号DatagramSocket ds = new DatagramSocket(8954);//2、定义一个DatagramPacket对象，用于接收数据byte[] buf = new byte[1024];DatagramPacket dp = new DatagramPacket(buf,buf.length);//3、调用接受数据的1方法System.out.println("等待接收数据");ds.receive(dp);//等待接收数据，如果没有数据，则会堵塞//4、查看接收到的数据信息byte[] data = dp.getData();int length = dp.getLength();//查看接收数据的长度String ip = dp.getAddress().getHostAddress();//获取发送端的IP地址int port = dp.getPort();//获取发送端的端口号String str = new String(data,0,length);System.out.println(str + "from" + ip + ":"port);//5、释放资源ds.close();}
}//注意当出现：Addres already in use:Cannot bind
/*
就意味着：想要使用的端口被占用，因为一个端口只能运行一个程序，遇到这种情况，再DOS命令行窗口上，输入“netstat -ant”命令来查看计算机端口的占用情况，只要把相应的程序关闭即可。
*/

2、聊天程序设计

/*
聊天室
*/
public class CharRoom{public static void main(String[] args){System.out.println("欢迎你来到聊天室！");Scanner sc = new Scanner(System.in);System.lout.print("请输入本程序发送端口号：");int sendPort = sc.nextInt();System.out.print("请输入本程序接受端口号：");int receivePort = sc.nextInt();System.out.println("聊天系统启动！！");new Thread(new SendTask(sendPort),"发送端任务").start();//发送操作new Thread(new ReceiveTask(receivePort),"接受端任务").start();//接受操作}
}/*
发送数据的任务类
*/
public class SendTask implements Runnable{private int sendPort;//发送端的端口号public SendTask(int sendPost){this.sendPort = sendPort;}public void run(){try{//1、创建DatagramSocket对象DatagramSocket ds = new DatagramSocket();//输入要发送的数据Scanner sc = new Scanner(System.in);while(true){String data = sc.nextLine();//键盘获取接收数据//3、封装数据到DatagramPacket对象中byte[] buf = data.getBytes();DatagramPacket dp = new DatagramPacket(buf,buf.length,InetAddress.getByName("127.0.0.225"),sendPort);//4、发送数据ds.send(dp);}catch(Exception e){e.printStackTrace();}}}
}/*
接受数据任务类
*/
public class ReceiveTask implements Runnable{private int receivePort;public ReceiveTask(int receivePort){this.receivePost = receivePort;}public void run(){try{//1、创建DatagramSocket对象DatagramSocket ds = new DatagramSocket(receivePort);//2、创建datagramPacket对象byte[] buf = new Byte[1024];DatagramPacket dp = new DatagramPacket(buf,buf.length);//3、接收数据while(true){ds.receive(dp);//显示接受的数据String str = new String(dp.getData(),0,dp.getLength());System.out.println("收到" + dp.getAddress().getHostAddress() + "--发送的数据--" + str);}}catch(Exception e){e.printStackTrace();}}
}

3、TCP通信

/*
一、定义：是面向连接的通信协议，在数据传输前先在发送端和接收端建立逻辑连接，然后再传输数据。在TCP连接中必须要明确客户端与服务器端， 由客户端向服务器端发出连接请求，每次连接的创建都需要经过“三次握手”。[第一次握手， 客户端向服务器端发出连接请求，等待服务器确认; 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求: 第三次握手，客户端再次向服务器端发送确认信息，确认连接。
二、Java提供了用来实现TCP程序的两个类)一个是SrverSocket类，用于表示服务器端;另个是Socket用于表示客户端。通信时，首先要创建代表服务器端的ServerSocket对象，创建该对象相当于开启个服务，此服务会等待客户端的连接;然后创建代表客户端的Socket对象，使用该对象向服务器端发出连接请求，服务器端响应请求后，两者才建立连接，开始通信.三、public Class ServerSocket1、常见的构造方法1. ServerSocket() 通过该方法创建一个ServerSocket对象不与任何端口绑定，但是不能直接使用，需要继续调用bind(SocketAddress endpoint)方法将其绑定到指定的端口号上，才能正常使用2. ServerSocket(int port) 通过该方法创建一个ServerSocket对象时，可以将其绑定到一个指定的端口号上。3. ServerSocket(int port, int backlog) 再2上增加一个backlog参数，该参数表示服务器忙的时候，可以与之保持连接请求的客户数量，没指定的话，默认为504. ServerSocket(int port, int backlog, InetAddress bindAddr) 在3的基础上增加一个bindAddr参数，这个参数用于指定相关的Ip地址，该构造方法适用于计算机上有多块网卡和多个IP地址的情况。2、常见的方法1. Socket accept()  该方法用于等待客户端的连接，在客户端连接之前会一直处于阻塞状态， 如果有客户端连接，就会返回一个与之对应的Socket对象2. void bind(SocketAddress endpoint) 将 ServerSocket绑定到特定地址（IP地址和端口号）其中endpoint是封装好的。3. InetAddress getInetAddress()  该方法用于返回一个InetAddress对象，该对象中封装了ServerSocket绑定的IP地址4. boolean isClosed() 返回ServerSocket的关闭状态。 3、 注意事项：SeverSocket对象负责监听某台计算机的某个端口号，在创建ServerSocket对象后，需要继续调用该对象的accept( )方法，接收来自客户端的请求。当执行了accept( )方法之后，服务器端程序会发生阻塞，直到客户端发出连接请求时，accept ( )方法才会返回一个Socket对象用于与客户端实现通信，程序才能继续四、public class Socket1、常见的构造方法1. Socket() 使用该构造方法时，并没有指定IP地址和端口号，也就意味着只创建了客户端对象，没法去连接任何服务器，通过该构造方法创建对象后还需调用connect(SocketAddress endpoint)方法，才能完成与指定服务器端的连接，其中参数endpoin用于封装IP地址和端口号。2. Socket (String host, int port)使用该构造方法在创建Socket对象时，会根据参数去连接在指定地址和端口上运行的服务器程序，其中参数host接收的是一个字符串类型的IP地址3. Socket ( InetAddress address, int port )该构造方法在使用上与第一二个构造方法类似，参数address用于接收一个 InetAddress类型的对象，该对象用于封装一个IP地址。2、常见的方法1. int getPort( )该方法返回一个int类型的对象，该对像是Socket对像与服务器连接的断后号2. InetAddress getLocalAddress ( )该方法用于获取Socket对象绑定的本地IP地址，井将IP地址封装成InetAddress类型的对象返回3. void close ( )该方法用于关闭Socket连接，结束本次通信。在关闭Socket之前，应将与Socket相关的所有的输入输出流全部关闭，这是因为一个良好的程序应该在执行完毕时释放所有的资源4. InputStream getInputStream( )该方法返回一个InputSream类型的输入流对象，如果该对象是由服务器端的Socket返回，就用于读取客户端发送的数据，反之，用于读取服务器端发送的数据5. OutputStream getOutputStream( )该方法返回一个OutputStream类型的输出流对象，如果该对象是由服务器端的Socket返回，就用于向客户端发送数据，反之，用于向服务器端发送数据3、注意事项getlnputstream( )和putOutputStream( )方法分别用于获取输人流和输出流。当客户端和服子容端建立连接后，数据是以IO流的形式进行交互的，从而实现通信*/

/*
TCP客户端
*/
public class Cilent{public static void main(String[] args){//创建一个Socket对象，并连接到指定的服务器IP地址和端口号Socket client = new Socket(InetAddress.getLocalHost(),7788);//2、发送数据该服务器，或者接收服务器发来的数据InputStream in = client.getInputStream();//得到接受的数据流byte[] buf = new byte[1024];int len = in.read(buf);//将数据读到缓冲数组中System.out.println(new String(buf,0,len));//3.关闭Socket对象，释放资源client.close();}
}/*
服务器端
*/
public class Serve{public static void main(String[] args)throws Exception{//创建服务器ServerSocket,表示服务器，指定服务器的端口号ServerSocket serverSocket = new ServerSocket(7788);//2.通过accept（）接受客户端的请求Socket client = serverSocket.accept();//3获取客户端的输出流或输入流OutputStream out = client.getOutputStream();//获取客户端的输出流//4通过输出流写数据到客户端，或者通过输入流从客户端中读取发来的数据System.out.println("开始与客户端交互数据");out.write("创智欢迎你".getBystes());Thread.sleep(5000);//模拟执行其他功能，占用时间System.out.println("结束与客户短的交互数据");//关闭Socket对象，释放资源out.close();client.close();}
}

4、多线程版TCP

/*
服务器端
*/
public class Serve{public static void main(String[] args)throws Exception{//创建服务器ServerSocket,表示服务器，指定服务器的端口号ServerSocket serverSocket = new ServerSocket(7788);while(true) {//2.通过accept（）接受客户端的请求final Socket client = serverSocket.accept();new Thread(new Runnable() {public void run() {try {//3获取客户端的输出流或输入流OutputStream out = client.getOutputStream();//获取客户端的输出流//4通过输出流写数据到客户端，或者通过输入流从客户端中读取发来的数据String ipAddress = client.getInetAddress().getHostAddress();System.out.println("开始与客户端交互数据"+ ipAddress + "交互数据");out.write("创智欢迎你".getBystes());Thread.sleep(5000);//模拟执行其他功能，占用时间System.out.println("结束与客户短的交互数据" + ipAddress + "交互数据");//关闭Socket对象，释放资源out.close();client.close();}catch(Exception e) {e.printStackTrace();}}});}}
}/*
TCP客户端
*/
public class Cilent{public static void main(String[] args){//创建一个Socket对象，并连接到指定的服务器IP地址和端口号Socket client = new Socket(InetAddress.getLocalHost(),7788);//2、发送数据该服务器，或者接收服务器发来的数据InputStream in = client.getInputStream();//得到接受的数据流byte[] buf = new byte[1024];int len = in.read(buf);//将数据读到缓冲数组中System.out.println(new String(buf,0,len));//3.关闭Socket对象，释放资源client.close();}
}

10、JDBC

1、定义

/*
DDL 定义语言， 
DML 操作语言  
DQL 查询语言 
DCL 控制语言
一、定义：JDBC的全称是Java数据库连接（Java Database
Connectivity)，它是一套用于执行SQL语句的Java APl。应用程序可通过这套API连接到关系型数据库，并使用SQL语句来完成对数据库中数据的查询、新增、更新和删除等操作。二、访问注意事项应用程序使用JDBC访问特定的数据库时，需要与不同的数据库驱动进行连接。由于不同数据库厂商提供的数据库驱动不同，因此，为了使应用程序与数据库真正建立连接，JDBC不仅需要提供访问数据库的API,还需要封装与各种数据库服务器通信的细节。三、JDBC常用的API1、Driver接口是所有JDBC驱动程序必须实现的接口，该接口专门提供给数据库厂商使用。需要注意的是，在编写JDBC程序时，必须要把所使用的数据库驱动程序或类库加载到项目的classpath中(这里指MySQL驱动JAR包）。2、DriverManager接口用于加载JDBC驱动并且创建与数据库的连接。在DriverManager类中，定义了两个比较重要的静态方法1. static void registerDriver(Driver driver)该方法用于向DriverManager中注册给定的JDBC驱2. static Connection getConnection(String u1,String user,String pwd)该方法用于建立和数据库的连接,并返回表示连接的 Connection对象。3、 Connection接口代表Java程序和数据库的连接;只有获得该连接对象后，才能访问数据库，并操作数据表。在Connection接口中，定义了一系列方法，其常用方法如下所示。1.  Statement createStatement()用于创建一个Statement对象来将SQL语句发送到数据库2. PreparedStatement prepareStatement(String sql)用于创建一个PreparedStatement对象来将参数化的SQL语句,发送到数据库·3. CallableStaterment prepareCall(String sql)用于创建一个 CallableStatement对象来调用数据库存储过程4、Statement接口用于执行静态的SQL语句，并返回一个结果对象。Statement接口对象可以通过Connection实例的createStatement()方法获得，该对象会把静态的SQL语句发送到数据库中编译执行，然后返回数据库的处理结果。在Statement接口中，提供了3个常用的执行SQL语句的方法，具体如下所示。1. boolean execute(String sql)用于执行各种sQL语句，该方法返回一个 boolean类型的值,如果为true，表示所执行的SQL语句有查询结果,可通过 Statement的getResultSet()方法获得查询结果2. int executeUpdate(String sqD)用于执行SQL 中的 insert、update和 delete语句。该方法返回一个int类型的值，表示数据库中受该SQL语句影响的记录条数·3. ResultSet executeQuery(String sql)用于执行SQL中的 select语句，该方法返回一个表示查询结果的ResultSet对象5、PreparedStatement接口PreparedStatement接口是Statement的子接口，用于执行预编译的SQL语句。该接口扩展了带有参数SQL语句的执行操作，应用该接口中的SQL语句可以使用占位符“?”来代替其参数，然后通过setXxx()方法为SQL语句的参数赋值。在PreparedStatement接口中，提供了一些常用方法，具体如下所示。1. int executeUpdate()  在此 PreparedStatement对象中执行SQL语句，该语句必须是一个DML语句或者是无返回内容的SQL语句,如DDL语句2. ResultSet executeQuery()  在此PreparedStatement对象中执行SQL查询,该方法返回的是ResultSet对象3. void setInt(int parameterIndex, int x) 将指定参数设置为给定的 int值4. void setFloat(int parameterIndex, float x)  将指定参数设香为给定的:float 值5. void setString(int parameterIndex, String x)  将指定参数设香为给定的String值6. void setDate(int parameterIndex, Date x, Calendar cal)  将指定参数设置为给定的 Date值需要注意的是， setDate()方法可以设置日期内容，但参数Date 的类型是java.sql.Date，而不是java.util.Date。在通过setXxx()方法为SQL语句中的参数赋值时，可以通过输入参数与SQL类型相匹配的方法。例如,如果参数具有SQL类型为Integer,那么应该使用setInt()方法,也可以通过setObject()方法设置多种类型的输入参数，具体如下所示。String sql = "INSERT INTo users (id,name, email) VALUES (?,?,?) ";Preparedstatement prestmt = conn.preparestatement (sql) ;preStmt .setInt(1,1);//使用参数的已定义sql类型prestmt .setString(2, " zhangsan");//使用参数的已定义sql,类型prestmt.setobject(3, "zsesina. com");//使用setObject ()方法设置参数prestmt.executeUpdate();6、ResultSet接口用于保存JDBC执行查询时返回的结果集，该结果集封装在一个逻辑表格中。在ResultSet接口内部有一个指向表格数据行的游标（或指针广，ResultSet对象初始化时，游标在表格的第一行之前，调用next()方法可将游标移动到下一行。如果下一行没有数据，则返回false。在应用程序中经常使用next()方法作为while循环的条件来迭代ResultSet结果集。ResultSet接口中的常用方法如下所示。1. String getString(String columnIndex)  用于获取指定字段的 String 类型的值，参数 columnindex 代表字段的索引2. String getString(int columnName)  用于获取指定字段的 String类型的值,参数columnName 代表字段的名称3. int getInt(int columnIndex)  用于获取指定字段的 int类型的值,参数coiumnIndex代表字段的索引4. int getInt(String columnName)  用于获取指定字段的 int类型的值，参数columnName 代表字段的名称5. boolean next()  将游标从当前位置向下移一行6. boolean absolute(int row) 将游标移动到ResultSet对象指定的行7. void afterLast()将游标移动到ResultSet对象的末尾8、void beforeFirst()将游标移动到ResultSet对象的开头9、boolean previous()将游标移动到ResultSet对象的上一行10. boolean last()将游标移动到ResultSet对象的最后一行注意：ResultSet接口中定义了大量的getXxx()方法,而采用哪种getXxx()方法取决于字段的数据类型。程序既可以通过字段的名称来获取指定数据，也可以通过字段的索引来获取指定的数据，字段的索引是从1开始编号的。例如，数据表的第一列字段名为id，字段类型为int，那么即可以使用getInt(1)获取该列的值，也可以使用getInt(*id")获取该列的值。*/

JDBC驱动器的API是接口、JDBC驱动器是实现类。

2、实现一个JDBC程序

/*
( 1 ）加载并注册数据库驱动注册数据库驱动的具体方式如下。DriverManager.registerDriver (Driver driver) ;或Class.forName("DriverName");(2）通过DriverManager 获取数据库连接获取数据库连接的具体方式如下。Connection conn = DriverManager.getConnection (String ur1,String user,Stringpwd);从上述代码可以看出，getConnection()方法中有3个参数，它们分别表示连接数据库的地址、登录数据库的用户名和密码。以 MySQL 数据库为例，其地址的书写格式如下。jdbc:mysql://nostname :port/databasename上面代码中，jdbc:mysql:是固定的写法，mysql指的是MySQL 数据库。hostname 指的是主机的名称（如果数据库在本机中，hostname 可以为 localhost或127.0.0.1;如果要连接的数据库在其他计算机上，hostname 为所要连接计算机的IP ),port 指的是连接数据库的端口号( MySQL端口号默认为3306 ),databasename指的是MySQL中相应数据库的名称。(3 ）通过Connection对象获取Statement对象Connection创建Statement的方式有如下3种。.      createStatement():创建基本的Statement象。prepareStatement():创建 PreparedStatement对象。prepareCall():创建CallableStatement 对象。以创建基本的Statement对象为例，创建方式如下。Statement stmt = conn.createStatement();(4）使用Statement 执行sQL语句所有的Statement都有如下.3种执柠SQL语句的方法execute():可以执行任何sQL语句。executeQuery():通常执行查询语句，执行后返回代表结果集的ResultSet对象。executeUpdate():主要用于执行DML和DDL语句。执行DML语句,如 INSERT.UPDATE或DELETE时，返回受SQL语句影响的行数，执行 DDL语句返回0。以executeQuery()方法为例，其使用方式如下。//执行sOL语句,获取结果集 ResultSetResultSet rs = stmt .executeouery (sql):(5）操作ResultSet结果集如果执行的SQL语句是查询语句，执行结果将返回一个ResultSet对象，该对象里保存了SQL语句查询的结果。程序可以通过操作该ResultSet对象来取出查询结果。( 6）关闭连接，释放资源每次操作数据库结束后都要关闭数据库连接，释放资源，包括关闭 ResultSet、Statement和Connection等资源。
*/
import java.sql.*;public class JdbcTest01 {public static void main(String[] args) throws SQLException {Statement stmt = null;ResultSet rs = null;Connection conn = null;try {//1.注册数据库的驱动Class.forName("com.mysql.cj.jdbc.Driver");//2..通过DirverManager获取数据库连接String url ="jdbc:mysql://localhost:3306/jdbc"+ "?serverTimezone=GMT%2B8&useSSL=false";String username = "root";String password = "kdh77585219513";conn = DriverManager.getConnection(url,username,password);// 3.通过connectiond对象获取statement对象stmt = conn.createStatement();String sql = "select * from users";//4. 使用stmt语句执行sql语句rs = stmt.executeQuery(sql);System.out.println("id|		name|	passoward"+"|	email		|	birthday");while(rs.next()) {//5. 通过列名获取指定字段的值int id = rs.getInt("id");String name = rs.getString("name");String psw = rs.getString("passward");String email = rs.getString("email");Date birthday = rs.getDate("birthday");System.out.println(id + " |      " + name + "       |" + psw + "        |" + email+"       |" + birthday + "      |");}} catch (ClassNotFoundException e) {e.printStackTrace();} finally {//6. 释放资源if(rs != null) {try {rs.close();} catch (SQLException e) {e.printStackTrace();}rs = null;}if(stmt != null) {try {stmt.close();} catch (SQLException e) {e.printStackTrace();}stmt = null;}if(conn != null) {try {conn.close();} catch (SQLException e) {e.printStackTrace();}conn = null;}}}
}
/*
以上注意啦：
1、注册驱动：方法一：Class.forName("com.mysql.cj.jdbc.Driver");这种方法有两个地方需要解释com.mysql.cj.jdbc.Driver这是现代版本特定的写法com.mysql.cj.数据库名称.Driver2、获取数据库连接String url ="jdbc:mysql://localhost:3306/jdbc？serverTimezone=GMT%2B8&useSSL=false";//true或者false都可以不光写jdbc:mysql://localhost:3306/jdbc原因是因为数据安装的是美国时间，不写serverTimezone=GMT%2B把其设置成背景时间，会报错误。高版本的MySQL需要指名是否进行SSL相连，否则会出现报警信息。只需要在后面加入&useSSL=false/true即可。3、释放资源由于数据库资源非常宝贵,数据库允许的并发访问连接数量有限,因此,当数据库资源使用完毕后,一定要记得释放资源。为了保证资源的释放,在Jva程序中,应该将释放资源的操作放在finally代码块中。*/

3、PreparedStatement对象

/*
一、Statement 提供了一个子类 PreparedStatement。PreparedStatement对象可以对 SQL语句进行预编译，预编译的信息会存储在 PreparedStatement对象中。当相同的SQL语句再次执行时，程序会使用PreparedStatement对象中的数据，而不需要对SQL 语句再次编译去查询数据库，这样就大大提高了数据的访问效率。
*/
import java.sql.*;public class JdbcTest02 {public static void main(String[] args) throws SQLException {Connection conn = null;//1.注册数据库的驱动Class.forName("com.mysql.cj.jdbc.Driver");//2..通过DirverManager获取数据库连接String url ="jdbc:mysql://localhost:3306/jdbc"+ "?serverTimezone=GMT%2B8&useSSL=false";String username = "root";String password = "kdh77585219513";conn = DriverManager.getConnection(url,username,password);// 3.通过connectiond对象获取PreparedStatement对象,需要指定sql语句String sql = "insert into users(name,password,email,birthday) values(?,?,?,?)";PreparedStatement preStmt = conn.prepareStatement(sql);//为sql语句的参数赋值preStmt.setString(1,"za");preStmt.setString(2,"123456");preStmt.setString(3,"[e-mail]");preStmt.setString(4,"1999-04-22");//4. 使用PreparedStament语句执行sql语句int count= preStmt.executeUpdate();System.out.println("影响数据库表中数据条数为"+count);//5、操作ResultSet结果集//6、关闭连接，释放资源preStmt.close();con.close();    }
}

4、ResultSet对象

import java.sql.*;public class JdbcTest02 {public static void main(String[] args) throws SQLException {Class.forName("com.mysql.cj.jdbc.Driver");String url ="jdbc:mysql://localhost:3306/jdbc"+ "?serverTimezone=GMT%2B8&useSSL=false";String username = "root";String password = "kdh77585219513";Connection conn = DriverManager.getConnection(url,username,password);String sql = "select * from users";PreparedStatement preStmt = conn.prepareStatement(sql);//执行SQL语句ResultSet rs = ppstmt.executeQuery();//操作查询结果集ResultSetrs.absolute(2);//将指针定位到结果集中的第3二行数据System.out.println("第2条数据的name值为"+rs.getString("name"));rs.beforeFirst();//将指针定位到结果集中的第1行数据之前System.out.println("第1条数据的name值为"+rs.getString("name"));re.afterLast();//将指针定位到结果集中的最后一条数据之后re.previous();//指针向前一定System.out.println("第4条数据的name值为："+rs.getString("name"));}
}

5、JDBC一个学生管理系统

/*
一、搭建数据库环境
在mysql中创建一个名为jdbcde1数据库，在jdbc中新建一个users表，创建数据库和表的sql语句
create database jdbc;
use jdbc
create table Student
(id int,name char(20),c_no char(20),ranking char(20),primary key(id)
);
insert into Student values (123,'小白','1902','2');
insert into Student values (124,'李菁','1902','1');
insert into Student values (125,'小李','1901','3');输入：select * from users; 查询表结构二、Mysql连接IDEA方法选则想用的modules模块 -> new -> directory -> 把数据库驱动程序.jar复制到这里面file -> projecct stucture -> modules -> dependencies -> JARs or directories -> 选则好下载好的Jar包确认，从而完成包添加到依赖项。三、Eclipse如何连接数据库驱动方法在Eclipse中新建一个名称为chapter09的Java项目，使用鼠标右键单击项目名称，然后选择【New】→【Folder 文件夹】，在弹出窗口中将该文件夹命名为lib并单击【Finish】按钮，此时项目根目录中就会出现一个名称为lib 的文件夹。将下载好的 MySQL 数据库驱动文件mysql-connector-java-5.0.8-bin.jar复制到项目的lib目录中,并使用鼠标右键单击该JAR包,在弹出框中选择【Build Path 】→【Add to Build Path ]，此时Eclipse 会将该JAR包发布到类路径下( MySQL 驱动文件可以在其官网地址http:/ldev.mysql.com/downloads/ connectorl/页面中下载,在浏览器中输入该地址后即可进入下载页面,点击页面Generally Available (GA)Releases窗口中的Looking for previous GA versions 超链接后，在显示出的下拉框中下载所需的驱动版本即可)。三、在刚才建立的mouules下建立对象的类和包即可
*/package cn.kong.jdbc;
import java.sql.*;
import java.util.Scanner;
public class Main<ex> {public static void main(String[] args)throws ClassNotFoundException, SQLException {Connection conn=null;Statement stat=null;String url ="jdbc:mysql://localhost:3306/jdbc"+ "?serverTimezone=GMT%2B8&useSSL=false";String username="root";String password="kdh77585219513";Class.forName("com.mysql.cj.jdbc.Driver");conn=DriverManager.getConnection(url,username,password);stat=conn.createStatement();try{System.out.println("欢迎进入学生管理系统！");System.out.println("如果想要查看全部学生信息，请按1");System.out.println("如果想要添加新学生信息，请按2");System.out.println("如果想要修改学生信息，请按3");System.out.println("如果想要删除学生信息，请按4");Scanner sc=new Scanner(System.in);int x=sc.nextInt();switch (x){case 1:Select(stat);break;case 2:Add(stat);break;case 3:Alter(stat,sc);break;case 4:Delete(stat,sc);break;default:System.out.println("抱歉，您输入的信息不符合要求！");break;}} catch (Exception e) {e.printStackTrace();}}public static void Select(Statement stat)throws SQLException{String sql="select * from Student";ResultSet re=stat.executeQuery(sql);System.out.println("|  学号  |  姓名  |  班级  |  排名  |");while(re.next()){int id=re.getInt("id");String name=re.getString("name");String c_no=re.getString("c_no");int rank=re.getInt("ranking");System.out.println("|  "+id+"  |  "+name+"  |  "+c_no+"  |  "+rank+"  |");}}public static void Add(Statement stat)throws SQLException{System.out.println("请输入需要添加的学生信息（学号，姓名，班级，总成绩排名）：");Scanner input =new Scanner(System.in);String str=input.nextLine();String[] arrs=str.split(" ");int id=Integer.parseInt(arrs[0]);String name=arrs[1];String c_no=arrs[2];int rank=Integer.parseInt(arrs[3]);boolean ex=Exist(stat,id);if(!ex){String sql="insert into Student values( "+id+",'"+name+"','"+c_no+"',"+rank+");";stat.execute(sql);System.out.println("添加成功！");}}public static void Alter(Statement stat,Scanner sc)throws SQLException{System.out.println("请输入需要修改信息的学生学号：");int target=sc.nextInt();System.out.println("请输入需要新的信息（班级和排名）");Scanner in=new Scanner(System.in);String[] new_info=in.nextLine().split(" ");if(Exist(stat,target)){String sql="update Student set c_no='"+new_info[0]+"' where Student.id="+target;String sql2="update Student set ranking="+Integer.parseInt(new_info[1])+" where Student.id="+target;stat.execute(sql);stat.execute(sql2);}}public static void Delete(Statement stat,Scanner sc)throws SQLException{System.out.println("请输入要删除的学生学号：");int target=sc.nextInt();if(Exist(stat,target)){String sql="delete from Student where id="+target;stat.execute(sql);System.out.println("删除成功！");}}public static boolean Exist(Statement stat,int id) throws SQLException{ResultSet re =stat.executeQuery("select id from Student");while(re.next()) {if (id == re.getInt("id")) {return true;}} return false;}}

11、GUI

/*
一、Swing顶级容器：学习Swing 组件的过程和学习AWT差不多，大部分的Swing组件都是JComponent类的直接或者间接子类，而JComponent类是AWT中 java.awt.Container的子类，说明Swing组件和AWT组件在继承树上形成了一定的关系。接下来通过一张继承关系图来描述一下 AWT和Swing大部分组件的关联关系，下图展示了一些常用的Swing组件，不难发现，这些组件的类名和对应的AWT组件类名基本一致，大部分都是在AWT组件类名的前面添加了“J”。但也有一些例外，例如Swing的JComboBox组件对应的是AWT中的 Choice 组件(下拉框)。图还可以看出，Swing 中有3个组件继承了AWT的 Window类，而不是继承自JComponent类，它们分别是JWindow、JFrame、和Jdialog。这3个组件是Swing 中的顶级容器，它们都需要依赖本地平台,因此被称为重量级组件。其中，JWindow和AWT中的 Window-样很少被使用，一般都是用JFrame和JDialog。二、JFrame类（窗口）在Swing 组件中,最常见的一个就是JFrame,它和Frame 一样是一个独立存在的顶级窗口,不能放置在其他容器之中，JFrame支持通用窗口所有的基本功能，例如窗口最小化、设定窗口大小等。1、静态摘要static int EXIT_ON_CLOSE 退出应用程序默认窗口关闭操作。 1. 常用的构造方法：1、 JFrame() 创建一个普通窗体对象2、 JFrame(String title) 创建一个窗体对象，并指定标题2. 常用的方法1、void setDefaultCloseOperation(int operation) 设置用户在此框架上启动“关闭”时默认执行的操作。 2、public void setSize(int width,int height)设置窗体大小3、public void setSize(Dimention d)通过Dimention设置窗体大小4、public void Backgroud(Color c)设置窗体的背景颜色5、public void setLocation(int x, int y)设置组件的显示位置6、public void setLocation(Point p)通过Point来设置组件的位置7、public void setVisible(boolean b)显示或隐藏组件8、public Component add(Component comp)向容器中增加组件9、public setLayout(Component comp)设置布局管理器，如果设置为null,表示不使用10、public void pack()调整窗口大小，以适应子组件的首选大小和布局11、public void Comntainer getContentPane()返回此窗体的容器对象12.setLocationRelativeTo(null);让窗体居中显示13、public void validate()验证此容器及其所有子组件。使用 validate 方法会使容器再次布置其子组件。已经布置容器后，在修改此容器的子组件的时候（在容器中添加或移除组件，或者更改与布局相关的信息），应该调用上述方法。覆盖：类 Component 中的 validate
*/

1、JFrame

package cn.kong.GUL;import javax.swing.*;public class Example01 extends JFrame {public static void main(String[] args) {//使用SwingUtilities工具调用createAndshowGUI()方法显示GUI程序SwingUtilities.invokeLater(Example01::createAndShowGUI);}private static void createAndShowGUI(){//创建并设置Jframe窗口JFrame frame = new JFrame("JFrameTest");//设置关闭窗口的默认操作frame.getDefaultCloseOperation(); //默认这里面不跟参数//设置窗口标题frame.setTitle("JFrameTest");//设置窗口的尺寸frame.setSize(350,300);//设置窗口的显示位置frame.setLocation(300,300);//让组件显示frame.setVisible(true);}
}

2、JDialog

/*JDialog 是Swing 的另外一个顶级窗口，它和Dialog 一样都表示对话框。对话框是模态或者非模态，可以在创建JDialog对象时为构造方法传入参数来设置，也可以在创建JDialog对象后调用它的setModal()方法来进行设置。1、概念：对话窗口分类；1. 模态对话框用户需要等到处理完对话框后才能继续与其他窗口交互的对话框,2. 非模态对话框允许用户在处理对话框的同时与其他窗口交互的对话框。2、常见构造方法1、JDialog(Frame owner)构造方法，用来创建一个非模态的对话框,owner为对话框所有者(顶级窗口JFrame )2、JDialog(Frame owner，String title)构造方法,创建一个具有指定标题的非模态对话框3、JDialog(Frame owner,boolean modal)创建一个有指定模式的无标题对话框(模态)->不允许点击其它位置，只能再次对话框中进行点击操作FRame owner 的方式是:类名.this(如果该类继承了JFrame或者Frame的话)，modal直接true就好。
*/

package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;public class Example02 {public static void main(String[] args) {//建立两个按钮JButton btn1 = new JButton("模态对话框");JButton btn2 = new JButton("非模态对话框");JFrame f = new JFrame("DialogDeme");f.setSize(300,250);f.setLocation(300,300) ;f.setLayout(new FlowLayout());//为内容面板增加布局管理器//在container对象上增加按钮f.add(btn1);f.add(btn2);f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭按钮为默认关闭窗口按钮f.setVisible(true);final JLabel label = new JLabel();//定义一个JDialog对话框final JDialog dialog = new JDialog(f, "Di alog");dialog.setSize(220,150);dialog.setLocation(400,500);dialog.setLayout(new FlowLayout()); //设置布局管理器final JButton btn3 = new JButton("确定");//创建按钮对象dialog.add(btn3);//为模态按钮添加单机事件btn1.addActionListener(new AbstractAction() {@Overridepublic void actionPerformed(ActionEvent e) {//设置对话框模态dialog.setModal(true);//如果JDialog窗口没添加JLabel标签，就把JLabel标签加上if(dialog.getComponents().length == 1){dialog.add(label);}//否则修改标签内容label.setText("模态对话框，单词确定按钮关闭");//显示对话框dialog.setVisible(true);}});为非模态按钮添加单机事件btn2.addActionListener(new AbstractAction() {@Overridepublic void actionPerformed(ActionEvent e) {//设置对话框非模态dialog.setModal(false);//如果JDialog窗口没添加JLabel标签，就把JLabel标签加上if(dialog.getComponents().length == 1){dialog.add(label);}//否则修改标签内容label.setText("非模态对话框，单词确定按钮关闭");//显示对话框dialog.setVisible(true);}});//为对话框中的按钮添加单机事件btn3.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {dialog.dispose();}});}
}

3、布局管理器

/*
一、作用：组件不能单独存在，必须放置于容器当中，而组件在容器中的位置和尺寸是由布局管理器来决定的。在 java.awt包中提供了5种布局管理器，但是在Swing中最常用是4个，分别是 FlowLayout（流式布局管理器)、Border Layout(边界布局管理器).GridLayout(网格布局管理器).GridBagLayout（网格包布局管理器）。每个容器在创建时都会使用一种默认的布局管理器，在程序中可以通过调用容器对象的setLayout()方法设置布局管理器，通过布局管理器来自动进行组件的布局管理。例如把一个JFrame 窗体的布局管理器设置为FlowLayout,代码如下所示。JFrame frame= new JFrame();frame.setlayout (new FlowLayout ());
*/

1、FlowLayout

/*
一、概念：流式布局管理器(FlowLayout)是最简单的布局管理器，在这种布局下，容器会将组件按照添加顺序从左向右放置。当到达容器的边界时，会自动将组件放到下一行的开始位置。这些组件可以左对齐、居中对齐（默认方式）或右对齐的方式排列。二、常用构造方法1. FlowLayout() 构造一个新的 FlowLayout中心对齐和默认的5单位水平和垂直间隙。 2. FlowLayout(int align) 构造一个新的 FlowLayout具有指定的对齐和默认的5单位水平和垂直间隙。 3. FlowLayout(int align, int hgap, int vgap) 创建一个新的流程布局管理器，具有指示的对齐方式和指示的水平和垂直间距。三、常用常量1. public static final int LEFT该值表示每一行的组件应为左对齐。 2. public static final int RIGHT该值表示组件的每一行都应该是右对齐的。 3.public static final int CENTER该值表示每行的组件应该居中。 4. public static final int LEADING该值表示组件的每一行应该对齐到容器方向的前端，例如从左到右的方向向左。 四、注意事项FlowLayout的3个构造方法。参数align 决定组件在每行中相对于容器边界的对齐方式，可以使用该类中提供的常量作为参数传递给构造方法。其中，FlowLayout.LEFT用于表示左对齐,FlowLayout.RIGHT用于表示右对齐, FlowLayout.CENTER 用于表示居中对齐。参数 hgap和参数vgap分别设定组件之间的水平和垂直间隙，可以填入一个任意数值。接下来通过一个添加按钮的案例来学习一下 FlowLayout 布局管理器的用法，五、特点：FlowLayout布局管理器的特点就是可以将所有组件像流水一样依次进行排列，不需要用户明确地设定，但是在灵活性上相对差了点。例如将图8-5中的窗体拉伸变宽，按钮的大小和按钮之间的间距将保持不变，但按钮相对于容器边界的距离会发生变化，*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;public class Example03 {public static void main(String[] args) {JFrame frame = new JFrame("hello World");//设置窗体的布局管理器为FlowLayout,所有的组件居中对齐，水平和垂直及间距为3frame.setLayout(new FlowLayout(FlowLayout.CENTER,3,3));JButton button = null;for(int i = 0; i < 9; i++){button = new JButton("按钮"+i);frame.add(button);}frame.setSize(280,250);frame.setVisible(true);}
}

2、BorderLayout

/*
一、边界布局管理器BorderLayout(边界布局管理器）是一种较为复杂的布局方式，它将容器划分为5个区域，分别是东(EAST )、南( SOUTH )、西（WEST)、北（NORTH)、中（CENTER )。组件可以被放置在这5个区域中的任意一个。BorderLayout边界布局管理器，将容器划分为5个区域，其中，箭头是指改变容器大小时各个区域需要改变的方向。也就是说，在改变容器时，NORTH和SOUTH 区域高度不变，长度调整，WEST和EAST区域宽度不变，高度调整，CENTER 会相应进行调整。当向 BorderLayout布局管理器的容器中添加组件时，需要使用add ( Componentcomp,Object constraints )方法。其中，参数comp表示要添加的组件，constraints 指定将组件添加到布局中的方式和位置的对象，它是一个 Object 类型，在传参时可以使用 BorderLayout类提供的5个常量，它们分别是 EAST、 SOUTH、WEST. NORTH 和 CENTER。二、常用的构造方法：1、public BorderLayout()构造没有间距得布局器2、public BordeerLayout(int align,ing hgap, int vgap)构造有水平和垂直间距的布局器三、常用常量1、EAST  将组建设置在东区域2、WEST  将组建设置在西区域3、SOUTH 将组建设置在南区域4、NORTH 将组建设置在北区域5、CENTER 将组建设置在中间区域四、特点BorderLayout的好处就是可以限定各区域的边界，当用户改变容器窗口大小时，各个组件的相对位置不变。但需要注意的是，向BorderLayout 的布局管理器添加组件时，如果不指定添加到哪个区域，则默认添加到 CENTER 区域，并且每个区域只能放置一个组件，如果向一个区域中添加多个组件时,后放入的组件会覆盖先放入的组件。
*/
package cn.kong.GUL;import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;public class BorderLayoutDemo extends JFrame {public static void main(String[] args) {BorderLayoutDemo f = new BorderLayoutDemo();f.setTitle("边界布局");f.pack();f.setVisible(true);f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);f.setLocationRelativeTo(null);//让窗体居中显示}//构造函数，初始化对象值public BorderLayoutDemo(){//设置边界布局，组件件横向、纵向间距均为5个像素setLayout(new BorderLayout(5,5));setFont(new Font("Helvetica",Font.PLAIN,14));//将按钮添加到窗口中getContentPane().add("North",new JButton(BorderLayout.NORTH));getContentPane().add("South",new JButton(BorderLayout.SOUTH));getContentPane().add("East",new JButton(BorderLayout.EAST));getContentPane().add("West",new JButton(BorderLayout.WEST));getContentPane().add("Center",new JButton(BorderLayout.CENTER));}
}
//例二
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;public class Example04 {public static void main(String[] args) {final JFrame f = new JFrame("BorderLayout");f.setLayout(new BorderLayout());f.setSize(300,300);//设置窗体大小f.setLocation(300,300);//窗体显示的位置f.setVisible(true);//设置窗体可见//5个按钮分别填充到BorderLayout5个区域中Button but1 = new Button("East");Button but2 = new Button("West");Button but3 = new Button("South");Button but4 = new Button("North");Button but5 = new Button("Center");//将创建好的按钮添加到窗体中，并设置位置f.add(but1,BorderLayout.EAST);f.add(but2,BorderLayout.WEST);f.add(but3,BorderLayout.SOUTH);f.add(but4,BorderLayout.NORTH);f.add(but5,BorderLayout.CENTER);}
}

3、GridLayout

/*
一、定义；GridLayout(网格布局管理器）使用纵横线将容器分成n行m列大小相等的网格，每个网格中放置一个组件。添加到容器中的组件首先放置在第1行第1列(左上角)的网格中,然后在第1行的网格中从左向右依次放置其他组件。行满后，继续在下一行中从左到右放置组件。与FlowLayout 不同的是，放置在GridLayout布局管理器中的组件将自动占据网格的整个区域。二、构造方法：1. GridLayout() 弄人只有一行，每个组件占一列2. GridLayout(int rows, int cols) 指定容器的行数和列数3. GridLayout(int rows, int clos, int hgap, int vgap)指定容器的行数和列数以及组件之间的水平，垂直间距三、提示：GridLayout的3个构造方法。其中，参数rows代表行数，cols 代表列数,hgap和 vgap 规定水平和垂直方向的间隙。水平间隙指的是网格之间的水平距离，垂直间隙指的是网格之间的垂直距离。
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;public class Example05 {public static void main(String[] args) {JFrame f = new JFrame("GridLayout");f.setLayout((new GridLayout(3,3,2,3)));//3*3网格f.setSize(300,300);//窗体大小f.setLocation(400,300);//位置//将9个按钮添加到GridLayout中for(int i = 1; i <= 9; i++){Button btn = new Button("btn" + i);f.add(btn);//像窗体中添加按钮}f.setVisible(true);}
}

4、GridBagLayout

/*
一、概念：GridBagLayout(网格包布局管理器）是最灵活、最复杂的布局管理器。与GridLayout布局管理器类似，不同的是，它允许网格中的组件大小各不相同，而且允许一个组件跨越一个或者多个网格。二、使用步骤1、创建GridBagLayout布局管理器，并使用容器采用该布局管理器GridBagLayout layout = new GridBagLayout();container.setLayout(layout);2、创建GridBagContraints对象（布局约束条件)，并设置该对象的相关属性。GridBagContraints constraints = new GridBagContraints();constraints.gridx = 1; //设置网格的左上角横向索引constraints.gridy = 1;//设置网格的左上角纵向索引constraints.gridwidth = 1;//设置组件横向跨越网格constraints.gridheight = 1;//设置组件纵向跨越网格3、调用GridBagLayout对象的setConstraints()方法建立GridBagConstraints对象和受控组件之间的关联。layout.setconstraints (component, constraints);4、向容器中添加组件container.add(conponent);5、GridBagConstraints对象可以重复使用，只需要改变它的属性即可。如果要向容器中添加多个组件，则重复步骤（2）、步骤（3）、步骤(4）。从上面的步骤可以看出，使用GridBagLayout布局管理器的关键在于GridBagConstraints对象，它才是控制容器中每个组件布局的核心类，在GridBagConstraints类中有很多表示约束的属性，GridBagConstraints常用到的属性1. gridx和gridy设置组件的左上角所在网格的横向和纵向索引(即所在的行和列）。如果将 gridx和gridy的值设gridBagConstraints.RELATIVE(默认值)，表示当前组件紧跟在上一个组件后面2. gridwidth和gridheight设置组件横向、纵向跨越几个网格,两个属性的默认值都是1。如果把这两个属性的值设为 GridBagConstraints.REMAINER(remainer)，表示当前组件在其行或其列上为最后一个组件。如果把这两个属性的值设为GridBagConstraints.RELATIVE(relative),表示当前组件在其行或列上为倒数第2个组件3. fill如果当组件的显示区域大于组件需要的大小，设置是否以及如何改变组件大小，该属性接收以下几个属性值。NONE:默认，不改变组件大小(note)HORIZONTAL:使组件水平方向足够长以填充显示区域，但是高度不变(horizontal)VERTICAL:使组件垂直方向足够高以填充显示区域,但长度不变(vertical)BOTH:使组件足够大，以填充整个显示区域(组件横向纵向可拉伸)4. weightx和weigthy设置组件占领容器中多余的水平方向和垂直方向空白的比例（也称为权重)。假设容器的水平方向放置3个组件，其weightx分别为1、2、3，当容器宽度增加60个像素时,这3个容器分别增加10、20、和30的像素。这两个属性的默认值是0,即不占领多余的空间列出了GridBagConstraints 的常用属性。其中，gridx和gridy用于设置组件左上角所在网格的横向和纵向索引，gridwidth和 gridheight 用于设置组件横向、纵向跨越几个网格，fill用于设置是否及如何改变组件大小，weightx和 weighty用于设置组件在容器中的水平方向和垂直方向的权重。需要注意的是，如果希望组件的大小随着容器的增大而增大，必须同时设置 GridBagConstraints对象的fil属性和weightx、weighty属性。
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;public class Example06 {public static void main(String[] args) {new Layout("GirdBagLayout");}
}
class Layout extends JFrame{public Layout(String title){GridBagLayout layout = new GridBagLayout();GridBagConstraints c = new GridBagConstraints();this.setLayout(layout); //等价于JFrame.setLayout(new GridBagLayout());因为继承的是JFramec.fill = GridBagConstraints.BOTH;//设置组件横向，纵向可拉伸c.weightx = 1;//横向权重为1c.weightx = 1; //纵向权重为1this.addComponent("btn1",layout,c);this.addComponent("btn2",layout,c);this.addComponent("btn3",layout,c);//添加的组件是本行最后一个组件c.gridwidth = GridBagConstraints.REMAINDER; //行上的this.addComponent("btn4",layout,c);c.weightx = 0;//横向权重为0c.weighty = 0;//纵向权重为0this.addComponent("btn5",layout,c);//添加的组件是本行的最后一个组件c.gridwidth = GridBagConstraints.REMAINDER;this.addComponent("btn6",layout,c);c.gridwidth = 1; //组件横跨1个网格c.gridheight = 2;//组件纵跨2个网格c.weightx = 2; //横向权重股为2c.weighty = 2; //纵向权重为2this.addComponent("btn8",layout,c);c.gridwidth = GridBagConstraints.REMAINDER;//改行最后一个c.gridheight = 1; //纵跨1this.addComponent("btn9",layout,c);this.addComponent("btn10",layout,c);this.setTitle(title);this.pack();this.setVisible(true);this.setLocation(400,500);}//增加组件的方法private void addComponent(String name,GridBagLayout layout, GridBagConstraints c) {Button bt = new Button(name);//创建一个名为name的按钮layout.setConstraints(bt,c);//设置GridBagConstraint和bt的关联this.add(bt);//给JFrame增加组件}
}

5、不常用的布局管理器

CardLayout卡片布局管理器

• 一个CardLayout对象是CardLayout的布局管理器。 它将容器中的每个组件视为一张卡。 一次只能看到一张卡片，容器就是一堆卡片。 添加到CardLayout对象的第一个组件是首次显示容器时的可见组件。

任何时候只有一张卡片可见。

4、事件处理机制

1、事件处理机制

/*
一、概念：事件处理机制专门用于响应用户的操作，例如，想要响应用户的单击鼠标、按下键盘等操作,就需要使用Swing 的事件处理机制。在学习如何使用Swing事件处理机制之前，首先向读者介绍几个比较重要的概念，具体如下所示。·事件源（组件Event Source):事件发生的场所，通常就是产生事件的组件,如窗口，按钮，菜单·事件对象(Event ):封装了GUI组件上发生的特定事件（通常就是用户的一次操作)。·监听器( Listener ):负责监听事件源上发生的事件,并对各种事件做出相应处理的对象(对象中包含事件处理器）。
二、事件源是一个组件，当用户进行一些操作时，如按下鼠标或者释放键盘等，这些动作会触发相应的事件。如果事件源注册了事件监听器，则触发的相应事件将会被处理。在程序中，如果想实现事件的监听机制，首先需要定义一个实现了事件监听器接口的类，例如Window类型的窗口需要实现WindowListener 。接着通过 addWindowListener()方法为事件源注册事件监听器对象，当事件源上发生事件时，便会触发事件监听器对象，由事件监听器调用相应的方法来处理相应的事件。三、一般步骤：1. 编写事件处理类（事件监听者）2. 需要给事件处理类实现监听器接口3. 在事件处理类重写事件处理方法4. 在事件源中指定该事件的监听器（响应者）是谁，即注册监听器
四、以下是案列，实现窗口关闭功能*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.*;public class Example07 {public static void main(String[] args) {//建立新窗体JFrame f = new JFrame("我的窗体");//设置窗体的宽和高f.setSize(400,300);f.setLocation(400,500);f.setVisible(true);//为窗口组件注册监听器MyWindowsListener mw = new MyWindowsListener();f.addWindowListener(mw);}
}
//1、编写事件处理类
class MyWindowsListener implements WindowListener{ //2.实现监听器接口@Overridepublic void windowOpened(WindowEvent e) {}//重写处理方法（监听器监听事件对象做出处理）public void windowClosing(WindowEvent e){Window window = e.getWindow();window.setVisible(false);//释放窗口window.dispose();}public void windowActivated(WindowEvent e){}public void windowClosed(WindowEvent e){}public void windowDeactivated(WindowEvent e){}public void windowDeiconified(WindowEvent e){}public void windowIconified(WindowEvent e){}}

2、Swing常用事件处理

1、窗体事件

/*
一、定义：大部分GUI应用程序都需要使用 Window窗体对象作为最外层的容器，可以说窗体对象是所有GUI应用程序的基础，应用程序中通常都是将其他组件直接或者间接地置于窗体中。当对窗体进行操作时，例如窗体的打开、关闭、激活、停用等，这些动作都属于窗体事件,JDK中提供了一个类 WindowEvent用于表示这些窗体事件。在应用程序中，当对窗体事件进行处理时，首先需要定义一个实现了 WindowListener接口的类作为窗体监听器，然后通过addWindowListener()方法将窗体对象与窗体监听器绑定。
*/
package cn.kong.GUL;import sun.swing.SwingUtilities2;import javax.swing.*;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;public class Example08 {public static void main(String[] args) {//使用SwingUtilities.invokeLater工具类调用createAndShowGUI方法，并显示GUI程序SwingUtilities.invokeLater(Example08::createAndShowGUI);}private static void createAndShowGUI() {JFrame f = new JFrame("WindowEvent");f.setSize(400,300);f.setLocation(400,500);f.setVisible(true);f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//使用内部类创建WindowListener实例对象，监听窗口事件//为窗口增加监听机制f.addWindowListener(new WindowListener() {@Overridepublic void windowOpened(WindowEvent e) {System.out.println("windowOpened--窗口打开事件");}@Overridepublic void windowClosing(WindowEvent e) {System.out.println("windowClosing--窗体正在关闭事件");}@Overridepublic void windowClosed(WindowEvent e) {System.out.println("windowClosed--窗体关闭事件");}@Overridepublic void windowIconified(WindowEvent e) {System.out.println("windowIconified--窗体图标化事件");}@Overridepublic void windowDeiconified(WindowEvent e) {System.out.println("windowDeiconified--窗体取消图标化事件");}@Overridepublic void windowActivated(WindowEvent e) {System.out.println(" windowActivated--窗体激活事件");}@Overridepublic void windowDeactivated(WindowEvent e) {System.out.println("windowDeactivated--窗体停用事件");}});}
}
/*
匿名内部类中对操作的窗口进行监听，当收到特定的操作后，就将所触发的事件的名称打印下来。
*/

2、鼠标事件

/*
一、定义：在图形用户界面中，用户会经常使用鼠标来进行选择、切换界面等操作，这些操作被定义为鼠标事件，其中包括鼠标按下、鼠标松开、鼠标单击等。JDK中提供了一个MouseEvent类用于表示鼠标事件，几乎所有的组件都可以产生鼠标事件。处理鼠标事件时，首先需要通过实现MouseListener接口定义监听器（也可以通过继承适配器MouseAdapter类来实现)，然后调用addMouseListener()方法将监听器绑定到事件源对象。二、MouseEvent类为鼠标的按键定义了对应的常量，可以通过MouseEvent对象的getButton()方法获取被操作的按键的键值，从而判断是哪个案件的操作。
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;public class Example09 {public static void main(String[] args) {//使用SwingUtilities.invokeLater工具类调用createAndShowGUI方法，并显示GUI程序SwingUtilities.invokeLater(Example09::createAndShowGUI);}private static void createAndShowGUI() {JFrame f = new JFrame("MouseEvent");f.setSize(400,300);f.setLocation(400,500);f.setVisible(true);f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);JButton but = new JButton("Button");//创建按钮对象f.add(but);//使用内部类创建MouseListener实例对象，监听按钮but.addMouseListener(new MouseListener() {@Overridepublic void mouseClicked(MouseEvent e) {if(e.getButton()==MouseEvent.BUTTON1){System.out.println("鼠标左击事件");}else if(e.getButton()==MouseEvent.BUTTON3){System.out.println("鼠标右击事件");}else if(e.getButton()==MouseEvent.BUTTON2){System.out.println("鼠标中建单机事件");}System.out.println("mouseClicked--鼠标完成单机");}@Overridepublic void mousePressed(MouseEvent e) {System.out.println("mousePressed--鼠标按下事件");}@Overridepublic void mouseReleased(MouseEvent e) {System.out.println(" mouseReleased--鼠标放开事件");}@Overridepublic void mouseEntered(MouseEvent e) {System.out.println("mouseEntered--鼠标进入按钮区事件");}@Overridepublic void mouseExited(MouseEvent e) {System.out.println("mouseExited--鼠标移除按钮区事件");}});}}

3、键盘事件

/*
一、定义：键盘操作也是最常用的用户交互方式，例如键盘按下、释放等，这些操作被定义为键盘事件。JDK中提供了一个 KeyEvent类表示键盘事件，处理 KeyEvent事件的监听器对象需要实现KeyListener 接口或者继承KeyAdapter类。
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;public class Example10 {public static void main(String[] args) {//使用SwingUtilities.invokeLater工具类调用createAndShowGUI方法，并显示GUI程序SwingUtilities.invokeLater(Example10::createAndShowGUI);}private static void createAndShowGUI() {JFrame f = new JFrame("KeyEvent");f.setLayout(new FlowLayout());//流式布局管理器f.setSize(400,400);f.setLocation(450,500);JTextField tf = new JTextField(30);//创建文本框对象f.add(tf);f.setVisible(true);f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//为文本框添加监听器tf.addKeyListener(new KeyListener() {@Overridepublic void keyTyped(KeyEvent e) {//获取对应的键盘字符char keyChar = e.getKeyChar();//获取对应的键盘字符代码int keyCode = e.getKeyCode();System.out.println("键盘按下的字符为-->" + keyChar + " ");System.out.println("键盘按下的字符代码为-->"+ keyCode);}@Overridepublic void keyPressed(KeyEvent e) {}@Overridepublic void keyReleased(KeyEvent e) {}});}
}

4、动作事件

/*
一、定义：动作事件与前面3种事件有所不同，它不代表某个具体的动作，只是表示一个动作发生了。例如，在关闭一个文件时，可以通过键盘关闭，也可以通过鼠标关闭。在这里读者不需要关心使用哪种方式对文件进行关闭，只要是对关闭按钮进行操作，即触发了动作事件。在Java 中，动作事件用 ActionEvent类表示，处理 ActionEvent 事件的监听器对象需要实现 ActionListener接口。监听器对象在监听动作时，不会像鼠标事件一样处理鼠标的移动和单击的细节，而是去处理类似手“按钮按下”这样“有意义”的事件。关于动作事件的案例在事件处理机制中讲过，再次不在赘述。ActionEvent事件和ItemEvent时间的区别
*/

5、Swing中的绘图

/*
1、  很多GUI程序都需要在组件上绘制图形，比如实现一个五子棋的小游戏，就需要在组件上绘制棋盘和棋子。在java.awt包中专门提供了一个Graphics类，它相当于一个抽象的画笔，其中提供了各种绘制图形的方法，使用Graphics类的方法就可以完成在组件上绘制图形2、Graphice类，绘制各种图形的类1、常用的方法：1. void setColor(Color c)将此图形上下文的当前颜色设置为指定颜色2. void setFont(Font f)将此图形上下文的字体设置为指定字体3. void drawLine(int x1,int y1 ,int x2,int y2)以(×1,y1)和(×2,y2)为端点绘制一条线段4. void drawRect(int x, int y, int width, int height)绘制指定矩形的边框。矩形的左边缘和右边缘分别位于×和x+width。上边缘和下边缘分别位于y和y + height5. void drawRect(int x, int y, int width, int height)绘制椭圆的边框。得到一个圆或椭圆,它刚好能放入由×、y.
width和 height参数指定的矩形中。椭圆覆盖区域的宽度为width+1像素,高度为height +1 像素6. void fillRect (int x,int y, int width, int height)用当前颜色于填充指定的矩形。该矩形左边缘和右边缘分别位于×和×+width - 1。上边缘和下边缘分别位于y和y + height - 17. void fillOval(int x,int y,int width,int height)用当前颜色填充外接指定矩形框的椭圆8. void drawString (String str, int×,int y)使用此图形上下文的当前字体和颜色绘制指定的文本 str。最左侧字符左下角位于 (x)坐标.2、方法的详细说明：1. setColor()方法用于指定上下文颜色，方法中接收一个Color类型的参数。在AWT 中，Color类代表颜色，其中定义了许多代表各种颜色的常量，例如 Color.RED，Color.BLUE等，这些常量都是Color类型的，可以直接作为参数传递给setColor()方法。2. setFont()方法用于指定上下文字体，方法中接收一个Font类型的参数。Font类表示字体，可以使用new关键字创建Font对象。Font的构造方法中接收3个参数，第一个是String类型，表示字体名称，如“宋体”“微软雅黑”等;第2个参数是int类型，表示字体的样式，参数接收Font类的3个常量Font.PLAINT、Font.ITALIC 和Font.BOLD;第3个参数为int类型，表示字体的大小。3. drawRect()方法和drawOval()方法用于绘制矩形和椭圆形的边框4. fillRect()和 fillOval()方法用于使用当前的颜色填充绘制完成的矩形和椭圆形。        5.drawString()方法用于绘制--段文本，第一个参数str表示绘制的文本内容，第2个和第3个参数×、y为绘制文本的左下角坐标。3、目前大部分的网站为了防止用户在注册时重复提交表单，在注册页面都会有一个图片验证码。接下来通过重写JPanel组件的paint()方法，在一个 JPanel面板上绘制一张图片验证码，
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.util.Random;public class Example11 {public static void main(String[] args) {final JFrame frame = new JFrame("验证码");final JPanel panel = new MyPanel();//创建Panel对象frame.add(panel);frame.setSize(200,200);//将Frame窗口居中frame.setLocationRelativeTo(null);frame.setVisible(true);}
}
class MyPanel extends JPanel{public void paint(Graphics g){int width = 160;//验证码的图片的宽度int height = 40;//高度g.setColor(Color.LIGHT_GRAY);//设置上下文颜色g.fillRect(0,0,width,height);//填充验证码背景g.setColor(Color.BLACK);g.drawRect(0,0,width -1, height - 1);//绘制边框//绘制干扰点Random r = new Random();for(int i = 0; i < 4; i++){int x = r.nextInt(width) - 2;int y = r.nextInt(height) - 2;g.drawOval(x,y,2,2);}g.setFont(new Font("黑体",Font.BOLD,30));//验证码字体g.setColor(Color.BLUE);//随机产生验证码char[] chars= ("0123456789abcdefghijkmnopqrstuvwxyzABCDEFG"+ "HIJKLMNPQRSTUVwXYz").toCharArray();StringBuilder sb = new StringBuilder();for (int i =0;i<4; i++){int pos = r.nextInt (chars. length);char c= chars[pos];sb. append(c +"");}g.drawString(sb.toString(),20,30);//写入验证码}
}

6、Swing常用组件(中间容器)

1、面板组件

/*
一、概念：Swing组件中不仅具有JFrame和 JDialog这样的顶级窗口，还提供了一些中间容器，这些容器不能单独存在，只能放置在顶级窗口中。其中最常见的中间容器有两种——JPanel和JScrollPane，接下来分别来介绍这两种容器。①JPanel:JPanel和AWT中的 Panel组件使用方法基本一致，它是一个无边框，不能被移动、放大、缩小或者关闭的面板，它的默认布局管理器是 FlowLayout。当然也可以使用JPanel带参数的构造函数JPanel(LayoutManager layout)或者它的setLayout()方法为其制定布局管理器。2、JScrollPane:与JPanel 不同的是，JScrollPane是一个带有滚动条的面板容器，而且这个面板只能添加一-个组件。如果想在JScrollPane面板中添加多个组件，应该先将组件添加到JPanel中，然后将JPanel添加到JScrollPane 中。二、常见的构造方法：1. JScrollPane()创建一个空的JScrollPane面板2. JScrollPane(Component view)创建一个显示指定组件的JScrolPane面板，只要组件的内容超过视图大小就会显示水平和垂直滚动条3. JScrollPane(Component view,int vsbPolicy,int hsbPolicy)创建一个显示指定容器并具有指定滚动条策略的JScrollPane。参数vsbPolicy和hsbPolicy 分别表示垂直滚动条策略和水平滚动条策略，应指定为ScrollPaneConstants的静态常量,如下所示。HORIZONTAL_SCROLLBAR_AS_NEEDED:表示水平滚动条只在需要时显示，是默认策略HORIZONTAL_SCROLLBAR_NEVER:表示水平滚动条永远不显示         HORIZONTAL_SCROLLBAR_ALWAYS:表示水平滚动条一直显示
三、上面列出了JScrollPane 的3个构造方法。其中，第一个构造方法用于创建一个空的JScrollPane面板，第2个构造方法用于创建显示指定组件的JScrollPane面板，这两个方法都比较简单。第3个构造方法是在第2个构造方法的基础上指定滚动条策略。如果在构造方法中没用指定显示组件和滚动条策略,也可以使用JScrolPane提供的方法进行设置，四、常见的方法：1. void setHorizontalBarPolicy(int policy)指定水平滚动条策略,即水平滚动条何时显示在滚动面板上2. void setVerticalBarPolicy(int policy)指定垂直滚动条策略,即垂直滚动条何时显示在滚动面板上3. void setViewportView(Component view)设置在滚动面板显示的组件五、上述介绍的的方法JScrollpane面板策略的设置方法，ScrollPaneConstants接口声明了很多常量属性1.VERTICAL_SCROLLBAR_AS_NEEDED HORIZONTAL_SCROLLBAR_AS_NEEDED 以上两个常量：当填充的组件超过客户端窗口大小时，自动显示水平和竖直滚动条2. VERTICAL_SCROLLBAR_NEVER HORIZONTAL_SCROLLBAR_NEVER 无论填充的组件视图大小如何，始终显示水平和竖直滚动条3. VERTICAL_SCROLLBAR_ALWAYS HORIZONTAL_SCROLLBAR_ALWAYS 无论填充的组件试图大小如何，始终不显示水平和竖直滚动条4、调用方式：ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED 五、下面通过一个案例来向中间容器添加按钮
*/package cn.kong.GUL;import javax.swing.*;
import java.awt.*;public class Example12 {public static void main(String[] args) {//使用SwingUtilities.invokeLater工具类调用createAndShowGUI方法，并显示GUI程序SwingUtilities.invokeLater(Example12::createAndShowGUI) ;}private static void createAndShowGUI() {JFrame f = new JFrame("PanelDemo");f.setLayout(new BorderLayout());f.setSize(300,200);f.setLocation(300,200);f.setVisible(true);f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//创建Jscorllpane滚动面板组件JScrollPane scrollPane = new JScrollPane();//设置水平滚动条策略--滚动条一直显示scrollPane.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);//设置垂直滚动条策略--滚动条需要时显示scrollPane.setVerticalScrollBarPolicy (ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);//定义TJPanel 面板JPanel panel = new JPanel();//在JPanel面板中添加四个按钮panel.add(new JButton("按钮1"));panel.add(new JButton("按钮2"));panel.add (new JButton("按钮3"));panel.add (new JButton("按钮4"));//设置JPane1面板在滚动面板中显示scrollPane.setViewportView (panel);//将滚动面板添加到内容面板的CENTER区域f.add(scrollPane, BorderLayout.CENTER);}
}

2、文本组件

/*
一、定义：文本组件用于接收用户输入的信息或向用户展示信息，其中包括文本框（JtextField ) 、文本域(JtextArea )等，它们都有一个共同父类JTextComponent。JTextComponent 是一个抽象类，它提供了文本组件常用的方法，如JTextComponent抽象类提供的方法1. String getText()返回文本组件中所有的文本内容2. String getSelectedText()返回文本组件中选定的文本内容3. void selectAil()在文本组件中选中所有内容4. void setEditable()设置文本组件为可编辑或者不可编辑状态5. void setText(String text)设置文本组件的内容6. void replaceSelection(String content)用给定的内容替换当前选定的内容总结：以上是几种对文本组件进行操作的方法，其中包括选中文本内容、设置文本内容以及获取文本内容等。由于JTextField和JTextArea这两个文本组件都继承了JTextComponent飞，因此它们都具有以上的方法，但它们在使用上还有一定的区别。接下来就对这两个文本组件进行详细讲解。二、JTextField:JTextField:JTextField称为文本框，它只能接收单行文本的输入。    1. JTextField 常用的构造方法。1.  JTextField()创建一个空的文本框,初始字符串为null2. JTextField(int columns)创建一个典有指定列数的文本框初始字符串为null3. JTextField(String text)创建一个显示指定初始字符串的文本框4. JTextField(String text, int column)创建一个具有指定列数并显示指定初始字符串的文本框一个子类：JPasswordTextJTextField 有一个子类JPasswordText，它表示一个密码框，只能接收用户的单行输入，但是在此框中不显示用户输入的真实信息，而是通过显示指定的回显字符作为占位符。新创建的密码框默认地回显字符为“*”。JPasswordText和JTextField 的构造方法相似，这里就不再介绍了。三、JTextAreaJTextArea:JTextArea称为文本域，它能接收多行的文本的输入，使用JTextArea构造方法创建对象时可以设定区域的行数、列数。接下来介绍一下JTextArea常用的构造方法，1. JTextArea()创建一个空的文本域2. JTextArea(String text)创建显示指定初始字符串的文本域3. JTextArea(int rows,int columns)创建具有指定行和列的空的文本域4. JTextArea(String text, int rows,int columns)创建显示指定初始文本并指定了行列的文本域
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;public class Example13  extends JFrame{public static void main(String[] args) {new Example13();}JButton sendBt;JTextField inputField;JTextArea chatContent;public Example13(){this.setLayout(new BorderLayout());chatContent = new JTextArea(12,34);//创建一个文本域//创建一个滚动面板，将文本域作为其显示按钮JScrollPane showPanel = new JScrollPane(chatContent);chatContent.setEditable(false);//设置文本域不可编辑JPanel inputPanel = new JPanel();//创建一个JPanel面板inputField = new JTextField(20);//创建一个文本框sendBt = new JButton("发送");//创建一个发送按钮//为按钮添加事件sendBt.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {String content = inputField.getText();//获取输入文本信息//判断输入信息是否为空if(content != null && !content.trim().equals("")){chatContent.append("本人：" + content + "\n");}else{chatContent.append("聊天信息不能为空" + "\n");}inputField.setText("");//将输入文本域的内容设置为空}});Label label = new Label("chating");inputPanel.add(label);//将标签添加到JPanel面板inputPanel.add(inputField);//将文本框添加到JPanel面板inputPanel.add(sendBt);//将按钮添加到JPanel面板//将滚动面板和JPanel面板添加到JFrame创口this.add(showPanel,BorderLayout.CENTER);this.add(inputPanel,BorderLayout.SOUTH);this.setSize(400,300);this.setTitle("聊天窗口");this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setVisible(true);}
}

3、标签组件&图标组件

/*
一、定义：JLabel组件可以显示文本，图象，还可以设置标签内容的垂直和水平对齐方式。二、常用构造方法：1. JLabel() 创建一个没有图像的 JLabel实例，标题为空字符串。2. JLabel(Icon image) 使用指定的图像创建一个 JLabel实例。3. JLabel(Icon image, int horizontalAlignment) 创建一个具有指定图像和水平对齐的 JLabel实例。4. JLabel(String text)使用指定的文本创建一个 JLabel实例。 5. JLabel(String text, Icon icon, int horizontalAlignment)创建具有 JLabel文本，图像和水平对齐的JLabel实例。 6. JLabel(String text, int horizontalAlignment) 创建一个具有指定文本和水平对齐的 JLabel实例。二、图标组件public class ImageIcon从图像绘制图标的图标界面的实现。 使用MediaTracker预先从URL，文件名或字节数组创建的图像，以监视图像的加载状态。1. 常用构造方法1. ImageIcon()创建未初始化的图像图标。 2， ImageIcon(String filename) 从指定的文件创建一个ImageIcon。 3. ImageIcon(Image image) 从图像对象创建一个ImageIcon。2.常用的方法：1. int getIconHeight() 获取图标的高度。2. int getIconWidth() 获取图标的宽度。 3. Image getImage()返回此图标的 Image 4. void setImage(Image image)设置此图标显示的图像。  
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;public class Example14 {public static void main(String[] args) {//使用SwingUtilities.invokeLater工具类调用createAndShowGUI方法，并显示GUI程序SwingUtilities.invokeLater(Example14::createAndShowGUI) ;}private static void createAndShowGUI() {JFrame f = new JFrame("PanelDemo");f.setLayout(new BorderLayout());f.setSize(300,200);f.setLocation(300,200);f.setVisible(true);f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//创建一个JLabel标签组件,用来显示图片JLabel label1 = new JLabel();//创建一个ImageIcon图表组件，并加入到JLabel中filename跟的是图片的路径ImageIcon icon = new ImageIcon("C:\\Users\\28929\\Pictures\\pic\\动漫\\FruitStore.jpg");Image img = icon.getImage();//返回此图标的Image//设置图片的大小img = img.getScaledInstance(300,150,Image.SCALE_DEFAULT);icon.setImage(img);//设置此图标的显示图象label1.setIcon(icon);//创建一个页尾JPanel面板，并加入到JLabel标签组件JPanel panel = new JPanel();JLabel label2 = new JLabel("Welcome to here",JLabel.CENTER);panel.add(label2);//向JFrame顶部和尾部分别加入JLabel和JPanel组件f.add(label1,BorderLayout.PAGE_START);f.add(panel,BorderLayout.PAGE_END);}
}

4、按钮组件

/*
一：定义：在 Swing 中，常见的按钮组件有JButton、JCheckBox、JRadioButton等，它们都是抽象类AbstractButton类的直接或间接子类。在 AbstractButton类中提供了按钮组件通用的一些方法，AbstractButton类常用方法：1. lcon getlcon()和void setlcon(Icon icon)设置或者获取按钮的图标2. String getText()和void setText(String text)设置或者获取按钮的文本3. setSelected(boolean b)设置按钮的状态，当b为true时，按钮是选中状态，反之为未选中4. void setEnable(boolean b)启用（当b 为true）或禁用〔当b为false)按钮5. boolean isSelected(返回按钮的状态（ true为选中，反之为未选中)
二、子类中的JButtona按钮1.常用构造方法1. JButton() 创建一个没有设置文本或图标的按钮。2. JButton(Icon icon)创建一个带有图标的按钮。3. JButton(String text)创建一个带文本的按钮。 4.JButton(String text, Icon icon)创建一个带有初始文本和图标的按钮。 三、JCheckBox（复选框按钮）1.常用构造方法1. JCheckBox() 创建一个最初未选择的复选框按钮，没有文字，没有图标。2. JCheckBox(String text) 创建一个最初未选择的复选框与文本。 3. JCheckBox(String text, boolean selected)创建一个带有文本的复选框，并指定是否最初选择它。2，解释：JCheckBox组件被称为复选框，它有选中（是）/未选中（非）两种状态，如果用户想接收的输入只有“是”和“非”，则可以通过复选框来切换状态。如果复选框有多个，则用户可以选中其中一个或者多个。四、JRadionButton(单选按钮)1.概念：JRadioButton组件被称为单选按钮，与JCheckBox复选框不同的是，单选按钮只能选中--个。就像随身听上的播放和快进按钮，当按下一个，先前按下的按钮就会自动弹起。对于JRadioButton按钮来说，当一个按钮被选中时，先前被选中的按钮就会自动取消选中。由于JRadioButton组件本身并不具备这种功能，因此若想实现JRadioButton 按钮之间的互斥，需要使用javax.swing.ButtonGroup类，它是一个不可见的组件，不需要将其增加到容器中显示，只是在逻辑上表示-个单选按钮组。将多个JRadioButton 按钮添加到同一个单选按钮组对象中，就能实现按钮的单选功能。2. 常见的构造方法1. JRadioButton() 创建一个没有设置文本的最初未选择的单选按钮2. JRadioButton(Icon icon, boolean selected) 创建具有指定图像和选择状态的单选按钮，但不包含文本。3、 JRadioButton(String text) 使用指定的文本创建一个未选择的单选按钮。4. JRadioButton(String text, boolean selected) 创建具有指定文本和选择状态的单选按钮。
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;public class Example15 extends JFrame {private JCheckBox italic;private JCheckBox bold;private JLabel label;public static void main(String[] args) {new Example15();}public Example15(){//创建一个 JLabel标签，标签文本居中对齐label = new JLabel("传智播客欢迎你!",JLabel.CENTER);//设置标签文本的字体label.setFont (new Font("宋体", Font.PLAIN,20));this.add(label);//在CENTER域添加标签JPanel panel = new JPanel();//创建一个JPanel面板// 创建两个JCheckBox复选框italic = new JCheckBox("ITALIC");bold = new JCheckBox("BOLD");//为复选框定义ActionListener监听器ActionListener listener = new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {int mode = 0;if(bold.isSelected()){mode += Font.BOLD;}if(italic.isSelected()){mode += Font.ITALIC;label.setFont(new Font("宋体",mode,20));}}};//文两个复选框增加监听器italic.addActionListener(listener);bold.addActionListener(listener);//在JPanel面板中添加复选框panel.add(italic);panel.add(bold);//在south域中添加JPanel面板this.add(panel,BorderLayout.SOUTH);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setSize(300,300);this.setVisible(true);}
}//按例2
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.awt.event.ActionListener;public class Example16 extends JFrame {private ButtonGroup group;//单选按钮组对象private JPanel panel;//JPanel面板放置3个JRadioButton按钮private JPanel pallet;//JPanel面板作为调色public static void main(String[] args) {new Example16();}public Example16(){pallet = new JPanel();this.add(pallet,BorderLayout.CENTER);panel = new JPanel();group = new ButtonGroup();//调用addJRadioButton方法addJRadioButton("灰");addJRadioButton("粉");addJRadioButton("黄");this.add(panel,BorderLayout.SOUTH);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setSize(300,300);this.setVisible(true);}private void addJRadioButton(final String text) {JRadioButton radioButton = new JRadioButton(text);group.add(radioButton);panel.add(radioButton);radioButton.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {Color color = null;if("灰".equals(text)){color = Color.GRAY;}else if("粉".equals(text)){color = Color.PINK;}else if("黄".equals(text)){color = Color.YELLOW;}else{color = Color.WHITE;}pallet.setBackground(color);}});}
}

5、下拉框组件

/*
一、定义：JComboBox组件被称为组合框或者下拉列表框，它将所有选项折叠收藏在一起，默认显示的是第一个添加的选项。当用户单击组合框时，会出现下拉式的选择列表，用户可以从中选择其中一项并显示。JComboBox组合框组件分为可编辑和不可编辑两种形式，对于不可编辑的组合框，用户只能在现有的选项列表中进行选择;而对于可编辑的组合框，用户既可以在现有的选项中选择，也可以自己输入新的内容。需要注意的是，自己输入的内容只能作为当前项显示，并不会添加到组合框的选项列表中。二、构造方法：1. JComboBox()创建一个没有可选项的组合框2. JComboBox(Object[] items)创建一个组合框，将Object数组中的元素作为组合框的下拉列表选项3. JComboBox(Vector items)创建一个组合框，将Vector集合中的元素作为组合框的下拉列表选项
三、常用方法1. void addItem （Object anObject)为组合框添加选项2. void insertItemAt(Object anObject,int index)在指定的索引处插入选项3. Objct getItemAt(int index)返回指定索引处选项,第一个选项的索引为04. int getItemCount()返回组合框中选项的数目5. Object getSelectedItem()返回当前所选项6. void removeAllItems()删除组合框中所有的选项7. void removeItem(Object object)从组合框中删除指定选项 8. void removeItemAt(int index)移除指定索引处的选项9. void setEditable(boolean aFlag)设置组合框的选项是否可编辑，aFlag为true 则可编辑,反之则不可编辑
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;public class Example17 extends JFrame {private JComboBox comboBox;//定义一个JComboBox组合框private JTextField field;//定义一个JTextField文本框public static void main(String[] args) {new Example17();}public Example17(){JPanel panel = new JPanel();//创建一个JPanel面板comboBox = new JComboBox();//为组合框添加选项comboBox.addItem("请选择城市");comboBox.addItem("北京");comboBox.addItem("天津");comboBox.addItem("南京");comboBox.addItem("上海");comboBox.addItem("重庆");//为组合和框添加监听器comboBox.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {String item = (String)comboBox.getSelectedItem();if("请选择城市".equals(item)){field.setText("");}else{field.setText("你选择的城市是："+ item);}}});field = new JTextField(20);panel.add(comboBox);//在面板中添加组合框panel.add(field);//在面板中添加文本框//在内容面板中添加JPanel面板this.add(panel,BorderLayout.NORTH);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setSize(350,100);this.setVisible(true);}
}

6、菜单组件

1、下拉式菜单

/*
一、定义：对于下拉式菜单，读者肯定很熟悉，因为计算机中很多文件的菜单都是下拉式的，如记事本的菜单。在GUI程序中，创建下拉式菜单需要使用3个组件;JmenuBar(菜单栏).Jmenu（菜单）和Jmenultem（菜单项)二、分类( 1 ) JMenuBar:JMenuBar 表示一个水平的菜单栏，它用来管理菜单，不参与同用户的交互式操作。菜单栏可以放在容器的任何位置,但通常情况下会使用顶级窗口(如 JFrame, Jdialog )的setJMenuBar (JMenuBar menuBar)方法将它放置在顶级窗口的顶部。JMenuBar有一个无参构造函数，创建菜单栏时，只需要使用new关键字创建JMenuBar对象即可。创建完菜单栏对象后，可以调用它的add(JMenu c)方法为其添加JMenu菜单。(2 ) JMenu:JMenu表示一个菜单，它用来整合管理菜单项。菜单可以是单一层次的结构，也可以是多层次的结构。大多情况下，会使用构造函数JMenu(String text)创建JMenu菜单，其中的参数text表示菜单上的文本。JMenu中还有一些常用的方法,如1.  void JMenultem add( JMenultem menultem)将菜单项添加到菜单末尾，返回此菜单项2. void addSeparator()将分隔符添加到菜单的末尾3. JMenultem getltem(int pos)返回指定索引处的菜单项,第一个菜单项的索引为О4. int getltemCount()返回菜单上的项数,菜单项和分隔符都计算在内5. void JMenultem insert(JMenultem menultem,int pos)在指定索引处插入菜单项6. void insertSeparator(int pos)在指定索引处插入分隔符7. void remove(int pos)从菜单中移除指定索引处的菜单项8、 void remove(JMenultem menultem)从菜单中移除指定的菜单项9. void removeAll()从菜单中移除所有的菜单项( 3 ) JMenultem:JMenultem表示一个菜单项，它是菜单系统中最基本的组件。和JMenu菜单一样，在创建JMenultem菜单项时，通常会使用构造方法JMenumltem(String text)为菜单项指定文本内容。由于JMenultem类是继承自AbstractButton类的，因此可以把它看成是一个按钮。如果使用无参的构造方法创建了一个菜单项，则可以调用从 AbstractButton类中继承的setText(Stringtext)方法和setlcon()方法为其设置文本和图标。4、创建和添加下拉式菜单，一般分为以下几个步骤。(1）创建一个JMenuBar 菜单栏对象，将其放置在JFrame窗口的顶部。   （2）创建JMenu菜单对象，将其添加到JMenuBar 菜单栏中。(3）创建JMenultem 菜单项,将其添加到JMenu菜单中。5、一下面的例子为例本例中，在JMenu菜单中添加item1（弹出窗口）和item2(关闭）两个菜单项，并调用了JMenu的addSeparator()方法在菜单中添加了一-条分隔符。在代码第13~22行和第23~27行中分别为 item1和 item2添加了事件监听器。当单击item1菜单时，会弹出一个模态的JDialog窗口，当单击item2时会退出程序。
*/
package cn.kong.GUL;import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;public class Example18 extends JFrame {public static void main(String[] args) {new Example18();}public Example18(){JMenuBar menuBar = new JMenuBar();//创建菜单栏this.setJMenuBar(menuBar);//将菜单栏添加到JFrame窗口中JMenu menu = new JMenu("操作");//创建菜单menuBar.add(menu);//创建两个菜单项JMenuItem item1 = new JMenuItem("弹出窗口");JMenuItem item2 = new JMenuItem("关闭");//为菜单项添加事件监听器item1.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {//创建一个JDialog窗口JDialog dialog = new JDialog(Example18.this,true);dialog.setTitle("弹出窗口");dialog.setSize(200,200);dialog.setLocation(50,50);dialog.setVisible(true);}});item2.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {System.exit(0);}});menu.add(item1);//将选项增加到菜单中menu.addSeparator();//添加一个分隔符menu.add(item2);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setSize(300,300);this.setVisible(true);}
}

2、弹出式菜单

/*
一、定义：JPopupMenu弹出式菜单和下拉式菜单一样，都通过调用add()方法添加JMenultem菜单项,但它默认是不可见的。如果想要显示出来,则必须调用它的show(Component invoker,int x,inty)方法。该方法中参数invoker表示 JPopupMenur菜单显示位置的参考组件,x和y表示 invoker组件坐标空间中的一个坐标，显示的是 JPopupMenur 菜单的左上角坐标。
二、以下的方法：在菜单中右击才可以显示弹出式菜单
*/
package cn.kong.GUL;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;public class Example19 extends JFrame {public static void main(String[] args) {new Example19();}private JPopupMenu popupMenu;public Example19(){//创建一个JPopupMenu菜单popupMenu = new JPopupMenu();//创建三个JMenuItem菜单项JMenuItem refreshItem = new JMenuItem("refresh");JMenuItem createItem = new JMenuItem("create");JMenuItem exitItem = new JMenuItem("exit");//为exitItem增加监听器exitItem.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {System.exit(0);}});//往JPopupMenu菜单增加菜单项popupMenu.add(refreshItem);popupMenu.add(createItem);popupMenu.add(exitItem);//为JFrame窗口添加clicked鼠标事件监听器this.addMouseListener(new MouseListener() {@Overridepublic void mouseClicked(MouseEvent e) {//如果淡季的是鼠标右键，显示JPopupMenu菜单if(e.getButton() == e.BUTTON3){popupMenu.show(e.getComponent(),e.getX(),e.getY());}}@Overridepublic void mousePressed(MouseEvent e) {}@Overridepublic void mouseReleased(MouseEvent e) {}@Overridepublic void mouseEntered(MouseEvent e) {}@Overridepublic void mouseExited(MouseEvent e) {}});this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);this.setSize(300,300);this.setVisible(true);}
}

//下拉式弹出菜单 choice 下拉式弹出菜单类
import javax.swing.*;
import java.awt.*;public class ChoiceTest01 {public static void main(String[] args) {Choice i = new Choice();i.add("Green");i.add("Red");i.add("Black");JFrame j = new JFrame();j.add(i);j.setVisible(true);j.setLocation(300,400);j.setSize(500,600);}
}

7、表格组件

/*
一、 表格也是 GUI程序中常用的组件，表格是一个由多行、多列组成的二维显示区。Swing 的JTable 以及相关类提供了对这种表格的支持。使用了JTable以及相关类，程序既可以使用简单代码创建出表格来显示二维数据，也可以开发出功能丰富的表格，还可以为表格定制各种显示外观、编辑特性。使用JTable 来创建表格是非常容易的事情，它可以把一个二维数据包装成一个表格，这个二维数据既可以是一个二维数组，也可以是集合元素Vector对象（Vector里面包含Vector形成二维数据)。除此之外，为了给该表格的每一列指定列标题，还需要传入一个一维数据作为列标题，这个一维数据既可以是一维数组，也可以是Vector对象。二、JTable的构造函数1. JTable()建立一个新的Jtable，并使用系统默认的 Model2. JTable(int numRows,int numColumns)建立一个具有numRows 行,numColumns 列的空表格，使用的是 DefaultTableModel3. JTable(Object[][] rowData,Object[][] columnNames)建立一个显示二维数组数据的表格,且可以显示列的名称4. JTable(TableModel dm)建立一个Jtable，有默认的字段模式以及选择模式,并设置数据模式5. JTable(TableModel dm, TableColumnModel cm)建立一个Jtable，设置数据模式与字段模式,并有默认的选择模式6. JTable(TableModel dm,TableColumnModel cm,ListSelectionModel sm)建立一个Jtable，设置数据模式、字段模式与选择模式7. JTable(Vector rowData, Vector columnNames)建立一个以Vector为输入来源的数据表格,可显示行的名称三、TableModelTableModel是用来存储列表数据的，数据包括表头的标题数据与表体的实体数据。TableModel为功能接口，通常使用其具体的实现类DefaultTableModel，其构造方法如下。public DefaultTableModei(Object[][] tbody, Object[] thead)
在上述代码中，tbody表示表体，为一个二维数组;thead表示表头，为一个一维数组。其具体描述如下。·表体:是一个Object类型的二维数组，由于多态的自动类型提升，可以直接使用String[][]来存储数据。
。表头:是一个Object类型的一维数组，同样，可以直接使用String[]来存储所有的标题字符串。*/
package cn.kong.GUL;import javax.swing.*;public class Example20 {public static void main(String[] args) {new Example20().init();}//创建JFrame窗口JFrame jf = new JFrame("简单表格");//声明JTable类型的变量tableJTable table;//1.定义一位数组作为列标题Object[] columnTitle = {"姓名","年龄","性别"};//2.定义二维数组作为表格行对象数据Object[][] tableDate = {new Object[]{"李清照",29,"女"},new Object[]{"苏格拉里",56,"男"},new Object[]{"李白",35,"男"},new Object[]{"李菁",18,"女"},new Object[]{"张三",2,"男"}};//3.使用JTable对象创建表格public void init(){//以二维数组和一维数组来创建一个JTable对象table = new JTable(tableDate,columnTitle);//将JTable对象放在JScrollPane中，并将JScrollPane放在窗口中显示出来jf.add(new JScrollPane(table));//设置自适应窗体大小jf.pack();//设置单击关闭按钮是默认为退出jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);jf.setVisible(true);}
}

12、反射机制

/*
2、反射机制2.1、反射机制有什么用?通过java语言中的反射机制可以操作字节码文件。优点类似于黑客。(可以读和修改字节码文件。)通过反射机制可以操作代码片段。(class文件。）2.2、反时机制的相关类在哪个包下?java.lang.reflect.*;2.3、反射机制相关的重要的类有哪些?java.lang.class:代表整个字节码，代表一个类型，代表整个类。java.lang.reflect.Method:代表字节码中的方法字节码。代表类中的方法。java.lang.reflect.Constructor:代表字节码中的构造方法字节码。代表类中的构造方法java.lang.reflect.Field:代表字节码中的属性字节码。代表类中的成员变量（静态变量)
*/

package example05;class Yuangong{String name;int id;int salary;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public int getSalary() {return salary;}public void setSalary(int salary) {this.salary = salary;}public void print(){System.out.println("员工姓名："+name+"，员工工号："+id+"，员工薪水："+salary);}
}
class Jingli extends Yuangong{int getpay;public int getGetpay() {return getpay;}public void setGetpay(int getpay) {this.getpay = getpay;}public void print(){System.out.println("经理姓名："+name+"，经理工号："+id+"，经理薪水："+salary+"，经理奖金："+getpay);}
}
public class MjTest2{public static void main(String arg[]){Yuangong A = new Yuangong();Jingli B = new Jingli();A.setName("张三");A.setId(20212001);A.setSalary(2000);A.print();B.setName("李四");B.setId(20211001);B.setSalary(5000);B.setGetpay(1000);B.print();}
}