Java中GUI编程总结—事件监听、TextField监听、画笔、（鼠标、窗口、键盘）监听

事件监听、TextField监听、画笔、鼠标监听

2.2.4事件监听

• 当某个事件发生的时候，他要干什么

  public class javaPractice {
      public static void main(String[] args) {
          //按下按钮，触发一些事件
          Frame frame= new Frame();
          Button bt=new Button("botton1");
          //按钮addActionListener()需要一个ActionListener，所以需要构造一个ActionListener
          MyActionListener myActionListener=new MyActionListener();
          bt.addActionListener(myActionListener);
          frame.add(bt,BorderLayout.CENTER);
          frame.pack();
          frame.setVisible(true);
          //关闭窗口
          windowclose(frame);
      }
      //关闭窗体事件
      private static void windowclose(Frame frame) {
          frame.addWindowListener(new WindowAdapter() {
              @Override
              public void windowClosing(WindowEvent e) {
                  System.exit(0);
              }
          });
      }
  }
  //事件监听
  class MyActionListener implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {
          System.out.println("ddd");
      }
  }
  

• 多个按钮共享一个事件

  public class javaPractice {
      public static void main(String[] args) {
          //按下按钮，触发一些事件
          Frame frame= new Frame();
          Button bt1=new Button("start");
          Button bt2=new Button("stop");
          //可以定义出发显示会返回的命令，如果不显示定义值，则会用按钮上默认的
          //这样就可以多个按钮只写一个监听类
          bt2.setActionCommand("stop-1");
          Mymonitor mymonitor=new Mymonitor();
          bt1.addActionListener(mymonitor);
          bt2.addActionListener(mymonitor);
          frame.add(bt1,BorderLayout.NORTH);
          frame.add(bt2,BorderLayout.SOUTH);
          frame.pack();
          frame.setVisible(true);
      }
  }
  //事件监听
  class Mymonitor implements ActionListener{
      @Override
      public void actionPerformed(ActionEvent e) {
          //e.getActionCommand();获得按钮的信息
          System.out.println("按钮被点击——》"+e.getActionCommand());
  
      }
  }
  

2.2.5输入框TextField 监听

public class javaPractice {
    public static void main(String[] args) {
       new Myframe();
    }
}
class Myframe extends Frame{
    public Myframe(){
        TextField textField=new TextField();
        add(textField);
        //监听这个文本框输入的文字
        MyActionListener myActionListener=new MyActionListener();
        textField.addActionListener(myActionListener);
        //设置替换编码
        textField.setEchoChar('*');
        setVisible(true);
        pack();
    }
}
//事件监听
class MyActionListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        TextField filed=(TextField)e.getSource();//获得一个资源，返回一个对象
        System.out.println(filed.getText()); //获得输入框的文本
        filed.setText("");//注意：null是一个对象，""是空
    }
}

2.2.6简易的计算器，组合+内部类复习

• oop原则：组合 大于 继承

  //继承
  class A extends B{
      
  }
  //组合   不会产生很大的耦合性
  class A{
      public B b;
  }
  

• 面向对象的写法

public class javaPractice {
    public static void main(String[] args) {
       //面向对象写法
        new Calculator().loadFrame();
    }
}
//计算器类
class Calculator extends Frame{
    //属性
    TextField num1,num2,num3;
    //方法
    public void  loadFrame(){
        //组件
        num1=new TextField(10);
        num2=new TextField(10);
        num3=new TextField(20);
        Button button=new Button("=");
        Label label=new Label("+");
        button.addActionListener(new MyCalculatorListener(this));
        //布局
        setLayout(new FlowLayout());
        add(num1);
        add(label);
        add(num2);
        add(button);
        add(num3);
        pack();
        setVisible(true);
    }
}
//监听器类
class MyCalculatorListener implements ActionListener {
    //获取计算器这个对象，在一个类中组合另一个类
    Calculator calculator=null;
    public MyCalculatorListener (Calculator calculator){
        this.calculator=calculator;
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        //1.获得加数和被加数
        //2.将这个值+法运算后，放到第三个框
        //3.清除前两个框
        int n1=Integer.parseInt(calculator.num1.getText());
        int n2=Integer.parseInt(calculator.num2.getText());
        calculator.num3.setText(""+(n1+n2));
        calculator.num1.setText("");
        calculator.num2.setText("");
    }
}

• 匿名内部类的写法（将上面的监听器类写进计算器类中成为内部类）

  private class MyCalculatorListener implements ActionListener {
          @Override
          public void actionPerformed(ActionEvent e) {
              //1.获得加数和被加数
              //2.将这个值+法运算后，放到第三个框
              //3.清除前两个框
              int n1=Integer.parseInt(num1.getText());
              int n2=Integer.parseInt(num2.getText());
              num3.setText(""+(n1+n2));
              num1.setText("");
              num2.setText("");
          }
      }
  

2.2.7画笔

public class javaPractice {
    public static void main(String[] args) {
        new MyPaint().loadFrame();
    }
}
class MyPaint extends Frame{
    public void loadFrame(){
        setBounds(200,200,600,500);
        setVisible(true);
    }
    @Override
    public void paint(Graphics g) {
        //画笔，需要有颜色，画笔可以画画
        g.setColor(Color.red);
        g.drawOval(100,100,100,100);
        g.fillRect(150,200,200,200);//实心
        //养成习惯,画笔用完将他还原到最初的颜色
    }
}

2.2.8鼠标监听

• 思路
  
• 代码

  //鼠标监听事件
  public class javaPractice {
      public static void main(String[] args) {
          new MyFrame("画图");
      }
  }
  //自己的类
  class MyFrame extends Frame{
      //画画需要画笔，需要监听鼠标的当前的位置，需要集合来存储这个点
      ArrayList points;
      public MyFrame(String title){
          super(title);
          setBounds(200,200,400,300);
          //存储鼠标点击的点
          points=new ArrayList<>();
          //鼠标监听事件，针对这个窗口
          this.addMouseListener(new MyMouseListener());
          setVisible(true);
      }
      @Override
      public void paint(Graphics g) {
          //画画，监听鼠标的事件
          Iterator iterator = points.iterator();
          while (iterator.hasNext()){
              Point point = (Point) iterator.next();
              g.setColor(Color.BLACK);
              g.fillOval(point.x,point.y,10,10);
          }
      }
      //添加一个点到界面上面
      public void addPaint(Point point){
          points.add(point);
      }
      //适配器模式
      private class  MyMouseListener extends MouseAdapter{
          //鼠标、按下、弹起，按住不放
          @Override
          public void mousePressed(MouseEvent e) {
              MyFrame frame = (MyFrame) e.getSource();
              //这里点击时候，就会在界面产生一个点
              //这个点就是鼠标的点
              frame.addPaint(new Point(e.getX(),e.getY()));
              //每次点击鼠标都要重新画一遍
              frame.repaint();//刷新
          }
      }
  }
  

2.2.9 窗口监听

public class javaPractice {
    public static void main(String[] args) {
        new WindowFrame();
    }
}
class WindowFrame extends Frame {
    public WindowFrame()  {
        setVisible(true);
        setBounds(100,100,200,200);
        setBackground(Color.blue);
        this.addWindowListener(new WindowAdapter() {
            //关闭窗口
            @Override
            public void windowClosing(WindowEvent e) {
                System.out.println("windowClosing");
                System.exit(0);
            }
            @Override
            public void windowActivated(WindowEvent e) {
                WindowFrame source = (WindowFrame)e.getSource();
                source.setTitle("被激活了");
                System.out.println("windowActivated");
            }
        });
    }
}

2.2.10键盘监听

public class javaPractice {
    public static void main(String[] args) {
        new keyFrame();
    }
}
class keyFrame extends Frame{
    public keyFrame(){
        setBounds(1,2,300,400);
        setVisible(true);
        this.addKeyListener(new KeyAdapter() {
            @Override
            public void keyPressed(KeyEvent e) {
                int keycode=e.getKeyCode();
                System.out.println(keycode);
                if(keycode==KeyEvent.VK_UP){
                    System.out.println("你按下了上键");
                }
            }
        });
    }
}