25.01_單例設計模式(掌握)
- 單例設計模式：保證類在內存中只有一個對象。
/**
* 餓漢式 單例 （直接創建對象了），官方Runtime單利類使用的這種方式
*/
class Singleton2 {
// 1.私有構造方法，其他類不能訪問該構造方法
private Singleton2() {}
// 2.創建本類對象，因為不能創建對象，外部想要調用，就得static，為了不讓外部隨便改，就得私有
private static Singleton2 self = new Singleton2();
// 3.對外提供公共訪問方法
public static Singleton2 getInstance() {
return self;
}
}
/**
* 懶加載 單例 （直接創建對象了）(單例的延遲加載模式) 這種方式有安全隱患，在多線程時，可能多次創建對象
*/
class Singleton {
// 1.私有構造方法，其他類不能訪問該構造方法
private Singleton() {}
// 2.創建本類對象，因為不能創建對象，外部想要調用，就得static，為了不讓外部隨便改，就得私有
private static Singleton self;
// 3.對外提供公共訪問方法
public static Singleton getInstance() { //如果想要線程安全，可以加synchronized關鍵字
return self == null ? self = new Singleton() : self;
}
}
/**
* 單例模式的第三種方法
*/
class Singleton3 {
// 1.私有構造方法，其他類不能訪問該構造方法
private Singleton3() {}
// 2.創建本類對象，因為不能創建對象，外部想要調用，就得static
public static final Singleton3 self = new Singleton3();
}
事實上，可以通過Java反射機制來實例化private類型的構造方法
此時基本上會使所有的Java單例實現失效。這里不討論反射情況下問題。
25.02_多線程(Runtime類)
-
Runtime類是一個單例類
Runtime rt = Runtime.getRuntime(); //單例模式，獲取Runtime類
rt.exec("shutdown -s -t 300"); //執行字符串命令(五分鐘后關機)，可能有IOException
rt.exit(0); //終止當前正在運行的JVM
25.03_多線程(Timer)(掌握)
-
Timer類:計時器
// 任務類，需要繼承TimerTask后才能使用，不能直接使用TimerTask
class MyTimerTask extends TimerTask {
public void run() {
System.out.println("起床..么么噠...");
}
}
Timer timer = new Timer();
timer.schedule(new MyTimerTask(), 5000); //5秒后執行MyTimerTask任務
schedule(TimerTask task, Date time) // 安排在指定的時間執行指定的任務。
schedule(TimerTask task, Date firstTime, long period)
安排指定的任務在指定的時間開始進行重復的固定延遲執行。
25.04_多線程(兩個線程間的通信)(掌握)
- 1.什么時候需要通信
- 多個線程并發執行時, 在默認情況下CPU是隨機切換線程的
- 如果我們希望他們有規律的執行, 就可以使用通信, 例如每個線程執行一次打印
- 2.怎么通信
- 如果希望線程等待, 就調用
wait() - 如果希望喚醒等待的線程, 就調用
notify(); - 這兩個方法必須在同步代碼中執行, 并且使用同步鎖對象來調用
- 如果希望線程等待, 就調用
class Printer {
private int flag = 1;
public void print1() throws InterruptedException {
synchronized(this){
if (flag != 1)
this.wait(); //讓當前線程等待，如果沒有被喚醒，就會一直等待
System.out.print("我");
System.out.print("日");
System.out.print("妮");
System.out.print("\r\n");
flag = 2;
this.notify(); //隨機喚醒單個等待的線程
}
}
public void print2() throws InterruptedException {
synchronized(this) {
if (flag != 2)
this.wait(); //讓當前線程等待，如果沒有被喚醒，就會一直等待
System.out.print("鄭");
System.out.print("州");
System.out.print("市");
System.out.println();
flag = 1;
this.notify(); //隨機喚醒單個等待的線程
}
}
}
final Printer p = new Printer(); //匿名類在使用局部變量時，需要final修飾
new Thread() {...}.start(); //開始兩個線程分別運行p的print1()和print2（）
new Thread() {...}.start();
25.05_JDK1.5之前三個或三個以上間的線程通信
- 多個線程通信的問題
-
notify()方法是隨機喚醒一個線程 -
notifyAll()方法是喚醒所有線程 - JDK5之前無法喚醒指定的一個線程
- 如果多個線程之間通信, 需要使用
notifyAll()通知所有線程, 用while來反復判斷條件
-
private int flag = 1;
public void print1() throws InterruptedException {
synchronized(this){
while (flag != 1) { //if語句是在哪里等待，就在哪里幻想起來。不會再次判斷，所以使用while
this.wait(); //讓當前線程等待，如果沒有被喚醒，就會一直等待
}
System.out.print("1我");
System.out.print("日");
System.out.print("妮");
System.out.print("\r\n");
flag = 2;
this.notifyAll(); //喚醒所有等待的線程
}
}
25.99_線程間的通訊需要注意的問題
1.在同步代碼塊中，用哪個對象鎖，就用哪個對象調用wait()方法.
2.為什么wiat()方法和notify()方法定義在Object類中？
因為鎖對象可以是任意對象，而Object是所有類的基類，所以wiat()方法和notify()方法需要定義在Object方法中！
3.sleep()方法和wait()方法的區別？
sleep()方法必須傳入參數，參數就是時間，時間到了，自動喚醒。
wait()可以傳入參數，也可以不傳，傳入參數就是在參數時間結束后等待，不傳入就是直接等待，不會自動喚醒，必須由notify()方法喚醒
sleep()方法在同步函數或同步代碼塊中，不釋放鎖
wait()方法在同步函數或同步代碼塊中，釋放鎖。
25.06_JDK1.5的新特性互斥鎖(掌握)
- 1.同步
- 使用
ReentrantLock類的lock()和unlock()方法進行同步
- 使用
- 2.通信
- 使用
ReentrantLock類的newCondition()方法可以獲取Condition對象 - 需要等待的時候使用
Condition的await()方法, 喚醒的時候用signal()方法 - 不同的線程使用不同的
Condition, 這樣就能區分喚醒的時候找哪個線程了
- 使用
private ReentrantLock r = new ReentrantLock();
private Condition c1 = r.newCondition(); //Condition線程監視器類
private Condition c2 = r.newCondition();
private Condition c3 = r.newCondition();
public void print1() throws InterruptedException {
r.lock(); //獲取鎖
if (flag != 1) //if語句是在哪里等待，就在哪里幻想起來.因為能指定線程喚醒和睡眠，所以使用if
c1.await(); //讓當前線程等待，如果沒有被喚醒，就會一直等待
System.out.print("1我");
System.out.print("日");
System.out.print("妮");
System.out.print("\r\n");
flag = 2;
c2.signal(); //喚醒c2線程，這能做到喚醒指定線程
r.unlock(); //釋放鎖
}
25.07_線程組的概述和使用(了解)
- Java中使用ThreadGroup來表示線程組，它可以對一批線程進行分類管理，Java允許程序直接對線程組進行控制。
- 默認情況下，所有的線程都屬于主線程組。
-
public final ThreadGroup getThreadGroup()//通過線程對象獲取他所屬于的組 -
public final String getName()//通過線程組對象獲取他組的名字
-
- 我們也可以給線程設置分組
- 1,
ThreadGroup(String name)創建線程組對象并給其賦值名字 - 2,創建線程對象
- 3,
Thread(ThreadGroup?group, Runnable?target, String?name) - 4,設置整組的優先級或者守護線程
- 1,
Thread(tg,mr,"線程一"); //將線程t1放在組中
Thread t2 = new Thread(tg,mr,"線程二"); //將線程t2放在組中
System.out.println(t1.getThreadGroup().getName()); // 獲取線程所在線程組 的名字
System.out.println(t2.getThreadGroup().getName());
//線程組的 好處 可以成組的設置。比如 tg.setDaemon(true) 組都變成了守護線程
// 通過結果我們知道了：線程默認情況下屬于main線程組
// 通過下面的測試，你應該能夠看到，默任情況下，所有的線程都屬于同一個組
25.08_多線程(線程的五種狀態)(掌握)
- 新建,就緒,運行,阻塞,死亡
線程狀態圖.png
25.09_線程池的概述和使用(了解)
程序啟動一個新線程成本是比較高的，因為它涉及到要與操作系統進行交互。而使用線程池可以很好的提高性能，尤其是當程序中要創建大量生存期很短的線程時，更應該考慮使用線程池。線程池里的每一個線程代碼結束后，并不會死亡，而是再次回到線程池中成為空閑狀態，等待下一個對象來使用。在JDK5之前，我們必須手動實現自己的線程池，從JDK5開始，Java內置支持線程池
- JDK5新增了一個Executors工廠類來產生線程池，有如下幾個方法
static ExecutorService newFixedThreadPool(int nThreads)static ExecutorService newSingleThreadExecutor()- 這些方法的返回值是
ExecutorService對象，該對象表示一個線程池，可以執行Runnable對象或者Callable對象代表的線程。它提供了如下方法 Future<?> submit(Runnable task)<T> Future<T> submit(Callable<T> task)
ExecutorService es = Executors.newFixedThreadPool(2); //創建線程池
es.submit(new MRunnable()); //將線程池放進池里并執行，接收Runnable子接口
es.submit(new MRunnable());
es.shutdown(); //關閉線程池
25.10_多線程程序實現的方式三(了解)
class MyCallable implements Callable<Integer> { //Callable的好處是可以拋異常和有返回值
private int num;
public MyCallable(int num) {this.num = num;} // 1...num的和
public Integer call() throws Exception {
int sum = 0 ;
for(int i = 0; i < num; i++){
sum += i;
}
return sum;
}
}
ExecutorService es = Executors.newFixedThreadPool(2); //創建線程池
Future<Integer> f1 = es.submit(new MyCallable(20)); //可以有返回值
Future<Integer> f2 = es.submit(new MyCallable(30));
System.out.println(f1.get() + "....." + f2.get());
es.shutdown();
25.11_簡單工廠模式概述和使用(了解)
- A:簡單工廠模式 ： 又叫靜態工廠方法模式，它定義一個具體的工廠類負責創建一些類的實例
- B:優點
- 客戶端不需要在負責對象的創建，從而明確了各個類的職責
- C:缺點
- 這個靜態工廠類負責所有對象的創建，如果有新的對象增加，或者某些對象的創建方式不同，就需要不斷的修改工廠類，不利于后期的維護
public class AnimalFactory {
public static Dog getDog() { //得到狗對象
return new Dog();
}
public static Cat getCat() { //得到貓對象
return new Cat();
}
// 改進,弊端是有新的類型，得修改這里
public static Animal createAnimal(String type) {
if("狗".equals(type)) {
return new Dog();
} else if("貓".equals(type)) {
return new Cat();
} else return null;
}
}
25.12_工廠方法模式的概述和使用(了解)
A:工廠方法模式概述: 工廠方法模式中抽象工廠類負責定義創建對象的接口，具體對象的創建工作由繼承抽象工廠的具體類實現。
-
B:優點
- 客戶端不需要在負責對象的創建，從而明確了各個類的職責，如果有新的對象增加，只需要增加一個具體的類和具體的工廠類即可，不影響已有的代碼，后期維護容易，增強了系統的擴展性
-
C:缺點
- 需要額外的編寫代碼，增加了工作量
動物抽象類：public abstract Animal { public abstract void eat(); }
工廠接口：public interface Factory {public abstract Animal createAnimal();}
具體狗類：public class Dog extends Animal {}
具體貓類：public class Cat extends Animal {}
開始，在測試類中每個具體的內容自己創建對象，但是，創建對象的工作如果比較麻煩，就需要有人專門做這個事情，所以就知道了一個專門的類來創建對象。發現每次修改代碼太麻煩，用工廠方法改進，針對每一個具體的實現提供一個具體工廠。
狗工廠：
public class DogFactory implements Factory {
public Animal createAnimal() {…}
}
貓工廠：
public class CatFactory implements Factory {
public Animal createAnimal() {…}
}
25.13_GUI(如何創建一個窗口并顯示)
-
Graphical User Interface圖形用戶接口
Frame f = new Frame(“么么噠”);
f.setLayout(new FlowLayout());//設置布局管理器
f.setSize(500,400);//設置窗體大小 px
f.setLocation(300,200);//設置窗體出現在屏幕的位置
f.setIconImage(Toolkit.getDefaultToolkit().createImage("qq.png"));
f.setVisible(true); //設置可見
25.14_GUI(布局管理器)
-
FlowLayout（流式布局管理器）,從左到右的順序排列,Panel默認的布局管理器 -
BorderLayout（邊界布局管理器）,東，南，西，北，中 ,Frame默認的布局管理器 -
GridLayout（網格布局管理器）,規則的矩陣 -
CardLayout（卡片布局管理器）,選項卡 -
GridBagLayout（網格包布局管理器）,非規則的矩陣
25.15_GUI(窗體監聽)
Frame f = new Frame("我的窗體");
//事件源是窗體,把監聽器注冊到事件源上
//事件對象傳遞給監聽器
f.addWindowListener(new WindowAdapter() { //方法里還有放大，縮小，關閉等很多方法
public void windowClosing(WindowEvent e) {
System.exit(0); //退出虛擬機,關閉窗口
}
});
25.16_GUI(鼠標監聽)
Button b1 = new Button("按鈕一");
b1.addMouseListener(new MouseAdapter() { //鼠標事件
public void mouseClicked(MouseEvent e) {
System.out.println("么么噠");;
}
});
25.17_GUI(鍵盤監聽和鍵盤事件)
Button b1 = new Button("按鈕一");
b1.addKeyListener(new KeyAdapter() {
public void keyReleased(KeyEvent e) {
System.out.println("鍵盤" + e.getKeyCode());
if(KeyEvent.VK_SPACE == e.getKeyCode()) System.exit(0); //空格就退出
}
});
25.18_GUI(動作監聽)
Button b2 = new Button("按鈕二");
f.add(b2);
b2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
System.out.println("鍵盤事件 或者 鼠標事件");
}
});
25.19_設計模式(適配器設計模式)(掌握)
- a.什么是適配器
- 在使用監聽器的時候, 需要定義一個類事件監聽器接口.
- 通常接口中有多個方法, 而程序中不一定所有的都用到, 但又必須重寫, 這很繁瑣.
- 適配器簡化了這些操作, 我們定義監聽器時只要繼承適配器, 然后重寫需要的方法即可.比如GUI里的
KeyAdapter，WindowAdapter，MouseAdapter等就是標準的適配器模式。
- b.適配器原理
- 適配器就是一個類, 實現了監聽器接口, 所有抽象方法都重寫了, 但是方法全是空的.
- 適配器類需要定義成抽象的,因為創建該類對象,調用空方法是沒有意義的
- 目的就是為了簡化程序員的操作, 定義監聽器時繼承適配器, 只重寫需要的方法就可以了.
interface Animal {
public void eat();
public void sleep();
public void run();
}
abstract class AnimalAdapter implements Animal { //動物接口適配器,必須加abstract修飾，因為都是空方法
public void eat() {}
public void sleep() {}
public void run() {}
}
25.20_GUI(需要知道的)
- 事件: 用戶的一個操作
- 事件源: 被操作的組件
- 監聽器: 一個自定義類的對象, 實現了監聽器接口, 包含事件處理方法,把監聽器添加在事件源上, 當事件發生的時候虛擬機就會自動調用監聽器中的事件處理方法
END。
我是小侯爺。
在魔都艱苦奮斗，白天是上班族，晚上是知識服務工作者。
如果讀完覺得有收獲的話，記得關注和點贊哦。
非要打賞的話，我也是不會拒絕的。
