클라우드 기반 웹 개발자 과정 공부/JAVA

190415 Day6 이클립스 설치, 접근지정(제한)자, 자기참조연산자, 인터페이스, final, 클래스와 인터페이스 간의 상속 문법

용진용진 2019. 4. 15. 21:45

190415_6일차 이클립스 설치, 접근지정(제한)자, 자기참조연산자, 인터페이스, final, 클래스와 인터페이스 간의 상속 문법


이클립스 설치

  • 1555290513997
  • https://www.eclipse.org/downloads/packages/
  • 우리는 Enterprise용으로 받는다~! // 밑에 있는 버전은 자바만 개발 가능하고, 위의 버전은 자바도 가능하고 HTML, JavaScript, Spring, Git 등이 사용 가능하기 때문에!
  • 첫 화면에서 다운 받으면 .exe 실행파일 되기 때문에, zip 파일 선호, 자칫 실행파일로 설치하면 개발 설정을 바꿀 수도 있기에…

  • 1555292175950

  • 작업공간 설정

  • 1555292331690

  • 1555292361723

  • Open Perspective 는 작업환경~, 기본적으로 제공하는 플러그인, 자바 프로젝트 하면 보통 Java와 Java EE를 사용

  • 자바 클래스 = 자바 빈, 아직 우리는 Java로 한다!

  • /*
         * 이클립스 단축 키 : 메뉴 window - Preferences - General - Keys
         * 
         * Ctrl + space : 자동완성
         * Ctrl + 1 : 제안기능
         * Ctrl + / : 한줄 주석 추가, 삭제
         * Ctrl + Alt + 아래 화살표 : 설택된 블럭을 복사하여 아래로 붙여넣기
         * Alt + 위 아래 화살표 : 선택된 블럭을 위 아래로 이동
         */
  • 나는 폰트는 cambria로~!

  • 패키지 이름 달리하면 병합 할때 좋다. 그래서 com.~~~ 이런식으로 이름을 구성한다!

  • 웬만하면 Refector - rename 은 하지 말자, 할거면 그냥 코드 복사해서 붙여 넣는 방법이 더 좋음, 왜? 이클립스가 좋은 부분 중 하나가 작성하고 저장하면 히스토리를 다 남김,

  • //package선언 : 현재 프로그램(클래스)의 위치 지정
    //형식 ) package 상위패키지명, 하위패키지명;

    //import 선언 : 현재 프로그램(클래스) 에서 사용할 외부 클래스의 위치 지정
    //형식 ) import 패키지명, 클래스명;

//지난 과제
package com.encore.$0415;

import java.io.IOException;

//package선언 : 현재 프로그램(클래스)의 위치 지정
//형식 ) package 상위패키지명, 하위패키지명;

//import 선언 : 현재 프로그램(클래스) 에서 사용할 외부 클래스의 위치 지정
//형식 ) import 패키지명, 클래스명;

public class MenuTest 
{
    public static void main( String[] args ) throws IOException 
    //System.in.read() 하면 에러가 발생할 수도 있는데 예외처리 안할래! 라는 의미.
    // 왜 IOException을 예외처리할까? 지난번엔 그냥 Exception 이었는데, 
    //추후에 배운다!
    {
        int num;
        int su = 0;// 증가 또는 감소한 값을 유지하기 위해 반복문 밖에 선언
        do
        {
        System.out.println( " < < 메 뉴 > > " );
        System.out.println( "1. 검색  2. 증가  3. 감소  4. 종료" );
        System.out.print( "번호를 입력하세요 ==>> " );
        num = System.in.read() - 48;
                     System.in.read(); // CR (13) 맨 앞으로 이동
                     System.in.read(); // LF (10) 줄 바꿈

        switch(num)
            {
            case 1 : System.out.println( "#검색 결과\n" + su); break;
            case 2 : su++; System.out.println( "#1증가"); break;
            case 3 : su--; System.out.println( "#1감소"); break;
            }
        System.out.println();
        }while( num != 4 );
        //자바에서 { } 는 영역가로 Scope , Body 라고 말함, 

        System.out.println( "-- END --" );
    }
}

<접근지정(제한)자 : AccessControl>

  • public
    • 서로 다른 패키지에서도 접근가능
  • protected

    • 서로 같은 패키지에서 접근가능, 만약 상속관계를 갖는다면 자식에서 부모를 참조할 수 있는 것.
  • default

    • 생략, 서로 같은 패키지에서 접근가능
  • private
    • 같은 클래스 내에서만 멤버끼리만 접근 가능
##p1패키지
class Parent
{
    public void m1(){}
    protected void m2(){}
    void m3(){}
    private void m4()P{} //m1, m2, m3 만 호출 가능 다른 패키지, 클래스에서 불가
}

class Child extends Parent
{
    // m1, m2, m3 접근 가능하나 m4에서는 접근 불가
}

================================
##p2패키지
class Child extends Parent
{
    //m1 접근 가능, m2 접근 가능(부자 관계이기 때문), m3 불가, m4 불가
}
================================
##p3패키지
class other
{
    //m1만 호출 가능, 같은 패키지도 아니며 부자 클래스 관계도 아니기 때문
}
  • 접근 지정자 위치

    1. 필드

      • [접근지정자 4개] 자료형 변수명;
    2. 메소드

      • [접근지정자 4개] 리턴자료형 메소드명(매개변수){}
    3. 클래스

      • [접근지정자 2개 (public , default 만 가능)] class 클래스명 {}
      • 클래스인데 만약 private가 된다면 그냥 쓰레기임…
  • 접근 지정자 뭐 해야 하는데 고민이라면 그냥 public 깔아두고 생각해보자,

직접 해보자!

//p1패키지

package p1;

//기준!! (서로 다른 접근 제한자를 갖는 메소드 정의)
public class Parent { 

        public void m1()
        {
            System.out.println("m1");
        }
        protected void m2()
        {
            System.out.println("m2");
        }
        void m3()
        {
            System.out.println("m3");
        }
        private void m4()
        {
            System.out.println("m4");
        }

}

package p1;

//자식에서 부모클래스의 메소드 호출
public class Child extends Parent{

    void callTest() {
        m1();
        m2();
        m3();
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child
    }

}

package p1;

//자식에서 부모클래스의 메소드 호출
public class Other {

    void callTest() {
        //m1(); // 에러 The method m1() is undefined for the type Other
        //m2(); // 에러
        //m3(); // 에러
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child

        Parent p = new Parent();
        p.m1();
        p.m2();
        p.m3();
        //p.m4(); // 에러 , The method m4() from the type Parent is not visible
    }

}
//p2 패키지
package p2;
//import 안하면 패키지 달라서 에러
import p1.Parent;

//자식에서 부모클래스의 메소드 호출
public class Child extends Parent{
    void callTest() {
        m1();
        m2(); //같은 패키지에서 접근 가능하다 하지만 상속관계인 부자 패키지 관계이면 패키지가 달라도 접근 가능!
        //m3(); // 에러, 디폴트는 패키지가 다르면 호출 불가
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child
    }
}
//-------------------------
package p2;

import p1.Parent;

//자식에서 부모클래스의 메소드 호출
public class Other {
    void callTest() {
        //m1(); // 에러 The method m1() is undefined for the type Other
        //m2(); // 에러
        //m3(); // 에러
        //m4(); // 에러 The method m4() from the type Parent is not visible , 자식도 호출 불가
        //m5(); // 에러 The method m5() is undefined for the type Child

        Parent p = new Parent();
        p.m1(); // 왜 여기서는 에러가 발생하지 않은걸까요? public이기 때문~!
        //p.m2(); protected는 같은 패키지에서 접근 가능
        //p.m3(); 디폴트는 같은 패키지 내에서만 접근 가능
        //p.m4(); // 에러 , The method m4() from the type Parent is not visible
    }
}

자기 참조 연산자

  • 1반 홍길동, 2반 홍길동, 3반 홍길동 이 있는데 모두가 모인자리에서 특정 홍길동을 부를땐 2반 홍길동~! 이렇게 말해야 하지만, 2반 안에서 길동이를 찾을때는 굳이 그래야 하는 필요가 있을까? 보통은 생략하고 홍길동이라고 부른다 하지만 아래와 같은 경우에 사용한다!
  • 현재 클래스를 가르키는 레퍼런스 변수(참조변수)!
  • 보통은 생략

    1. 메소드 내에서 사용
    2. 객체 생성자내에서 다른 생성자를 호출시 사용
    3. 매개변수(지역변수)와 멤버변수(필드)를 구분하기 위해 멤버변수 앞에 this.을 붙여 사용.
//형식
this.필드명;
this.메솓명();
this(); //생성자 호출
//참고
super.필드명;
super.메소드명();
super(); //부모클래스 생성자 호출
  • 오른쪽 버튼 눌러서 - source - generate constructor using fields 로 쉽게 생성 가능

%생성자 만드는 단축키 컨 + 스 + 엔


인터페이스

  • 인터페이스는 메뉴판이다!, 유지보수하는데 이점이 있다.

    • 형식

    • “`java
      interface 인터페이스명
      {
      //필드
      [고정 public static final] int su;
      //여기서 static이란 new처럼 메모리 할당 할 수 있음
      //new는 동적메모리 할당, static은 정적 메모리 할당
      //여기서 final이란 마지막 변수라는 뜻, 절대 변하지 않는 수!

      //선언된 메소드
      [고정 public abstract] void print();
      //대괄호 생략 가능
      }

      
      - 저장 : 인터페이스명.java -> 컴파일 -> 인터페이스명.class
      
      - interface의 구성멤버는 필드, 선언된 메소드로만 구성
      
      - ```java
      void print()
      {
          //정의된 메소드, 구현된 메소드!
      }
      
      ///////////////////////선언된 메소드!
      void print(); // 기능 없이 이름만 선언된 메소드 ( 바디없는, 영역괄호 없는 메소드 )
      //단지 연결시켜준것, 메뉴판처럼 손님과 요리사를!

    < 손님의 입장 >

    • 서로 다른 제품에 연결할 수 있는 공통 연결 모듈을 의미.

    < 주방장의 입장 ( 객체를 생성하는 곳 ) >

    • 클래스에 다중 상속을 구현 할 수 있다.

    • ★ 인터페이스는 어떻게 사용? 클래스에 구현해서 사용!!

    • 구현 키워드 : implements

    • “`
      class 클래스명(//주방) implements(//구현의 약속) 인터페이스(//메뉴판)명
      {

    }
    “`

  • 실습

    package com.encore.$0415;
    
    public interface MenuPan 
    {
    // public static final 고정
    //final은 유지할 고정값을 명시해야 함
    
    
    //int coin; 에러 발생, 반드시 초기화 해야 함
    int coin = 500;
    /*public abstract 고정 생략*/void 짜장면();
    /*퍼블릭이 고정 생략*/abstract void 짬뽕(); //선언된 메소드 : abstract method
    public abstract void 볶음밥();
    }
    
    //============
    package com.encore.$0415;
    
    public class Hongkong implements MenuPan  //주방
    { 
    //implements : 구현의 약속
    @Override //어노테이션 JDK5버전 이후
    public void 짬뽕() 
    {
        System.out.println("매콤한 짬뽕");
    }
    @Override 
    public void 짜장면() 
    {
        System.out.println("달콤한 짜장면");  
    }
    @Override
    public void 볶음밥() 
    {
        System.out.println("갓볶은 볶음밥");  
    }
    public void 초밥() // 추가해도 상관 없다!
    {
        System.out.println("초밥 한입에 쏙~");
    }
    }
    
    //============
    package com.encore.$0415;
    
    public class InterfaceTest  //extedns String : 에러 발생
    {
    public static void main(String[] args) 
    {
        //손님
        MenuPan menu = new Hongkong(); 
        //인터페이스는 new 못씀
    
        menu.짬뽕();
        menu.짜장면();
        menu.볶음밥( );
    
        //static멤버는 클래스명으로 접근!!
        System.out.println("코인값 : " + MenuPan.coin);
    }
    }
    
    

Final

  1. final 자료형 변수명;

    • 마지막 변수 : 상수 (constant)
    • 상수의 식별을 위해 전체 대문자로 표기
    //예)
    final int max = 100;
    max++; >> 101 // 에러 발생!
  2. final 리턴형 메소드명 () {}

    • 마지막 메소드 : 오버라이딩(메소드 재정의) 할 수 없는 메소드.
  3. final class 클래스명{}

    • 마지막 클래스 : 클래스는 자식클래스를 통해 기능을 확장하는데, final 클래스는 무자식상팔자 클래스 : 자식 클래스를 갖지 않는 클래스
    • 완벽한 클래스(자식클래스 통한 기능확장을 원치 않는다.)
    • 보안적인 측면에서 사용하기도 함

<클래스와 인터페이스 간의 상속 문법>

class A{}

class B extends A //extends 뒤에는 상속 받고자 하는 한개의 클래스 명만 정의! 
{
    //extends 는 확장의 의미를 갖는다. 자식클래스를 확장 클래스라고도 함   
}
//============================================
interface A
{}
interface B
{}

class C implements A,B 
{}
//위와 대조하여 클래스는 무조건 한개의 클래스만 상속 가능하지만 interface는 , 를 사용하여 다중 인터페이스를 다중 상속 할 수 있다
// A와 B인터페이스 내의 선언된 메소드를 C클래스에서 전부 구현!, 구현의 약속!
//============================================
interface A{}
class B{}

//class C implements A extends B? 
// 얘는 에러가 발생함
//클래스와 인터페이스를 동시에 상속 할때에는 순서가 중요하다.
//클래스를 먼저 상속 받고 인터페이스는 나중에!
//implements가 먼저 나오면 컴파일러가 extends Object를 implements 키워드 앞에 추가해줌! 그래서 implements 가 두개가 되어버리는것... 에러!

class C extends B implements A // 로 해줘야 한다!
{

}

//============================================
interface A { void hello(); }
interface B { void hi(); }

interface C implements A,B {} 는 에러
interface C extends A,B {}
/*interface C extends A,B 
{
    void hello();
    void hi();

}
*/ //이렇게 기능을 가져오겠데...
//엥 이건 무슨 소리야?!
//A 안에는 hello(); 선언되어있음, hi();

//============================================
class A {void hello(){}}
interface B ㅁ A {} // 이런 경우는 절대 없다. 말이 안됨 extends는 내려준다라는 뜻인데 중괄호 있는 애를 어케 내려줌, 
// 주방을 물려받는 메뉴판은 없다.
  • mission

    package com.encore.$0415.misson;
    
    import java.io.IOException;
    
    /*
    * 기능정의
    * -단입력
    *    int inputDan ()
    * {
    *    int dan = read() 또는 readLine() 을 사용해서 받기 //그리고 단출력에 전달해야 함, return 타입 통해
    * }
    * 
    * -단출력
    *    void outputDan () 
    * {
    *    //전달받은 dan에 대한 출력
    * }
    * -계속여부
    *    char continueDan () 
    * {
    *    read() 또는 readLine()
    * }
    */
    
    public class Gugudan 
    {
    //public int dan;//=0
    //public char continuedan;//='\u0000'
    
    
    int inputDan() throws IOException
    {
        System.out.println("point");
        System.out.println("원하시는 단을 입력해주세요");
        int dan = System.in.read() - 48;
        System.in.read();
        System.in.read();
        return dan;
    
    }
    
    void outputDan(int dan)
    {
        System.out.println(dan + "단 구구단 출력");
        for (int i = 1; i <10; i++)
        {
            System.out.println(dan + "X" + i + " = " +  dan*i) ;
        }
    }
    
    char continueDan() throws IOException
    {
        System.out.println("계속하시겠습니까?");
        char continuedan = (char) (System.in.read());
        System.out.println(continuedan);
        System.in.read();
        System.in.read();
        return continuedan;
    
    }
    
    }
    
    
    //----------------
    
    package com.encore.$0415.misson;
    
    import java.io.IOException;
    
    /*
    * main() 포함
    * 반복적인 실행을 할 것(while 또는 do~while 사용 하면 됨)
    * 이번은 while로 해보자!
    * 반복문 내에서 Gugudan클래스 안에 3개의 메소드가 있는데 3개의 메소드들을 적당히 호출.
    */
    
    public class GugudanTest extends Gugudan
    {
    
    public static void main( String[] args) throws IOException
    {
        Gugudan g = new Gugudan(); 
    
    
        System.out.println("구구단");
    
        int dan = g.inputDan();
        g.outputDan(dan);
    
    //        
    //        g.inputDan();
    //        g.outputDan(dan);
    //        g.continueDan();
    //        
    
        while(g.continueDan() == 'y' )
        {
            dan = g.inputDan();
            g.outputDan(dan);
        }
            System.out.println("종료");
    }
    
    }
    
궁금상자
    - 패키지 이름 2개 이상 권장하는 이유?

    - jdbc

    - 어노테이션?

    - throw와 throws의 차이
        https://jhkim2017.wordpress.com/2017/04/24/java-throws%EC%99%80-throw%EC%9D%98-%EC%B0%A8%EC%9D%B4/
    - 자바 프로젝트 패키지 클래스 이해
        https://skyilcts.tistory.com/5
    - 패키지
        https://opentutorials.org/course/2517/14135
    - 인터패이스 패키지
        https://nittaku.tistory.com/46
        https://studymake.tistory.com/428
        https://opentutorials.org/module/2495/14142
    -