BlogJava-大头剑客学习园地--路在自己脚下......-文章分类-学习笔记

自己编写的计算器

大头剑客 — Sat, 29 Sep 2007 07:27:00 GMT

此仅为自己学习之用，欢迎各位朋友批评指正，谢谢。

package cal.test;

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class CalTest extends JFrame implements ActionListener
{
private static final long serialVersionUID = 1L;
private JPanel jContentPane = null;
private JTextField tf = null;
private JButton Backspace = null;
private JButton clear = null;
private JButton bt7 = null;
private JButton bt8 = null;
private JButton bt9 = null;
private JButton bt11 = null;
private JButton sqrt = null;
private JButton bt4 = null;
private JButton bt5 = null;
private JButton bt6 = null;
private JButton bt12 = null;
private JButton bt13 = null;
private JButton bt1 = null;
private JButton bt2 = null;
private JButton bt3 = null;
private JButton bt14 = null;
private JButton jButton = null;
private JButton bt15 = null;
private JButton bt0 = null;
private JButton bt16 = null;
private JButton bt17 = null;
private JButton bt18 = null;
private JButton bt19 = null;

boolean com=false;//用来判断是否点击过"+-*/"
boolean rs=false;//是否点击过'='
boolean qm=false;//取模
int flag=0;
int i=0;
String beforeNum=""; // @jve:decl-index=0:
String afterNum=""; // @jve:decl-index=0:

private JTextField getTf()
{
  if (tf == null)
  {
   tf = new JTextField();
   tf.setBounds(new Rectangle(5, 3, 283, 24));
  }
  return tf;
}

private JButton getBackspace() {
  if (Backspace == null) {
   Backspace = new JButton();
   Backspace.setBounds(new Rectangle(35, 41, 80, 28));
   Backspace.setText("C");
   Backspace.setForeground(Color.RED);
   Backspace.setFont(new Font("",Font.BOLD,15));
   Backspace.addActionListener(this);
  }
  return Backspace;
}

private JButton getClear() {
  if (clear == null) {
   clear = new JButton();
   clear.setBounds(new Rectangle(150, 41, 110, 28));
   clear.setText("Backspace");
   clear.setForeground(Color.RED);
   clear.setFont(new Font("",Font.BOLD,15));
   clear.addActionListener(this);
  }
  return clear;
}

private JButton getBt7() {
  if (bt7 == null) {
   bt7 = new JButton();
   bt7.setBounds(new Rectangle(3, 83, 53, 30));
   bt7.setText("7");
   bt7.setForeground(Color.BLUE);
   bt7.setFont(new Font("",Font.BOLD,15));
   bt7.addActionListener(this);
  }
  return bt7;
}

private JButton getBt8() {
  if (bt8 == null) {
   bt8 = new JButton();
   bt8.setBounds(new Rectangle(59, 83, 53, 30));
   bt8.setText("8");
   bt8.setForeground(Color.BLUE);
   bt8.setFont(new Font("",Font.BOLD,15));
   bt8.addActionListener(this);
  }
  return bt8;
}

private JButton getBt9() {
  if (bt9 == null) {
   bt9 = new JButton();
   bt9.setBounds(new Rectangle(117, 83, 53, 30));
   bt9.setText("9");
   bt9.setForeground(Color.BLUE);
   bt9.setFont(new Font("",Font.BOLD,15));
   bt9.addActionListener(this);
  }
  return bt9;
}

private JButton getBt11() {
  if (bt11 == null) {
   bt11 = new JButton();
   bt11.setBounds(new Rectangle(175, 83, 53, 30));
   bt11.setText("/");
   bt11.setForeground(Color.RED);
   bt11.setFont(new Font("",Font.BOLD,15));
   bt11.addActionListener(this);
  }
  return bt11;
}

private JButton getSqrt() {
  if (sqrt == null) {
   sqrt = new JButton();
   sqrt.setBounds(new Rectangle(233, 83, 53, 30));
   sqrt.setText("sqrt");
   sqrt.setForeground(Color.BLUE);
   sqrt.addActionListener(this);
   //sqrt.setFont(new Font("",Font.BOLD,10));
  }
  return sqrt;
}

private JButton getBt4() {
  if (bt4 == null) {
   bt4 = new JButton();
   bt4.setBounds(new Rectangle(3, 125, 53, 30));
   bt4.setText("4");
   bt4.setForeground(Color.BLUE);
   bt4.setFont(new Font("",Font.BOLD,15));
   bt4.addActionListener(this);
  }
  return bt4;
}

private JButton getBt5() {
  if (bt5 == null) {
   bt5 = new JButton();
   bt5.setBounds(new Rectangle(59, 125, 53, 30));
   bt5.setText("5");
   bt5.setForeground(Color.BLUE);
   bt5.setFont(new Font("",Font.BOLD,15));
   bt5.addActionListener(this);
  }
  return bt5;
}

private JButton getBt6() {
  if (bt6 == null) {
   bt6 = new JButton();
   bt6.setBounds(new Rectangle(117, 125, 53, 30));
   bt6.setText("6");
   bt6.setForeground(Color.BLUE);
   bt6.setFont(new Font("",Font.BOLD,15));
   bt6.addActionListener(this);
  }
  return bt6;
}

private JButton getBt12() {
  if (bt12 == null) {
   bt12 = new JButton();
   bt12.setBounds(new Rectangle(175, 125, 53, 30));
   bt12.setText("*");
   bt12.setForeground(Color.RED);
   bt12.setFont(new Font("",Font.BOLD,18));
   bt12.addActionListener(this);
  }
  return bt12;
}

private JButton getBt13() {
  if (bt13 == null) {
   bt13 = new JButton();
   bt13.setBounds(new Rectangle(233, 125, 53, 30));
   bt13.setText("%");
   bt13.setForeground(Color.BLUE);
   bt13.setFont(new Font("",Font.BOLD,15));
   bt13.addActionListener(this);
  }
  return bt13;
}

private JButton getBt1() {
  if (bt1 == null) {
   bt1 = new JButton();
   bt1.setBounds(new Rectangle(3, 167, 53, 30));
   bt1.setText("1");
   bt1.setForeground(Color.BLUE);
   bt1.setFont(new Font("",Font.BOLD,15));
   bt1.addActionListener(this);
  }
  return bt1;
}

private JButton getBt2() {
  if (bt2 == null) {
   bt2 = new JButton();
   bt2.setBounds(new Rectangle(59, 167, 53, 30));
   bt2.setText("2");
   bt2.setForeground(Color.BLUE);
   bt2.setFont(new Font("",Font.BOLD,15));
   bt2.addActionListener(this);
  }
  return bt2;
}

private JButton getBt3() {
  if (bt3 == null) {
   bt3 = new JButton();
   bt3.setBounds(new Rectangle(117, 167, 53, 30));
   bt3.setText("3");
   bt3.setForeground(Color.BLUE);
   bt3.setFont(new Font("",Font.BOLD,15));
   bt3.addActionListener(this);
  }
  return bt3;
}

private JButton getBt14() {
  if (bt14 == null) {
   bt14 = new JButton();
   bt14.setBounds(new Rectangle(175, 167, 53, 30));
   bt14.setText("-");
   bt14.setForeground(Color.RED);
   bt14.setFont(new Font("",Font.BOLD,18));
   bt14.addActionListener(this);
  }
  return bt14;
}

private JButton getJButton() {
  if (jButton == null) {
   jButton = new JButton();
   jButton.setBounds(new Rectangle());
   jButton.setText("1/x");
   jButton.addActionListener(this);
  }
  return jButton;
}

private JButton getBt15() {
  if (bt15 == null) {
   bt15 = new JButton();
   bt15.setBounds(new Rectangle(233, 167, 53, 30));
   bt15.setText("1/x");
   bt15.setForeground(Color.BLUE);
   bt15.setFont(new Font("",Font.BOLD,15));
   bt15.addActionListener(this);
  }
  return bt15;
}

private JButton getBt0() {
  if (bt0 == null) {
   bt0 = new JButton();
   bt0.setBounds(new Rectangle(3, 209, 53, 30));
   bt0.setText("0");
   bt0.setForeground(Color.BLUE);
   bt0.setFont(new Font("",Font.BOLD,15));
   bt0.addActionListener(this);
  }
  return bt0;
}

private JButton getBt16() {
  if (bt16 == null) {
   bt16 = new JButton();
   bt16.setBounds(new Rectangle(59, 209, 53, 30));
   bt16.setText("+/-");
   bt16.setForeground(Color.BLUE);
   bt16.setFont(new Font("",Font.BOLD,15));
   bt16.addActionListener(this);
  }
  return bt16;
}

private JButton getBt17() {
  if (bt17 == null) {
   bt17 = new JButton();
   bt17.setBounds(new Rectangle(117, 209, 53, 30));
   bt17.setText(".");
   bt17.setForeground(Color.BLUE);
   bt17.setFont(new Font("",Font.BOLD,18));
   bt17.addActionListener(this);
  }
  return bt17;
}

private JButton getBt18() {
  if (bt18 == null) {
   bt18 = new JButton();
   bt18.setBounds(new Rectangle(175, 209, 53, 30));
   bt18.setText("+");
   bt18.setForeground(Color.RED);
   bt18.setFont(new Font("",Font.BOLD,15));
   bt18.addActionListener(this);
  }
  return bt18;
}

private JButton getBt19() {
  if (bt19 == null) {
   bt19 = new JButton();
   bt19.setBounds(new Rectangle(233, 209, 53, 30));
   bt19.setText("=");
   bt19.setForeground(Color.RED);
   bt19.setFont(new Font("",Font.BOLD,15));
   bt19.addActionListener(this);
  }
  return bt19;
}

public static void main(String[] args)
{
  // TODO Auto-generated method stub
  SwingUtilities.invokeLater(new Runnable()
  {
   public void run()
   {
    CalTest thisClass = new CalTest();
    thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    thisClass.setVisible(true);
   }
  });
}

public CalTest()
{
  super();
  initialize();
  this.setResizable(false);
}

private void initialize()
{
  this.setSize(296, 284);
  this.setContentPane(getJContentPane());
  this.setTitle("计算器");
  Dimension screenSize=Toolkit.getDefaultToolkit().getScreenSize();
  Dimension frameSize=this.getSize();
  if(frameSize.width>screenSize.width)
  {
   frameSize.width=screenSize.width;
  }
  if(frameSize.height>screenSize.height)
  {
   frameSize.height=screenSize.height;
  }
  this.setLocation((screenSize.width-frameSize.width)/5, (screenSize.width-frameSize.width)/5);
  tf.setHorizontalAlignment(JTextField.RIGHT);//使数字从右边显示
  tf.setEditable(false);
  tf.setText("0.");
}

private JPanel getJContentPane() {
  if (jContentPane == null) {
   jContentPane = new JPanel();
   jContentPane.setLayout(null);
   jContentPane.add(getTf(), null);
   jContentPane.add(getBackspace(), null);
   jContentPane.add(getClear(), null);
   jContentPane.add(getBt7(), null);
   jContentPane.add(getBt8(), null);
   jContentPane.add(getBt9(), null);
   jContentPane.add(getBt11(), null);
   jContentPane.add(getSqrt(), null);
   jContentPane.add(getBt4(), null);
   jContentPane.add(getBt5(), null);
   jContentPane.add(getBt6(), null);
   jContentPane.add(getBt12(), null);
   jContentPane.add(getBt13(), null);
   jContentPane.add(getBt1(), null);
   jContentPane.add(getBt2(), null);
   jContentPane.add(getBt3(), null);
   jContentPane.add(getBt14(), null);
   jContentPane.add(getJButton(), null);
   jContentPane.add(getBt15(), null);
   jContentPane.add(getBt0(), null);
   jContentPane.add(getBt16(), null);
   jContentPane.add(getBt17(), null);
   jContentPane.add(getBt18(), null);
   jContentPane.add(getBt19(), null);
  }
  return jContentPane;
}

public void actionPerformed(ActionEvent e)
{
  //变量com为true点击过"+-*/"，反之变量com为false没有点击过"+-*/"
  //数字键1
  if(e.getSource()==bt1)
  {
   if(com)
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("1");
     com=false;
    }
    else
    {
     tf.setText(tf.getText().trim()+"1");
    }
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("1");
    }
    else
    {
     tf.setText(tf.getText().trim()+"1");
    }
   }
  }
  //数字键2
  else if(e.getSource()==bt2)
  {
   if(com==true)
   {
    tf.setText(tf.getText().trim()+"2");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("2");
    }
    else
    {
     tf.setText(tf.getText().trim()+"2");
    }
   }
  }
  //数字键3
  else if(e.getSource()==bt3)
  {
   if(com==true)
   {
    tf.setText(tf.getText().trim()+"3");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("3");
    }
    else
    {
     tf.setText(tf.getText().trim()+"3");
    }
   }
  }
  //数字键4
  else if(e.getSource()==bt4)
  {
   if(com)
   {
    tf.setText(tf.getText().trim()+"4");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("3");
    }
    else
    {
     tf.setText(tf.getText().trim()+"4");
    }
   }
  }
  //数字键5
  else if(e.getSource()==bt5)
  {
   if(com)
   {
    tf.setText(tf.getText().trim()+"5");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("5");
    }
    else
    {
     tf.setText(tf.getText().trim()+"5");
    }
   }
  }
  //数字键6
  else if(e.getSource()==bt6)
  {
   if(com)
   {
    tf.setText(tf.getText().trim()+"6");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("6");
    }
    else
    {
     tf.setText(tf.getText().trim()+"6");
    }
   }
  }
  //数字键7
  else if(e.getSource()==bt7)
  {
   if(com)
   {
    tf.setText(tf.getText().trim()+"7");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("7");
    }
    else
    {
     tf.setText(tf.getText().trim()+"7");
    }
   }
  }
  //数字键8
  else if(e.getSource()==bt8)
  {
   if(com)
   {
    tf.setText(tf.getText().trim()+"8");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("8");
    }
    else
    {
     tf.setText(tf.getText().trim()+"8");
    }
   }
  }
  //数字键9
  else if(e.getSource()==bt9)
  {
   if(com)
   {
    tf.setText(tf.getText().trim()+"9");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("9");
    }
    else
    {
     tf.setText(tf.getText().trim()+"9");
    }
   }
  }
  //数字键0
  else if(e.getSource()==bt0)
  {
   if(tf.getText().trim().equals("0."))
   {}
   else
   {
    tf.setText(tf.getText().trim()+"0");
   }
  }
  //运算符+
  else if(e.getSource()==bt18)
  {
   if(com==true)
   {}
   else
   {
    beforeNum=tf.getText().trim();
    tf.setText(tf.getText().trim()+"+");
    com=true;
    flag=1;
   }
  }
  //运算符-
  else if(e.getSource()==bt14)
  {
   if(com==true)
   {}
   else
   {
    beforeNum=tf.getText().trim();
    tf.setText(tf.getText().trim()+"-");
    flag=2;
    com=true;
   }
  }
  //运算符*
  else if(e.getSource()==bt12)
  {
   if(com==true)
   {}
   else
   {
    beforeNum=tf.getText().trim();
    tf.setText(tf.getText().trim()+"*");
    flag=3;
    com=true;
   }
  }
  //运算符/
  else if(e.getSource()==bt11)
  {
   if(com==true)
   {}
   else
   {
    beforeNum=tf.getText().trim();
    tf.setText(tf.getText().trim()+"/");
    flag=4;
    com=true;
   }
  }
  //运算符%
  else if(e.getSource()==bt13)
  {
   tf.setText(tf.getText().trim()+"%");
   qm=true;
  }
  //运算符1/x
  else if(e.getSource()==bt15)
  {
   if(com==false&&rs==false)
   {
    double d=Double.valueOf(tf.getText().trim());
    tf.setText(String.valueOf(1/d));
   }
  }
  //运算符sqrt
  else if(e.getSource()==sqrt)
  {
   if(com==false&&rs==false)
   {
    double d=Double.valueOf(tf.getText().trim());
    tf.setText(String.valueOf(Math.sqrt(d)));
   }
  }
  //退格
  else if(e.getSource()==clear)
  {
   if(tf.getText().trim().length()<1)
   {
    tf.setText("0.");
   }
   else
   {
    if(tf.getText().trim().equals("0."))
    {
     tf.setText("0.");
    }
    else
    {
     tf.setText(tf.getText().trim().substring(0, tf.getText().trim().length()-1));
    }
    if(tf.getText().trim().indexOf('=')==-1)
    {
     rs=false;
    }
    if(tf.getText().trim().indexOf('+')==-1)
    {
     com=false;
    }
    else
    {
     com=true;
    }
    if(tf.getText().trim().indexOf('-')==-1)
    {
     com=false;
    }
    else
    {
     com=true;
    }
    if(tf.getText().trim().indexOf('*')==-1)
    {
     com=false;
    }
    else
    {
     com=true;
    }
    if(tf.getText().trim().indexOf('/')==-1)
    {
     com=false;
    }
    else
    {
     com=true;
    }
    if(tf.getText().trim().indexOf('%')==-1)
    {
     qm=false;
    }
    else
    {
     qm=true;
    }
   }
  }
  else if(e.getSource()==Backspace)
  {
   //清除文本框中的全部内容
   tf.setText("0.");
   com=false;
   rs=false;
   qm=false;
  }
  //运算符+/-
  else if(e.getSource()==bt16)
  {
   if(com==false&&rs==false&&qm==false)
   {
    String str=tf.getText().trim();
    double d=Double.parseDouble(str);
    if(d>0)
    {
     tf.setText(String.valueOf(-d));
    }
    else
    {
     tf.setText(String.valueOf(Math.abs(-d)));
    }
   }
  }
  //运算符"."
  else if(e.getSource()==bt17)
  {
   //如果点击过"+-*/"
   if(com==true)
   {
    int index=0;
    if(flag==1)//点击'+'
    {
     index=tf.getText().trim().indexOf('+');
     String str=tf.getText().trim().substring(index);
     if(str.indexOf('.')==-1)
     {
      tf.setText(tf.getText().trim()+".");
     }
    }
    else if(flag==2)//点击'-'
    {
     index=tf.getText().trim().indexOf('-');
     String str=tf.getText().trim().substring(index);
     if(str.indexOf('.')==-1)
     {
      tf.setText(tf.getText().trim()+".");
     }
    }
    else if(flag==3)//点击'*'
    {
     index=tf.getText().trim().indexOf('*');
     String str=tf.getText().trim().substring(index);
     if(str.indexOf('.')==-1)
     {
      tf.setText(tf.getText().trim()+".");
     }
    }
    else if(flag==4)//点击'/'
    {
     index=tf.getText().trim().indexOf('/');
     String str=tf.getText().trim().substring(index);
     if(str.indexOf('.')==-1)
     {
      tf.setText(tf.getText().trim()+".");
     }
    }
   }
   //如果没有点击过"+-*/"
   else
   {
    if(tf.getText().trim().indexOf('.')==-1)
    {
     tf.setText(tf.getText().trim()+".");
    }
   }
  }
  //数字键'='
  else if(e.getSource()==bt19)
  {
   //先判断取模键是否为true,如果为true，就进行取模运行；否则进行“+-*/”运算
   if(qm==true)
   {
    if(com==false&&rs==false)
    {
     int index=tf.getText().trim().indexOf('%');
     String beforeStr=tf.getText().trim().substring(0, index);
     String afterStr=tf.getText().trim().substring(index+1);
     if(afterStr.length()>0)
     {
      double d1=Double.valueOf(beforeStr);
      double d2=Double.valueOf(afterStr);
      tf.setText(tf.getText().trim()+"="+String.valueOf((int)(d1%d2)));
      qm=false;
     }
    }
   }
   else
   {
    //先判断“=”键是否存在，假如不存在执行下列语句，否则下面的else语句。
    if(rs==false)
    {
     Double result=0.0;
     switch (flag)
     {
      case 1://点击'+'
      {
       int index=0;
       index=tf.getText().trim().indexOf('+');
       afterNum=tf.getText().trim().substring(index+1);
       result=Double.valueOf(beforeNum)+Double.parseDouble(afterNum);
       tf.setText(tf.getText().trim()+"="+result.toString());
       break;
      }
      case 2://点击'-'
      {
       int index=0;
       index=tf.getText().trim().indexOf('-');
       afterNum=tf.getText().trim().substring(index+1);
       result=Double.valueOf(beforeNum)-Double.parseDouble(afterNum);
       tf.setText(tf.getText().trim()+"="+result.toString());
       break;
      }
      case 3://点击'*'
      {
       int index=0;
       index=tf.getText().trim().indexOf('*');
       afterNum=tf.getText().trim().substring(index+1);
       result=Double.valueOf(beforeNum)*Double.parseDouble(afterNum);
       tf.setText(tf.getText().trim()+"="+result.toString());
       break;
      }
      case 4://点击'/'
      {
       int index=0;
       index=tf.getText().trim().indexOf('/');
       afterNum=tf.getText().trim().substring(index+1);
       if(Double.valueOf(afterNum)==0)
       {
        tf.setText("除数不能为零");
       }
       else
       {
        result=Double.valueOf(beforeNum)/Double.parseDouble(afterNum);
        tf.setText(tf.getText().trim()+"="+result.toString());
       }

       break;
      }
     }
     rs=true;
    }
    else
    {
     Double result=0.0;
     switch (flag)
     {
      case 1://点击'+'
      {
       int index=0;
       int x=0;
       index=tf.getText().trim().indexOf('+');
       x=tf.getText().trim().indexOf('=');
       afterNum=tf.getText().trim().substring(index+1, x);
       result=Double.valueOf(beforeNum)+Double.parseDouble(afterNum);
       tf.setText(tf.getText().trim().substring(0,x+1)+result.toString());
       break;
      }
      case 2://点击'-'
      {
       int index=0;
       int x=0;
       index=tf.getText().trim().indexOf('-');
       x=tf.getText().trim().indexOf('=');
       afterNum=tf.getText().trim().substring(index+1, x);
       result=Double.valueOf(beforeNum)-Double.parseDouble(afterNum);
       tf.setText(tf.getText().trim().substring(0,x+1)+result.toString());
       break;
      }
      case 3://点击'*'
      {
       int index=0;
       int x=0;
       index=tf.getText().trim().indexOf('*');
       x=tf.getText().trim().indexOf('=');
       afterNum=tf.getText().trim().substring(index+1, x);
       result=Double.valueOf(beforeNum)*Double.parseDouble(afterNum);
       tf.setText(tf.getText().trim().substring(0,x+1)+result.toString());
       break;
      }
      case 4://点击'/'
      {
       int index=0;
       int x=0;
       index=tf.getText().trim().indexOf('/');
       x=tf.getText().trim().indexOf('=');
       afterNum=tf.getText().trim().substring(index+1, x);
       if(Double.valueOf(afterNum)==0)
       {
        tf.setText("除数不能为零");
       }
       else
       {
        result=Double.valueOf(beforeNum)/Double.parseDouble(afterNum);
        tf.setText(tf.getText().trim().substring(0,x+1)+result.toString());
       }
       break;
      }
     }
    }
   }
  }

}
} // @jve:decl-index=0:visual-constraint="220,8"

大头剑客 2007-09-29 15:27 发表评论

第8章 GUI/图形用户界面

大头剑客 — Wed, 19 Sep 2007 04:42:00 GMT

摘要: 第8章 GUI/图形用户界面 &n... 阅读全文

大头剑客 2007-09-19 12:42 发表评论

第七章 IO/输入与输出

大头剑客 — Tue, 21 Aug 2007 04:55:00 GMT

摘要: 第七章 IO/输入与输出 ● File类 ● RandomAccessFile类 ● 各种节点流类 ● 字符编码 ● 各种过滤流与包装... 阅读全文

大头剑客 2007-08-21 12:55 发表评论

第六章 Java API

大头剑客 — Mon, 02 Jul 2007 04:04:00 GMT

摘要: 第六讲 Java API ● 理解API的概念 ● java辅助工具的使用 ● String类和StringBuffer类 ● 基本数据类型的对象包装类 ● &... 阅读全文

大头剑客 2007-07-02 12:04 发表评论

第五章多线程

大头剑客 — Fri, 08 Jun 2007 02:46:00 GMT

摘要: 第五讲多线程 ● 在多任务系统中，每个独立执行的程序称为进程，也就是“正在进行的程序”。我们现在使用的操作系统一般都是多任务的，即能够同时执行多个应用程序，实际情况是，操作系统负责CPU等设备的资源进行分配和管理，虽然这些设备某一时刻只能做一件事，但以非常小的时间间隔交替执行多个程序，就可以给人以同时执行... 阅读全文

大头剑客 2007-06-08 10:46 发表评论

第四章面向对象（下）

大头剑客 — Thu, 07 Jun 2007 15:35:00 GMT

摘要: 第四讲面向对象（下）类的继承 ● 通过继承可以简化类的定义 ● Java只支持单继承，不允许多重继承。 ● 可以有多层继承，即一个类可以继承某一个类的子类，如类B继承了类A，类C又可以继承类B，那么类C也间接继承了类A。 ●... 阅读全文

大头剑客 2007-06-07 23:35 发表评论

第三章面向对象（上）

大头剑客 — Thu, 07 Jun 2007 15:33:00 GMT

第三讲 面向对象

理解面向对象的概念

● 面向过程

在一个结构体中定义窗口的大小，位置，颜色，背景等属性，对窗口操作的函数与窗口本身的定义没有任何关系，如HideWindow,MoveWindow,MinimizeWindow，这些函数都需要接受一个代表要被操作的窗口参数，是一种谓语与宾语的关系。

● 面向对象

定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，位置，颜色，背景等外，还要指定该窗口可能具有的动作，如隐藏，移动，最小化等。这些函数被调用时，都是以某个窗口要隐藏某个窗口要移动的语法格式来使用的，这是一种主语与谓语的关系。

● 面向对象的三大特征

▂封装

▂继承

▂多态

类与对象

类是对某一类事物的描述，是抽象的，概念上的定义;对象是实际存在的该类事物的每个个体，因而也称实例（instance）。

如果将对象比作汽车，那么类就是汽车的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。

类的定义

public class Person()

{

int age;

void shout()

{

System.out.println("I am age "+age);

}

● age是类的属性，也叫类成员变量

● shout是方法也叫类的成员函数。

● shout方法可以直接访问同一类中的age变量，如果一个方法中有与成员同名的局部变量，该方法中对这个
变量名的访问是局部变量，而不是成员变量。

在类中创建的成员变量会被初始化，局部变量不会被初始化。

对象的使用

创建新的对象之后，我们就可以使用“对象名.对象成员”的格式，来访问对象的成员（包括属性和方法）

class Person

{

int age;

void shout()

{

System.out.println("age="+age);

}

class TestPerson

{

public static void main(String[]args)

{

Person p1=new Person();

p1.age=20;

p1.shout();

Person p2=new Person();

p2.shout();

}

上面程序运行的内存布局如下：

对象的比较

● “==”运算符与equals()方法的区别

“==”用来比较值是否相等，equals()方法用来比较两个对象的内容是否相等

● 怎样比较两个数组对象的内容是否相等

arrays.equals(ary1[],ary2[]);

匿名对象

● 我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象，
如：new Person().shout();

● 如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。

● 我们经常将匿名对象作为实参传递给一个函数调用。

实现类的封装性

● 如果外面的程序可以随意修改一个类的成员变量，会造成不可预料的程序错误，就象一个人身高，不能被外部随意修改，只能通过各种摄取营养的方法去修改这个属性。

● 在定义一个类的成员（包括变量和方法）时，使用private关键字说明这个成员的访问权限，这个成员成了类的私有成员，只能被这个类其他成员方法调用，而不能被其他类中的方法所调用。

● 为了实现良好的封装性，我们通常将类的成员变量声明为private，再通过public方法来对这个变量进行访问。对一个变量操作，一般都有读取和赋值操作，我们分别定义两个方法来实现这两种操作，一个是getXxx()方法（Xxx表示要访问的成员变量的名字），用来读取这个成员变量操作，另外一个是setXxx()用来对这个变量赋值。

● 一个类通常就是一个小的模块，我们应该让模块仅仅公开必须要让外界知道的内容，而隐藏其它一切内容。我们在进行程序的详细设计时，应尽量避免一个模块直接修改或操作另外一个模块的数据，模块设计追求强内聚（许多功能尽量在类的内部独立完成，不让外面干预），弱耦合（提供给外部尽量少的方法调用）。

class Person
{
  private int age;
  void shout()
  {
    System.out.println(age);
  }
  public void setAge(int x)
  {
     if(x<0)
       return;
     age=x;
  }
  public int getAge()
  {
     return age;
  }

}

class TestPerson
{
  public static void main(String[]args)
  {
    Person p=new Person();
    p.setAge(18);
    p.shout();
    System.out.println(p.getAge());
  }


}

构造函数的定义与作用

● 构造函数的特征

▁它具有与类相同的名称；

▁它不含返回值

▁它不能在方法中用return语句返回一个值

注意：在构造方法里不含返回值的概念是不同于“void”的，在定义构造方法时加了”voiid”，结果这个方法就不再被自动调用。

● 构造方法的作用：当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码。

构造方法的重载

● 和一般的方法重载一样，重载的构造方法具有不同个数或不同类型的参数，编译器就可以根据这一点判断出用new 关键字产生对象时，该调用哪个构造方法了。产生对象的格式是：new 类名（参数列表）；

● 重载构造方法可以完成不同初始化的操作，如：p3=new Person(“Tom”18);语句，会做这样几件事：创建指定类的新实例对象，在堆内存中为实例对象分配内存空间，并调用指定类的构造方法，最后将实例对象的首地址赋值给引用变量p3。

This引用句柄的应用

● 一个类中成员方法可以直接调用同类中的其他成员，其实我们在一个方法内部使用“this.其他成员”的引用方式和直接使用“其他成员”的效果是一样的，那this还有多大的作用呢？在有些情况下，我们是非得用this关键字不可的：

▁让类的成员变量名和对其进行赋值的成员方法的形参变量同名是必要的，这样的代码谁看了都能明白这两个变量是彼此相关的。

▁假设我们有一个容器类和一个部件类，在容器类的某个方法中创建部件类的实例对象，而部件类的构造方法要接收一个代表其所在容器的参数。

▁构造方法是在产生对象时被java系统自动调用的，我们不能在程序中象调用其他方法一样去调用构造方法。但我们可以在一个构造方法里调用其他重载的构造方法，不是用构造方法名，而是用this(参数列表)形式，根据其中的参数列表，选择相应的构造方法。

垃圾回收过程分析

● c++中的析构方法

● java中的finalize()方法

● System.gc的作用

Static静态变量

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份。

编写使用静态变量统计一个类产生的实例对象的个数的程序。

class Person

{

private String name;

private static int count=0;

static String country="中国";

public Person()

{

System.out.println(name+":"+ ++count);

}

public Person(String name)

{

this.name=name;

System.out.println(name+":"+ ++count);

}

void shout()

{

System.out.println(name);

}

class TestPerson

{

public static void main(String[]args)

{

Person p=new Person("张三");

new Person();

p.shout();

new Person("李四").shout();

System.out.println(Person.country);

}

运行结果：

张三:1

null:2

张三

李四:3

李四

中国

Static静态方法

● 在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。

● 静态方法不能以任何方式引用this和super关键字。与上面的道理一样，因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。

● main()方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

单态设计模式

● 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。

● 所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这样就不能用new操作符在类的外部产生类的对象了，但在类的内部仍可以产生该类的对象。因为在类的外部开始还无法等到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

class Chinese

{

static Chinese obj=new Chinese();

public static Chinese getInstance()

{

return obj;

}

private Chinese()

{

System.out.println("ss");

}

class TestChinese

{

public static void main(String[]args)

{

Chinese obj1=Chinese.getInstance();

Chinese obj2=Chinese.getInstance();

System.out.println(obj1==obj2);

//如果相等返回true,否则返回false.

}

运行结果：
ss
true

内部类

——在类中直接定义的内部类(嵌套类)

● 内部类(嵌套类)可以直接访问外部类(嵌套它的类)的成员，包括private成员，但是，内部类(嵌套类)的成员却不能被外部类(嵌套它的类)直接访问。

● 在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，内部类中对this的引用会被传递给那个外部类对象的引用。

● 如果用static修饰一个内部类，这个类就相当于是一个外部定义的类，所以static的内部类中可声明static成员，但是，非static的内部类中的成员是不能声明为static。Static的内部类不能再使用外层封装的非static的成员变量，这个道理不难想象，所以static嵌套类很少使用。

class Outer

{

int outer_i=100;

void test()

{

Inner inner=new Inner();

inner.display();

}

class Inner

{

void display()

{

System.out.println(outer_i);

}

public static void main(String[]args)

{

Outer outer=new Outer();

outer.test();

}

● 如果函数的局部变量（函数的参数也是局部变量）、内部类的成员变量、外部类的成员变量重名，我们应该按下面的程序代码所使用的方式来明确指定我们真正要访问的变量。

public class Outer

{

private int size;

public class Inner

{

private int size;

public void doStuff(int size)

{

size++;//引用的是doStuff函数的形参

this.size++;//引用的是Inner类中的成员变量

Outer.this.size++;//引用的是Outer类中的成员变量

}

内部类如何被外部引用

class Outer

{

private int size=100;

public class Inner

{

public void doStuff()

{

System.out.println(++size);

}

public class TestInner

{

public static void main(String[]args)

{

Outer outer=new Outer();

Outer.Inner inner=outer.new Inner();

inner.doStuff();

}

在方法中定义的内部类

● 嵌套类并非只能在类中定义，也可以在几个程序块的范围之内定义内部类。例如，在方法中，或甚至在for循环体内部，都可以定义嵌套类。

● 在方法中定义的内部类只能访问方法的fianl类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。

大头剑客 2007-06-07 23:33 发表评论

第一章/第二章

大头剑客 — Wed, 16 May 2007 12:16:00 GMT

Java中的常量

（Lesson02A.rmvb）

●字符常量

‘\r’表示接受键盘输入，相当于按下了回车键;

‘\n’是换行;

‘\t’是制表符，相当于table键;

‘\b’是退格键，相当于BackSpace;

‘\’’是单引号

‘\”’是双引号;

‘\\’是一个斜杠

变量的概念与作用

● 变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。根据所存储的数据类型的不同，有各种不同类型的变量。变量名代表这块内存中的数据。

● int x=0,y;

y=x+3;

x在被取值前必须被初始化。

Java的变量类型

变量的字节大小

byte占用1个字节

Boolean占用1个字节

short占用2个字节

char占用2个字节

int占用4个字节

float占用4个字节

long占用8个字节

double占用8个字节

类型转化

● 自动类型转换（也叫隐式类型转换）

● 强制类型转换（也叫显式类型转换）

● 类型转换的原理，及什么时候要用强制类型转换

● 表达式的数据类型自动提升

◆ 所有byte型、short型和char的值将被提升到int型

◆ 如果一个操作数是long型，计算结果就是long型;

◆ 如果一个操作数是float型，计算结果就是float型;

◆ 如果一个操作数是double型，计算结果就是double型;

算术运算符的应用技巧

● 思考题1：某个培训中心要为新到的学员安排房间，假设共有X个学员，每个房间可以住6个，让你用一个公式计算他们要住的房间数？

答案：(x+5)/6。这种算法还可用在查看留言板的分布显示上：其中x是总共的留言数，6是每页显示的留言数，结果是总共有多少页。

● 思考题2:假设你要让x 的值在0至9之间循环变化，请写出相应的程序代码。

class A
{
       public static void main(String[]args)
       {
              int i=0;
              while(true)
              {
                     i=(i+1)%10;
                     System.out.println(i);
              }
         }
}

逻辑运算符

运算符运算

& AND(与)

范例

False & True

结果

False

| OR(或)

^ XOR(异或)

False | true

False ^ true

True

! NOT(非)

&& AND(短路)

!TRUE

False && True

False

|| OR(短路)

False !! True

True

注1：逻辑运算符用于对boolean型结果的表达式进行运算，运算的结果都是boolean型。

注2：”&”和”&&”的区别在于，如果使用前者连接，那么无论任何情况，”&”两边的表达式都会参与计算。如果使用后者连接，当”&&”的左边为false，则将不会计算其右边的表达式。”|”和”||”的区别与”&”和”&&”的区别一样。

位运算符

● 任何信息在计算机中都是以二进制的形式保存的，&|^除了可以作为逻辑运算符，也可以做为位运算符它们对两个操作数中的每一个二进制位都进行运算。

◆ 只有参加运算的两位都为1，&运算的结果才为1，否则就为0。

◆ 只有参加运算的两位都为0，|运算的结果才为0，否则就为1。

◆ 只有参加运算的两位不同，^运算的结果才为1，否则就为0。

● 我们可以对数据按二进制位进行移位操作，java的移位运算符有三种：

◆ <<左移

◆ >>右移

◆ >>>无符号右移

移位运算的注意事项及小技巧

● 移位运算符适用数据类型有byte、short、char、int、long。

● 对低于int型的操作数将先自动转换为int型再移位。

● 对int型整数移位a>>b，系统先将b对32取模，得到的结果才是真正移位的位数。例如：a>>33和a>>1结果是一样的，a>>32结果还是a原来的数字。

● 对于long型整数移位时a>>b，则是先将移位位数b对64取模。

● 移位不会改变量本身的值。A>>1;在行语句中单独存在，毫无意义。

● x>>1的结果和x/2的结果是一样的，x<<2和X*4的结果也是一样的。总之，一个数左移n位，就是等于这个数乘以2的n次方，一个数右移n位，就是等于这个数除以2的n次方。请思考：如何用程序实现求2的x次方。答案：y=1<

(Lesson02B.rmvb)

程序的流程控制

● 顺序结构

● 选择结构

● 循环结构

if语句的选择结构

● if(表达式)语句

● if(表达式)语句1;else语句2;

● if(表达式1)语句1;

else if(表达式2)语句2;

else if(表达式3)语句3;

……

else语句n;

● 每个语句可以是使用｛｝组成的复合语句

● 变量=布尔表达式？语句1:语句2;

● if语句还可以嵌套使用

if(表达式1)

if(表达式2)语句1;

else语句2;

else

if(表达式3)语句3;

else语句4;

嵌套时使用｛｝确定层次界限，举例说明

switch语句的选择结构

Switch(表达式)

｛

case 常量表达式1：语句1;

case 常量表达式2：语句2;

……

case 常量表达式n：语句n;

default:语句n;

｝

● default语句是可选的，它接受除上面接受值有其他值，通俗的讲，就是谁是也不要的都归它。

● case后面可以跟多个语句，这些语句可以不用在括号括起来。

● switch语句判断条件可以接受int,byte,char,short型，不可以接受其他类型。

● 一旦碰到第一次case匹配，就会开始顺序执行以后所有的程序代码，而不管后面的case条件是否匹配，后面case条件下的代码都会被执行，直到碰到break语句为止。我们可以利用这个特点来用同一段语句处理多个case条件。

While循环语句

While(表达式)

语句;

int x=1;

while(x<3)

{

System.out.println(“x=”+x);

X++;

}

脚下留心：while表达式的括号后面一定不要加“;”

do-while循环语句

do 语句

while(表达式);

do..while 循环则先执行，再判断是否要继续执行，也就是说循环至少执行一次，有点像是先斩后奏的方法。只有条件计算结果为 true 时语句才会执行。
public class TestDO

{

public static void main(String[]args)

{

int x=3;

while(x==0)

{

System.out.println("ok1");

x++;

}

int y=0;

{

System.out.println("ok2");

y++;

}

while(y==0);

}

编写一个程序，这个程序不断地读取从键盘上输入的字符，直到讲到字符’q’时，程序结束。提示：调用System.in.read();可以读取到一个从键盘上输入的字符对应的整数。通过这个程序，你一定体会到在什么样的情况下，用do-while循环语句经while循环语句方便。

public class TestWhile

{

public TestWhile()

{

}

public static void main(String[] args)

{

// TODO code application logic here

int ch=0;

/* try

{

ch=System.in.read();

while(ch!='q')

{

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

try

{

ch=System.in.read();

}catch(Exception e){}

}

catch(Exception e)

{

e.printStackTrace();

//e.getMessage();

}

{

try

{

ch=System.in.read();

}

catch(Exception e)

{

e.printStackTrace();

//e.getMessage();

}

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

//System.out.println(ch);

}

while(ch!='q');

}

for循环语句

for(表达式1, 表达式2, 表达式3) 语句

break与continue语句

break语句可以中止循环中的子语和switch语句。一个无标号的break语句会把控制传给当前（最内）循环（while,do,for或switch）的下一条语句。如果有标号，控制会被传递给当前方法中的带有这一标号的语句。

St:while(true)

{

while(true)

{

break st;

}

continue语句在能出现在循环语句(while,do,for)的子语句块中，无标号的continue语句的作用是跳过当前循环的剩余语句块，接着执行下一次循环。用continue语句的打印出0到10之间的所有奇数的程序例子。

public class TestContinue

{

public TestContinue()

{

}

public static void main(String[] args)

{

// TODO code application logic here

for(int i=0;i<10;i++)

{

if(i%2==0)

continue;

System.out.println(i);

}

数组

● 静态数组

▂int ia[]={1,2,3,4};

▂int[]ia=new int[]{3,4,5};

▂int a[5];//声明数组时，不能指定其长度，编译时将出错

▂a=null;
● 使用数组时要注意的问题

▂空指针异常

▂如何计算数组长度

▂数组越界异常

多维数组

● java中并没有真正的多维数组，只有数组的数组，Java中多维数组不一定是规则矩阵形式。

● 定义一个多维数组

int [][]xx;

xx=new int [3][];

xx[0]=new int[3];

xx[1]=new int[2];

xx[2]=new int[8];

public class hello
{

public static void main(String[] args)

{

int[][]xx=new int[2][3];

xx[0][0]=2;

xx[1][2]=6;

for(int i=0;i

{

for(int j=0;j

{

System.out.println("xx["+i+"]["+j+"]="+xx[i][j]);

}

数组的排序：

class ArrayTest

{

public static void main(String[]args)

{

int []x=new int[]{1,5,2,7,4};

for(int i=0;i

{

System.out.println("x["+i+"]="+x[i]);

}

java.util.Arrays.sort(x);

for(int i=0;i

{

System.out.println("x["+i+"]="+x[i]);

}

数组的拷贝：

public static void arraycopy(Object src,

                             int srcPos,

                             Object dest,

                             int destPos,

int length)

class ArrayTest

{

public static void main(String[]args)

{

int []x=new int[]{1,5,2,7,4};

for(int i=0;i

{

System.out.println("x["+i+"]="+x[i]);

}

int[]y=new int[10];

System.arraycopy(x,0,y,1,4);

for(int i=0;i

{

System.out.println("y["+i+"]="+y[i]);

}

大头剑客 2007-05-16 20:16 发表评论

访问其他WEB应用程序

大头剑客 — Mon, 07 May 2007 13:25:00 GMT

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.http.HttpServlet;

public class OtherContextServlet extends HttpServlet
{
public void service(HttpServletRequest request,HttpServletResponse response)throws IOException,ServletException
{
  PrintWriter pwout=response.getWriter();
  ServletContext rootContext=getServletContext().getContext("/");
  if(rootContext!=null)
  {
   pwout.println(rootContext.getRealPath("/"));
  }
  else
  {
   pwout.println("getServlet failed!");
  }
}
}

注：要想在某一WEB应用程序中获得其他WEB应用程序的ServletContext 对象，必须加入红字部分。   crossContext="true" >

大头剑客 2007-05-07 21:25 发表评论

使用ServletContext接口和ClassLoader类中的方法访问资源文件

大头剑客 — Mon, 07 May 2007 05:53:00 GMT

import java.io.*;
import javax.servlet.http.*;
import javax.servlet.*;
import java.net.URL;
import java.util.Properties;
import javax.servlet.http.HttpServlet;

public class ResourceServlet extends HttpServlet
{
public void service(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException
{
  response.setContentType("text/html;charset=GB2312");
  PrintWriter pwout=response.getWriter();
  URL urlIt=getServletContext().getResource("/WEB-INF/classes/longin.properties");
  pwout.println(urlIt.toString());
  pwout.println("
");
  /*下面的两条语句可以实现两样的功能，但被注释的部分我没有实现，哪位好心人能帮我实现就好了，谢谢。
  it315.properties这个文件我放在了WEB-INF\classes目录中。*/
  //InputStream ips=getServletContext().getResourceAsStream("longin.properties");
  InputStream ips=getClass().getResourceAsStream("longin.properties");
  Properties props = new Properties();
  try
  {
   props.load(ips);
   pwout.println("database=" + props.getProperty("database"));
   pwout.println("username=" + props.getProperty("username"));
   pwout.println("password=" + props.getProperty("password"));
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }

ips.close();
}
}

注：getClass().getResourceAsStream方法只能加载位于classloader搜索目录中的资源文件，如果将longin.properties文件放在WEB-INF目录外的其它目录，就只能使用getServletContext().getResourceAsStream方法。

大头剑客 2007-05-07 13:53 发表评论

Tomcat启动分析

大头剑客 — Thu, 03 May 2007 03:44:00 GMT

Tomcat笔记(1)

Tomcat启动分析

heavyz, 2003-03-22

1 - Tomcat Server的组成部分

1.1 - Server

A Server element represents the entire Catalina servlet container. (Singleton)

1.2 - Service

A Service element represents the combination of one or more Connector components that share a single Engine
Service是这样一个集合：它由一个或者多个Connector组成，以及一个Engine，负责处理所有Connector所获得的客户请求

1.3 - Connector

一个Connector将在某个指定端口上侦听客户请求，并将获得的请求交给Engine来处理，从Engine处获得回应并返回客户
TOMCAT有两个典型的Connector，一个直接侦听来自browser的http请求，一个侦听来自其它WebServer的请求
Coyote Http/1.1 Connector 在端口8080处侦听来自客户browser的http请求
Coyote JK2 Connector 在端口8009处侦听来自其它WebServer(Apache)的servlet/jsp代理请求

1.4 - Engine

The Engine element represents the entire request processing machinery associated with a particular Service
It receives and processes all requests from one or more Connectors
and returns the completed response to the Connector for ultimate transmission back to the client
Engine下可以配置多个虚拟主机Virtual Host，每个虚拟主机都有一个域名
当Engine获得一个请求时，它把该请求匹配到某个Host上，然后把该请求交给该Host来处理
Engine有一个默认虚拟主机，当请求无法匹配到任何一个Host上的时候，将交给该默认Host来处理

1.5 - Host

代表一个Virtual Host，虚拟主机，每个虚拟主机和某个网络域名Domain Name相匹配
每个虚拟主机下都可以部署(deploy)一个或者多个Web App，每个Web App对应于一个Context，有一个Context path
当Host获得一个请求时，将把该请求匹配到某个Context上，然后把该请求交给该Context来处理
匹配的方法是“最长匹配”，所以一个path==""的Context将成为该Host的默认Context
所有无法和其它Context的路径名匹配的请求都将最终和该默认Context匹配

1.6 - Context

一个Context对应于一个Web Application，一个Web Application由一个或者多个Servlet组成
Context在创建的时候将根据配置文件$CATALINA_HOME/conf/web.xml和$WEBAPP_HOME/WEB-INF/web.xml载入Servlet类
当Context获得请求时，将在自己的映射表(mapping table)中寻找相匹配的Servlet类
如果找到，则执行该类，获得请求的回应，并返回

2 - Tomcat Server的结构图

3 - 配置文件$CATALINA_HOME/conf/server.xml的说明

该文件描述了如何启动Tomcat Server

















... ... ... ...

4 - Context的部署配置文件web.xml的说明

一个Context对应于一个Web App，每个Web App是由一个或者多个servlet组成的
当一个Web App被初始化的时候，它将用自己的ClassLoader对象载入“部署配置文件web.xml”中定义的每个servlet类
它首先载入在$CATALINA_HOME/conf/web.xml中部署的servlet类
然后载入在自己的Web App根目录下的WEB-INF/web.xml中部署的servlet类
web.xml文件有两部分：servlet类定义和servlet映射定义
每个被载入的servlet类都有一个名字，且被填入该Context的映射表(mapping table)中，和某种URL PATTERN对应
当该Context获得请求时，将查询mapping table，找到被请求的servlet，并执行以获得请求回应

分析一下所有的Context共享的web.xml文件，在其中定义的servlet被所有的Web App载入

















default

org.apache.catalina.servlets.DefaultServlet


debug
0


listings
true

1





invoker

org.apache.catalina.servlets.InvokerServlet


debug
0

2





jsp
org.apache.jasper.servlet.JspServlet

logVerbosityLevel
WARNING

3







default
/


invoker
/servlet/*


jsp
*.jsp






... ... ... ...

5 - Tomcat Server处理一个http请求的过程

假设来自客户的请求为：
http://localhost:8080/wsota/wsota_index.jsp

1) 请求被发送到本机端口8080，被在那里侦听的Coyote HTTP/1.1 Connector获得
2) Connector把该请求交给它所在的Service的Engine来处理，并等待来自Engine的回应
3) Engine获得请求localhost/wsota/wsota_index.jsp，匹配它所拥有的所有虚拟主机Host
4) Engine匹配到名为localhost的Host（即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机）
5) localhost Host获得请求/wsota/wsota_index.jsp，匹配它所拥有的所有Context
6) Host匹配到路径为/wsota的Context（如果匹配不到就把该请求交给路径名为""的Context去处理）
7) path="/wsota"的Context获得请求/wsota_index.jsp，在它的mapping table中寻找对应的servlet
8) Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类
9) 构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
10)Context把执行完了之后的HttpServletResponse对象返回给Host
11)Host把HttpServletResponse对象返回给Engine
12)Engine把HttpServletResponse对象返回给Connector
13)Connector把HttpServletResponse对象返回给客户browser

大头剑客 2007-05-03 11:44 发表评论

Tomcat下创建和发布Web应用

大头剑客 — Sun, 15 Apr 2007 16:13:00 GMT

前面我们把Tomcat+JDK1.5+MySQL+Eclipse架构搭起来了，接下去的工作是举一个小例子让初学者明白如何创建和发布Web应用，有了一个总的框架，这样大家在做JSP和Servlet的时候就不会有一种破损残缺、缺乏系统的感觉，我的学习方式历来是由粗到细，先看树木再俯瞰森林会把我弄疯的......

1、首先创建Web应用的目录结构，我这里在Tomcat的/webapps下面创建一个Web应用的目录helloapp,这是Web应用的根目录，所有JSP和HTML文件都存放在此目录下；它下一级有个WEB-INF文件夹，它存放web.xml文件和classes、lib文件夹，详细后面再说，先建了。

2、介绍web.xml文件。这是一个发布描述文件，用来配置发布信息，包括：Servlet定义；Servlet初始化参数；Servlet以及JSP的映射；安全域配置参数；welcome文件清单；资源引用；环境变量的定义。闲话少说，创建web.xml文件，内容如下：

http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
    version="2.4">

第一行指定XML的版本和字符编码，第二行指定文档类型，中放着关于Web应用的配置元素。

3、在server.xml中加入元素。server.xml在/conf下,打开后在后面加入如下元素

reloadable="true"/>

其中，path指定访问该Web应用的URL入口；docBase指定Web应用的文件路径；reloadable如果为true,一旦class文件被更新，服务器会自动重新加载Web应用，当然这样会加重服务器运行负荷。

4、部署HTML文件。在helloapp下创建index.html文件，内容如下：

Alec's Addressing

Welcome to Alec's Home

English version

在浏览器地址栏键入http://localhost:8080/helloapp/index.html

5、部署JSP。创建两个JSP文件，一个login.jsp,一个hello.jsp。前者显示登陆页面，要求输入用户名和口令，这个页面链接到名为DispatcherServlet的Servlet。后者被这个Servlet调用，显示hello页面。如前面所说，JSP文件都放在helloapp下。

  Alex's Addressing

上述是login.jsp文件内容。

Alec's Addressing

欢迎：<%=request.getAttribute("USER")%>

这是hello.jsp文件内容。

6、部署Servlet。创建名为DispatcherServlet.java的文件编译成Servlet，它调用HttpServletRequest对象的getParameter方法读取提交的loginForm表单数据，获取用户名和口令，然后将用户名和口令保存在HttpServletRequest对象的属性中，在把请求转发给hello.jsp。

package mypack;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
import java.util.*;

public class DispatcherServlet extends HttpServlet
{
public String target="/hello.jsp";

public void init(ServletConfig config)
throws ServletException{
super.init(config);
}

public void doGet(HttpServletRequest request,HttpServletResponse response)
throws ServletException,IOException{
doPost(request,response);
}

public void doPost(HttpServletRequest request,HttpServletResponse response)
  throws ServletException,IOException{
  String username=request.getParameter("username");
  String password=request.getParameter("password");

request.setAttribute("USER",username);
request.setAttribute("PASSWORD",password);

//将请求定向到目标文件
ServletContext context=getServletContext();

  System.out.println("重定向到"+target);
  RequestDispatcher dispatcher=context.getRequestDispatcher(target);
  dispatcher.forward(request,response);
}

public void destroy(){
}
}

上述是DispatcherServlet.java文件，用来编译成servlet。编译成class文件后存放位置为/helloapp/WEB-INF/classes/mypack/DispatcherServlet.class；然后在/helloapp下的web.xml中作如下修改：

'-//Sun Microsystems,Inc.//DTD Web Application 2.3//EN'

'http://java.sun.com/j2ee/dtds/web-app_2_3.dtd'>

        dispatcher
        mypack.DispatcherServlet

        dispatcher
        /dispatcher

说明一下，定义Servlet的名字；指定实现这个Servlet的类；定义Servlet的初始化参数（包括参数名和参数值），一个元素中可以有多个元素；指当Web应用启动时，装载Servlet的次序。当这个值为正数或零时，Servlet容器先加载数值小的servlet，再依次加载其他数值大的servlet，如果这个值为负数或者没有设定，那么Servlet容器将在Web客户首次访问这个Servlet时加载它。我这里没用到后两个元素。

7、部署JSP Tag Library

Tag Library向用户提供了自定义JSP标签的功能。我们定义一个名为mytaglib的标签库，包含一个简单的hello标签，它能将JSP页面中所有的解析为字符串“Hello”。

（1）

package mypack;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspTagException;
import javax.servlet.jsp.tagext.TagSupport;

public class HelloTag extends TagSupport
{
public void HelloTag(){}
public int doEndTag() throws JspException{

  try{
   pageContext.getOut().print("Hello");
  }
  catch(Exception e){
   throw new JspTagException(e.getMessage());
  }

return SKIP_BODY;
}

public void release(){
super.release();
}
}

这是HelloTag.java文件，编译成用于处理hello标签的类。

（2）创建Tag Library的描述文件mytaglib.tld文件，这个文件定义mytaglib标签库和hello标签。它存放为/WEB-INF/mytaglib.tld。源码如下：

1.0
1.1
mytaglib
mytaglib

   hello
   mypack.HelloTag
   empty
   Just Says Hello

（3）在/helloapp/WEB-INF下的web.xml添加元素，如下：

   /mytaglib
   /WEB-INF/mytaglib.tld

中包含和属性。前者指定Tag Library标示符；后者指定Tag Library的描述文件(TLD)的位置。

（4）在hello.jsp文件中加入hello标签。prefix用来指定引用mytaglib标签库时的前缀，修改后如下：

<%@ taglib uri="/mytaglib" prefix="mm"%>

Alec's Addressing

<mm:hello/><%=request.getAttribute("USER")%>

经测试OK！

8、创建并发布WAR文件。一般来说，在Web应用的开发阶段，为了方便调试，采用开放式的目录结构来发布Web应用，这样方便更新或替换文件。产品发布时，应将整个Web应用打包为WAR文件，再进行发布。

（1）MS-DOS下进入/helloapp目录下键入如下命令：jar cvf helloapp.war *.*；

（2）把helloapp.war拷贝到/webapps目录下；

（3）删除原来的helloapp目录；

（4）启动Tomcat服务器。

Tomcat服务器启动时，会把webapps下所有WAR文件自动展开为开放式的目录结构，变为/webapps/helloapp目录。
文章来源：http://syneer1981.spaces.live.com/blog/cns!6F8B2C7500427759!120.entry?_c=BlogPart

大头剑客 2007-04-16 00:13 发表评论

◆用UDP编写网络聊天程序

大头剑客 — Mon, 29 Jan 2007 12:31:00 GMT

/**
* @(#)Chat1.java
*
* Chat1 application
*
* @author
* @version 1.00 2007/1/29
*/
import java.awt.List;
import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.util.*;
public class Chat1 extends Frame
{
List lst=new List(6);
TextField tfIP=new TextField(15);
TextField tfData=new TextField(20);
DatagramSocket ds=null;
    public Chat1()
    {
    this.addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       ds.close();
       e.getWindow().dispose();
       System.exit(0);
      }
    });
    Panel pl=new Panel();
    pl.setLayout(new BorderLayout());
    pl.add(tfIP,BorderLayout.WEST);
    pl.add(tfData,BorderLayout.EAST);
    this.add(lst,BorderLayout.CENTER);
    this.add(pl,BorderLayout.SOUTH);

    try
    {
    ds=new DatagramSocket(3000);
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }

    new Thread(new Runnable()
    {
      public void run()
      {
       byte []buf=new byte [1024];
       DatagramPacket dp=new DatagramPacket(buf,1024);
       while(true)
       {
        try
        {
         ds.receive(dp);
         Calendar c=Calendar.getInstance();
         lst.add(new String(dp.getData(),0,dp.getLength())+"    from: "+
          dp.getAddress().getHostAddress()+":"+dp.getPort()+new Date(),0);
        }
        catch(Exception e)
        {
         if(ds.isClosed()==false)
         {
          e.printStackTrace();
         }
        }
       }
      }
    }).start();

    tfData.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
       byte []buf=tfData.getText().getBytes();
       try
       {
        DatagramPacket dp=new DatagramPacket(buf,buf.length,
         InetAddress.getByName(tfIP.getText()),3000);
        ds.send(dp);
       }
       catch(Exception ex)
       {
        ex.printStackTrace();
       }
       //lst.add(tfData.getText());
       tfData.setText("");

      }
    });


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

    // TODO, add your application code
    System.out.println("Hello World!");
    Chat1 mainFrame=new Chat1();
    mainFrame.setTitle("Chat");
    mainFrame.setBounds(300,200,300,400);
    mainFrame.setVisible(true);
    mainFrame.setResizable(false);
    }
}

大头剑客 2007-01-29 20:31 发表评论

第九讲网络编程

大头剑客 — Sat, 27 Jan 2007 10:32:00 GMT

第九讲网络编程

● 网络编程的基础知识

◆ 网络协议与 TCP/IP

◆ IP 地址和 Port （端口号）

▼本地回路的 IP 地址： 127.0.0.1

▼端口号的范围为 0 ～ 65535 之间， 0 ～ 1023 之间的端口数是用于一些知名的网络服务和应用。

● UDP 网络程序

◆ UDP ，用户数据报协议（ User Datagram Protocol ），是无连接通信协议。

● TCP 网络程序

◆ TCP ，传输控制协议（ Transmission Control Protocol ） , 是面向连接的通信协议。

TCP 、 UDP 的数据帧格式简单图例：

协议类型

源 IP

目标 IP

源端口

目标端口

帧序号

帧数据

其中协议类型用于区分 TCP ， UDP

Socket

◆ Socket 是网络驱动层提供给应用程序编程的接口和一种机制。

◆ 可以把 Socket 比喻成是一个港口码头，应用程序只要把货物放到港口码头上，就算完成了货物的运送。应用程序只需等待货物到达码头后，将货物取走。

◆ Socket 是应用程序中创建，通过一种绑定机制与驱动程序建立关系，告诉自己所对应的 IP 和 Port 。

◆ Socket 数据发送过程

◆ Socket 数据接收过程

Java 中的网络编程类

◆ 位于 java.net 包中

◆ DatagramSocket 类用于 UDP 通信

◆ ServerSocket 类用于 TCP 通信的服务器端（接受客户端连接的）

◆ Socket 类用于 TCP 通信的服务器（专用于和客户端进行数据传输的）和客户端

UDP 网络程序

◆ DatagramSocket 类

此类表示用来发送和接收数据报包的套接字。

数据报套接字是包投递服务的发送或接收点。每个在数据报套接字上发送或接收的包都是单独编址和路由的。从一台机器发送到另一台机器的多个包可能选择不同的路由，也可能按不同的顺序到达。

在 DatagramSocket 上总是启用 UDP 广播发送。为了接收广播包，应该将 DatagramSocket 绑定到通配符地址。在某些实现中，将 DatagramSocket 绑定到一个更加具体的地址时广播包也可以被接收。

示例： DatagramSocket s = new DatagramSocket(null); s.bind(new InetSocketAddress(8888)); 这等价于： DatagramSocket s = new DatagramSocket(8888); 两个例子都能创建能够在 UDP 8888 端口上接收广播的 DatagramSocket

■ 构造函数

▼DatagramSocket ()
构造数据报套接字并将其绑定到本地主机上任何可用的端口。

▼DatagramSocket (int port)
创建数据报套接字并将其绑定到本地主机上的指定端口

▼DatagramSocket (int port, InetAddress laddr)
创建数据报套接字，将其绑定到指定的本地地址。

■ close ()
关闭此数据报套接字。

■ send (DatagramPacket p)
从此套接字发送数据报包。

■ receive (DatagramPacket p)
从此套接字接收数据报包。

◆ DatagramPacket 类

如果把 DatagramSocket 比作创建的港口码头，那么 DatagramPacket 就是发送和接收数据的集装箱。

■ 构造函数：

▼DatagramPacket (byte[] buf, int length)
构造 DatagramPacket ，用来接收长度为 length 的数据包

▼DatagramPacket (byte[] buf, int length, InetAddress address, int port)
构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

■ getAddress ()
返回某台机器的 IP 地址，此数据报将要发往该机器或者是从该机器接收到的。

■ getPort ()
返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接收到的。

■ getData ()
返回数据缓冲区。

■ getLength ()
返回将要发送或接收到的数据的长度。

◆ InetAddress 类

■ InetAddress 是用于表示计算机 IP 地址的一个类，而在日常应用中的计算机地址是用“ 192.168.0.1 ”、 www.it315.org 等字符串格式来表示的。

■ getByName (String host)
在给定主机名的情况下确定主机的 IP 地址。

■ getHostAddress ()
返回 IP 地址字符串（以文本表现形式）。

■ getHostName ()
获取此 IP 地址的主机名。

■ getLocalHost ()
返回本地主机。

◆ 最简单的 UDP 程序

■ 字符串与字节数组之间的双向转换

■ UDP 接收程序必须先启动运行，才能接收 UDP 发送程序发送的数据。

■ 用 start 命令来打开新命令行窗口的好处。

■ 解决发送中文字符串的问题。

◆     用 UDP 编写网络聊天程序
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
import java.net.*;
public class UdpSend
{

/**
* Method main
*
*
* @param args
*
*/
public static void main(String[] args)
{
  // TODO: Add your code here
  try
  {
   DatagramSocket ds=new DatagramSocket();
   /*
   String strInfo="hello www.it315.org";
   ds.send(new DatagramPacket(strInfo.getBytes(),strInfo.length(),InetAddress.getByName("192.168.0.239"),2000));
   */
   String str="hello 中国";
   ds.send(new DatagramPacket(str.getBytes(),str.getBytes().length,InetAddress.getByName("192.168.0.239"),2500));
   ds.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }

}
}
import java.net.*;
public class UdpReceive
{

/**
* Method main
*
*
* @param args
*
*/
public static void main(String[] args)
{
  // TODO: Add your code here
  try
  {
   DatagramSocket ds=new DatagramSocket(2500);
   byte []buf=new byte [1024];
   DatagramPacket dp=new DatagramPacket(buf,1024);
   ds.receive(dp);
   System.out.println(new String(dp.getData(),0,dp.getLength())+
    " from:"+" IP: "+dp.getAddress().getHostAddress()+" Port: "+dp.getPort());
   ds.close();
  }
  catch(Exception e)
  {
   e.printStackTrace();
  }


}
}

大头剑客 2007-01-27 18:32 发表评论

BoxLayout组件

大头剑客 — Fri, 26 Jan 2007 07:16:00 GMT

/**
* @(#)TestBoxLayout.java
*
* TestBoxLayout application
*
* @author
* @version 1.00 2007/1/25
*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.EventListener;
public class TestBoxLayout extends JFrame implements ActionListener
{
JTextField jtf=new JTextField();
    public TestBoxLayout()
    {
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Container c=this.getContentPane();

    JPanel jpl1=new JPanel();
    JPanel jpl2=new JPanel();
    JPanel jpl3=new JPanel();
    JPanel jpl4=new JPanel();

    //BoxLayout blo=new BoxLayout(jtf,BoxLayout.LINE_AXIS);
    BoxLayout blo1=new BoxLayout(jpl1,BoxLayout.X_AXIS);
    BoxLayout blo2=new BoxLayout(jpl2,BoxLayout.X_AXIS);
    BoxLayout blo3=new BoxLayout(jpl3,BoxLayout.X_AXIS);
    BoxLayout blo4=new BoxLayout(jpl4,BoxLayout.X_AXIS);
    /*
    blo1.maximumLayoutSize(jpl1);
    blo2.maximumLayoutSize(jpl2);
    blo3.maximumLayoutSize(jpl3);
    blo4.maximumLayoutSize(jpl4);
    */
    jpl1.setLayout(blo1);
    jpl2.setLayout(blo2);
    jpl3.setLayout(blo3);
    jpl4.setLayout(blo4);

    JButton jb=null;

    for(int i=0;i<4;i++)
    {
      String str=new String("123+");
      Character ch=str.charAt(i);
      jb=new JButton(ch.toString());
      jb.setSize(100,100);
      jpl1.add(jb);
      jb.addActionListener(this);
    }
    for(int i=0;i<4;i++)
    {
      String str=new String("456-");
      Character ch=str.charAt(i);
      jb=new JButton(ch.toString());
      jpl2.add(jb);
      jb.addActionListener(this);
    }

    for(int i=0;i<4;i++)
    {
      String str=new String("789*");
      Character ch=str.charAt(i);
      jb=new JButton(ch.toString());
      jpl3.add(jb);
      jb.addActionListener(this);
    }
    for(int i=0;i<4;i++)
    {
      String str=new String("0.=\\");
      Character ch=str.charAt(i);
      jb=new JButton(ch.toString());
      jpl4.add(jb);
      jb.addActionListener(this);
    }
    c.setLayout(new GridLayout(5,1));
    c.add(jtf);
    c.add(jpl1);
    c.add(jpl2);
    c.add(jpl3);
    c.add(jpl4);
    }
    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestBoxLayout mainFrame=new TestBoxLayout();
    mainFrame.setTitle("TestBoxLayout");
    mainFrame.setBounds(300,200,200,200);
    mainFrame.setVisible(true);
    }

/**
* Method actionPerformed
*
*
* @param e
*
*/
public void actionPerformed(ActionEvent e)
{
  // TODO: Add your code here
  jtf.setText(jtf.getText()+e.getActionCommand());
  //d.setText(jfd.getText()+e.getActionCommand());
}
}

大头剑客 2007-01-26 15:16 发表评论

GridLayout,JPane组件

大头剑客 — Fri, 26 Jan 2007 07:14:00 GMT

/**
* @(#)TestCalculator.java
*
* TestCalculator application
*
* @author
* @version 1.00 2007/1/22
*/
import java.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.EventListener;
public class TestCalculator extends JFrame implements ActionListener
{
private JTextField jfd=new JTextField();
String str=new String("123+456-789*0.=\\");
String strch=null;
Character ch=null;

    public TestCalculator()
    {

    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    Container c=this.getContentPane();
    jfd.setHorizontalAlignment(JTextField.RIGHT);
    JPanel jpl=new JPanel();
    jpl.setLayout(new GridLayout(4,4));
    c.add(jfd,BorderLayout.NORTH);
    c.add(jpl,BorderLayout.CENTER);
    //System.out.println(str.substring(1));
    JButton b=null;

    for(int i=0;i<16;i++)
    {
      ch=str.charAt(i);
      b=new JButton(ch.toString());
      //b=new JButton(new Integer(i+1).toString());
      b.addActionListener(this);
      jpl.add(b);
    }
    /*b=new JButton("1");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("2");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("3");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("+");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("4");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("5");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("6");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("-");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("7");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("8");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("9");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("*");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("0");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton(".");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("=");
    b.addActionListener(this);
    jpl.add(b);

    b=new JButton("\\");
    b.addActionListener(this);
    jpl.add(b);*/





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

    // TODO, add your application code
    System.out.println("Hello World!");
    TestCalculator mainFrame=new TestCalculator();
    mainFrame.setTitle("TestCalculator");
    mainFrame.setBounds(300,200,300,400);
    mainFrame.setVisible(true);
    }

public void actionPerformed(ActionEvent e)
{
  // TODO: Add your code here
     //||strnum.indexOf("-")!=-1||strnum.indexOf("*")!=-1||strnum.indexOf("\\")!=-1

  String strnum=jfd.getText();
  //System.out.println(strnum);
  Character c1='+';
  //Character c2='-';
  int n1=0;
  float num1=0;
  float num2=0;
  float sum=0;
  Integer len=new Integer(0);

  if(e.getActionCommand().equals("+")||e.getActionCommand().equals("-")||e.getActionCommand().equals("*")||e.getActionCommand().equals("\\"))
  {

   num1=new Float(strnum.substring(0,len));

   System.out.println(num1);
   if(strnum.indexOf(c1)!=-1||strnum.indexOf("-")!=-1||strnum.indexOf("*")!=-1||strnum.indexOf("\\")!=-1)
   {
    //System.out.println(strnum.length());
    jfd.setText(jfd.getText());
    //System.out.println(e.getActionCommand());
   }
   else
   {
    jfd.setText(jfd.getText()+e.getActionCommand());

    //System.out.println("no find.");
   }

  }
  else if(e.getActionCommand().equals("."))
  {

   if(strnum.indexOf(".")!=-1)
   {

    n1=strnum.indexOf(".");

    //System.out.println(strnum.length());
    if(strnum.substring(n1+1,n1+1).equals(".")==false)
    {
     //System.out.println(strnum.substring(n1+1,n1+1).equals("."));
     jfd.setText(jfd.getText());

    }
    else
    {
     jfd.setText(jfd.getText()+e.getActionCommand());

    }
   }
   else
   {
    jfd.setText(jfd.getText()+e.getActionCommand());
   }

  }
  else
  {
   if(e.getActionCommand().equals("="))
   {
    if(strnum.indexOf("=")!=-1)
    {
     jfd.setText(jfd.getText());
    }
    else
    {

     jfd.setText(jfd.getText()+e.getActionCommand());


     //System.out.println(strnum.substring(len+1,strnum.length()));
    }
   }
   else
   {
    jfd.setText(jfd.getText()+e.getActionCommand());
   }

  }

}
}

大头剑客 2007-01-26 15:14 发表评论

Swing中的标准对话框

大头剑客 — Sun, 21 Jan 2007 17:32:00 GMT

/**
* @(#)TestJOptionPane.java
*
* TestJOptionPane application
*
* @author
* @version 1.00 2007/1/22
*/
import javax.swing.*;
import javax.swing.event.*;
import java.awt.event.*;
public class TestJOptionPane extends JFrame
{
String strValue=null;
    public TestJOptionPane()
    {
    JOptionPane.showMessageDialog(/*this*/null,"程序已开始运行...","运行",JOptionPane.DEFAULT_OPTION);
    JTextArea jta=new JTextArea();
    JScrollPane jsp=new JScrollPane();
    jsp.getViewport().add(jta);
    this.getContentPane().add(jsp);
    this.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
    strValue=JOptionPane.showInputDialog(null,"请输入姓名：");
    //jta.setText(strValue);
    jta.append(strValue);
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       if(JOptionPane.OK_OPTION==JOptionPane.showConfirmDialog(TestJOptionPane.this,"确认要退出程序吗？","Exit",JOptionPane.OK_CANCEL_OPTION,JOptionPane.WARNING_MESSAGE))
       {
        e.getWindow().dispose();
       }

      }
    });

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

    // TODO, add your application code
    System.out.println("Hello World!");
    TestJOptionPane mainFrame=new TestJOptionPane();
    mainFrame.setTitle("TestJOptionPane");
    mainFrame.setBounds(300,200,400,400);
    mainFrame.setVisible(true);
    }
}

大头剑客 2007-01-22 01:32 发表评论

JscrollPane组件

大头剑客 — Sun, 21 Jan 2007 15:57:00 GMT

/**
* @(#)TestSwing.java
*
* TestSwing application
*
* @author
* @version 1.00 2007/1/21
*/
import javax.swing.*;
public class TestSwing extends JFrame
{
    public TestSwing()
    {
    JTextArea jta=new JTextArea(50,50);
     JScrollPane jsp=new JScrollPane();
     jsp.getViewport().add(jta);
     this.getContentPane().add(jsp);
     this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestSwing mainFrame=new TestSwing();
    mainFrame.setTitle("TestSwing");
    mainFrame.setBounds(300,200,400,400);
    mainFrame.setVisible(true);
    }
}

大头剑客 2007-01-21 23:57 发表评论

JFrame来创建程序的主框架窗口

大头剑客 — Sun, 21 Jan 2007 13:22:00 GMT

/**
* @(#)TestSwing.java
*
* TestSwing application
*
* @author
* @version 1.00 2007/1/21
*/
import javax.swing.*;
public class TestSwing extends JFrame
{
    public TestSwing()
    {
    this.getContentPane().add(new JButton("hello"),"South");
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestSwing mainFrame=new TestSwing();
    mainFrame.setTitle("TestSwing");
    mainFrame.setBounds(300,200,400,400);
    mainFrame.setVisible(true);
    }
}

大头剑客 2007-01-21 21:22 发表评论

取消布局管理器

大头剑客 — Sun, 21 Jan 2007 05:28:00 GMT

取消布局管理器

● 调用 Container.setLayout(null) 方法取消布局管理器设置，在这种情况下，可以调用 Component.setBounds 方法来用绝对坐标设置容器上的每个组件的大小和位置。

● 不使用布局管理器将会给程序带来一个潜在的问题，当容器大小改变时，所有组件仍保持原来的位置和大小，将导致整个程序界面比较“难看”。

大头剑客 2007-01-21 13:28 发表评论

布局管理器—CardLayout、GridLayout(Panel组件)

大头剑客 — Sun, 21 Jan 2007 05:01:00 GMT

/**
* @(#)TestCardLayout.java
*
* TestCardLayout application
*
* @author
* @version 1.00 2007/1/21
*/
import java.awt.*;
import java.awt.event.*;

public class TestCardLayout extends Frame
{
CardLayout cl=new CardLayout();
    Panel plCenter=new Panel(cl);
    public TestCardLayout()
    {
    GridLayout gl=new GridLayout(5,1);
    Panel plWest=new Panel(gl);
    Button first=new Button("first");
    Button prev=new Button("prev");
    Button next=new Button("next");
    Button three=new Button("three");
    Button last=new Button("last");
    plWest.add(first);
    plWest.add(prev);
    plWest.add(next);
    plWest.add(three);
    plWest.add(last);

    plCenter.add(new Button("one"),"1");
    plCenter.add(new Button("two"),"2");
    plCenter.add(new Button("three"),"3");
    plCenter.add(new Button("four"),"4");
    plCenter.add(new Button("five"),"5");
    add(plWest,"West");
    add(plCenter);
    class MyactionListener implements ActionListener
    {
      public void actionPerformed(ActionEvent e)
      {
       if(e.getActionCommand().equals("first"))
       {
        cl.first(plCenter);
       }
       else if(e.getActionCommand().equals("prev"))
       {
        cl.previous(plCenter);
       }
       else if(e.getActionCommand().equals("next"))
       {
        cl.next(plCenter);
       }
       else if(e.getActionCommand().equals("three"))
       {
        cl.show(plCenter,"3");
       }
       else
       {
        cl.last(plCenter);
       }
      }
    }
    MyactionListener ml=new MyactionListener();
    first.addActionListener(ml);
    prev.addActionListener(ml);
    next.addActionListener(ml);
    three.addActionListener(ml);
    last.addActionListener(ml);
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       e.getWindow().dispose();
      }
    });
    }
    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestCardLayout mainFrame=new TestCardLayout();
    mainFrame.setTitle("TestCardLayout");
    mainFrame.setBounds(300,200,400,400);
    mainFrame.setVisible(true);

    }
}

大头剑客 2007-01-21 13:01 发表评论

布局管理器—FlowLayout

大头剑客 — Sun, 21 Jan 2007 03:13:00 GMT

/**
* @(#)TestFlowLayout.java
*
* TestFlowLayout application
*
* @author
* @version 1.00 2007/1/21
*/
import java.awt.*;
import java.awt.event.*;
public class TestFlowLayout extends Frame
{
    public void init()
{
  add(new Button("第一个"));
  add(new Button("第二个"));
  add(new Button("第三个"));
  add(new Button("第四个"));
}
    public TestFlowLayout()
    {
    FlowLayout fl=new FlowLayout();
    setLayout(fl);
    init();
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       e.getWindow().dispose();
      }
    });
    }
    public static void main(String[] args)
    {
    System.out.println("Hello World!");
    TestFlowLayout mainFram=new TestFlowLayout();
    mainFram.setTitle("TestBorderLayout");
    mainFram.setBounds(300,200,400,400);
    mainFram.setVisible(true);
    }
}

大头剑客 2007-01-21 11:13 发表评论

布局管理器—BorderLayout组件

大头剑客 — Sun, 21 Jan 2007 02:42:00 GMT

/**
* @(#)TestBorderLayout.java
*
* TestBorderLayout application
*
* @author
* @version 1.00 2007/1/21
*/
import java.awt.*;
import java.awt.event.*;
public class TestBorderLayout extends Frame
{
public void init()
{
  add(new Button("East"),"East");
  add(new Button("South"),"South");
  add(new Button("West"),"West");
  add(new Button("North"),"North");
  add(new Button("Center"),/*"Center"*/BorderLayout.CENTER);
}
    public TestBorderLayout()
    {
    init();

    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       e.getWindow().dispose();
      }
    });
    }
    public static void main(String[] args)
    {
    System.out.println("Hello World!");
    TestBorderLayout mainFram=new TestBorderLayout();
    mainFram.setTitle("TestBorderLayout");
    mainFram.setBounds(300,200,400,400);
    mainFram.setVisible(true);
    }
}

大头剑客 2007-01-21 10:42 发表评论

ScrollPane与TextArea组件

大头剑客 — Sat, 20 Jan 2007 12:14:00 GMT

/**
* @(#)TestScrollPane.java
*
* TestScrollPane application
*
* @author
* @version 1.00 2007/1/20
*/
import java.awt.*;
import java.awt.event.*;
public class TestScrollPane extends Frame
{
    public TestScrollPane()
    {
    TextArea ta=new TextArea("",10,50,TextArea.SCROLLBARS_NONE);
    ScrollPane sp=new ScrollPane(ScrollPane.SCROLLBARS_AS_NEEDED);
    add(sp);
    sp.add(ta);
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       e.getWindow().dispose();
      }
    });
    }
    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestScrollPane mainFrame=new TestScrollPane();
    mainFrame.setTitle("TestScrollPane");
    mainFrame.setBounds(300,200,200,200);
    mainFrame.setVisible(true);
    }
}

大头剑客 2007-01-20 20:14 发表评论

Choice组件

大头剑客 — Sat, 20 Jan 2007 11:50:00 GMT

/**
* @(#)TestChoice.java
*
* TestChoice application
*
* @author
* @version 1.00 2007/1/20
*/

import java.awt.*;
import java.awt.event.*;
public class TestChoice extends Frame
{
Choice ch=new Choice();
    public TestChoice()
    {
    FlowLayout fl=new FlowLayout();
    setLayout(fl);
    ch.add("choice1");
    ch.add("choice2");
    ch.add("choice3");

    add(ch);
    ch.addItemListener(new ItemListener()
    {
      public void itemStateChanged(ItemEvent e)
      {
       System.out.println(e.getItem());
      }
    });
    addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    e.getWindow().dispose();
   }
  });
    }

    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestChoice mainFrame=new TestChoice();
    mainFrame.setTitle("TestChoice");
    mainFrame.setBounds(300,200,200,100);
    mainFrame.setVisible(true);
    }
}

大头剑客 2007-01-20 19:50 发表评论

Checkbox组件

大头剑客 — Sat, 20 Jan 2007 10:54:00 GMT

/**
* @(#)TestCheckbox.java
*
* TestCheckbox application
*
* @author
* @version 1.00 2007/1/20
*/
import java.awt.*;
import java.awt.event.*;
public class TestCheckbox extends Frame
{

Checkbox cb1=new Checkbox("Are you a boy or gril?",true);
CheckboxGroup cbg=new CheckboxGroup();
Checkbox cb2=new Checkbox("Boy",true,cbg);
Checkbox cb3=new Checkbox("Girl",false,cbg);

class CbItemListener implements ItemListener
{
  public void itemStateChanged(ItemEvent e)
  {
   Checkbox cb=(Checkbox)e.getItemSelectable();
   /*if(cb.getLabel().equals("Are you a boy or gril?"))
   {
    ....
   }*/
   if(cb==cb1)
   {
    if(cb.getState()==true)
    {
     System.out.println("你选择了复选框");
    }
    else
    {
     System.out.println("你取消选择复选框");
    }
   }
   else if(cb==cb2)
   {
    if(cb.getState()==true)
    {
     System.out.println("你是个男孩");
    }
    else
    {
     System.out.println("你是个女孩");
    }
   }
   else
   {
    if(cb.getState()==true)
    {
     System.out.println("你是个女孩");
    }
    else
    {
     System.out.println("你是个男孩");
    }
   }

  }
}

public TestCheckbox()
{
  FlowLayout fl=new FlowLayout();
  setLayout(fl);
  add(cb1);
  add(cb2);
  add(cb3);
  addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    e.getWindow().dispose();
   }
  });
  CbItemListener cbit=new CbItemListener();
  cb1.addItemListener(cbit);
  cb2.addItemListener(cbit);
  cb3.addItemListener(cbit);
}

    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestCheckbox mainFrame=new TestCheckbox();
  mainFrame.setTitle("TestCheckbox");
  mainFrame.setBounds(300,200,400,400);
  mainFrame.setVisible(true);
    }
}

大头剑客 2007-01-20 18:54 发表评论

MenuBar、Menu、MenuItem组件

大头剑客 — Sat, 20 Jan 2007 06:40:00 GMT

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.EventListener;
public class TestMenuBar extends Frame /*implements ActionListener*/
{
MenuBar menubar=new MenuBar();

Menu fileM=new Menu("File");
Menu editM=new Menu("Edit");
Menu toolsM=new Menu("Tools");
Menu helpM=new Menu("Help");

MenuItem fileM1=new MenuItem("New");
MenuItem fileM2=new MenuItem("Open");
MenuItem fileM3=new MenuItem("Save");
Menu fileM4=new Menu("Print");
CheckboxMenuItem fileM5=new CheckboxMenuItem("Quit",true);
MenuItem printM=new MenuItem("Preview");
MenuItem setM=new MenuItem("Setting");
MenuItem editM1=new MenuItem("连接");

    public TestMenuBar()
    {
    setM.setActionCommand("set");
    editM1.setActionCommand("connect");
    printM.addActionListener(new MenuBarListener());
    setM.addActionListener(new MenuBarListener());

       menubar.add(fileM);
  menubar.add(editM);
  menubar.add(toolsM);
  menubar.add(helpM);

  fileM.add(fileM1);
  fileM.add(fileM2);
  fileM.add(fileM3);
  fileM.add(fileM4);
  fileM.addSeparator();
  fileM4.add(printM);
  fileM4.add(setM);
  fileM.add(fileM5);

  editM.add(editM1);
  //editM1.addActionListener(this);

  this.setMenuBar(menubar);

    this.addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       e.getWindow().dispose();
      }
    });
    editM1.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
       if(editM1.getActionCommand().equals("connect"))
       {
        editM1.setActionCommand("disconnect");
        editM1.setLabel("断开");
       }
       else if(editM1.getActionCommand().equals("disconnect"))
       {
        editM1.setActionCommand("connect");
        editM1.setLabel("连接");
       }
      }
    });
    }
    public static void main(String[] args)
    {
    System.out.println("Hello World!");
    TestMenuBar mainFrame=new TestMenuBar();
    mainFrame.setTitle("TestMenuBar");
    mainFrame.setSize(400,400);
    mainFrame.setVisible(true);
    }

/*public void actionPerformed(ActionEvent e)
{
  // TODO: Add your code here
  if(e.getActionCommand().equals("connect"))
  {
   editM1.setActionCommand("disconnect");
   editM1.setLabel("断开");
  }
  else if(e.getActionCommand().equals("disconnect"))
  {
   editM1.setActionCommand("connect");
   editM1.setLabel("连接");
  }
}*/
}

大头剑客 2007-01-20 14:40 发表评论

利用双缓冲来DrawLine

大头剑客 — Sat, 20 Jan 2007 06:26:00 GMT

/**
* @(#)DrawLine.java
*
* DrawLine application
*
* @author
* @version 1.00 2007/1/17
*/

import java.awt.*;
import java.awt.event.*;
public class DrawLine extends Frame
{
private int begX;
private int begY;
private int endX;
private int endY;
Image oimg=null;
Graphics og=null;
public void paint(Graphics g)
{
  /*
  Image img=this.getToolkit().getImage("..\\我要学习啦.gif");
  g.drawImage(img,100,100,this);
  if(oimg!=null)
  {
   //g.drawImage(oimg,0,0,this);
  }
  */
  g.drawImage(oimg,0,0,this);

}
    public DrawLine()
    {
    setTitle("DrawLines");
    setSize(400,400);
    setVisible(true);
    Dimension d=this.getSize();
    oimg=this.createImage(d.width,d.height);
    og=oimg.getGraphics();
    addWindowListener(new WindowAdapter()
    {
      public void windowClosing(WindowEvent e)
      {
       e.getWindow().dispose();
      }
    });
    addMouseListener(new MouseAdapter()
    {

      public void mousePressed(MouseEvent e)
      {
       begX=e.getX();
       begY=e.getY();
      }
      public void mouseReleased(MouseEvent e)
      {
       endX=e.getX();
       endY=e.getY();
       Graphics g=getGraphics();
       g.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
       g.setColor(Color.RED);
       g.drawString(begX+","+begY,begX,begY);
       g.drawString(endX+","+endY,endX,endY);
       g.drawLine(begX,begY,endX,endY);
       og.setFont(new Font(null,Font.ITALIC|Font.BOLD,30));
       og.setColor(Color.RED);
       og.drawString(begX+","+begY,begX,begY);
       og.drawString(endX+","+endY,endX,endY);
       og.drawLine(begX,begY,endX,endY);

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

    // TODO, add your application code
    System.out.println("Hello World!");
    DrawLine mainFrame=new DrawLine();


    }
}

大头剑客 2007-01-20 14:26 发表评论

Dialog组件

大头剑客 — Sat, 20 Jan 2007 06:18:00 GMT

/**
* @(#)TestDialog2.java
*
* TestDialog2 application
*
* @author
* @version 1.00 2007/1/20
*/
import java.awt.*;
import java.awt.event.*;
public class TestDialog2 extends Frame
{
private TextField tf=new TextField(10);

   public TestDialog2()
   {
    Button bt1=new Button("打开模态窗口");
    Button bt2=new Button("打开非模态窗口");
     add(tf,"North");
     add(bt1,"Center");
     add(bt2,"East");

   bt1.addActionListener(new ActionListener()
   {
     public void actionPerformed(ActionEvent e)
     {
      MyDialog dlg=new MyDialog(TestDialog2.this,"模态窗口",true);
      dlg.setTF(tf.getText());
      dlg.setVisible(true);
     }
   });

   bt2.addActionListener(new ActionListener()
   {
     public void actionPerformed(ActionEvent e)
     {
      MyDialog dlg=new MyDialog(TestDialog2.this,"非模态窗口",false);
      dlg.setTF(tf.getText());
      dlg.setVisible(true);
     }
   });

   addWindowListener(new WindowAdapter()
   {
     public void windowClosing(WindowEvent e)
     {
      e.getWindow().dispose();
     }
   });
   }

   public void setTF(String setInfo)
   {
     tf.setText(setInfo);
   }


    public static void main(String[] args)
    {

    // TODO, add your application code
    System.out.println("Hello World!");
    TestDialog2 mainFram=new TestDialog2();
    mainFram.setTitle("hello");
    //mainFram.setBackground(Color.lightGray);
    mainFram.setBounds(300,200,400,400);
    mainFram.setVisible(true);
    }
}
//**************************************************************
import java.awt.*;
import java.awt.event.*;
import java.awt.Dialog;
public class MyDialog extends Dialog
{
private TextField tf=new TextField(10);

public MyDialog(Frame owner,String title,boolean modal)
{
  super(owner,title,modal);
  Button b1=new Button("应用");
  Button b2=new Button("确定");

  add(tf,"North");
  add(b1,"Center");
  add(b2,"East");
  setBounds(0,0,200,200);

  if(this.isModal()==true)
  {
   b1.setEnabled(false);
  }

  b1.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    ((TestDialog2)MyDialog.this.getOwner()).setTF(tf.getText());
   }
  });

  b2.addActionListener(new ActionListener()
  {
   public void actionPerformed(ActionEvent e)
   {
    ((TestDialog2)MyDialog.this.getOwner()).setTF(tf.getText());
    dispose();
   }
  });


  addWindowListener(new WindowAdapter()
  {
   public void windowClosing(WindowEvent e)
   {
    e.getWindow().dispose();
   }
  });
}
public void setTF(String setInfo)
{
  tf.setText(setInfo);
}

}

大头剑客 2007-01-20 14:18 发表评论

用户名：
密码：

BlogJava-大头剑客学习园地--路在自己脚下......-文章分类-学习笔记

自己编写的计算器

第8章 GUI/图形用户界面

第七章 IO/输入与输出

第六章 Java API

第五章 多线程

第四章 面向对象（下）

第三章 面向对象（上）

第一章/第二章

访问其他WEB应用程序

使用ServletContext接口和ClassLoader类中的方法访问资源文件

Tomcat启动分析

Tomcat启动分析

1 - Tomcat Server的组成部分

2 - Tomcat Server的结构图

3 - 配置文件$CATALINA_HOME/conf/server.xml的说明

4 - Context的部署配置文件web.xml的说明

5 - Tomcat Server处理一个http请求的过程

Tomcat下创建和发布Web应用

◆用UDP编写网络聊天程序

第九讲 网络编程

Socket

BoxLayout组件

GridLayout,JPane组件

Swing中的标准对话框

JscrollPane组件

JFrame来创建程序的主框架窗口

取消布局管理器

布局管理器—CardLayout、GridLayout(Panel组件)

布局管理器—FlowLayout

布局管理器—BorderLayout组件

ScrollPane与TextArea组件

Choice组件

Checkbox组件

MenuBar、Menu、MenuItem组件

利用双缓冲来DrawLine

Dialog组件

第五章多线程

第四章面向对象（下）

第三章面向对象（上）

第九讲网络编程