maven은 dependency 엘리먼트 하위의 scope 엘리먼트를 통해 포함하려는 라이브러리의 범위를 지정할 수 있다. Maven 3에서는 다음의 여섯가지 옵션을 지원하고 있다. compile : 기본 scope이다. 만약 dependency에 아무것도 입력하지 않았다면 기본적으로 입력되는 scope이다. 이 옵션은 프로젝트의 모든 classpath에 추가된다(테스트 중이건 런타임 중이건 상관없이). provided : 이 옵션은 compile과 매우 비슷하지만, 실행시 의존관계를 제공하는 JDK나 Web Container(tomcat 같은)에 대해서 적용된다. 예를 들어 Java Enterprise Edition Web application을 개발할때 Servlet API나 Java EE API들은 "provided" scope로 지정해야한다. 왜냐하면 Servlet API같은 경우는 Servlet Container 자체에서 지원해 주기 때문에(Tomcat 같은 경우는 ${tomcat home directory}/lib 디렉토리에 있는 Servlet 라이브러리를 사용) 컴파일시 또는 테스트시에는 필요하지만 실행시에는 필요하지 않기 때문이다. runtime : 컴파일 시에는 필요하지 않지만 실행시에 사용되는 경우 사용한다. 이 옵션은 런타임, 테스트 시 classpath에 추가 되지만, 컴파일시에는 추가 되지 않는다. test : 일반적인 경우에는 필요하지 않고 테스트시에만 필요한 경우 사용한다. system : 해당 jar를 포함해야 한다고 명시적으로 입력 하는 것을 제외하고는 provided와 유사하다. 선언된 artifact들은 항상 사용가능하지만 Maven의 central repository에서 찾아서 가져오는 것은 아니다. import : Maven 2.0.9 이상의 버전에서 지원하는 scope로서, 이 scope는 섹션에서 pom의 의존관계에 대해 사용된다. 지정된 pom이 해당 pom의 영역에 있는 의존관계로 대체됨을 뜻한다. 자세한 예제는 메이븐 공식 홈페이지 에서 확인할 수 있다.

출처: https://krespo.net/166 [KRESPO.NET]

os환경: windows10

db환경: Oracle Database 11g Express Edition Release 11.2.0.2.0

error:ORA-12514, TNS:listener does not currently know of service requested in connect descriptor

접속하기 위한 작성된 코드의 오타 ==> 오라클의 SID, SERVICE_NAME은 대소문자를 반드시 구분하여 기술해야 한다.

host아래 Database에 들어가야할 Service name을 잘못 적어서 나오는 에러였다. 이런 에러가 나오면 본인의 오라클 정보를 확인하자!

1. pom.xml:ojdbc6(+repository),mybatis,mybatis-spring,commoms-dbcp,spring-orm을 설치
2. web.xml:applicationContext.xml 변경, mapping(*,do), encoding filter 설정
3. /WEB-INF/spring/sqls/myboard.sql
4. DTO,DAO,BIZ,controller
5. src/main/resources/mybatis/board-mapper.xml
6. src/main/resources/mybatis/db.properties
7. /web-inf/spring/sqls/config.xml
8. applicationContext.xml, servlet-context.xml 을 가지고 놀것이다.

_filter 9. com/mvc/upgrade/common/filter/LogFilter(impl javax.servlet.Filter) 10. web.xml:filter

_aop 11. pom.xml : aspectjweaver, aspectjrt 12. com/mvc/upgrade/common/aop/LogAop 13. WEB-INF/spring/appServlet/aop-context.xml 14. web.xml : aop-context.xml 추가(init-param) 15. src/main/resources/log4j.xml(logger추가 및 log level변경 - trace) 16. pom.xml:jackson-core-asl,jsckson-mapper-asl(spring 4.x 이후부터는 변경된) 17.web-inf/spring/sqls/mymember.sql

_login 18.dto,dao,biz,controller 19.src/main/resources/mybatis/member-mapper.xml 20.web-inf/spring/sqls/config.xml

_intercepter 21. com/mvc/upgrade/common/intercepter/LoginIntercepter(impl HandlerIntercepter) 22. servlet-context.xml:인터셉터 추가

_transaction

23. (Board)dao,biz,controller 에 무엇인가 추가.
24. servlet-context.xml :tx(namespace)추가
25. applicationContext.xml:transactionManager

_security 26. pom.xml:spring-security-web 27. /WEB-INF/spring/appServlet/secutity-context.xml 28. web.xml:security-context.xml 추가

spring version upgrade 방법 1.web.xml:2.5->4.0 (dynamic web project 만들면서 web module 설정을 4.0으로 생성->생성된 web.xml 부분 복사해서 스프링에 붙여넣기)

2.pom.xml java:1.6->1.8 springframework-version:3.1.1->원하는 버전 servlet-api:2.5->4.0.1(servlet-api->javax.servlet-api) jsp-api:2.1->2.3.3(jsp-api->javax.servlet.jsp-api) maven-compiler-plugin:source/target 둘다 1.6->1.8

3.project facet dynamic web module 2.5->4.0 java 1.6->1.8

4.maven update

서버쪽에서 실행되면서 클라이언트의 요청에 따라 동적으로 서비스를 제공하는 자바 클래스.(클라이언트의 HTTP요청에 대해 특정 기능을 수행, HTML 문서를 생성등의 응답을 하는 인터넷 서버 프로그램.)

2.서블릿 컨테이너

서블릿을 관리하면서 , 서블릿의 생명주기를 관리하고, 요청에 따라 스레드를 생성해준다. 또 클라이언트의 Request를 받아주고 Response를 보낼 수 있게 웹 서버와 소켓을 만들어서 통신을 해준다.

3. 톰캣

톰캣은 서블릿 컨테이너이다. 톰캣은 웹 서버와 연동하여 실행할 수 있는 자바 환경을 제공하여 자바 서버페이지와 자바 서블릿이 실행할 수 있는 환경을 제공하고 있다.

웹서버와 WAS참조http://blog.naver.com/PostView.nhnblogId=ssohyuny2000&logNo=155249496 출처:https://jusungpark.tistory.com/15

JDBC(Java Database Connectivity)는 자바에서 데이터베이스에 접속할 수 있도록 하는 자바 API이다.

ojdbc:오라클 사이트에서 자바와 오라클 데이터베이스의 연동을 위한 ojdbc 라이브러리를 제공하고 있고

mybatis정리:https://velog.io/@changyeonyoo/Mybatis%EB%9E%80-%EC%9E%A5%EC%A0%90-%ED%8A%B9%EC%A7%95-%EC%BB%B4%ED%8F%AC%EB%84%8C%ED%8A%B8

필터란?:https://twofootdog.github.io/Spring-%ED%95%84%ED%84%B0(Filter)%EB%9E%80-%EB%AC%B4%EC%97%87%EC%9D%B8%EA%B0%80/

resoueces 폴더패턴들-> https://gocoder.tistory.com/1105

스피일 폴더구성 -> https://codevang.tistory.com/240

스프링 필터-AOP-interceptor:https://yzlosmik.tistory.com/24

log https://to-dy.tistory.com/20

spring https://victorydntmd.tistory.com/176

static https://mangkyu.tistory.com/47?category=872426

lombok https://advenoh.tistory.com/24

👀이 글은 제가 공부한 것들을 잊어버리지 않기 위해 정리해 놓은 것입니다.

📌web.xml이란?

웹 어플리케이션의 배포설명자로, 각 어플리케이션의 환경을 설정하는 역할을 한다.

(서버 작동이 가능하도록 servlet 정보를 설정함.)

(브라우저가 Java Servlet에 접근하기 위해서는 WAS(Ex. Tomcat)에 필요한 정보를 알려줘야 해당하는Servlet을 호출할 수 있다.)

📌maven이란?

출처:https://velog.io/@changyeonyoo/Maven-%EC%9D%B4%EB%9E%80

📌pom.xml이란?

프로젝트의 중요한 정보를 정의하고 정리하기 위한 곳이다.

대부분 Maven의 중요 설정파일들이 들어가있으며, 라이브러리를 추가함으로써, 불러오는 기능인 '의존성' 이 있으며, 실제 라이브러리 파일이 저장되어 있는 저장소 서버의 위치를 지정하고, 사용할 라이브러리를 지정해줍니다.

그렇기 때문에, Maven을 통해서 라이브러리를 설정해놓고 잘 관리한다면, jar파일을 보다 pom.xml 파일만 관리하면 됩니다.

출처:https://m.blog.naver.com/rla99tjr/221862232097

👀이 글은 제가 공부한 것들을 잊어버리지 않기 위해 정리해 놓은 것입니다.

@ModelAttribute

사용자 요청시 전달하는 값은 오브젝트 형태로 전달한다. 메소드레벨 그리고 메소드 파라미터에 적용가능하다.

👀이 글은 제가 공부한 것들을 잊어버리지 않기 위해 정리해 놓은 것입니다.

AOP(Aspect - Oriented - Programing): 관점지향 프로그래밍.

✔AOP는 spring이 아니라 방법론이다.

✔사용자가 원하는 관점의 업무(주업무-객체지향)이 아닌,

개발자가 원하는 관점의 업무(로그,보안,트랜잭션...)을 말한다.

✔공통 관심 사항(로그,보안,트랜잭션...)은 프록시 객체로 따로 빼어 놓고 사용한다.

📌용어정리.

프록시 객체:

타겟(cc)을 호출하면 자기가 타겟(cc)인 척 호출되어 타겟(cc)에 지정된 어드바이스를 첨가해서 타겟에게 건내줌(ccc가 붙어서 나옴). 그러면 타겟은 그걸 뿌림.

출처:https://www.youtube.com/watch?v=y2JkXjOocZ4

👀이 글은 제가 공부한 것들을 잊어버리지 않기 위해 정리해 놓은 것입니다.

13.1 제네릭을 사용하는 이유는?

제네릭 정의: 클래스, 인터페이스, 메소드를 정의할 때 타입을 파라미터로 사용할 수 있도록 해준다.

✨컴파일에서 잘못된 타입을 검사해 준다.

✨타입 변환을 제거한다.

List list = new ArrayList();
list.add("hello");
String str = (String)list.get(0);


List<String> list = new ArrayList<String>();     
list.add("hello");
String str = list.get(0);

13.2 제네릭 타입(class< T >,interface< T >)

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

사용이유: ✨타입 변환을 제거한다.

public class Box<T>{
    private T t;                     //T는 Box클래스를 객체로 생성할 때 구체적인 타입으로 변경된다.
    public T get() {return t;}
    public void set(T t) {this.t = t; }

}



Box<String> box = new Box<String>();

public class Box<String> {              //객체가 생성되면서 타입이 바뀜.
    private String t;
    public String get() {return t;}
    public void set(String t) {this.t = t;}

}

13.3 멀티 타입 파라미터(class<k,v,...>,interface<k,v,...>)

제네릭 타입은 두 개 이상의 타입 파라미터를 사용할 수 있다.

public class Product<T, M> {
    private T kind;
    private M model;

    public T getKind() {
        return kind;
    }

    public M getModel() {
        return model;
    }

    public void setKind(T kind) {
        this.kind = kind;
    }

    public void setModel(M model) {
        this.model = model;
    }
}


public static void main(String[] args) {

    Product<TV, String> product1 = new Product<TV, String>();
    product1.setKind(new TV());
    product1.setModel("스마트TV");

    TV tv = product1.getKind();
    String tvModel = product1.getKind();

    Product<Car, String> product1 = new Product<Car, String>();
    product1.setKind(new Car());
    product1.setModel("디젤");

    Car tv = product1.getKind();
    String carModel = product1.getKind();

}

13.4 제네릭 메소드(< T, R > R method (T t))

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

🎈예제1
public < 타입 파라미터 >  리턴타입  메소드면(매개변수,....){.....}

🎈예제2
public class Util {

    public static <T> Box<T> boxing(T t){

        Box<T> box = new Box<T>();
        box.set(t);

        return box;

        }
}



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

        Box<Integer> box1 = Util.<Integer>boxing(100); //🎃제네릭 메소드 호출방법1
        int intvalue = box1.get();

        Box<String> box2 = Util.boxing("홍길동");       //🎃제네릭 메소드 호출방법2
        String strvalue = box1.get();

    }
}

🎈예제3
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 {

    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {

        boolean keyCompare = p1.getKey().equals(p2.getKey());
        boolean valCompare = p1.getValue().equals(p2.getValue());

        return keyCompare && valCompare;
    }

}
public class CompareMethodExample {

    public static void main(String[] args) {

        Pair<Integer , String> p1 = new Pair<Integer, String>(1, "사과");
        Pair<Integer , String> p2 = new Pair<Integer, String>(1, "사과");

        boolean result1 = Util.<Integer, String>compare(p1, p2);
        if(result1) {
            System.out.println("논리적으로 동등하다1.");
        }else {
            System.out.println("논리적으로 동등하지 않다1.");
        }

        Pair<String , String> p3 = new Pair<String, String>("user1", "사과");
        Pair<String , String> p4 = new Pair<String, String>("user2", "사과");

        boolean result2 = Util.compare(p3, p4);
        if(result2) {
            System.out.println("논리적으로 동등하다2.");
        }else {
            System.out.println("논리적으로 동등하지 않다2.");
        }



    }

}

13.5 제한된 타입 파라미터(< T extends 최상위 타입 >)

타입 파라미터에 구체적인 타입을 제한할 때 사용한다.

상위 타입은 클래스뿐만 아니라 인터페이스도 가능하다.

인터페이스라고 해서 Implements를 사용하지 않는다.

🎈예제1
public class Util {

    public static <T extends Number> int compare(T t1, T t2) {
        double v1 = t1.doubleValue();
        double v2 = t2.doubleValue();

        return Double.compare(v1, v2);
    }

}

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

        // String str = Util.compare("a", "b"); String은 Number타입이 아님.

        int result = Util.compare(10, 20);
        System.out.println(result);

        int result2 = Util.compare(4.5, 3);
        System.out.println(result2);

    }

}

13.6 와일드카드 타입(< ? >, < ? extends...>, < ? super...>)

제네릭 타입을 매개값이나 리턴 타입으로 사용할 떄 구체적인 타입대신 와일드 카드를 사용할 수 있다.

수강생이 될 수 있는 타입은 4가지 클래스라고 가정하자.

🎈예제1
public class Course<T> {

    private String name;
    private T[] students;

    public Course(String name, int capacity) {
        this.name = name;
        students = (T[]) (new Object[capacity]);
    }

    public String getName() {
        return name;
    }

    public T[] getStudents() {
        return students;
    }

    public void add(T t) {
        for (int i = 0; i < students.length; i++) {
            if (students[i] == null) {
                students[i] = t;
                break;
            }
        }
    }

}


public class WildCardExample {

    public static void registerCourse(Course<?> course) {// 수강생은 모든 타입일 될수 있다.
        System.out.println(course.getName() + "수강생" + Arrays.toString(course.getStudents()));

    }
    public static void registerCourseStudent(Course<? extends Student> course) {// 수강생은 student,highstudent.
        System.out.println(course.getName() + "수강생" + Arrays.toString(course.getStudents()));

    }
    public static void registerCourseWorker(Course<? super Worker> course) {// 수강생은 worker, person 타입일 될수 있다.
        System.out.println(course.getName() + "수강생" + Arrays.toString(course.getStudents()));

    }

    public static void main(String[] args) {
        Course<Person> personCourse = new Course<Person>("일반인과정", 5);
        personCourse.add(new Person("일반인"));
        personCourse.add(new Worker("직장인"));
        personCourse.add(new Student("학생"));
        personCourse.add(new HighStudent("고등학생"));

        Course<Worker> workerCourse = new Course<Worker>("작장인과정", 5);
        workerCourse.add(new Worker("직장인"));

        Course<Student> studentCourse = new Course<Student>("학생과정", 5);
        studentCourse.add(new Student("학생"));
        studentCourse.add(new HighStudent("고등학생"));

        Course<HighStudent> highCourse = new Course<HighStudent>("고등학생과정", 5);
        highCourse.add(new HighStudent("고등학생"));

        System.out.println("----------------------------------");
        registerCourse(personCourse);//모든 과정 등록 가능
        registerCourse(workerCourse);
        registerCourse(studentCourse);
        registerCourse(highCourse);
        System.out.println();

        //registerCourseStudent(personCourse); X
        //registerCourseStudent(workerCourse); X
        registerCourseStudent(studentCourse);  //학생 과정만 등록 가능
        registerCourseStudent(highCourse);

        registerCourseWorker(workerCourse);//직장인과 일반인 과정만 등록 가능.
        registerCourseWorker(personCourse);

    }

}

13.7 제네릭 타입의 상속과 구현

제네릭 타입도 다른 타입과 마찬가지로 부모 클래스가 될수 있다.

public class ChildProduct<T,M> extends ParentProduct<T,M>{....}
//자식 제네릭 타입은 추가적으로 타입 파라미터를 가질 수 있다.
public class ChildProduct<T,M,C> extends ParentProduct<T,M>{....}

🎈예제1
//부모 제네릭 클래스
public class Product<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;
    }

}

class Tv {
}

//자식 제네릭 클래스
public class ChildProduct <T,M,C> extends Product<T, M>{
    private C company;

    public C getCompany() {
        return company;
    }

    public void setCompany(C company) {
        this.company = company;
    }


}

//제네릭 인터페이스
public interface Storage<T> {
    public void add(T item, int index);

    public T get(int index);
}

//제네릭 구현 클래스
public class StorageImpl<T> implements Storage<T> {

    private T[] array;

    public StorageImpl(int capacity) {
        this.array = (T[])(new Object[capacity]);
    }

    @Override
    public void add(T item, int index) {

    }

    @Override
    public T get(int index) {

        return null;
    }

}

//제네릭 타입 사용 클래스
public class ChildProductAndStorageExample {

    public static void main(String[] args) {
        ChildProduct<Tv, String, String> product = new ChildProduct<>();
        product.setKind(new Tv());
        product.setModel("SmartTv");
        product.setCompany("samsong");

        Storage<Tv> storage = new StorageImpl<Tv>(100);
        storage.add(new Tv(), 0);
        Tv tv = storage.get(0);


    }
}

이 글은 제가 공부한 것들을 정리한 것입니다.

10.1 예외와 예외클래스

에러: 하드웨어 오작동

예외: 사용자의 잘못된 조작, 개발자의 잘못된 코딩.

예외 종류

-일반예외(Exception),실행예외(RuntimeExceiption)

✔일반예외

• 컴파일 하는 과정에서 예외처리코드가 필요한지 검사한다.

• 만약 예외처리가 필요한 코드에 예외 처리 코드가 없다면 컴파일 오류가 발생한다. * 일반예외는 Exception을 상속받지만 RuntimeException을 상속받지 않는다.

  ✔실행예외

• 컴파일시 예외 처리를 확인하지 않는다.

• RuntimeException을 상속받는 클래스들이다. RuntimeException 역시 Exception을 상속받지만 JVM은 RuntimeException을 상속했는지 여부를 보고 실행예외를 판단한다.

  10.2 실행예외

  10.2.1 NullPointerException

  10.2.2 ArrayIndexOutOfBoundException

  10.2.3 NuberFormatException

  10.2.4 ClassCastException

  10.3 예외처리 코드

  ✨일반 예외처리
  public class TryCatchFinallyExample {
  
    public static void main(String[] args) {
  
        try {
            Class Class = Class.forName("java.lang.String2");
        } catch (ClassNotFoundException e) {
            System.out.println("클래스가 존재하지 않습니다.");
            e.printStackTrace();
        }
    }
  

}

✨실행예외처리 - 오로지 개발자의 경험에 의해 작성해주어야 한다. public class TryCatchFinallyRuntimeExceptionExample {

public static void main(String[] args) {
    String data1 = null;
    String data2 = null;

    try {
        data1 = args[0];
        data2 = args[1];
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("실행 매개값의 수가 부족하다.");
        System.out.println("[실행 방법]");
        return;

    }

    try {
        int value1 = Integer.parseInt(data1);
        int value2 = Integer.parseInt(data2);
        int result = value1 + value2;

    } catch (NumberFormatException e) {
         System.out.println("숫자로 변환 할 수 없습니다.");
    } finally {
        System.out.println("다시 실행 하세요.");
    }
}

}

### 10.4 예외종류에 따른 처리 코드
#### 10.4.1 다중 catch

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

    try {
        String data1 = args[0];
        String data2 = args[1];

        int value1 = Integer.parseInt(data1);// 여기는 실행이 안된다.
        int value2 = Integer.parseInt(data2);
        int result = value1 + value2;
        System.out.println(data1 + "+" + data2 + "=" + result);

    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("실행 매개값의 수가 부족하다.");
        System.out.println("[실행 방법]");


    } catch (NumberFormatException e) {
        System.out.println("숫자로 변환 할 수 없습니다.");
    } finally {
        System.out.println("다시 실행 하세요.");
    }
}

}

#### catch 블록이 여러 개라 할지라도 하나만 실행된다. try 블록에서 동시 다발적으로 예외가 발생하지 ㅇ낳고 하나의 예외가 발생하면 즉시 실행을 멈추고 해당 catch블록으로 이동하기 때문이다. 
### 10.4.2 catch 순서
#### 다중 catch블록 작성시 주의할 점은 상위 예외 클래스가 하위 예외 클래스보다 아래에 위치해야 한다. 하위 예외는 상위 예외를 상속했기 때문에 상위 예외 타입도 되기 때문이다.
### 10.4.3 멀티 catch

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

    try {
        String data1 = args[0];
        String data2 = args[1];

        int value1 = Integer.parseInt(data1);
        int value2 = Integer.parseInt(data2);
        int result = value1 + value2;
        System.out.println(data1 + "+" + data2 + "=" + result);
    } catch (ArrayIndexOutOfBoundsException | NumberFormatException e) {
        System.out.println("실행 매개값의 수가 부족하거나 숫자로 변환할 수 없습니다.");

    } catch (Exception e) {
        System.out.println("알수 없는 예외.");
    } finally {
        System.out.println("다시 실행 하세요.");
    }
}

}

### 10.5 자동 리소스 닫기
### 자바 7에서 새로 추가된 try-with-resources 를 사용하면 예외 발생 여부와 상관없이 사용했던 리소스 객체(각종 입출력 스트림, 서버 소켓, 소켓 , 각종 채널)의 close()메소드를 호출해서 안전하게 리소스를 닫아준다.
#### 리소스는 간단히 데이터를 읽고 쓰는 객체라고 생각하자.

FileInputStream fis = null; try { fis = new FileInputStream("file.txt"); } catch (FileNotFoundException e) {

    } finally {

        if (fis != null) {
            try {
                fis.close();
            } catch (IOException e) {

            }
        }
    }

//✨자바 7에서 새로 추가됬다.

try (FileInputStream fis = new FileInputStream("file.txt")) {

    } catch (IOException e) {

    }

//✨try 블록이 정상적으로 실행을 완료했거나 예외가 발생하게 되면 자동으로 FileInputStream의 close() 메소드가 호출된다.

//✨복수개의 리소스를 작성할 수 도 있다.

try (FileInputStream fis1 = new FileInputStream("file.txt"); FileInputStream fis2 = new FileInputStream("file.txt")) {

    } catch (IOException e) {

    }

//✨try - with - resources를 사용하기 위해서는 조건이 있는데 리소스 객체는 java.lang.AutoCloseable 인터페이스를 구현하고 있어야 한다.

public class FileInputStream implements AutoCloseable {

private String file;

public FileInputStream(String file) {
    this.file = file;
}

public void read() {
    System.out.println(file + "를 읽습니다.");
}

@Override
public void close() throws Exception {
    System.out.println(file + "를 닫습니다.");

}

}

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

    try (FileInputStream fis = new FileInputStream("file.txt")) {
        fis.read();
        throw new Exception();// 강제로 예외 발생
    } catch (Exception e) {
        System.out.println("예외처리 코드가 실행되었습니다.");
    }
}

}

### 10.6 예외 떠넘기기
#### 메소드 내부에서 예외가 발생할 수 있는 코드를 try-catch 구문으로 예외를 처리하는 것이 기본이지만, 메소드를 호출한 곳으로 예외를 떠넘길 수 도 있다. 이때 사용하는 키워드가 <span style="color:red">throws</span>이다.

public void method1() { try { method2(); } catch (ClassNotFoundException e) { System.out.println("클래스가 존재하지 않습니다."); } }

public void method2() throws ClassNotFoundException{ Class class = Class.forName("java.lang.String2"); }

### 10.7 사용자 정의 예외와 예외 발생
#### 자바에서 제공하는 클래스만으로 다양한 예외를  표현할 수가 없다. 예를 들어 은행업무를 처리하는 프로그램에서 잔고보다 더 많은 출금 요청이 들어왔을 경우 오류가 되며 잔고 부족 오료를 발생시킬 필요가 있는데, 잔고부족 API는 자바에 존재하지 않는다. 이럴 경우 개발자가 직접 정의해서 만들어야 하므로 사용자 정의 예외라고 한다.
### 10.7.1 사용자 정의 예외 클래스 선언

public class BalanceInsufficientException extends Exception { //사용자 정의 예외 클래스 이름은 Exception으로 끝나는 것이 좋다. //사용자 정의 예외 클래스도 필드, 생성자, 메소드 선언들을 포함할 수 있지만, //대부분 생성자 선언만을 포함한다. //생성자는 두개가 일반적인데,하나는 기본생성자 //다른 하나는 예외 발생 원인을 전달하기 위해 Stirng 타입의 매개 변수를 갖는 생성자이다. //String 타입의 매개변수를 갖는 생성자는 상위 클래스의 생성자를 //호출하여 예외 메시지를 넘겨준다. public BalanceInsufficientException() { }

public BalanceInsufficientException(String message) {
    super(message);
}

}

public class Account {

private long balance;

public Account() {
}

public long getBalance() {
    return balance;
}

public void deposit(int money) {
    balance += money;
}

public void withdraw(int money) throws BalanceInsufficientException {

    if (money > balance) {
        throw new BalanceInsufficientException("잔고 부족: " + (money - balance) + "이 모자람.");
    }
    balance -= money;
}

}

public class AccountExample {

public static void main(String[] args) {
    Account acc = new Account();
    acc.deposit(10000);
    System.out.println("예금액:" + acc.getBalance());
    try {
        acc.withdraw(30000);
    } catch (BalanceInsufficientException e) {
        System.out.println("meassage:" + e.getMessage());
        System.out.println();
        e.printStackTrace();
    }
}

}

04-1 뷰 라우터

✔라우팅이란?

웹 페이지 간의 이동 방법을 말한다. 싱글 페이지 애플리케이션에서 주로 사용하고 있다.

✔싱글 페이지 어플리케이션이란?

페이지를 이동할 때마다 서버에 웹 페이지를 요청하여 새로 갱신하는 것이 아니라 미리 해당 페이지들을 받아 놓고 페이지 이동 시에 클라이언트의 라우팅을 이용하여 화면을 갱신하는 패턴을 적용한 애플리케이션이다.

✔뷰 라우터: 뷰에서 라우팅 기술을 구현 할 수 있도록 지원하는 공식 라이브러리 이다.

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <h1>뷰 라우터 예제</h1>
        <p>
            <router-link to="/main">Main component</router-link> <!-- 1.url 값을 변경하는 태그-->
            <router-link to="/login">Login component</router-link>
        </p>
        <router-view></router-view><!-- 2.url 값에 따라 갱신되는 화면영역 -->

    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script src="https://unpkg.com/vue-router@3.0.1/dist/vue-router.js"></script>
    <script>
        var Main = { template: '<div>main</div>' };// 3. 컴포넌트 정의
        var Login = { template: '<div>login</div>' };

        var routes = [
            { path: '/main', component: Main },// 4. 각url에맞춰 컴포넌트 지정 
            { path: '/login', component: Login }

        ];

        var router = new VueRouter({//5. 뷰라우터정의
         //   mode:'history',  주소에 해시값을없애고싶을떄 
            routes
        });

        var app = new Vue({         //6. 뷰객체에 라우터추가
            router
        }).$mount("#app");  // el 속성과같다 
    </script>
</body>

</html>

✔ 네스티드 라우터: 상위 컴포넌트가 하위 컴포넌트를 포함하는 형식.

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <router-view></router-view>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script src="https://unpkg.com/vue-router@3.0.1/dist/vue-router.js"></script>
    <script>
        var User = {
            template: '<div>User component<router-view></router-view></div>'
        }

        var UserProfile = { template: '<p>User Profile Component</p>' }
        var UserPost = { template: '<p>User Post Component</p>' }

        var routes = [
            {
                path: '/user',
                component: User,

                children: [{
                    path: 'posts',
                    component: UserPost
                },{
                    path:'profile',
                    component:UserProfile
                }
                ]

            }
        ]

        var router = new VueRouter({
            routes
        });

        var app = new Vue({
            router
        }).$mount("#app");
    </script>
</body>

</html>

✔네임드 뷰: 같은 레벨에서 여러 개의 컴포넌트를 한 번에 표시한다.

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <router-view name="header"></router-view>
        <router-view></router-view> <!-- name이없는경우 defalut-->
        <router-view name="footer"></router-view>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script src="https://unpkg.com/vue-router@3.0.1/dist/vue-router.js"></script>
    <script>

        var Body = { template: '<div> This is Body</div>' };
        var Header = { template: '<div>This is Header</div>' };
        var Footer = { template: '<div>This is Footer</div>' };

        var router = new VueRouter({
            routes: [
                {
                    path: '/',
                    components: {
                        default: Body,
                        header: Header, //router-view 의 name속성과 컴포넌트를 연결.
                        footer: Footer
                    }
                }
            ]
        });

        var app = new Vue({ router }).$mount("#app");
    </script>
</body>

</html>

04-2 뷰 HTTP 통신

✔뷰 리소스 (잘 안쓰는 추세이지만 사용은 한다.)

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <button v-on:click="getData">프레임 워크 목록 가져오기 </button>
    </div>


    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script src="https://cdn.jsdelivr.net/npm/vue-resource@1.3.4"></script>
    <script>

        new Vue({
            el: '#app',
            methods: {
                getData: function () {
                    this.$http.get('https://raw.githubusercontent.com/joshua1988/doit-vuejs/master/data/demo.json').then(function (response) {
                        console.log(response);
                        console.log(JSON.parse(response.data));
                        //// 응답 데이터의 body 값이문자열이기 때문에 JSON.parse() 이용하여 자바스크립트 객체로보기쉽게변환하였다 
                    })
                }
            },
        })
    </script>
</body>

</html>

✔엑시오스(promise 기반의 api형식이 다양하게 제공되어 별도의 로직을 구현 할 필요 없다.)

👍promise 기반의 api란: 서버에 데이터를 요청하면 받아오는 것과 같은 일을 하는 비동기 로직 처리에 유용한 자바 스크립트 객체이다. js는 단일 스레드로 코드를 처리하기 때문에 특정 로직의 처리가 끝날 때까지 기다려 주지 않는다.

js 비동기 이해에 도움이 되는 사이트

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <button v-on:click="getData">Get Data!</button>
    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
    <script>
        new Vue({
            el: '#app',
            methods: {
                getData: function () {
                    axios.get('https://raw.githubusercontent.com/joshua1988/doit-vuejs/master/data/demo.json').then(function (response) {
                        console.log(response);
                    })
                }
            },
        })

    </script>
</body>

</html>

03-1 뷰 인스턴스

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        {{message}}
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script>
        new Vue({       // Vue 객체 생성
            el:'#app',  // el 속성
            data:{      //data 속성
                message:'Hello Vue.js!'
            }
        })

    </script>
</body>

</html>

✔뷰 인스턴스 옵션 속성

• template - 마크업 요소 정의하는 속성.
• method - 전반적인 이벤트와 화면 동작과 관련되 로직을 추가할 수 있다.
• created - 뷰 객체가 생성되자마자 실행 할 로직을 정의할 수 있는 속성.

✔뷰 인스턴스의 유효범위.

뷰 객체를 생성하면 HTML의 특정 범위 안에서만 옵션 속성들이 적용되어 나타난다.

인스턴스가 화면에 적용되는 과정.

1. 뷰 라이브러리 파일 로딩->2.인스턴스 객체 생성(옵션 속성 포함.)->3.특정화면요소에 인스턴스를 붙임. -> 4.인스턴스 내용이 화면 요소로 변함. ->5.변환된 화면 요소를 사용자가 최종 확인.

✔뷰 인스턴스 라이프 사이클

객체 상태에 따라 호출 할 수 있는 속성을 라이프사이클 속성이라고 한다.

그리고 각 라이프 사이클 속성에서 실행되는 커스텀 로직을 라이프 사이클 훅(hook)이라고 한다.

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        {{message}}
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script>
        new Vue({       // Vue 객체 생성
            el:'#app',  // el 속성
            data:{      //data 속성
                message:'Hello Vue.js!'
            },
            beforeCreate() {
                console.log("beforeCreate");
            },
            mounted() {
                console.log("mounted");
                this.message = 'Hello vue!!!';
            },
            updated() {
                console.log("updated");
            },
        })

    </script>
</body>

</html>

03-2 뷰 컴포넌트

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <button>컴포넌트등록</button>
        <my-global-component></my-global-component> <!-- 전역컴포넌트자리 -->
        <my-local-component></my-local-component> <!-- 지역컴포넌트자리 -->
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script>

        Vue.component('my-global-component', {
            template: '<div>전역 컴포넌트가 등록되었습니다. </div>'
        })

        var cmp = {
            template: '<div>지역 컴포넌트가 등록되었습니다. </div>'
        }

        new Vue({
            el: '#app',
            components: {
                'my-local-component':cmp
            }

        })
    </script>
</body>

</html>

✔전역 컴포넌트는 인스턴스를 새로 생성할 때마다 인스턴스에 componemts 속성으로 등록할 필요없이 한 번 등록하면 어느 인스턴스에서든지 사용할 수 있다. 반대로 지역 인스턴스는 생성할 때마다 등록해줘야 한다.

03-3 뷰 컴포넌트 통신.

뷰는 컴포넌트로 화면을 구성하므로 같은 웹 페이지라도 데이터를 공유 할 수 없다. 이유는 컴포넌트마다 고유한 유효범위를 같기 때문이다.

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <my-component01></my-component01>
        <my-component02></my-component02>

    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script>
        var cmp1 = {
            template: '<div>첫번째 지역컴포넌트:{{cmp1Data}}</div>',
            data: function () {
                return { cmp1Data: 100 }
            }
        }

         var cmp2 = {
            template: '<div>두번째 지역컴포넌트:{{cmp2Data}}</div>',
            data: function () {
                return { cmp1Data:cmp1.data.cmp1Data  }// 각 컴포넌트의 고유한 범위 때문에 이부분은 나타나지않는다. 
            }
        }

        new Vue({
            el:'#app',
            components:{
                'my-component01':cmp1,
                'my-component02':cmp2
            }
        })
    </script>
</body>

</html>

✔상하위 컴포넌트 관계.

컴포넌트는 각각 고유한 유효범위가 있어서 직접 다른 컴포넌트의 값을 참조 할 수 없다. 그래서 뷰 에서 정의한 데이터 전달 방법을 따라야 한다. 가장 기본 적인 데이터 전달 방법은 상위 하위 데이터 전달 방법이다.

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">

        <child-component v-bind:propsdata="message"></child-component>
          <!-- 인스턴스 객체 자체가 상위컴포넌트이다. 
             인스턴스에 새로운 컴포넌트를 등록하면 기존에 있는 컴포넌트가 
             상위컴포넌트가 되고 새로 등록된 것이 하위컴포넌트가 된다. 그러면 인스턴스가 최상위 컴포넌트가 된다. -->
    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script>
        Vue.component('child-component',{
            props:['propsdata'],
            template:'<p>{{propsdata}}</p>'

        })
       new Vue({
           el:'#app',
           data:{
               message:'Hello vue'
           }
       })
    </script>
</body>

</html>

✔하위에서 상위 컴포넌트로 이벤트 생성하기.

<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <div id="app">
        <!--  show-log:하위컴포넌트이벤트명, printText:상위컴포넌트메소드명  -->
         <child-component v-on:show-log="printText"></child-component>  <!-- //3 -->

    </div>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script>

        Vue.component('child-component', {
            template: '<button v-on:click="showLog">show</button>',   //1
            methods: {                                                //2
                showLog: function () {
                    this.$emit("show-log");
                }
            },
        })

        var app = new Vue({
            el:'#app',
            data:{
                message:'Hello vue passed from Parent Component'
            },
            methods:{
                printText:function(){
                    console.log("received an event");                   //4
                }
            }
        })
    </script>
</body>

</html>

✔같은 레벨간의 컴포넌트 간 통신, 관계 없는 컴포넌트간 통신 - 이벤트 버스

<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <div id="app">
        <child-component></child-component>
    </div>

    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.2/dist/vue.js"></script>
    <script>
        var eventBus = new Vue();   //1

        Vue.component('child-component',{  //2
            template:'<div>하위 컴포넌트입니다 <button v-on:click="showLog">show</button></div>',
            methods: {
                showLog:function(){//이벤트 명 , 데이터
                    eventBus.$emit('triggerEventBus',100);
                }
            },
        })

        var app = new Vue({
            el:'#app',
            created() {
                eventBus.$on('triggerEventBus',function(val){
                    console.log("전달받은값: "+ val);

                })
            },
        })


    </script>
</body>
</html>

👀이 글은 제가 공부한 것들을 잊어버리지 않기 위해 정리해 놓은 것입니다.

01-1 Vue.js란?

웹 페이지 화면 개발을 위한 프론트 엔드 프레임 워크다.

01-2 특징1 .뷰는 UI 화면 개발 방법 중 하나인 MVVM 패턴의 뷰 모델에 해당하는 화면단 라이브러리이다.

이러한 방식은 화면요소를 제어하는 코드와 데이터 제어로직을 분리하여 직관적으로 이해할 수 있고, 유지보수에도 편리하다.

데이터 바인딩- 뷰에 표시되는 내용과 모델의 데이터를 동기화.

모델-데이터를 담는 용기. 서버에서 가져온 데이터를 js 객체형태로 저장.

EX)구글 버튼을 클릭했을 때 돔 리스너에서 버튼의 클릭을 감지.데이터 바인딩이 관여, 검색결과를 모델에서 가져와 화면에 나타내줌.

특징2 뷰는 컴포넌트 개발 프레임 워크다.

컴포넌트는 레고와 같아서 잘 조합하면 원하는 모양을 만들 수 있듯이, 뷰의 컴포넌트를 조합하여 화면을 구성한다. 위 그림의 왼쪽은 각영역을 컴포넌트로 구분지은 것이고 오른쪽은 관계를 지정해 놓은 것이다.

컴포넌트 기반방식은 코드를 재사용하기가 쉽다고 한다.

해봐야 알꺼 같다.........

뷰의 컴포넌트를 사용하면HTML 코드에서 화면의 구조를 직관적으로 파악할 수 있다.

뷰는 앵귤러의 양방향 데이터 바인딩과 리액트의 단방향 데이터 흐름의 장점을 모두 결합한 프레임 워크다. 이 외 빠른 렌더링을 위해 가상 돔 렌더링 방식을 적용하여 사용자 인터랙션이 많은 요즘의 웹 화면에 적합한 동작 구조를 갖추고 있다. 가상 돔을 사용하면 특정 돔을 추가하거나 삭제하는 변경이 일어날 때 화면 전체를 다시 그리지 않고 프레임 워크에서 정의한 방식에 따라 화면을 갱신한다. 따라서 브라우저 입장에선 성능 부하가 적고 일반 렌더링 방식보다 빠르게 화면을 그린다.

02-1 뷰 학습을 위한 개발 환경 설정.

크롬 브라우저, 아톰(대신 vscode사용), 노드제이에스 , 뷰 개발자 도구 (크롬 확장 플러그인)

👍 노드제이에스란?

*윈도우, 맥, 리눅스 등 다양한 플랫폼에서 서버 사이드(웹 화면과 관련된 서버 로직을 처리하는 영역) 자바스크립트 코드를 실행할 수 있는 실행 환경이다. 노드제이에스 덕분에 자바스크립트는 웹뿐만 아니라 서버사이드, 사물인터엣, 로봇제어에도 활용되는 기반을 갖추게 되었다.

• 01-1 Vue.js란 무엇인가.
• 01-2 Vue.js 의 특징.

  02 개발 환경 설정 및 첫 번째 프로젝트

• 02-1 뷰학습을 위한 개발 환경설정하기.
• 02-2 Hello Vue.js 프로젝트 만들기.

03 화면을 개발하기 위한 필수 단위

• 03-1 뷰 인스턴스
• 03-2 뷰 컴포넌트
• 03-3 뷰 컴포넌트 통신

  04 상용 웹을 개발하기 위한 필수 기술들

• 04-1 뷰 라우터.
• 04-2 뷰 HTTP 통신.

  05 화면을 개발하기 위한 기본 지식과 팁

• 05-1 뷰 템플릿
• 05-2 뷰 프로젝트 구성방법

  06 실전 애플리케이션 만들기

• 06-1 할 일 관리 앱 살펴보기
• 06-2 프로젝트 생성하고 구조 확인하기
• 06-3 컴포넌트 생성하고 등록하기
• 06-4 컴포넌트 내용 구현하기
• 06-5 기존 애플리케이션 구조의 문제점 해결하기
• 06-6 더 나은 사용자 경험을 위한 기능 추가하기

  07 Vue.js 고급 개발자 되기

• 07-1 뷰 고급 레벨로 올라가기 위한 지식
• 07-2 뷰 개발을 위한 웹팩
• 07-3 뷰 개발을 위한 ES^
• 07-4 뷰 CLI에서 사용하는 NPM

  보너스 - 지금 당장 실무에서 써먹는 Vue.js

• 1 뷰와 제이쿼리를 같이 사용해도 되나요?
• 2 개발 기간이 너무 짧은데 기존 레거시 코드에 어떻게 뷰를 바로 적용하죠?
• 3 뷰에 UI 라이브러리와 차트를 어떻게 연동할까요?
• 4 뷰로 프로그레시브 웹 앱을 개발하려면 어떻게 시작해야 하죠?

상속편에서 나왔던 Animal tree를 머리 속으로 떠올려 보자.

Dog, Cat, Hippo... 클래스를 객체로 만드는 것은 이해가 되지만,

Animal 객체, 뭔가 이상하다. 하나의 외계생명체를 만드는 것과 같은 생각이 든다.

상속과 다형성을 위해 Animal 클래스는 필요하다.

프로그래머는 Animal 클래스의 하위 클래스 객체만 만들 수 있으면 좋지 않을까?

실제로 우리가 만드는 객체는 하위클래스이기 때문이다.

Animal 클래스를 객체로 만들지 못하게 하고, 대신에 그 레퍼런스를 사용 할 수 있으면 좋지 않을까?

이 레퍼런스를 사용하는 것이 추상 클래스를 만드는 핵심적인 이유이다.(다형적인 인자나 리턴유형을 쓰기 위해, 또는 다형적인 배열을 만들기 위해)

추상클래스란 새로운 객체를 만들수 없는 클래스를 의미한다.

하지만 다형성을 활용하기 위해 레퍼런스 유형을 선언할 때 추상클래스를 쓸수 있다.

📌추상 메소드

추상클래스는 반드시 확장해야 하는 클래스이다.

추상 메소드는 반드시 오버라이드 해야 하는 메소드이다. 이유는?

Animal클래스에 Bark()메소드를 구체적으로 정의를 내릴수 있을까? 적당한 코드를 생각할 수 없는 메소드를 추상 메소드로 만든다.

각 하위클래스에서 알아서 맞게 정의 내려서 사용할 수 밖에 없다.

그래서 상위클래스에서 몸통 없는 메소드를 만들고 각 하위 클래스에서 만들게끔 강제시킨다.

이러면 어떤 점이 좋을까?

물론 다형성이다. 상위클래스 유형을 메소드의 인자나 리턴유형 또는 배열 유형으로 쓸수 있기 때문이다.
추상 메소드는 다형성을 활용하기 위해 "이 유형에 속하는 모든 하위클래스 유형에는 이 메소드가 있어햐 한다" 는 것을 지정하기 위해 필요한 것이다.

📌Animal이 아닌 객체는 어떻게 하죠? 어떤 것이든 받아들이는 더 포괄적인 클래스를 만드는 것은 어떨까요?

자바에서 모든 클래스는 object라는 클래스를 확장한 것이다.

object 유형의 다형적 레퍼런스를 쓸 떄 치뤄야 할 대가...

ArrayList<Object> myDogArrayList = new ArrayList<Object>();
Dog adog = new Dog();
myDogArrayList.add(adog);

Dog d = myDogArrayList.get(0); //X  

ArrayList< Object > 를 사용할 때는 get()메소드에서의 리턴유형도 Object가 됩니다. 컴파일러에서는 그 객체가 Object의 하위 클래스라는 것만 알 수 있을 뿐 Dog인지 전혀 알 수가 없습니다.

📌다형성은 여러 형태를 의미합니다.

Dog를 Dog 또는 Object로 간주할 수 있다.

중요한 점은 Dog유형의 객체인 경우에도 그 Dog객체에 대한 Object 레퍼런스에서는 Dog에만 있는 메소드를 사용할 수 가 없다는 점이다.

Dog adog = new Dog();
Object o = adog;
o.bark();//XX 컴파일이 안됨.Object객체 메소드만 사용할 수 있다.
(Dog)o.bark()//

📌동물 상속 트리에서 애완동물 트리를 만들어야 한다면....(Pet 메소드를 추가하는 방법.)

📌그러면 다음과 같은 것이 필요하다.

✨애완동물의 행동을 Pet클래스에만 집어넣는 방법

✨모든 애완동물 클래스에 똑같은 메소드가 정의되게 하는 방법. 이 때 모든 프로그래머가 그런 메소드를 제대로 사용할 수 있게 해야 한다.(똑같은 이름, 똑같은 리턴유형을 가져야 하며 모든 메소드가 빠짐없이 있어야 합니다.)

✨각 애완동물 클래스마다 다른 인자 리턴유형 배열을 사용하지 않고도 다형성을 활용하여 모든 애완동물에 대해 애완동물용 메소드를 호출할 수 있게 하는 방법.

📌그런데 상위클래스를 두개 사용하는 경우 문제점이 있다.

그런 것을 '다중 상속'라고 부르는데, 자바에서는 다중 상속을 사용할 수 없다. 죽음의 다이아몬드라고 알려져 있는 문제가 있기 때문이다.

위 그림 맨 아래 클래스인 ComblDrive 에서 burn()메소드를 호출하면 어떤 메소드가 실행이 될까?

📌우리에겐 인터페이스가 있다.

해결방법은 모든 메소드를 추상 메소드로 만드는 것이다. 그러면 하위 클래스에서 반드시 메소드를 구현해야하므로 실행 중에JVM에서 상속받은 두 가지 버전 중 어떤 것을 호출해야 할 지 결정하지 못하는 문제가 생길 리 없다.

인터페이스 제작과 구현



public interface Pet{

    public abstract void beFriendly();
     void paly();             // 인터페이스 메소드는 자동으로 Public abstract이 되기 때문에 
                                 안 써도 된다.
                                (사실 사용하는 것은 그리 좋은 코딩 스타일이라고 할 수 없다.)
}

public class Dot extends Canine implements Pet{
    public void beFriendly(){...}
    public void play(){....}

    public void roam(){...}
    public void eat(){...}
}

질문: 모든 메소드가 추상메소드라면 인터페이스를 왜 사용해야 하나요?
다형성 때문입니다.
인자나 리턴 유형으로 구상 클래스 대신 인터페이스를 사용하면 그 인터페이스를 구현하는 것은 무엇이든 사용할 수 있다.
그리고 인터페이스가 있으면 클래스가 반드시 상속트리 하나로부터 나오지 않아도 됩니다.
클래스 하나는 클래스 하나를 확장하고 인터페이스 하나를 구현할 수 있습니다.
하지만 완전히 다른 상속 트리에서 나온 또 다른 클래스에서 같은 인터페이스를 구현할 수 도 있습니다.
따라서 객체를 그 인스턴스의 클래스 유형이 아닌 그 역할을 기준으로 처리할 수 있습니다.

📌정리(암기필)

👍클래스를 새로 만드려고 할 때 그 클래스가 다른 어떤 유형에 대해서도 'A는 B 다' 테스트를 통과할 수 없다면 그냥 클래스를 만든다.

👍어떤 클래스의 더 구체적인 버전을 만들고 어떤 메소드를 오버라이드하거나 새로운 행동을 추가해야 한다면 하위클래스를 만듭니다.(즉 클래스를 확장합니다.)

👍일련의 하위 클래스에서 사용할 틀을 정의하고 싶다면, 그리고 모든 하위클래스에서 사용할 구현 코드가 조금이라도 있다면 추상클래스를 사용합니다. 그리고 그유형의 객체를 절대 만들 수 없게 하고 싶다면 그 클래스를 추상 클래스도 만듭니다.

👍상속트리에서의 위치에 상관없이 어떤 클래스의 역할을 정의하고 싶다면 인터페이스를 사용하면 됩니다.

출처:headfirst (저자:케이시 시에라,버트 베이츠)

👀이 글은 제가 공부한 것들을 잊어버리지 않기 위해 정리해 놓은 것입니다.

👿상속,다형성 정리.

상속을 먼저 이해하고 다형성을 이해하자.

일단 상속 왜 사용하는가?

코드 중복을 방지하기 위해서 이다.

상속 예제로 많이 쓰이는 Animal계층 구조를 보자.

우선 인스턴스 변수를 모든 Animal형식에 적용할 수 있다고 가정하자.

사자class가 있고 그사자의 고유 picture,food,hunger,boundaries,location 값이 있다.

하마class도 인스턴스의 변수의 값은 다르지만,

어쨌든 변수자체는 다른 Animal 형식에 있는 것과 똑같은 것을 가지고 있다.

개, 호랑이 등의 동물에서도 똑같다. 하지만 행동도 그럴까?

사자와 개가 똑같은 소리를 낼까? 고양이가 하마와 똑같은 식으로 먹을까?

그래서 override라는 것을 사용한다.

하위 클래스에서 상위클래스의 메소드를 사용하되 각 개체의 특성에 맞게 커스터마이징을 한다.

✨오버라이드 정의: 하위클래스에서 메소드의 역할을 변경하거나 확장할 필요가 있을때 상속받은 메소드를 새로 정의 하는것이다.

오버라이드 규칙

하위 클래스의 메소드는 상위 클래스의 메소드와 똑같아야 한다.

즉 인자와 리턴형식이 동일해야 하는 것을 의미한다.

컴파일러에서는 어떤 레퍼런스에 대해 특정한 메소드가 제대로 호출할 수 있는지를 결정할 때 레퍼런스의 형식을 살펴본다.

Dog에 대한 Animal의 레퍼런스가 있을때,

Animal a = new Dog();

컴파일러에서는 Animal레퍼런스에 대해 호출하는 메소드가 Animal 클래스에 있는지만 신경쓴다.

하지만 실행할 땐 JVM에서는 레퍼런스 형식이 아닌 힙에 들어있는 실제 Dog객체를 사용한다.

따라서 컴파일러에서 메소드 호출을 허가한 후에도 오버라이드하는 메소드의 인자와 리턴형식이 똑같을 때에만,

그 메소드가 제대로 작동한다.

🅰일련의 클래스에 대한 상위클래스를 만들면 그 상위 클래스 형식이 들어갈 수 있는 모든 자리에 해당 클래스와 임의 하위 클래스에 속하는 객체를 마음대로 사용할 수 있다.

이것이 다형성을 사용하는 이유이다.

아래 예제를 보면서 이해해 보자.

다형성을 사용하면 레퍼런스 유형을 실제 객체 유형의 상위 상위클래스 유형으로 지정 할 수 있다.

'A는 B다'의 공식이 적용된 상속관계에서 모든 하위 객체(Dog,Hippo,Cat..)는 상위객체(Animal)에 대입할 수 있다. 이렇게 하면 배열을 만드는 것과 같은 일을 할 수 있다.

Animal[] a = new Animal[5];
a[0] = new Dog();
a[1] = new Cat();
a[2] = new Lion();
a[3] = new Hippo();

for(int i =0;i<a.length;i++){
       a[i].eat(); //각 클래스에 들어있는 eat메소드가 실행.
}

또한 인자와 리턴 유형에 대해서도 다형성을 적용할 수 있다.

class Vet(){//주사를 맞으면 소리가 남.
 public void giveShot(Animal a){ //✨ 
     a.makeNois();
 }
}

class petOwner(){
 public void start(){
      Vet v = new Vet();
      Dog d = new Dog();
      Hippo h = new Hippo();
      v.giveShot(d);  //Dog의 노이즈가 실행
      v.giveShot(h);  //Hippo의 노이즈가 실행
 }
}

✨표시 부분에서 인자가 Animal을 사용할 수 없다고 생각해보자.

만약 다형성을 사용할 수 없었다면, Vet클래스에선 giveShot 메소드가 하나가 아니라 하위클래스 갯수만큼의 메소드가 필요할 것이다. 왜? petOwner에서 giveShot을 호출할때 어떤 객체를 보낼지 모르기 때문이다.

🅰다형적인 인자를 사용하는 코드를 만들면, 즉 메소드 매개변수를 상위 클래스 유형으로 선언하면 실행할 때 어떤 하위 클래스의 객체도 전달할 수 있다.

🅰다형성을 활용하면 새로운 하위 클래스 형식을 프로그램에 추가하더라도 코드를 굳이 바꿀 필요가 없다. 위에 나와있는 Vet클래스 giveShot 메소드에서 선언된 인자는 새로운 하위클래스에 대한 사전 지식이 없어도 그 새로운 하위클래스 형식의 객체를 전달 받을 수 있다.

출처:headfirst (저자:케이시 시에라,버트 베이츠)