java程序解释

 

例4-2 UsePhoneCard.java

package ch4;

public class UsePhoneCard {

    public static void main(String args[]) {

        PhoneCard myCard=new PhoneCard(0000,0526,50.0,"200");

        System.out.println(myCard.toString());

    }

}

class PhoneCard{

    long cardNumber;//定义域

    private int pwd;

    double balance;

    String connectNumber;

    boolean connected;

   

    PhoneCard(long cn,int p,double b,String ctn){//构造函数，完成初始化工作

        cardNumber=cn;

        pwd=p;

        if(balance>0)

            balance=b;

        else

            System.exit(0);

        connectNumber=ctn;

        connected=false;         

    }

   

    boolean performConnection(long cn,int p){//实现接入电话的操作

        if(cn==cardNumber && p==pwd){//若用户所拨的卡号和密码与电话卡内保存的卡号和密码一致，则电话接通

            connected=true;

            return true;

        }

        else{

            connected=false;

            return false;

        }

    }

   

    double getBalance(){ //获得余额

        if(connected)

            return balance;

        else

            return -1;

    }

   

    void performDial(){

        if(connected)//先检查电话是否接通，接通责扣除一次电话的费用0.5元

            balance-=0.5;

    }

   

    public String toString(){//以字符串的形式显示出来

        String s="电话卡接入号码："+cardNumber+"电话卡卡号："+cardNumber

                +"电话卡密码："+pwd+"剩余金额"+balance;

        if(connected)

            return(s+"\n电话已接通！");

        else

            return(s+"\n电话未接通！");

    }

   

}

注：main函数通过先创建PhoneCard的一个对象myCard为之并赋值，然后调用myCard的toString方法，把myCard中的各个域数据组合成一段信息在屏幕上输出，从而实现测试功能。

例4-3 TestField.java

package ch4;

public class TestField {//测试类

    public static void main(String[] args) {

        MyDate md=new MyDate(2010,6,12);//创建日期对象，给雇用年月赋值

        Employee emp=new Employee("欧阳",21,6000,md);//创建雇员对象并为之赋值

        emp.print();//emp对象引用print方法

    }

}

class Employee{ //Employee类的域定义

    String name;

    int age;

    float salary;

    MyDate hiredate;//用户自定义的域作为域的类型

   

    Employee(String n,int a,float s,MyDate h){//构造函数

        name=n;

        if(a>=18 && a<60)//构造函数中的合法性检查，年龄限制

            age=a;

        else

        {

            System.out.println("年龄超过规定");

            System.exit(0);//结束当前程序的运行

        }

        salary=s;

        hiredate=h;

    }

   

    void print(){

        String s_hiredate;//定义变量s_hiredate，用于保存数据

        s_hiredate=hiredate.year+"年"+hiredate.month+"月"+hiredate.day+"日";

        System.out.println("姓名："+name+"年龄："+"工资："+salary+"雇用年月：");

    }

}

class MyDate{

    int year,month,day;

    MyDate(int y,int m,int d){

        year=y;

        month=m;

        day=d;

    }

}

例4-5 TestStatic.java：

package ch4;

public class TestStatic {

    public static void main(String[] args) {

        PhoneCard200 my200_1=new PhoneCard200();//创建对象

        PhoneCard200 my200_2=new PhoneCard200(); 

    }

}

class PhoneCard200{  //静态域

    static long nextCardNumber;

    static String connectNumber="200";

    static double additoryFee;

    long cardNumber;

    int password;

    boolean connected;

    double balance;

   

    static{//静态初始化器

    nextCardNumber=2012022801;

    }

    PhoneCard200(){//构造函数，使卡号从2012022801开始自动增1

        cardNumber=nextCardNumber++;

       

    }

}

例4-7 TestAbstract.java

package ch4;

public class TestAbstract {

    public static void main(String[] args) {

    }

}

abstract class PhoneCard{//抽象类

    double balance;

    abstract void performDial();//定义抽象方法performDial,为其子类规定了该方法的标准样式

   

    double TimeLeft(){//定义电话卡中的余额还可以拨打多少次电话的方法TimeLeft

        double current=balance;//保留当前的余款

        int times=0;

        do{//反复拨打电话直至余额小于0

            performDial();

            times++;

        }while(balance>=0);

        balance=current;//恢复余款

        return times-1;//返回可以拨打电话的次数

    }

}

class PhoneCard200 extends PhoneCard{//继承自PhoneCard

    static long nextCardNumber;

    static final String connectNumber="200";

    static double additoryFee;

    long cardNumber;

    int password;

    boolean connected;

   

    static{

        nextCardNumber=2012022801;

        additoryFee=0.1;//在静态初始化器中将附加费设置为0.1

    }

    PhoneCard200(double ib){//构造函数

        cardNumber=nextCardNumber++;

        balance=ib;//指定新电话卡余额

    }

    void performDial(){//重新定义父类中的抽象方法performDial()

        balance-=0.5+additoryFee;//根据200卡的特点扣除0.5元的通话费用和附加费

    }

}

class IC_Card extends PhoneCard{//PhoneCard的子类IC_Card

    IC_Card(double ib){//构造函数指定新IC卡的金额

        balance=ib;

    }

    void performDial(){//重新定义父类中的抽象方法

        balance-=0.9;//每次通话从balance中扣除0.9元的费用

    }

}

注：抽象方法可以隐藏具体的细节信息，使调用该方法的程序不必过分关注类及其子类内部的具体情况。由于所有的子类使用的都是相同的方法头，而方法头实际上包含了调用该方法的全部信息。

例5-2 TestHiddenField.java：

package ch5;

public class TestHiddenField {

    public static void main(String[] args) {

        D200_Card my200=new D200_Card();//创建D200_Card类的对象my200,这个对象有两个balance变量，一个继承自父类，一个由D200_Card重新定义

        my200.balance=50.0;//为my200对象的balance变量赋值

        System.out.println("父类被隐藏的金额为："+my200.getBalance());//输出my200对象的getBalance方法的返回值，返回父类的余额

        if(my200.performDial())//这里的performDial方法是子类的方法

            System.out.println("子类的剩余金额为："+my200.balance);//输出的是拨打电话之后my200对象的balance变量的数值

    }

}

abstract class PhoneCard{//抽象类

    double balance;

    abstract boolean performDial();//定义抽象方法

    double getBalance(){//父类定义getBalance方法，返回余额

        return balance;

    }

}

abstract class Number_PhoneCard extends PhoneCard{//子类也是抽象类

    long cardNumber;

    int password;

    String connectNumber;

    boolean connected;

   

    boolean performConnection(long cn,int pw){//构造函数

        if(cn==cardNumber && pw==password){//若用户所拨的卡号和密码与电话卡内保存的卡号和密码一致，则电话接通

            connected=true;

            return true;

        }

        else

            return false;

    }

}

class D200_Card extends Number_PhoneCard{

    double additoryFee;

    double balance;//隐藏了父类了balance，子类重新定义了balance

   

    boolean performDial(){

        if(balance>(0.5+additoryFee)){//检查余额是否大于0.5加上附加费，若是则余额减少

            balance-=(0.5+additoryFee);

            return true;

        }

        else

            return false;

        }

}

注：隐藏是指子类拥有了两个相同名字的变量，一个继承自父类，另一个由自己定义；当子类执行继承自父类的操作时，处理的是继承自父类的变量，而当子类执行它自己定义的方法时，所操作的就是它自己定义的变量，而把继承自父类的变量隐藏起来。

例5-3 TestOverLoad.java：

package ch5;

public class TestOverLoad {

    public static void main(String args[]) {

        D200_Card my200=new D200_Card();//创建D200_Card类的对象my200,这个对象有两个balance变量，一个继承自父类，一个由D200_Card重新定义

        my200.balance=50.0;//为my200对象的balance变量赋值

        System.out.println("父类自己的金额为："+my200.getBalance());//输出my200对象的getBalance方法的返回值，返回子类自己的余额

        if(my200.performDial())//这里的performDial方法是子类的方法

            System.out.println("子类的剩余金额为："+my200.balance);//输出的是拨打电话之后my200对象的balance变量的数值

    }

}

abstract class PhoneCard{//抽象类

    double balance;

    abstract boolean performDial();//定义抽象方法

    double getBalance(){//父类定义getBalance方法，返回余额

        return balance;

    }

}

abstract class Number_PhoneCard extends PhoneCard{//子类也是抽象类

    long cardNumber;

    int password;

    String connectNumber;

    boolean connected;

   

    boolean performConnection(long cn,int pw){//构造函数

        if(cn==cardNumber && pw==password){//若用户所拨的卡号和密码与电话卡内保存的卡号和密码一致，则电话接通

            connected=true;

            return true;

        }

        else

            return false;

    }

}

class D200_Card extends Number_PhoneCard{

    double additoryFee;

    double balance;//隐藏了父类的balance，子类重新定义了balance

   

    boolean performDial(){

        if(balance>(0.5+additoryFee)){//检查余额是否大于0.5加上附加费，若是则余额减少

            balance-=(0.5+additoryFee);

            return true;

        }

        else

            return false;

        }

   

    double getBalance(){//覆盖了父类的balance

        return balance;

    }

}

注：子类方法对父类同名方法的覆盖将清除父类方法占用的内存，从而使父类方法在子类对象中不复存在。

例5-7 TestPolymorphism1.java：

package ch5;

public class TestPolymorphism1 {

    public static void main(String[] args) {

        Employee emp1=new Employee("笑笑",22,3000);//创建职工对象，并且通过调用对象方法emp1.getInfo()显示了该职工的信息

        System.out.println(emp1.getInfo());

        Employee emp2=new Manager("欧阳",28,8000,2000);//创建一个管理者对象，并将对象的引用赋值给Employee类变量emp2

        System.out.println(emp2.getInfo());    //通过emp2.getInfo()方法的调用，返回职工的信息  

    }

}

class Employee{

    String name;

    int age;

    float salary;

    Employee(){ }//无参数的构造函数

    Employee(String name,int age,float salary){//带参数的构造函数,可以建立一个具体的职工对象

        this.name=name;

        this.age=age;

        this.salary=salary;

    }

   

    String getInfo(){//获取职工信息的方法

        return "职工姓名："+name+"  年龄："+age+"  工资："+salary;

    }  

}

class Manager extends Employee{

    float allowance;//津贴

    Manager(String name,int age,float salary,float allowance){//构造函数

        this.name=name;

        this.age=age;

        this.salary=salary;

        this.allowance=allowance;      

    }

}

例5-8 TestPolymorphism2.java：

package ch5;

public class TestPolymorphism2 {

    public static void main(String[] args) {

        Employee emp1=new Employee("笑笑",22,3000);//创建职工对象，并且通过调用对象方法emp1.getInfo()显示了该职工的信息

        System.out.println(emp1.getInfo());

        Employee emp2=new Manager("欧阳",28,8000,2000);//创建一个管理者对象，并将对象的引用赋值给Employee类变量emp2

        System.out.println(emp2.getInfo());    //通过emp2.getInfo()方法的调用，返回职工的信息  

    }

}

class Employee{

    String name;

    int age;

    float salary;

    Employee(){ }//无参数的构造函数

    Employee(String name,int age,float salary){//带参数的构造函数,可以建立一个具体的职工对象

        this.name=name;

        this.age=age;

        this.salary=salary;

    }

   

    String getInfo(){//获取职工信息的方法

        return "职工姓名："+name+"  年龄："+age+"  工资："+salary;

    }  

}

class Manager extends Employee{

    float allowance;//津贴

    Manager(String name,int age,float salary,float allowance){//构造函数

        this.name=name;

        this.age=age;

        this.salary=salary;

        this.allowance=allowance;      

    }

   

    String getInfo(){//子类重新定义自已的getInfo()方法，并覆盖了父类的同名方法

        return "职工姓名："+name+"  年龄："+age+"  工资："+salary+  "津贴"+allowance;

    }  

}

例5-9 TestPolymorphism3.java：

package ch5;

public class TestPolymorphism3 {

    public static void main(String[] args) {

        Employee emp1=new Employee("笑笑",22,3000);//创建职工对象，并且通过调用对象方法emp1.getInfo()显示了该职工的信息

        System.out.println(emp1.name);

        Employee emp2=new Manager("欧阳",28,8000,2000);//创建一个管理者对象，并将对象的引用赋值给Employee类变量emp2

        if(emp2 instanceof Manager){//判断emp2是否是Manager类型

            Manager mgr=(Manager)emp2;//强制类型转化，把emp2转化为Manager类型并赋值给mgr

            System.out.println(mgr.name);  

            System.out.println(mgr.allowance);

            System.out.println(mgr.getTotal());//调用mgr对象的getTotal()方法，得到经理的总薪水  

        }

    }

}

class Employee{

    String name;

    int age;

    float salary;

    Employee(){ }//无参数的构造函数

    Employee(String name,int age,float salary){//带参数的构造函数,可以建立一个具体的职工对象

        this.name=name;

        this.age=age;

        this.salary=salary;

    }

   

    String getInfo(){//获取职工信息的方法

        return "职工姓名："+name+"  年龄："+age+"  工资："+salary;

    }  

}

class Manager extends Employee{

    float allowance;//津贴

    Manager(String name,int age,float salary,float allowance){//构造函数

        this.name=name;

        this.age=age;

        this.salary=salary;

        this.allowance=allowance;      

    }

   

    String getInfo(){//子类重新定义自已的getInfo()方法，并覆盖了父类的同名方法

        return "职工姓名："+name+"  年龄："+age+"  工资："+salary+  "津贴"+allowance;

    }

   

    float getTotal(){//获得总薪水

        return salary+allowance;

    }

}

 

                                                                    

例 7-6 BtnLabelAction.java：

package ch6;

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public  class BtnLabelAction extends Applet implements ActionListener{//定义Applet类的子类的同时也声明该类实现ActionListener接口，是ActionEvent事件的监听者

    Label prompt;//定义标签

    Button btn;//定义按钮

   

    public void init(){

        prompt=new Label("你好");//创建标签对象

        btn=new Button("操作");//创建按钮对象

        add(prompt);//加入到Applet程序的图像界面中去

        add(btn);

        btn.addActionListener(this);//将按钮对象btn注册给这个监听者，这样它将监听并处理在btn上引发的动作事件     

    }

   

    public void actionPerformed(ActionEvent e){//用actionPerformed方法来处理动作事件

        if(e.getSource()==btn)//判断动作事件是否由按钮btn引发的，是则修改prompt对象的文本标签，

            if(prompt.getText()=="你好")//把你好变为再见

                prompt.setText("再见");

            else

                prompt.setText("你好");//把再见变为你好

    }

}

例 7-7  TextComponentEvent.java

package ch6;

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class TextComponentEvent extends Applet implements TextListener,ActionListener{//实现两个接口

    TextField tf;//定义单行文本框

    TextArea ta;//定义多行文本框

   

    public void init(){

        tf=new TextField(45);//创建TextField对象tf

        ta=new TextArea(5,45);//创建TextArea对象ta

        add(tf);//将tf加入到图形界面的窗框中

        add(ta);

        tf.addActionListener(this);

        tf.addTextListener(this);

    }

   

    public void textValueChanged(TextEvent e) {//textValueChanged()方法用来处理文本事件

        if(e.getSource()==tf)//当用户在tf中输入或修改文本时，在ta文本区域中可以得到一个同步的拷贝

            ta.setText(((TextField)e.getSource()).getText());    //强制类型转换 

    }

   

    public void actionPerformed(ActionEvent e) {//textValueChanged()用来处理动作事件

        if(e.getSource()==tf)//当用户在tf中输入回车时将ta中的文本清空

            ta.setText("");

       

    }  

}

例 7-16 TestCanvas.java

package ch7;

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class TestCanvas extends Applet{

    CanvasDraw cd;

    public void init(){

        cd=new CanvasDraw(new Dimension(200,180),this);//创建一个CanvasDraw对象

        cd.setBackground(Color.pink);//将画布对象的背景色设置为粉红色

        add(cd);//把画布对象放在applet窗口中

        cd.requestFocus();//使画布获得焦点

    }

}

class CanvasDraw extends Canvas{//CanvasDraw类用于测试画布类及对鼠标和键盘的事件响应,canvas对象及其子类对象是基本组件而不是容器

    Applet m_Parent;

    boolean md_Flag=false;//md_Flag表示用户是否在用鼠标画直线的标志

    int startX=0,startY=0,currentX=0,currentY=0;//startX,startY表示所画直线的起点坐标，currentX,currentY表示是当前的鼠标坐标

    StringBuffer sb=new StringBuffer();//StringBuffer对象sb用来保存用户击键所输入的字符

    public CanvasDraw(Dimension d, TestCanvas p) {//构造函数

        m_Parent=p;

        setSize(d);

        setBackground(Color.gray);//设置背景色为灰色

        addKeyListener(new KeyEventProcess());

        addMouseListener(new MouseAdpt());

        addMouseMotionListener(new MouseMotionAdpt());

        }

    void setStart(int x,int y){

        currentX=x;

        currentY=y;

    }

    void setCurrent(int x,int y){

        currentX=x;

        currentY=y;

    }

    void setMouseDragged(boolean b){

        md_Flag=b;

    }

    void showMeg(String s){

        m_Parent.showStatus(s);

    }

    void clearAll(){

        startX=0;

        startY=0;

        currentX=0;

        currentY=0;

        repaint();

    }

    public void paint(Graphics g){

        g.drawString("("+currentX+","+currentY+")",+10,20);

        if(md_Flag)

            g.drawLine(startX, startY, currentX, currentY);

    }

    class KeyEventProcess implements KeyListener{//内部类，用于对键盘事件做出响应，实现接口

        public void keyTyped(KeyEvent e){

            char ch=e.getKeyChar();

            if(ch=='c'){//当敲c键时起到清空作用

                sb.setLength(0);//清空sb

                clearAll();//清空画布

                }

            else

                sb.append(ch);

            showMeg("击键"+sb.toString());

            }

        public void keyPressed(KeyEvent e) {}//重载方法，方法体为空

        public void keyReleased(KeyEvent e) {}

    }

   

    class MouseAdpt extends MouseAdapter{//内部类继承裁剪类 MouseAdapter

        public void mousePressed(MouseEvent e){//按下鼠标键

            setStart(e.getX(),e.getY());//以X、Y为坐标开始画线

            showMeg("你开始画线");

        }

        public void mouseReleased(MouseEvent e){//鼠标键抬起

            if((startX!=currentX)|(startY!=currentY))//如果起点坐标和当前坐标不同，则说明拖动了鼠标，画出了直线

                showMeg("你画出了一条直线");

        }

        public void mouseEntered(MouseEvent e){//移动鼠标进入画布

            showMeg("鼠标进入画布");

        }

        public void mouseExited(MouseEvent e){//鼠标移出画布

            showMeg("鼠标移出画布");

        }

    }

   

    class MouseMotionAdpt extends MouseMotionAdapter{//内部类

        public void mouseMoved(MouseEvent e){//移动鼠标

            setCurrent(e.getX(),e.getY());

            setMouseDragged(false);

            repaint(10,0,60,30);//鼠标移动时只刷新画布左上角区域

        }

        public void mouseDragged(MouseEvent e){//拖动鼠标

            setCurrent(e.getX(),e.getY());

            setMouseDragged(true);

            repaint();

        }

    }

}

例 7-21 TestFrame.java

package ch7;

import java.awt.*;

import java.awt.event.*;

public class TestFrame {

    public static void main(String[] args) {

        new MyFrame();//创建frame窗口，主程序界面

    }

}

class MyFrame extends Frame{

    Button btn;

    MyFrame(){

        btn=new Button("关闭");

        setLayout(new FlowLayout());//设定标签、文本框等对象在窗框中位置安排的布局策略

        add(btn);//把按钮对象加入到Applet图形界面中

        btn.addActionListener(new HandleAct(this));

        addWindowListener(new HandleWin());

        setSize(300,200);//设置Frame大小

        setTitle("我的窗口");//设置Frame标题

        setVisible(true);//设置Frame可见

        }

    class HandleAct implements ActionListener{//用窗口中的按钮关闭窗口

        Frame my_frame;

        HandleAct(Frame f){//构造函数

            my_frame=f;

        }

        public void actionPerformed(ActionEvent e){

            my_frame.dispose();

            System.exit(0);

        }

    }

    class HandleWin extends WindowAdapter{//用标题栏上的关闭按钮关闭窗口

        public void windowClosing(WindowEvent e){//关闭窗口事件处理

            (e.getWindow()).dispose();

            System.exit(0);

        }

    }

}

例 8-2 TestQueueException.java

package ch8;

public class TestQueueException {

    public static void main(String[] args) {

        Queue queue=new Queue();//新建一个queue对象

        System.out.println("-----下面是入队操作-----");

        for(int i=1;i<=3;i++){//往队列加入三个数据，用于测试出队操作

            queue.enQueue(i);//调用queue的enQueue方法，循环执行三次

            System.out.println(queue.visitAllNode());

        }

        System.out.println("-----下面是出队操作-----");

        try{

            while(true){//死循环

                System.out.println(queue.deQueue()+"出队");//当无限制出队时才会触发异常

                System.out.println("队列中还有："+queue.visitAllNode());

            }

        }

        catch(EmptyQueueException e){//catch后 要指定能处理的异常类

            System.out.println("-----异常处理-----");

            System.out.println(e.getMessage());//取异常对象信息

            System.out.println(e.toString());//调取自定义异常的方法，输出异常详细信息         

        }

        System.out.println("-----异常处理之后的后续代码被执行-----");

    }

}

class EmptyQueueException extends Exception{//用户自定义的异常类

    Queue qq;

    public EmptyQueueException(Queue q){

        super("队列已空！");//调用父类构造函数，为异常对象设置信息

        qq=q;

    }

   

    public String toString(){//重载父类的方法，给出详细的错误信息

        return("队列对象"+qq.toString()+"执行出队操作时引发自定义异常");

    }

}

class Queue extends LinkList{//队列类是链表类的子类

    boolean isEmpty(){//判断队列是否为空

        if(m_FirstNode==null)

            return true;

        else

            return false;    

    }

    void enQueue(int newdata){//进队操作，在队列尾部加入一个数据

        Node next=m_FirstNode;

        if(next==null)

            m_FirstNode=new Node(newdata);//新建一个结点

        else{

            while(next.getNext()!=null)

                next=next.getNext();

            next.setNext(new Node(newdata));

        }

    }

   

    int deQueue() throws EmptyQueueException{//减队操作，若队列不空，则从队列头部取出一个数据

        int data;

        if(isEmpty())//出队操作时遇到队列已空

            throw(new EmptyQueueException(this));//如果队列为空，抛出异常

        else{

            data=m_FirstNode.getData();//正常出队操作

            m_FirstNode=m_FirstNode.getNext();

            return data;

        }

    }  

}

   

class Node{

    private int m_Data;//结点中保存的数据

    private Node m_Next;//结点中的指针属性，指向下一个Node对象

    Node(int data){//构造函数

        m_Data=data;

        m_Next=null;

    }

   

    int getData(){//获得结点中数据的方法

        return m_Data;

    }

   

    void setNext(Node next){//修改结点中的指针

        m_Next=next;

    }

    Node getNext(){//获得结点中的指针指向的对象引用

        return m_Next;

    }  

}

class LinkList{//定义链表类

    Node m_FirstNode;//链表中的第一个结点

    LinkList(){//构造函数1；建立空链表

        m_FirstNode=null;

    }

    String visitAllNode(){//遍历链表的每个结点，将 所有数据串成一个字符串

        Node next=m_FirstNode;//从第一个结点开始

        String s="";

        while(next!=null){//直到最后一个结点

            s=s+next.getData()+";";

            next=next.getNext();//使next指向下一个结点

        }

        return s; 

    }

}

例 8-8  MyFileIo.java

package ch8;

import java.io.*;

public class MyFileIo {//将用户键盘输入的字符保存到磁盘文件，并回显在屏幕上

    public static void main(String[] args) {

        char ch;

        int chi;

        File myPath=new File("subdir");//创建File对象代表当前目录下的subdir文件

        if(!myPath.exists())//如果此目录不存在，则创建之

            myPath.mkdir();

        File myFile=new File(myPath,"crt.txt");//创建指定目录下指定名文件

        try{

            FileOutputStream fout=new FileOutputStream(myFile);//创建FileOutputStream文件输出字节流对象

            System.out.println("请输入一个字符串并以#结尾");

            while((ch=(char)System.in.read())!='#')//当从键盘缓冲区读入的数据不是#时就写入

                fout.write(ch);//

            fout.close();//关闭文件

            System.out.println("下面是从刚写入的文件中读出的数据");

            FileInputStream fin=new FileInputStream(myFile);//利用文件名字符串创建从该文件读入数据的输入流

            while((chi=fin.read())!=-1)

                System.out.println((char)chi);

            fin.close();

        }

        catch(FileNotFoundException e){//抛出异常FileNotFoundException

            System.err.println(e);

        }

        catch(IOException e){//凡输入输出操作，都可能引发异常，必须使用try和catch

            System.err.println(e);

        }

    }

}

例 9-3

package ch9;

import java.awt.*;

import java.awt.event.*;

import java.sql.*;

public class AccEmp3 {

    public static void main(String[] args) {

        new Emp();

    }

}

class Emp extends Frame{

    Panel p1,p2,p3;

    Label e1,e2,e3,e4,e5,e6,msg;

    TextField text1,text2,text3,text4,text5,text6;

    CheckboxGroup sex;

    Checkbox m,w;//分别代表"男"，"女"

    Button b1;

    Connection cn;

    PreparedStatement ps;

    String ssql,ssex;

    Emp(){

        try{

            DriverManager.registerDriver(new sun.jdbc.odbc.JdbcOdbcDriver());

            cn=DriverManager.getConnection("jdbc:odbc:employee");

            ssql="INSERT INTO emp VALUES(?,?,?,?,?,?)";

            ps=cn.prepareStatement(ssql);

        }catch(SQLException el){

            msg.setText("数据库连接有误!");

        };

        e1=new Label("职工号");

        e2=new Label("姓名");

        e3=new Label("性别");

        e4=new Label("出生年月");

        e5=new Label("工资");

        e6=new Label("部门号");

        msg=new Label("             ");

        text1=new TextField(10);

        text2=new TextField(10);

        text3=new TextField(10);

        text4=new TextField(10);

        text5=new TextField(10);

        text6=new TextField(10);

        sex=new CheckboxGroup();

        m=new Checkbox("男",true,sex);

        w=new Checkbox("女",false,sex);

        b1=new Button("插入职工记录");

        p1=new Panel();

        p2=new Panel();

        p3=new Panel();

        p1.add(e1);p1.add(e2);p1.add(e3);p1.add(text1);p1.add(text2);p1.add(m);p1.add(w);

        p2.add(e4);p2.add(e5);p2.add(e6);p2.add(text4);p2.add(text5);p2.add(text6);

        p3.add(msg);p3.add(b1);

        setLayout(new FlowLayout());

        add(p1);add(p2);add(p3);

        b1.addActionListener(new B1());

        addWindowListener(new WinClose());

        setSize(500,200);

        setTitle("职工信息维护");

        setVisible(true);    

    }

   

    class B1 implements ActionListener{//插入职工记录按钮

        public void actionPerformed(ActionEvent e) {

            try{

                ps.setString(1,text1.getText());//为SQL语句中参数赋值

                ps.setString(2,text2.getText());

                if(m.getState())

                    ssex="男";

                else

                    ssex="女";

                ps.setString(3, ssex);

                ps.setString(4, text4.getText());

                ps.setInt(5, Integer.parseInt(text5.getText()));

                ps.setString(6, text6.getText());

                ps.executeUpdate();//执行INSERT语句

                msg.setText("记录插入成功");

                text2.setText("");//清空各输入框

                text4.setText("");

                text5.setText("");

                text6.setText("");

                text1.setText("");

                text1.requestFocus();    //焦点移到第一个输入框         

            }catch(Exception e2){

                msg.setText("输入数据有误!");

                text1.requestFocus();

            }          

        }      

    }

   

    class WinClose extends WindowAdapter{//关闭窗口

        public void windowClosing(WindowEvent e){//关闭窗口事件处理

            try{

                cn.commit();

                cn.close();

            }catch(SQLException e3){};

            (e.getWindow()).dispose();

            System.exit(0);

        }

    }

   

}