ABOUT ME

    -

    Today
    -
    Yesterday
    -
    Total
    -
    • 10. oop9 - (1) TvDemo (인터페이스)
      java/코드 리뷰 2020. 4. 2. 20:41
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      package oop9;
      public class NormalTv {
          
          private Monitor monitor; // Monitor 타입의 객체를 담는 멤버변수
          
          public NormalTv(Monitor monitor) { // 생성자 실행할 때 Monitor를 구현한 객체만을 전달받음
              this.monitor = monitor; // NormalMonitor, HDMonitor, CinemaMonitor, LCDCinemaMoitor만을 전달받음
          }
          
          public void watch() {
              // Monitor 인터페이스를 기준으로 프로그램을 작성
             monitor.on();    // Monitor 인터페이스에 추상화된 기능을 사용
              monitor.display(); // Monitor 인터페이스에 추상화된 기능을 사용
              
              // monitor.display() 실행 시 
              // 실제 멤버변수에 조립된 객체가 NormalMonitor일 때 // 컬러로 동영상 재생
              //                        HDMonitor일 때 // 4K 화질로 동영상 재생
              //                       CinemaMonitor일 때 // 100인치 화면에서 동영상 재생
              //                       LCDCMonitor일 때 // 터치 가능한 100인치 화면에서 동영상 재생
              /*
              ★ 다형성 (polymorphism)
               1. 조상 타입의 참조변수로 여러가지 형태의 자손타입 객체를 참조 가능
               2. 실행하는 메서드는 동일하지만, 조상 타입의 참조 변수에 실제로 조립된 객체의 재정의(오버라이딩)된 내용 실행
                   : 실행하는 메서드 동일, 실제 조립된 객체에 따라 다른 실행결과 발현됨
               */
              System.out.println(""); 
          }
          
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      package oop9;
       
      // 인터페이스(기획서)
      // 모든 종류의 모니터가 반드시 갖춰야 하는 기능을 정의
      // 모든 종류의 모니터에 대한 표준을 정의 (사용 방법의 표준)
      public interface Monitor {
          
          public abstract void on();
          void off();  // public abstract void off();
          void display(); // public abstract 생략 가능
          
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      package oop9;
       
      // 추상 클래스 (기획서에 대한 미완성 설계도)
      // 모든 모니터가 공통으로 가지는 속성, 기능을 구현함으로서 자식 클래스의 구현부담을 감소시킴
      // 자식 클래스마다 조금씩 다르게 구현되는 기능은 자식 클래스에서 직접 재정의
      //  ㄴ 추상 클래스에서 해당 기능을 별도로 구현하지 않고 자식 클래스에 구현을 위임
      public abstract class AbstractMonitor implements Monitor {
          
          private boolean power; // 멤버변수
          
          @Override
          public void on() { // 인터페이스의 추상화된 메서드를 재정의한 멤버 메서드
              power = true;
              System.out.println("전원을 켭니다.");
          }
          
          @Override
          public void off() { // 인터페이스의 추상화된 메서드를 재정의한 멤버 메서드
              power = false;
              System.out.println("전원을 끕니다.");
          }
          
          public boolean getPower() { // 일반 멤버 메서드
              return power;
          }
          
          // Monitor 인터페이스의 void display() 기능의 구현은 자식 클래스에게 구현을 위임
           // ㄴ 아무리 그래도 아예 안쓴다고? 나중에 어케 찾을라고? // 뭔소리여
          
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      package oop9;
       
      public class NormalMonitor extends AbstractMonitor {
          
          
          // Monitor 인터페이스의 추상화된 메서드 구현
          @Override
          public void display() {
              
              if(!getPower()) {
                  System.out.println("전원이 꺼져있습니다.");
                  return;
              }
              
                  System.out.println("컬러로 동영상을 표시합니다.");
          }
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      package oop9;
       
      public class HDMonitor extends AbstractMonitor {
          
          String resolution;
          
          public HDMonitor(String resolution) {
              this.resolution = resolution;
          }
          
          @Override
          public void display() {
              if (!getPower()) {
                  System.out.println("전원이 꺼져있습니다.");
                  return;
              }
              
              System.out.println("[" + resolution + "] 급 화질로 동영상을 재생합니다.");
              
          }
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      package oop9;
       
      public class LCDCinemaMonitor extends AbstractMonitor implements Speakable, Touchable {
          
          private String screenSize;
          private int volume;
          
          public LCDCinemaMonitor() {
              screenSize = "30인치";
              volume = 30;
          }
          
          public LCDCinemaMonitor(String screenSize, int volume) {
              this.screenSize = screenSize;
              this.volume = volume;
          }
          
          // 코드의 간편화를 위해 전원 체크는 생략
          @Override
          public void display() {
              System.out.println("[" + screenSize +"] 크기의 LCD 시네마 모니터로 동영상을 재생합니다.");
          }
       
          @Override
          public void touch() {
              System.out.println("화면의 메뉴를 터치해서 장면을 전환합니다.");
          }
       
          @Override
          public void sound() {
              System.out.println("볼륨 [" + volume + "] 크기로 소리를 재생합니다.");
          }
       
          @Override
          public void volumeDown() {
              if(volume > Speakable.MAX_VOLUMN) {
                  volume -= 5;
              }
              System.out.println("현재 볼륨 : " + volume);
          }
       
          @Override
          public void volumeUp() {
              if(volume > Speakable.MIN_VOLUMN) {
                  volume += 5;
              }
              System.out.println("현재 볼륨 : " + volume);
          }
          
          
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      package oop9;
       
      public interface Touchable {
          
          void touch();
      }
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      65
      66
      67
      68
      69
      70
      71
      72
      package oop9;
       
      public class CinemaMonitor extends AbstractMonitor implements Speakable {
          
          private String screenSize;
          private int volume;
          
          public CinemaMonitor() {
              screenSize  = "100인치";
              volume = 50;
          }
       
          public CinemaMonitor(String screenSize) {
              this.screenSize = screenSize;
              this.volume = 50;
          }
          
          @Override
          public void display() {
              if (this.powerCheck()) {
                  return;
              }
              
              System.out.println("[" + screenSize + "] 크기 스크린으로 동영상을 재생");
          }
          
          @Override
          public void sound() {
              if (this.powerCheck()) {
                  return;
              }
              
              System.out.println("[" + volume + "]으로 소리를 재생합니다.");
          }
          
          @Override
          public void volumeDown() {
              if(!this.powerCheck()) {
                  return;
              }
              
              volume -= 5;
              if (volume > Speakable.MAX_VOLUMN) {
                  volume = Speakable.MAX_VOLUMN;
              }
              System.out.println("현재 볼륨 : " + volume);
          }
          
          @Override
          public void volumeUp() {
              if (!this.powerCheck()) {
                  return;
              }
              
              volume += 5;
              if (volume < Speakable.MIN_VOLUMN) {
                  volume = Speakable.MIN_VOLUMN;
              }
              System.out.println("현재 볼륨 : " + volume);        
          }
          
          // 내부에서만 사용하는 메서드
          private boolean powerCheck() {
              if (!getPower()) {
                  System.out.println("전원이 꺼져있습니다.");
                  return false;
              }
              return true;
          }
          
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      package oop9;
       
      // 인터페이스 기획서
      // 사운드 출력이 지원되는 모든 모니터가 갖춰야 하는 기능 정의
      // 사운드 출력이 지원되는 모든 모니터는 최소, 최대 범위내의 소리 크기만을 가지도록 상수 정의
      public interface Speakable {
          public static final int MIN_VOLUMN = 0; // 상수
          public static final int MAX_VOLUMN = 100; // 상수
          
          void sound();
          void volumeUp();
          void volumeDown();
          
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      package oop9;
       
      public class TvDemo {
          public static void main(String[] args) {
              NormalMonitor m1 = new NormalMonitor();  // Monitor 인터페이스 구현
              HDMonitor m2 = new HDMonitor("4K");  // Monitor 인터페이스 구현
              CinemaMonitor m3 = new CinemaMonitor();  // Monitor, Speakable 인터페이스 구현
              LCDCinemaMonitor m4 = new LCDCinemaMonitor(); // Monitor, Speakable, Touchable 인터페이스 구현
              
              // NormalTv 객체를 생성하고 여러 종류의 Monitor 인터페이스 구현객체를 전달해서 사용
              NormalTv tv1 = new NormalTv(m1);
              NormalTv tv2 = new NormalTv(m2);
              NormalTv tv3 = new NormalTv(m3);
              NormalTv tv4 = new NormalTv(m4);
       
              tv1.watch();
              tv2.watch();
              tv3.watch();
              tv4.watch();
              
          }
      }
       
       
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      package oop9;
       
      public class MonitorDemo {
          
          public static void main(String[] args) {
              
              // 일반 모니터
      //        NormalMonitor m1 = new NormalMonitor();
      //        m1.on();
      //        m1.display();
      //        m1.off();
      //        m1.display();
              
              // 해상도 조정이 가능한 고화질 모니터
      //        HDMonitor m2 = new HDMonitor("4K");
      //        m2.on();
      //        m2.display();
      //        m2.off();
              
              // 스크린 크기 조정이 가능하고 사운드 출력이 지원되는 대형 모니터
      //        CinemaMonitor m3 = new CinemaMonitor("200인치");
      //        m3.on();
      //        m3.display();
      //        m3.volumeUp();    // Speakable 인터페이스 구현
      //        m3.volumeDown(); // Speakable 인터페이스 구현
      //        m3.display();
      //        m3.off();
              
              // 스크린 크기 조정이 가능하고 사운드 출력과 터치 기능이 지원되는 대형 LCD 모니터
              LCDCinemaMonitor m4 = new LCDCinemaMonitor("100인치", 60);
              m4.on();
              m4.touch(); // Touchable 인터페이스 구현
              m4.display();
              m4.volumeUp();
              m4.volumeUp();
              m4.off();
              
          }
          
      }
       
       

       

      'java > 코드 리뷰' 카테고리의 다른 글

      10. oop11 - (1) HTAListDemo (리스트 객체 반환)  (0) 2020.04.03
      10. oop10 - (1) Outer Demo (내부 클래스)  (0) 2020.04.03
      10. oop8 - (2) PersonDemo ( super() )  (0) 2020.04.02
      10. oop8 - (1) BookDemo (getter, setter 메서드)  (0) 2020.04.02
      10. oop7 - (2) ModifierDemo (다른 패키지, 접근 제한)  (0) 2020.04.02

      관련글 관련글 더보기

    Designed by Tistory.

    티스토리툴바