GUI编程..

1.GUI(Graphical User Interface 图形用户界面)

所谓GUI 指的是在计算机中采用图形方式展示用户的界面
在GUI之前采用的是字符界面

有了GUI之后 采用的则是图形界面

2.Java的GUI编程方案

常见的有四种

3.Swing

1.实现一个窗口

public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 首先创建一个窗口 并且命名
        JFrame frame = new JFrame("第一个窗口");
        // 设置窗口的大小和位置
        frame.setBounds(300, 300, 400, 400);
        // 设置窗口关闭以后程序就退出
        frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
        // 设置窗口可见性
        frame.setVisible(true);
    }
}

2.Swing的常用组件

Swing提供了很多常用的组件 其中紫色的组件位于java.awt包中 绿色的组件位于javax.swing包中
以下是swing中常用的组件预览

接下来我们利用这些组件实现一个小案例：
就是实现以下简单的加法运算 而且要对不合理的输入触发反应

public class MyFrame extends JFrame {
    // 定义一个构造方法
    public MyFrame(){
        // 调用父类的构造方法创建一个窗口
        super("计算窗口");
        // 设置窗口的位置和大小
        setBounds(400, 400, 700, 400);
        // 设置窗口的关闭后的默认操作 即程序退出
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        // 接着我们设置一下窗口的布局方式为流式布局 是从左到右、从上到下进行布局的 可以设置水平间隔和竖直间隔
        setLayout(new FlowLayout(FlowLayout.LEFT,  20, 20));
        // 我们可以设置一个字体 去控制之后的字体大小
        Font font = new Font("微软雅黑", Font.PLAIN, 18);
        // 接着我们首先添加第一个加数的文本域
        JTextField tf1 = new JTextField(10);
        tf1.setFont(font);
        add(tf1);
        // 接着我们添加加号所在的文本标签
        JLabel addLabel = new JLabel("+");
        addLabel.setFont(font);
        add(addLabel);
        // 接着我们添加第二个加数的文本域
        JTextField tf2 = new JTextField(10);
        tf2.setFont(font);
        add(tf2);
        // 接着我们添加等号所在的文本标签
        JLabel equalLabel = new JLabel("=");
        equalLabel.setFont(font);
        add(equalLabel);
        // 接着我们添加结果所在的文本标签
        JLabel resultLabel = new JLabel();
        resultLabel.setFont(font);
        resultLabel.setText("?");
        add(resultLabel);
        // 接着我们添加一个计算的按钮
        JButton button = new JButton();
        button.setFont(font);
        button.setText("计算");
        add(button);
        // 为计算按钮添加监听器
        button.addActionListener((e) -> {
            try {
                int result = Integer.parseInt(tf1.getText()) + Integer.parseInt(tf2.getText());
                resultLabel.setText(result + "");
            }catch(Exception a){
                int w = 500;
                int h = 100;
                int x = this.getX() + ((this.getWidth() - w) >> 1);
                int y = this.getY() + ((this.getHeight() - h) >> 1);
                // 弹出一个警告窗口 设置弹出以后父窗口就不可以执行点击操作了
                JDialog dialog = new JDialog(this, true);
                dialog.setTitle("警告");
                dialog.setBounds(x, y, w, h);
                // 还得提示一下输入正确的值
                JLabel label = new JLabel("请输入正确的整数!!!");
                label.setFont(font);
                dialog.add(label);
                dialog.setVisible(true);
            }
        });
    }
}
public class Main{
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 展示窗口以及一些组件
        new MyFrame().setVisible(true);
    }
}

4.Java程序的运行过程

有一个思考：Java的IDE是如何将我们所编写的Java程序运行起来的呢？
其实就是先将我们所编写的.java源文件编译成.class字节码文件 然后将字节码文件加载到JVM中 通过JVM解析成机器指令(二进制数据)

JDK的bin目录下已经包含了运行Java程序的工具(IDE就是调用了这些工具将Java程序运行起来的)
javac xx.java
编译xx.java为xx.class

java xx
启动JVM 加载xx.class文件

5.字节码文件的类型

每一个类(也包括枚举 因为枚举的本质是类)、接口编译完毕以后都会生成一个对应的.class文件

顶级类型(类、接口)–类型.class
嵌套类型(类、接口)–外部类型 + $ + 嵌套类型.class
局部类–外部类型 + $ + 数字 + 局部类.class
匿名类–外部类型 + $ + 数字.class

// 顶级类：字节码文件的名称是类名.class
public class Main {
	// 嵌套类一：字节码文件的名称是外部类型$嵌套类.class
	public class Inner{
		// 嵌套类二：字节码文件的名称是外部类型$嵌套类.class
		public class Inner3{
			
		}
	}
	public static void main(String[] args) {
		// 局部类：字节码文件的名称是外部类型$数字局部类.class
		class Inner2{
			
		}
		// 匿名类一：字节码文件的名称是外部类型$数字.class
		Runnable r1 = new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				
			}
			
		};
		// 匿名类二：字节码文件的名称是外部类型$数字.class
		Runnable r2 = new Runnable() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				
			}
			
		};
	}
}

在eclipse的工作空间中的bin目录下的各个类型的文件对应的字节码文件如下所示

6.main方法的参数

public class Main{
	public static void main(String... args){
		try{
			int a = Integer.parseInt(args[0]);
			int b = Integer.parseInt(args[1]);
			System.out.println("a + b = " + (a + b));
		}catch(Exception e){
			System.out.println("please pass two ints");
		}
	}
}

main方法的限制
必须是公共、静态(public static)
不能有返回值(void) 也就是说 前面三个修饰符都不能够动
有且只有一个参数 参数类型只能是String[]或者String…

7.JAR

如果想将自己写的Java代码共享给其他人使用的话 那么有两种方式：
1.直接将.Java文件直接分享出去
2.将相关的.class文件打包成一个.jar文件分享出去

对于第一种做法 他是开源的 就是我们可以直接看到源代码 但是你需要将Java文件所在的包也一并拷贝 不然的话 仅拷贝Java文件就会发生导包语句的报错(Java文件中含有导包语句)
对于第二种做法 我详细介绍一下：
eclipse中自带了导包操作
首先右击项目或者文件(项目注意导出的是项目所有文件组成的jar包) 点击Export 选择JAR file

接着我们可以打开验证一下看jar包中是否是我们所想要的文件
可以见的 确实如此
然后我们可以在想要使用jar包的项目中创建一个libs用于储存刚才的jar包

然后我们需要右击这个libs中的jar包 选择build path中的add to选项 就会生成一个

然后我们就可以在这个项目中使用导入的jar包

但是我们按住ctrl的同时点击我们所导入的Student的话 可以看到里面没有源码

说明这种方式是闭源的 如果想要开源的话 那么我们就需要将刚才的Student文件打包成源文件格式的jar包 这是什么意思呢
我们还是右击指定文件 选择Export 打开选项卡 选择JAR file

然后我们将打包好的jar包同样存放到libs中 然后对其进行build path操作

然后我们要将字节码文件和源文件关联起来 右击字节码文件的jar包 选择properties

最后我们在去使用Student的时候 ctrl同时点击Student就可以看到他的源码了

注意别人的源代码可读不可写
但是有一种可能是它会将别人jar包中的文件替换掉 换成一些恶意的文件 这种情况应该如何杜绝呢
就是对jar进行数字签名 防止代码被篡改

8.Runnable_JAR

所谓可运行的JAR 指的就是包含了main方法的JAR
这个的Export有别于正常的JAR 他的执行方式为
右击项目或者文件 选择Export 选择Runnable JAR file

选择合适的第三方库处理方式 并且设置好可运行JAR的存放路径

对于第一种处理方式 他的第三方库储存情况是
第三方库解压后直接储存在可运行JAR包中

对于第二种处理方式 第三方库的储存情况为：
不经过解压直接储存到可运行JAR包中

第三种处理方式 第三方库的储存情况为：
将第三方库储存到和可运行JAR包同目录的文件夹中(该文件夹的名字默认和第三方库同名)

1.Runnable JAR的启动方式

常见的有三种
1.通过命令行启动
java -jar JAR文件路径
2.编写bat文件 双击执行bat文件(只适用于Windows)
bat文件的大致内容为：
java -jar JAR文件路径
pause(按任意键结束的意思)
3.第三种就是将JAR转换为exe文件 然后双击exe(只适用于Windows 而且仍然需要JVM的支持)

9.生成Java文档

文档注释的生成方法 就是/**然后回车
如何构造一个Java文档呢？

上一步也可以有下图替代执行

下图这个界面按默认的选项即可


生成文档实际上是调用了jdk bin目录中的javadoc.exe

10.双括号初始化

public class Main {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>() {
			{
				add(11);
				add(22);
			}
		};
		System.out.println(list);// [11, 22]
	}
}

实际上com.axihh包中只有两个类 但是字节码文件中有三个类 那么多出来一个类是谁呢 我们可以发现 多出来的格式为外部类$数字 这不就是匿名类吗 说明我们上述代码所使用到的双括号初始化正是采用了匿名类的语法 具体是怎么操作的呢
我们都知道初始化块在编译阶段会自动添加到构造方法开头 我们就可以认为内括号这个初始化块就是在调用一个仅含初始化块内容的构造方法 而且等号右边就是匿名类的父类
以下就是双括号初始化的本质

public class Main {
	public static void main(String[] args) {
		List<Integer> list = new Main$2();
		System.out.println(list);// [11, 22]
	}
}

public class Main {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<>();
		list.add(11);
		list.add(22);
		System.out.println(list);// [11, 22]
	}
}

上述两端代码都可以完成同一需求 就是添加并打印
两者的优劣分别是什么
优点：
双括号初始化的优点就是代码简洁 特别是调用方法的次数规模十分庞大的时候
缺点：
1.多生成了一个匿名类
2.可能会影响equals方法的正常使用

public class Main {
	public static void main(String[] args) {
		Person p1 = new Person(10);
		Person p2 = new Person(10);
		System.out.println(p1.equals(p2));// true
		System.out.println(p1 == p2);// false
		// 本质上这个类是Person的子类
		Person p3 = new Person(10){{
			
			}
		};
		System.out.println(p1.equals(p3));// false
		System.out.println(p2.equals(p3));// false
	}
}

(匿名类是Person的子类 不是Person类 虽然年龄都是10 但是类型不同 所以结果肯定是false 所以使用这种语法会影响equals方法的正确使用)
所以建议慎重使用这个语法