11일차 수업 정리(Nested Class, Singleton, Sort)

Tip
1. 차후에라도 디자인패턴은 무조건 공부해볼것 'gof 디자인패턴' 서적 참조
2. 객체지향 프로그램 완료시 클래스 다이어그램을 꼭 만들기

참고자료
1.7 API: http://docs.oracle.com/javase/7/docs/api/
1.8 API: http://docs.oracle.com/javase/8/docs/api/

예제 코드
http://www.java2s.com/Code/JavaAPI/CatalogJavaAPI.htm
http://www.java2s.com/Tutorial/Java/CatalogJava.htm

인스턴스는 원하면 메모리 초기화 가능, 클래스는 불가능하므로 인스턴스가 유리할수있음

**Nested Class
    => 클래스 안에 만드는 클래스
    => Java는 클래스 내부에 다른 클래스를 만드는 것을 지원
         하나의 파일에 여러개의 클래스를 만드는 것과는 다른 개념 - 비추천
    => 특정 클래스 안에서만 사용되는 클래스가 있다면 굳이 외부에 만들 필요없이 클래스 내부에 만들어 타 클래스             의 접근이 불가능하게 하자는 취지에서 생성
    => 객체 지향 언어에서는 접근 제한에 민감
        (서버 프로그래밍시는 접근제한에 민감한 것이 좋지만 클라이언트의 경우 덜 민감하게 반응해도 괜찮음)

1. 일반 Inner Class
    => 클래스 안에 만들어진 클래스
    => 이 클래스는 static 프로퍼티를 소유할 수 없음
    => static 이 없는 클래스는 인스턴스를 만들기 전까지 메모리 할당을 받지 않기 때문에 static 처럼 클래스가 만들

        어질 때 저장 되어야 하는 데이터를 사용 할 수 없음

2. Static Inner Class
    => inner class가 static 멤버를 가져야 하는 경우 사용하는 클래스

3. local Inner Class
    => 메소드 안에 만들어지는 클래스
    => 메소드 안에서만 사용 가능

4. anonymous class(이름 없는 클래스 - 딱 한번만 사용(열차 예매 앱등))
    => 클래스 생성시 이름없이 생성하여 인스턴스를 만들고 사용하는 방법
    => Java 1.7부터는 함수형 프로그래밍 지원을 위해 메소드가 1개인 경우 람다라는 특수 문법으로 만들수 있음
         Android Studio는 메소드가 1개인 anonymous class를 생성하면 프로젝트를 다시 열때 람다식으로 치환

5. 생성 문법
  1) 일반 inner class
    class Outer{ 
                     class Inner{  (프로퍼티, 메소드 선언)  }
                     public void method(){
                                                   Inner inner = new Inner();
                                                   inner 인스턴스 사용 } }

  2) static inner
    class Outer{ 
                     static class Inner{  (프로퍼티, 메소드 선언) 
                                             + (static 프로퍼티)  } //일반 Inner Class로는 에러
                     public void method(){
                                                   Inner inner = new Inner();
                                                   inner 인스턴스 사용 } }

  3) local inner class
    class Outer{ 
                     public void method(){
                                                   class Inner{  (프로퍼티, 메소드 선언) }
                                                   Inner inner = new Inner();
                                                   inner 인스턴스 사용 } }
    => inner class는 class안에 만들어 졌지만 컴파일이 될 때는 Outer$Inner.class 파일로 별도 생성
         한번 만들어 사용시 메모리에 계속 load된 상태가 됨
  4) anonymous class(이름없는 클래스로 만든 인스턴스 - 익명객체)
     new + 상위클래스() { (필요한 메소드나 프로퍼티를 생성) };
    => 상위 클래스로부터 상속받은 클래스의 인스턴스 생성 및 참조 리턴

6. 클래스 대신 인터페이스 사용가능

7. 클래스(인터페이스)를 상속받아서 사용하는 방법
  1) 상속받는 클래스를 만들고 그 클래스의 인스턴스를 만들어서 사용
    => 클래스를 만들어 두었기 때문에 여러개의 인스턴스 생성 가능
    => 클래스는 정적 메모리 영역을 사용하므로 한번만 사용하는 클래스의 경우 클래스 생성시 메모리 낭비 발생

  2) anonymou class를 이용하는 방법
    => 클래스를 만들지 않고 바로 인스턴스를 만들기 때문에 1개의 인스턴스만 생성가능
    => 클래스를 만들기 않기 때문에 정적 메모리 영역을 사용하지 않음(필요한 순간에만 코드가 만들어짐)

** 인스턴스간의 데이터 공유
1. 동일한 클래스로부터 만든 인스턴스의 경우에는 클래스에 static변수를 만들어서 공유

2. 서로 다른 클래스로부터 만들어진 인스턴스 사이의 데이터 공유
  => 전역변수를 생성
  1) 클래스를 만들고 public static 변수를 만들어서 모든 곳에서 클래스명.변수명으로 접근할 수 있도록 함
  
  2) singleton 클래스를 만들어서 사용
    => Singleton : 클래스의 인스턴스를 1개만 만들수 있도록 디자인 하는 패턴
    => 공유변수를 소유한 인스턴스, 프로그램의 entry point 인스턴스, 클라이언트 요청을 처리하는 서버의 인스턴                스 제작시 사용
    => 만드는 법
       (1) 생성자를 private로 생성 : 외부에서 인스턴스를 생성할 수 없게 하기 위해
       (2) private static으로 현재 클래스의 변수 생성 : 외부에서 접근 할수 없고, static으로 만들어서 1개만 생성되게 함
       (3) public static으로 자기 자신의 타입을 리턴하는 메소드 생성
           public static 클래스명 메소드명(){ 
                            if(변수 ==null){ 변수 = new 생성자() ; }
                            return 변수 }
    => 메소드 명은 MS의 경우 공유데이터를 가진다는 의미로 shareInstance라는 이름으로 생성

3. 부모자식관계 클래스 사이의 데이터 공유
    => 포함관계로 다른 클래스의 인스턴스를 내부에서 만들어서 사용하는 경우
    => 외부 클래스의 인스턴스 안에서는 안에 만들어진 인스턴스의 데이터를 사용 가능하지만, 
        내부에서 만들어진 인스턴스는 외부의 데이터를 사용하려면 데이터를 생성자나 setter를 이용하여 넘겨 받아야함

** Object Aid
1. 설치
    => [help] -> [Install New...] -> "http://www.objectaid.com/update/current" -> 설치

2. 알고리즘 연습
   1) 정올 ++
   2) 알고스팟 +
   3) 더블릿

** 도큐먼트
1. 클래스의 상속 관계 확인

2. class 앞에 붙을수 있는 단어
  1) abstract : 상속을 통해서 사용
  2) final : 상속할 수 없음

3. interface
    => 다른 클래스에 implements 해서 사용

4. Nested Class
    => 클래스 안에 속한 클래스 : java.awt.Button에서 확인 가능

5. field Summary
    => static final 속성
    => 클래스 안에서 사용할 옵션등을 표현 할 때 사용
    => java.lang.Thread, java.lang.System 에도 존재
    => 사용시 클래명만으로 사용

6. Constructor Summary - 생성자
    => 인스턴스를 만들기 위해서 호출하는 메소드
    => 생성자가 없는 경우
  1) abstract class나 interface는 생성자가 없음 : 인스턴스 생성을 못하기 때문
     ex) java.util.List
  2) 모든 메소드가 static인 경우 : 인스턴스를 생성할 필요가 없기 때문
    ex) java.lang.Math
  3) 디자인 패턴을 적용한 클래스의 경우 : 싱글톤처럼 인스턴스를 1개만 만들도록 디자인하고 팩토리 메소드 패턴 적용
    => java.lang.Runtime
    => 이런 클래스는 method를 확인해보면 static 메소드도 있고 static이 아닌 메소드도 있는데 , 이런경우 동일한 클래스 이름 뒤에 factory가 붙는 클래스가 있는지 확인해보고 없으면 메소드 중에서 자기와 동일한 타입을 리턴하는 static 메소드를 찾아봐야 함

7. Method Summary - public, protected 메소드가 보임
    => public은 생략
  1) static이 있는지 없는지 확인
    => static이 있으면 클래스명으로 호출
    => static이 없으면 인스턴스를 생성하여 인스턴스로 호출
  2) 매개변수 확인
    => 메소드를 호출 할 때, 매개변수의 자료형과 개수를 일치시켜서 호출해야 하기 때문
  3) 리턴 타입(맨 앞에 보임)
    => 메소드가 수행하고 남겨주는 데이터에 대한 자료형
    => void 는 남겨주는 데이터가 없다는 의미로 메소드만 호출
    => void 가 아닌경우 데이터를 남겨주는 것이므로, 데이터를 연산이나 메소드의 매개변수로 대입하거나 변수에 저장

** Sort(정렬)
    => 데이터를 순서대로 나열하는 것
1. 정렬 방식
  1) Ascending(오름차순) : 작은것에서부터 큰 것순으로 나열하는 것(기본)
  2) Descending(내림차순) : 큰것에서부터 작은것 순으로 나열하는 것

2. 정렬 알고리즘
  1) selection sort(선택 정렬)
  2) bubble sort(버블 정렬)
  3) insertion sort(삽입 정렬)
  4) quick sort - 설명까지 할 수 있도록(이해까지)
==============================필수
  5) radix sort
  6) heap sort
  7) merge sort
...

3. selection sort(선택 정렬)
    => 첫 위치부터 마지막 하나 앞 위치까지 자신의 뒤의 모든 데이터와 비교후, 뒤의 데이터가 더 작으면 자리를 교환

ex)      17   20   30   15   29
1Pass   15   20   30   17   29
2Pass   15   17   30   20   29
3Pass   15   17   20   30   29
4Pass   15   17   20   29   30

  1) 5개의 데이터를 배열에 저장
  2) 선택 정렬을 구현
  3) 데이터를 출력해서 확인
  4) 내림차순의 구현?