제네릭(Generic) 메소드

매개변수타입과 리턴타입 으로 타입파라미터를 갖는 메소드를 말한다.

제네릭 메소드 선언방법

제네릭 메소드를 호출하는 두가지 방법

public class GenericMethod {
    static class Box<T> {    //box 클래스
        private T t;
        public T getT() { return t; }
        public void setT(T t) { this.t = t; }
    }
    static class Util {     // 박스를 이용해 제네릭 메소드가 있는 Util클래스
        public static <T> Box<T> boxing(T t) {
            Box<T> box = new Box<T>();
            box.setT(t);
            return box;
        }
    }
    public static void main(String[] args) {
        //1번 구체적 타입 명시              <Integer>boxing(100)  구체적타입 Integer 명시
        Box<Integer> box1 = Util.<Integer>boxing(100);
        int intValue = box1.getT();
        System.out.println(intValue);

        //2번 매개값을 보고 구체적 타입 추정.   홍길동 = String 타입
        Box<String> box2 = Util.boxing("홍길동");
        String strValue = box2.getT();
        System.out.println("strValue = " + strValue);

    }
}

exam2

public class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { return key; }

    public void setKey(K key) { this.key = key; }

    public V getValue() { return value; }

    public void setValue(V value) { this.value = value; }
}

public class Util {
    //두개의 Pair객체를 받아서 페어 객체의 K,V값을 비교   K와 V가 같다면 true or false
    public static <K,V> boolean compare(Pair<K,V> p1, Pair<K,V> p2) {
        boolean keyCompare = p1.getKey().equals(p2.getKey());
        boolean valueCompare = p1.getValue().equals(p2.getValue());

        // keyCompare 그리고 valueCompare 가 같으면 true
        return keyCompare && valueCompare;

    }
}

public class CompareMethodExample {
    public static void main(String[] args) {
        //두개의 Pair객체 생성
        Pair<Integer, String> p1 = new Pair<>(1, "사과");
        Pair<Integer, String> p2 = new Pair<>(1, "사과");
        // 구체적 타입 명시.. 두개의 페어 객체를 비교
        Util.<Integer,String>compare(p1, p2);

        //매개값을 보고 구체적 타입 추정,  new Pair<>(1, "사과")     1 =Integer 타입 , "사과" = String 타입
        boolean result1 = Util.compare(p1, p2);
        if (result1) {
            System.out.println("논리적으로 동등합니다.");
        } else {
            System.out.println("논리적으로 동등하지 않습니다.");
        }
    }
}

제네릭(Generic)이란?

제네릭을 사용함으로서 얻는 이점

제네릭 타입이란

  타입을 파라미터로 가지는 클래스와 인터페이스를 말한다.

타입 파라미터

제네릭 타입을 사용할 경우의 효과

public class testBox {
        private Object object;
        public Object getObject() { return object; }
        public void setObject(Object object) { this.object = object; }

    public static void main(String[] args) {
        testBox box = new testBox();
        box.setObject("hello");               //String 타입을 Object 타입으로 자동 타입 변환 후 저장
        String str = (String) box.getObject();//Object 타입을 String 타입으로 강제 타입 변환 후 얻음
    }
}

제네릭 적용    불필요한 타입변환이 필요 없어짐.         제네릭 타입을 사용할때( 제네릭타입의 객체를 만들때 ?)  T 부분을 원하는 타입을 주면 된다.

public class TestGenericBox<T> {
        private T t;
        public T getT() { return t; }
        public void setT(T t) { this.t = t; }

    public static void main(String[] args) {
        TestGenericBox<String> stringGecericBox = new TestGenericBox<String>();
        stringGecericBox.setT("hello");
        String  str = stringGecericBox.getT();
    }
}

두 개 이상의 타입 파라미터를 사용해서 선언할 수 있다.

public class 두개이상의타입파라미터<T, M> {
    private T kind;
    private M 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; }
}

중복된 타입 파라미터를 생략한 다이아몬드( <>) 연산자

두개이상의타입파라미터<Tv, String> 티비 = new 두개이상의타입파라미터<Tv, String>();

//다이아몬드연산자 적용
두개이상의타입파라미터<Tv, String> 티비 = new 두개이상의타입파라미터<>();

Exam

public static void main(String[] args) {
    // 제네릭 을 사용사여 생성시 Tv 타입과 String 타입을 지정후 set, get 실행
    두개이상의타입파라미터<Tv, String> product1 = new 두개이상의타입파라미터<>();
    produck1.setKind(new Tv());
    product1.setModel("스마트 TV");
    Tv tv = product1.getKind();
    String tvModel = product1.getModel();
    
    // 제네릭 을 사용사여 생성시 Car 타입과 String 타입을 지정후 set, get 실행
    두개이상의타입파라미터<Car, String> product2 = new 두개이상의타입파라미터<>();
    product2.setKind(new Car());
    product2.setModel("리어카");
    Car car = product2.getKind();
    String carModel = product2.getModel();

자바 애플리캐이션은     메인(main) 스레드가 main() 메소드를 실행시킨다.

작업 스레드 클래스는 Thread 클래스를 상속 해서 만들 수 있다.

Runnable 객체는 스레드가 실행해야할 코드를 가지고 있는 객체라고 볼 수 있다.

스레드를 만드는  방법,? 종류?

1. 클래스 extends Thread     스레드를 상속받고  run()메소드를 오버라이딩 

2. 클래스 implement Runnable            Runnable을 구현한 클래스를 

다른 곳에서 생성자로 호출     

Thread thread = new Thread(new 클래스 ) 호출

3.  익명객체로 Runnable 구현 (람다식 가능)?

스레드의 우선순위  

동기화 메소드와  동기화 블록    synchronized

스레드 일시 정지상태 

 스레드 상태 제어 메소드

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

        Thread thread = new MovieThread();
        thread.start();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //    interrupt() 실행   일정지가 되면 InterruptedException 발생
        thread.interrupt();

    }
}

public class MovieThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("동영상을 재생합니다.");
            // 방법 1
            //  Thread.sleep(1000)  일지 정지 상태로 만듬.
            // 일시정지가되면 InterruptedException 발생
            // catch부분에서 break; 실행
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }

            //방법 2
            //  this.isInterrupted()
            if (Thread.interrupted()) {
                break;
            }

        }
    }
}

while  문으로 반복저인 작업을 하는 스레드를 종료 시키는 방법 !

데몬 스레드

스레드풀