黑马程序员——基础学习（十四）多线程（Thread）和图形界面编程（GUI）

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Thread（多线程）

同步方法及其锁对象

this

静态同步方法其锁对象

类名.class

死锁

就是两个线程都进入锁，而都在等待对方释放锁造成的程序停滞现象

我的代码：

public class DieLock extends Thread {
	private boolean flag;
	public DieLock() {
	}
	public DieLock(boolean flag) {
		this.flag = flag;
	}
	public void run() {
		if (flag) {
			while (true) {
				synchronized (MyLock.lockA) {
					System.out.println("if lockA");
					synchronized (MyLock.lockB) {
						System.out.println("if lockB");
					}
				}
			}
		} else {
			while (true) {
				synchronized (MyLock.lockB) {
					System.out.println("else lockB");
					synchronized (MyLock.lockA) {
						System.out.println("else lockA");
					}
				}
			}
		}
	}
}

线程间通信

A:Student

B:SetThread

C:GetThread

D:StudentDemo

等待唤醒机制

A:wait()

B:notify()

C:notifyAll()

几个常见方法

A:线程优先级

B:暂停线程

C:加入线程

D:守护线程

run()和start()的区别

a:run()封装了被线程执行的代码

b:start()启动线程，并调用run()

线程生命周期

新建，就绪，运行，死亡

 阻塞

实现多线程的方式有两种

继承Thread类

实现Runnable接口

实现Runnable接口的步骤：

A:自定义类MyRunnable实现Runnable接口

B:重写run()方法

C:创建MyRunnable的对象

D:创建Thread类的对象，并把MyRunnable的对象作为构造参数传递

public Thread(Runnable target) {}

Thread(Runnable target, String name) 

我的代码：

public class MyRunnableDemo {
	public static void main(String[] args) {
		// 创建MyRunnable的对象
		MyRunnable my = new MyRunnable();
		// 创建Thread类的对象，并把MyRunnable的对象作为构造参数传递
		Thread t1 = new Thread(my, "kevin");
		Thread t2 = new Thread(my, "david");
		t1.start();
		t2.start();
	}
}

sleep()和wait()的区别

sleep():必须指定时间。不释放锁。

wait():可以指定时间，也可以不指定时间。释放锁。

设计模式：

就是前人总结的一些经验供我们使用。

设计模式的分类：

A:创建型模式 工厂模式,单例设计模式

B:行为型模式 模板设计模式

C:结构型模式 迭代器模式

单例设计模式：

类在内存中只有一个对象。

分析：如何实现类在内存中只有一个对象?

A:让外界不能创建对象，其实就是把构造方法私有。

B:在成员位置创建一个本类的对象。

C:提供一个公共的方法让外界访问。

作用：保证类在内存中只有一个对象

分析：

A:构造私有

B:本身提供一个对象

C:提供公共的方式让别人使用

代码体现：

A:饿汉式

			class Student {
				private Student(){}
				private static Student s = new Student();
				public  static Student getStudent() {
					return s;
				}
			}

B:懒汉式

			class Student {
				private Student(){}
				private static Student s = null;
				public  static synchronized Student getStudent() {
					if(s == null) {
						s = new Student();
					}
					return s;
				}
			}

懒汉式的优点：

A:延迟加载

B:线程安全

GUI

图形界面编程

概念

GUI:图形界面编程 操作方便直观

CLI:命令行窗口 需要记忆一些命令，比较麻烦

包：

java.awt 和系统关联较强

javax.swing 纯Java实现，与系统无关

GUI继承体系

组件：

基本组件 按钮，文本框等

容器组件 窗体或者面板

案例：

A:第一个窗体案例

B:窗体案例可以关闭了

C:窗体中添加按钮，并对按钮添加事件

D:把文本框里面的值赋值给文本域

E:IO流和GUI的结合

F:单级菜单案例

G:多级菜单案例

事件监听机制和适配器设计模式

A:事件监听机制

事件源

事件

事件处理

事件监听

B:适配器设计模式

接口中方法较多的时候，提供一个适配器类。

 

接口：

 

适配器类：

 

具体类：

我的代码：

需求1：

在窗体上添加一个按钮，并对按钮添加一个事件，做这样的一件事情，每次点击按钮，在控制台输出一句话：你在点试试。

import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class ButtonDemo {
	public static void main(String[] args) {
		// 创建窗体对象
		Frame f = new Frame("添加按钮");
		f.setSize(400, 300);
		f.setLocation(400, 200);
		//更改布局方式
		f.setLayout(new FlowLayout());
		// 创建按钮对象
		Button bu = new Button("点我啊");
		// 设置按钮大小
		// bu.setSize(20, 10);
		// 把按钮添加到窗体
		f.add(bu);
		// 给窗体加一个关闭事件
		f.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		
		//给按钮添加一个事件
		//ActionListener动作监听
		bu.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.out.println("你在点试试。");
			}
		});
		// 显示窗体
		f.setVisible(true);
	}
}

需求2：实现一个多级菜单：

菜单的儿子可以是菜单，也可以是菜单项目。

import java.awt.Frame;
import java.awt.Menu;
import java.awt.MenuBar;
import java.awt.MenuItem;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
public class MenuDemo3 {
	public static void main(String[] args) {
		// 创建窗体对象
		final Frame f = new Frame("多级菜单");
		f.setSize(400, 300);
		f.setLocation(400, 200);

		// 创建菜单栏
		MenuBar mb = new MenuBar();

		// 创建菜单
		Menu m1 = new Menu("文件");
		Menu m2 = new Menu("更改标题");
		Menu m3 = new Menu("帮助");

		// 记录以前的标题
		final String title = f.getTitle();

		// 创建菜单项
		MenuItem mi1 = new MenuItem("好好学习");
		MenuItem mi2 = new MenuItem("天天向上");
		MenuItem mi3 = new MenuItem("恢复标题");
		MenuItem mi4 = new MenuItem("退出系统");
		MenuItem mi5 = new MenuItem("打开记事本");
		MenuItem mi6 = new MenuItem("打开计算器");

		// 给菜单添加菜单项
		m2.add(mi1);
		m2.add(mi2);
		m2.add(mi3);
		m1.add(m2);
		m1.add(mi4);
		m3.add(mi5);
		m3.add(mi6);

		// 把菜单和菜单栏连接起来
		mb.add(m1);
		mb.add(m3);

		// 设置菜单栏
		f.setMenuBar(mb);

		f.addWindowListener(new WindowAdapter() {
			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});

		// 退出系统
		mi4.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				System.exit(0);
			}
		});

		// 打开记事本
		mi5.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				Runtime r = Runtime.getRuntime();
				try {
					r.exec("notepad");
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
		});

		// 打开计算器
		mi6.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				Runtime r = Runtime.getRuntime();
				try {
					r.exec("calc");
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
		});

		// 好好学习
		mi1.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				f.setTitle("好好学习");
			}
		});

		// 天天向上
		mi2.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				f.setTitle("天天向上");
			}
		});

		// 恢复标题
		mi3.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				f.setTitle(title);
			}
		});

		f.setVisible(true);
	}
}