Java 제네릭(Generic)은 코드의 재사용성을 높이고, 컴파일 타임에 타입 안전성을 보장하기 위해 도입된 기능입니다. 이를 통해 클래스, 인터페이스, 메서드 등을 다양한 타입으로 사용할 수 있습니다.
1. 타입 파라미터 (Type Parameter)
타입 파라미터는 제네릭 클래스나 메서드의 정의에서 사용됩니다. 이는 구체적인 타입을 지정하지 않고, 사용할 때마다 다른 타입을 지정할 수 있게 합니다.
예제
public class Box<T> {
private T content;
public void setContent(T content) {
this.content = content;
}
public T getContent() {
return content;
}
public static void main(String[] args) {
Box<String> stringBox = new Box<>();
stringBox.setContent("Hello");
System.out.println(stringBox.getContent());
Box<Integer> integerBox = new Box<>();
integerBox.setContent(123);
System.out.println(integerBox.getContent());
}
}
2. 와일드카드 (Wildcard)
와일드카드는 제네릭 타입을 사용할 때, 특정 타입을 제한하거나 불특정 타입을 허용할 때 사용됩니다. ? 기호를 사용합니다.
예제
- Unbounded Wildcard: 제한이 없는 와일드카드
public void printList(List<?> list) {
for (Object elem : list) {
System.out.println(elem);
}
}
- Bounded Wildcard: 특정 상위 타입을 제한하는 와일드카드
public void printList(List<? extends Number> list) {
for (Number num : list) {
System.out.println(num);
}
}
- Lower Bounded Wildcard: 특정 하위 타입을 제한하는 와일드카드
public void addNumbers(List<? super Integer> list) {
list.add(1);
list.add(2);
}
3. 타입 소거 (Type Erasure)
타입 소거(Type Erasure)는 Java 제네릭이 컴파일 시점에 타입 정보를 제거하는 방식입니다. 이는 제네릭 타입이 런타임에 타입 정보를 갖지 않도록 합니다.
예제
public class ErasureExample {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("Hello");
// 런타임 시점에는 List<String>이 List로 변환됩니다.
if (list instanceof ArrayList) {
System.out.println("ArrayList instance");
}
}
}
4. 장점
- 타입 안전성: 컴파일 타임에 타입 검사를 수행하여 타입 오류를 방지합니다.
- 재사용성: 동일한 코드 베이스를 여러 타입에 대해 사용할 수 있습니다.
- 가독성: 코드의 가독성을 높여, 어떤 타입이 사용되는지 명확히 알 수 있습니다.
5. 단점
- 복잡성: 제네릭의 사용과 제한사항을 완전히 이해하는 데 시간이 필요합니다.
- 타입 소거: 런타임에 타입 정보가 소거되어 일부 기능 구현이 제한될 수 있습니다.
- 제약 사항: 기본 타입(primitive type)을 직접 사용할 수 없고, 특정 타입 제한 등의 제약 사항이 있습니다.
6. 제네릭 메서드
제네릭 메서드는 메서드 레벨에서 타입 파라미터를 정의할 수 있습니다.
예제
public class GenericMethodExample {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.println(element);
}
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"A", "B", "C"};
printArray(intArray);
printArray(strArray);
}
}
결론
Java 제네릭은 코드의 재사용성을 높이고, 타입 안전성을 보장하는 강력한 도구입니다. 타입 파라미터, 와일드카드, 타입 소거 등의 개념을 통해 다양한 타입을 안전하게 처리할 수 있습니다. 이를 올바르게 사용하면 코드의 가독성과 유지보수성을 크게 향상시킬 수 있습니다. 다만, 제네릭의 제한 사항과 타입 소거로 인한 런타임 제약을 잘 이해하고 사용하는 것이 중요합니다.
java generic에 관해서(주제)
나는 새로운 것에 흥미를 느끼는 편인데 좀 새롭거나 좀 더 어려운 내용이나 필요한 다른 내용 추천 해줘
Java 제네릭을 깊이 이해하고 활용하려면, 기본적인 내용에서 더 나아가 고급 주제와 실전 활용 사례를 다루는 것이 좋습니다. 다음은 좀 더 새롭고 복잡한 내용을 포함한 주제들입니다.
1. 고급 와일드카드 사용법
캡처-도우미 메서드 (Capture Helper Method)
Java 컴파일러는 때로는 와일드카드의 실제 타입을 "캡처"할 수 없습니다. 이러한 경우, 캡처-도우미 메서드를 사용하여 이 문제를 해결할 수 있습니다.
import java.util.List;
public class WildcardExample {
// 캡처-도우미 메서드 사용 전
public static void swapFirst(List<?> list) {
swapHelper(list);
}
private static <T> void swapHelper(List<T> list) {
if (list.size() > 1) {
T temp = list.get(0);
list.set(0, list.get(1));
list.set(1, temp);
}
}
public static void main(String[] args) {
List<String> list = List.of("A", "B", "C");
swapFirst(list);
System.out.println(list);
}
}
2. 재귀적 제네릭 바운드 (Recursive Generics Bound)
재귀적 제네릭 바운드는 자기 자신을 타입 파라미터로 사용하는 경우입니다. 이는 주로 Comparable 인터페이스와 같이 비교할 때 유용합니다.
public class ComparableExample<T extends Comparable<T>> implements Comparable<ComparableExample<T>> {
private T value;
public ComparableExample(T value) {
this.value = value;
}
@Override
public int compareTo(ComparableExample<T> other) {
return value.compareTo(other.value);
}
public static void main(String[] args) {
ComparableExample<Integer> a = new ComparableExample<>(1);
ComparableExample<Integer> b = new ComparableExample<>(2);
System.out.println(a.compareTo(b)); // -1 출력
}
}
3. 제네릭 타입 인스턴스 생성
Java는 타입 소거 때문에 제네릭 타입의 인스턴스를 직접 생성할 수 없습니다. 하지만, 리플렉션을 사용하면 이 문제를 해결할 수 있습니다.
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class GenericInstance<T> {
private Class<T> type;
@SuppressWarnings("unchecked")
public GenericInstance() {
Type t = getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) t;
type = (Class<T>) pt.getActualTypeArguments()[0];
}
public T createInstance() throws InstantiationException, IllegalAccessException {
return type.newInstance();
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
GenericInstance<String> instance = new GenericInstance<String>() {};
String str = instance.createInstance();
System.out.println(str); // 빈 문자열 출력
}
}
4. 제네릭과 리플렉션
리플렉션과 제네릭을 함께 사용하면 런타임에 타입 정보를 다룰 수 있습니다. 이는 동적 타입 체크와 같은 고급 기능을 구현하는 데 유용합니다.
import java.lang.reflect.Field;
public class GenericReflectionExample<T> {
private T value;
public GenericReflectionExample(T value) {
this.value = value;
}
public void printType() {
Field field = getClass().getDeclaredFields()[0];
System.out.println("Type: " + field.getGenericType());
}
public static void main(String[] args) {
GenericReflectionExample<String> example = new GenericReflectionExample<>("Hello");
example.printType(); // 출력: Type: T
}
}
5. 제네릭을 활용한 빌더 패턴
빌더 패턴을 제네릭과 함께 사용하면, 더 유연하고 타입 안전한 빌더를 만들 수 있습니다.
public class GenericBuilder<T> {
private T instance;
public GenericBuilder(Class<T> clazz) throws InstantiationException, IllegalAccessException {
this.instance = clazz.newInstance();
}
public <U> GenericBuilder<T> with(GenericSetter<T, U> setter, U value) {
setter.set(instance, value);
return this;
}
public T build() {
return instance;
}
public interface GenericSetter<T, U> {
void set(T instance, U value);
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException {
class Person {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + '}';
}
}
Person person = new GenericBuilder<>(Person.class)
.with(Person::setName, "John")
.with(Person::setAge, 30)
.build();
System.out.println(person); // 출력: Person{name='John', age=30}
}
}
6. 고급 제네릭 활용 패턴: 커링(Currying)
커링은 함수형 프로그래밍에서 유래된 개념으로, 여러 인수를 갖는 함수를 단일 인수를 갖는 함수의 연속으로 변환하는 것을 말합니다. 제네릭을 사용하여 커링 패턴을 구현할 수 있습니다.
import java.util.function.Function;
public class CurryingExample {
public static void main(String[] args) {
Function<Integer, Function<Integer, Integer>> add = x -> y -> x + y;
Function<Integer, Integer> add5 = add.apply(5);
System.out.println(add5.apply(10)); // 출력: 15
}
}
결론
이러한 고급 제네릭 주제와 패턴은 Java 제네릭의 깊이와 가능성을 보여줍니다. 제네릭을 사용하면 코드의 재사용성과 타입 안전성을 극대화할 수 있으며, 다양한 프로그래밍 패러다임을 지원할 수 있습니다. 이를 잘 활용하면 더욱 유연하고 강력한 소프트웨어를 개발할 수 있습니다.
@Override
public int compareTo(ComparableExample<T> other) { return value.compareTo(other.value); }에서 파라미터로 자기 자신을 쓰기 때문에 재귀적이다 라는 말은 쓴거지? 이건 디자인 패턴이기 보단 용법에 가깝겠네
맞습니다, Comparable<T> 인터페이스를 구현할 때 사용되는 재귀적 제네릭 바운드는 디자인 패턴이라기보다는 제네릭의 사용법 중 하나입니다. 이는 특정 타입이 자기 자신과 비교될 수 있도록 하는 용법입니다. 좀 더 정확히 설명하자면, 재귀적 제네릭 바운드는 제네릭 타입 파라미터가 자신을 상위 타입으로 사용하는 경우를 의미합니다. 이 용법은 주로 타입 안전성을 높이고, 특정 인터페이스를 구현할 때 유용하게 사용됩니다.
다음은 재귀적 제네릭 바운드와 관련된 더 깊은 내용과 다른 고급 주제를 다루겠습니다.
1. 재귀적 제네릭 바운드 (Recursive Generics Bound)
재귀적 제네릭 바운드는 주로 Comparable, Enum, Self-Bounded Type과 같은 인터페이스를 구현할 때 사용됩니다.
예제: Comparable 인터페이스
Comparable<T> 인터페이스는 제네릭 타입 파라미터 T를 사용하여 자신과 같은 타입의 객체를 비교할 수 있도록 합니다.
public class ComparableExample<T extends Comparable<T>> implements Comparable<ComparableExample<T>> {
private T value;
public ComparableExample(T value) {
this.value = value;
}
@Override
public int compareTo(ComparableExample<T> other) {
return value.compareTo(other.value);
}
public static void main(String[] args) {
ComparableExample<Integer> a = new ComparableExample<>(1);
ComparableExample<Integer> b = new ComparableExample<>(2);
System.out.println(a.compareTo(b)); // -1 출력
}
}
여기서 ComparableExample<T> 클래스는 Comparable<ComparableExample<T>> 인터페이스를 구현하며, 이는 재귀적 제네릭 바운드의 예시입니다. 이 경우 T 타입은 반드시 Comparable<T>를 구현해야 합니다.
2. Self-Bounded Type
Self-Bounded Type은 특정 타입이 자신을 타입 파라미터로 사용하여 타입 안전성을 높이는 용법입니다. 이는 Enum 클래스에서 주로 사용됩니다.
예제: Enum 클래스
public abstract class MyEnum<E extends MyEnum<E>> implements Comparable<E> {
private String name;
protected MyEnum(String name) {
this.name = name;
}
@Override
public int compareTo(E other) {
return name.compareTo(other.name());
}
public String name() {
return name;
}
}
3. 제네릭 메서드의 고급 활용
제네릭 메서드는 메서드 레벨에서 제네릭 타입을 정의할 수 있습니다. 이는 메서드가 호출될 때 타입을 지정할 수 있게 합니다.
예제: 제네릭 메서드
public class Utility {
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.println(element);
}
}
public static <T extends Comparable<T>> T findMax(T[] array) {
T max = array[0];
for (T element : array) {
if (element.compareTo(max) > 0) {
max = element;
}
}
return max;
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"A", "B", "C"};
Utility.printArray(intArray); // 1 2 3 4 5 출력
Utility.printArray(strArray); // A B C 출력
System.out.println("Max: " + Utility.findMax(intArray)); // Max: 5 출력
System.out.println("Max: " + Utility.findMax(strArray)); // Max: C 출력
}
}
4. 제네릭을 활용한 컨테이너 클래스
제네릭을 사용하여 다양한 타입을 지원하는 컨테이너 클래스를 구현할 수 있습니다. 이는 데이터 구조와 알고리즘을 타입에 독립적으로 설계할 수 있게 합니다.
예제: 제네릭 스택
public class GenericStack<T> {
private Node<T> top;
private static class Node<T> {
private T data;
private Node<T> next;
public Node(T data) {
this.data = data;
}
}
public void push(T item) {
Node<T> t = new Node<>(item);
t.next = top;
top = t;
}
public T pop() {
if (top == null) throw new EmptyStackException();
T item = top.data;
top = top.next;
return item;
}
public T peek() {
if (top == null) throw new EmptyStackException();
return top.data;
}
public boolean isEmpty() {
return top == null;
}
public static void main(String[] args) {
GenericStack<Integer> stack = new GenericStack<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println(stack.pop()); // 3 출력
System.out.println(stack.peek()); // 2 출력
System.out.println(stack.isEmpty()); // false 출력
}
}
결론
재귀적 제네릭 바운드, Self-Bounded Type, 제네릭 메서드, 제네릭 컨테이너 클래스 등 고급 제네릭 활용법은 Java 제네릭의 깊이를 더합니다. 이러한 기법들은 타입 안전성을 유지하면서도 유연하고 재사용 가능한 코드를 작성하는 데 도움이 됩니다. 이를 통해 코드의 가독성과 유지보수성을 높일 수 있으며, 다양한 타입을 안전하게 처리할 수 있습니다.
제네릭 타입 인스턴스 생성
제네릭은 런타임 때 보통 타입이 정해지기 때문에 컴파일 단계에서는 타입을 거의 알 수 가 없지. 그래서 런타임 단계에서 코드를 구동하고 수정하는 리플랙션으로 제네릭 인스턴스를 실행하면 타입이 정해지기도 하고 인스턴스가 생성이 되겟네
맞습니다. 제네릭은 타입 소거(Type Erasure)로 인해 컴파일 단계에서는 타입 정보를 유지하지 않지만, 런타임에서는 리플렉션(Reflection)을 사용하여 타입 정보를 다룰 수 있습니다. 이를 통해 제네릭 인스턴스를 생성하고 조작할 수 있습니다. 여기서는 리플렉션을 사용하여 제네릭 타입 인스턴스를 생성하는 예제를 살펴보겠습니다.
제네릭 타입 인스턴스 생성
리플렉션을 사용하면 런타임에 타입 정보를 얻고, 이를 바탕으로 제네릭 타입의 인스턴스를 생성할 수 있습니다.
예제 1: 기본적인 리플렉션을 사용한 제네릭 인스턴스 생성
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
public class GenericInstance<T> {
private Class<T> type;
@SuppressWarnings("unchecked")
public GenericInstance() {
Type t = getClass().getGenericSuperclass();
if (t instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) t;
type = (Class<T>) pt.getActualTypeArguments()[0];
}
}
public T createInstance() throws InstantiationException, IllegalAccessException {
return type.newInstance();
}
public static void main(String[] args) {
try {
GenericInstance<String> instance = new GenericInstance<String>() {};
String str = instance.createInstance();
System.out.println("Created instance of type: " + str.getClass().getName()); // Created instance of type: java.lang.String
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
위 예제에서는 GenericInstance<T> 클래스가 제네릭 타입의 인스턴스를 생성하기 위해 리플렉션을 사용합니다. 클래스의 GenericSuperclass를 통해 제네릭 타입 정보를 얻고, newInstance() 메서드를 통해 인스턴스를 생성합니다.
예제 2: 제네릭 타입을 가진 컨테이너 클래스
제네릭 타입을 가진 컨테이너 클래스에서 리플렉션을 사용하여 제네릭 타입의 인스턴스를 생성하는 방법도 있습니다.
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
public class GenericContainer<T> {
private Class<T> type;
@SuppressWarnings("unchecked")
public GenericContainer() {
Type t = getClass().getGenericSuperclass();
if (t instanceof ParameterizedType) {
ParameterizedType pt = (ParameterizedType) t;
type = (Class<T>) pt.getActualTypeArguments()[0];
}
}
public T createInstance() throws InstantiationException, IllegalAccessException {
return type.newInstance();
}
public List<T> createList() throws InstantiationException, IllegalAccessException {
List<T> list = new ArrayList<>();
list.add(createInstance());
return list;
}
public static void main(String[] args) {
try {
GenericContainer<String> container = new GenericContainer<String>() {};
String str = container.createInstance();
System.out.println("Created instance of type: " + str.getClass().getName()); // Created instance of type: java.lang.String
List<String> list = container.createList();
System.out.println("Created list with element of type: " + list.get(0).getClass().getName()); // Created list with element of type: java.lang.String
} catch (InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
이 예제에서는 GenericContainer<T> 클래스가 제네릭 타입의 인스턴스를 생성하고, 이를 리스트에 추가하는 방법을 보여줍니다. 리플렉션을 사용하여 제네릭 타입 정보를 얻고, newInstance() 메서드를 통해 인스턴스를 생성한 후, 리스트에 추가합니다.
결론
리플렉션을 사용하여 제네릭 타입의 인스턴스를 생성하는 방법은 런타임에 타입 정보를 다루는 유용한 기술입니다. 이를 통해 제네릭 타입을 동적으로 생성하고 조작할 수 있습니다. 다만, 리플렉션은 성능에 영향을 미칠 수 있으므로 필요한 경우에만 사용하는 것이 좋습니다. 이러한 기법은 프레임워크나 라이브러리 개발, 또는 동적 객체 생성이 필요한 상황에서 유용하게 사용될 수 있습니다.
제네릭을 활용한 빌더 패턴에 관해 더 다양하고 자세하게 설명해줘
제네릭을 활용한 빌더 패턴은 객체 생성 시 유연성과 가독성을 높이기 위한 디자인 패턴입니다. 빌더 패턴은 복잡한 객체를 단계적으로 생성할 수 있게 하며, 제네릭을 사용하면 더 강력하고 타입 안전한 빌더를 만들 수 있습니다. 여기서는 제네릭 빌더 패턴의 다양한 예제와 구현 방법을 자세히 설명하겠습니다.
1. 기본적인 제네릭 빌더 패턴
기본 빌더 패턴
기본 빌더 패턴에서는 객체를 생성하기 위해 여러 설정 메서드를 호출한 후, 최종적으로 build() 메서드를 호출하여 객체를 생성합니다.
public class Product {
private String name;
private double price;
private Product(Builder builder) {
this.name = builder.name;
this.price = builder.price;
}
public static class Builder {
private String name;
private double price;
public Builder setName(String name) {
this.name = name;
return this;
}
public Builder setPrice(double price) {
this.price = price;
return this;
}
public Product build() {
return new Product(this);
}
}
@Override
public String toString() {
return "Product{name='" + name + "', price=" + price + '}';
}
public static void main(String[] args) {
Product product = new Product.Builder()
.setName("Laptop")
.setPrice(999.99)
.build();
System.out.println(product);
}
}
2. 제네릭을 활용한 빌더 패턴
제네릭을 사용하면 빌더 패턴을 더 유연하고 재사용 가능하게 만들 수 있습니다. 특히, 상속 구조를 가진 객체를 생성할 때 유용합니다.
제네릭 빌더 패턴
public class Computer {
private String CPU;
private int RAM;
protected Computer(Builder<?> builder) {
this.CPU = builder.CPU;
this.RAM = builder.RAM;
}
public static class Builder<T extends Builder<T>> {
private String CPU;
private int RAM;
public T setCPU(String CPU) {
this.CPU = CPU;
return self();
}
public T setRAM(int RAM) {
this.RAM = RAM;
return self();
}
protected T self() {
return (T) this;
}
public Computer build() {
return new Computer(this);
}
}
@Override
public String toString() {
return "Computer{CPU='" + CPU + "', RAM=" + RAM + '}';
}
}
public class GamingComputer extends Computer {
private String GPU;
private GamingComputer(Builder builder) {
super(builder);
this.GPU = builder.GPU;
}
public static class Builder extends Computer.Builder<Builder> {
private String GPU;
public Builder setGPU(String GPU) {
this.GPU = GPU;
return this;
}
@Override
protected Builder self() {
return this;
}
@Override
public GamingComputer build() {
return new GamingComputer(this);
}
}
@Override
public String toString() {
return "GamingComputer{" + "CPU='" + CPU + "', RAM=" + RAM + ", GPU='" + GPU + "'}";
}
public static void main(String[] args) {
GamingComputer gamingComputer = new GamingComputer.Builder()
.setCPU("Intel i9")
.setRAM(32)
.setGPU("NVIDIA RTX 3080")
.build();
System.out.println(gamingComputer);
}
}
3. 고급 제네릭 빌더 패턴
Fluent API와 제네릭 빌더
플루언트 API 스타일을 사용하면 메서드 체이닝을 통해 더 읽기 쉽고 직관적인 코드를 작성할 수 있습니다.
public class House {
private String foundation;
private String structure;
private String roof;
private House(Builder builder) {
this.foundation = builder.foundation;
this.structure = builder.structure;
this.roof = builder.roof;
}
public static class Builder<T extends Builder<T>> {
private String foundation;
private String structure;
private String roof;
public T setFoundation(String foundation) {
this.foundation = foundation;
return self();
}
public T setStructure(String structure) {
this.structure = structure;
return self();
}
public T setRoof(String roof) {
this.roof = roof;
return self();
}
protected T self() {
return (T) this;
}
public House build() {
return new House(this);
}
}
@Override
public String toString() {
return "House{" +
"foundation='" + foundation + '\\\\'' +
", structure='" + structure + '\\\\'' +
", roof='" + roof + '\\\\'' +
'}';
}
}
public class Villa extends House {
private String pool;
private Villa(Builder builder) {
super(builder);
this.pool = builder.pool;
}
public static class Builder extends House.Builder<Builder> {
private String pool;
public Builder setPool(String pool) {
this.pool = pool;
return this;
}
@Override
protected Builder self() {
return this;
}
@Override
public Villa build() {
return new Villa(this);
}
}
@Override
public String toString() {
return "Villa{" +
"foundation='" + foundation + '\\\\'' +
", structure='" + structure + '\\\\'' +
", roof='" + roof + '\\\\'' +
", pool='" + pool + '\\\\'' +
'}';
}
public static void main(String[] args) {
Villa villa = new Villa.Builder()
.setFoundation("Concrete")
.setStructure("Brick")
.setRoof("Tile")
.setPool("Infinity Pool")
.build();
System.out.println(villa);
}
}
4. 제네릭과 리플렉션을 사용한 빌더 패턴
제네릭과 리플렉션을 결합하여 더 유연한 빌더를 만들 수 있습니다. 예를 들어, 빌더에서 자동으로 필드 값을 설정하는 방법을 구현할 수 있습니다.
import java.lang.reflect.Field;
public class ReflectionBuilder<T> {
private T instance;
public ReflectionBuilder(Class<T> clazz) throws IllegalAccessException, InstantiationException {
instance = clazz.newInstance();
}
public ReflectionBuilder<T> with(String fieldName, Object value) throws NoSuchFieldException, IllegalAccessException {
Field field = instance.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(instance, value);
return this;
}
public T build() {
return instance;
}
public static void main(String[] args) {
try {
Product product = new ReflectionBuilder<>(Product.class)
.with("name", "Smartphone")
.with("price", 699.99)
.build();
System.out.println(product);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Product {
private String name;
private double price;
@Override
public String toString() {
return "Product{name='" + name + "', price=" + price + '}';
}
}
결론
제네릭을 활용한 빌더 패턴은 객체 생성의 유연성과 타입 안전성을 크게 향상시킬 수 있습니다. 제네릭을 사용하면 다양한 타입을 지원하는 빌더를 쉽게 만들 수 있으며, 리플렉션을 활용하면 빌더의 유연성을 극대화할 수 있습니다. 이러한 고급 빌더 패턴은 복잡한 객체 생성 로직을 단순화하고, 가독성을 높이는 데 매우 유용합니다.
플루언트 API 스타일이 뭐야?
플루언트 API(Fluent API) 스타일은 메서드 체이닝(Method Chaining)을 통해 코드를 더 읽기 쉽고 직관적으로 작성할 수 있게 하는 프로그래밍 스타일입니다. 주로 객체 설정이나 복잡한 쿼리 빌더 등에서 많이 사용됩니다. 플루언트 API는 메서드 호출을 연쇄적으로 이어나갈 수 있도록 설계되며, 이를 통해 코드의 가독성을 크게 향상시킬 수 있습니다.
플루언트 API의 특징
- 메서드 체이닝(Method Chaining): 각 메서드 호출이 객체 자신을 반환하여 연속적인 메서드 호출을 가능하게 합니다.
- 가독성: 플루언트 API는 자연어처럼 읽히도록 설계되어 코드의 가독성을 높입니다.
- 유연성: 다양한 설정을 간단하고 명확하게 할 수 있도록 지원합니다.
예제: 빌더 패턴에서의 플루언트 API
빌더 패턴에서 플루언트 API를 사용하여 객체를 구성하는 예제를 살펴보겠습니다.
public class Car {
private String engine;
private String color;
private int doors;
private Car(Builder builder) {
this.engine = builder.engine;
this.color = builder.color;
this.doors = builder.doors;
}
public static class Builder {
private String engine;
private String color;
private int doors;
public Builder setEngine(String engine) {
this.engine = engine;
return this;
}
public Builder setColor(String color) {
this.color = color;
return this;
}
public Builder setDoors(int doors) {
this.doors = doors;
return this;
}
public Car build() {
return new Car(this);
}
}
@Override
public String toString() {
return "Car{" +
"engine='" + engine + '\\\\'' +
", color='" + color + '\\\\'' +
", doors=" + doors +
'}';
}
public static void main(String[] args) {
Car car = new Car.Builder()
.setEngine("V8")
.setColor("Red")
.setDoors(2)
.build();
System.out.println(car);
}
}
위 예제에서 Car.Builder 클래스는 플루언트 API 스타일로 설계되었습니다. 각 설정 메서드(setEngine, setColor, setDoors)는 Builder 객체 자신을 반환하여, 연쇄적으로 메서드를 호출할 수 있습니다.
장점
- 가독성 향상: 메서드 체이닝을 통해 코드를 자연스럽게 읽을 수 있습니다.
- 유지보수성: 코드가 더 직관적이기 때문에 유지보수가 쉬워집니다.
- 유연성: 다양한 설정을 간단하게 할 수 있어, 객체 생성 시 많은 매개변수를 가질 때 유리합니다.
단점
- 디버깅 어려움: 체이닝된 메서드 호출 중 어느 부분에서 오류가 발생했는지 찾기 어려울 수 있습니다.
- 추가 메서드: 체이닝을 위해 각 메서드가 자기 자신을 반환해야 하므로, 클래스가 약간 더 복잡해질 수 있습니다.
플루언트 API의 다른 예제
스트림 API
Java 8의 스트림 API는 플루언트 API의 좋은 예입니다.
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> filteredNames = names.stream()
.filter(name -> name.startsWith("A"))
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(filteredNames); // [ALICE]
}
}
위 예제에서 filter, map, collect 메서드는 모두 체이닝 방식으로 호출됩니다.
결론
플루언트 API 스타일은 가독성과 유지보수성을 향상시키기 위한 프로그래밍 기법입니다. 주로 메서드 체이닝을 통해 코드가 자연스럽게 읽히도록 설계되며, 이를 통해 복잡한 객체 생성이나 설정을 간단하게 할 수 있습니다. 플루언트 API는 빌더 패턴, 스트림 API 등에서 자주 사용되며, 이를 적절히 활용하면 더 직관적이고 읽기 쉬운 코드를 작성할 수 있습니다.
아 먼가 했는데 체이닝 메서드가 플루언트 API패턴이엿네
맞습니다. 체이닝 메서드(Method Chaining)는 플루언트 API(Fluent API) 패턴의 핵심 개념 중 하나입니다. 이 패턴을 사용하면 메서드 호출을 연속적으로 이어나갈 수 있어, 더 직관적이고 가독성이 높은 코드를 작성할 수 있습니다. 이제 플루언트 API 패턴에 대해 좀 더 깊이 있게 설명하고, 몇 가지 추가 예제를 살펴보겠습니다.
플루언트 API 패턴
플루언트 API 패턴은 주로 다음과 같은 특징을 갖습니다:
- 메서드 체이닝: 각 메서드 호출이 객체 자신을 반환하여 연속적인 메서드 호출이 가능하게 합니다.
- 읽기 쉬운 코드: 자연어처럼 읽히도록 설계되어 코드의 가독성을 높입니다.
- 단계별 설정: 객체를 단계별로 설정할 수 있어, 복잡한 객체를 쉽게 구성할 수 있습니다.
플루언트 API 패턴의 예제
1. 빌더 패턴
빌더 패턴에서 플루언트 API를 사용하여 객체를 구성하는 예제입니다.
public class Car {
private String engine;
private String color;
private int doors;
private Car(Builder builder) {
this.engine = builder.engine;
this.color = builder.color;
this.doors = builder.doors;
}
public static class Builder {
private String engine;
private String color;
private int doors;
public Builder setEngine(String engine) {
this.engine = engine;
return this;
}
public Builder setColor(String color) {
this.color = color;
return this;
}
public Builder setDoors(int doors) {
this.doors = doors;
return this;
}
public Car build() {
return new Car(this);
}
}
@Override
public String toString() {
return "Car{" +
"engine='" + engine + '\\\\'' +
", color='" + color + '\\\\'' +
", doors=" + doors +
'}';
}
public static void main(String[] args) {
Car car = new Car.Builder()
.setEngine("V8")
.setColor("Red")
.setDoors(2)
.build();
System.out.println(car);
}
}
위 예제에서는 Builder 클래스의 각 메서드가 this를 반환하여 메서드 체이닝이 가능하게 합니다. 이를 통해 객체를 단계별로 구성할 수 있습니다.
2. 스트림 API
Java 8의 스트림 API는 플루언트 API 패턴의 좋은 예입니다. 데이터를 필터링, 변환, 수집하는 작업을 체이닝된 메서드 호출로 처리할 수 있습니다.
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> filteredNames = names.stream()
.filter(name -> name.startsWith("A"))
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(filteredNames); // [ALICE]
}
}
위 예제에서는 filter, map, collect 메서드가 체이닝되어 연속적인 데이터 처리 작업을 수행합니다.
3. 설정 클래스
플루언트 API를 사용하여 설정 클래스를 구현하면, 복잡한 설정을 더 읽기 쉽게 만들 수 있습니다.
public class DatabaseConfig {
private String url;
private String username;
private String password;
private DatabaseConfig(Builder builder) {
this.url = builder.url;
this.username = builder.username;
this.password = builder.password;
}
public static class Builder {
private String url;
private String username;
private String password;
public Builder setUrl(String url) {
this.url = url;
return this;
}
public Builder setUsername(String username) {
this.username = username;
return this;
}
public Builder setPassword(String password) {
this.password = password;
return this;
}
public DatabaseConfig build() {
return new DatabaseConfig(this);
}
}
@Override
public String toString() {
return "DatabaseConfig{" +
"url='" + url + '\\\\'' +
", username='" + username + '\\\\'' +
", password='" + password + '\\\\'' +
'}';
}
public static void main(String[] args) {
DatabaseConfig config = new DatabaseConfig.Builder()
.setUrl("jdbc:mysql://localhost:3306/mydb")
.setUsername("root")
.setPassword("password")
.build();
System.out.println(config);
}
}
위 예제에서는 DatabaseConfig 객체를 플루언트 API 스타일로 구성하여, 설정 값을 읽기 쉽게 설정할 수 있습니다.
결론
플루언트 API 패턴은 메서드 체이닝을 통해 코드를 더 읽기 쉽고 직관적으로 만드는 프로그래밍 스타일입니다. 이는 빌더 패턴, 스트림 API, 설정 클래스 등 다양한 곳에서 사용되며, 객체를 단계별로 설정하거나 복잡한 작업을 단순화하는 데 유용합니다. 플루언트 API를 적절히 활용하면 코드의 가독성과 유지보수성을 크게 향상시킬 수 있습니다.
'개인 개발 공부 일지' 카테고리의 다른 글
| Thread 사용법 및 코드예제 (1) | 2024.06.13 |
|---|---|
| Java Collection (0) | 2024.06.13 |
| Garbage Collector: minor GC vs full GC 과정과 차이점 (2) | 2024.06.10 |
| Java Stacktrace, 로그 관리 시스템, Elasticsearch (1) | 2024.05.29 |
| JVM (0) | 2024.05.29 |