精华内容
下载资源
问答
  • 说明 要求 假定现在有路由/news,/login 监听键盘事件,只允许在/news页面内有效 不管后面哪个页面,都不会...进过/news后,不管有没有按键盘上的,再到别的页面,按键盘上的,都会触发事件 代码 srcvi...
        

    说明

    要求

    1. 假定现在有路由/news,/login
    2. 监听键盘事件,只允许在/news页面内有效
    3. 不管后面跳到哪个页面,都不会触发对应的键盘事件,只能在/news里才触发

    问题

    1. 没有进入/news之前,按键盘上的键,不会触发事件,
    2. 进过/news后,不管有没有按键盘上的键,再跳到别的页面,按键盘上的键,都会触发事件

    代码

    srcviewsnews.vue
    <template>
      <div>
        news
      </div>
    </template>
    
    <script>
    export default {
      data() {
        return {
          flag: true, //底部图片列表显示隐藏
          name: "aa"
        };
      },
      methods: {
        keyLeft() {
          alert(this.name);
        },
        keyUp() {
          alert("向上方向键");
        },
        keyRight() {
          alert("向右方向键");
        },
        keyDown() {
          alert("向下方向键");
        },
        keys() {
          var that = this;
          document.onkeydown = function(e) {
            let key = window.event.keyCode;
            if (key == 37) {
              that.keyLeft();
            } else if (key == 38) {
              that.keyUp();
              return false; //有上下滚动条的时候,不向上滚动
            } else if (key == 39) {
              that.keyRight();
            } else if (key == 40) {
              that.keyDown();
              return false; //有上下滚动条的时候,不向上滚动
            }
          };
        }
      },
      created() {
        if (this.flag == true && this.$route.path == "/news") {
          this.keys();
        }
      },
      mounted() {}
    };
    </script>
    
    展开全文
  • 流水灯我们已经学过了,那么我们来学习行列式键盘的实现。 我的依旧是IAP15F2K61S2芯片,建的...我们先来写一个程序,让s4按下后led灯全亮: #include "reg52.h" sbit P30 = P3^0; sbit P31 = P3^1; sbit P32 = P3^2;

    流水灯我们已经学过了,那么我们来学习独立按键的实现。
    我的依旧是IAP15F2K61S2芯片,建的工程是IAP89C52的
    首先要是写独立按键键盘,请将J5跳线帽跳到2,3上,这样才是只有s4-s7起作用,我们来看原理图
    在这里插入图片描述
    这样很清晰能看出来哪个引脚控制哪个,也就不用多讲
    如果按下s4那么P33为0,则能表示出来按键情况
    我们先来写一个程序,让s4按下后led灯全亮:

    #include "reg52.h"
    sbit P30 = P3^0;
    sbit P31 = P3^1;
    sbit P32 = P3^2;
    sbit P33 = P3^3;
    void delayms(int ms)
    {
    	unsigned int i;
    	while(ms--){
    		for(i=0;i<628;i++);
    	}
    }
    void main(){
    	P2=0XA0;P0=0X00;
    	P2=0X80;P0=0XFF;
    	while(1){
    		if(P33==0){
    			delayms(5);
    			if(P32==0)
    			{
    				P0=0x00;
    			}
    			while(!P33);
    		}
    	}
    }
    

    编译后写入,可以看到,按下s4灯全亮,按其他的都不管用,而且关不掉灯
    先来解释一下delayms(5),理想按键的电流图是矩形的,但是实际人按下来的时候他是会抖的,所以我们避开那个5ms的抖动时间来判断按键
    while(!P30)是为了确认按键是否真的被松开
    那么我们还可以设计四个按键的功能:

    #include "reg52.h"
    sbit P30 = P3^0;
    sbit P31 = P3^1;
    sbit P32 = P3^2;
    sbit P33 = P3^3;
    void delayms(int ms)
    {
    	unsigned int i;
    	while(ms--){
    		for(i=0;i<628;i++);
    	}
    }
    void main(){
    	P2=0XA0;P0=0X00;
    	P2=0X80;P0=0XFF;
    	while(1){
    		if(P33==0){
    			delayms(5);
    			if(P32==0)
    			{
    				P0=0x00;
    			}
    			while(!P33);
    		}
    		else if(P31==0){
    			delayms(5);
    			if(P31==0){
    				P0=0xf0;//led亮前四个
    			}
    			while(!P31);
    		}
    		else if(P32==0){
    			delayms(5);
    			if(P32==0)
    			{
    				P0=0xff//led灯全灭
    			}
    			while(!P32);
    		}
    		else if(P33==0){
    			delayms(5);
    			if(P32==0)
    			{
    				P0=0x77//led灯奇数灯亮
    			}
    			while(!P33);
    		}
    	}
    }
    

    但是这样的话,主函数是不是太麻烦,太长了呢?
    我们可以设置四个变量来储存他们的情况
    看代码,我是这样实现的:

    #include "reg52.h"
    sbit P30 = P3^0;
    sbit P31 = P3^1;
    sbit P32 = P3^2;
    sbit P33 = P3^3;
    unsigned char s7=0,s6=0,s5=0,s4=0;
    void delayms(int ms);
    void main(){
    	P2=0XA0;P0=0X00;
    	P2=0X80;P0=0XFF;
    	while(1){
    		keycan();
    		if(s7==1){
    			s7=0;
    			P0=0X00;
    		}
    		else if(s6==1){
    			s6=0;
    			P0=0xff;
    		}
    		else if(s5==1){
    			s5=0;
    			P0=0x55;
    		}
    		else if(s4==1){
    			s4 = 1;
    			P0=0xAA;
    	}
    }
    }
    void delayms(int ms)
    {
    	unsigned int i;
    	while(ms--){
    		for(i=0;i<628;i++);
    	}
    }
    
    void keycan(){
    	if(P30==0){
    		delayms(5);
    		if(P30==0){
    			s7=1;
    		}
    		while(!P30);
    	}
    	else if(P31==0){
    		delayms(5);
    		if(P31==0){
    			s6=1;
    		}
    		while(!P31);
    	}
    	else if(P32==0){
    		delayms(5);
    		if(P32==0)
    		{
    			s5=1;
    		}
    		while(!P32);
    	}
    	else if(P33==0){
    		delayms(5);
    		if(P32==0)
    		{
    			s5=1;
    		}
    		while(!P33);
    	}
    }
    

    好了,这就是独立键盘的控制,当然你也可以写成P3口整体的形式 P3=0x·· 来表示引脚的状态,只不过本人觉得难写罢了

    展开全文
  • 无论按钮位于一个按钮上的哪个位置,都将在其他按钮上位于相同的按钮位置。 下面将显示控件,就像您正在使用XBox 360或XBox One控制器一样。 行动 键盘 控制器 移动 [WASD] [L模拟] / [D打击垫] [。] [一个]...
  • 在文本框中添加键盘监听(参数是创建KeyListener的匿名内部类),会出来重写三方法,我们只要重写俩就行(按键被按下、按键释放) 用switch来判断案件代码代表的是哪个按键(使用KeyEvent提供的静态常量) ...

    键盘事件

    java中处理键盘事件的方法:KeyListener键盘监听(它是一个接口,一共有3种抽象方法)
    在这里插入图片描述
    KeyEvent提供了很多静态常量,而这些静态常量就分别代表了键盘上不同的按键
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在文本框中添加键盘监听(参数是创建KeyListener的匿名内部类),会跳出来重写三个方法,我们只要重写俩个就行(按键被按下、按键释放)
    用switch来判断案件代码代表的是哪个按键(使用KeyEvent提供的静态常量)。另外要注意,当释放这个键时,颜色再变回去
    但是,键盘上一共有26个字母,可以不用写26个case,去运用简单的方法:既然我们已经有了按钮对象,把所有这些按钮对象放在一个集合中

    package keyboard_event;
    
    import java.awt.*;
    import java.util.List;
    import java.awt.event.*;
    import java.util.*;
    import javax.swing.*;
    import javax.swing.border.*;
    
    public class KeyBoard extends JFrame { // 创建“键盘”类继承JFrame
    
    	// 声明窗体中的成员组件
    	private JPanel contentPane;
    	private JTextField textField;
    	private JButton btnQ;
    	private JButton btnW;
    	private JButton btnE;
    	private JButton btnR;
    	private JButton btnT;
    	private JButton btnY;
    	private JButton btnU;
    	private JButton btnI;
    	private JButton btnO;
    	private JButton btnP;
    	private JButton btnA;
    	private JButton btnS;
    	private JButton btnD;
    	private JButton btnF;
    	private JButton btnG;
    	private JButton btnH;
    	private JButton btnJ;
    	private JButton btnK;
    	private JButton btnL;
    	private JButton btnZ;
    	private JButton btnX;
    	private JButton btnC;
    	private JButton btnV;
    	private JButton btnB;
    	private JButton btnN;
    	private JButton btnM;
    
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		EventQueue.invokeLater(new Runnable() { // 使得Runnable中的run()方法在the system EventQueue
    			public void run() { // 的指派线程中被调用
    				try {
    					KeyBoard frame = new KeyBoard(); // 创建KeyBoard对象
    					frame.setVisible(true); // 使窗体frame可视
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	/**
    	 * Create the frame.
    	 */
    	public KeyBoard() { // KeyBoard的构造方法
    
    		setResizable(false); // 不可改变窗体的宽高
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗体关闭的方式
    		setBounds(100, 100, 548, 280); // 设置窗体的位置和宽高
    
    		/**
    		 * 创建JPanel面板contentPane置于JFrame窗体中,并设置面板的背景色、边距和布局
    		 */
    		contentPane = new JPanel();
    		contentPane.setBackground(Color.WHITE);
    		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    //		contentPane.setLayout(new BorderLayout(0, 0));
    		setContentPane(contentPane);
    		contentPane.setLayout(null);
    
    		/**
    		 * 创建按钮button置于面板contentPane中,设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    		 */
    		btnQ = new JButton("Q");
    		btnQ.setBackground(Color.WHITE);
    		btnQ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnQ.setHorizontalAlignment(SwingConstants.LEADING);
    		btnQ.setVerticalAlignment(SwingConstants.TOP);
    		btnQ.setBounds(0, 60, 47, 45);
    		contentPane.add(btnQ);
    
    		/**
    		 * 创建按钮button置于面板contentPane中,设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
    		 */
    		btnW = new JButton("W");
    		btnW.setBackground(Color.WHITE);
    		btnW.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnW.setHorizontalAlignment(SwingConstants.LEADING);
    		btnW.setVerticalAlignment(SwingConstants.TOP);
    		btnW.setBounds(55, 60, 49, 45);
    		contentPane.add(btnW);
    
    		btnE = new JButton("E");
    		btnE.setBackground(Color.WHITE);
    		btnE.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnE.setHorizontalAlignment(SwingConstants.LEADING);
    		btnE.setVerticalAlignment(SwingConstants.TOP);
    		btnE.setBounds(110, 60, 45, 45);
    		contentPane.add(btnE);
    
    		btnR = new JButton("R");
    		btnR.setBackground(Color.WHITE);
    		btnR.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnR.setHorizontalAlignment(SwingConstants.LEADING);
    		btnR.setVerticalAlignment(SwingConstants.TOP);
    		btnR.setBounds(165, 60, 45, 45);
    		contentPane.add(btnR);
    
    		btnF = new JButton("F");
    		btnF.setBackground(Color.WHITE);
    		btnF.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnF.setHorizontalAlignment(SwingConstants.LEADING);
    		btnF.setVerticalAlignment(SwingConstants.TOP);
    		btnF.setBounds(195, 125, 45, 45);
    		contentPane.add(btnF);
    
    		btnD = new JButton("D");
    		btnD.setBackground(Color.WHITE);
    		btnD.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnD.setHorizontalAlignment(SwingConstants.LEADING);
    		btnD.setVerticalAlignment(SwingConstants.TOP);
    		btnD.setBounds(137, 125, 45, 45);
    		contentPane.add(btnD);
    
    		btnT = new JButton("T");
    		btnT.setBackground(Color.WHITE);
    		btnT.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnT.setHorizontalAlignment(SwingConstants.LEADING);
    		btnT.setVerticalAlignment(SwingConstants.TOP);
    		btnT.setBounds(220, 60, 45, 45);
    		contentPane.add(btnT);
    
    		btnY = new JButton("Y");
    		btnY.setBackground(Color.WHITE);
    		btnY.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnY.setHorizontalAlignment(SwingConstants.LEADING);
    		btnY.setVerticalAlignment(SwingConstants.TOP);
    		btnY.setBounds(275, 60, 45, 45);
    		contentPane.add(btnY);
    
    		btnU = new JButton("U");
    		btnU.setBackground(Color.WHITE);
    		btnU.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnU.setHorizontalAlignment(SwingConstants.LEADING);
    		btnU.setVerticalAlignment(SwingConstants.TOP);
    		btnU.setBounds(330, 60, 45, 45);
    		contentPane.add(btnU);
    
    		btnI = new JButton("I");
    		btnI.setBackground(Color.WHITE);
    		btnI.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnI.setHorizontalAlignment(SwingConstants.LEADING);
    		btnI.setVerticalAlignment(SwingConstants.TOP);
    		btnI.setBounds(385, 60, 45, 45);
    		contentPane.add(btnI);
    
    		btnO = new JButton("O");
    		btnO.setBackground(Color.WHITE);
    		btnO.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnO.setHorizontalAlignment(SwingConstants.LEADING);
    		btnO.setVerticalAlignment(SwingConstants.TOP);
    		btnO.setBounds(440, 60, 46, 45);
    		contentPane.add(btnO);
    
    		btnP = new JButton("P");
    		btnP.setBackground(Color.WHITE);
    		btnP.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnP.setHorizontalAlignment(SwingConstants.LEADING);
    		btnP.setVerticalAlignment(SwingConstants.TOP);
    		btnP.setBounds(495, 60, 45, 45);
    		contentPane.add(btnP);
    
    		btnA = new JButton("A");
    		btnA.setBackground(Color.WHITE);
    		btnA.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnA.setHorizontalAlignment(SwingConstants.LEADING);
    		btnA.setVerticalAlignment(SwingConstants.TOP);
    		btnA.setBounds(23, 125, 45, 45);
    		contentPane.add(btnA);
    
    		btnS = new JButton("S");
    		btnS.setBackground(Color.WHITE);
    		btnS.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnS.setHorizontalAlignment(SwingConstants.LEADING);
    		btnS.setVerticalAlignment(SwingConstants.TOP);
    		btnS.setBounds(82, 125, 45, 45);
    		contentPane.add(btnS);
    
    		btnG = new JButton("G");
    		btnG.setBackground(Color.WHITE);
    		btnG.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnG.setHorizontalAlignment(SwingConstants.LEADING);
    		btnG.setVerticalAlignment(SwingConstants.TOP);
    		btnG.setBounds(251, 125, 45, 45);
    		contentPane.add(btnG);
    
    		btnH = new JButton("H");
    		btnH.setBackground(Color.WHITE);
    		btnH.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnH.setHorizontalAlignment(SwingConstants.LEADING);
    		btnH.setVerticalAlignment(SwingConstants.TOP);
    		btnH.setBounds(306, 125, 45, 45);
    		contentPane.add(btnH);
    
    		btnJ = new JButton("J");
    		btnJ.setBackground(Color.WHITE);
    		btnJ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnJ.setHorizontalAlignment(SwingConstants.LEADING);
    		btnJ.setVerticalAlignment(SwingConstants.TOP);
    		btnJ.setBounds(361, 125, 45, 45);
    		contentPane.add(btnJ);
    
    		btnK = new JButton("K");
    		btnK.setBackground(Color.WHITE);
    		btnK.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnK.setHorizontalAlignment(SwingConstants.LEADING);
    		btnK.setVerticalAlignment(SwingConstants.TOP);
    		btnK.setBounds(416, 125, 47, 45);
    		contentPane.add(btnK);
    
    		btnL = new JButton("L");
    		btnL.setBackground(Color.WHITE);
    		btnL.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnL.setHorizontalAlignment(SwingConstants.LEADING);
    		btnL.setVerticalAlignment(SwingConstants.TOP);
    		btnL.setBounds(471, 125, 45, 45);
    		contentPane.add(btnL);
    
    		btnZ = new JButton("Z");
    		btnZ.setBackground(Color.WHITE);
    		btnZ.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnZ.setHorizontalAlignment(SwingConstants.LEADING);
    		btnZ.setVerticalAlignment(SwingConstants.TOP);
    		btnZ.setBounds(39, 190, 45, 45);
    		contentPane.add(btnZ);
    
    		btnX = new JButton("X");
    		btnX.setBackground(Color.WHITE);
    		btnX.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnX.setHorizontalAlignment(SwingConstants.LEADING);
    		btnX.setVerticalAlignment(SwingConstants.TOP);
    		btnX.setBounds(107, 190, 45, 45);
    		contentPane.add(btnX);
    
    		btnC = new JButton("C");
    		btnC.setBackground(Color.WHITE);
    		btnC.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnC.setHorizontalAlignment(SwingConstants.LEADING);
    		btnC.setVerticalAlignment(SwingConstants.TOP);
    		btnC.setBounds(178, 190, 45, 45);
    		contentPane.add(btnC);
    
    		btnV = new JButton("V");
    		btnV.setBackground(Color.WHITE);
    		btnV.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnV.setHorizontalAlignment(SwingConstants.LEADING);
    		btnV.setVerticalAlignment(SwingConstants.TOP);
    		btnV.setBounds(256, 190, 45, 45);
    		contentPane.add(btnV);
    
    		btnB = new JButton("B");
    		btnB.setBackground(Color.WHITE);
    		btnB.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnB.setHorizontalAlignment(SwingConstants.LEADING);
    		btnB.setVerticalAlignment(SwingConstants.TOP);
    		btnB.setBounds(315, 190, 45, 45);
    		contentPane.add(btnB);
    
    		btnN = new JButton("N");
    		btnN.setBackground(Color.WHITE);
    		btnN.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnN.setHorizontalAlignment(SwingConstants.LEADING);
    		btnN.setVerticalAlignment(SwingConstants.TOP);
    		btnN.setBounds(382, 190, 47, 45);
    		contentPane.add(btnN);
    
    		btnM = new JButton("M");
    		btnM.setBackground(Color.WHITE);
    		btnM.setFont(new Font("Times New Roman", Font.PLAIN, 16));
    		btnM.setHorizontalAlignment(SwingConstants.LEADING);
    		btnM.setVerticalAlignment(SwingConstants.TOP);
    		btnM.setBounds(449, 190, 48, 45);
    		contentPane.add(btnM);
    
    		/**
    		 * 创建面板panel置于面板contentPane中,设置面板panel的位置和宽高,TitleBorder、背景色以及布局方式(边界布局)
    		 */
    		JPanel panel = new JPanel();
    		panel.setBorder(new TitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP));
    		panel.setBackground(Color.WHITE);
    		panel.setBounds(0, 0, 540, 45);
    		contentPane.add(panel);
    		panel.setLayout(new BorderLayout(0, 0));
    
    		/**
    		 * 创建文本框textField置于面板panel的中间
    		 */
    		textField = new JTextField();
    		panel.add(textField, BorderLayout.CENTER);
    		textField.setColumns(10);
    		
    		List<JButton> list = new ArrayList<>();
    		Component items[] = contentPane.getComponents();    //返回容器中所有的组件
    		for(Component c: items) {
    			if(c instanceof JButton) {                      //如果这个组件是按钮
    				list.add((JButton)c);
    			}
    		}
    		
    		textField.addKeyListener(new KeyListener() {
    			@Override
    			public void keyPressed(KeyEvent e) {           //按键被按下
    				char ch = e.getKeyChar();                  //获取按键字符
    				for(JButton btn: list) {
    					String btnText = btn.getText();
    					if(btnText.equalsIgnoreCase(String.valueOf(ch))) {
    						btn.setBackground(Color.green);
    					}
    				}
    			}
    
    			@Override
    			public void keyReleased(KeyEvent e) {          //按键释放
    				char ch = e.getKeyChar();                  //获取按键字符
    				for(JButton btn: list) {
    					String btnText = btn.getText();
    					if(btnText.equalsIgnoreCase(String.valueOf(ch))) {
    						btn.setBackground(Color.white);
    					}
    				}
    			}
    
    			@Override
    			public void keyTyped(KeyEvent e) {
    				
    			}
    			
    		});
    		
    	}
    }
    
    

    键盘事件监听:在给组件添加键盘事件监听时,java虚拟机会自动捕获用户输入的指令(通过具体方法来看用户输入的到底是哪个指令),再根据用户输入的指令让程序做出相应操作

    鼠标事件

    在这里插入图片描述
    鼠标按下+释放,做完这一套动作之后,不同的程序会对我们的动作做出不同的反应。而这个动作触发的事件就叫做鼠标事件。
    在这里插入图片描述
    在java中,我们使用MouseListener来监听鼠标事件(它也是一个接口,有5个方法
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    鼠标事件监听可以知道用户点击了几次,以及按下的是哪个按键
    鼠标事件e的一个方法getButton返回的是一个int值获取用户点击了哪个按键(按钮的一个代码);getClickCount可以获取用户点击的次数

    package mouse_event;
    
    import java.awt.*;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    
    import javax.swing.*;
    import javax.swing.border.*;
    
    public class Mouse extends JFrame {              //继承窗体类JFrame
    
    	private JPanel contentPane;
    
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				try {
    					Mouse frame = new Mouse();
    					frame.setVisible(true);     //设置窗体可见
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	/**
    	 * Create the frame.
    	 */
    	public Mouse() {
    		setTitle("鼠标事件示例");
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setBounds(100, 100, 473, 321);
    		getContentPane().setLayout(null);
    		
    		final JLabel label = new JLabel();
    		label.setBounds(244, 57, 160, 141);
    		label.setBorder(new LineBorder(Color.red, 2));
    		getContentPane().add(label);
    		
    		JScrollPane scrollPane = new JScrollPane();
    		scrollPane.setBounds(32, 27, 183, 216);
    		getContentPane().add(scrollPane);
    		
    		JTextArea textArea = new JTextArea();
    		scrollPane.setViewportView(textArea);
    		
    		JLabel label_1 = new JLabel("鼠标点击区域");
    		label_1.setBounds(281, 32, 84, 15);
    		getContentPane().add(label_1);
    		
    		label.addMouseListener(new MouseListener() {
    
    			@Override
    			public void mouseClicked(MouseEvent e) {      //鼠标点击
    				textArea.append("点击了鼠标按键\n");
    				
    				int btn = e.getButton();
    				switch(btn) {
    				case MouseEvent.BUTTON1:
    					textArea.append("按下的是鼠标左键\n");
    					break;
    				case MouseEvent.BUTTON2:
    					textArea.append("按下的是鼠标滚轮键\n");
    					break;	
    				case MouseEvent.BUTTON3:
    					textArea.append("按下的是鼠标右键\n");
    					break;	
    				}
    				
    				int count = e.getClickCount();           //鼠标点击次数
    				textArea.append("鼠标点击了" + count + "次\n");
    			}
    
    			@Override
    			public void mousePressed(MouseEvent e) {     //按键按下
    				textArea.append("鼠标按键被按下\n");
    			}
    
    			@Override
    			public void mouseReleased(MouseEvent e) {     //按键释放
    				textArea.append("鼠标按键被释放\n");
    			}
    
    			@Override
    			public void mouseEntered(MouseEvent e) {      //鼠标进入
    				textArea.append("鼠标进入组件\n");
    			}
    
    			@Override
    			public void mouseExited(MouseEvent e) {       //鼠标退出
    				textArea.append("鼠标离开组件\n");
    			}
    			
    		});
    		
    	}
    }
    
    

    窗体焦点事件

    在这里插入图片描述
    当窗体得到或失去焦点时,会触发一个事件,这个事件就是窗体焦点事件
    在java中,用WindowFocusListener来对窗体焦点事件进行监听(WindowFocusListener是一个接口,它有两个方法
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    这里有两个label,第一个label是一个标签(输出一行话),第二个标签放的是一个图片。我们只需要在切换窗体焦点时,对这两个标签进行操作就行了
    给窗体添加焦点事件监听:

    package forms_focus_event;
    
    import java.awt.*;
    import java.awt.event.*;
    
    import javax.swing.*;
    import javax.swing.border.*;
    
    public class Forms_Focus extends JFrame {         //创建一个“焦点”类,并继承JFrame
    /**
     * 焦点事件的监听,使用焦点事件的监听模拟点亮灯泡的过程
     */
    	//声明窗体中的组件
    	private JPanel contentPane;
    	private JLabel lblTip;
    	private JLabel lblLight;
    
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				try {
    					Forms_Focus frame = new Forms_Focus();
    					frame.setVisible(true);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	/**
    	 * Create the frame.
    	 */
    	public Forms_Focus() {                //Focus的构造方法
    		setResizable(false);              //不可改变窗体大小
    		setTitle("焦点事件的监听");           //设置窗体题目
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setBounds(100, 100, 300, 300);
    		
    		/**
    		 * 创建JPanel面板contentPane置于JFrame窗体中,并设置面板背景色、边距和布局)
    		 */
    		contentPane = new JPanel();
    		contentPane.setBackground(Color.BLACK);
    		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
    		contentPane.setLayout(new BorderLayout(0, 0));
    		setContentPane(contentPane);
    		
    		/**
    		 * 创建标签lblTip置于JFrame窗体中的南侧,设置该标签中字体的颜色、样式以及水平居中
    		 */
    		lblTip = new JLabel("JFrame窗体获得焦点,灯亮了!");
    		lblTip.setHorizontalAlignment(SwingConstants.CENTER);
    		lblTip.setFont(new Font("微软雅黑", Font.PLAIN, 14));
    		lblTip.setForeground(Color.CYAN);
    		contentPane.add(lblTip, BorderLayout.SOUTH);
    		
    		/**
    		 * 创建标签lblLight置于JFrame窗体中的中间,设置该标签中的图标位置和样式
    		 */
    		lblLight = new JLabel();
    		lblLight.setHorizontalAlignment(SwingConstants.CENTER);
    		lblLight.setIcon(new ImageIcon(Forms_Focus.class.getResource("light.png")));
    		contentPane.add(lblLight, BorderLayout.CENTER);
    		
    		//直接给窗体添加监听事件
    		addWindowFocusListener(new WindowFocusListener() {
    
    			@Override
    			public void windowGainedFocus(WindowEvent e) {      //获得焦点
    				lblLight.setIcon(new ImageIcon(Forms_Focus.class.getResource("light.png")));
    				lblTip.setText("JFrame窗体获得焦点,灯亮了!");
    			}
    
    			@Override
    			public void windowLostFocus(WindowEvent e) {        //失去焦点
    				lblLight.setIcon(new ImageIcon(Forms_Focus.class.getResource("dark.png")));
    				lblTip.setText("JFrame窗体失去焦点,灯灭了!");
    			}
    			
    		});
    		
    	}
    
    }
    
    

    窗体状态事件

    在这里插入图片描述
    在java中,用WindowStateListener来监听窗体的状态事件(它是一个接口,只有一个方法
    在这里插入图片描述
    窗体事件类提供了两个方法,可以分别捕获以前的状态getOldState、现在的状态getNewState
    在这里插入图片描述
    两个方法的返回值都是一个int的值

    package forms_state_event;
    
    import java.awt.*;
    import java.awt.event.*;
    
    import javax.swing.*;
    import javax.swing.border.*;
    
    public class Forms_State extends JFrame {
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				try {
    					Forms_State frame = new Forms_State();
    					frame.setVisible(true);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	/**
    	 * Create the frame.
    	 */
    	public Forms_State() {
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setBounds(100, 100, 300, 300);
    		
    		addWindowStateListener(new WindowStateListener() {
    
    			@Override
    			public void windowStateChanged(WindowEvent e) {
    				int oldState = e.getOldState();      //窗体以前的状态
    				int newState = e.getNewState();      //窗体选中的状态
    				String from = "";
    				switch(oldState) {
    				case Frame.NORMAL:                   //窗体处于正常化
    					from = "正常化";
    					break;
    				case Frame.MAXIMIZED_BOTH:           //窗体处于最大化
    					from = "最大化";
    					break;
    				default:                             //窗体处于最小化
    					from = "最小化";
    				}
    				
    				String to = "";
    				switch(newState) {
    				case Frame.NORMAL:                   //窗体处于正常化
    					to = "正常化";
    					break;
    				case Frame.MAXIMIZED_BOTH:           //窗体处于最大化
    					to = "最大化";
    					break;
    				default:                             //窗体处于最小化
    					to = "最小化";
    				}
    				System.out.println(from + "--->" + to);
    			}
    			
    		});
    	}
    
    }
    
    

    窗体有了正常化、最大化,但是窗体最小化并没有一个确切的常量,所以这里用default
    这个例子充分展示了窗体状态监听的使用方式,用到了两个常量:Frame.NORMAL(窗体处于正常化)和Frame.MAXIMIZED_BOTH(窗体处于最大化)

    窗体事件

    窗体事件涵盖了很多可以触发的事件,在java中,使用WindowListener监听窗体事件(它是一个接口,其抽象方法有7个)
    在这里插入图片描述
    现在要给窗体创建监听事件,这个监听事件可以直接写成一个匿名内部类,也可以单独写成一个类
    我们在这里创建一个成员内部类

    package forms_event;
    
    import java.awt.*;
    import java.awt.event.*;
    
    import javax.swing.*;
    import javax.swing.border.*;
    
    public class Forms extends JFrame {
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				try {
    					Forms frame = new Forms();
    					frame.setVisible(true);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	/**
    	 * Create the frame.
    	 */
    	public Forms() {
    		//setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setDefaultCloseOperation(DISPOSE_ON_CLOSE);     //关闭窗体时 释放窗体资源
    		setBounds(100, 100, 300, 300);
    		
    		addWindowListener(new MyWindowListener());
    	}
    	
    	class MyWindowListener implements WindowListener{
    
    		@Override
    		public void windowOpened(WindowEvent e) {       //窗体打开
    			System.out.println("窗体被打开!");
    		}
    
    		@Override
    		public void windowClosing(WindowEvent e) {      //窗体要被关闭
    			System.out.println("窗体将要被关闭!");
    		}
    
    		@Override
    		public void windowClosed(WindowEvent e) {      //窗体已被关闭  
    			System.out.println("窗体已经被关闭了!");        //EXIT_ON_CLOSE 可能无法触发此方法
    		}
    
    		@Override
    		public void windowIconified(WindowEvent e) {
    			System.out.println("窗体被最小化!");
    		}
    
    		@Override
    		public void windowDeiconified(WindowEvent e) {
    			System.out.println("窗体恢复正常大小!");
    		}
    
    		@Override
    		public void windowActivated(WindowEvent e) {       //窗体激活
    			System.out.println("窗体被激活!");
    		}
    
    		@Override
    		public void windowDeactivated(WindowEvent e) {     //窗体失去激活状态
    			System.out.println("窗体失去激活!");
    		}
    		
    	}
    
    }
    
    

    当我们打开一个窗体时,首先会激活这个窗体,于是就触发了这个方法(窗体首先被激活,然后再被打开
    窗体最小化,就是失去激活(我们现在操作不了它了);再点回来,窗体重新被激活
    点击关闭窗体,不会失去激活,但是会windowClosing(将要关闭),已经被关闭(windowClosed)不会触发;
    注意:
    dispose_on_close:关闭窗体时释放窗体资源(窗体不存在,但是程序并没有停),这个情况下,窗体关闭之前会失去激活,最后窗体被彻底关闭
    exit_on_close:关闭窗体时同时停止程序
    另外,全屏操作不会触发任何方法

    选项事件

    在这里插入图片描述
    在java中,用ItemListener来监听选项事件(它是一个接口,有一个抽象方法
    用到这个监听的常用组件有三个:下拉列表框、复选框、单选框。同一种监听可以用在不同组件上
    在这里插入图片描述
    选项事件类提供了两个常用的方法:
    object getItem()返回选中的对象(通常用在下拉列表框上)
    int getStateChange()返回选中的状态(此方法用于复选框和单选框上)
    在这里插入图片描述
    在这里插入图片描述

    package option_event;
    
    import java.awt.*;
    import java.awt.event.*;
    
    import javax.swing.*;
    import javax.swing.border.*;
    
    public class Option extends JFrame {
    	/**
    	 * Launch the application.
    	 */
    	public static void main(String[] args) {
    		EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				try {
    					Option frame = new Option();
    					frame.setVisible(true);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		});
    	}
    
    	/**
    	 * Create the frame.
    	 */
    	public Option() {
    		setTitle("展示组件");
    		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		setBounds(100, 100, 307, 194);
    		
    		Container contentPane = getContentPane();          //获取窗体容器
    		JPanel leftPanel = new JPanel();                   //创建左侧面板
    		contentPane.add(leftPanel, BorderLayout.WEST);     //放入容器西部区域
    		leftPanel.setLayout(new BorderLayout());           //左侧面板使用边界布局
    		
    		JLabel titleLabel = new JLabel("选择要显示的组件");
    		leftPanel.add(titleLabel, BorderLayout.NORTH);     //标签放入左侧面板北部区域
    		
    		String items[] = {"全部显示", "复选框", "单选按钮"};      //创建下拉列表框数组
    		JComboBox comboBox = new JComboBox(items);         //创建下拉列表框,使用items作为显示值
    		
    		JPanel tmpPanel = new JPanel();                    //临时面板,为了避免下拉列表框被边界布局拉扯变形
    		tmpPanel.add(comboBox);                            //下拉列表框放入临时面板中
    		leftPanel.add(tmpPanel, BorderLayout.CENTER);      //临时面板放入左侧面板中部区域
    		
    		JPanel rightPanel = new JPanel();                  //创建右侧面板
    		rightPanel.setBorder(new LineBorder(Color.black)); //右侧面板使用黑色线边框
    		contentPane.add(rightPanel, BorderLayout.CENTER);  //右侧面板放入容器中部区域
    		
    		JCheckBox check = new JCheckBox("复选框");            //复选框
    		rightPanel.add(check);	
    		JRadioButton radio = new JRadioButton("单选按钮");    //单选按钮
    		rightPanel.add(radio);
    		
    		comboBox.addItemListener(new ItemListener() {
    
    			@Override
    			public void itemStateChanged(ItemEvent e) {
    				String itemName = e.getItem().toString();   //获取下拉列表中选中的字符串类型值
    				switch(itemName) {
    				case "复选框":
    					check.setVisible(true);                 //复选框可见
    					radio.setVisible(false);                //单选框不可见
    					break;
    				case "单选按钮":
    					check.setVisible(false);                //复选框不可见
    					radio.setVisible(true);                 //单选框可见
    					break;
    				default:
    					check.setVisible(true);                 //复选框可见
    					radio.setVisible(true);                 //单选框可见
    				}
    				
    			}
    			
    		});
    		
    		check.addItemListener(new MyItemListener());
    		radio.addItemListener(new MyItemListener());	
    	}
    	
    	class MyItemListener implements ItemListener{
    
    		@Override
    		public void itemStateChanged(ItemEvent e) {
    			//强制地转换成 复选框和单选按钮的共同父类:抽象按钮
    			AbstractButton btn = (AbstractButton)e.getSource();   //返回触发选项事件的组件
    			int state = e.getStateChange();    //获取组件的选中状态
    			switch(state) {
    			case ItemEvent.SELECTED:
    				System.out.println(btn.getText() + "选中");
    				break;
    			case ItemEvent.DESELECTED:
    				System.out.println(btn.getText() + "取消");
    			}
    		}
    		
    	}
    
    }
    
    

    复选框和单选按钮也可以添加选项事件,让他们输出选中和未选中的状态
    我们在这里创建内部类MyItemListener,去继承ItemListener
    复选框和单选按钮都有选中和未选中的状态,所以我们先去获取它们各自的选中状态
    用ItemEvent的getSource这个方法(它的返回值是object类型的,所以要做强制转换),获取触发此事件的组件(因为单选框和复选框是两个完全不同的组件),可以去调用这两个组件的一个父类:AbstractButton这样一个类然后可以输出它的文本值btn.getText()

    展开全文
  • 你必须知道的495C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此...
  • 《你必须知道的495C语言问题》

    热门讨论 2010-03-20 16:41:18
    我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此...
  • 我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此...
  • 入门学习Linux常用必会60命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    虚拟控制台的切换可以通过按下Alt一个功能来实现,通常使用F1-F6 。 例如,用户登录后,一下“Alt+ F2”,用户就可以看到上面出现的“login:”提示符,说明用户看到了第二个虚拟控制台。然后只需“Alt+...
  • 你必须知道的495C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    4.3 我有一个char * 型指针正巧指向一些int 型变量, 我想过它们。 为什么如下的代码((int *)p)++; 不行? . . . . . . . . . . . . . . 17 4.4 我有个函数,它应该接受并初始化一个指针void f(int *ip) f static ...
  • 我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此...
  • 我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此...
  • 我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此...
  • 我在设计一个状态机,用函数表示每种状态,每个函数都会返回一个指向下一个状态的函数的指针。可我找不到任何方法来声明这样的函数——感觉我需要一个返回指针的函数,返回的指针指向的又是返回指针的函数……,如此...
  • Visual Studio程序员箴言中文扫描PDF

    热门讨论 2010-12-28 01:04:18
    技巧1.5 使用ctrl+delete组合删除下一个单词,使用ctrl+backspace组合删除前一个单词 3 技巧1.6 使用ctrl+l组合剪切当前行,使用ctrl+shift+l组合删除当前行 4 技巧1.7 删除一行开头的水平空白 4 技巧...
  • 解决了关闭窗口可能会更改下一个窗口上的选项卡的错误。 如果您想提供帮助,请为这个问题加注星标:http://code.google.com/p/chromium/issues/detail?id=37739或将“可配置默认功能”评分为5星以下(每个窗口)。...
  • 当有多个同时按下时,只处理一个按键,不管一次按键持续多长时间,仅执行一次按键功能程序。 矩阵按键扫描程序是一种节省IO口的方法,按键数目越多节省IO口就越可观,思路:先判断某一列(行)是否有按键按下,再...
  • Visual Studio程序员箴言--详细书签版

    热门讨论 2012-10-16 20:37:39
    技巧1.5 使用Ctrl+Delete组合删除下一个单词,使用Ctrl+Backspace组合删除前一个单词 3 技巧1.6 使用Ctrl+L组合剪切当前行,使用Ctrl+Shift+L组合删除当前行 4 技巧1.7 删除一行开头的水平空白 4 ...
  • 让默认的就可以了,但是超频玩者是肯定不会放过任何可以提高性能的东西的,所以如果你想在这里让你的电脑提升一点性能的话,就必须慢慢试验,选择一个适当的参数才能让你的计算机达到性能和稳定的最佳状态!...
  • 3、如果你只想拥有本页顶部描述的基本功能,请过本条看下一条。 想拥有更强大的DOS功能,请下载下面的压缩包(复制链接,使用工具下载): 地址1: http://nnmm.arongsoft.com/dos/boot/dosapp-1218.rar 地址2: ...
  • CuteFTP9简易汉化版

    2014-04-11 12:31:30
    覆盖Rules-Configure一种上传软件,以确定现有文件匹配一个被转移需要重写,重命名,或过基于日期、大小、和其他标准,或选择促使每次找到一个匹配的文件。 Auto-Rename Transfers-Create规则更改一个文件的名字,扩展,...
  • o 5.3 我有一个 char * 型指针正巧指向一些 int 型变量, 我想过它们。为什么如下的代码 ((int *)p)++; 不行? o 5.4 我有个函数,它应该接受并初始化一个指针 void f(int *ip) { static int dummy = 5; ip = &...
  • 安装完毕,选择现在不激活以后激活,按下一步,至少填入一个名字,如JixXP,一路回车,可以 了。 现在开始激活系统:我采用的是俄罗斯黑客的激活办法。见下面使用说明: 方法:把SETUPREG.HIV复制到%...
  • powerbuilder

    2013-11-21 17:11:48
    用法在一个打印作业中,应用程序能够最多同时定义8种字体。当应用程序需要使用更多的字体时,可以在使用了某个字体号输出内容后使用PrintDefineFont()函数将该字体号对应的字体更换为其它字体。 ----------------...
  • shift切换输入法,esc隐藏输入法,空格选中第一个汉字,回车选中输入的拼音。和搜狗输入法处理一致。 英文、中文、数字字母、大小写、特殊字符自由切换。 支持单拼双拼词组输入,网上大部分只支持单个汉字输入。...
  • 自己可以写一个简单的demo看效果): 第一个是opcity和rgab的区别 <p><img alt="" src="https://img-blog.csdnimg.cn/img_convert/8938c01f3d5ffacf0b3504eaa4000727.png" /></p> 第二张是在ie6中的...

空空如也

空空如也

1 2
收藏数 32
精华内容 12
关键字:

键盘跳下一个按哪个键