Java 核心技术笔记

一. 接口、继承、多态

1. 继承、Object类
2. 多态、抽象类、接口

二. 类的高级特性
三. 异常处理
四. Swing程序设计

4.1 窗体
4.2 标签和图标
4.3 布局管理器
4.4 面板
4.5 按钮组件
4.6 列表组件
4.7 文本组件
4.8 常用事件监听器
4.9 Swing应用

一. 接口、继承、多态

1. 继承、Object类

使用extends关键字来标识两个类的继承关系
继承并不只是扩展父类的功能，还可以重写父类的方法。重写就是在子类中保留父类成员方法的名称，重写成员方法的内容，更改成员方法的存储权限，或是修改权限修饰符。
重写父类方法时，修改方法的修饰权限只能由小改大，不能从大变小。例如：private---->public。
子类重写父类的方法还可以修改方法的返回值类型。但是重写的返回值类型必须是父类同一方法返回值类型的子类。
在实例化子类对象时，父类无参构造方法将被自动调用。有参构造方法不能被自动调用，用户只能使用super关键字来显式的调用父类的构造方法。
super.关键字和this关键字一样。this关键字指向本类的的对象；super.关键字指向父类中的对象。
多重继承
子类会覆盖父类的方法和属性

父类
package java_2_04_1;

public class Computer 
{
	String screen = "液晶显示屏";
	void starUp()
	{
		System.out.println("正在开机，请稍等········");
	}
	void showPicture()
	{
		System.out.println("鼠标点击，打开图片");
	}
	String sayHello()
	{
//		return "欢迎使用";
		return "welcome";
	}
}

子类
package java_2_04_1;

public class Pad extends Computer //pad继承computer
{
	String battery = "5000毫安";
	public Pad()
	{
		this.screen = super.screen;//this.screen是继承自父类的属性。
	}
	void open5G()
	{
		System.out.println("打开5G网络");
	}
	void showPicture()
	{
		super.showPicture();
		System.out.println("平板电脑，触摸屏幕，打开图片");
	}
	String sayHello()
	{
//		return "欢迎使用"+"平板电脑";
		return super.sayHello()+"平板电脑";//使用super关键字调用父类的sayhello方法
	}
}

main方法
package java_2_04_1;

public class Demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Computer father = new Computer();//创建父类对象
		Pad son = new Pad();//创建子类对象
		System.out.println("父类显示屏:   "+father.screen);//输出父类属性---显示屏
		father.starUp();//父类方法----开机
		System.out.println("子类显示屏:   "+son.screen);
		son.starUp();//子类方法----开机
		System.out.println("子类电池:   "+son.battery);
		son.open5G();//子类方法----5G
		son.showPicture();
		father.showPicture();
		System.out.println(father.sayHello());
		System.out.println(son.sayHello());
	}

}

输出结果：
父类显示屏: 液晶显示屏
正在开机，请稍等········
子类显示屏: 液晶显示屏
正在开机，请稍等········
子类电池: 5000毫安
打开5G网络
鼠标点击，打开图片
平板电脑，触摸屏幕，打开图片
鼠标点击，打开图片
welcome
welcome平板电脑

Object类是所有类的父类
Object类中有三个常用的方法。
（1）getClass()方法。返回对象执行时的Class实例
（2）toString()方法。将对象返回为字符串形式。
（3）equals()方法。用equals()方法比较两个对象时，等同于“==”，比较的是两个对象的地址，而不是对象内容。这与字符串的equals()方法不一样。
类的上下转型
（1）向上转型：把子类对象赋值给父类类型的变量，称为向上转型。隐式转换。即：子类---------->父类。
用父类声明对象，用子类实例化对象。例如：Parents obj = new Child();和Person tom = new Student():
（2）向下转型：把父类的对象转换为子类的对象，称为向下转型。必须显式转换。即：父类---------->子类。
用父类来声明和实例化对象，在强制转型为子类。例如：Person p = new Person();Child c = (Child)p;
instanceof()关键字>
（1）作用：判断一个对象是否是一个类的实例化。
（2）语法：obj instanceof ExampleClass。obj：某个类的实例化对象。ExampleClass：某个类
（3）instanceof操作符返回值为布尔值。例：boolean b = tom instanceof Person;

2. 多态、抽象类、接口

（1）多态

同一个变量，同一个方法，执行出不同的结果

package java_2_05;
class Animal
{
	void move()
	{
	
	}
}
class Fish extends Animal
{
	void move()
	{
		System.out.println("我会游泳");
	}
}
class Hawk extends Animal
{
	void move()
	{
		System.out.println("我会飞翔");
	}
}
public class Java_2_05 
{
	public static void main(String[] args)
	{
		Animal jack = new Animal();//实例化Jack为动物类
		jack.move();//空方法。
		jack = new Fish();//重新实例化Jack为鱼类
		jack.move();//输出“游泳”
		jack = new Hawk();//重新实例化Jack为老鹰类
		jack.move();//输出“飞翔”
	}
}

多态就是，同一个对象Jack，由于实例化的不同，执行不同的结果。

（2）抽象类

abstract是定义抽象类的关键字。
不能创建抽象类的对象。如果要实例化，必须用它的子类来实例化。抽象类必须被继承。
抽象方法：只需要声明，不需要实现。用abstract声明的方法。抽象方法必须被抽象类的子类所重写。
抽象类被继承后必须实现其中所有的抽象方法。

抽象类
package java_2_05;

public abstract class Teacher //抽象类
{
	abstract public void teaching();//抽象方法，后面直接写分号，不能有大括号。

}
class MathTeacher extends Teacher
{

	@Override
	public void teaching() {//前面有一个白色的小三角，说明这个方法是被重写的。
		// TODO 自动生成的方法存根
		System.out.println("我是数学老师！");
	}
}
class EnglishTeacher extends Teacher
{

	@Override
	public void teaching() {
		// TODO 自动生成的方法存根
		System.out.println("我是英语老师！");
		
	}
	
}

main方法
package java_2_05;

public class Demo {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Teacher lee = new MathTeacher();
		Teacher tom = new EnglishTeacher();
		lee.teaching();
		tom.teaching();

	}

}

（3）接口

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中所有方法都没有方法体。
接口使用interface关键字声明。
（1）语法：public interface Test{void draw();}
（2）在接口中，方法必须被定义为public或abstract形式。
（3）接口的方法省略abstract关键字
类实现接口，使用implements关键字，一个类可以实现多个接口。
语法：class 类名 implements 接口1，接口2，接口3···

二. 类的高级特性

（1）类包

自己写的类可以覆盖掉API中的类。
导入类：import java.lang.Math;，“java.lang”是包名，“Math”是类名。
import java.util.*;，这个星号表示导入“java.util”下所有的类。
如果导入两个不同包下同名的类，实例化时需要使用完整类名。例：java.util.Date = new java.util.Date();
import也可以导入静态成员。语法：import static 静态成员。导入静态成员可以使编程更方便。例：import static java.lang.System.out;。在后面可以直接使用out.println();。

（2）final

final关键字用于变量声明。可以将变量（一般用大写）声明为常量。常量就是不允许被再修改的量。final关键字定义的变量必须在声明时就对其赋值。例：final double PI = 3.14;。
final修饰类时，这个类不能被继承。语法：final 类名{}，如果类时final时，其中的所有方法都被隐式的定义为final。
修饰方法时，这个方法不能被重写。将方法定义为final类型，可以防止子类重写这个方法。

（3）内部类

内部类：如果在类中再定义一个类，则再类中的那个类被称为内部类。

成员内部类
（1）在内部类中可以随意使用外部类的成员方法和成员变量。但内部类的成员只在内部类的范围之内是可知的。
（2）内部类的实例化一定要绑定在外部类的实例上。即：Demo.innerClass in = d.new innerClass(1);
（3）成员内部类语法：

public class OuterClass{//外部类
		public class InnerClass{//内部类
				//```
		}

}

package java_2_06;

public class Demo
{
	innerClass obj = new innerClass(1);//调用内部类的方法，必须先创建一个内部类对象
	public void outf() //外部类方法
	{
		obj.inf();//调用内部类的方法
	}

	class innerClass//成员内部类
	{
		int a;
		public innerClass(int a)
		{
			this.a = a;
		}
		public void inf()//内部类方法
		{
			System.out.println("内部类方法");
		}
	}
	public static void main(String[] args) {
		Demo d = new Demo();//定义外部类
		d.outf();
		Demo.innerClass in = d.new innerClass(1);//实例化内部类
		in.inf();
	}
}

局部内部类
（1）局部内部类被定义在方法体中。

三. 异常处理

什么是异常？程序运行是可能出现的错误都是异常。
异常的分类：

（1）Error：描述java运行系统中的内部错误及资源耗尽的错误。无法解决。
（2）Exception：非致命性错误，可以捕捉处理，使程序继续运行。
（3）RuntimeException：运行时错误。比如：空指针，数组下标越界等。
捕捉异常
（1）java捕捉异常捕获结构由try、catch、finally三部分组成。try语句存放可能发生异常的语句；catch语句在try语句之后，用来激发被捕获的异常；finally语句放在最后，无论try语句如何结束，finally语句块都会执行。
（2）当try语句块中发生异常时，程序会调转到catch代码块中执行，执行完catch代码块中的语句后，将继续执行catch后面的语句，但不会执行try代码块中发生异常的语句之后的部分。当try代码块中没有发生异常时，就不会执行catch代码块中的内容。
（3）可以在循环内部写try语句。
（4）语法：

try {
	语句1；
	语句2；
}
catch(some Exception1 e)//也可接多重catch语句
{```}
finally
{```//最后一定会执行}

package java_2_06;

public class Java_2_06 {

	public static void main(String[] args) 
	{
		try//放可能发生异常的代码
		{
			String s1 = "12";
			System.out.println("Hello");
			int age = Integer.parseInt("20L");
			System.out.println(age);
		}
		catch(Exception e)
		{
			e.printStackTrace();
			System.out.println("这是catch语句");
		}
		finally
		{
			System.out.println("这是finally语句");
		}
	}
}

输出结果：

catch(Exception e)，Exception是try代码块传给catch代码块的变量类型，e是变量名。如果有多个catch语句，如果有一个执行了，则下面的catch语句块不会被执行。
异常处理常用三个函数来获取异常信息：

函数	说明
e.getMessage();	输出错误性质
e.toString();	给出异常的类型和性质
e.printStackTrace();	指出异常的类型、性质，栈层次以及出现在程序中的位置

finally语句块在以下四种特殊情况会不执行：
（1）在finally语句块中发生了异常。
（2）在前面的代码中用System.exit();退出了程序。
（3）程序所在线程死亡。
（4）关闭CPU。
常见异常：

异常	说明
ClassCastException	类转型异常
ClassNotFoundException	未找到相应的类异常
ArithmeticException	算术异常
ArrayIndexOutOdBoundsException	数组下标越界异常
NullPointerException	空指针异常
SQLException	操作数据库异常
IOException	出入输出异常
EOFException	文件已结束异常
FileNotFoundException	文件未找到异常

自定义异常
（1）自己创建一个API中不存在的异常。用这个异常来处理我们遇到的异常。
自定义异常步骤：
（1）创建自定义异常。public class MyException extends Exception
（2）在方法中通过throw关键字抛出异常。throw new MyException("不可以使用负数");
（3）如果在当前抛出异常的方法中处理异常，可以用try-catch语句捕获，否则在方法声明处通过throws关键字指明要把异常抛出给方法的调用者。将异常交给别人来处理。static int avg(int a,int b)throws MyException
（4）在方法的调用者中捕获并处理异常。

public class MyException extends Exception
{
	public MyException(String message)
	{
		super(message);
	}
}

package java_2_07;

public class Java_2_07
{

	static int avg(int a,int b)throws MyException//使用throws关键字将发生的异常
	{											//抛出到主函数中。
		int num;
		if(a<0||b<0)
		{
			throw new MyException("不可以使用负数");
		}
		else if(a>100||b>100)
		{
			throw new MyException("数值太大");
		}
		else
		{
			num = a+b/2;
		}
		return num;
	}
	public static void main(String[] args)
	{
		try
		{
			int result = avg(103,10);
			System.out.println(result);
		}
		catch(MyException e)
		{
			System.out.println(e);
		}
		finally
		{
			System.out.println("程序结束");
		}
	}
}

使用throws关键字抛出异常。将异常抛出给上一级，但最终要有能够处理该异常的代码。
使用throw关键字抛出异常
（1）throw关键字通常用于方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即终止，它后面的语句不会被执行。语法：throw new MyException("数值太大");
（2）通过throw抛出异常后，如果想在上一级代码中捕获并处理这个异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常。static int avg(int a,int b)throws MyException
（3）如果要捕获并处理throw抛出的异常，则必须用try-catch语句。

四. Swing程序设计

4.1 窗体

GUI是指图形用户界面，为程序提供图形界面。

Swing包中的类可以用来开发图形用户界面程序，即：桌面程序。
Swing常用组件：

组件	定义
JButton	按钮，可以带一些图片和文字
JRadioButton	单选按钮
JCheckBox	多选按钮
JComBox	下拉列表框
JDialog	对话框
JTextField	文本框
JPasswordField	密码框

窗体作为Swing应用程序中组件的承载体，处于非常重要的位置。Swing中常用的窗体包括JFrame和JDialog。
JFrame窗体是一个容器，它是Swing程序中各个组件的载体。它拥有“最大化”、“最小化”、“关闭”等按钮。
如何创建一个JFrame窗体：
（1）让一个类继承JFrame，让这个类成为一个窗体。public class Demo1 extends JFrame。
（2）在这个类的构造方法中对其初始化。public Demo1(String title)
（3）设置窗体的内容，如：窗体标题、大小，坐标、关闭方式等
（4）获将窗体转换为容器。Container c = getContentPane();。
（5）设置容器背景颜色，然后在容器中添加或删除组件。c.add(jl);。

package java_2_07_1;

import javax.swing.*;
import java.awt.*;
public class Demo1 extends JFrame//让demo类成为一个窗体
{
	public Demo1(String title)//构造方法，对Demo作初始化
	{
//		JFrame jf = new JFrame(title);//实例化一个JFrame对象，title是窗体标题。创建窗体。
		/*
		 * 因为Demo本身就是一个窗体，就不需要再创建窗体
		 */
		setTitle(title);//设置窗体标题
		JLabel jl = new JLabel("这是一个JFrame窗体");//创建一个JLabel标签
		
		jl.setHorizontalAlignment(SwingConstants.CENTER);//是标签上的文字居中
		
		setResizable(false);//设置窗体是否可以改变大小，也不能最大化
//		jf.setSize(500, 450);//设置窗体大小
//		jf.setLocation(200, 200);//窗体显示坐标，左上角的点
		setBounds(200, 200, 500, 450);//上面两行代码合二为一，前两个是坐标，后两个是窗体大小
		int x = getX();//获取坐标
		int y = getY();
		System.out.println("x坐标："+x+"  y坐标："+y);
		/*
		 * EXIT_ON_CLOSE:隐藏窗体并停止程序
		 * DO_NOTHING_ON_CLOSE:无任何操作
		 * HIDE_ON_CLOSE:隐藏窗体但不停止程序
		 * DISPOSE_ON_CLOSE:释放窗体资源，过一段时间在停掉程序。
		 */
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置窗体关闭方式。
		
		Container c = getContentPane();//获取窗体一个容器
		c.setBackground(Color.white);//设置容器背景颜色	
		c.add(jl);//将标签添加到容器中。add方法可以在容器中添加组件
//		c.remove(jl);//删除组件
		c.validate();//刷新。验证容器中的组件使容器可以重新布置组件
		setVisible(true);//使窗体可视
	}
	public static void main(String[] args) 
	{
//		new Demo1("窗体");//我的理解是，这里只是创建对象，并没有让一个对象指向它
		Demo1 D = new Demo1("窗体");
	}
}

JDialog窗体，它是swing组件中的对话框。它的功能是从一个窗体中弹出另外一个窗体。实质上就是另外一种类型的窗体，与JFrame窗体类似，在使用时也需要调用getContentPane()方法将窗体转换为容器，然后在容器中设置窗体属性。
如何创建一个JDialog对话框窗体：
（1）让一个类继承JDialog类。public class Demo3 extends JDialog。
（2）在构造方法中对这个对话框窗体进行设置：大小等属性。然后将其转换为容器。
（3）创建父窗体并设置属性。
（4）创建按钮，设置按钮坐标，大小。
（5）在按钮中添加动作监听。btu.addActionListener(new ActionListener() {```按按钮之后会执行的操作});。
（6）在父窗体中添加按钮。c.add(btu);//添加按钮。

package java_2_07_1;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.*;

public class Demo3 extends JDialog
{
	public Demo3(JFrame jf)//构造方法
	{
		//第一个参数是父窗体，第二个是对话框标题，第三个布尔值，是否阻塞父窗体
		super(jf,"对话框标题",true);//调用父类构造方法。
		setBounds(300,100,200,200);//设置对话框窗体坐标，大小。
		setResizable(false);//设置窗体是否可以改变大小，也不能最大化
		Container c = getContentPane();//获取窗体容器
		JLabel jl = new JLabel("这是一个对话框");//创建一个JLabel标签
		jl.setHorizontalAlignment(SwingConstants.CENTER);//是标签上的文字居中

		c.add(jl);

	}
	public static void main(String[] args)
	{
		JFrame f = new JFrame("父窗体");
		f.setBounds(50, 50,700, 650);
		f.setVisible(true);//使父窗体可见
		f.setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = f.getContentPane();//获取父窗体容器
		JButton btu = new JButton("按钮");//创建一个按钮
		btu.setBounds(260,60,60,20);//设置按钮相对于父窗体的位置和大小
		c.setLayout(new FlowLayout());//设置布局，使用流布局。
		btu.addActionListener(new ActionListener()//匿名内部类
		 {
			public void actionPerformed(ActionEvent e) //按按钮之后会运行的方法
			{
				Demo3 d = new Demo3(f);
				d.setVisible(true);//使对话框可见
			}	
		});//添加动作监听
		c.add(btu);//添加按钮
	}
}

4.2 标签和图标

标签的使用：

package java_2_07_1;

import java.awt.*;

import javax.swing.*;

public class Demo4 extends JFrame
{
	public Demo4()
	{
		setBounds(100,100,500,450);//设置窗体坐标，大小
		setDefaultCloseOperation(EXIT_ON_CLOSE);//设置窗体关闭方式
		setVisible(true);//使窗体可见
		Container c = getContentPane();//将窗体转换为容器。
		
		JLabel jl = new JLabel("这是一个标签");//实例化一个标签对象
		/*
		 * Font有三个参数
		 * 一：字体
		 * 二：样式，比如加粗，Font.BOLD
		 * 三：大小
		 */
		jl.setFont(new Font("微软雅黑",Font.BOLD,15));//Font有三个参数
		jl.setForeground(Color.red);//更改字体颜色，可以更改标签前景色
		jl.setHorizontalAlignment(SwingConstants.CENTER);//是标签上的文字居中
//		jl.setText("更改");//更改标签内容
		System.out.println(jl.getText());//获取标签内容
		c.add(jl);
		
	}
	public static void main(String[] args) 
	{
		Demo4 d = new Demo4();
	}
}

在窗体中添加图片

package java_2_08;

import javax.*;
import javax.swing.*;
import java.awt.*;
import java.net.URL;

public class Demo extends JFrame
{

	public Demo()
	{
		setBounds(200,200,1000,450);//设置窗体坐标，大小
		setDefaultCloseOperation(EXIT_ON_CLOSE);//窗体关闭方式

		Container c = getContentPane();//将窗体转换为容器。
		JLabel jl = new JLabel("这是一个展示图片的标签");
		jl.setSize(20, 20);//即使设置标签大小，也不能改变照片大小
		jl.setOpaque(true);//设置标签为不透明状态
		URL url = Demo.class.getResource("2.png");//获取图片地址
		Icon icon = new ImageIcon(url);//获取相应路径下的图片文件
		
		jl.setIcon(icon);//添加图片；
		c.add(jl);//将标签添加到容器中
		setVisible(true);//这句应该放在最后，使上面所有操作都可见。
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();	
	}
}

4.3 布局管理器

在Swing中，每个组件在容器中都有一个具体的位置和大小，而在容器中摆放各种组件时很难判断其具体位置和大小。所以有了布局管理器。布局管理器提供了Swing组件安排，展示在容器中的方法和基本布局功能。
常用的布局管理器包括：流布局管理器、边界布局管理器、网格布局管理器。
绝对布局（null布局）：
（1）绝对布局就是硬性指定组件在容器中的位置和大小。
（2）使用c.setLayout(null)方法取消布局管理器。再使用setBounds()方法设置每个组件的大小和坐标。
流布局（FlowLayout）：
（1）从左到右，默认居中对齐。
（2）c.setLayout(new FlowLayout(1,10,10));第一个参数是对齐方式，后面两个是水平和竖直间距；0：左对齐。1：居中对齐。2：右对齐。

package java_2_08;

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

public class Demo1 extends JFrame 
{

	public Demo1()
	{
		setBounds(200,200,300,300);//设置窗体坐标，大小
		setDefaultCloseOperation(EXIT_ON_CLOSE);//窗体关闭方式
		Container c = getContentPane();
		c.setLayout(new FlowLayout(1,10,10));//0：左对齐。1：居中对齐。2：右对齐。10：水平和竖直间距
		for(int i=0;i<10;i++)
		{
			c.add(new JButton("按钮"+i));
		}
		setVisible(true);
	}
	public static void main(String[] args)
	{
		Demo1 d = new Demo1();
		
	}
}

边界布局（BorderLayout）：
（1）窗体默认的布局方式，它将窗体分为东、南、西、北、中，五个区域。
（2）添加组件时要指定区域，否则会默认添加到中间并拉伸。
（3）同一个区域的组件会相互覆盖。
（4）c.setLayout(new BorderLayout());设置为边界布局
（5）c.add(b1,BorderLayout.EAST);第一个参数是组件，第二个是添加部位。

成员变量	含义
BorderLayout.NORTH	置于顶端
BorderLayout.SOUTH	置于底端
BorderLayout.EAST	置于右端
BorderLayout.WEST	置于置于左端
BorderLayout.CENTER	从中间开始填充，直到和其他组件相接

网格布局（GridLayout）：
（1）语法：c.setLayout(new GridLayout(int rows,int columns,int horizaGap,int vertGap));
（2）rows：行数。columns：列数。horizaGap：水平间距。vertGap：竖直间距。
网格组布局管理器（GridBagLayout）：

属性	说明
gridx、gridy	组件所在的位置
gridwidth、gridheight	组件所占用的行数和列数
anchor	组件所在方位
fill	组件填充方式
insets	组件与单元格边缘的最小距离
ipadx、iPady	组件的首选大小
weightx、weighty	一个单元格的最大宽高

package java_2_08;

import java.awt.*;

import javax.swing.*;

public class Demo2 
{
	JFrame f = new JFrame();//主窗体
	Container c;//主容器
	void creatFrame()
	{
		c=f.getContentPane();
		c.setLayout(new GridBagLayout());//获取容器
		f.setSize(800, 600);//大小
		f.setLocationRelativeTo(null);//使窗体居中显示
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
	void init()
	{
		GridBagConstraints g1 = new GridBagConstraints();
		g1.gridx=1;//组件的行列索引
		g1.gridy=1;
		g1.gridheight=1;
		g1.gridwidth=1;
		g1.insets=new Insets(19,5,5,10);
		g1.weightx=10;
		g1.weighty=10;
		c.add(new JButton("none"),g1);
		
		GridBagConstraints g2 = new GridBagConstraints();
		g2.gridx=4;
		g2.gridy=4;
		g2.gridheight=2;
		g2.gridwidth=2;//组件的长和宽
		g2.fill=GridBagConstraints.HORIZONTAL;//填充属性
		c.add(new JButton("HORIZONTAL"),g2);
		
		GridBagConstraints g3 = new GridBagConstraints();
		g3.gridx=6;
		g3.gridy=6;
		g3.gridheight=2;
		g3.gridwidth=2;
		g3.fill=GridBagConstraints.VERTICAL;
		c.add(new JButton("VERTICAL"),g3);
		
		GridBagConstraints g4 = new GridBagConstraints();
		g4.gridx=8;
		g4.gridy=8;
		g4.gridheight=2;
		g4.gridwidth=2;
		g4.fill=GridBagConstraints.BOTH;
		c.add(new JButton("BOTH"),g4);
	}
//	void init2()
//	{
//		GridBagConstraints g1 = new GridBagConstraints();
//		g1.gridx=1;//组件的行列索引
//		g1.gridy=1;
//		g1.gridheight=2;
//		g1.gridwidth=2;
//		g1.anchor=GridBagConstraints.NORTH;
//		c.add(new JButton("."),g1);
//	
//	}
	void creatButton()
	{
		for(int i=0;i<10;i++)
		{
			GridBagConstraints g1 = new GridBagConstraints();
			g1.gridx=i;//组件的行列索引
			g1.gridy=0;
			c.add(new JButton("组件"+i),g1);
			GridBagConstraints g2 = new GridBagConstraints();
			g2.gridx=0;//组件的行列索引
			g2.gridy=i;
			c.add(new JButton("组件"+i),g2);
		}
	}
	public static void main(String[] args) 
	{
		Demo2 d = new Demo2();
		d.creatFrame();
		d.creatButton();
		d.init();
		d.f.setVisible(true);
	}

}

输出：

4.4 面板

面板也是一个Swing容器，它可以作为容器容纳其他组件，但它必须被添加到其他容器中。常用面板包括：JPenal面板和JScrollPane面板。面板只能放在窗体中使用。
容器之间互不干扰
JPanel面板：

package java_2_08;

import java.awt.*;

import javax.swing.*;

public class Demo3 extends JFrame
{
	public Demo3()
	{
		setBounds(200,200,500,300);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = getContentPane();
		c.setLayout(new GridLayout(2,2,10,10));
		JPanel p1 = new JPanel();
		p1.setLayout(new GridLayout(1,3,10,10));//给面板添加布局
		JPanel p2 = new JPanel(new BorderLayout());//给面板添加边界布局
		JPanel p3 = new JPanel(new GridLayout(1,2,10,10));
		JPanel p4 = new JPanel(new GridLayout(2,1,10,10));
		
		/*
		 * 给面板添加边框
		 */
		p1.setBorder(BorderFactory.createTitledBorder("面板一"));//添加标题边框
		p2.setBorder(BorderFactory.createTitledBorder("面板二"));//添加标题边框
		p3.setBorder(BorderFactory.createTitledBorder("面板三"));//添加标题边框
		p4.setBorder(BorderFactory.createTitledBorder("面板四"));//添加标题边框、
		/*
		 * 在面板中添加组件
		 */
		p1.add(new JButton("p1"));//在面板中添加按钮
		p1.add(new JButton("p1"));//在面板中添加按钮
		p1.add(new JButton("p1"));//在面板中添加按钮
		p1.add(new JButton("p1"));//在面板中添加按钮
		
		p2.add(new JButton("p1"),BorderLayout.CENTER);//在面板2中添加按钮，在中间
		p2.add(new JButton("p1"),BorderLayout.EAST);
		p2.add(new JButton("p1"),BorderLayout.WEST);
		p2.add(new JButton("p1"),BorderLayout.SOUTH);
		p2.add(new JButton("p1"),BorderLayout.NORTH);
		
		p3.add(new JButton("p3"));
		p3.add(new JButton("p3"));
		p4.add(new JButton("p4"));
		p4.add(new JButton("p4"));
		p4.setBackground(Color.yellow);
		c.add(p1);
		c.add(p2);
		c.add(p3);
		c.add(p4);
		setVisible(true);
	}
	public static void main(String[] args) 
	{
		Demo3 d = new Demo3();
	}
}

输出效果：

JScrollPane面板（滚动面板）：
（1）JScrollPane面板是一个带滚动条的面板，它也是一个容器，但是它只能放一个组件，并且不能使用布局管理器，如果需要在JScrollPane面板上放置多个组件，需要将多个组件放置在JPanel面板上，再降JPanel面板作为一个整体添加到JScrollPane面板上。
（2）

package java_2_08;

import java.awt.*;

import javax.swing.*;

public class Demo4 extends JFrame
{
	public Demo4()
	{

		setBounds(200,200,500,300);
		
		Container c = getContentPane();
		JTextArea a = new JTextArea(100,100);//文本编辑域
		JScrollPane sp = new JScrollPane(a);//创建滚动面板，给文本区域添加滚动条
		c.add(sp);//给容器添加滚动面板
		
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setVisible(true);
	}
	public static void main(String[] args) 
	{
		Demo4 d = new Demo4();
	}
}

输出效果：

4.5 按钮组件

提交按钮组件：

package java_2_08;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

import javax.swing.*;
public class Demo5 extends JFrame
{
	public Demo5()
	{
		setBounds(200,200,500,400);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c =getContentPane();
		c.setLayout(new GridLayout(3,2,5,5));//网格布局，三行两列，水平间距竖直间距
		JButton btn[] = new JButton[6];//创建按钮组
		for (int i=0;i<btn.length;i++)
		{
			btn[i]=new JButton();//实例化按钮
			c.add(btn[i]);//将按钮加入容器
		}
		btn[0].setText("不可用");//设置按钮文本
		btn[0].setEnabled(false);//设置组件不可用；
		btn[1].setText("有背景色");
		btn[1].setBackground(Color.yellow);//设置按钮颜色
		btn[2].setText("无边框");
		btn[2].setBorderPainted(false);//不显示边框
		btn[3].setText("有边框");
		btn[3].setBorder(BorderFactory.createLineBorder(Color.red));//设置线边框
		URL url = Demo.class.getResource("2.png");//获取图片地址
		Icon icon = new ImageIcon(url);//获取相应路径下的图片文件
		btn[4].setIcon(icon);//给按钮设置图片
		btn[4].setToolTipText("图片按钮");//鼠标悬停提示
		btn[5].setText("可点击");
		btn[5].addActionListener(new ActionListener() {//添加事件监听
			public void actionPerformed(ActionEvent e) //监听触发方法
			{
				JOptionPane.showMessageDialog(Demo5.this, "这是一个对话框");//弹出一个小对话框
				
			}
			
		});
		setVisible(true);
	}
	public static void main(String[] args)
	{
		Demo5 d = new Demo5();
	}

}

输出效果：

单选按钮组件（JRadioButton）：
（1）在默认情况下，单选按钮显示一个圆形图标，并且通常在该图标旁放置一些说明文字。

package java_2_08;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

import javax.swing.*;
public class Demo5 extends JFrame
{
	public Demo5()
	{
		setBounds(200,200,500,400);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c =getContentPane();
		c.setLayout(new FlowLayout());//设置窗体布局，流布局
		JRadioButton left = new JRadioButton("向左走");//创建按钮
		JRadioButton right = new JRadioButton("向右走");
		
		ButtonGroup group = new ButtonGroup();//按钮组
		group.add(left);//将单选按钮放在按钮组中，
		group.add(right);//当一个按钮选中后，会自动关闭另外一个按钮
		left.setSelected(true);//默认选中left按钮
		
		JButton btn = new JButton("打印");
		btn.addActionListener(new ActionListener() {//设置事件监听
			public void actionPerformed(ActionEvent e) 
			{
				System.out.println(left.getText()+"按钮的选中方法"+left.isSelected());
				System.out.println(right.getText()+"按钮的选中方法"+right.isSelected());
				group.clearSelection();//清空按钮组选项
			}
			
		});
		c.add(left);
		c.add(right);
		c.add(btn);
		setVisible(true);
	}
	public static void main(String[] args)
	{
		Demo5 d = new Demo5();
	}

}

输出效果：

多选框（JCheckBox）：

package java_2_08;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.net.URL;

import javax.swing.*;
public class Demo5 extends JFrame
{
	public Demo5()
	{
		setBounds(200,200,500,400);//创建窗体
		setDefaultCloseOperation(EXIT_ON_CLOSE);//设置窗体关闭方式
		Container c =getContentPane();//将窗体转换成一个容器
		c.setLayout(new BorderLayout());//设置窗体布局，为边界布局
		JPanel p1 = new JPanel();//创建面板P1
		p1.setLayout(new FlowLayout());//设置面板p1布局方式
		JPanel p2 = new JPanel();//创建面板P2
		JTextArea a = new JTextArea(7,15);//文本编辑域
		JScrollPane sp = new JScrollPane(a);//创建滚动面板，给文本区域添加滚动条
		p2.setLayout(new FlowLayout());//设置面板p2布局方式
		p2.add(sp);//在面板p2中添加文本编辑区
		JPanel p3 = new JPanel();//创建面板P3
		JTextArea a3 = new JTextArea(7,10);//文本编辑域
		JScrollPane sp3 = new JScrollPane(a3);//创建滚动面板，给文本区域添加滚动条
		p3.setLayout(new FlowLayout());//设置面板p3布局方式
		JLabel jl3 = new JLabel("交流区");//设置标签
		jl3.setFont(new Font("楷体",Font.BOLD,15));//Font有三个参数
		jl3.setForeground(Color.black);//更改字体颜色，可以更改标签前景色
		jl3.setHorizontalAlignment(SwingConstants.CENTER);//是标签上的文字居中
		p3.add(jl3);//在面板3中添加标签
		p3.add(sp3);//在面板3中添加文本编辑区
		JPanel p4 = new JPanel();//创建面板P4
		JTextArea a4 = new JTextArea(7,10);//文本编辑域
		JScrollPane sp4 = new JScrollPane(a4);//创建滚动面板，给文本区域添加滚动条
		p4.setLayout(new FlowLayout());//设置面板p4布局方式
		JLabel jl4 = new JLabel("交流区");
		jl4.setFont(new Font("楷体",Font.BOLD,15));//Font有三个参数
		jl4.setForeground(Color.black);//更改字体颜色，可以更改标签前景色
		jl4.setHorizontalAlignment(SwingConstants.CENTER);//是标签上的文字居中
		p4.add(jl4);
		p4.add(sp4);
		JCheckBox c1 = new JCheckBox();//设置多选按钮
		JCheckBox c2 = new JCheckBox();
		JCheckBox c3 = new JCheckBox();
		
		URL url1 = Demo5.class.getResource("4.png");//获取图片地址
		Icon icon1 = new ImageIcon(url1);//获取相应路径下的图片文件
		c1.setIcon(icon1);//给按钮设置图片
		c1.setToolTipText("打野英雄，李白");//鼠标悬停提示
		
		URL url2 = Demo5.class.getResource("5.png");//获取图片地址
		Icon icon2 = new ImageIcon(url2);//获取相应路径下的图片文件
		c2.setIcon(icon2);//给按钮设置图片
		c2.setToolTipText("射手一姐，孙尚香");//鼠标悬停提示
		
		URL url3 = Demo5.class.getResource("6.png");//获取图片地址
		Icon icon3 = new ImageIcon(url3);//获取相应路径下的图片文件
		c3.setIcon(icon3);//给按钮设置图片
		c3.setToolTipText("偷野王子，韩信");//鼠标悬停提示
		
		p1.add(c1);//在面板p1中添加多选按钮
		p1.add(c2);
		p1.add(c3);
		c1.addActionListener(new ActionListener() {//给选项1按钮设置事件监听
			public void actionPerformed(ActionEvent e) //事件触发：
			{
				a.append("我方选择打野英雄，李白\n");
			}
			
		});
		c2.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) 
			{
				a.append("我方选择射手英雄，孙尚香\n");
			}
			
		});
		c3.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) 
			{
				a.append("我方选择打野英雄，韩信\n");
			}
			
		});
//		c1.setSelected(true);//默认选中
		c.add(p1,BorderLayout.SOUTH);//将面板添加到窗体中
		c.add(p2,BorderLayout.NORTH);
		c.add(p3,BorderLayout.WEST);
		c.add(p4,BorderLayout.EAST);
		setVisible(true);
		
		
		
		
	}
	public static void main(String[] args)
	{
		Demo5 d = new Demo5();
	}

}

输出效果：

4.6 列表组件

Swing提供两种列表组件，分别是下拉列表框和列表框。

（1）下拉列表框（JCombBox）

package java_2_09;

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

public class Demo extends JFrame
{
	public Demo()
	{
		setBounds(200,200,500,450);//设置窗体
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = getContentPane();
		c.setLayout(null);//容器的布局方式为绝对布局
		//在下拉列表添加数据----第一种方式
//		JComboBox<String> com = new JComboBox<>();	
//		com.addItem("身份证");//添加数据
//		com.addItem("学生证");
//		com.addItem("工作证");
//		com.setBounds(100,100,80,21);//下拉列表在坐标，长和宽	
		
		//在下拉列表添加数据----第二种方式
//		String items[] = {"身份证","学生证","工作证"};//需要添加的数据
//		JComboBox<String> com = new JComboBox<>(items);//使用字符串数组添加元素
//		com.setBounds(100,100,80,21);//下拉列表在坐标，长和宽
		
		//在下拉列表添加数据----第三种方式
		JComboBox<String> com = new JComboBox<>();	//实例化下拉列表对象
		String items[] = {"身份证","学生证","工作证"};
		ComboBoxModel cm = new DefaultComboBoxModel<>(items);//创建下拉列表模型，
		com.setModel(cm);//向列表中添加模型				
		com.setBounds(100,100,80,21);//下拉列表在坐标，长和宽
		com.setEditable(true);//下拉列表是否可以编辑
		
		JButton btn = new JButton("打印");
		btn.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) 
			{
				System.out.println("选中索引："+com.getSelectedIndex());//获取选中索引
				System.out.println("选中的值："+com.getSelectedItem());//获取选中的值
				
			}
			
		});
		btn.setBounds(100,60,70,30);
		
		c.add(btn);
		c.add(com);
		
		setVisible(true);//使窗体可见
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();	
	}
}

（2）列表框（Jlist）

package java_2_09;

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

public class Demo extends JFrame
{

	public Demo()
	{
		setBounds(200,200,500,450);//设置窗体
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = getContentPane();
		c.setLayout(null);//容器的布局方式为绝对布局
		//方法一
		String items[] = {"元素1","元素2","元素3","元素4","元素5","元素6"};
//		JList<String> jl = new JList<>(items);
		//方法二：使用模型的优点：可以随时添加元素
		DefaultListModel<String> model = new DefaultListModel<>();//列表框数据模型
		for(String s1:items)
		{
			model.addElement(s1);//向数据模型添加元素
		}
		JList<String> jl = new JList<>(items);
		model.addElement("身份证");//随时给数据模型添加元素
		/*
		 * SINGLE_SELECTION:单选模式
		 * MULTIPLE_INTERVAL_SELECTION：随便选择，不限定模式
		 * SINGLE_INTERVAL_SELECTION:只能选择连续相邻的
		 */
		jl.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);//现在模式
		jl.setModel(model);
		JScrollPane p1 = new JScrollPane(jl);//添加滚动条面板
		p1.setBounds(10, 10, 100, 100);//不需要给列表框坐标和大小，直接给滚动面板。
		c.add(p1);
		JButton btn = new JButton("确认");
		btn.setBounds(150,60,70,30);
		btn.addActionListener(new ActionListener() {//添加事件监听
			public void actionPerformed(ActionEvent arg0) 
			{
				//获取列表框中选定的所有元素
				java.util.List<String> va = jl.getSelectedValuesList();
				for(String s1:va)
				{
					System.out.println(s1);
				}
				System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~");
			}
			
		});
		
		
		c.add(btn);
		
		setVisible(true);//使窗体可见
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		
	}
}

输出效果：

4.7 文本组件

（1）文本框组件（JTextField）：用来显式或编辑一个单行文本

package java_2_09;

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

public class Demo extends JFrame
{
	public Demo()
	{
		setBounds(200,200,500,450);//设置窗体
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = getContentPane();
		c.setLayout(new FlowLayout());//容器的布局方式为
		JTextField jt = new JTextField();//创建一个文本框
		jt.setText("初始文本");//设置初始文本
		jt.setFont(new Font("黑体",Font.PLAIN,20));//设置字体格式，第二个是字体样式，然后字体大小
		jt.setColumns(30);//设置文本框长度
		c.add(jt);
		
		JButton btn = new JButton("确认");
		btn.addActionListener(new ActionListener() {//添加事监听
			public void actionPerformed(ActionEvent e) 
			{
				System.out.println("文本框的值："+jt.getText());
				jt.setText("");//清空文本框
				jt.requestFocus();//获取光标
			}
			});
		c.add(btn);
		setVisible(true);//使窗体可见
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();
	}
}

（2）密码框组件（JPasswordField）：

package java_2_09;

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

public class Demo extends JFrame
{
	public Demo()
	{
		setBounds(200,200,500,450);//设置窗体
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = getContentPane();
		c.setLayout(new FlowLayout());//容器的布局方式为
		JPasswordField jp = new JPasswordField();
		jp.setEchoChar('*');
		jp.setColumns(20);//密码框宽度
		jp.setFont(new Font("Arial",Font.BOLD,20));//设置字体格式，第二个是字体样式-加粗，然后字体大小
		jp.addActionListener(new ActionListener() {//给密码框添加一个动作监听
			public void actionPerformed(ActionEvent e)//回车监听
			{
				char ch[] = jp.getPassword();//获取密码的字符数组
				String s1 = new String(ch);//将字符数组改为字符串
				System.out.println(s1);//在控制台输出密码字符串
			}
			
		});
		c.add(jp);
		setVisible(true);//使窗体可见
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		
	}

}

（3）文本域组件（JTextArea）：接受多行文字输入

package java_2_09;

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

public class Demo extends JFrame
{
	public Demo()
	{
		setBounds(200,200,400,350);//设置窗体
		setTitle("自动换行文本域");
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = getContentPane();
		c.setLayout(new FlowLayout());//容器的布局方式为
		JTextArea jt = new JTextArea();
		jt.setText("这是一个文本域，");
		jt.setFont(new Font("楷体",Font.PLAIN,20));//字体格式
		jt.setRows(5);//设定文本域可以有多少行
		jt.setColumns(20);//设定框，列数
		jt.append("添加内容");//添加内容
		jt.insert("（插入）", 2);
		JScrollPane js = new JScrollPane(jt);//给文本添加滚动条
		jt.setLineWrap(true);//是否可以自动换行
		c.add(js);
		setVisible(true);//使窗体可见
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();·
	}
}

4.8 常用事件监听器

（1）监听事件简介：

监听（Listener）：盯着事件，如果事件发生，则立即被监听到。
事件（Event）：鼠标事件，窗体事件，键盘事件等。

（2）动作事件监听（ActionEvent）：

	JLabel jl = new JLabel("点击组件");
	JButton btn = new JButton("确认");
		btn.addActionListener(new ActionListener()
		{//添加事监听
			/*
			 * ActionEvent:动作事件的类，获得事件是由哪个组件触发
			 * 
			 */
			public void actionPerformed(ActionEvent e) 
			{
				jl.setText("按钮被点击");
			}
		});

事件	事件源	监听接口	方法
ActionEvent	JButton、JList、JTextField	ActionListener	addActionListener()、removeActionListener()

（3）焦点事件监听（FocusEvent）：

组件.addFocusListener(); FocusEvent 焦点事件

package java_2_09;

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

public class Demo extends JFrame
{
	public Demo()
	{
		setBounds(200,200,400,350);//设置窗体
		setTitle("自动换行文本域");
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		Container c = getContentPane();
		c.setLayout(new FlowLayout());//容器的布局方式为
		JButton btn = new JButton("确认");
		JLabel jl = new JLabel("初始状态");//标签
		JTextField jt = new JTextField();//文本框
		jt.setColumns(20);//文本框宽度
		//就不需要用内部类
		jt.addFocusListener(new MyFocusListener());//使用我们创建好的自定义事件监听
		JLabel jl2 = new JLabel("标签2初始状态");//标签2
		JTextField jt2 = new JTextField();//文本框
		jt2.setColumns(20);//文本框宽度
		//使用内部类来添加监听
		jt2.addFocusListener(new FocusListener() {
			public void focusGained(FocusEvent e) //获得焦点
			{
				// TODO 自动生成的方法存根
				jl2.setText("获得焦点");
				
			}
			public void focusLost(FocusEvent e)//失去焦点 
			{
				// TODO 自动生成的方法存根
				jl2.setText("失去焦点");
				
			}
			
		});
		c.add(jt);
	
		c.add(jl);
		c.add(jt2);
		c.add(jl2);
		setVisible(true);//使窗体可见
	}
	//使用自定义类比内部类方便。
	class MyFocusListener implements FocusListener//创建内部类来实现接口FocusListener
	{//自定义焦点事件监听
		public void focusGained(FocusEvent e)
		{
			JTextField tmp=(JTextField)e.getSource();//获取触发焦点的事件
			tmp.setBorder(BorderFactory.createLineBorder(Color.green));//给获取焦点的文本框一个边框
		}
		public void focusLost(FocusEvent e) {
			JTextField tmp=(JTextField)e.getSource();//获取触发焦点的事件
			tmp.setBorder(BorderFactory.createLineBorder(Color.red));//给失去焦点的文本框一个边框
		}
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		
	}

}

4.9 Swing应用

package java_qq;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;

public class User extends JDialog
{
	
	public User(JFrame jf,JTextField jt1,JPasswordField jp1)
	{
		super(jf,"用户登录",true);//调用父类构造方法。
		setSize(600,400);//设置对话框窗体坐标，大小。
		setResizable(false);//设置窗体是否可以改变大小，也不能最大化
		Container c = getContentPane();//获取窗体容器
		c.setLayout(null);
		JLabel jl1 = new JLabel("账号：");//创建一个JLabel标签
		jl1.setBounds(140,50,70,50);
		JLabel jl2 = new JLabel("密码：");//创建一个JLabel标签
		jl2.setBounds(140,130,70,50);
		jl2.setFont(new Font("楷体",Font.BOLD,20));//Font有三个参数
		jl1.setFont(new Font("楷体",Font.BOLD,20));//Font有三个参数
		setLocationRelativeTo(null);
		
		JTextField jt = new JTextField();//创建一个文本框
		jt.addFocusListener(new MyFocusListener());//使用我们创建好的自定义事件监听
		
		jt.setFont(new Font("黑体",Font.PLAIN,20));//设置字体格式，第二个是字体样式，然后字体大小
		jt.setBounds(210, 65, 180, 25);
		
		JPasswordField jp = new JPasswordField();
		jp.addFocusListener(new MyFocusListener());//使用我们创建好的自定义事件监听
		jp.setEchoChar('*');
		jp.setFont(new Font("Arial",Font.BOLD,20));//设置字体格式，第二个是字体样式-加粗，然后字体大小
		jp.setBounds(210, 145, 180, 25);
		
        JButton jb = new JButton("登录");
        jb.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent arg0)
            {
            	String s3=jt1.getText();
            	String s4=jp1.getText();
                if (jt.getText().trim().length() == 0
                        || new String(jp.getPassword()).trim()
                                .length() == 0) {
                    JOptionPane.showMessageDialog(null, "用户名密码不允许为空");
                    return;
                }
                if (jt.getText().trim().equals(s3)
                        && new String(jp.getPassword()).trim()
                                .equals(s4)) {
                    JOptionPane.showMessageDialog(null, "登录成功");
                } else {
                    JOptionPane.showMessageDialog(null, "用户名或密码错误");
                }
            }
        });
        jb.setBounds(260, 240, 60, 30);
       
    	JCheckBox c1 = new JCheckBox("自动登录");//设置多选按钮
		JCheckBox c2 = new JCheckBox("记住密码");
		c1.setToolTipText("下次自动登录，方便快捷");//鼠标悬停提示
		c2.setToolTipText("保存密码，用于下次自动登录");//鼠标悬停提示
		c1.setBounds(200, 300, 100, 30);
		c2.setBounds(320, 300, 100, 30);
		jl1.setHorizontalAlignment(SwingConstants.CENTER);//是标签上的文字居中
		c.add(jl1);
		c.add(jl2);
		c.add(jt);
		c.add(jp);
		c.add(jb);
		c.add(c1);
		c.add(c2);
	}
	class MyFocusListener implements FocusListener//创建内部类来实现接口FocusListener
	{//自定义焦点事件监听
		public void focusGained(FocusEvent e)
		{
			JTextField tmp=(JTextField)e.getSource();//获取触发焦点的事件
			tmp.setBorder(BorderFactory.createLineBorder(Color.green));//给获取焦点的文本框一个边框
		}
		public void focusLost(FocusEvent e) {
			JTextField tmp=(JTextField)e.getSource();//获取触发焦点的事件
			tmp.setBorder(BorderFactory.createLineBorder(Color.black));//给失去焦点的文本框一个边框
		}
	}


}

package java_qq;

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

public class Zhuce extends JDialog
{
	public Zhuce(JFrame jf,	JTextField jt,JPasswordField jp)
	{
		super(jf,"用户注册",true);//调用父类构造方法
		setSize(600,400);//设置对话框窗体坐标，大小。
		setResizable(false);//设置窗体是否可以改变大小，也不能最大化
		Container c = getContentPane();//获取窗体容器
		c.setLayout(null);
		JLabel jl1 = new JLabel("新建账号：");//创建一个JLabel标签
		jl1.setBounds(140,50,140,50);
		JLabel jl2 = new JLabel("设置密码：");//创建一个JLabel标签
		jl2.setBounds(160,130,140,50);
		jl2.setFont(new Font("楷体",Font.BOLD,20));//Font有三个参数
		jl1.setFont(new Font("楷体",Font.BOLD,20));//Font有三个参数
		setLocationRelativeTo(null);
		
	
		jt.setFont(new Font("黑体",Font.PLAIN,20));//设置字体格式，第二个是字体样式，然后字体大小
		jt.setBounds(280, 65, 180, 25);
		
		
		jp.setEchoChar('*');
		jp.setFont(new Font("Arial",Font.BOLD,20));//设置字体格式，第二个是字体样式-加粗，然后字体大小
		jp.setBounds(280, 145, 180, 25);
		
        JButton jb = new JButton("注册");
        jb.addActionListener(new ActionListener()
        {
			public void actionPerformed(ActionEvent arg0)
            {
                if (jt.getText().trim().length() == 0
                        || new String(jp.getPassword()).trim()
                                .length() == 0) {
                    JOptionPane.showMessageDialog(null, "用户名密码不允许为空");
                    return;
                }
                else 
                {
                    JOptionPane.showMessageDialog(null, "注册成功");
         
                }
            }
        });
        jb.setBounds(260, 240, 60, 30);

    	JCheckBox c1 = new JCheckBox("自动登录");//设置多选按钮
		JCheckBox c2 = new JCheckBox("记住密码");
		c1.setToolTipText("下次自动登录，方便快捷");//鼠标悬停提示
		c2.setToolTipText("保存密码，用于下次自动登录");//鼠标悬停提示
		c1.setBounds(200, 300, 100, 30);
		c2.setBounds(320, 300, 100, 30);
		jl1.setHorizontalAlignment(SwingConstants.CENTER);//是标签上的文字居中
		c.add(jl1);
		c.add(jl2);
		c.add(jt);
		c.add(jp);
		c.add(jb);
		
	}

}

package java_qq;

import javax.swing.*;

import java_qq.User.MyFocusListener;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.net.URL;

public class Demo
{
	JFrame jf = new JFrame();
	String s1;//获得字体格式
	String s2;//获得字体大小
	String s3;//注册账号
	String s4;//设置密码
	String s5;//账号
	String s6;//密码
	JTextField jt = new JTextField();//创建一个文本框
	JPasswordField jp = new JPasswordField();
	
	public void Creatbk()
	{
		//主窗体
		jf.setTitle("邮件");
		jf.setSize(1200,900);//大小
		jf.setResizable(false);//设置窗体是否可以改变大小，也不能最大化
		jf.setLocationRelativeTo(null);//使窗体居中显示
		Container c =jf.getContentPane();
		c.setLayout(null);//使用绝对布局
		//面板一；放置三个按钮
		URL url1 = Demo.class.getResource("发送.png");//发送图标
		Icon icon1 = new ImageIcon(url1);
		URL url2 = Demo.class.getResource("保存.png");//保存图标
		Icon icon2 = new ImageIcon(url2);//获取相应路径下的图片文件
		URL url3 = Demo.class.getResource("切换用户.png");//保存图标
		Icon icon3 = new ImageIcon(url3);//获取相应路径下的图片文件
		
		URL url5 = Demo.class.getResource("注册.png");//发送图标
		Icon icon5 = new ImageIcon(url5);
		
		JButton btn1 = new JButton();//发送图标
		btn1.setIcon(icon1);//给发送按钮添加图标
		btn1.addActionListener(new MyActionListener1());//按钮执行效果
		btn1.setBounds(10, 10, 50, 50);
		btn1.setToolTipText("写完邮件后，点此键发送");//鼠标悬停提示
		JButton btn2 = new JButton();//发送按钮
		btn2.setIcon(icon2);
		btn2.addActionListener(new MyActionListener2());
		btn2.setBounds(70, 10, 50, 50);
		btn2.setToolTipText("邮件未写完，有事离开时，点此键保存");//鼠标悬停提示
		JButton btn3 = new JButton();//切换用户按钮
		btn3.setIcon(icon3);
		btn3.addActionListener(new MyActionListener3());
		btn3.setBounds(130, 10, 50, 50);
		btn3.setToolTipText("点此键登录或切换用户");//鼠标悬停提示
		JButton btn5 = new JButton();//切换用户按钮
		btn5.setIcon(icon5);
		btn5.addActionListener(new MyActionListener4());
		btn5.setBounds(190, 10, 50, 50);
		btn5.setToolTipText("点此键注册用户");//鼠标悬停提示
		JPanel p1 = new JPanel();//使用模板1，放置三个按钮
		p1.setLayout(null);//给面板添加布局
		p1.setBounds(10, 5, 900, 75);
		p1.setBorder(BorderFactory.createTitledBorder(""));
		p1.add(btn1);
		p1.add(btn2);
		p1.add(btn3);
		p1.add(btn5);
		c.add(p1);
		
		//面板二：放置发件人，收件人，和主题
		JLabel fjr = new JLabel("发件人：");//发件人标签
        fjr.setForeground(Color.blue);//更改字体颜色，可以更改标签前景色
        fjr.setFont(new Font("楷体",Font.BOLD,15));//Font有三个参数
        fjr.setBounds(30, 12, 70, 30);
        JLabel sjr = new JLabel("收件人：");
        sjr.setForeground(Color.blue);//更改字体颜色，可以更改标签前景色
        sjr.setBounds(30, 47, 70, 30);
        sjr.setFont(new Font("楷体",Font.BOLD,15));//Font有三个参数
    	JLabel title = new JLabel("主  题：");
        title.setForeground(Color.black);//更改字体颜色，可以更改标签前景色
        title.setFont(new Font("楷体",Font.BOLD,15));//Font有三个参数
        title.setBounds(30, 80, 70, 30);
        JTextField jt1 = new JTextField();//创建一个文本框----发件人
        
        jt1.addFocusListener(new MyFocusListener());//使用我们创建好的自定义事件监听
		jt1.setFont(new Font("黑体",Font.PLAIN,20));//设置字体格式，第二个是字体样式，然后字体大小
		jt1.setBounds(110, 15, 180, 25);
	 	JTextField jt2 = new JTextField();//创建一个文本框------收件人
	 	jt2.addFocusListener(new MyFocusListener());//使用我们创建好的自定义事件监听
		jt2.setFont(new Font("黑体",Font.PLAIN,20));//设置字体格式，第二个是字体样式，然后字体大小
		jt2.setBounds(110, 50, 180, 25);      
        JTextField jt01 = new JTextField();//创建一个文本框----主题
        jt01.addFocusListener(new MyFocusListener());//使用我们创建好的自定义事件监听
		jt01.setFont(new Font("楷体",Font.PLAIN,20));//设置字体格式，第二个是字体样式，然后字体大小
		jt01.setBounds(110, 85, 580, 25);
		
		
	
		JPanel p2 = new JPanel();//使用模板2，放置发件人，收件人，和主题
		p2.setLayout(null);//给面板添加布局
		p2.setBounds(10,85, 900, 130);
		p2.setBorder(BorderFactory.createTitledBorder(""));
        p2.add(fjr);
        p2.add(sjr);
        p2.add(title);
        p2.add(jt1);
        p2.add(jt2);
        p2.add(jt01);
        c.add(p2);
		
		JLabel nr = new JLabel("内容：");
        nr.setForeground(Color.green);//更改字体颜色，可以更改标签前景色
        nr.setBounds(20, 500, 70, 30);
        nr.setFont(new Font("楷体",Font.BOLD,15));//Font有三个参数
	
        
        JComboBox<String> com = new JComboBox<>();	//实例化下拉列表对象
		String items[] = {"楷体","宋体","黑体"};
		ComboBoxModel cm = new DefaultComboBoxModel<>(items);//创建下拉列表模型，
		com.setModel(cm);//向列表中添加模型				
		com.setBounds(110,250,70,30);//下拉列表在坐标，长和宽
		com.setToolTipText("字体格式");
		c.add(com);
		JComboBox<String> com2 = new JComboBox<>();	//实例化下拉列表对象
		String items2[] = {"10","20","30"};
		ComboBoxModel cm2 = new DefaultComboBoxModel<>(items2);//创建下拉列表模型，
		com2.setModel(cm2);//向列表中添加模型				
		com2.setBounds(200,250,70,30);//下拉列表在坐标，长和宽
		com2.setToolTipText("字体大小");
		c.add(com2);
		JButton btn4 = new JButton("应用");
//		btn4.addActionListener(new MyActionListener4());
		btn4.setBounds(290, 250, 60, 30);
		JTextArea a = new JTextArea(800,500);//文本编辑域
		
		a.setLineWrap(true);//是否可以自动换行
		JScrollPane sp = new JScrollPane(a);//创建滚动面板，给文本区域添加滚动条
		sp.setBounds(110, 300, 800, 500);
		c.add(sp);//给容器添加滚动面板
		a.setFont(new Font("微软雅黑",Font.PLAIN,20));//字体格式
		btn4.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) 
			{
				s1 = (String) com.getSelectedItem();//获取选中的值
				s2 = (String) com2.getSelectedItem();//获取选中的值\
				if(s2.equals("10"))
					a.setFont(new Font(s1,Font.PLAIN,10));//字体格式
				else if (s2.equals("20"))
					a.setFont(new Font(s1,Font.PLAIN,20));//字体格式
				else if(s2.equals("30"))
					a.setFont(new Font(s1,Font.PLAIN,30));//字体格式
					
			}
			
		});
			
		JRadioButton jj = new JRadioButton("紧急发送");//创建按钮
		jj.setBounds(680, 260, 100, 30);
		JRadioButton pt = new JRadioButton("普通发送");
		pt.setBounds(800, 260, 100, 30);
		ButtonGroup group = new ButtonGroup();//按钮组
		group.add(jj);//将单选按钮放在按钮组中，
		group.add(pt);//当一个按钮选中后，会自动关闭另外一个按钮
		pt.setSelected(true);//默认选中普通发送按钮
		
		JCheckBox c1 = new JCheckBox("普通邮件");//设置多选按钮
		JCheckBox c2 = new JCheckBox("绝密邮件");
		JCheckBox c3 = new JCheckBox("阅读回执");
		c1.setToolTipText("普通邮件，用于日常联系");//鼠标悬停提示
		c2.setToolTipText("绝密邮件，用于绝密信息");//鼠标悬停提示
		c3.setToolTipText("阅读后需要回复");//鼠标悬停提示
		c1.setBounds(540, 220, 100, 30);
		c2.setBounds(680, 220, 100, 30);
		c3.setBounds(800,220, 100,30);
		c.add(c1);
		c.add(c2);
		c.add(c3);
		c.add(jj);
		c.add(pt);
		
		c.add(btn4);
		
        c.add(nr);
    
		
		JTextArea a1 = new JTextArea(190,190);//文本编辑域
		a1.setText("xxx：\n");
		a1.append("xxx：\n");
		JScrollPane sp1 = new JScrollPane(a1);//创建滚动面板，给文本区域添加滚动条
		sp1.setBounds(10, 20, 190, 190);
		JPanel p3 = new JPanel();//使用面板2，放联系人框
		p3.setLayout(null);//给面板添加布局
		p3.setBounds(950, 100, 210, 220);
		p3.setBorder(BorderFactory.createTitledBorder("联系人"));
		p3.add(sp1);
		c.add(p3);
		
		jf.setDefaultCloseOperation(WindowConstants. EXIT_ON_CLOSE);
		jf.setVisible(true);
	}
	class MyActionListener1 implements ActionListener
	{
		public void actionPerformed(ActionEvent e) 
		{
			if(jt.getText().equals(""))
			{
				JOptionPane.showMessageDialog(null, "请先登录");
				return;
			}
			JOptionPane.showMessageDialog(null, "发送成功");
		}
		
	}
	class MyActionListener2 implements ActionListener
	{
		public void actionPerformed(ActionEvent e) 
		{
			JOptionPane.showMessageDialog(null, "保存成功");
		}
		
	}
	class MyActionListener3 implements ActionListener
	{
		public void actionPerformed(ActionEvent e) 
		{
			if(jt.getText().equals(""))
			{
				JOptionPane.showMessageDialog(null, "请先注册");
				return;
			}
			User s = new User(jf,jt,jp);
			s.setVisible(true);
			
		}
		
	}
	class MyActionListener4 implements ActionListener
	{
		public void actionPerformed(ActionEvent e) 
		{
			Zhuce s = new Zhuce(jf,jt,jp);
			s.setVisible(true);
			
		}
		
	}
	class MyFocusListener implements FocusListener//创建内部类来实现接口FocusListener
	{//自定义焦点事件监听
		public void focusGained(FocusEvent e)
		{
			JTextField tmp=(JTextField)e.getSource();//获取触发焦点的事件
			tmp.setBorder(BorderFactory.createLineBorder(Color.green));//给获取焦点的文本框一个边框
		}
		public void focusLost(FocusEvent e) {
			JTextField tmp=(JTextField)e.getSource();//获取触发焦点的事件
			tmp.setBorder(BorderFactory.createLineBorder(Color.black));//给失去焦点的文本框一个边框
		}
	}
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.Creatbk();
		
	}

}