JAVA课件总结

JAVA课件总结

第一章 Java入门

1、JAVA特点：简单性、面向对象性、分布式、健壮性、安全性、体系结构中立、可移植性、解释型（Java运行机制：先编译后解释，开发环境：源文件.java?，编译器：字节码文件.class，解释器：解释运行(由虚拟机完成字节码文件的解释运行)）、高性能、多线程、动态性。 2、Java程序特点：Java源文件可由若干各类组成，类的关键字是class，类名后{}内的部分为类体；每个文件中最多只能有一个public类，public类名与文件名相同；public static void main(String args[]){} 主方法，程序运行的入口，命令行参数 String args[]；可以有多个其他方法。

3、注释：javadoc 用于对.java文件中的文档注释进行提取，从而生成一个帮助文档 命令：javadoc -d docs HelloWorld.java

第二章 java数据类型

1、标识符：对程序中各元素加以命名时使用的符号，遵循以下规则：

由字母、下划线、$、数字组成；不能以数字打头，不能是java中关键字；望文生义。

包名所有单词均小写；类名每个单词的首字母大写；变量、方法名第一个单词首字母小写、其它单词首字母大写；常量都大写

2、变量：变量三要素：变量类型；变量名；变量作用域（作用域从定义它开始，到定义它的代码块结束为止）。

3、数组：声明数组仅仅是给出了数组名字和元素的数据类型；要使用数组还必须为它分配内存空间，即创建数组。

第三章 运算符、表达式和语句

1、实验内容

输出1-10之间的奇数之和，偶数之和，及总和 输出1-100之间，能够被5整除的前5个数

编程输出所有的三位水仙花数 水仙花数:各位数字的立方数相加等于该数本身 例如 153 1*1*1+5*5*5+3*3*3=153 153就是一个三位水仙花数 从键盘输入一个数，求这个数的阶乘。

从键盘输入一个数，求这个数的阶乘之和（1!+2!...7!）。 输入成绩，并按成绩给出相应的等级。

第四章 类、对象和接口

1、面向对象编程三特性：封装（Encapsulation) 、继承 (Inheritance) 、多态 (Polymorphism) 2、成员变量和局部变量关系：局部变量在使用之前，必须进行初始化；对于成员变量即使程序员不进行初始化,虚拟机也会对成员变量进行初始化操作赋默认值。实例变量和局部变量可重名，重名后在方法内采用局部优先策略，这时通过使用this,在该方法内使用成员变量。 3、方法重载：OverLoading 编译时多态：方法的重载指的是在一个类中定义多个名字相同的方法，但是这些方法的参数列表必须不同，编译器会根据实参的型来确定调用哪一个方法，

对使用者屏蔽由于方法的形参不同所带来的差异

3、简单变量与对象变量：简单变量，8种原始类型定义的变量；对象变量，引用 对象类型定义出来的变量 ；区别，简单变量--》值；对象变量---》地址。

4、对象的引用和实体：类中的成员变量被分配内存空间，这些内存空间称做该对象的实体。 对象中存放着是对实体的引用，以确保实体由该对象操作使用。 一个类创建的两个对象，如果两对象具有相同的引用，那么就具有完全相同的实体。 没有实体的对象称作空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。

5、访问权限修饰符： private(私有的） 类的内部访问，不能被子类继承；( default)(友好的) 本包内部可用，本包子类可以继承； protected(受保护的) 本包以及其他包的子类访问，可被子类继承，注：继承后，在子类里覆盖后使用 ； public（公开的）所有地方都可用 ，可以被子类继承。只有public和default可以修饰类。

6、接口回调：可以把实现某一接口的类创建的对象的引用赋给该接口声明的接口变量中,之后接口变量可以调用被类实现的接口中的方法。

7、运行时多态：原则：1. 对象类型不变；2. 对于一个引用只能调用其引用类型里定义的方法；3. 运行时会根据对象的真实类型，运行覆盖过的方法

8、实验内容

定义表示用户的类User。用户的属性包括用户ID、用户姓名，年龄，性别，用户名，密码等；方法包括所有属性的设置和获取方法，以及打印用户名，用户性别，和用户年龄的打印方法，覆盖toString()方法为返回用户的ID，覆盖equals()方法为用户ID相等时两个对象想同。编写主程序，创建User类的对象userA，userB，设置他们的相关属性，并按要求覆盖相应方法，在本题中体现static关键字的使用及权限修饰符的使用。

建立User类的子类Student，在子类中对父类方法进行覆盖，然后编写主程序实现上转型对象，体现运行时多态的编程理念。 定义接口Shape，其中包括Area方法。类Circle、Square和Triangle均实现了接口Shape。定义主函数，创建元素个数为3的Shape类型的一维数组，分别为数组元素创建Circle、Square和Triangle类型的对象，最后分别调用各数组元素的Area方法，输出相关信息。 编辑程序利用包装类实现各类型数据的转换。 编辑程序实现Class类的应用工

第五章 字符串时间日期和数字

1、字符串：字符串常量与字符串变量；“equals（）”与“= =”。

2、StringTokenizer类：构造函数 StringTokenizer（String s） 为字符串s构造一个分析器。使用默认的分隔符集合，即空格符 、换行符、回车符、Tab符、进纸符。StringTokenizer(String s, String delim) 为字符串s构造一个分析器。参数dilim中的字符被作为分隔符。StringTokenizer字符串分析器使用nextToken()方法逐个获取字符串中的语言符号（单词） 3、StringBuffer类 ：StringBuffer类能创建可修改的字符串序列，也就是说，该类的对象的实体的内存空间可以自动的改变大小，便于存放一个可变的字符序列。String类创建的字符串对象是不可修改的，也就是说，String字符串不能修改、删除或替换字符串中的某个字符，即String对象一旦创建，那么实体是不可以再发生变化的。

append()将其他Java类型数据转化为字符串再追加到StringBuffer对象中

4、Date类：使用Date类的无参数构造方法创建的对象可以获取本地当前时间: new Date()，Date对象表示时间的默认顺序是：星期、月、日、小时、分、秒、年。

实现时期的格式化:使用DataFormat的子类SimpleDateFormat来。构造方法：public SimpleDateFormat(String pattern) ，pattern中应当含有一些特殊意义字符，这些特殊的字符被称做元字符，y或yy：表示用2位数字输出年份，yyyy表示用4为数字输出年份；M 或MM表示用2为数字或文本输出月份，如果想用汉字输出月份，应连续包含至少3个M。 d 或dd表示用2为数字输出日；H或HH表示用两位数字输出小时；m或mm表示用两位数字输出分；s或ss表示用两位数字输出秒；E 表示用字符串输出星期。

5、Calendar类：使用Calendar类的static方法getInstance()可以初始化一个日历对象。月份返回0表示当前是一月

第六章 异常处理

1、异常(Exception)概述：异常:一种“例外”情况,也就是正常情况之外的一种“情况”? 2、异常机制：异常机制能够简化错误控制代码?程序再也不用对特定错误进行检查,然后在发生错误的多处地方对其进行控制处理?也不需要在方法调用的时候检查错误?程序中只在异常处理模块进行问题处理，这样可有效减少代码量,并将那些用于描述具体操作的代码与专门纠正错误的代码分隔开?

3、异常条件：异常条件是表示在出现什么问题的时候应中止方法或作用域的继续，在异常条件情况下：程序不能再进行下去，因为当地没有提供解决问题所需的足够多的信 息?此时,我们能做的唯一事情就是跳出当地环境,将那个问题委托给一个更高级的负责人?这便是出现异常时出现的情况?

4、异常处理方法：抛出异常： throws 异常类类名 消极处理；throw 异常类名 捕获异常： try-catch-finally

语法：将可能出现的异常操作放在try~catch语句的try部分，当try部分中的某个语句发生异常后，try部分将立刻结束执行，而转向执行相应的catch部分；程序将发生异常后的处理放在 catch部分。一个try可以跟多个catch 积极处理，分别处理发生的相应异常。 Finally代表无论如何都要执行的代码，除非try-catch里出现System.exit(0); 注：被抛出的异常沿着方法调用顺序的反向传递方法覆盖时，子类覆盖的方法不能比父类被覆盖的方法抛出更多的异常。 5、例子

public class NopositiveException extends Exception {//处理在除法计算中出现的0值异常 }

String message;

public NopositiveException(int i){ message=i+\不是一个正整数\}

@Override

public String toString(){ }

return message;

public class Computer {

public int divide(int i,int j)throws NopositiveException{

if(j<=0){ NopositiveException n=new NopositiveException(j); throw n;

} }

}

} int x=i/j; return x;

public class Text {

public static void main(String[] args) { }

// TODO Auto-generated method stub Scanner sc=new Scanner(System.in); int i=sc.nextInt();

int j=sc.nextInt();

Computer c=new Computer(); int k=0; try {

k=c.divide(i, j);

} catch (NopositiveException e) { }

// TODO Auto-generated catch block System.out.println(e.toString());

System.out.println(k);

第七章 图形用户界面（GUI）

1、图形用户界面（Graphics User Interface，缩写GUI）：以图形的显示方式与用户实现交互操作的应用程序界面。Java语言中有两个包（java.awt和javax.swing）包括了实现图形用户界面的所有基本元素。“awt”是抽象窗口工具包（Abstract Windowing Toolkit）的缩写，其中的组件常被称为AWT组件。 javax.swing是Java2提出的AWT的改进包，它主要改善了组件的显示外观，增强了组件的控制能力。

2、在Java中，设计用户界面需要经历4个基本步骤：（1）创建和设置组件（2）将组件加入到容器中 （3）布局组件 （4）处理由组件产生的事件

3、GUI的三要素：组件：与用户实现交互操作的部件,集成了一定的功能模块，提供了公用接口以便外部调用，具有良好的可重用性。容器：也称窗体，是一种特殊的组件，容器中可以放置其他组件，并且通过布局管理器（LayoutManager）管理容器中各组件的位置。事件：每个组件都会触发动作事件，Java中不同的事件由不同的监听器（Listener）处理，组件是事件源，而某种监听器主要用来监听来自指定事件源产生的动作事件。

4、FlowLayout是Panel容器的默认布局管理器。BorderLayout是Frame和Dialog两种容器的默认布局管理器。

5、Swing容器：尽管所有的Swing都属于容器，但还是有几种专门用于作为容器的组件。它们被分成顶层容器、通用容器和专用容器三个类别，其中顶层容器和通用容器是常用的两类容器形式。

6、事件处理机制：事件处理主要涉及三种对象：事件源(An event source)，可供用户进行交互的GUI组件；事件对象(An event object)，封装了包含所发生的各种事件的有效信息，信

息包括: 事件源的引用、以及事件监听器在处理事件时所需要的其它各种信息，事件信息被包含在类AWTEvent或其子类的实例对象中；事件监听器(event listener(s))，接受事件对象，并处理事件对象 7、例子

public class AwtTest extends Frame implements ActionListener{

public Button b; public Label l1; public Label l2; public Panel p; public CardLayout a; public AwtTest(){ super(\实例\

b=new Button(\确定\ b.addActionListener(this); l1=new Label(\北京\ l2=new Label(); p=new Panel();

a=new CardLayout(); p.setLayout(a); p.add(l1,\ p.add(l2,\

p.add(b,\a.show(p, \this.add(p);

this.setBounds(100, 100, 200, 400);

this.setVisible(true); }

@Override

public void actionPerformed(ActionEvent e) { // TODO Auto-generated method stub

l2.setText(l1.getText()); a.show(p, \

}

public static void main(String[] args) {

// TODO Auto-generated method stub AwtTest at=new AwtTest();

}

}

8、实验

编写一个登陆界面，在该界面中包括一个用户名输入的文本框，在其中输入用户名为“admin”，一个密码框，在其中输入密码为“123456”时登陆系统，跳转到登陆成功窗口。在登陆成功窗口建立菜单栏，包括“文件”，“操作”两个菜单，文件菜单中包括“退出”菜单项，操作菜单中包括录入和查询页面。在点击录入功能时，将打开一个个人信息录入窗口，在其中录入个人信息，包括文本框的用户名，密码框的密码和确认密码，单选按钮的性别，下拉列表的省份，以及下拉列表的城市，（随着省份列表框的选项不同，城市列表框的内容

产生变化），复选框的个人爱好。可输入多组用户信息，然后通过操作菜单的查询字菜单项，在查询窗口中显示前面输入的所有用户信息。

第八章 多线程机制

1、程序是描述应用软件执行的蓝本的一段静态代码。 进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的执行单位,一个进程在其执行过程中，可以产生多个线程，形成多条执行线索。每条线索，即每个线程也有它自身的产生、存在和消亡的过程，也是一个动态的概念。 Java的多线程就是在操作系统每次分时给Java程序一个时间片的CPU时间内，在若干个独立的可控制的线程之间切换。 2、用Thread类或子类创建线程对象。编写Thread类的子类时，需要重写父类的run方法，其目的是规定线程的具体操作 。

public class Clerk extends Thread { public Clerk(String name) { super(name); } @Override public void run() { super.run(); // 添加具体的工作代码 } }

3、实现Runnable接口。 构造方法：Thread（Runnable target）形式参数为Runnable类型的接口，在创建线程对象时实际参数为Runnable接口类的实例对象，作为所创线程的目标对象。当线程享用CPU资源，目标对象就会自动调用接口中的run方法（接口回调）。 public class Clerk implements Runnable{ @Override public void run() { // 添加具体的工作代码 } }

Thread clerk=new Thread(new Clerk()); 4、线程的常用方法：

start() 作用：线程调用该方法将启动线程，使之从新建状态进入就绪队列排队，一旦轮到它来享用CPU资源时，就可以脱离创建它的线程独立开始自己的生命周期了。 格式：创建线程对象.start(); run() 作用：用来定义线程对象被调度之后所执行的操作，都是系统自动调用而用户程序不得引用的方法。注：系统的Thread类中，run()方法没有具体内容，所以用户程序需要创建自己的Thread类的子类，并重写run()方法来覆盖原来的run()方法。当run方法执行完毕，线程就变成死亡状态。

currentThread（）特点：Thread类中的类方法，可以用类名调用。作用：返回当前正在使用CPU资源的线程。 格式：Thread.currentThread()

sleep(int millsecond)作用：线程运行期间执行sleep方法来使自己放弃CPU资源，休眠一段时间。休眠时间的长短由参数millsecond决定，以毫秒为单位计算休眠时间。如果线程在休眠时被打断JVM就抛出Interrupted Exception异常。所以必在try~catch语句块中调用sleep方法。 格式：Thread.sleep(int millsecond);

interrupt() intertupt方法用来“吵醒”休眠的线程。作用:当一些线程调用sleep方法处于休眠状态时，一个正占有CPU资源的线程可让休眠的线程调用interrupt 方法“吵醒”自己 。 格式：休眠线程.interrupt();

5、线程同步:当几个线程都需要调用一个同步方法(使用关键字synchronized修饰的方法) ,称为线程同步.

同步机制：当一个线程A使用一个synchronized修饰的方法时，其他线程再想使用这个方法时就必须等待，直到线程A 使用完该方法（除非线程A使用wait主动让出CPU资源）。 6、挂起：所谓挂起一个线程就是让线程暂时让出CPU的使用权限，暂时停止执行，但停止执行的持续时间不确定，因此不能使用sleep方法暂停线程。挂起一个线程需使用wait方法，即让准备挂起的线程调用 wait 方法，主动让出CPU的使用权限. 7、恢复线程

8、在其它线程占有CUP资源期间，让挂起的线程的目标对象执行notifyAll()方法，使得挂起的线程继续执行；如果线程没有目标对象，为了恢复该线程，其它线程在占有CUP资源期间，让挂起的线程调用notifyAll()方法，使挂起的线程继续执行。

9、计时器线程Timer：作用：需要周期性执行的操作,可以通过计时器来进行处理

构造方法：Timer(int a, Object b)创建一个计时器 参数a的单位是豪秒，确定计时器每隔a 毫秒\震铃\一次，参数b是计时器的监视器。

震铃事件为ActinEvent 类型，当该事件发生时，监视器就会监视到这个事件，然后执行方法:actionPerformed(Actionevent e) 使用Timer类的start()方法启动计时器即启动线程。使用stop()方法停止计时器，即挂起线程，使用restart()方法重新启动计时器，即恢复线程。

10、线程联合：一个线程A在占有CUP资源期间，可以让其它线程调用join()和本线程联合。如果线程A在占有CUP资源期间一旦联合B线程，那么A线程将立刻中断执行，一直等到它联合的线程B执行完毕，A线程再重新排队等待CUP资源，以便恢复执行。 11、例子

public class ThreadTest { public static void main(String args[]){ //调用所建立的线程类，并创建线程对象 LHand l; RHand r; l=new LHand(); r=new RHand(); //调用start方法运行线程对象 r.start(); l.start(); //编写主线程代码 for(int i=0;i<10;i++){ System.out.println(\ } } }

class LHand extends Thread{ public void run(){ for(int i=0;i<10;i++){ System.out.println(\ } } }

class RHand extends Thread{ public void run(){ for(int i=0;i<10;i++){ System.out.println(\ }

} }

public class runnableTest { public static void main(String[] args) { // TODO Auto-generated method stub Hand h=new Hand(); //调用start方法运行线程对象 h.l.setPriority(10); h.l.start(); h.r.start(); //编写主线程代码 } }

class Hand implements Runnable{ Thread l,r; public Hand(){ l=new Thread(this); r=new Thread(this); l.setName(\ r.setName(\ } public void run(){ if(Thread.currentThread()==l){ System.out.println(l.getName()+\ System.out.println(l.isAlive()); try { Thread.sleep(1000*60); } catch (InterruptedException e) { // TODO Auto-generated catch block System.out.println(l.getName()+\被叫醒了！\ } System.out.println(l.getName()+\开始听课！\ }else if(Thread.currentThread()==r){ for(int i=0;i<3;i++){ System.out.println(\上课\ try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block } } l.interrupt(); } } }

//线程同步

public class threadSY { public static void main(String[] args) {

// TODO Auto-generated method stub FM f=new FM(); f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); f.setSize(500, 500); f.setVisible(true); } }

class FM extends JFrame implements Runnable,ActionListener{ int money=100; int weekDay; JButton bStart; JTextArea tj1,tj2; Thread kj,cn; public FM(){ super(\线程同步示例\ bStart=new JButton(\开始演示\ bStart.addActionListener(this); kj=new Thread(this); cn=new Thread(this); tj1=new JTextArea(); tj2=new JTextArea(); ScrollPane s1=new ScrollPane(); s1.setSize(100,150); s1.add(tj1); ScrollPane s2=new ScrollPane(); s2.setSize(100,150); s2.add(tj2); Container c=this.getContentPane(); FlowLayout f=new FlowLayout(); f.setHgap(30); c.setLayout(f); c.add(bStart); c.add(s1); c.add(s2); } @Override public void actionPerformed(ActionEvent arg0) { // TODO Auto-generated method stub if(!cn.isAlive()){ cn=new Thread(this); kj=new Thread(this); cn.start(); kj.start(); } } @Override public void run() { // TODO Auto-generated method stub if(Thread.currentThread()==kj||Thread.currentThread()==cn){ for(int i=1;i<=3;i++){

weekDay=i; cq(30); } } } public synchronized void cq(int number){ if(Thread.currentThread()==kj){ tj1.append(\今天是星期\ for(int i=0;i<3;i++){ money=money+number; try { Thread.sleep(1000); } catch (InterruptedException e) { // TODO Auto-generated catch block tj1.append(\帐上有\ } } }else if(Thread.currentThread()==cn){ } } 12、实验

（1）编写一个应用程序，除主线程外还有两个线程，一个负责模拟红色按钮从(10,60)运动到(100,60)，另一个负责模拟一个绿色按钮从(100,60)运动到(100,300)。

（2）三人排队买票，甲、乙、丙，售票员只有三张5元，电影票5元一张。甲拿20元一张的人民币排在乙的前面买票，乙排在丙前面拿一张10元人民币买票，丙拿一张5元人民币买票。(售票方法为同步对象,在售票方法中分别对接受到五元,十元和二十元的几种货币作区分,对于无法找零的情况,让当时运行的县城被挂起,知道有合适找零金额再将其唤醒。) （3）编写一个应用程序，在主线程中创建三个线程：“运货司机”“装运工”“仓库管理员”。要求线程“运货司机”占有CPU资源后立刻联合线程“装运工”，而“装运工”占有资源后立刻联合线程“仓库管理员”，打开仓库搬运货物，然后装成，运走。(采用线程联合的概念)

第九章 输入输出流

1、File类：代表了磁盘上的一个文件或一个目录，该类对象主要用来获取文件本身的一些信息，例如文件所在的目录、长度、读写权限等。注：File不涉及对文件的读写操作。 2、I/O流：流就是一个传送有序的字节序列，是传输在数据节点和程序间的连接通道上的字节序列。换句话说，流就是对输入数据源和输出目的地的抽象表示。

按照传输单位分类：字节流：数据的处理以字节为基本单位InputStream（字节输入流）OutputStream(字节输出流)；字符流，用于字符数据的处理 Reader（字符输入流）Writer(字符输出流)

3、流编程的步骤：创建节点流对象；创建节点流；利用过滤流对节点流进行封装；传递数据；关闭流 (关闭外层流) 4、例子

//字节型输入输出流的使用 public class StreamTest {

public static void main(String args[]) { int b;

byte tom[]=new byte[25];

try{ File f=new File(\ File of=new File(\ of.createNewFile();

FileInputStream in=new FileInputStream(f);

FileOutputStream out=new FileOutputStream(of); while((b=in.read(tom,0,25))!=-1)

{ String s=new String (tom,0,b); System.out.print(s);

out.write(s.getBytes()); }

in.close(); }

catch(IOException e)

{ System.out.println(\ } }

//字符型输入输出流的使用 public class ReaderTest { public static void main(String args[ ]) { File file=new File(\ String content[]={\你好:\近来工作忙吗?\常联系\祝好\ try{ FileWriter outOne=new FileWriter(file); BufferedWriter outTwo= new BufferedWriter(outOne); for(int k=0;k

}

//使用RandomAccessFile字节节点流 public class RandomAccesssTest {

public static void main(String args[]) { new CommFrame(); } }

class InputArea extends Panel implements ActionListener { File f=null;

RandomAccessFile out;

Box baseBox ,boxV1,boxV2; TextField name,email,phone; Button button; InputArea(File f)

{ //setBackground(Color.cyan); this.f=f;

name=new TextField(12); email=new TextField(12); phone=new TextField(12); button=new Button(\录入\

button.addActionListener(this); boxV1=Box.createVerticalBox(); boxV1.add(new Label(\输入姓名\

boxV1.add(Box.createVerticalStrut(8)); boxV1.add(new Label(\输入email\ boxV1.add(Box.createVerticalStrut(8)); boxV1.add(new Label(\输入电话\

boxV1.add(Box.createVerticalStrut(8)); boxV1.add(new Label(\单击录入\ boxV2=Box.createVerticalBox(); boxV2.add(name);

boxV2.add(Box.createVerticalStrut(8)); boxV2.add(email);

boxV2.add(Box.createVerticalStrut(8)); boxV2.add(phone);

boxV2.add(Box.createVerticalStrut(8)); boxV2.add(button);

baseBox=Box.createHorizontalBox(); baseBox.add(boxV1);

baseBox.add(Box.createHorizontalStrut(10)); baseBox.add(boxV2); add(baseBox); }

public void actionPerformed(ActionEvent e) { try{

RandomAccessFile out=new RandomAccessFile(f,\ if(f.exists())

{ long length=f.length();

out.seek(length); }

out.writeUTF(\姓名:\ out.writeUTF(\ out.writeUTF(\电话:\ out.close(); }

catch(IOException ee){} } }

class CommFrame extends JFrame implements ActionListener { File file=null; JMenuBar bar; JMenu fileMenu;

JMenuItem 录入,显示; JTextArea show;

InputArea inputMessage;

CardLayout card=null; //卡片式布局. JPanel pCenter; CommFrame() { super(\ Container c=this.getContentPane(); file=new File(\通讯录.txt\ 录入=new JMenuItem(\录入\ 显示=new JMenuItem(\显示\ bar=new JMenuBar();

fileMenu=new JMenu(\操作\ fileMenu.add(录入); fileMenu.add(显示); bar.add(fileMenu);

this.setJMenuBar(bar);

录入.addActionListener(this); 显示.addActionListener(this);

inputMessage=new InputArea(file); show=new JTextArea(12,20); card=new CardLayout(); pCenter=new JPanel(); pCenter.setLayout(card);

pCenter.add(\录入\ pCenter.add(\显示\

add(pCenter,BorderLayout.CENTER);

addWindowListener(new WindowAdapter()

{ public void windowClosing(WindowEvent e) { System.exit(0); } }); setVisible(true);

setBounds(100,50,420,380); validate(); }

public void actionPerformed(ActionEvent e) { if(e.getSource()==录入)

{ card.show(pCenter,\录入\ }

else if(e.getSource()==显示) { int number=1;

show.setText(null);

card.show(pCenter,\显示\

try{ RandomAccessFile in=new RandomAccessFile(file,\ String 姓名=null;

while((姓名=in.readUTF())!=null)

{ show.append(\姓名);

show.append(in.readUTF()); //读取email. show.append(in.readUTF()); //读取phone

show.append(\ number++; }

in.close(); }

catch(Exception ee){} } } }

5、实验

（1）将保存在本地机当前文件夹中的a.txt文本文件的内容在屏幕上显示出来，然后将其

另存为b.txt 文件。

分别利用字节型输入输出流和字符型输入输出流来完成。

（2）保存对象信息到文件，并将文件中的对象信息显示出来。

import java.io.*;

public class ObjectTest implements Serializable{ //序列化接口

int bh=1; int nl=21; String xm; //构造方法

ObjectTest(int bh,String xm,int nl){ }

//保存到文件中的方法 void save(String fname){

try{

FileOutputStream fout = new FileOutputStream(fname);//输出文件流 ObjectOutputStream out = new ObjectOutputStream(fout);//输出对象流 out.writeObject(this); //写入对象 out.close(); this.bh = bh; this.xm = xm; this.nl = nl;

}

}

}catch (FileNotFoundException fe){} catch (IOException ioe){}

//显示文件中对象信息的方法

void display(String fname){ }

public static void main(String arg[]){ }

String fname = \ObjectTest.obj\

ObjectTest oriObj = new ObjectTest(1,\张驰\oriObj.save(fname); oriObj.display(fname); try {

FileInputStream fin = new FileInputStream(fname);//输入文件流 ObjectInputStream in = new ObjectInputStream(fin);//输入对象流 ObjectTest oriObj = (ObjectTest)in.readObject(); //读取对象 System.out.println(\类名： \System.out.println(\ \in.close();

oriObj.getClass().getInterfaces()[0]);

}catch (FileNotFoundException fe){} catch (IOException ioe){}

catch (ClassNotFoundException ioe) {}

（2）理解打开和另存为对话框的使用，并自己编程实现，（参照实例）

第十章 网络编程

1、URL：URL规范了WWW资源网络地址的表示方法。一个URL包含两部分内容：协议名和资源名。://:/#

URL工作原理：URL对象创建后，即可通过它访问指定的WWW资源。这时需调用URL类的OpenStream()方法与指定的URL建立连接并返回一个InputStream类的对象，这样访问WWW资源的操作就转变为I/O操作，然后即可用字节流的方式读取WWW资源数据。 2、InetAddress类：netAddress类又称互连网地址类，该类的对象是封装计算机名称和IP地址的实例。

3、套接字编程：计算机网络常见应用模式：客户端/服务器（Client/Server，C/S）模式；浏览器/服务器（Brower/Server，B/S）模式。在C/S模式下，客户向服务器发出服务请求，服务器接收到请求后，提供相应的服务：客户端部分、服务器部分、“请求/响应”的工作模式 Socket：由一个地址(标识Internet上的计算机)和一个端口号(标识正在计算机上运行的进程) 来标识的网络通讯端点，利用这个端口在程序间进行数据传输。

作用：套接字是工作在是网络协议传输层的接口，利用套接字将网络作为流对象，就象对文件操作一样对这个流进行操作。

分类：流套接字：提供面向连接的、可靠的数据传输服务；数据报套接字：提供无连接的数据传输服务

4、基于TCP/IP的Socket通信模式：每一个基于TCP/IP的程序都赋予了一个端口号（0~65535），通过不同的端口号，区别服务器上运行的每一个应用程序和所提供的服务。注:习惯上将低于1024的端口号保留给系统服务使用

java.net包中包含流套接字：服务器端Socket使用ServerSocket类，客户端Socket使用Socket类。

Socket类的输入输出都是通过流来实现的。通过主机操作系统直接使用本地TCP栈进行通信。客户端流Socket的创建可通过使用Socket类的构造函数完成。构造函数不仅可以创建Socket对象，并且会尝试连接服务器端的Socket。可通过构造方法测试某个端口的连接是否允许。

ServerSocket类用在服务器端，侦听和响应客户端的连接请求，并接收客户端发送的数据。具体功能：服务器启动，耐心地等候客户端的连接请求，一旦客户端应用程序申请建立一个Socket连接，Server Socket类就会通过accept()方法返回一个对应的服务器端Socket对象，以便进行直接通信。从两台计算机连接成功时起，服务器端与客户端就得到了一个真正的“Socket-Socket”连接。 5、Socket编程的基本步骤：

1．服务器端应用程序编写步骤（1）创建一个等待连接的ServerSocket对象，如Sersocket；（2）调用Sersocket对象的accept()方法侦听接收客户端的连接请求。当侦听到一个客户的连接请求时，连接成功，并返回一个用于通信的Socket对象；（3）创建与Socket对象绑定的输入输出流，并建立相应的数据输入输出流；（4）通过数据输入输出流与客户端进行数据读写，完成双向通信；（5）当客户端断开连接时，关闭各个流对象，结束通信。（2）~（5）可循环执行。

2．客户端应用程序编写步骤（1）创建指定服务器上指定端口号的Socket对象；（2）创建与Socket对象绑定的输入输出流，并建立相应的数据输入输出流；（3）通过数据输入输出流与服务器端进行数据读写，完成双向通信；（4）通过调用close()方法关闭与服务器端的连接，并关闭各个流对象，结束通信。

6、UDP编程：用户数据报协议（User Datagram Protocol，UDP）是一种面向无连接的传输层协议，提供简单的不可靠数据传送服务。 特点：传输数据之前客户端和服务器端不建立连接，当它想发送数据时则获取来自应用程序的数据，并尽可能快地把它放到网络上。由于传输数据时不需建立连接，不需维护连接状态，因此一台服务器可同时向多个客户传输相同的数据。

UDP使用的类：DatagramPacket类包含具体的要传输的信息，这些信息被封装在称为数据报（Datagram）的UDP包中

DatagramSocket类用于收发UDP数据报。工作原理：发送数据时：需将数据封装到DatagramPacket中，使用DatagramSocket发送该包。接收数据时要从DatagramSocket中接收一个DatagramPakcet对象，然后解析该包的内容。

DatagramPacket类：定义：该类表示一个数据报包。该数据报包用来实现一个无连接包的传送服务。它是进行数据报通信的基本单位。包含了IP地址、端口号和需要传输的数据等。在发送和接收数据报时，要创建DatagramPakcet类对象作为数据的载体。

DatagramSocket类：该类表示用来发送和接收数据报包的套接字（Socket）要收发DatagramPacket，必须打开一个数据报套接字（Datagram Socket）。在Java中，数据报套接字通过DatagramSocket类来创建和访问。

7、基于UDP协议的Socket编程：建立一个DatagramSocket对象；创建用于接收或发送数据的DatagramPacket对象；利用DatagramSocket类方法receive()或send()接收或发送数据报包。

1．服务器端程序具体开发步骤：1）建立一个DatagramSocket对象；（2）进入收发数据报包的循环，直到客户端数据传送完毕。循环过程如下：创建一个用于接收数据的DatagramPakcet对象；利用DatagramSocket的receive()等待接收数据报包；处理客户端数据报包内容；创建一个用于发送响应信息数据的DatagramPakcet对象，利用DatagramSocket类方法send()向客户端发送包含响应信息的数据报包；（3）客户端数据传送完毕，释放Socket。 2．客户端程序具体开发步骤：1）建立一个DatagramSocket对象；（2）进入发收数据报包的循环，直到数据传送完毕。循环过程如下：创建一个用于发送数据的DatagramPakcet对象，并将要发送的数据封装到该数据报包；利用DatagramSocket类send()向服务器端发送数据报包；创建一个用于接收响应信息数据的DatagramPakcet对象；利用DatagramSocket类方法receive()等待接收服务器端包含响应信息的数据报包；处理服务器端数据报包内容。（3）

数据传送完毕，释放Socket。

8、UDP与TCP的比较：UDP没有两台主机间唯一连接的概念。使用UDP时，每个数据报中都给出了完整的地址信息，因此无需要建立连接。对于TCP协议，在Socket之间进行数据传输之前必然要建立连接。一个DatagramSocket可以从多个独立主机接收数据，也可向多个主机传输相同的数据，此Socket并不专用于一个连接。传输方式：TCP Socket将网络视为流，通过与Socket相关的输入输出流来收发数据。流中的数据是有序的，而UDP所处理的总是单个数据报包封装在一个数据报中的数据都以一个包的形式整体收发，一个包不需与其它包相关，各数据报包之间是无序的。数据量限制：使用UDP传输数据时有大小限制，每个被传输的数据报必须限定在64KB之内。TCP没有这方面的限制。 9、例子 TCP：

public class ClientTest {

public static void main(String args[]) { new ComputerClient(); } }

class ComputerClient extends Frame implements Runnable,ActionListener { Button connection,send;

TextField inputText,showResult; Socket socket=null;

DataInputStream in=null; DataOutputStream out=null; Thread thread; ComputerClient()

{ socket=new Socket();

setLayout(new FlowLayout()); Box box=Box.createVerticalBox();

connection=new Button(\连接服务器\ send=new Button(\发送\ send.setEnabled(false);

inputText=new TextField(12); showResult=new TextField(12); box.add(connection);

box.add(new Label(\输入三角形三边的长度,用逗号或空格分隔:\ box.add(inputText); box.add(send);

box.add(new Label(\收到的结果：\ box.add(showResult);

connection.addActionListener(this); send.addActionListener(this); thread=new Thread(this); add(box);

setBounds(10,30,300,400); setVisible(true); validate();

addWindowListener(new WindowAdapter()

{ public void windowClosing(WindowEvent e) { System.exit(0); } }); }

public void actionPerformed(ActionEvent e) { if(e.getSource()==connection)

{ try //请求和服务器建立套接字连接： { if(socket.isConnected()) {} else

{ InetAddress address=InetAddress.getByName(\

InetSocketAddress socketAddress=new InetSocketAddress(address,4331); socket.connect(socketAddress);

in =new DataInputStream(socket.getInputStream());

out = new DataOutputStream(socket.getOutputStream()); send.setEnabled(true); thread.start(); } }

catch (IOException ee){} }

if(e.getSource()==send) { String s=inputText.getText(); if(s!=null) { try { out.writeUTF(s); }

catch(IOException e1){} } } }

public void run() { String s=null; while(true) { try{ s=in.readUTF();

showResult.setText(s); }

catch(IOException e)

{ showResult.setText(\与服务器已断开\ break; } } } }

public class ServerTest {

public static void main(String args[]) { ServerSocket server=null; Server_thread thread; Socket you=null; while(true) { try{ server=new ServerSocket(4331); }

catch(IOException e1)

{ System.out.println(\正在监听\对象不能重复创建 }

try{ System.out.println(\等待客户呼叫\ you=server.accept();

System.out.println(\客户的地址:\ }

catch (IOException e)

{ System.out.println(\正在等待客户\ }

if(you!=null)

{ new Server_thread(you).start(); //为每个客户启动一个专门的线程 } } } }

class Server_thread extends Thread {

Socket socket;

DataOutputStream out=null; DataInputStream in=null; String s=null;

boolean quesion=false; Server_thread(Socket t) { socket=t; try { out=new DataOutputStream(socket.getOutputStream()); in=new DataInputStream(socket.getInputStream()); }

catch (IOException e)

{e.printStackTrace();} }

public void run() { while(true) { double a[]=new double[3] ; int i=0; try{ s=in.readUTF();//堵塞状态，除非读取到信息 quesion=false;

StringTokenizer fenxi=new StringTokenizer(s,\ while(fenxi.hasMoreTokens())

{ String temp=fenxi.nextToken(); try{ a[i]=Double.valueOf(temp).doubleValue(); i++; }

catch(NumberFormatException e) { out.writeUTF(\请输入数字字符\ quesion=true; } }

if(quesion==false) {

double p=(a[0]+a[1]+a[2])/2.0;

out.writeUTF(\ } }

catch (IOException e)

{ System.out.println(\客户离开\ return;

} } } }

UDP：

lass Beijing_Frame extends Frame implements Runnable,ActionListener { TextField out_message=new TextField(\发送数据到上海：\ TextArea in_message=new TextArea();

Button b=new Button(\发送数据包到上海\ Beijing_Frame()

{ super(\我是北京\

setSize(200,200);setVisible(true); b.addActionListener(this);

add(out_message,\ Thread thread=new Thread(this); thread.start();//线程负责接收数据包 }

public void actionPerformed(ActionEvent event)

{ byte buffer[]=out_message.getText().trim().getBytes();

try{ InetAddress address=InetAddress.getByName(\DatagramPacket data_pack=

new DatagramPacket(buffer,buffer.length, address,666);

DatagramSocket mail_data=new DatagramSocket();

in_message.append(\数据报目标主机地址:\ in_message.append(\数据报目标端口是:\ in_message.append(\数据报长度:\ mail_data.send(data_pack); }

catch(Exception e){} }

public void run()

{ DatagramSocket mail_data=null; byte data[]=new byte[8192]; DatagramPacket pack=null; try{

pack=new DatagramPacket(data,data.length); mail_data=new DatagramSocket(888); }

catch(Exception e){} while(true)

{ if(mail_data==null) break; else

try{ mail_data.receive(pack); int length=pack.getLength();

InetAddress adress=pack.getAddress(); int port=pack.getPort();

String message=new String(pack.getData(),0,length);

in_message.append(\收到数据长度：\

in_message.append(\收到数据来自：\端口：\ in_message.append(\收到数据是：\ }

catch(Exception e){} } } }

public class Beijing

{ public static void main(String args[])

{ Beijing_Frame beijing_win=new Beijing_Frame();

beijing_win.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0); } });

beijing_win.validate(); } }

class Shanghai_Frame extends Frame implements Runnable,ActionListener { TextField out_message=new TextField(\发送数据到北京：\ TextArea in_message=new TextArea();

Button b=new Button(\发送数据包到北京\ Shanghai_Frame() { super(\我是上海\ setSize(200,200); setVisible(true);

b.addActionListener(this); add(out_message,\ add(in_message,\ add(b,\

Thread thread=new Thread(this); thread.start();//线程负责接收数据包 }

public void actionPerformed(ActionEvent event) //点击按扭发送数据包 { byte buffer[]=out_message.getText().trim().getBytes(); try{ InetAddress address=InetAddress.getByName(\ DatagramPacket data_pack=new DatagramPacket(buffer,buffer.length, address,888);//构造发送数据包

DatagramSocket mail_data=new DatagramSocket();

in_message.append(\数据报目标主机地址:\ in_message.append(\数据报目标端口是:\ in_message.append(\数据报长度:\ mail_data.send(data_pack); }

catch(Exception e){} }

public void run() // //接收数据包 { DatagramPacket pack=null; DatagramSocket mail_data=null; byte data[]=new byte[8192]; try{ pack=new DatagramPacket(data,data.length); mail_data=new DatagramSocket(666); }

catch(Exception e){} while(true)

{ if(mail_data==null) break; else

try{ mail_data.receive(pack); int length=pack.getLength();

InetAddress adress=pack.getAddress(); int port=pack.getPort();

String message=new String(pack.getData(),0,length); in_message.append(\收到数据长度：\

in_message.append(\收到数据来自：\端口：\ in_message.append(\收到数据是：\ }

catch(Exception e){} } } }

public class Shanghai { public static void main(String args[])

{ Shanghai_Frame shanghai_win=new Shanghai_Frame(); shanghai_win.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {System.exit(0); } });

shanghai_win.validate(); } }

10、实验

1）本实验是基于TCP协议的C/S模式的图形界面通讯程序，以可视化操作模式，实现服务器与客户端之间的通信操作。客户端提出获取时间请求，服务器给出应答，在客户端显示当前服务器的时间（1）建立服务器端处理程序（2）建立客户端程序

2）在实验三的基础上将客户端获取的数据保存到服务器上的文件中，当客户端需要获取数据时，从服务器端获取到相应数据。具体内容如下：a、编写一个登陆界面，在该界面中包括一个用户名输入的文本框，在其中输入用户名和密码，当该用户名和密码为服务器上以保存的用户信息时，则准予用户登陆系统，跳转到登陆成功窗口。b、在登陆成功窗口建立菜单栏，包括“文件”，“操作”两个菜单，文件菜单中包括“退出”菜单项，操作菜单中包括录入和查询页面。在点击“录入”时，将打开一个用户信息录入窗口，在其中录入用户信息，包括用户名，密码和确认密码，单选按钮的性别，下拉列表的省份，以及下拉列表的城市，（随着省份列表框的选项不同，城市列表框的内容产生变化），复选框的个人爱好。可输入多组用户信息，这些用户信息会被客户端发送到服务器上所建立的数据文件中进行保存。点击“查询”子菜单项时，在查询窗口中显示服务器上数据文件中保存的所有用户信息，或根据自定义条件查询特定内容。

3）基于UDP协议的C/S模式的图形界面通讯程序，以可视化操作模式，实现服务器与客户端之间的通信操作。（1）建立服务器端聊天程序（2）建立客户端聊天程序

本文来源：https://www.bwwdw.com/article/xwlg.html