第 37 級。有關該級別主題的面試問題的答案

在 Random-TW 群組發布

你好。我再次沒有找到這些問題的答案。我決定發布我自己整理的答案。第 37 級。有關第 1 級主題的面試問題的答案

以下是實際問題： 面試問題：

什麼是設計模式？
你知道哪些設計模式？
為我們介紹一下單例模式嗎？如何使其線程安全？
跟我們介紹一下工廠模式嗎？
告訴我們 AbstractFactory 模式
給我們介紹一下 Adaper 模式，它與 Wrapper 的差異？
告訴我們有關代理模式的信息
什麼是迭代器？你知道哪些與迭代器相關的介面？
為什麼我們需要 Arrays 類別？
為什麼我們需要 Collections 類別？

以下是我的回答： 我的回答：

設計模式是針對程式或其部分的設計和開發過程中出現的最常見問題的成熟、成功的解決方案。
Singleton,,,,,,,,,,,, Factory. Abstract Factory_ Template method_ Strategy_ Pool_ Adapter_ Proxy_ Bridge_ MVC_

當程式中只需要存在一個類別的一個實例時，就可以使用該模式Singleton。它看起來像這樣（延遲初始化）：

clas Singleton {
	private Singleton instance;

	private Singleton() {}

	public static Singletot getInstance() {
		if (instance == null)
			instance = new Singleton();
		return instance;
	}
}

為了使其線程安全，您可以向該方法添加getInstance()修飾符synchronized。但這不是最好的解決方案（而是最簡單的）。更好的解決方案是以getInstance這種方式編寫方法（雙重檢查鎖定）：

public static synchronized Singleton getInstance() {
	if (instance == null)
		synchronized(Singleton.class) {
			instance = new Singleton();
		}
	return instance;
}

模式Factory是一種生成模式。它允許您按需建立物件（例如，在某些條件下）。它看起來像這樣：

class Factory{
	public static Object1 getObject1() {
		return new Object1();
	}

	public static Object2 getObject2() {
		return new Object2();
	}

	public static Object3 getObject3() {
		return new Object3();
	}
}

這種模式還有一個變體，稱為FactoryMethod。根據此模式，根據傳入的輸入資料（參數值），在一種方法中建立不同的物件。所有這些物件必須有一個共同的祖先（或一個共同的可實現介面）。它看起來像這樣：

class FactoryMethod {
	public enum TypeObject {
		TYPE1,
		TYPE2,
		TYPE3
	}

	public static CommonClass getObject(TypeObject type) {
		switch(type) {
			case TYPE1:
				return new Object1();
			case TYPE2:
				return new Object2();
			case TYPE3:
				return new Object3();
			default:
				return null;
		}
	}
}

類Object1，Object2並Object3從類別繼承CommonClass。

模式Abstract Factory也是一種生成設計模式。根據此模式，建立一個抽象工廠，用作多個特定工廠的範本。這是一個例子：

class Human {}

class Boy extends Human {}
class TeenBoy extends Human {}
class Man extends Human {}
class OldMan extends Human {}

class Girl extends Human {}
class TeenGirl extends Human {}
class Woman extends Human {}
class OldWoman extends Human {}

interface AbstractFactory {
	Human getPerson(int age);
}

class FactoryMale implements AbstractFactory {
	public Human getPerson(int age) {
		if (age < 12)
			return new Boy();
		if (age >= 12 && age <= 20)
			return new TeenBoy();
		if (age > 20 && age < 60)
			return new Man();
		return new OldMan();
	}
}

сlass FactoryFemale implements AbstractFactory {
	public Human getPerson(int age) {
		if (age < 12)
			return new Girl();
		if (age >= 12 && age <= 20)
			return new TeenGirl();
		if (age > 20 && age < 60)
			return new Woman();
		return new OldWoman();
	}
}

模式Adapter是一種結構模式。它的實作允許在需要另一種類型的物件（通常是抽象類型）的地方使用一種類型的物件。此模式的範例實作：

interface TotalTime {
	int getTotalSeconds();
}
interface Time {
	int getHours();
	int getMinutes();
	int getSeconds();
}

class TimeAdapter extends TotalTime {
	private Time time;
	public TimeAdapter(Time time) {
		this.time = time;
	}
	public int getTotalTime() {
		return time.getSeconds + time.getMinutes * 60 + time.getHours * 60 * 60;
	}
}

class TotalTimeAdapter extends Time {
	private TotalTime totalTime;
	public TotalTimeAdapter(TotalTime totalTime) {
		this.totalTime = totalTime;
	}

	public int getSeconds() {
		return totalTime % 60;
	}

	public int getMinutes() {
		return (totalTime / 60) % 60;
	}

	public int getHours() {
		return totaltime/ (60 * 60) ;
	}
}

class Main {
	public static void main(String[] args) {
		Time time = new Time() {
			public int getSeconds() {
				return LocalTime.now().getSecond();
			}

			public int getMinutes() {
				return LocalTime.now().getMinute();
			}

			public int getHours() {
				return LocalTime.now().getHour() ;
			}
		};

		TotalTime totalTime = new TimeAdapter(time);
		System.out.println(totalTime.getTotalSeconds());

		TotalTime totalTime2 = new TotalTime() {
			public int getTotalSeconds() {
				LocalTime currTime = LocalTime.now();
				return currTime.getSecond() + currTime.getMinute * 60 + currTime.getHour * 60 * 60;
			}
		};

		Time time2 = new TotalTimeAdapter(totalTime2);
		System.out.println(time2.getHours + ":" + time2.getMinutes() + ":" + time2.getSeconds());
	}
}

При реализации паттерна Wrapper создаётся класс, который оборачивает исходный класс и реализует тот же интерфейс, который реализует исходный класс. Таким образом, это позволяет расширить функциональность исходного класса и использовать новый класс там, где ожидается использование исходного класса. Это отличается от реализации паттерна Adapter тем, что в данном случае используется один интерфейс (тот же, что есть у исходного класса). В паттерне Adapter же используется два интерфейса, и класс, который оборачивает экземпяр исходного класса, реализует совсем другой инферфейс, не интерфейс исходного класса.

Паттерн Proxy — это структурный паттерн проектирования. Он нужен для того, чтобы контролировать доступ к Howому-то an objectу. Для этого пишется класс по типу "обёртка", то есть внутрь класса передаётся исходный an object, реализующий некий интерфейс, сам класс тоже реализует этот интерфейс, и в каждом методе этого класса вызывается похожий метод у исходного an object. Реализация того же интерфейса, что и у исходного an object, позволяет подменить исходный an object прокси-an objectом. Также это позволяет, не меняя исходного an object, "навешивать" на его методы Howую-то специальную дополнительную функциональность (например, логирование, проверка прав доступа, кэширование и т.д.). Пример:
```
interface Bank {
	void setUserMoney(User user, double money);
	double getUserMoney(User user);
}

class CitiBank implements Bank { //оригинальный класс
	public void setUserMoney(User user, double money) {
		UserDAO.update(user,money);
	}

	public double getUserMoney(User user) {
		UserDAO.getUserMoney(user);
	}
}

class SecurityProxyBank implements Bank {
	private Bank bank;

	public SecurityProxyBank(Bank bank) {
		this.bank = bank;
	}

	public void setUserMoney(User user, double money) {
		if (!SecurityManager.authorize(user,BankAccounts.Manager)
			throw new SecurityException("User can't change money value");

		UserDAO.update(user,money);
	}

	public double getUserMoney(User user) {
		if (!SecurityManager.authorize(user,BankAccounts.Manager)
			throw new SecurityException("User can't get money value");

		UserDAO.getUserMoney(user);
	}
```

Итератор — это специальный внутренний an object коллекции, который позволяет последовательно перебирать элементы этой коллекций. Этот an object должен реализовывать интерфейс Iterator<E>, либо ListIterator<E> (для списков). Также, для того, чтобы перебирать элементы коллекции, коллекция должна поддерживать интерфейс Iterable<E>. Интерфейс Iterable<E> содержит всего один метод — iterator(), который позволяет извне получить доступ к итератору коллекции.

Интерфейс Iterator<E> содержит следующие методы:
- boolean hasNext() — проверяет, есть ли в коллекции ещё Howой-то элемент
- E next() — позволяет получить очередной элемент коллекции (после получения element, внутренний курсор итератора передвигается на следующий элемент коллекции)
- void remove() — удаляет текущий элемент из коллекции
Интерфейс же ListIterator<E> содержит такие методы:
- boolean hasNext() — проверяет, существуют ли ещё один элемент в коллекции (следующий за текущим)
- E next() — возвращает очередной элемент коллекции (и передвигает внутренний курсок итератора на следующий элемент)
- int nextIndex() — возвращает индекс следующего element
- void set(E e) — устанавливает meaning текущего element void add(E e). Добавляет элемент в конец списка.
- boolean hasPrevious() — проверяет, существует ли Howой-то элемент в коллекции перед данным элементом
- E previous() — возвращает текущий элемент коллекции и переводит курсор на предыдущий элемент коллекции
- int previousIndex — возвращает индекс предыдущего element коллекции
- void remove() — удаляет текущий элемент коллекции
- void add(E e) — добавляет элемент e после текущего element коллекции
此類別Arrays是為各種數組操作而設計的實用程式類別。此類具有將數組轉換為列表、搜尋數組、複製數組、比較數組、獲取數組哈希碼、將數組表示為字串等方法。
該類別Collections是用於處理集合的實用程式類別。該類別具有向集合添加元素、以元素填充集合、搜尋集合、複製集合、比較集合、查找集合的最大和最小元素的方法，以及獲取集合的特定修改的方法已知類型（例如，您可以獲得線程安全集合或具有一個元素的不可變集合）。