KH 11일차 - 정적 초기화 블록과 상수 + 간단한 10일 후기

1.    인스턴스 멤버 선언 VS 정적 멤버 선언의 기준

-      객체마다 가지고 있어야 할 데이터면 인스턴스 필드, 공용적인 데이터는 정적필드로 선언한다.

-      인스턴스 필드는 계산기의 색, 정적 필드는 계산기 속에 있는 파이의 값이 해당 된다.

-      인스턴스 필드로 작업해야 할 메소드는 인스턴스 메소드, 인스턴스 필드로 작업하지 않는 메소드는 정적 메소드로 선언한다.

-      인스턴스 메소드를 불러들여 사용할 때에는 인스턴스 메소드를 사용해야 한다.

-      정적 메소드는 더하기나 빼기처럼 자기 스스로 기능이 실행되어야 하기에, 정적 메소드를 사용하는 경우는 적은 편이다.

 

2.    정적 초기화 블록 [ Static initializer ]

-      클래스의 구성 멤버 :

-      1) 필드

-      2) 생성자 : 인스턴스 필드의 초기값을 넣어주는 역할

-      3) static initializer ( 정적 초기자, 정적 블록 ) : 정적 필드에 초기값을 넣어주는 역할

-      4) 매소드

-      클래스 로드 : .class 파일을 읽어 메소드 영역에 clazz를 집어 넣을 때, static initializer을 호출하게 된다.

-      static initializer(정적 초기화 블록)은 클래스가 메소드 영역으로 로딩될 때 자동으로 실행하는 블록이다. [ static { } ]

-      ex. static double PI; // 정적 필드

-      static { PI = 3.14159; } // static initializer

-      정적필드를 초기값을 넣어주지 않아도 타입별 기본값으로 값이 들어간다.

-      싱글톤 ( Singleton ) : 하나의 어플리케이션 내에서 단 하나만 생성되는 객체

-      싱글톤은 JVM의 힙 영역에 오로지 단 한번만 생성되는 객체이다.

-      싱글톤을 생성하기 위해서는 싱글톤 패턴을 사용해야 한다.

-      싱글톤의 대표적인 예시는 “환경설정”이다.

-      싱글톤을 만드는 방법 :

-      1) 외부에서 new 연산자로 생성자를 호출할 수 없도록 막아 버리기!

-       => private 접근 제한자를 생성자 앞에 붙여서 막아 버리기!

-      2) 클래스 자신의 타입으로 정적 필드를 선언

-      3) 외부에서 호출할 수 있는 정적 메소드인 getInstance( ) 선언

 

3.    Final 필드와 상수 ( static final )

-      Final 필드 : 최종적인 값을 갖고 있기에, 값을 변경할 수 없는 필드이다.

-      주로 값을 읽는데 사용이 된다.

-      Final 필드는 딱 한 번 초기값을 지정하게 된다.

-      객체마다 가지는 불변의 인스턴스 필드이다.

-      상수 ( static final ) : 메소드 영역에 클래스 별로 관리되는 불변의 정적 필드

-      Final과 다르게 객체마다 가지고 있지 않으며, 공용 데이터로서 사용된다.

-      상수 이름은 전부 대문자로 작성하게 된다.

-      다른 단어가 결합하게 되면 _로 연결한다.

 

4.    패키지 ( Package )

-      패키지란? 클래스를 기능별로 묶어서 그룹 이름을 붙여 놓은 것이다.

-      100개의 클래스를 생성했을 때, 목적이나 관련성이 있게 클래스를 묶을 때 사용한다.

-      자바 언어에서 패키지의 물리적인 모습은 그냥 “폴더”에 불과한다.

-      A.B.C.D 패키지는 A폴더 아래 B폴더 아래 C폴더 아래 D폴더가 있다는 것이다.

-      이때 패키지의 이름은 : A – A.B – A.B.C – A.B.C.D로 작성하여 생성하게 된다.

-      그렇게 되면 패키지가 A따로 A.B따로 보이는 것이 아니라 A.B.C.D로 보이는데, 이는 안에 클래스가 존재하지 않기 때문이다.

-      어느 패키지에서 만들지는 class 생성할 때 정할 수 있다.

-      이때 패키지 내에서 클래스를 생성하게 되면 package “패키지명;”이 뜨게 된다.

-      이러한 패키지의 깊이를 directory depth라고 부른다.

-      폴더 내에는 클래스가 들어있을 수도, 들어가 있지 않을 수도 있다.

-      패키지의 이름은 소문자로 만든다.

-      패키지 안에 클래스가 들어가 있으면 색이 들어가 있는 이모티콘으로, 클래스가 없으면 하얗게 나오게 된다.

-      Default package는 패키지 내에서 만들지 않은, 패키지 안에 들어가지 않은 클래스가 모아져 있다.

 

5.    클래스의 구성멤버 정리 ( *** )

-      1) 필드 : 인스턴스 필드 , 정적 필드 , static final 상수 ( 진리 값을 살수로 만듦 )

-      2) static initializer : 정적 필드의 초기화 담당

-      3) 생성자 ( constructor ) : 인스턴스 필드의 초기화 담당

-      4) 메소드 : 인스턴스 메소드 , 정적 메소드

-      5) 그 외 . . .

 

---

01. 인스턴스 멤버 - Getter과 Setter

 

public class Car4 {

      

       // 1. 인스턴스 필드

       String model;

       int speed;

      

       // 2. 생성자 : 인스턴스 필드의 초기화를 담당

       Car4 ( String model ) {

             this.model = model;

       } // constructor

      

       // 3. 인스턴스 메소드

       void setSpeed ( int speed ) { // 메소드의 이름 = 'set' + 필드 이름(대문자로 시작) (**) -> "setter 메소드"라고 한다.

             this.speed = speed; // 인스턴스 필드 speed의 값을 변경해주는 기능을 한다. (****)

       } // setSpeed

      

       // 4. 인스턴스 메소드

       int getSpeed ( ) { // 현재의 필드 값을 되돌려주는 역할을 한다. (****)

             return this.speed; // 메소드 이름 = 'get' + 필드 이름(대문자로 시작) (**) -> "Getter" 메소드라고 부른다.

       } // getSpeed

      

       // 5. 인스턴스 메소드

       void run() {

             for ( int i =10; i <= 50; i +=10 ) {

                    this.setSpeed(i);

                    System.out.println(this.model + "가 달립니다. ( 시속 : " + this.speed + " Km/h");

             } // for

       } // run

 

} // end class

 

02. 정적멤버의 활용 - static initializer

 

public class Calculator02 { // static initializer

      

//     static double pi = 3.14159; // 하드 코딩

//     static double pi = Math.PI; // 이 방법도 가능하다!

      

       // 게터 세터

      

       int age; // 인스턴스 필드

      

//     int getAge() {

//           return this.age; // age여도 사용이 가능은 하지만 인스턴스 필드 구분을 위해 this.을 붙이자!!

//     } // getAge

//    

//     void setAge ( int age ) { // 값을 반환하는 것이 아니라 값을 변경하는 것이기에 void를 사용한다.

//           this.age = age; // 매개변수를 사용해서 값을 변경해 준다.

//     } // setAge

      

       // source 탭에서 generate getter setter을 누르면 자동으로 만들어 준다.

      

       int getAge() {

             return age;

       }

 

       void setAge(int age) {

             this.age = age;

       }

 

       static double pi;

      

       static {

             System.out.println("static initalizer invoked.");

//           pi = 3.14159; // 안에서 정적 필드의 초기화를 해주고 있다.

             pi = Math.PI; // Math라는 클래스 내에 이미 PI의 값을 저장하고 있다.

             // pi가 아니라 PI인 이유는 PI가 변하지 않는 상수값이기 때문이다.

       } // static initializer

      

//     ===========================================================================

      

       static {

             System.out.println("static initalizer2 invoked.");

       } // static initializer3

      

       static int plus ( int x, int y ) {

             return x + y;

       } // plus

      

//     ============================================================

      

       static int minus ( int x, int y ) {

             return x - y;

       } // minus

 

       static {

             System.out.println("static initalizer3 invoked.");

       } // static initializer3

      

       //Example에서 출력하게 되면 static initializer invoked 1,2,3이 위에 합쳐져서 출력된다. - static initializer은 한번에 수행된다.

      

} // end class

---

public class Calculator02Example {

      

       public static void main (String ... args) {

            

             double radius = 10.0; // 원의 반지름

             double result1 = radius * radius * Calculator02.pi; // 원의 넓이

            

             int result2 = Calculator02.plus(10, 5);

             int result3 = Calculator02.minus(10, 5);

            

             System.out.println("result1 : " + result1);

             System.out.println("result2 : " + result2);

             System.out.println("result3 : " + result3);

            

       } // main

 

} // end class

 

03. 정적 멤버와 인스턴스 멤버의 호출

 

public class Television {

      

       static String company = "Samsung";

       static String model = "LCD";

       static String info;

      

       double price;

      

       static { // 표현식으로 초기화하였다.

             info = company + " - " + model;

       } // static initializer

      

       void instanceMethod1() { // 인스턴스 메소드

            

             System.out.println(this.price); // 인스턴스 필드 사용 가능!

            

             this.instanceMethod2(); // 인스턴스 메소드 사용 가능!!

             // this를 붙어야 이 클래스에 있는 인스턴스 메소드임을 알 수 있기에 붙이는 것이 좋다.(***)

            

             Television.staticMethod(); // 정적 메소드도 사용이 가능하다!!

             // 하지만 앞에 클래스 명을 붙여서 정적 메소드 답게 사용하자!!!! (*****)

            

            

             // 다른 클래스(TTT99)의 인스턴스 메소드 호출!! (******)

             TTT99 ttt = new TTT99(); // 인스턴스 멤버이기에 객체를 생성해야 한다!!!!

             ttt.instanceMethod(); // 객체를 생성하여 앞에 붙임으로써 클래스에 구분할 수 있다.

            

             // 다른 클래스에서 정적 메소드 호출!! (********)

             TTT99.staticMethod(); // 객체를 생성하지 않아도!! 앞에 클래스 명을 붙이면 사용이 가능하다.

            

       } // instanceMethod1

      

       void instanceMethod2() { // 인스턴스 메소드

             System.out.println(Television.model); // 정적 필드 사용 가능!

             System.out.println(this.price); // 같은 클래스 내에서라면 객체를 생성하지 않아도 this.으로 사용이 가능하다!! (***)

       } // instanceMethod2

      

       static void staticMethod() { // 정적 메소드

             System.out.println(Television.model); // model은 정적 멤버이기에 사용이 가능하다.

            

             // 정적 메소드 안에서 인스턴스를 사용하기 위해서는?

             // 객체를 생성해야 한다!!! (****)

            

             Television obj = new Television();

             System.out.println(obj.price); // 객체를 생성하면 정적 메소드 내에서 인스턴스 멤버 출력이 가능하다.

            

       } // staticMethod

 

}  // end class

 

 

class TTT99 {

      

       void instanceMethod() {;;}

      

       static void staticMethod() {;;}

      

} // end class - TTT

 

---

public class TelevisionExample {

      

       public static void main(String[] args) {

            

             // 대전제 2 : 정적멤버는 정적 멤버답게 사용해랴!!!

             System.out.println(Television.info);

            

             Television obj = new Television();

             System.out.println(Television.info); // 이 방법도 출력을 정상적으로 가능은 하지만

             // 이 방법은 인스턴스 멤버가 사용하는 방법이기레 정적 멤버 답게 사용하는 것이 좋다.

            

       } // main

 

} // end class

 

04. 인스턴스 필드의 활용

 

public class Car5 {

      

       int speed; // instance field

      

       void run () {

             System.out.println(speed + "으로 달립니다.");

       } // run

      

       public static void main (String[] args) { 

            

             Car5 myCar = new Car5(); // 인스턴스 멤버를 사용할 때에는 객체 생성!!

            

             myCar.speed = 60;

             myCar.run();

            

       } // main

 

} // end class

 

05. 싱글톤 패턴 ( *** )

 

public class Singleton { // Singleton 패턴 (*********)

      

      

       // 이 클래스는 소위 'singleton Design Pattern'에 의해 설계된 클래스이다.

       // 목적 : 자바 APP이 살아있는 동안, 힙 영역에 단 한번만 생성되는 객체를 만들기 위함입니다.

       // 클래스는 보이지만 생성자는 private로 숨겨져 있다.

      

       // 단! private는 외부에서 못보도록 막는 것이기 때문에,

       // 같은 클래스 내에서는 private는 아무런 기능을 하지 못한다. (****)

      

       private static Singleton obj = new Singleton(); // (*******)

      

//     = > private static Singleton obj = new Singleton(); 식을 풀면 아래와 같은 식이 된다.

      

//     =

//     private static Singleton obj; //다른 클래스 파일에서 선언하기 전 정의인 상태에서 불러들이면 기본값인 null로 들어갈 수 있으니

//                                                          private를 붙여서 안전하게 보호하였다.

//    

//     static {

//           obj = new Singleton(); // static 안에 new 연산자를 넣어 더 이상 새로운 객체를 생성할 수 없게 막아버렸다.

//     } // static initializer - 버츄어 머신이 "단 한번만"!!! 수행하도록 하기에 더 이상 생성 불가능 (*****)

      

      

       private Singleton() { // private으로 해서 외부에서는 보이지 않도록 캡슐화 (*****)

             ;;

       } // default constructor

      

       static Singleton getInstance() { // 싱글톤 타입 객체의 주소를 돌려줄게!! (**)

             // 인스턴스 멤버로 만들기 위해서는 새로 객체를 생성해야 하는데 이는 막혀 있기 때문에 (**)

             // 반드시 static을 붙여서 정적 멤버로 만들어야 한다!!! (********)

            

             return obj;  // 싱글톤 타입 객체의 주소를 반환한다.

            

       } // getInstance - 싱글톤은 객체를 1번만 생성하지만 주소를 공유할 수는 있다!!!

 

} // end class

 

---

 

public class SingletonExample {

      

       public static void main(String[] args) {

            

//           Singleton obj1 = new Singleton();

//           Singleton obj2 = new Singleton();

             // 둘 다 오류가 발생하게 된다. 왜냐하면 싱글톤의 생성자가 보이지 않기 대문이다.

             // 이렇게 되면 new 연산자를 통해서 객체 생성이 불가능해져 버린다.

            

//           Singleton obj1 = Singleton.getInstance();

//           Singleton obj2 = Singleton.getInstance();

//          

//           if( obj1 == obj2 ) {  // 주소가 같은지 확인해 본다.

//                  System.out.println("같은 single 객체입니다."); // 출력

//           } else {

//                  System.out.println("다른 single 객체입니다.");

//           }// if- else

//          

            

             for ( int i = 0; i <10 ; i++ ) {

                    Singleton obj = Singleton.getInstance();

                    System.out.println(obj); // 10번 출력하여 주소가 다 같은지 확인한다.

             } // for // 객체는 단 1번만 생성되었기에 몇 번을 출력하더라도 주소는 다 같아야 한다.

            

             // 싱글톤은 JVM이 끝나기 전까지는 파괴가 불가능 하다.

            

             Singleton obj1 = Singleton.getInstance();

             Singleton obj2 = Singleton.getInstance();

            

//           assert (obj1 != obj2); // 검증하다.

//          

//           assert (1 != 2);

//           System.out.println("OK");

            

             // assert는 뒤에있는 것이 참이면 그냥 넘어가지만 거짓이면 오류를 발생시켜 버린다.

             // 하지만 assert는 자바 버전에 따라서 기능이 잘 안되기에 사용하지 않는 것이 좋다.

            

       } // main

 

} // end class

 

06. final

 

public class Person { // final

      

       // final은 상수화시키는 것이고, static은 정적 멤버화시키는 것이다.

       // 둘의 차이점을 알아야 한다.

      

       final String nation = "Korea";

       final String ssn; // 주민등록번호

       String name;

      

       public Person (final String ssn, final String name ) { // final을 붙이게 되면 매개 변수의 값을 변경하지 못하게 한다.

            

             this.ssn = ssn;

             this.name = name;

            

       } // constructor

 

} // end class

---

public class PersonExample {

      

       public static void main (String [] args) {

            

             Person p1 = new Person("123456789", "계백"); // static 정적 멤버와 다르게 객체를 생성해야 됨을 알 수 있다.

            

             System.out.println(p1.nation);

             System.out.println(p1.ssn);

             System.out.println(p1.name);

            

             // p1.nation = "usa"

             // p1.ssn = "23456987";

            

             p1.name = "을지문덕";;

            

//          

            

             Person p2 = new Person("123123123", "계맥");

             // final은 "객체마다" 다른 값으로 초기화 되는 상수이지, static처럼 다 같은 수를 가지고 있는 것은 아니다.

             // final은 객체 내에서 불변의 값을 가지게 된다.

            

             System.out.println(p2.nation);

             System.out.println(p2.ssn);

             System.out.println(p2.name);

            

       } // main

 

} // end class

 

07. static final 상수

 

public class Earth {

      

       static final double EARTH_RADIUS = 6400;  // static final 상수

       static final double EARTH_SURFACE_AREA; // static initializer 내에 있는 식이 이 뒤로 옮길 수 있지만

       // 실제로 코드를 뜯어보면 아래와 같은 식으로 구성되어 있음을 알 수 있다.

      

       // static final는 어디에서나 변하지 않는 진리의 값을 말한다.

      

       static {

             EARTH_SURFACE_AREA = 4 * Math.PI * EARTH_RADIUS * EARTH_RADIUS;

       } // static initializer (***)

      

       // static initializer는 여러개 만들 수는 있지만 결국에는 하나로 합쳐져서 실행된다.

      

       void instanceMethod(final String name ) { // final을 붙여 "이 블록 내"에서는 절대 값을 변하지 않게 한다.

             final int temp = 0;

       } // instanceMthod - 메소드 블록 {} 내에서 선언되는 것은 지역변수 () 내에 있는 것은 매개변수!

 

} // end class

 

08. 패키지

 

package A.B;

// 패키지를 안에 클래스를 생성하게 되면 패키지가 뜨게 된다.

// C1 클래스의 완전한 이름은 FQCN : Fully-Qualified Class Name  이다.

// FQCN : A.B.C1 가 클래스의 진짜 이름이다! [패키지 명 + 클래스 명] (****)

// FQCN을 통해 "폴더가 다르면" class의 이름이 같아도 생성이 가능한 것을 볼 수 있다. (**)

 

// 패키지 이름의 관례 : 1. All 소문자!  2. 숫자를 사용하지 않기!  3. 특수기호를 넣지마라! (ex. _ )

 

// 패키지 명을 의미있게 짓는 기본 규칙 : (**)

// - > 각 회사의 도메인 이름을 거꾸로 뒤집어서 top-level 패키지 생성

// ex. naver.com --> 네이버의 도메인 이름 ( 네이버 주소에서 www.를 뺀 것 )

// ex2. com.naver --> 가장 높은 패키지의 이름이 되어야 한다.

// 도메인 이름이 가장 높은 패키지의 이름이 되어야 하는 이유는 도메인의 경우 회사마다 고유하게 할당되기 때문이다.

 

public class C1 { // Simple Name

 

}

---

 + 후기

이제는 단순하게 코드를 외우는 것이 아니라, 파일이 전체적으로 실행되는 흐름을 파악해야 될 때도 있어 다소 이해하는데 어려움이 생기는 것 같다. 하지만 다행히도 선생님께서 기본부터 차근차근 밟아 주시는 것 같아서 비전공인 나도 원활하게 따라갈 수 있는 것 같다. 과제를 진행하면서 새롭게 느낀 점이 있는데 알고리즘을 별도로 공부해야 될 필요성과 복습의 중요성이다. 단순한 코드라고 해도 새로운 것을 받아들이는데 집중하게 되면 까먹는 경우가 있기도 하고, 문제만 봤을 때에는 어려워 보여서 머리를 잡는 문제도 알고리즘만 알고 있다면 정말 단순하게 짤 수 있기 때문이다.

 

+ KH 강남점 10일 후기

 수업과 선생님에 대해서 매우 높은 만족도를 느끼고 있다. 선생님이 단순하게 수업계획표를 따라가는 것이 아니라 학생들의 분위기를 보고 이해 정도가 높고 낮음에 따라서 다르게 진도를 나가거나 눈높이를 맞춰 주면서 진행해 주시기 때문이다. 또한 과제도 다양하게 내주심으로써 복습도 할 수 있고 개인적으로 학생들과 소통도 잘 해주시고 있어 코딩이 어려워도 재미를 느끼며 배울 수 있는 것 같다.

 

+ 국비 학원에 대해서 많은 궁금증과 불안을 가지고 있었던 사람으로써 지금 학원을 평가하자면, KH학원을 선택한 것은 매우 좋은 선택인 것 같다. 만약, 비전공이고 IT계열로 방향을 바꾸고 싶고 열정이 있는 사람은 국비학원에 신청하는 것을 추천해주고 싶은 정도이다. 국비지원을 통해서 무료로 백엔드 혹은 프론트 엔드를 배울 수 있으며 국비학원의 특성 상 비전공자가 전공자에 비해 많기에 많은 선생님들께서 이를 고려하여 차근차근 진도를 나가주시기 때문이다. 하지만 만약 컴공이 전공이시라면 국비학원을 추천하지 않는다. 진도가 느릴뿐만이 아니라 전공자에 맞지 않은 과제들이 많이 나오기 때문에 국비가 아닌 학원을 다니는 것을 추천한다.

 

 또한 학원이나 선생님을 잘 알아보는 것을 추천한다. 사실상 국비학원은 나라에서 정해준 NCS의 과정을 따라서 진도를 나가기 때문에 학원간 계획표를 보면 많은 차이가 나지는 않지만, 보통 학원이나 선생님에 따라서 다르게 과정을 나가시기 때문이다. 그리고 유명한 학원의 경우 과정이 자주 열릴뿐만이 아니라 보통 대기 시간이 1-2달은 잡아야 하는 경우가 많은데, 엄청 급하지 않으신 분들이라면 이러한 학원에 신청하는 것을 추천한다. 인지도가 있는 학원의 경우 선생님이 단순히 강의만 하시는게 아니라 실제 개발자로써 일을 하시는 분이 많이 계시는데, 이때 정말 꿀팁이나 우리가 인터넷으로는 몰랐던 사실, 혹은 실제 개발자는 코드를 어떻게 짜는지 등에 대해서 많은 정보를 얻을 수 있기 때문이다. ( 특히 프론트 엔드 쪽은 변화하는 속도가 빠르기에 현장에서 오랫동안 벗어나신 선생님께 배우게 되면 실제로 잘 안쓰이거나 못쓰는 코드를 배울 수도 있다고 한다. )

 

 아직은 10일차가 이제 막 끝난 상태이기에 정확한 판단을 하기에는 너무 이르지만, 지금까지 내가 느낀 점을 정리하자면 위와 같이 정리할 수 있을 것 같다. 추후에 시간이 지나면 새롭게 느낀점이나 아쉬웠던 점에 대해서 정리해 보고자 한다.