[Java] Generic Method 제네릭 메소드

⭐제네릭 메소드(generic method)

 

• 제네릭 메소드란 메소드의 선언부에 타입 변수를 사용한 메소드를 의미
• 데이터 타입을 상속관계와 상관없이 다양하게 주고 싶을 때 사용한다.

 

• 형태
  • public class 클래스명<T> { ... }
  • public interface 인터페이스명<T> { ... } 

 

• 특징
  • 파라미터 타입이나 리턴 타입에 대한 정의를 외부로 미룸
  • 타입에 대한 안정성과 유연성 확보
  • 만약 최상위 클래스 Object로 매개변수를 받는다면 객체변수의 실제 인스턴스 필드나 메서드에 접근할때 형변환 필요하다.
  • 또한 Object 객체변수의 실제 인스턴스 필드나 메서드에 접근하기 위해 형변환을 잘못할 경우 컴파일러는 이를 잡지 못한다.

 

• 제너릭 장점
  
  • 데이터 형 변환 제거
  • 컴파일시 데이터 타입 체크 가능

 

예시 

import java.util.Objects;

public class GiftBox<T> {
    private T gift;

    public GiftBox() {
    }

    public GiftBox(T gift) {
        this.gift = gift;
    }

    public T getGift() {
        return gift;
    }

    public void setGift(T gift) {
        this.gift = gift;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        GiftBox<?> that = (GiftBox<?>) o;
        return gift.equals(that.gift);
    }

    @Override
    public int hashCode() {
        return Objects.hash(gift);
    }

    @Override
    public String toString() {
        return "RandomGiftBox{" +
                "gift=" + gift +
                '}';
    }
}

import me.day13.generic.basics.gift.Note;
import me.day13.generic.basics.gift.Pen;
import me.day13.generic.basics.gift.SmartPhone;
import me.day13.generic.basics.gift.Tablet;

    public class GenericExample {
        public static void main(String[] args) {
            GiftBox<Note> noteBox = new GiftBox<>();
            noteBox.setGift(new Note("1001", "모닝글로리", true));
            System.out.println("noteBox = " + noteBox);

            // 형 변환 후 사용해야 함
            noteBox.getGift().setHasLine(false); // 형변환 불필요.
//        ((Pen)noteBox.getGift()).setInkColor("빨강"); // 컴파일러 오류.
            System.out.println("noteBox = " + noteBox);
            System.out.println();

            GiftBox<Pen> penBox = new GiftBox<>();
            penBox.setGift(new Pen("2001", "모닝글로리", "검정"));
            System.out.println("penBox = " + penBox);

            penBox.getGift().setInkColor("파랑"); // 형변환 불필요.
            System.out.println("penBox = " + penBox);
            System.out.println();

            GiftBox<Tablet> tableBox = new GiftBox<>();
            tableBox.setGift(new Tablet("3001", "APPLE", "IPAD-AIR3", true));
            System.out.println("tableBox = " + tableBox);

            tableBox.getGift().setHasPencil(false);
            System.out.println("tableBox = " + tableBox);
            System.out.println();


            GiftBox<SmartPhone> smartPhoneBox = new GiftBox<>();
            smartPhoneBox.setGift(new SmartPhone("4001", "SAMSUNG", "Z-FOLD4", 3, 20));
            System.out.println("smartPhoneBox = " + smartPhoneBox);

            smartPhoneBox.getGift().setNumOfCameras(5);
            smartPhoneBox.getGift().setNumOfSensors(30);
            System.out.println("smartPhoneBox = " + smartPhoneBox);
            System.out.println();
        }
    }

 

• 멀티 타입 파라미터
  • 제너릭 타입은 두 개 이상 멀티 타입 파라미터 사용 가능
  • 형태

출처:&nbsp;https://devlog-wjdrbs96.tistory.com/201

제너릭 메서드에 대한 자세한 설명: https://devlog-wjdrbs96.tistory.com/201

 

예시 

public interface Utils {
    static <T> Box<T> boxing(T item) {

// <T>는 제너릭 메서드. 제너릭 메서드는 타입이 변하는 메서드. 만약 T에 Note가 들어오면 Note가 boxing되어서 Note타입의 Box가 반환되는것이다. 

<T> = 이 메서드가 제너릭 메서드 라고 의미

<T>  = 반환되는 Box 타입을 의미

T = 매개변수의 타입을 의미

따라서 이 메서드를 사용하면 boxing이 되고 이 반환box를 통해서 
        Box<T> box = new Box<>();
        box.setItem(item);
        return box;
    }

클래스에 제너릭 메서드를 사용하면 새로 객체를 생성할때 타입을 정해줄수 잇는데 인터페이스는 새로 객체를 생성을 못하기때문에 여기서 타입을 정해주는것이다. 

    static <T> void decoration(Box<T> box, Decorations decoration) {
        System.out.println(box + " is decorated with "+ decoration);
    }

    static <T> T unboxing(Box<T> box) {
        T item = box.getItem();
        return item;
    }
}

 

• 제한된 타입 파라미터
  • bounded type parameter
  • <타입 파라미터 extends 상위타입>
    • 상속 관계도에서 상위 타입 이하에 있는 타입이 파라미터로 올 수 있음
    • 상한 타입 제한
  • <타입 파라미터 super 하위타입>
    • 상속 관계도에서 하위 타입 이상에 있는 타입이 파라미터로 올 수 있음
    • 하한 타입 제한

import java.util.Arrays;
import java.util.Objects;

public class Gifts<E extends Item> {

    private static final int DEFULAT_SIZE = 10;
    private int size;

    private E[] gifts;
    private int count;

    public Gifts() {
        gifts = (E[]) new Item[DEFULAT_SIZE];
        this.size = DEFULAT_SIZE;
    }

    public Gifts(int size) {
        gifts = (E[]) new Item[size];
        this.size = size;
    }

    public E get(int i) {
        return gifts[i];
    }

    public void add(E element) { // 특정인덱스에 요소 추가하기
        if (count < size) {
            gifts[count] = element;
            count++;
        } else {
            E[] origin = Arrays.copyOf(gifts, count); 
            // Arrays.copy(배열, 개수) = 배열을 개수만큼 복사하는 함수
            size *= 2;
            gifts = Arrays.copyOf(origin, size);
            add(element);
        }
    }


    public void remove(E element) { // 특정인덱스값 삭제하기
        int elementIndex = -1;
        for (int i = 0; i < count; i++) {
            if (gifts[i] != null) {
                if (gifts[i].equals(element)) {
                    elementIndex = i;
                }
            }
        }
        if (elementIndex == -1) {// 초기값이 안변했으면 찾는 인덱스가 없다는 의미
            System.out.println(element + " can't be found.");
        } else {
            gifts[elementIndex] = null;
            for (int i = elementIndex+1; i < count; i++) {
                gifts[i-1] = gifts[i];
            }
            count--;

            System.out.println(element + " removed successfully.");
        }
    }


    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public E[] getGifts() {
        return gifts;
    }

    public void setGifts(E[] gifts) {
        this.gifts = gifts;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Gifts<?> that = (Gifts<?>) o;
        return size == that.size && count == that.count && Arrays.equals(gifts, that.gifts);
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(size, count);
        result = 31 * result + Arrays.hashCode(gifts);
        return result;
    }

    @Override
    public String toString() {
        return "RandomGiftBox{" +
                "size=" + size +
                ", gifts=" + Arrays.toString(gifts) +
                ", count=" + count +
                '}';
    }
}

import me.day13.generic.extend.gift.*;

public class GenericExtendsExample {
    public static void main(String[] args) {

        Gifts<Note> randomNotes = new Gifts<>();
        randomNotes.add(new Note("1001", "모닝글로리", true));
        randomNotes.add(new Note("2001", "바른손", false));
        randomNotes.add(new Note("3001", "바른손", true));
        randomNotes.add(new Note("4001", "모닝글로리", false));


        for (int i = 0; i < randomNotes.getCount(); i++) {
            randomNotes.get(i).setHasLine(true);
            System.out.println("randomNotes.getGifts().get(i) = " + randomNotes.get(i));
        }

        System.out.println();
        randomNotes.remove(new Note("1001", "모닝글로리", true));
        randomNotes.remove(new Note("2001", "바른손", true));
        randomNotes.remove(new Note("3001", "바른손", true));
        randomNotes.remove(new Note("4001", "모닝글로리", true));
        randomNotes.remove(new Note("4001", "모닝글로리", true));
        System.out.println();
        System.out.println();

        //////////////////////////////////////////////////////////////////////////////////////////


        Gifts<Pen> randomPens = new Gifts<>();
        randomPens.add(new Pen("1001", "모닝글로리", "빨강"));
        randomPens.add(new Pen("2001", "바른손", "검정"));
        randomPens.add(new Pen("3001", "바른손", "검정"));
        randomPens.add(new Pen("4001", "모닝글로리", "파랑"));


        for (int i = 0; i < randomPens.getCount(); i++) {
            randomPens.get(i).setInkColor("검정");
            System.out.println("randomPens.getGifts().get(i) = " + randomPens.get(i));
        }

        System.out.println();
        randomPens.remove(new Pen("1001", "모닝글로리", "검정"));
        randomPens.remove(new Pen("2001", "바른손", "검정"));
        randomPens.remove(new Pen("3001", "바른손", "검정"));
        randomPens.remove(new Pen("4001", "모닝글로리", "검정"));
        randomPens.remove(new Pen("4001", "모닝글로리", "검정"));
        System.out.println();
        System.out.println();

        //////////////////////////////////////////////////////////////////////////////////////////


        Gifts<Tablet> randomTables = new Gifts<>();
        randomTables.add(new Tablet("1001", "SAMSUNG", "GALAXY-TAB S8", true));
        randomTables.add(new Tablet("2001", "APPLE", "IPAD-AIR3", false));
        randomTables.add(new Tablet("3001", "APPLE", "IPAD-PRO3", false));
        randomTables.add(new Tablet("4001", "SAMSUNG", "GALAXY-TAB S8+", true));

        for (int i = 0; i < randomTables.getCount(); i++) {
            randomTables.get(i).setHasPencil(true);
            System.out.println("randomTables.getGifts().get(i) = " + randomTables.get(i));
        }

        System.out.println();
        randomTables.remove(new Tablet("1001", "SAMSUNG", "GALAXY-TAB S8", true));
        randomTables.remove(new Tablet("2001", "APPLE", "IPAD-AIR3", true));
        randomTables.remove(new Tablet("3001", "APPLE", "IPAD-PRO3", true));
        randomTables.remove(new Tablet("4001", "SAMSUNG", "GALAXY-TAB S8+", true));
        randomTables.remove(new Tablet("4001", "SAMSUNG", "GALAXY-TAB S8+", true));
        System.out.println();
        System.out.println();

        //////////////////////////////////////////////////////////////////////////////////////////


        Gifts<SmartPhone> randomSmartPhone = new Gifts<>();
        randomSmartPhone.add(new SmartPhone("1001", "SAMSUNG", 3, 20));
        randomSmartPhone.add(new SmartPhone("2001", "LG", 2, 10));
        randomSmartPhone.add(new SmartPhone("3001", "LG", 3, 10));
        randomSmartPhone.add(new SmartPhone("4001", "SAMSUNG", 2, 15));

        for (int i = 0; i < randomSmartPhone.getCount(); i++) {
            randomSmartPhone.get(i).setNumOfCameras(3);
            randomSmartPhone.get(i).setNumOfSensors(20);
            System.out.println("randomSmartPhone.getGifts().get(i) = " + randomSmartPhone.get(i));
        }

        System.out.println();
        randomSmartPhone.remove(new SmartPhone("1001", "SAMSUNG", 3, 20));
        randomSmartPhone.remove(new SmartPhone("2001", "LG", 3, 20));
        randomSmartPhone.remove(new SmartPhone("3001", "LG", 3, 20));
        randomSmartPhone.remove(new SmartPhone("4001", "SAMSUNG", 3, 20));
        randomSmartPhone.remove(new SmartPhone("4001", "SAMSUNG", 3, 20));
        System.out.println();
        System.out.println();
        
    }
}

E 자리에 사용할 타입을 쓰면 된다. 

⭐와일드카드

• 코드에서 ? 로 사용
• 제너릭 타입을 메소드의 매개값이나 리턴 타입으로 사용할 때 구체적인 타입 대신에 와일드 카드로 대체 가능하다.
• 클래스/인터페이스명<?>
  • Unbounded Wildcards (제한없음)
  • 타입 파라미터를 대치하는 구체적인 타입으로 모든 클래스/인터페이스 올 수 있음
• 클래스/인터페이스명<? extends 상위타입>
  • Upper Bounded Wildcards (상위 클래스 제한)
  • 타입 파라미터를 대치하는 구체적인 타입으로 상위 타입이나 상위 타입 이하의 타입만 올 수 있음
• 클래스/인터페이스명<? super 하위타입>
  • Lower Bounded Wildcards (하위 클래스 제한)
  • 타입 파라미터를 대치하는 구체적인 타입으로 하위 타입이나 하위 타입 이상의 타입만 올 수 있음

• <?>           // 타입 변수에 모든 타입을 사용할 수 있음.
• <? extends T> // T 타입과 T 타입을 상속받는 자손 클래스 타입만을 사용할 수 있음.
• <? super T>   // T 타입과 T 타입이 상속받은 조상 클래스 타입만을 사용할 수 있음.

 

예시

import java.util.Arrays;
import java.util.Objects;



public class Course<T> {

    public enum RegisterStudentType { ANIMAL, PERSON, STUDENT, HIGH_STUDENT, UNIV_STUDENT, WORKER }

    private String courName;
    private RegisterStudentType registerStudentType;
    private T[] registerStudents;
    private int count = 0;
    private int size = 0;

    public Course() {
    }

    public Course(String courName, RegisterStudentType registerStudentType, int size) {
        this.courName = courName;
        this.registerStudentType = registerStudentType;
        this.registerStudents = (T[]) new Object[size];
        this.size = size;
    }

    public String getCourName() {
        return courName;
    }

    public void setCourName(String courName) {
        this.courName = courName;
    }

    public RegisterStudentType getRegisterStudentType() {
        return registerStudentType;
    }

    public void setRegisterStudentType(RegisterStudentType registerStudentType) {
        this.registerStudentType = registerStudentType;
    }

    public T[] getRegisterStudents() {
        return registerStudents;
    }

    public void setRegisterStudents(T[] registerStudents) {
        this.registerStudents = registerStudents;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public void add(T t) {
        if (count < size) {
            registerStudents[count] = (T) t;
            count++;

            System.out.println(t + " is added successfully.");
        } else {
            T[] copied = Arrays.copyOf(registerStudents, size);
            size *= 2;
            registerStudents = Arrays.copyOf(copied, size);
            add(t);
        }

    }

    public T remove(T t) {
        if (t == null) {
            System.out.println(t +" can't be removed successfully.");
            return null;
        }

        int index = -1;
        for (int i = 0; i < count; i++) {
            if (t instanceof Person) {
                if (registerStudents[i] != null) {
                    if (registerStudents[i].equals(t)) {
                        index = i;
                    }
                }
            }
        }
        T removeStudent = registerStudents[index];
        registerStudents[index] = null;

        for (int i = index+1; i < count; i++) {
            registerStudents[i-1] = registerStudents[i];
        }

        System.out.println(removeStudent + " is removed successfully.");
        return removeStudent;
    }



    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Course<?> course = (Course<?>) o;
        return courName.equals(course.courName) && registerStudentType == course.registerStudentType && Arrays.equals(registerStudents, course.registerStudents);
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(courName, registerStudentType);
        result = 31 * result + Arrays.hashCode(registerStudents);
        return result;
    }

    @Override
    public String toString() {
        return "Course{" +
                "courName='" + courName + '\'' +
                ", registerStudentType=" + registerStudentType +
                ", registerStudents=" + Arrays.toString(registerStudents)  +
                '}';
    }
}

public interface CourseUtils {
    static void registerPersonCourse(Course<? extends Person> course) {
        System.out.println(course + " is registered successfully.\n\n");
    }
    static void registerAnimalCourse(Course<? extends Animal> course) {
        System.out.println(course + " is registered successfully.\n\n");
    }

}

public class GenericWildCardExample {
    public static void main(String[] args) {
        Course<Person> personCourse = new Course<>("제테크 시작하기", Course.RegisterStudentType.PERSON, 5);
        Course<Student> studentCourse = new Course<>("스크래치 프로그래밍", Course.RegisterStudentType.STUDENT, 5);
        Course<Worker>  workerCourse = new Course<>("실무 자동화를 위한 프로그래밍", Course.RegisterStudentType.WORKER, 5);
        Course<HighStudent> highStudentCourse = new Course<>("대학 입시를 위한 SW 경진대회 대비", Course.RegisterStudentType.HIGH_STUDENT, 5);
        Course<UnivStudent> univStudentCourse = new Course<>("OOP 프로그래밍", Course.RegisterStudentType.UNIV_STUDENT, 5);
        Course<Animal> animalCourse = new Course<>("반려동물 사회성 기르기", Course.RegisterStudentType.ANIMAL, 5);


        Person person = new Person();
        personCourse.add(person);
//        studentCourse.add(person); // 컴파일 오류.
//        workerCourse.add(person); // 컴파일 오류.
//        highStudentCourse.add(person); // 컴파일 오류.
//        univStudentCourse.add(person); // 컴파일 오류.
//        animalCourse.add(person); // 컴파일 오류.
        System.out.println();

        Student student = new Student();
        personCourse.add(student);
        studentCourse.add(student);
//        workerCourse.add(student); // 컴파일 오류.
//        highStudentCourse.add(student); // 컴파일 오류.
//        univStudentCourse.add(student); // 컴파일 오류.
//        animalCourse.add(student); // 컴파일 오류.
        System.out.println();


        Worker worker = new Worker();
        personCourse.add(worker);
//        studentCourse.add(worker); // 컴파일 오류.
        workerCourse.add(worker);
//        highStudentCourse.add(worker); // 컴파일 오류.
//        univStudentCourse.add(worker); // 컴파일 오류.
//        animalCourse.add(worker); // 컴파일 오류.
        System.out.println();


        HighStudent highStudent = new HighStudent();
        personCourse.add(highStudent);
        studentCourse.add(highStudent);
//        workerCourse.add(highStudent); // 컴파일 오류.
        highStudentCourse.add(highStudent);
//        univStudentCourse.add(highStudent); // 컴파일 오류.
//        animalCourse.add(highStudent); // 컴파일 오류.
        System.out.println();


        UnivStudent univStudent = new UnivStudent();
        personCourse.add(univStudent);
        studentCourse.add(univStudent);
//        workerCourse.add(univStudent); // 컴파일 오류.
//        highStudentCourse.add(univStudent); // 컴파일 오류.
        univStudentCourse.add(univStudent);
//        animalCourse.add(univStudent); // 컴파일 오류.
        System.out.println();

        Animal animal = new Animal();
//        personCourse.add(animal); // 컴파일 오류.
//        studentCourse.add(animal); // 컴파일 오류.
//        workerCourse.add(animal); // 컴파일 오류.
//        highStudentCourse.add(animal); // 컴파일 오류.
//        univStudentCourse.add(animal); // 컴파일 오류.
        animalCourse.add(animal);

        System.out.println("\n\n========================================================= " +
                "register person course results =========================================================");
        CourseUtils.registerPersonCourse(personCourse);
        CourseUtils.registerPersonCourse(studentCourse);
        CourseUtils.registerPersonCourse(workerCourse);
        CourseUtils.registerPersonCourse(highStudentCourse);
        CourseUtils.registerPersonCourse(univStudentCourse);
//        CourseUtils.registerPersonCourse(animalCourse); // 컴파일 오류.

        System.out.println("\n\n========================================================= " +
                "register animal course results =========================================================");
//        CourseUtils.registerAnimalCourse(personCourse); // 컴파일 오류.
//        CourseUtils.registerAnimalCourse(studentCourse); // 컴파일 오류.
//        CourseUtils.registerAnimalCourse(workerCourse); // 컴파일 오류.
//        CourseUtils.registerAnimalCourse(highStudentCourse); // 컴파일 오류.
//        CourseUtils.registerAnimalCourse(univStudentCourse); // 컴파일 오류.
        CourseUtils.registerAnimalCourse(animalCourse);

    }
}

 

• 제너릭 타입 상속
  • 상속 후 타입 파라미터 추가 가능
  ChildProduct<T, M, C> extends Product<T, M>

예시

import java.util.Objects;

public class Product<T, M> {
    private T kind;
    private M model;

    public Product() {
    }

    public Product(T kind, M model) {
        this.kind = kind;
        this.model = model;
    }

    public T getKind() {
        return kind;
    }

    public void setKind(T kind) {
        this.kind = kind;
    }

    public M getModel() {
        return model;
    }

    public void setModel(M model) {
        this.model = model;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Product<?, ?> product = (Product<?, ?>) o;
        return kind.equals(product.kind) && model.equals(product.model);
    }

    @Override
    public int hashCode() {
        return Objects.hash(kind, model);
    }

    @Override
    public String toString() {
        return "Product{" +
                "kind=" + kind +
                ", model=" + model +
                '}';
    }
}

import java.util.Objects;

public class ChildProduct<T, M, C> extends Product<T, M> {
    private C company;

    public ChildProduct() {
    }

    public ChildProduct(C company) {
        this.company = company;
    }

    public ChildProduct(T kind, M model, C company) {
        super(kind, model);
        this.company = company;
    }

    public C getCompany() {
        return company;
    }

    public void setCompany(C company) {
        this.company = company;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        if (!super.equals(o)) return false;
        ChildProduct<?, ?, ?> that = (ChildProduct<?, ?, ?>) o;
        return company.equals(that.company);
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), company);
    }

    @Override
    public String toString() {
        return "ChildProduct{" + super.toString() + ", " +
                "company=" + company +
                '}';
    }
}

 

• 제너릭 타입 구현
  • 구현 후 타입 제한 가능
  StorageImpl<T extends Clothes> implements Storage<T>

public interface Storage<T> {
    void add(T item);
    T get(int index);
    void remove(T item);
}

import java.util.Arrays;
import java.util.Objects;

public class StorageImpl<T extends Clothes> implements Storage<T> {
    private static final int DEFULAT_SIZE = 10;
    private int size;

    private T[] list;
    private int count;

    public StorageImpl() {
        list = (T[]) new Clothes[DEFULAT_SIZE];
        this.size = DEFULAT_SIZE;
    }

    public StorageImpl(int size) {
        list = (T[]) new Clothes[size];
        this.size = size;
    }

    public T get(int i) {
        return list[i];
    }

    public void add(T element) {
        if (count < size) {
            list[count] = element;
            count++;
        } else {
            T[] origin = Arrays.copyOf(list, count);
            size *= 2;
            list = Arrays.copyOf(origin, size);
            add(element);
        }
    }

    public void remove(T element) {
        int elementIndex = -1;
        for (int i = 0; i < count; i++) {
            if (list[i] != null) {
                if (list[i].equals(element)) {
                    elementIndex = i;
                }
            }
        }
        if (elementIndex == -1) {
            System.out.println(element + " can't be found.");
        } else {
            list[elementIndex] = null;
            for (int i = elementIndex+1; i < count; i++) {
                list[i-1] = list[i];
            }
            count--;

            System.out.println(element + " removed successfully.");
        }
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public T[] getList() {
        return list;
    }

    public void setList(T[] list) {
        this.list = list;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        StorageImpl<?> storage = (StorageImpl<?>) o;
        return size == storage.size && count == storage.count && Arrays.equals(list, storage.list);
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(size, count);
        result = 31 * result + Arrays.hashCode(list);
        return result;
    }

    @Override
    public String toString() {
        return "StorageImpl{" +
                "size=" + size +
                ", list=" + Arrays.toString(list) +
                ", count=" + count +
                '}';
    }
}

import java.util.Objects;

class Clothes {
    private String type;
    private String season;
    private String color;

    public Clothes() {
    }

    public Clothes(String type, String season, String color) {
        this.type = type;
        this.season = season;
        this.color = color;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Clothes clothes = (Clothes) o;
        return type.equals(clothes.type) && season.equals(clothes.season) && color.equals(clothes.color);
    }

    @Override
    public int hashCode() {
        return Objects.hash(type, season, color);
    }

    @Override
    public String toString() {
        return "Clothes{" +
                "type='" + type + '\'' +
                ", season='" + season + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

public class ImplementExample {
    public static void main(String[] args) {
        StorageImpl<Clothes> storage = new StorageImpl<>();
        storage.add(new Clothes("셔츠", "가을", "블루"));
        storage.add(new Clothes("반바지", "여름", "검정"));
        storage.add(new Clothes("니트", "겨울", "베이지"));
        System.out.println();

        for (int i = 0; i < storage.getCount(); i++) {
            System.out.println("storage.get(i) = " + storage.get(i));
        }

        System.out.println();
        storage.remove(new Clothes("셔츠", "가을", "블루"));
        storage.remove(new Clothes("반바지", "여름", "검정"));
        storage.remove(new Clothes("니트", "겨울", "베이지"));
    }
}