Java - Interface

// Interface - 추상화 메서드를 통해 규격을 잡아주는 역할 (중간 역할)

<--------------------------- MouseEvent.class -------------------------------->

< Interface >

public interface MouseEvent {

    

    // 인터페이스는 본래 추상화 메서드만 선언 가능 하다.

    // 그래서 abstract 키워드가 생략 된다.

    public void click(int c);

    public void dbclick(int d);

    public double[] move();

    

    // JDK 1.8부터 default 메서드를 제공

    // default를 붙이면 일반 메서드가 된다.

    public default void wheel(int i) {

        if(i == 1) {

            System.out.println("위 방향");

        }else {

            System.out.println("아래 방향");

        }

    }

    

    // JDK 1.8부터 static 메서드 제공

    // static을 쓰면 interface에 직접 접근해서 사용 가능.

    public static void setDpi(int dpi) {

        System.out.println("감도조절 : " + dpi);

    }

    

}

< Class >

public class Linux implements MouseEvent { // interface Add로 만들어논 interface 추가

    

    // implements로 interface 추가

    @Override

    public void click(int c) {

        System.out.println("리눅스 "+ c + "번 마우스를 클릭");

    }

    @Override

    public void dbclick(int d) {

        System.out.println("리눅스 "+ d + "번 마우스를 더블 클릭");

    }

    @Override

    public double[] move() {

        return null;

    }

}

public class Windows implements MouseEvent {

    @Override

    public void click(int c) {

        System.out.println("윈도우 "+ c + "번 마우스를 클릭");

    }

    @Override

    public void dbclick(int d) {

        System.out.println("윈도우 "+ d + "번 마우스를 더블 클릭");

    }

    @Override

    public double[] move() {

        return null;

    }

}

public class Mac implements MouseEvent {

    @Override

    public void click(int c) {

        System.out.println("맥 "+ c + "번 마우스를 클릭");

    }

    @Override

    public void dbclick(int d) {

        System.out.println("맥 "+ d + "번 마우스를 더블 클릭");

    }

    @Override

    public double[] move() {

        return null;

    }

}

< Main >

public class Main {

    public static void main(String[] args) {

        

        Windows w = new Windows();

        w.click(3);

        Linux l = new Linux();

        l.dbclick(5);

        Mac m = new Mac();

        m.click(2);

        

        // 다형성은 구현 관계에서도 된다.

        MouseEvent e;

        e = new Windows();

        e.click(3);

        e = new Linux();

        e.dbclick(2);

        e = new Mac();

        e.click(2);

        

        // 다형성 배열

        MouseEvent[] e2 = new MouseEvent[3];

        e2[0] = new Windows();

        e2[1] = new Linux();

        e2[2] = new Mac();

        

        for(MouseEvent me : e2) {

            me.click(3);

        }

        

e.wheel(1); // default emthod

MouseEvent.setDpi(2); // static method는 직접 접근

        

    }

}

// 추상화는 1개의 클래스만 상속가능

// 인터페이스는 여러 개의 인터페이스 implement 구현 가능

// 둘다 객체화 불가능, 인터페이스는 일반메서드를 default로 정의하고 사용가능

// 여러 번 인터페이스를 쓸 때는 implement interface, interface 이런식으로 사용 가능

< interface >

public interface MouseEvent {

    public void click(int c);

    public void dbclick(int d);

    public double[] move();

    

}

public interface KeyEvent {

    public void keyDown(int kd);

    public void keyUp(int ku);

    

}

public class Window implements MouseEvent, KeyEvent { // interface 2개 사용

< Key Interface >

    @Override

    public void keyDown(int kd) {

        System.out.println(kd + "번 키를 눌렀다");

    }

    @Override

    public void keyUp(int ku) {

        System.out.println(ku + "번 키를 올렸다");

    }

< Mouse Interface >

    @Override

    public void click(int c) {

        System.out.println(c + "번 마우스를 클릭했다");

    }

    @Override

    public void dbclick(int d) {

        System.out.println(d + "번 마우스를 더블 클릭했다");

    }

    @Override

    public double[] move() {

        return null;

    }

}

public class Main {

    public static void main(String[] args) {

        

        Window w = new Window();

        w.keyDown(1);

        w.keyUp(2);

        

        w.click(4);

        w.dbclick(3);

        w.move();

    }

}

< Common Interface >

public interface Common {

    

    public void test1();

    public void test2();

}

public class CommonImp implements Common {

    

    // Common의 interface

    @Override

    public void test1() {

        System.out.println("test1");

    }

    @Override

    public void test2() {

        System.out.println("test2");

    }

}

public class Main {

    public static void main(String[] args) {

        

        // 다형성을 사용하지 않은 경우

        CommonImp ci = new CommonImp();

        ci.test1();

        ci.test2();

        

        // 다형성을 사용한 경우

        Common c = new CommonImp();

        c.test1();

        c.test2();

        

    }

}

< anonymous >

package chapter06.exam06.anony;

import chapter06.exam05.instance.Common;

import chapter06.exam05.instance.CommonImp;

public class Main {

    public static void main(String[] args) {

        

        // 일반적인 경우는 만들어 놓은 클래스를 사용한다 ( 여럿이서 재활용하며 사용 가능 )

        // CommonImp는 언제나 사용 가능 하다.

        // 두고두고 사용 가능하다.

        Common comm = new CommonImp();

        comm.test1();

        comm.test2();

        

        // 하지만 한번만 사용하고 말 것이라면 굳이 클래스를 만들어 줄 필요가 없다.

        // 아래의 경우 이프로그램이 실행될 동안만 유지되는 익명 객체를 생성 한다.

        Common com = new Common() { // 프로그램이 종료되면 익명 객체도 사라진다. 1회성 용도

            

            @Override

            public void test2() {

                System.out.println("익명 객체의 test2");

            }

            

            @Override

            public void test1() {

                System.out.println("익명 객체의 test1");

            }

        }; // 익명 객체는 끝날 때 세미콜론을 붙여야 한다.         com.test1();

com.test2();

        

    }

}

// Class는 한번만 상속이 되지만, Interface는 여러 번 상속 가능

< Interface - Inheritance >

public interface MouseEvent {

    

    public void click(int c);

    public void dbclick(int d);

    public double[] move();

}

public interface KeyEvent {

    public void keyDown(int kd);

    public void keyUp(int ku);

    

}

public interface Child extends KeyEvent, MouseEvent { // Interface가 Interface를 상속 받을 땐

extends 사용

    public void textFild(String s);

    public void selectOne();

    public void checkOne();

    

}

< Interface들을 상속받은 Child Interface 이용 >

public class ChildImple implements Child {

    @Override

    public void keyDown(int kd) {

        System.out.println(kd + "번 키를 눌렀다");

    }

    @Override

    public void keyUp(int ku) {

        System.out.println(ku + "번 키를 올렸다");

    }

    @Override

    public void click(int c) {

        System.out.println(c + "번 마우를 클릭했다");

    }

    @Override

    public void dbclick(int d) {

        System.out.println(d + "번 마우를 더블 클릭했다");

    }

    @Override

    public double[] move() {

        return null;

    }

    @Override

    public void textFild(String s) {

        System.out.println("입력한 문자 : " + s);

    }

    @Override

    public void selectOne() {

        System.out.println("하나를 선택");

    }

    @Override

    public void checkOne() {

        System.out.println("하나를 체크");

    }

}

< Main >

public class Main {

    public static void main(String[] args) {

        

// 객체 생성

        ChildImple ci = new ChildImple();

        ci.click(1);

        ci.dbclick(2);

        ci.move();

        

        ci.keyUp(3);

        ci.keyDown(4);

        

        ci.checkOne();

        ci.selectOne();

        ci.textFild("개");

// 다형성

Child c = new ChildImple();

        c.click(5);

        c.dbclick(6);

        c.move();

        

        c.keyUp(7);

        c.keyDown(8);

        

        c.checkOne();

        c.selectOne();

        c.textFild("양");

        

// 익명 객체

        Child cc = new Child() {

            

            @Override

            public double[] move() {

                return null;

            }

            

            @Override

            public void dbclick(int d) {

                System.out.println("익명 객체에서 " + d + "번 더블 클릭했습니다");

            }

            

            @Override

            public void click(int c) {

                System.out.println("익명 객체에서 " + c + "번 클릭했습니다");

            }

            

            @Override

            public void keyUp(int ku) {

                System.out.println("익명 객체에서 " + ku + "번 키를 올렸습니다");

            }

            

            @Override

            public void keyDown(int kd) {

                System.out.println("익명 객체에서 " + kd + "번 키를 눌렀습니다");

            }

            

            @Override

            public void textFild(String s) {

                System.out.println("익명 객체에서의 입력한 문자 : " + s);

            }

            

            @Override

            public void selectOne() {

                System.out.println("익명 객체에서 selectOne");

            }

            

            @Override

            public void checkOne() {

                System.out.println("익명 객체에서 checkOne");

            }

        };

        

        // 익명 객체 활용

        cc.click(12);

        cc.dbclick(13);

        cc.move();

        

        cc.keyDown(9);

        cc.keyUp(8);

        

        cc.textFild("Anony");

        cc.selectOne();

        cc.checkOne();

        

    }

}

// 결합도가 높으면 좋지 않기 때문에 추상화와 인터페이스로 어느 정도 해결할 수 있다.