ch6.Java多线程开发
6.1 进程与线程的概念
进程(Process):操作系统中能够“同时”运行的多个应用程序(QQ、浏览器、Word、WPS)。
线程(Thread):一个应用程序中,能够“同时”运行的多个任务,比如在线播放(一边下载,一边播放),很多软件都支持线程功能,如QQ可以一边接收信息、一边用户可以发送信息,抖音可以一边下载、一边播放。
两者实际上在底层是“分时”(时间片轮转),由操作系统决定。
针对Java语言,我们讲解线程。
6.2 实现线程的两种方法
6.2.1 方法一
- 让需要实现线程的类,继承java.lang.Thread类;
- 将需要实现线程的代码,放在从Thread类中重写的run函数里面;
- 开启线程,用线程对象的start方法。
class Downloader extends Thread{ //①第一步:继承Thread
public void run() { //②第二步:重写run函数
for(int i=1;i<=10;i++){
try{
Thread.sleep(1000); //休息1秒
} catch(Exception ex){}
System.out.println("下载进度:"+i*10+"%");
}
}
}
class Player extends Thread{
public void run(){
for(int i=1;i<=10;i++){
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("播放进度:"+i*10+"%");
}
}
}
class ThreadTest{
public static void main (String[] args) {
Downloader d = new Downloader();
Player p = new Player();
d.start(); p.start(); //③第三步:用start方法开启各个线程的run函数
}
}
当要在执行某个线程一段时间后执行另一个进程时,可用以下代码:
class Downloader extends Thread{ //①第一步:继承Thread
public void run() { //②第二步:重写run函数
for(int i=1;i<=10;i++){
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("下载进度:"+i*10+"%");
if(i==2){ //一个线程调用另一个线程
new Player().start();
}
}
}
}
class Player extends Thread{
public void run(){
for(int i=1;i<=10;i++){
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("播放进度:"+i*10+"%");
}
}
}
class ThreadTest{
public static void main (String[] args) {
Downloader d = new Downloader();
d.start(); //③第三步:用start方法开启各个线程的run函数
}
}
6.2.2 方法二
- 让需要实现线程的类,继承java.lang.Runnable接口;
- 将需要实现线程的代码,放在从Runnable接口中重写的run函数里面;
- 实例化线程,将类的对象传入线程的构造函数,再调用线程的start方法。
class Downloader implements Runnable{ //①第一步:实现Runnable
public void run() { //②第二步:重写run函数
for(int i=1;i<=10;i++){
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("下载进度:"+i*10+"%");
}
}
}
class Player implements Runnable{
public void run(){
for(int i=1;i<=10;i++){
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("播放进度:"+i*10+"%");
}
}
}
class ThreadTest{
public static void main (String[] args) {
Downloader d = new Downloader(); Thread th1 = new Thread(d);
Player p = new Player(); Thread th2 = new Thread(p);
th1.start(); th2.start(); //③第三步:实例化线程,将类的对象传入线程的构造函数,再调用线程的start方法
}
}
用了多线程,多个任务完成得比以前快,不是因为多线程让CPU运行更快,是让CPU的利用率提高。
6.3 线程控制
- 线程开启(start)
- 线程暂停(suspend)
- 线程继续(resume)
- 线程结束(run函数运行完毕)
【例】下载文件,下载到30%,暂停下载5秒,5秒后继续下载,编写代码实现该功能。
class Downloader extends Thread{
public void run() {
for(int i=1;i<=10;i++){
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("下载进度:"+i*10+"%");
}
}
}
class ThreadTest{
public static void main (String[] args) throws Exception {
Downloader d = new Downloader();
d.start();
Thread.sleep(3200);
d.suspend();
Thread.sleep(5000);
d.resume();
}
}
【注意】suspend、resume是不建议使用的函数,有死锁倾向。
这两个函数,特别是suspend,在暂停时不会释放线程中的资源,导致资源被该线程长期持有,别人不能使用,故可能造成循环等待。所以不建议使用。可采用以下方法:线程暂停,就让该线程结束(run函数运行完毕);线程继续,新开启一个线程(start)。
class Downloader extends Thread{
boolean RUN = true;
static int i = 1;
public void run() {
for(;i<=10&&RUN;i++){
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("下载进度:"+i*10+"%");
}
}
}
class ThreadTest{
public static void main (String[] args) throws Exception {
Downloader d = new Downloader();
d.start();
Thread.sleep(3000);
d.RUN = false;
Thread.sleep(5000);
d = new Downloader(); //新开启一个线程继续
d.start();
}
}
6.4 线程同步
- 主要出现在“多个线程访问同一内存资源的场合”,如:下载文件时,如果同时开多个线程下载文件,可以提高下载速度
- 解决同步问题:用synchronized将原子代码包含起来,保证其要么全部运行,要么全部不运行,别的线程在此之间,无法抢占CPU
这种方式。实际上,是将线程功能进行了退化,“几乎又变成串行”。
//此处不能用方法1(继承thread类),定义d1、d2对象,因为synchronized的参数this打在的是对象中(synchronized运行结束this上的标记自动消亡), 这种方法会使this标记打在了两个对象,而Runnable方法可使this打在一个对象,达到目的。
class Downloader implements Runnable{
static int i = 1; //定义静态变量,可以使类中所有对象共用
public void run() {
while(true){
synchronized(this){
if(i>10) { break; }
try{ Thread.sleep(1000); } catch(Exception ex){}
System.out.println("下载进度:"+i*10+"%");
i++;
}
}
}
}
class ThreadTest{
public static void main (String[] args) throws Exception {
Downloader d = new Downloader();
new Thread(d).start(); new Thread(d).start();
}
}
- 实际过程中,解决同步问题的方法是:人为进行资源划分(如一个线程下载前50%,另一个线程下载后50%)。
ch7.JavaIO操作
IO:输入输出。
输入设备:键盘、鼠标、扫描仪
输出设备:打印机、显示器
同时属于输入输出设备:硬盘
输入设备和输出设备是站在内存的角度划分的。
将文件从硬盘上读入,QQ收到对方信息;将文件保存到硬盘,QQ输出信息给对方。
这里重点讲解文件输入输出,对应的包是java.io。
7.1 封装文件
java.io.File:文件封装,得到文件信息,删除文件,重命名文件
[例1]用File类封装E:/test.txt.
import java.io.*;
class IOTest{
public static void main (String[] args) {
File f = new File("E:/test.txt");
f.delete();
}
}
[例2]列出D盘下面所有的文件,并显示.
import java.io.*;
class IOTest{
public static void main (String[] args) {
File f = new File("D:/");
File[] files = f.listFiles();
for(File file : files){
System.out.println(file.getPath() + ":" + file.length());
}
}
}
[例3]删除E:/testDir下面的所有文件.
import java.io.*;
class IOTest{
public static void main (String[] args) {
File f = new File("D:/testDir");
File[] files = f.listFiles();
for(File file : files){
file.delete();
}
}
}
[例4]编写一个病毒,用户运行,自动清空输入文件夹路径中所有的文件和文件夹。
package VirusTest;
import java.io.File;
public class VirusTest {
public static void FileDelete(File f) {
if(f.isDirectory())
{
File[] files = f.listFiles();
for (File file : files) {
FileDelete(file);
}
}
f.delete();
}
public static void main(String[] args) throws Exception{
String str = javax.swing.JOptionPane.showInputDialog("请输入您要删除的文件夹");
File f = new File(str);
FileDelete(f);
}
}
7.2 读文件
场景:test.txt里面有一些内容,读入到内存后,显示在屏幕上。
7.2.1 java.io.FileInputStream
FileInputStream类一个个字节读取,对中文支持不佳。文件输入输出流,打开之后,记得及时关闭
【注】字节流和字符流
字节流以字节的形式读取文件,对于有一些“双字节字符”,支持不好。为了解决该问题,Java中推出专门支持字符流的文件输入输出类。
import java.io.*;
class IOTest{
public static void main (String[] args) throws Exception{
File f = new File("test.txt");
FileInputStream fis = new FileInputStream(f);
while(true){
int i = fis.read();
if(i==-1) break;
char ch = (char)i;
System.out.print(ch);
}
fis.close();
}
}
批量读取:
import java.io.*;
class IOTest{
public static void main (String[] args) throws Exception{
File f = new File("test.txt");
FileInputStream fis = new FileInputStream(f);
byte[] data = new byte[(int)f.length()];
fis.read(data);
String s = new String(data);
System.out.println(s);
fis.close();
}
}
7.2.2 java.io.FileReader
字符读取,可一个个字符读,也可一块块读,支持字符。
7.2.3 java.io.BufferedReader
重点针对字符特别是多字节字符讲解的不是FileReader,最常见使用的是“按行读”的另一个类:java.io.BufferedReader。如果对字符串进行读取,最佳办法是用:BufferedReader。它支持按行读字符串,和FileReader配套。
import java.io.*;
class IOTest{
public static void main (String[] args) throws Exception{
File f = new File("test.txt");
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
while(true){
String s = br.readLine();
if(s==null) break;
System.out.println(s);
}
fr.close();
}
}
字节流读取(FileInputStream)和字符流读取(FileReader/BufferedReader)进行比较,FileInputStream(适合图像、视频、语音、文本都支持),而字符流读取一般只适合字符和字符串。
【总结】
- java.io.FileInputStream:字节读取,可一个个字节读,也可一块块读,使用最广
- java.io.FileReader:字符读取,可一个个字符读,也可一块块读,支持字符
- java.io.BufferedReader:支持按行读字符串,和FileReader配套
7.3 写文件
场景:定义一个变量,保存到test.txt中。
- java.io.FileOutputStream:字节流输出
注意:向文件保存数据时,有两种模式:1)在文件末尾添加; 2)覆盖原有内容,用append参数确定。
import java.io.*;
class IOTest{
public static void main (String[] args) throws Exception{
File f = new File("test.txt");
FileOutputStream fos = new FileOutputStream(f, false); //append参数为false,覆盖原有内容
String str = "CSU中南大学";
fos.write(str.getBytes()); //getBytes函数转为字节数组,然后写入文件
fos.close();
}
}
- java.io.FileWriter:字符流输出
- java.io.PrintStream:支持丰富的格式对字符串进行输出,字符串万能输出,和FileOutputStream配套
[例1]将一个99乘法表保存到test.txt中。
import java.io.*;
class IOTest{
public static void main (String[] args) throws Exception{
File f = new File("test.txt");
FileOutputStream fos = new FileOutputStream(f, false);
PrintStream ps = new PrintStream(fos);
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
ps.print(i + "*" + j + "=" + i*j + " ");
}
ps.println();
}
fos.close();
}
}
[例2]将一个图像加密,加密方法:每个字节的值+3。
import java.io.*;
class IOTest{
public static void main (String[] args) throws Exception{
File f1 = new File("img1.jpg");
File f2 = new File("img2.jpg");
FileInputStream fis = new FileInputStream(f1);
FileOutputStream fos = new FileOutputStream(f2);
while(true){
int i = fis.read();
if(i==-1) break;
i+=3;
fos.write(i);
}
fos.close();
fis.close();
}
}
另外,RandomAccessFile类可以提供文件的随机访问,既支持文件读,又支持文件写。
ch8.Java界面开发与事件处理
本章讲述Java开发桌面应用程序,包括用Swing开发GUI程序、Java事件处理与Java绘图。
Swing:Java中的一个包,负责开发GUI程序
GUI:图形用户界面,一般指可视化桌面系统中的应用程序。
Windows:将应用程序从字符界面拓展到图形界面。
常见图形用户界面的基本结构:
-
界面(容器窗口)
-
控件(界面上的组件,如按钮、文本框等)
-
渲染(颜色、字体等)
-
事件响应(完成功能)
界面、控件、渲染中的图标使用的包:javax.swing包【注:javax的x:eXtension(扩展)】
渲染(颜色:Color、字体:Font)使用的包:java.awt包。
8.1 界面
又称容器、窗口,提供整个界面的空间。
- 框架界面: javax.swing.JFrame
- 窗口界面: javax.swing.JWindow
- 对话框界面: javax.swing.JDialog
一般掌握第(1)种即可。
显示:setVisible函数
[例]在桌面出现一个界面,标题是:HelloWorld
用框架界面:
import javax.swing.JFrame;
class GUI1{
public static void main(String[] args) throws Exception {
JFrame jfm = new JFrame("HelloWorld");
jfm.setSize(600,400);
jfm.setLocation(300,200);
jfm.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //退出框架界面
jfm.setVisible(true);
}
}
通过构造函数进行初始化:
import javax.swing.JFrame;
class GUI extends JFrame{
public GUI(){
super("HelloWorld"); //调用父类的构造函数
this.setSize(600,400);
this.setLocation(300,200);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) throws Exception {
new GUI();
}
}
8.2 控件
界面上的组件,如按钮、文本框、复选框等。
注意:Java中,容器还有:面板 javax.swing.JPanel
一般我们在界面上添加一个面板,面板上增加控件。
- 按钮:javax.swing.JButton
- 静态文本:javax.swing.JLabel
- 文本框:javax.swing.JTextField
- 密码框:javax.swing.JPasswordField
- 多行文本框:javax.swing.JTextArea
- 下拉菜单:javax.swing.JComboBox
- 复选框:javax.swing.JCheckBox
举一反三:
- 知道一个控件,用哪个类?
- 查文档看构造函数和其他重要函数
- 将控件实例化后加到容器中
import javax.swing.*;
class GUI extends JFrame{
private JLabel jlb = new JLabel("——————欢迎来到中南大学社团学生注册系统——————");
private JButton jbt = new JButton("学生注册");
private JLabel jlbAcc = new JLabel("请您输入账号");
private JTextField jtfAcc = new JTextField(20);
private JLabel jlbAdd = new JLabel("请您选择您的家乡");
private JComboBox jcbAdd = new JComboBox();
private JCheckBox jcbMember = new JCheckBox("是否立即成为会员",true);
private JLabel jlbInfo = new JLabel("请您输入个人详细描述");
private JTextArea jtaInfo = new JTextArea(20,30);
private JPanel jpl = new JPanel();
public GUI(){
jpl.add(jlb); jpl.add(jbt); jpl.add(jlbAcc); jpl.add(jtfAcc);
jpl.add(jlbAdd); jpl.add(jcbAdd); jpl.add(jlbInfo); jpl.add(jtaInfo);
jcbAdd.addItem("湖南"); jcbAdd.addItem("湖北");
jcbAdd.addItem("河南"); jcbAdd.addItem("河北");
jpl.add(jcbMember);
this.add(jpl);
this.setSize(400,600);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) throws Exception {
new GUI();
}
}
8.3 渲染
-
包含颜色、字体(java.awt)、图标(javax.swing)三部分
-
任何界面和控件都可以设置背景颜色和前景颜色
setBackground(颜色) setForeground(颜色) (文档可查)
凡是有字的控件,都有setFont函数(文档可查)
-
颜色:java.awt.Color
-
字体:java.awt.Font
import javax.swing.*; import java.awt.*; class GUI extends JFrame{ private JButton jbt = new JButton("学生注册"); private JPanel jpl = new JPanel(); public GUI(){ jpl.setBackground(new Color(0,255,255)); jbt.setBackground(Color.blue); jbt.setForeground(Color.yellow); Font f = new Font("微软雅黑",Font.BOLD,50); jbt.setFont(f); jpl.add(jbt); this.add(jpl); this.setSize(400,600); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE ); this.setVisible(true); } public static void main(String[] args) throws Exception { new GUI(); } }
-
图标:很多控件都可以设置图标,如按钮、静态文本等。但不是所有,比如文本框就不能。具体看文档。用的函数:setIcon函数
注意:Icon和ImageIcon在swing中。
主要方法有:
控件.setBackground和setForeground(颜色)
控件.setFont(字体)
控件.setIcon(图标)
【例】将按钮设置为图标形式。
import javax.swing.*; import java.awt.*; class GUI extends JFrame{ private JButton jbt = new JButton(); private JPanel jpl = new JPanel(); public GUI(){ ImageIcon icon = new ImageIcon("img.jpg"); jbt.setIcon(icon); jbt.setText("这是一个按钮"); jpl.add(jbt); this.add(jpl); this.setSize(600,800); this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE ); this.setVisible(true); } public static void main(String[] args) throws Exception { new GUI(); } }
8.4 界面布局管理
布局:将控件有序的放在界面上,使用java.awt包。
8.4.1 FlowLayout
JPanel默认的布局方式是:流式布局(FlowLayout),优先放在1行,放不下,到后面1行。该布局方式由java.awt.FlowLayout来管理;
任何容器管理类都有setLayout函数设置布局。
[例]将一个按钮,一个文本框放在界面上。
import javax.swing.*;
import java.awt.*;
class Layout1 extends JFrame{
private JTextField jtf = new JTextField(20);
private JButton jbt = new JButton("按钮");
private JPanel jpl = new JPanel();
public Layout1(){
FlowLayout fl = new FlowLayout(FlowLayout.LEFT,20,20);
jpl.setLayout(fl);
this.add(jpl); jpl.add(jtf); jpl.add(jbt);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) throws Exception {
new Layout1();
}
}
8.4.2 GridLayout
网格布局,将界面设置为多行多列的格子,放置控件。该布局方式由java.awt.GridLayout来管理。
[例1]放置24个按钮在界面上。
import javax.swing.*;
import java.awt.*;
class Layout1 extends JFrame{
private JPanel jpl = new JPanel();
public Layout1(){
GridLayout gl = new GridLayout(6,4);
jpl.setLayout(gl);
this.add(jpl);
for(int i=1;i<=24;i++){
jpl.add(new JButton(String.valueOf(i)));
}
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) throws Exception {
new Layout1();
}
}
[例2]制作一个8*8国际象棋棋盘。
import javax.swing.*;
import java.awt.*;
class Layout1 extends JFrame{
private JPanel jpl = new JPanel();
public Layout1(){
GridLayout gl = new GridLayout(8,8);
jpl.setLayout(gl);
this.add(jpl);
for(int i=1;i<=8;i++){
for(int j=1;j<=8;j++){
JPanel pl = new JPanel();
if((i+j)%2==0) {pl.setBackground(Color.white);}
else { pl.setBackground(Color.black);}
jpl.add(pl);
}
}
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) throws Exception {
new Layout1();
}
}
8.4.3 BorderLayout
边界布局:将界面分为东西南北中,添加控件。该布局方式由java.awt.BorderLayout来管理。
JFrame的默认布局方式是BorderLayout。
import javax.swing.*;
import java.awt.*;
class Layout1 extends JFrame{
private JPanel jpl = new JPanel();
public Layout1(){
BorderLayout bl = new BorderLayout();
jpl.setLayout(bl);
this.add(jpl);
jpl.add(new JButton("按钮"),BorderLayout.SOUTH);
jpl.add(new JTextField(),BorderLayout.NORTH);
jpl.add(new JTextArea(),BorderLayout.CENTER);
jpl.add(new JButton("按钮"),BorderLayout.WEST);
jpl.add(new JButton("按钮"),BorderLayout.EAST);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) throws Exception {
new Layout1();
}
}
[注]教科书中有关于计算器的编制程序。
8.4.4 完全自由布局
在完全自由布局中,控件的位置,大小,用坐标决定,而不是由界面大小决定。实际上是:设置容器布局为null,然后通过setSize设置大小,setLocation设置位置。
部分情况不适用该布局方式的原因:坐标体系在不同的操作系统不能保证相同。
[例1]设置一个按钮,从界面上方以抛物线的形式掉下来。
import javax.swing.*;
import java.awt.*;
class Layout1 extends JFrame implements Runnable{
private JButton jbt = new JButton();
int X,Y = 0;
public Layout1(){
jbt.setIcon(new ImageIcon("img.jpg"));
this.setLayout(null);
jbt.setSize(80,60);
this.add(jbt);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
Thread th = new Thread(this);
th.start();
}
public void run(){
while(true){
try{Thread.sleep(20) ;} catch(Exception e){}
X++; Y=X*X/100;
jbt.setLocation(X,Y);
}
}
public static void main(String[] args) throws Exception {
new Layout1();
}
}
[例2]小球自由落体掉下,弹起来,再次自由落体。
import javax.swing.*;
import java.awt.*;
class Layout1 extends JFrame implements Runnable{
private JButton jbt = new JButton();
int Y = 0;
int DIR = 1;
public Layout1(){
Icon icon = new ImageIcon("img.jpg");
jbt.setIcon(icon);
this.setLayout(null);
jbt.setSize(icon.getIconWidth(),icon.getIconHeight());
this.add(jbt);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
Thread th = new Thread(this);
th.start();
}
public void run(){
while(true){
try{Thread.sleep(20);} catch(Exception e){}
if(DIR==1) { Y+=2; if(Y>=(this.getHeight()-jbt.getHeight())) DIR=0; }
else if(DIR==0) { Y--; if(Y<=0) DIR=1; }
jbt.setLocation(60,Y);
}
}
public static void main(String[] args) throws Exception {
new Layout1();
}
}
8.5 事件监听机制
Java事件处理在java.awt.event包中。
事件:程序对某些操作的响应。
点击按钮,打印“Hello”的三个步骤是:(其余都类似)
- 事件响应类必须能够听到相应的命令(加一个耳朵)
点击按钮如果要响应,必须让响应类实现java.awt.event.ActionListener接口 - 将事件响应的代码,放在接口中重写的函数内
- 绑定,确保按钮发出命令,响应对象能够执行
①实现接口(监听器)、②编写函数、③绑定,叫做事件监听机制。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class Printer implements ActionListener{ //①实现接口
public void actionPerformed(ActionEvent e){ //②事件响应代码
System.out.println("Hello");
}
}
class EventTest extends JFrame{
private JButton jbt = new JButton("按钮");
public EventTest(){
Printer p = new Printer();
jbt.addActionListener(p); //③绑定,确保按钮发出命令,p能够执行
this.add(jbt,BorderLayout.NORTH);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new EventTest();
}
}
更加简洁的方法是:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements ActionListener{
private JButton jbt = new JButton("按钮");
public EventTest(){
jbt.addActionListener(this);
this.add(jbt,BorderLayout.NORTH);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public void actionPerformed(ActionEvent e){
System.out.println("Hello");
}
public static void main(String[] args){
new EventTest();
}
}
Java中定义,不同的事件,由不同的XXXListener来监听。
事件响应函数中,ActionEvent参数表示命令发出时,封装的命令发出方的信息。
[例]实现两个按钮,一个按钮点击,界面变红,另一个点击,界面变蓝。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements ActionListener{
private JButton jbt1 = new JButton("变红");
private JButton jbt2 = new JButton("变蓝");
private JPanel jpl = new JPanel();
public EventTest(){
this.add(jbt1,BorderLayout.NORTH);
this.add(jbt2,BorderLayout.SOUTH);
this.add(jpl,BorderLayout.CENTER);
jbt1.addActionListener(this);
jbt2.addActionListener(this);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public void actionPerformed(ActionEvent e){
if(e.getSource()==jbt1){ //getSource()函数可以得知事件的源头
jpl.setBackground(Color.red);
}else{
jpl.setBackground(Color.blue);
}
}
public static void main(String[] args) {
new EventTest();
}
}
8.6 常见监听事件处理
下列Listener,分别监听以下事件:
-
ActionListener:监听按钮点击,文本框内回车,菜单单击、其他支持单击响应的控件,以及一些拥有addActionListener函数的控件
-
ItemListener:监听选项变化时要响应的事件,如下拉菜单等
下拉菜单中有红绿蓝三个选项,选择时,界面自动变色
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements ItemListener {
private JComboBox jcb = new JComboBox();
private JPanel jpl = new JPanel();
public void itemStateChanged(ItemEvent e){
if(jcb.getSelectedItem().equals("红")){
jpl.setBackground(Color.red);
}else if(jcb.getSelectedItem().equals("绿")){
jpl.setBackground(Color.green);
}else{
jpl.setBackground(Color.blue);
}
}
public EventTest(){
this.add(jcb,BorderLayout.NORTH);
this.add(jpl,BorderLayout.CENTER);
jcb.addItemListener(this);
jcb.addItem("红"); jcb.addItem("绿"); jcb.addItem("蓝");
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new EventTest();
}
}
- MouseListener:监听鼠标操作(单击,双击,进入,离开等)
[例1]鼠标进入按钮,按钮变红,退出,按钮变白。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements MouseListener{
private JButton jbt = new JButton("按钮");
public EventTest(){
jbt.addMouseListener(this);
this.add(jbt,BorderLayout.NORTH);
this.setSize(300,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {
jbt.setBackground(Color.red);
}
public void mouseExited(MouseEvent e) {
jbt.setBackground(Color.white);
}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public static void main(String[] args) {
new EventTest();
}
}
[例2]界面上有一个图片,鼠标进入,图片随机躲开。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements MouseListener{
private JLabel jlb = new JLabel();
int X=50,Y=50;
public EventTest(){
Icon icon = new ImageIcon("img.jpg");
jlb.setIcon(icon);
this.setLayout(null); this.add(jlb);
jlb.setSize(icon.getIconWidth(),icon.getIconHeight());
jlb.setLocation(X,Y);
jlb.addMouseListener(this);
this.setSize(400,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {
X = (int)(Math.random()*this.getWidth())-jlb.getWidth();
Y = (int)(Math.random()*this.getHeight())-jlb.getHeight();
jlb.setLocation(X,Y);
}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public static void main(String[] args) {
new EventTest();
}
}
- MouseMotionListener:监听鼠标移动和拖动操作
[例]鼠标在界面上移动,标题栏显示鼠标的当前坐标。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements MouseMotionListener{
public EventTest(){
this.addMouseMotionListener(this);
this.setSize(400,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public void mouseDragged(MouseEvent e) {
String str = e.getX() + "," + e.getY();
this.setTitle(str);
}
public void mouseMoved(MouseEvent e) {
}
public static void main(String[] args) {
new EventTest();
}
}
作业:界面上有一个图片,鼠标可以将图片从一个地方拖动到另一个地方。
作业:界面上有10个图片,鼠标可以将某个图片从一个地方拖动到另一个地方。
- KeyListener:监听键盘输入时要响应的事件(如俄罗斯方块)
[例]使用键盘上的上下左右键,能控制界面上一个图片的上下左右移动。
[注意]键盘事件一般被更大的容器先截获。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements KeyListener{
private JLabel jlb = new JLabel();
int X=50,Y=50;
public EventTest(){
Icon icon = new ImageIcon("img.jpg");
jlb.setIcon(icon);
this.setLayout(null); this.add(jlb);
jlb.setSize(icon.getIconWidth(),icon.getIconHeight());
jlb.setLocation(X,Y);
this.addKeyListener(this); //键盘事件应通过界面截获
this.setSize(400,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
if(keyCode==KeyEvent.VK_UP){
Y-=30;
}else if(keyCode==KeyEvent.VK_DOWN){
Y+=30;
}else if(keyCode==KeyEvent.VK_LEFT){
X-=30;
}else if(keyCode==KeyEvent.VK_RIGHT){
X+=30;
}
jlb.setLocation(X,Y);
}
public void keyReleased(KeyEvent e) {}
public void keyTyped(KeyEvent e) {}
public static void main(String[] args) {
new EventTest();
}
}
[综合例题]界面中一个图片掉下,鼠标进入,暂停,离开,继续掉。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class EventTest extends JFrame implements Runnable,MouseListener {
private JLabel jlb = new JLabel();
int X=50,Y=50;
boolean RUN = true;
public EventTest(){
Icon icon = new ImageIcon("img.jpg");
jlb.setIcon(icon);
this.setLayout(null); this.add(jlb);
jlb.setSize(icon.getIconWidth(),icon.getIconHeight());
jlb.setLocation(X,Y);
this.addMouseListener(this);
this.setSize(400,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
new Thread(this).start();
}
public void mouseClicked(MouseEvent e) {}
public void mouseEntered(MouseEvent e) {
RUN = false;
}
public void mouseExited(MouseEvent e) {
RUN = true;
new Thread(this).start();
}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
public void run(){
while(RUN){
try{ Thread.sleep(100); }catch(Exception e){}
Y+=20;
jlb.setLocation(X,Y);
}
}
public static void main(String[] args) {
new EventTest();
}
}
-
AdjustmentListener:监听一些具有调整功能的控件(如滚动条)
-
FocusListener:监听当控件获得或者失去焦点时要响应的事件
如焦点到一行时上面的提示信息消失,移除后提示信息继续存在。
8.7 Java绘图
8.7.1 绘制基本图形
用控件组成的界面,一般叫做高级界面;纯粹用绘画方式组成的界面,一般叫做低级界面。
低级界面开发的原理:以面板为画布,画布上画内容,将画布放在JFrame上,画布单独编写一个类。
预备知识:
- 画布上画内容,将该工作重写在从父类继承过来的paint函数中
- paint函数会自动调用;如果手工调用,只能用repaint函数
- 具体画图,采用paint函数中的Graphics参数(相当于画笔)
注意:Graphics有一个子类Graphics2D,画笔可以直接转换成该类型,Graphics2D内拥有更加丰富的画笔功能
基础演示:
import javax.swing.*;
import java.awt.*;
class MyCanvas extends JPanel{
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.setStroke(new BasicStroke(50)); //设置粗细
g2d.setColor(Color.red);
g2d.drawLine(0,0,100,100);
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
[例1]界面上,不断随机位置出现随机颜色的线段。
import javax.swing.*;
import java.awt.*;
class MyCanvas extends JPanel implements Runnable{
public MyCanvas(){
new Thread(this).start();
}
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.setStroke(new BasicStroke((int)(Math.random()*50)));
g2d.setColor(new Color((int)(Math.random()*256),(int)(Math.random()*256),(int)(Math.random()*256)));
g2d.drawLine((int)(Math.random()*this.getWidth()),
(int)(Math.random()*this.getHeight()),
(int)(Math.random()*this.getWidth()),
(int)(Math.random()*this.getHeight()));
}
public void run(){
while(true){
try{ Thread.sleep(50); } catch(Exception e){}
repaint();
}
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
[例2]界面上,鼠标拖动,可以连续画线。
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class MyCanvas extends JPanel implements MouseMotionListener{
int X=0,Y=0;
public MyCanvas(){
this.addMouseMotionListener(this);
}
public void mouseDragged(MouseEvent e) {
X = e.getX(); Y = e.getY();
this.repaint();
}
public void mouseMoved(MouseEvent e) {}
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.setColor(Color.green);
g2d.fillOval(X,Y,20,20); //参数(int x,int y,int width,int height)函数用当前颜色填充由指定矩形界定的椭圆
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
8.7.2 绘制图像
绘制图像,使用的是画笔的drawImage函数。
- 原图绘制:drawImage(Image img,int x,int y, ImageObserver observer)
- 原图缩放绘制:drawImage(Image img,int x,int y,int width,int height, ImageObserver observer)
基础演示:
import javax.swing.*;
import java.awt.*;
class MyCanvas extends JPanel{
private Image img = Toolkit.getDefaultToolkit().createImage("img.jpg");
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.drawImage(img,50,60,this);
g2d.drawImage(img,200,300,200,50,this);
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
[例]一个图像,在界面上渐渐放大。
import javax.swing.*;
import java.awt.*;
class MyCanvas extends JPanel implements Runnable{
private Image img = Toolkit.getDefaultToolkit().createImage("img.jpg");
int X=0,Y=0;
public MyCanvas(){ new Thread(this).start(); }
public void run(){
while(true){
try{ Thread.sleep(50); } catch(Exception ex){}
X+=10; Y+=10;
repaint();
}
}
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.drawImage(img,20,20,X,Y,this);
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
- 截取图像部分绘制:drawImage(Image img,
int dx1,int dy1,int dx2,int dy2, //d指destination
int sx1,int sy1,int sx2,int sy2, //s指source
ImageObserver observer)
[例]将原图的左边一半,右边一半,上面一半,下面一半分别绘制。
import javax.swing.*;
import java.awt.*;
class MyCanvas extends JPanel{
private Image img = Toolkit.getDefaultToolkit().createImage("img.jpg");
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.drawImage(img,0,0,100,100,0,0,img.getWidth(this)/2,img.getHeight(this), this);
g2d.drawImage(img,200,200,300,300,img.getWidth(this)/2,0,img.getWidth(this),img.getHeight(this),
this);
g2d.drawImage(img,300,50,400,100,0,0,img.getWidth(this),img.getHeight(this)/2, this);
g2d.drawImage(img,400,200,500,300,0,
img.getHeight(this)/2,img.getWidth(this),img.getHeight(this),
this);
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
8.7.3 图像旋转
利用rotate函数。 rotate(double theta,double x,double y)
- theta - 以弧度表示的旋转角度(顺时针)
- x - 旋转原点的x坐标
- y - 旋转原点的y坐标
import javax.swing.*;
import java.awt.*;
class MyCanvas extends JPanel{
private Image img = Toolkit.getDefaultToolkit().createImage("img.jpg");
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.drawImage(img,200,300,this);
g2d.rotate(Math.PI/2,200+img.getWidth(this)/2,300+img.getHeight(this)/2);
g2d.drawImage(img,200,300,this);
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
[例]图像边移动边旋转。
import javax.swing.*;
import java.awt.*;
class MyCanvas extends JPanel implements Runnable{
private Image img = Toolkit.getDefaultToolkit().createImage("img.jpg");
double r = 0;
int X=0;
public MyCanvas(){ new Thread(this).start(); }
public void run(){
while(true){
try{ Thread.sleep(50); } catch(Exception e){}
r = r + 0.1;
X+=10;
repaint();
}
}
public void paint(Graphics g){
Graphics2D g2d = (Graphics2D)g;
g2d.setColor(Color.white);
g2d.fillRect(0,0,this.getWidth(),this.getHeight()); //实现之前经过的图像不在界面上显示
g2d.rotate(r,0+X+img.getWidth(this)/2,0+X+img.getHeight(this)/2);
g2d.drawImage(img,0+X,0+X,this);
}
}
class Paint1 extends JFrame{
private MyCanvas mc = new MyCanvas();
public Paint1(){
this.add(mc);
this.setSize(800,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
}
public static void main(String[] args) {
new Paint1();
}
}
ch9.Java网络编程
9.1 网络基础知识
网络中有两个重要的协议,分别是:
-
TCP:传输控制协议 面向连接 打电话
-
UDP:数据包协议 面向数据包 发短信
使用较多的是TCP。
网络应用程序有微信、QQ、抖音、浏览器等,Java网络编程讲解的是这些网络应用程序最底层的内容。
有两种服务器和客户端的通信模式:
-
C/S模式:客户端/服务器 客户安装应用程序,和服务器通信 微信、QQ
-
B/S模式:浏览器/服务器 客户端安装浏览器,和服务器通信 www.csu.edu.cn在浏览器中运行
信息通过客户端和服务器通信,客户端之间的通信,靠服务器转发;故网络应用程序,一定要分为客户端和服务器程序。
网络上的计算机靠IP地址来定位,出现在客户端。
用端口号(port)确定不同的网络应用程序类型,由服务器决定:
端口号用数字表示,一般0-65535之间,有些非常常见的应用程序,已经预设了端口号:HTTP(浏览器:80),FTP(21)等等。一般应用程序,建议使用4位数端口号,以免冲突
9.2 单个客户端连接服务器
场景:客户端给服务器发送一句:你好,服务器回应,欢迎。
客户端连接服务器的步骤如下:[使用java.net包]
- 1:服务器先运行,确定端口号
- 2:客户端通过服务器IP地址+端口号,连上
- 3:通信
运用到的类如下:
- ServerSocket:启动服务器;接受客户端连接
- Socket: 客户端连上服务器,双方通信
Server1.java:
import java.net.*;
import java.io.*;
class Server1 {
public static void main(String[] args) throws Exception {
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept();
InputStreamReader isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
String msg = br.readLine();
System.out.println(msg);
PrintStream ps = new PrintStream(s.getOutputStream());
ps.println("欢迎你连上服务器!");
}
}
Client1.java:
import java.net.*;
import java.io.*;
class Client1 {
public static void main(String[] args) throws Exception {
Socket s = new Socket("172.17.10.147", 9999);
PrintStream ps = new PrintStream(s.getOutputStream());
ps.println("你好,我是客户端");
BufferedReader br =
new BufferedReader(new InputStreamReader(s.getInputStream()));
String str = br.readLine();
System.out.println(str);
}
}
[例1]客户端和服务器互相聊天:
客户端和服务器都有文本框,输入内容,回车(ActionListener),信息发给对方显示;反过来也支持。
Server2.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class Server extends JFrame implements ActionListener,Runnable{
private JTextField jtf = new JTextField();
private JTextArea jta = new JTextArea();
private BufferedReader br = null;
private PrintStream ps = null;
public Server() throws Exception{
this.setTitle("服务器");
this.add(jtf,BorderLayout.SOUTH);
this.add(jta,BorderLayout.CENTER);
jtf.addActionListener(this);
this.setSize(300,500);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept();
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps = new PrintStream(s.getOutputStream());
new Thread(this).start();
}
public void run() {
while(true){
try{
String msg = br.readLine();
jta.append(msg + "\n");
}catch(Exception e){}
}
}
public void actionPerformed(ActionEvent e){
jta.append(jtf.getText() + "\n");
ps.println("服务器说:" + jtf.getText());
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client2.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class Client extends JFrame implements ActionListener,Runnable{
private JTextField jtf = new JTextField();
private JTextArea jta = new JTextArea();
private BufferedReader br = null;
private PrintStream ps = null;
public Client() throws Exception{
this.setTitle("客户端");
this.add(jtf,BorderLayout.NORTH);
this.add(jta,BorderLayout.CENTER);
jtf.addActionListener(this);
this.setSize(300,500);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
Socket s = new Socket("172.17.10.147",9999);
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps = new PrintStream(s.getOutputStream());
new Thread(this).start();
}
public void run() {
while(true){
try{
String msg = br.readLine();
jta.append(msg + "\n");
}catch(Exception e){}
}
}
public void actionPerformed(ActionEvent e){
jta.append(jtf.getText() + "\n");
ps.println("客户端说:" + jtf.getText());
}
public static void main(String[] args) throws Exception {
new Client();
}
}
[例2·B/S典型例子]客户端给服务器发信息,如果发N字母,服务器发给客户端一个随机数字;如果发M字母,服务器给客户端发送一个欢迎文本。
Server3.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class Server extends JFrame implements Runnable{
private BufferedReader br = null;
private PrintStream ps = null;
public Server() throws Exception{
this.setTitle("服务器");
this.setSize(200,200);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept();
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps = new PrintStream(s.getOutputStream());
new Thread(this).start();
}
public void run() {
while(true){
try{
String msg = br.readLine();
if(msg.equals("N")){ ps.println("数字:" + Math.random()); }
if(msg.equals("M")){ ps.println("文本:欢迎"); }
}catch(Exception e){}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client3.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
class Client extends JFrame implements ActionListener,Runnable{
private JTextField jtf = new JTextField();
private JTextArea jta = new JTextArea();
private BufferedReader br = null;
private PrintStream ps = null;
public Client() throws Exception{
this.setTitle("客户端");
this.add(jtf,BorderLayout.NORTH);
this.add(jta,BorderLayout.CENTER);
jtf.addActionListener(this);
this.setSize(300,500);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
Socket s = new Socket("172.17.10.147",9999);
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps = new PrintStream(s.getOutputStream());
new Thread(this).start();
}
public void run() {
while(true){
try{
String msg = br.readLine();
jta.append(msg + "\n");
}catch(Exception e){}
}
}
public void actionPerformed(ActionEvent e){
ps.println(jtf.getText());
}
public static void main(String[] args) throws Exception{
new Client();
}
}
9.3 多个客户端连接服务器
应用场合:多个客户端连上服务器,客户端之间的通信依靠服务器转发。
9.3.1 服务器端群聊案例
[例1]多个客户端连上服务器:服务器端有一个界面,界面上有一个多行文本框,多个客户端连接,连上就在服务器显示“有人连上” 。
Server1.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
class Server extends JFrame implements Runnable{
private JTextArea jta = new JTextArea();
private ServerSocket ss = null;
public Server() throws Exception{
this.add(jta);
this.setSize(200,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void run(){
while(true){
try{
Socket s = ss.accept();
jta.append("有人连上!!\n");
}catch(Exception ex){}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client1.java:
import java.net.*;
import java.io.*;
class Client {
public static void main(String[] args) throws Exception {
Socket s = new Socket("172.17.10.148", 9999);
}
}
[例2]服务器端群聊:每个客户端都可以输入信息,回车发送,发送之后的信息,在服务器端显示。
类中类,多线程,每个客户端连接对应一个线程。
Server2.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import javax.swing.*;
class Server extends JFrame implements Runnable{
private JTextArea jta = new JTextArea();
private ServerSocket ss = null;
public Server() throws Exception{
this.add(jta);
jta.setFont(new Font("宋体",Font.BOLD,30));
this.setSize(200,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void run(){
while(true){
try{
Socket s = ss.accept();
ChatThread ct = new ChatThread(s); ct.start();
}catch(Exception ex){}
}
}
class ChatThread extends Thread{
BufferedReader br = null;
ChatThread(Socket s) throws Exception{
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
}
public void run(){
while(true){
try{
String msg = br.readLine();
jta.append(msg + "\n");
}catch(Exception e){}
}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client2.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Client extends JFrame implements ActionListener {
private JTextField jtf = new JTextField();
private PrintStream ps = null;
private String nickName = null;
public Client() throws Exception{
this.add(jtf,BorderLayout.SOUTH);
jtf.addActionListener(this);
jtf.setFont(new Font("宋体",Font.BOLD,30));
this.setSize(300,200);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
nickName = JOptionPane.showInputDialog("请您输入昵称");
Socket s = new Socket("172.17.10.148", 9999);
ps = new PrintStream(s.getOutputStream());
}
public void actionPerformed(ActionEvent e){
ps.println(nickName + "说:" + jtf.getText());
}
public static void main(String[] args) throws Exception {
new Client();
}
}
9.3.2 客户端群聊案例
[例3]客户端群聊:每个客户端都可以输入信息,回车发送,发送之后的信息,在每个客户端显示[服务器转发]。
Server3.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.util.*;
import javax.swing.*;
class Server extends JFrame implements Runnable{
private ServerSocket ss = null;
private ArrayList<ChatThread> users = new ArrayList<ChatThread>(); //一维变长数组,存放ChatThread类型变量
public Server() throws Exception{
this.setSize(200,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void run(){
while(true){
try{
Socket s = ss.accept();
ChatThread ct = new ChatThread(s);
users.add(ct); ct.start();
}catch(Exception ex){}
}
}
class ChatThread extends Thread{
BufferedReader br = null;
PrintStream ps = null;
ChatThread(Socket s) throws Exception{
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps = new PrintStream(s.getOutputStream());
}
public void run(){
while(true){
try{
String msg = br.readLine();
for(ChatThread ct : users){
ct.ps.println(msg);
}
}catch(Exception e){}
}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client3.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Client extends JFrame implements ActionListener,Runnable {
private JTextField jtf = new JTextField();
private JTextArea jta = new JTextArea();
private PrintStream ps = null;
private BufferedReader br = null;
private String nickName = null;
public Client() throws Exception{
this.add(jta,BorderLayout.CENTER);
this.add(jtf,BorderLayout.SOUTH);
jtf.addActionListener(this);
jtf.setFont(new Font("宋体",Font.BOLD,30));
jta.setFont(new Font("宋体",Font.BOLD,30));
this.setSize(400,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
nickName = JOptionPane.showInputDialog("请您输入昵称");
Socket s = new Socket("172.17.10.148", 9999);
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
new Thread(this).start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
jta.append(msg + "\n");
}catch(Exception e){}
}
}
public void actionPerformed(ActionEvent e){
ps.println(nickName + "说:" + jtf.getText());
}
public static void main(String[] args) throws Exception {
new Client();
}
}
[例4]客户端群聊:每个客户端增加一个按钮,点击按钮,该客户端下线。其他客户端显示该客户端下线的消息。
Server4.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.util.*;
import javax.swing.*;
class Server extends JFrame implements Runnable{
private ServerSocket ss = null;
private ArrayList<ChatThread> users = new ArrayList<ChatThread>();
public Server() throws Exception{
this.setSize(200,400);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void run(){
while(true){
try{
Socket s = ss.accept();
ChatThread ct = new ChatThread(s);
users.add(ct); ct.start();
}catch(Exception ex){}
}
}
class ChatThread extends Thread{
BufferedReader br = null;
PrintStream ps = null;
String nickName = null;
ChatThread(Socket s) throws Exception{
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps = new PrintStream(s.getOutputStream());
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] strs = msg.split(":");
if(strs[0].equals("NICK")){
nickName = strs[1];
}else if(strs[0].equals("XIAXIAN")){ //传递
for(ChatThread ct : users){
if(ct.nickName.equals(strs[1])){
users.remove(ct);
}else{
ct.ps.println(strs[1]+"下线啦!");
}
}
}else{
for(ChatThread ct : users){
ct.ps.println(msg);
}
}
}catch(Exception e){}
}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client4.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class Client extends JFrame implements ActionListener,Runnable {
private JButton jbt = new JButton("下线");
private JTextField jtf = new JTextField();
private JTextArea jta = new JTextArea();
private PrintStream ps = null;
private BufferedReader br = null;
private String nickName = null;
public Client() throws Exception{
this.add(jbt,BorderLayout.NORTH);
this.add(jta,BorderLayout.CENTER);
this.add(jtf,BorderLayout.SOUTH);
jtf.addActionListener(this);
jbt.addActionListener(this);
jtf.setFont(new Font("宋体",Font.BOLD,30));
jta.setFont(new Font("宋体",Font.BOLD,30));
this.setSize(400,600);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setVisible(true);
nickName = JOptionPane.showInputDialog("请您输入昵称");
Socket s = new Socket("172.17.10.148", 9999);
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps.println("NICK:"+nickName);
new Thread(this).start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
jta.append(msg + "\n");
}catch(Exception e){}
}
}
public void actionPerformed(ActionEvent e){
if(e.getSource()==jtf){
ps.println(nickName + "说:" + jtf.getText());
}else{
ps.println("XIAXIAN:" + nickName);
System.exit(0);
}
}
public static void main(String[] args) throws Exception {
new Client();
}
}
另例:客户端群聊:每个客户端增加一个按钮,点击按钮,该客户端下线。其他客户端显示该客户端下线的消息——服务器要对信息进行分类处理。
9.3.3 客户端私聊案例
客户端还要显示在线客户名单,每个客户端可以选择某人,输入信息,回车发送,发送之后的信息,在指定客户端显示。
-
每个用户登录,用户昵称发给服务器,服务器转发给客户端显示用户列表
-
客户端选择人员之后,私聊对象的昵称发给服务器端,服务器端不再将聊天信息转发给所有客户端,而发给特定的客户端(加一个判断)
Server1.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.HashMap;
class Server extends JFrame implements Runnable,ActionListener{
private List users = new List();
private JButton jbt = new JButton("远程关闭");
private ServerSocket ss = null;
private HashMap<String,ChatThread> cts = new HashMap<String,ChatThread>();
public Server() throws Exception{
this.add(users,BorderLayout.CENTER);
this.add(jbt,BorderLayout.SOUTH);
jbt.addActionListener(this);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(200,300);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void actionPerformed(ActionEvent e){
String selectedUser = users.getSelectedItem();
String msg = "LOGOUT:"+selectedUser;
ChatThread ct = cts.get(selectedUser);
ct.ps.println(msg);
users.remove(selectedUser);
cts.remove(selectedUser);
}
public void run(){
while(true){
try{
Socket s = ss.accept();
ChatThread ct = new ChatThread(s);
}catch(Exception e){}
}
}
class ChatThread extends Thread{
PrintStream ps = null;
BufferedReader br = null;
String nickName = null;
ChatThread(Socket s) throws Exception{
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
this.start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("LOGIN")){
nickName = msgs[1];
users.add(nickName);
cts.put(nickName,this);
}
}catch(Exception ex){}
}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client1.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
class Client extends JFrame implements Runnable{
private String nickName = null;
private PrintStream ps = null;
private BufferedReader br = null;
public Client() throws Exception{
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(300,200);
this.setVisible(true);
nickName = JOptionPane.showInputDialog("输入昵称");
Socket s = new Socket("172.17.10.147", 9999);
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps.println("LOGIN:"+nickName);
new Thread(this).start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("LOGOUT")){
JOptionPane.showMessageDialog(this,"您被踢出!");
this.dispose();
}
}catch(Exception e){}
}
}
public static void main(String[] args) throws Exception {
new Client();
}
}
9.4 用户管理和控制
服务器可以监控各个客户端。
两个客户端输入昵称,连接到服务器,服务器显示昵称列表。选择某人,将其远程关闭
- 定义客户端连接的信息格式为:LOGIN:昵称
- 定义让某个客户端下线信息格式为:LOGOUT:昵称
Server1.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.HashMap;
class Server extends JFrame implements Runnable,ActionListener{
private List users = new List();
private JButton jbt = new JButton("远程关闭");
private ServerSocket ss = null;
private HashMap<String,ChatThread> cts = new HashMap<String,ChatThread>();
public Server() throws Exception{
this.add(users,BorderLayout.CENTER);
this.add(jbt,BorderLayout.SOUTH);
jbt.addActionListener(this);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(200,300);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void actionPerformed(ActionEvent e){
String selectedUser = users.getSelectedItem();
String msg = "LOGOUT:"+selectedUser;
ChatThread ct = cts.get(selectedUser);
ct.ps.println(msg);
users.remove(selectedUser);
cts.remove(selectedUser);
}
public void run(){
while(true){
try{
Socket s = ss.accept();
ChatThread ct = new ChatThread(s);
}catch(Exception e){}
}
}
class ChatThread extends Thread{
PrintStream ps = null;
BufferedReader br = null;
String nickName = null;
ChatThread(Socket s) throws Exception{
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
this.start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("LOGIN")){
nickName = msgs[1];
users.add(nickName);
cts.put(nickName,this);
}
}catch(Exception ex){}
}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client1.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
class Client extends JFrame implements Runnable{
private String nickName = null;
private PrintStream ps = null;
private BufferedReader br = null;
public Client() throws Exception{
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(300,200);
this.setVisible(true);
nickName = JOptionPane.showInputDialog("输入昵称");
Socket s = new Socket("172.17.10.147", 9999);
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps.println("LOGIN:"+nickName);
new Thread(this).start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("LOGOUT")){
JOptionPane.showMessageDialog(this,"您被踢出!");
this.dispose();
}
}catch(Exception e){}
}
}
public static void main(String[] args) throws Exception {
new Client();
}
}
[例1]两个客户端,每个客户端有一个图像掉下来,服务器端可以控制相应客户端暂停或继续。
定义客户端连接的信息格式为:LOGIN:昵称
- 定义暂停为:ZT:昵称
- 定义继续为:JX:昵称
Server2.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.HashMap;
class Server extends JFrame implements Runnable,ActionListener{
private List users = new List();
private JButton jbt = new JButton("暂停");
private JButton jbt2 = new JButton("继续");
private ServerSocket ss = null;
private HashMap<String,ChatThread> cts = new HashMap<String,ChatThread>();
public Server() throws Exception{
this.add(users,BorderLayout.CENTER);
this.add(jbt,BorderLayout.SOUTH);
this.add(jbt2,BorderLayout.NORTH);
jbt.addActionListener(this);
jbt2.addActionListener(this);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(200,300);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void actionPerformed(ActionEvent e){
String selectedUser = users.getSelectedItem();
String msg = null;
if(e.getSource()==jbt){
msg = "ZT:"+selectedUser;
}else{
msg = "JX:"+selectedUser;
}
ChatThread ct = cts.get(selectedUser);
ct.ps.println(msg);
}
public void run(){
while(true){
try{
Socket s = ss.accept();
ChatThread ct = new ChatThread(s);
}catch(Exception e){}
}
}
class ChatThread extends Thread{
PrintStream ps = null;
BufferedReader br = null;
String nickName = null;
ChatThread(Socket s) throws Exception{
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
this.start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("LOGIN")){
nickName = msgs[1];
users.add(nickName);
cts.put(nickName,this);
}
}catch(Exception ex){}
}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client2.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
class Client extends JFrame implements Runnable{
private String nickName = null;
private PrintStream ps = null;
private BufferedReader br = null;
private JLabel jlb = new JLabel();
private int X=100,Y = 0;
private ImageThread it = null;
public Client() throws Exception{
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setLayout(null); this.add(jlb);
Icon icon = new ImageIcon("img.jpg");
jlb.setIcon(icon);
jlb.setLocation(X,Y); jlb.setSize(icon.getIconWidth(),icon.getIconHeight());
this.setSize(300,500);
this.setVisible(true);
nickName = JOptionPane.showInputDialog("输入昵称");
Socket s = new Socket("172.17.10.147", 9999);
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps.println("LOGIN:"+nickName);
new Thread(this).start();
it = new ImageThread(); it.start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("ZT")){
it.RUN = false;
}
if(msgs[0].equals("JX")){
it = new ImageThread(); it.start();
}
}catch(Exception e){}
}
}
class ImageThread extends Thread{
boolean RUN = true;
public void run(){
while(RUN){
try{ Thread.sleep(100); Y++;
jlb.setLocation(X,Y);
}catch(Exception ex){}
}
}
}
public static void main(String[] args) throws Exception {
new Client();
}
}
[例2]两个客户端,服务器产生一个随机数,随机数从每个客户端掉下来,某一个先掉到底部,告知服务器,服务器重新产生随机数,两者同时从最上面掉下来。
定义客户端连接的信息格式为:LOGIN:昵称
- 定义发送随机数为:SJS:数字
- 定义掉到底部为:DB:昵称
Server3.java:
import java.net.*;
import java.io.*;
import java.awt.*;
import javax.swing.*;
import java.util.HashMap;
import java.util.Set;
class Server extends JFrame implements Runnable{
private List users = new List();
private ServerSocket ss = null;
private HashMap<String,ChatThread> cts = new HashMap<String,ChatThread>();
public Server() throws Exception{
this.add(users,BorderLayout.CENTER);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setSize(200,300);
this.setVisible(true);
ss = new ServerSocket(9999);
new Thread(this).start();
}
public void run(){
while(true){
try{
Socket s = ss.accept();
ChatThread ct = new ChatThread(s);
}catch(Exception e){}
}
}
class ChatThread extends Thread{
PrintStream ps = null;
BufferedReader br = null;
String nickName = null;
ChatThread(Socket s) throws Exception{
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
this.start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("LOGIN")){
nickName = msgs[1];
users.add(nickName);
cts.put(nickName,this);
}else if(msgs[0].equals("DB")){
String randStr = "SJS:"+Math.random();
Set<String> nickNames = cts.keySet();
for(String nk : nickNames){
ChatThread ct = cts.get(nk);
ct.ps.println(randStr);
}
}
}catch(Exception ex){}
}
}
}
public static void main(String[] args) throws Exception {
new Server();
}
}
Client3.java:
import java.net.*;
import java.io.*;
import javax.swing.*;
class Client extends JFrame implements Runnable{
private String nickName = null;
private PrintStream ps = null;
private BufferedReader br = null;
private JLabel jlb = new JLabel();
private int X=100,Y = 0;
private ImageThread it = null;
public Client() throws Exception{
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setLayout(null); this.add(jlb);
jlb.setText("欢迎参加本游戏"); jlb.setSize(200,50);
jlb.setLocation(X,Y);
this.setSize(300,500);
this.setVisible(true);
nickName = JOptionPane.showInputDialog("输入昵称");
Socket s = new Socket("172.17.10.147", 9999);
ps = new PrintStream(s.getOutputStream());
br = new BufferedReader(new InputStreamReader(s.getInputStream()));
ps.println("LOGIN:"+nickName);
new Thread(this).start();
it = new ImageThread(); it.start();
}
public void run(){
while(true){
try{
String msg = br.readLine();
String[] msgs = msg.split(":");
if(msgs[0].equals("SJS")){
jlb.setText(msgs[1]);
Y=0;
jlb.setLocation(X,Y);
}
}catch(Exception e){}
}
}
class ImageThread extends Thread{
boolean RUN = true;
public void run(){
while(RUN){
try{ Thread.sleep(100); Y++;
jlb.setLocation(X,Y);
if(Y>=500){
ps.println("DB:" + nickName);
}
}catch(Exception ex){}
}
}
}
public static void main(String[] args) throws Exception {
new Client();
}
}
附:《Java语言与系统设计》思维导图
考试题型:选择题、填空题、判断题、改错题、问答题、程序题。
模块 | 内容 | 要点 |
---|---|---|
Java语言基本语法 | Java特点 | 1、跨平台;2、运行的基本原理(代码用java文件,可执行文件是.class);3、语法和C基本相同,没有指针;程序入口是main函数 |
Java语法 | 1、变量、数据类型:float和long定义比较特殊;各种数据类型的精度顺序,高精度不能直接赋值给低精度;不能用0和非0表示真假;变量的定义必须掌握;字符数据类型有转义字符,用 ?表示 2、运算:算术运算:+ - * / % += -= *= /= ++ – ; 关系运算:> < >= <= == !=;逻辑运算:&& | |
面向对象基本概念 | 类和对象 | 类的定义(要会编程);由类来实例化对象原理;对象名的引用性质(理解对象名重新指向另一个对象的情况) |
成员变量和成员函数 | 成员变量和成员函数的定义;通过对象访问成员变量成员函数(.号);成员函数参数传递时的值传递和引用传递的区别(需要能够分析实例) | |
特殊的成员变量和成员函数 | 1、构造函数:定义方式、调用特点、垃圾收集机制 2、函数重载:三个条件满足其一即可 3、静态变量:定义方式、性质特点、如何调用(类名.或者对象名.来调用) 4、静态函数:定义方式(和静态变量类似)、性质特点(静态函数只能访问静态成员和函数中的局部变量)、如何调用(类名.或者对象名.来调用) 常见概念的英文形式必须要掌握 需要能够进行基本的编程 | |
面向对象基本特征 | 封装 | 1、包:定义包(注意包的嵌套关系);导入包中的类 2、类:public类(定义方式、特点);普通类(定义方式、特点) 3、成员:四个访问控制符:public、protected、默认、private 理解它们的具体权限 需要能够进行基本的编程 |
继承 | 1、如何实现继承(extends)?Java继承的特点(只能使用继承的非private成员、Java不支持多重继承) 2、覆盖:如何编程才算覆盖(子类定义成员和父类名称、返回类类型、参数皆相同)?覆盖有什么特点(子类对象调用时,直接调用子类成员)和要求(不允许减小子类成员的权限)? 3、父类构造函数的初始化(子类实例化时,会自动调用父类的构造函数,如果父类构造函数带参数,必须用super(参数列表)初始化父类对象,代码写在子类构造函数的第1句) 4、this和super的用法和意义 | |
多态性 | 1、多态性的定义:父类引用指向子类对象 Dialog d = new FontDialog(); 2、性质:该引用调用重写成员时,调用的是子类成员 | |
抽象类、接口等其他内容 | 1、抽象类如何定义?含有抽象函数的类,类前用abstract修饰 2、抽象类有何性质?不能被实例化;可以有普通函数;里面抽象函数必须被重写(除非子类也是抽象类) 3、接口如何定义?和抽象类有何区别?interface,用implements来实现。可以实现多个接口;接口中所有的函数都是抽象函数,并且是public;所有变量都是public的静态的final的变量(常量) 4、Object类:Java中所有类的最高父类 5、final关键字:final变量、final函数、final类特点 | |
Java语言基本功能 | 异常 | 1、try、catch、finally:匹配规则try(1)-catch(1…)-finally(0,1);程序运行的逻辑;了解Java中常见异常类和异常原因的对应(代码预测):NullPointerException、NumberFormatException、IOException等等 2、throw、throws:掌握其使用的位置 |
多线程 | 1、定义线程(能写代码):继承Thread、实现Runnable Thread.sleep(XX);知道其用法 2、调用线程:启动线程:继承Thread、实现Runnable两类有不同的启动方法 3、控制线程:暂停和继续 | |
基本API | 1、java.lang:Math重点掌握随机数;String重点掌握字符串长度、字符串按位置访问函数;StringBuffer掌握和String的区别;基本数据类型的包装类掌握字符串和数值的互相转换 以上需要会编程 2、java.util:变长数组:List系列(子类)、Set系列(子类)、Map系列(子类);掌握其区别;需要能够用它们解决实际问题(写伪代码) | |
IO | 1、java.io包 2、File、FileInputStream、FileOutputStream、BufferedReader、PrintStream、RandomAccessFile各自的功能(不编程) | |
Java语言界面开发 | 界面和控件 | javax.swing: 界面和控件,常见的必须知道意义 java.awt:颜色和字体 |
布局 | java.awt: FlowLayout/BorderLayout/GridLayout区别 | |
Java事件开发 | 事件开发 | java.awt.event包,按钮点击等简单事件用什么来监听,发出什么类型事件? |
Java绘图 | Graphics、paint函数作用;repaint函数作用 | |
Java网络编程 | 基本概念 | IP地址、端口各自区别;服务器、客户端的区别 |
具体实现 | java.net ServerSocket\Socket各自作用;ServerSocket的accept函数的意义。 |