본문 바로가기

JAVA/특강

특강 2일차


20. 접근지정자(access modifier)

    : 종류 4가지
        - public (+)
             : 같은 클래스에서 접근 가능
             : 다른 클래스에서 접근 가능
             : 같은 패키지 접근 가능
             : 다른 패키지 접근 가능

                ==> 모두 접근 가능

        - protected (#)
             : 같은 클래스에서 접근 가능
             : 다른 클래스에서 접근 가능
             : 같은 패키지에서 접근 가능
             : 다른 패키지에서 접근 불가 ( 단, 상속관계면 접근 가능 )

        -                (friendly)
             : protected와 동일 ( 상속관계에서도 접근 불가능 )

        - private (-)
             : 같은 클래스 내에서만 접근 가능

     : 용도
         ====> 외부에서의 접근을 제한할 목적으로.

     : 적용가능한 곳

        - 클래스
           : public  (*)
           : private
           : (friendly)

         - 인스턴스 변수
            : public
            : private     (*)
            : protected
            :   (friendly)
              ====> 로컬변수에는 사용 불가

          - 메소드
            : public    (*)
            : private
            : (friendly)

          - 생성자
            : public    (*)
            : (friendly)
            : private


21. 은닉화

      : 정의
           ==> 외부에서의 접근을 차단.    ( 데이터 무결성 : 데이터를 결점없이 구현 )
           ==> 외부에서 접근하고자 하는 곳의 세부사항을 모르게 처리
                 ( 외부에서 신경쓰지 않게 하고자 하는 의도 )
                   : 자동차

            예> public class MyDate {

                        //은닉화
                        private int day;
                        private int month;
                        private int year;

                         //메소드
                         public int getDay(){ return day; }
                         public void setDay(int d){
                                   if(validday(d)){
                                            day = d;
                                   }else{

                                   }
                          }
                          //검증메소드
                          public boolean validDay(int d) { }
                    }

                   public class XXX {
 
                              public void xx() {
                                        MyDate d = new MyDate();
                                        //d.day = 44;     // 문법적으로 문제없지만, 논리적으로 문제있다.
                                        d.setDay(44);
                              }
                    }





22. Object 클래스

          - equals 메소드
                : 내부적으로 == 구현되어 있다.

          - toString 메소드
                : 

      * 값 비교 (동등 비교)

          1) PDT
                 : == 연산자 이용


                 예> int n = 3;
                       int x = 3;
                       if ( n == x )

          2) RDT
                 : equals 메소드 이용

                 예> String x = "Hello";
                       String y = "Hello";

                       if( x == y ) //==> 권장안함
                       if(x.equals(y)) // 권장




23. 다형성 ( poymorphism )

    - 상속 전제
    - 정의
         : 하나의 변수가 여러개의 타입을 가진 값을 저장하는 능력.

        예>
                Employee e = new Employee();
                Manager m = new Manager();

                 // 다형성
                 Employee e2 = new Manager();   // Employee와 Manager가 상속관계일 때!!!!!!!
                 Employee e3 = new Engineer();


            PDT(정수)

                long ( 큰 타입 )

              byte   short    int  ( 작은 타입 )

              int n = 2;
              long x = n;  ( 큰 타입에 작은 타입 넣는거니까 ㅇㅇ )


             RDT

                 Employee ( 큰 타입 )

              Manager           Engineer    ( 작은 타입 )

              Employee e = new Manager();   ( 큰 타입에 작은 타입 넣는 거니깐 ㅇㅇㅇㅇ )

      - 적용
          : 메소드 인자에서 주로 적용된다.

          예> 세금구하기

            1) 모든 클래스마다 각각 메소드 추가

                      Employee (taxEmployee())

          Manager (taxManager())              Engineer (taxEngineer())

              2) 부모 클래스에서 구현, 나머지는 받아서 사용

                      Employee (taxEmployee())
                       : 0.3

          Manager ()              Engineer ()
            : 0.2                        : 0.5


       * 객체 지향 프로그램 3대 특징
              - 상속
              - 은닉화
              - 다형성




24. 문자열 생성하는 방법

      1) 리터럴 이용
                : String n = "Hello";

      2) new 이용
                : String x = new String("Hello");

      3) toString() 메소드 이용

             예>
                   Date d = new Date();
                   System.out.println( d );

                   Person p = new Person("홍길동", 23);
                   System.out.println( p );

           =====> Object의 toString() 메소드는 클래스명@16진수 출력하게끔 구현.
                      사용자가 만든 클래스에서 실제 데이터를 출력하기 위해서
                      toString() 오버라이딩해서 사용하자. (디버깅용)......................... 이거 오른쪽마우스->source->toString 추가 있음 +_+ 신기신기 ㅋㅋㅋㅋㅋㅋㅋ

      4) + (연결 연산자)
          
            // 아래 예제는 문자열이 있을 때 뒤에 숫자도 문자열로 인식
          String x = "Hello" + 1 + 2 + 3; // Hello123 출력
          String y = 1 + 2 + 3 + "Hello"; // 6Hello

          예>
                int num = 123;
                String sss = num +"";  // 권장하진 않음

                 // "123" ------> 123

                 int x = Integer.paseInt("123");
                 System.out.println( x + 11 ); //134



25. 인터페이스 (interface)

      : *.java
      : 문법

           public interface 인터페이스명 {


           }

       : 구성요소

           - 상수
               : public static final
                예>
                       public static final int NUM = 2; // 변수와 구별하기 위해서 대문자로
                       
           - 추상메소드 ( abstrace method )

                   * 메소드 종류
                         1) 일반 메소드 ( concrete method )
                                : 구현된 메소드
                                : { }이 존재
                                예>
                                       public void a(){}

                          2) 추상 메소드 ( abstract method )
                                : 선언된 메소드
                                : { }이 없다.
                                : abstract
                                예>
                                       public abstract void a();



         : 특징
              - 추상메소드를 가지기 때문에 객체생성불가 ( new 사용 불가 )
              - 다른 클래스를 이용해서 인터페이스의 구성요소를 사용한다.
                   ( 인터페이스와 클래스의 관계는 '준상속관계'이다. )

              - UML 표기

                    <<Flyer>>  =======> 상수, 추상메소드만 존재
                                     =======> 객체 생성 불가
                                       implements 관계( 구현관계 : 준상속관계 )
                                     =======> 반드시 Flyer 인터페이스의 추상메소드를 구현해야 한다.
                                                   구현하지 않으면 에러난다.........ㅇㅇㅇ (*)
                      Bird     

                예> 날아다니는 것들의 공통점 : 이륙  (takeOff) , 비행  (fly)  , 착륙   (land)


                                <<Flyer>>
                                     : takeOff();
                                     : fly();
                                     : land();

                       Bird                 Airplane
                   : takeOff(){}          : takeOff(){}
                   : fly(){}                : fly(){}
                   : land(){}             : land(){}

       ======> 대표적인 형태는 JDBC ( Java DataBase Connerctivity )
                    : 자바의 데이터베이스 연동기술
                    : 대부분이 인터페이스로 되어있다.

       : 다중구현이 가능
          ( public class Bird extends CCC implements Flyer , AAA , BBB {}

       : 인터페이스 끼리 상속가능

            public interface AAA extends BBB {}


    - 재사용성 증대
    - 목적 및 장점
          : 하위클래스에게 특정 메소드를 사용하도록 강요하는 방법
          ===> 통일성 및 일관된 접근방법을 제공
          ===> 동일한 메소드를 사용한 재사용성 증대

                  




              - 재사용성 증대


Object를 인자로 받아서 쓰는게 일반적인 다형성!!

'JAVA > 특강' 카테고리의 다른 글

특강 4일차  (0) 2011.11.27
특강 1일차  (0) 2011.11.19