一. 接口、继承、多态

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();//子类方法----5Gson.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
{@Overridepublic void teaching() {//前面有一个白色的小三角，说明这个方法是被重写的。// TODO 自动生成的方法存根System.out.println("我是数学老师！");}
}
class EnglishTeacher extends Teacher
{@Overridepublic 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();//创建面板P1p1.setLayout(new FlowLayout());//设置面板p1布局方式JPanel p2 = new JPanel();//创建面板P2JTextArea a = new JTextArea(7,15);//文本编辑域JScrollPane sp = new JScrollPane(a);//创建滚动面板，给文本区域添加滚动条p2.setLayout(new FlowLayout());//设置面板p2布局方式p2.add(sp);//在面板p2中添加文本编辑区JPanel p3 = new JPanel();//创建面板P3JTextArea 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();//创建面板P4JTextArea 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初始状态");//标签2JTextField 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();}}

效果展示：

Java笔记（二）（寒假）相关推荐

1. Java笔记二十二——设计模式

   使用设计模式的目的是为了可重用代码,提高代码的可扩展性和可维护性,降低代码的耦合度. 设计模式基于以下几个原则: 里氏替换原则 --如果调用一个父类的方法可以成功,那么替换成子类调用也应该完全可以运行 ...

2. 那年学过的Java笔记二SE面向对象

   面向对象 面向对象编程 1 什么是对象? 万物皆对象. 2 什么是面向对象? 面向对象就是指以特征/属性和行为的观点去分析现实世界中事物的方式.3 什么是面向对象编程? 面向对象编程就是指先以面向对象 ...

3. Java笔记(二)运算符——逻辑与逻辑或 / 按位与按位或 等（ || 和 |）

   1 赋值运算符 2 算数运算符 2.1 + - * / % 2.2 自增自减 运算符:++ - - 3 关系运算符 4 逻辑运算符 && || !& | 5 位运算符 & ...

4. Java笔记二十四——Spring开发

   Spring是一个支持快速开发Java EE应用程序的框架.它提供了一系列底层容器和基础设施,并可以和大量常用的开源框架无缝集成,可以说是开发Java EE应用程序的必备. 在Spring Frame ...

5. Java学习笔记二：数据类型

   Java学习笔记二:数据类型 1. 整型:没有小数部分,允许为负数,Java整型分4种:int short long byte 1.1 Int最为常用,一个Int类型变量在内存中占用4个字节,取值范围 ...

6. Java语言基础（Java自我进阶笔记二）

   Java语言基础(Java自我进阶笔记二) 一. 什么是Java 的主类结构? 1. #mermaid-svg-xWTL2A8kDyyRPexH .label{font-family:'trebuch ...

7. java面试笔记二：java的面向对象

   java面试笔记二:面向对象 面向对象和面向过程的区别 过程就是函数,就是写方法,就是方法的一种实现. 对象就是将函数,属性的一种封装.用人们思考习惯的方式思考问题. 匿名对象 即:创建对象时没有指定 ...

8. 10.4-全栈Java笔记:常用流详解（二）

   上节我们讲到「Java中常用流:文件字节流和字节数组流」,本节我们继续走起~  缓冲流 BufferedInputStream和BufferedOutputStream这两个流是处理流,通过内部缓存数 ...

9. [转载]dorado学习笔记(二)

   原文地址:dorado学习笔记(二)作者:傻掛 ·isFirst, isLast在什么情况下使用?在遍历dataset的时候会用到 ·dorado执行的顺序,首先由jsp发送请求,调用相关的ViewM ...

10. 趣谈网络协议笔记-二（第十三讲）

    趣谈网络协议笔记-二(第十三讲) 套接字Socket:Talk is cheap, show me the code 前言 这只是笔记,是为了整理刘超大神的极客时间专栏的只是而存在的! 经常会在网络上 ...

最新文章

1. Redis安装与调试
2. SQL------Hint
3. [No0000D0] 让你效率“猛增十倍”，沉浸工作法到底是什么？
4. html switch开关实现隐藏,css3实现switch开关效果
5. Android之ADB常用命令
6. FTP 两种传输模式 Binary 和 ASCII 的区别
7. leetcode 746. 使用最小花费爬楼梯（dp）
8. 基于C++中常见内存错误的总结
9. JS中new的实现原理及重写
10. php fopen 清空文件内容,如何在c语言中清空文件里的内容？
11. 计算机系统操作工中级工试卷,计算机系统操作工中级理论试题及答案.doc
12. 静态，类，实例方法，字典
13. python怎么在gui中显示图片_Python 3-如何从Web检索图像并使用TKINTER在GUI中显示？...
14. 电源大师课笔记 2.8
15. 雷达存在感应器技术，实时感知控制应用，雷达人体探测方案
16. Android之ViewStub的简单使用
17. 酷柚易汛进销存开源版对外接口
18. latex怎么看论文字数_如何确定latex文档字数
19. 计算机键盘没有fn,键盘Fn键失灵怎么解决？键盘Fn键失灵的修复方法
20. ❤ ❤html canvas面向对象的彩色小球❤ ❤

热门文章

1. 学习尚硅谷Nginx整理的笔记
2. 九个问题从入门到熟悉HTTPS
3. 2004年7月15日
4. 怎样才算得上是一名优秀的软件测试工程师呢？
5. 字符串存储的可修改性
6. Verilog语法-模块module[Day2学习笔记]
7. 自动更换壁纸软件 Bing Wallpaper
8. 芝加哥大学计算机硕士人数,芝加哥大学计算机硕士：我和芝加哥有个约定
9. 农产品商城毕业设计,农产品销售系统毕业设计,农产品电商毕业设计论文方案需求分析作品参考
10. 查重时的疑惑：一个字一个字手写的论文怎么查重率就46%？