diff --git a/ko/README.md b/ko/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7bc004db65b19ad6d54aae2a071598ac523bca9f
--- /dev/null
+++ b/ko/README.md
@@ -0,0 +1,263 @@
+
+
+# 자바로 구현된 디자인 패턴
+
+![Java CI with Maven](https://github.com/iluwatar/java-design-patterns/workflows/Java%20CI%20with%20Maven/badge.svg)[](https://raw.githubusercontent.com/iluwatar/java-design-patterns/master/LICENSE.md)![License MIT](https://img.shields.io/badge/license-MIT-blue.svg)[](https://sonarcloud.io/dashboard?id=iluwatar_java-design-patterns)![Join the chat at https://gitter.im/iluwatar/java-design-patterns](https://badges.gitter.im/Join%20Chat.svg)
+
+
+
+[](#contributors-)![All Contributors](https://img.shields.io/badge/all_contributors-133-orange.svg?style=flat-square)
+
+
+
+# 소개
+
+디자인 패턴은 프로그래머가 응용 프로그램이나 시스템을 디자인 할 때 일반적인 문제를 해결하는 데 사용할 수있는 가장 공식화 된 방법입니다.
+
+디자인 패턴은 테스트되고 입증 된 개발 패러다임을 제공하여 개발 프로세스 속도를 높일 수 있습니다.
+
+디자인 패턴을 재사용하면 주요 문제를 유발하는 미묘한 이슈들을 방지하는데 도움이 되며 또한 패턴에 익숙한 코더와 아키텍트의 코드 가독성도 향상됩니다.
+
+# 시작하기
+
+이 사이트는 Java 디자인 패턴을 보여줍니다. 이 솔루션은 오픈 소스 커뮤니티의 경험이 많은 프로그래머와 설계자가 개발했습니다. 패턴은 높은 수준의 설명이나 소스 코드를 통해 찾아 볼 수 있습니다. 소스 코드 예제는 잘 설명되어 있으며 특정 패턴을 구현하는 방법을 알려주는 프로그래밍 튜토리얼로 생각할 수 있습니다. 우리는 가장 널리 알려지고 실무에서 입증된 오픈 소스 Java 기술을 사용합니다.
+
+자료를 살펴보기 전에 다양한 [소프트웨어 설계 원칙](https://java-design-patterns.com/principles/)을 숙지해야합니다.
+
+모든 디자인은 가능한 한 단순해야합니다. 당신은 KISS, YAGNI로 시작해야하며, 원칙을 작동 할 수 있는 가장 단순한 일을 해야합니다. 복잡성과 패턴은 실용적인 확장성을 위해 필요할 때만 도입되어야합니다.
+
+이러한 개념에 익숙해지면 다음 접근 방식 중 하나를 이용하여 [사용 가능한 디자인 패턴](https://java-design-patterns.com/patterns/)으로 드릴다운 할 수 있습니다.
+
+- 이름으로 특정 패턴을 검색합니다. 찾을 수 없습니까? [여기](https://github.com/iluwatar/java-design-patterns/issues)에서 새 패턴을 보고하십시오.
+- `Performance`, `Gang of Four` 또는 `Data access` 태그 사용.
+- 패턴 카테고리, `Creational`, `Behavioral` 및 기타 사용
+
+이 사이트에 제시된 객체 지향 솔루션이 여러분의 아키텍처에서 유용하고 우리가 개발 한 것만큼 재미있게 배우기를 바랍니다.
+
+# 기여하는 방법
+
+프로젝트에 기여할 의향이 있다면 [developer wiki](https://github.com/iluwatar/java-design-patterns/wiki)에서 관련 정보를 찾을 수 있습니다. [Gitter chatroom](https://gitter.im/iluwatar/java-design-patterns)에서 귀하를 돕고 질문에 답변 해 드리겠습니다.
+
+# 특허
+
+이 프로젝트는 MIT 라이센스 조건에 따라 라이센스가 부여됩니다.
+
+# 기여자
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/ko/adapter/README.md b/ko/adapter/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8ef291972013f3796136fa65188146ab0180696c
--- /dev/null
+++ b/ko/adapter/README.md
@@ -0,0 +1,134 @@
+---
+layout: pattern
+title: Adapter
+folder: adapter
+permalink: "/patterns/adapter/"
+categories: Structural
+tags:
+- Gang of Four
+---
+
+## 또한 ~으로 알려진
+
+Wrapper
+
+## 의도
+
+클래스의 인터페이스를 클라이언트가 기대하는 다른 인터페이스로 변환합니다. adapter를 사용하면 호환되지 않는 인터페이스로 인해 같이 쓸 수 없는 클래스를 함께 작동 할 수 있습니다.
+
+## 설명
+
+예시
+
+> 메모리 카드에 몇 장의 사진이 있고 컴퓨터로 전송해야한다고 생각하십시오. 이들을 전송하려면 컴퓨터에 메모리 카드를 연결할 수 있도록 컴퓨터 포트와 호환되는 어댑터가 필요합니다. 이 경우 카드 리더는 어댑터입니다. 또 다른 예는 유명한 전원 어댑터입니다. 세 갈래 플러그는 두 갈래 콘센트에 연결할 수 없습니다. 두 갈래 콘센트와 호환되는 전원 어댑터를 사용해야합니다. 또 다른 예는 한 사람이 말한 단어를 다른 사람에게 번역하는 번역가입니다.
+
+평범하게 말하자면
+
+> adapter 패턴을 사용하면 호환되지 않는 개체를 adapter에 연결하여 다른 클래스와 호환되도록 할 수 있습니다.
+
+Wikipedia 말에 의하면
+
+> 소프트웨어 엔지니어링에서 adapter 패턴은 기존 클래스의 인터페이스를 다른 인터페이스로 사용할 수 있도록 하는 소프트웨어 디자인 패턴입니다. 소스 코드를 수정하지 않고 기존 클래스가 다른 클래스와 함께 작동하도록 만드는 데 자주 사용됩니다.
+
+**프로그램 코드 예제**
+
+조정 보트만 사용할 수 있고 전혀 항해할 수 없는 선장을 생각해보십시오.
+
+먼저 `RowingBoat` 및 `FishingBoat` 인터페이스가 있습니다.
+
+```java
+public interface RowingBoat {
+ void row();
+}
+
+public class FishingBoat {
+ private static final Logger LOGGER = LoggerFactory.getLogger(FishingBoat.class);
+ public void sail() {
+ LOGGER.info("The fishing boat is sailing");
+ }
+}
+```
+
+그리고 선장은 `RowingBoat` 인터페이스를 이동할 수 있게 구현했습니다.
+
+```java
+public class Captain {
+
+ private final RowingBoat rowingBoat;
+ // default constructor and setter for rowingBoat
+ public Captain(RowingBoat rowingBoat) {
+ this.rowingBoat = rowingBoat;
+ }
+
+ public void row() {
+ rowingBoat.row();
+ }
+}
+```
+
+이제 해적이오고 있고 우리 선장이 탈출해야하는데 어선만 있습니다. 선장이 조정 보트 기술로 어선을 조작 할 수있는 adapter를 만들어야합니다.
+
+```java
+public class FishingBoatAdapter implements RowingBoat {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(FishingBoatAdapter.class);
+
+ private final FishingBoat boat;
+
+ public FishingBoatAdapter() {
+ boat = new FishingBoat();
+ }
+
+ @Override
+ public void row() {
+ boat.sail();
+ }
+}
+```
+
+이제 `Captain` 은 `FishingBoat` 를 사용하여 해적을 탈출 할 수 있습니다.
+
+```java
+var captain = new Captain(new FishingBoatAdapter());
+captain.row();
+```
+
+## 클레스 다이어그램
+
+![alt text](https://github.com/warp125/java-design-patterns/blob/master/adapter/etc/adapter.urm.png?raw=true)
+
+## 적용 가능성
+
+다음과 같은 경우 adapter 패턴을 사용합니다.
+
+- 기존 클래스를 사용 하려는데 해당 인터페이스가 필요한 클래스와 일치하지 않습니다.
+- 관련이 없거나 예상치 못한 클래스, 즉 호환되는 인터페이스가 반드시 필요하지 않은 클래스와 협력하는 재사용 가능한 클래스를 만들고 싶습니다.
+- 기존의 여러 하위 클래스를 사용해야하지만 모든 하위 클래스를 하위 클래스로 지정하여 인터페이스를 조정하는 것은 비현실적입니다. 개체 adapter는 부모 클래스의 인터페이스를 조정할 수 있습니다.
+- 타사 라이브러리를 사용하는 대부분의 응용 프로그램은 adapter를 응용 프로그램과 타사 라이브러리 사이의 중간 계층으로 사용하여 라이브러리에서 응용 프로그램을 분리합니다. 다른 라이브러리를 사용해야하는 경우 애플리케이션 코드를 변경할 필요없이 새 라이브러리 용 adapter만 필요합니다.
+
+## 결과 :
+
+클래스 및 개체 adapter에는 서로 다른 장단점이 있습니다.
클래스 adapter
+
+- 구체적인 Adaptee 클래스를 커밋하여 Adaptee를 Target에 적용합니다. 결과적으로 클래스와 모든 하위 클래스를 조정하려는 경우 클래스 adapter가 작동하지 않습니다.
+- adapter는 Adaptee의 하위 클래스이기 때문에 Adaptee의 일부 동작을 오버라이드합니다.
+- 하나의 객체만 생성하고 adaptee를 얻기위해 위해 추가 포인터 간접 지정이 필요하지 않습니다.
+
+개체 adapter
+
+- 하나의 adapter가 많은 Adaptees, 즉 Adaptee 자체와 모든 하위 클래스 (있는 경우)와 함께 작동하도록합시다. adapter는 한 번에 모든 어댑터에 기능을 추가 할 수도 있습니다.
+- Adaptee 동작을 오버라이드하기가 더 어렵습니다. Adaptee를 서브 클래싱하고 어댑터가 Adaptee 자체가 아닌 서브 클래스를 참조하도록 해야합니다.
+
+## 실제 사례
+
+- [java.util.Arrays#asList()](http://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#asList%28T...%29)
+- [java.util.Collections#list()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#list-java.util.Enumeration-)
+- [java.util.Collections#enumeration()](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html#enumeration-java.util.Collection-)
+- [javax.xml.bind.annotation.adapters.XMLAdapter](http://docs.oracle.com/javase/8/docs/api/javax/xml/bind/annotation/adapters/XmlAdapter.html#marshal-BoundType-)
+
+## 크레딧
+
+- [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+- [J2EE Design Patterns](https://www.amazon.com/gp/product/0596004273/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596004273&linkCode=as2&tag=javadesignpat-20&linkId=48d37c67fb3d845b802fa9b619ad8f31)
+- [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
+- [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)
diff --git a/ko/factory/README.md b/ko/factory/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d020a9edd64c4c26537832c1404d1f6d2b58f9c0
--- /dev/null
+++ b/ko/factory/README.md
@@ -0,0 +1,128 @@
+---
+layout: pattern
+title: Factory
+folder: factory
+permalink: "/patterns/factory/"
+categories: Creational
+tags:
+- Gang of Four
+---
+
+## 또한 ~으로 알려진
+
+- Simple Factory
+- Static Factory Method
+
+## 의도
+
+구현 논리를 숨기고 클라이언트 코드가 새 객체를 초기화하는 대신 사용에 집중하도록하기 위해 factory라는 클래스에 캡슐화 된 정적 메서드를 제공합니다.
+
+## 설명
+
+예시
+
+> SQLServer에 연결된 웹 응용 프로그램이 있지만 이제 Oracle로 전환하려고 합니다. 기존 소스 코드를 수정하지 않고 이를 수행하려면 주어진 데이터베이스에 대한 연결을 생성하기 위해 정적 메서드를 호출 할 수 있는 Simple Factory 패턴을 구현해야합니다.
+
+Wikipedia 말에 의하면
+
+> factory는 다른 객체를 생성하기위한 객체입니다. 공식적으로 factory는 다양한 프로토 타입 또는 클래스의 객체를 반환하는 함수 또는 메서드입니다.
+
+**프로그램 코드 예제**
+
+우리는 인터페이스 `Car` 와 두 가지 구현 `Ford` 와 `Ferrari`을 가지고 있습니다.
+
+```java
+public interface Car {
+ String getDescription();
+}
+
+public class Ford implements Car {
+
+ static final String DESCRIPTION = "This is Ford.";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+
+public class Ferrari implements Car {
+
+ static final String DESCRIPTION = "This is Ferrari.";
+
+ @Override
+ public String getDescription() {
+ return DESCRIPTION;
+ }
+}
+```
+
+열거형은 우리가 지원하는 자동차 유형을 나타냅니다 ( `Ford` 및 `Ferrari` ).
+
+```java
+public enum CarType {
+
+ FORD(Ford::new),
+ FERRARI(Ferrari::new);
+
+ private final Supplier constructor;
+
+ CarType(Supplier constructor) {
+ this.constructor = constructor;
+ }
+
+ public Supplier getConstructor() {
+ return this.constructor;
+ }
+}
+```
+
+그런 다음 factory 클래스 `CarsFactory` 캡슐화 된 자동차 객체를 만드는 정적 메서드 `getCar` 가 있습니다.
+
+```java
+public class CarsFactory {
+
+ public static Car getCar(CarType type) {
+ return type.getConstructor().get();
+ }
+}
+```
+
+이제 클라이언트 코드에서 factory 클래스를 사용하여 다양한 유형의 자동차를 만들 수 있습니다.
+
+```java
+var car1 = CarsFactory.getCar(CarType.FORD);
+var car2 = CarsFactory.getCar(CarType.FERRARI);
+LOGGER.info(car1.getDescription());
+LOGGER.info(car2.getDescription());;
+```
+
+프로그램 출력 :
+
+```java
+This is Ford.
+This Ferrari.
+```
+
+## 클래스 다이어그램
+
+![alt text](https://github.com/iluwatar/java-design-patterns/blob/master/factory/etc/factory.urm.png)
+
+## 적용 가능성
+
+객체 생성 및 관리 방법이 아닌 객체 생성에만 관심이있을 때 Simple Factory 패턴을 사용합니다.
+
+장점
+
+- 모든 객체 생성을 한곳에 유지하고 코드베이스에 '새'키 값이 확산되는 것을 방지합니다.
+- 느슨하게 결합 된 코드를 작성할 수 있습니다. 주요 장점 중 일부는 더 나은 테스트 가능성, 이해하기 쉬운 코드, 교체 가능한 구성 요소, 확장성 및 격리된 기능을 포함합니다.
+
+단점
+
+- 코드는 생각보다 복잡해집니다.
+
+## 관련 패턴
+
+- [Factory Method](https://java-design-patterns.com/patterns/factory-method/)
+- [Factory Kit](https://java-design-patterns.com/patterns/factory-kit/)
+- [Abstract Factory](https://java-design-patterns.com/patterns/abstract-factory/)
diff --git a/ko/observer/README.md b/ko/observer/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f27e3fbf3b2df866e867c0c1f3bc118c52e6841
--- /dev/null
+++ b/ko/observer/README.md
@@ -0,0 +1,165 @@
+---
+layout: pattern
+title: Observer
+folder: observer
+permalink: "/patterns/observer/"
+categories: Behavioral
+tags:
+- Gang Of Four
+- Reactive
+---
+
+## 또한 ~으로 알려진
+
+Dependents, Publish-Subscribe
+
+## 의도
+
+하나의 개체가 상태를 변경하면 모든 종속 항목에 알림이 전송되고 자동으로 업데이트 되도록 개체간의 일대 다 종속성을 정의합니다.
+
+## 설명
+
+예시
+
+> 멀리 떨어진 땅에는 호빗과 오크 종족이 살고 있습니다. 둘 다 대부분 야외에 있으므로 날씨 변화를 면밀히 따릅니다. 끊임없이 날씨를 관찰하고 있다고 말할 수 있습니다.
+
+평범하게 말하자면
+
+> observer로 등록하여 개체의 상태 변경을 수신합니다.
+
+Wikipedia 말에 의하면
+
+> observer 패턴은 주제라고하는 객체가 observer라고 하는 종속 항목 목록을 유지하고 일반적으로 메서드 중 하나를 호출하여 상태 변경을 자동으로 알리는 소프트웨어 디자인 패턴입니다.
+
+**프로그램 코드 예제**
+
+먼저 `WeatherObserver` 인터페이스와 우리의 종족 `Orcs` 와 `Hobbits` 소개하겠습니다.
+
+```java
+public interface WeatherObserver {
+
+ void update(WeatherType currentWeather);
+}
+
+public class Orcs implements WeatherObserver {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(Orcs.class);
+
+ @Override
+ public void update(WeatherType currentWeather) {
+ LOGGER.info("The orcs are facing " + currentWeather.getDescription() + " weather now");
+ }
+}
+
+public class Hobbits implements WeatherObserver {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(Hobbits.class);
+
+ @Override
+ public void update(WeatherType currentWeather) {
+ switch (currentWeather) {
+ LOGGER.info("The hobbits are facing " + currentWeather.getDescription() + " weather now");
+ }
+ }
+}
+```
+
+그리고 끊임없이 변화하는 `Weather` 가 있습니다.
+
+```java
+public class Weather {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(Weather.class);
+
+ private WeatherType currentWeather;
+ private final List observers;
+
+ public Weather() {
+ observers = new ArrayList<>();
+ currentWeather = WeatherType.SUNNY;
+ }
+
+ public void addObserver(WeatherObserver obs) {
+ observers.add(obs);
+ }
+
+ public void removeObserver(WeatherObserver obs) {
+ observers.remove(obs);
+ }
+
+ /**
+ * Makes time pass for weather.
+ */
+ public void timePasses() {
+ var enumValues = WeatherType.values();
+ currentWeather = enumValues[(currentWeather.ordinal() + 1) % enumValues.length];
+ LOGGER.info("The weather changed to {}.", currentWeather);
+ notifyObservers();
+ }
+
+ private void notifyObservers() {
+ for (var obs : observers) {
+ obs.update(currentWeather);
+ }
+ }
+}
+```
+
+여기에 전체 예제가 있습니다.
+
+```java
+ var weather = new Weather();
+ weather.addObserver(new Orcs());
+ weather.addObserver(new Hobbits());
+ weather.timePasses();
+ weather.timePasses();
+ weather.timePasses();
+ weather.timePasses();
+```
+
+프로그램 출력 :
+
+```
+The weather changed to rainy.
+The orcs are facing rainy weather now
+The hobbits are facing rainy weather now
+The weather changed to windy.
+The orcs are facing windy weather now
+The hobbits are facing windy weather now
+The weather changed to cold.
+The orcs are facing cold weather now
+The hobbits are facing cold weather now
+The weather changed to sunny.
+The orcs are facing sunny weather now
+The hobbits are facing sunny weather now
+```
+
+## 클래스 다이어그램
+
+![alt text](https://github.com/iluwatar/java-design-patterns/blob/master/observer/etc/observer.png)
+
+## 적용 가능성
+
+다음 상황에서 관찰자 패턴을 사용하십시오.
+
+- 추상화에 두 가지 측면이 있을 때 하나는 다른 하나에 종속됩니다. 이러한 측면을 별도의 개체에 캡슐화하면 독립적으로 변경하고 재사용 할 수 있습니다.
+- 한 개체를 변경하려면 얼마나 다른 개체를 변경해야 하는지 알 수 없는 경우입니다.
+- 개체가 다른 개체가 누구인지 가정하지 않고 알릴 수 있어야하는 경우. 즉, 개체가 단단히 결합되는 것을 원하지 않습니다.
+
+## 일반적인 사용 사례
+
+- 한 개체를 변경하면 다른 개체도 변경됩니다.
+
+## 실제 사례
+
+- [java.util.Observer](http://docs.oracle.com/javase/8/docs/api/java/util/Observer.html)
+- [java.util.EventListener](http://docs.oracle.com/javase/8/docs/api/java/util/EventListener.html)
+- [javax.servlet.http.HttpSessionBindingListener](http://docs.oracle.com/javaee/7/api/javax/servlet/http/HttpSessionBindingListener.html)
+- [RxJava](https://github.com/ReactiveX/RxJava)
+
+## 크레딧
+
+- [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+- [Java Generics and Collections](https://www.amazon.com/gp/product/0596527756/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596527756&linkCode=as2&tag=javadesignpat-20&linkId=246e5e2c26fe1c3ada6a70b15afcb195)
+- [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
+- [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)
diff --git a/ko/prototype/README.md b/ko/prototype/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d15e6daafbe5afda0ba9a7b7c91bc8232dfcce19
--- /dev/null
+++ b/ko/prototype/README.md
@@ -0,0 +1,87 @@
+---
+layout: pattern
+title: Prototype
+folder: prototype
+permalink: "/patterns/prototype/"
+categories: Creational
+tags:
+- Gang Of Four
+- Instantiation
+---
+
+## 의도
+
+prototype 인스턴스를 사용하여 만들 개체의 종류를 지정하고 prototype을 복사하여 새 개체를 만듭니다.
+
+## 설명
+
+먼저 성능 이점을 얻기 위해 prototype 패턴이 사용되지 않는다는 점에 유의해야합니다. 오직 prototype 인스턴스에서 새 개체를 만드는 데만 사용됩니다.
+
+예시
+
+> 복제된 양인 돌리에 대해 기억나십니까? 자세한 내용은 다루지 않겠습니다만 여기서 핵심은 복제에 관한 것입니다.
+
+평범한 말하자면
+
+> 복제를 통해 기존 개체를 기반으로 개체를 만듭니다.
+
+Wikipedia 말에 의하면
+
+> prototype 패턴은 소프트웨어 개발에서 생성 디자인 패턴입니다. 생성 할 개체의 유형이 새 개체를 생성하기 위해 복제되는 prototype 인스턴스에 의해 결정될 때 사용됩니다.
+
+간단히 말해, 객체를 처음부터 만들고 설정하는 문제를 겪는 대신 기존 객체의 복사본을 만들어 필요에 맞게 수정할 수 있습니다.
+
+**프로그램 코드 예제**
+
+Java에서는 `Cloneable` 을 구현하고 `Object` 에서 `clone` 을 오버라이딩하여 쉽게 수행 할 수 있습니다.
+
+```java
+class Sheep implements Cloneable {
+ private String name;
+ public Sheep(String name) { this.name = name; }
+ public void setName(String name) { this.name = name; }
+ public String getName() { return name; }
+ @Override
+ public Sheep clone() {
+ try {
+ return (Sheep)super.clone();
+ } catch(CloneNotSuportedException) {
+ throw new InternalError();
+ }
+ }
+}
+```
+
+그런 다음 아래와 같이 복제할 수 있습니다.
+
+```java
+var original = new Sheep("Jolly");
+System.out.println(original.getName()); // Jolly
+
+// Clone and modify what is required
+var cloned = original.clone();
+cloned.setName("Dolly");
+System.out.println(cloned.getName()); // Dolly
+```
+
+## 클래스 다이어그램
+
+![alt text](https://github.com/iluwatar/java-design-patterns/blob/master/prototype/etc/prototype.urm.png)
+
+## 적용 가능성
+
+시스템이 제품의 생성, 구성, 표현 및 표현 방식에 독립적이어야 할 때 prototype 패턴을 사용
+
+- 인스턴스화할 클래스가 런타임에 지정되는 경우 (예 : 동적 로딩)
+- 제품의 클래스 계층 구조와 유사한 팩토리의 클래스 계층 구조 구축을 방지해야할 경우
+- 클래스의 인스턴스가 몇 가지 다른 상태 조합 중 하나만 가질 수 있는 경우. 적절한 상태로 매번 클래스를 수동으로 인스턴스화하는 것보다 해당하는 수의 prototype을 설치하고 복제하는 것이 더 편리 할 수 있습니다.
+- 복제에 비해 개체 생성 비용이 많이 드는 경우.
+
+## 실제 사례
+
+- [java.lang.Object#clone()](https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html#clone%28%29)
+
+## 크레딧
+
+- [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+- [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
diff --git a/ko/singleton/README.md b/ko/singleton/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..8875e56eb8c9e33bbfa3573a992af2d8a246400c
--- /dev/null
+++ b/ko/singleton/README.md
@@ -0,0 +1,84 @@
+---
+layout: pattern
+title: Singleton
+folder: singleton
+permalink: "/patterns/singleton/"
+categories: Creational
+tags:
+- Gang of Four
+---
+
+## 의도
+
+클래스에 인스턴스가 하나만 있는지 확인하고 이에 대한 전역 access point을 제공합니다.
+
+## 설명
+
+예시
+
+> 마법사들이 마법을 연구하는 상아탑은 단 하나뿐입니다. 마법사는 항상 동일한 마법의 상아탑을 사용합니다. 여기서 상아탑은 singleton입니다.
+
+평범하게 말하자면
+
+> 특정 클래스의 개체가 하나만 생성되도록합니다.
+
+Wikipedia 말에 의하면
+
+> 소프트웨어 엔지니어링에서 singleton 패턴은 클래스의 인스턴스화를 하나의 객체로 제한하는 소프트웨어 디자인 패턴입니다. 이는 시스템 전체에서 작업을 조정하는 데 정확히 하나의 개체가 필요할 때 유용합니다.
+
+**프로그램 코드 예제**
+
+Joshua Bloch, Effective Java 2nd Edition p.18
+
+> 단일 요소 열거형은 singleton을 구현하는 가장 좋은 방법입니다.
+
+```java
+public enum EnumIvoryTower {
+ INSTANCE
+}
+```
+
+그런 다음 사용하려면 :
+
+```java
+var enumIvoryTower1 = EnumIvoryTower.INSTANCE;
+var enumIvoryTower2 = EnumIvoryTower.INSTANCE;
+assertEquals(enumIvoryTower1, enumIvoryTower2); // true
+```
+
+## 클래스 다이어그램
+
+![alt text](https://github.com/iluwatar/java-design-patterns/blob/master/singleton/etc/singleton.urm.png)
+
+## 적용 가능성
+
+다음과 같은 경우 Singleton 패턴을 사용합니다.
+
+- 정확히 하나의 클래스 인스턴스가 있어야하며 잘 알려진 access point에서 클라이언트에 접근할 수 있어야합니다.
+- 단일 인스턴스가 서브 클래싱으로 확장 가능해야하고 클라이언트가 코드를 수정하지 않고 확장 인스턴스를 사용할 수 있어야 하는 경우
+
+## 일반적인 사용 사례
+
+- 로깅 클래스
+- 데이터베이스에 대한 연결 관리
+- 파일 관리자
+
+## 실제 사례
+
+- [java.lang.Runtime#getRuntime()](http://docs.oracle.com/javase/8/docs/api/java/lang/Runtime.html#getRuntime%28%29)
+- [java.awt.Desktop#getDesktop()](http://docs.oracle.com/javase/8/docs/api/java/awt/Desktop.html#getDesktop--)
+- [java.lang.System#getSecurityManager()](http://docs.oracle.com/javase/8/docs/api/java/lang/System.html#getSecurityManager--)
+
+## 결과
+
+- 자체 생성 및 수명주기를 제어하여 SRP (Single Responsibility Principle)를 위반합니다.
+- 이 개체가 사용하는 개체와 리소스가 할당 해제되는 것을 방지하는 전역 공유 인스턴스를 사용하도록 권장합니다.
+- 밀접하게 연결된 코드를 만듭니다. Singleton의 클라이언트는 테스트하기가 어려워집니다.
+- Singleton의 하위 클래스를 만드는 것이 거의 불가능합니다.
+
+## 크레딧
+
+- [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/gp/product/0201633612/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0201633612&linkCode=as2&tag=javadesignpat-20&linkId=675d49790ce11db99d90bde47f1aeb59)
+- [Effective Java](https://www.amazon.com/gp/product/0134685997/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0134685997&linkCode=as2&tag=javadesignpat-20&linkId=4e349f4b3ff8c50123f8147c828e53eb)
+- [Head First Design Patterns: A Brain-Friendly Guide](https://www.amazon.com/gp/product/0596007124/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596007124&linkCode=as2&tag=javadesignpat-20&linkId=6b8b6eea86021af6c8e3cd3fc382cb5b)
+- [Refactoring to Patterns](https://www.amazon.com/gp/product/0321213351/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0321213351&linkCode=as2&tag=javadesignpat-20&linkId=2a76fcb387234bc71b1c61150b3cc3a7)