[4일 차] 소프트웨어 엔지니어링 (Ch06 ~ Ch07)

---

25/01/23 (목)

요즘 베개에 머리를 대면 바로 잠들어버립니다. 주짓수의 힘일까요

어제는 새우빼기와 어께넘어 손(이름을 모르겠습니다) 터치하는걸 배웠습니다.

가장 기본적이고 많이 쓰이는 가드를 알려달라했더니 이 둘을 말씀하셨습니다.

주짓수의 꽃은 가드라지만 저는 탑이 더 매력적이게 느껴졌습니다.

테이크 다운 후 바로 가드 패스

빨리 배워서 대련을 하고싶습니다.

 

---

 

1.  WorkShop 발표

1) Garbage Collection

가비지 컬렉션의 판단 기준

-도달성( Reachablity)기반 판단

 1. Reachable : 객체가 참조되고 있는 상태

 2. Unreachable : 참조가 되고 있지 않는 상태 (GC 대상)

 

연쇄적 참조에도 해당됩니다.

 

2) String literal vs String 객체

// String Literal
String str1 = "test";

// String 객체
String str2 = new String ("test");

System.out.println(str1 == str2);
>> false

강사님> Primitive Type이 스택 메모리에 저장된다고 설명하는데 오해의 소지가 있다. Class 안에 Primitive Type이 선언되면 Heap영역 에 생성 될 수 있다고 합니다.

 

3) Overloading vs Overriding

*메소드 시그니처 : 메소드 이름 + 매개변수 타입과 개수

*다형성(polymorphism)

 

4) 문자열 상수 저장 관련

String a = "a";
String b = "b";
String ab = "ab";

Syetem.out.pritnln(ab == (a+b));
>> false

상수풀은 메소드 영역에 저장되는데 문자열 상수는 GC에게 제거 되지 않는가?

Java 6 이하는 JVM이 종료될 때까지 유지되었습니다.

Java 7 이상은 Heap 영역에 위치해서 GC의 대상이 될 수있습니다.

 - 하지만 GC가 String Constant Pool에 저장된 문자열이 재사용 가능성이 높다고 판단해서 회수하는 일은 드물었습니다.

 

강사님> JVM의 구현방식은 매우 융통성이 있어서 면접 때 '하지만' 부분이 중요합니다.

강사님> Pool이 붙은 것들은 재사용성이 높은 것들을 미리 만들어둔다는 뜻입니다.

 

2.  강의

2.1.  CH06 클래스

1) Method Overloading

Car.java

    public Car(int speed){
    }

    // 생성자 overloading
    public Car(String name, int speed){

    }
====================================================
test.java

        // 생성자 여러개 (Overloading)
        {
            Car car1 = new Car(1);
            Car car2 = new Car("소나타", 10);
        }

---

public class Car {
    // 필드 추가
    String name;
    int speed;

    public Car(int speed){
        // 추가된 필드에 값 지정
        this.speed = speed;
    }

    public Car(String name, int speed){
        // 추가된 필드에 값 지정
        this.name = name;
        this.speed = speed;
    }

---

---

    public Car(String name, int speed){
        // 4. 추가된 필드에 값 지정
        this.name = name;
        this.speed = speed;
    }

    // 5. this() 활용
    public Car(int speed){
        // name에 기본값(default)을 지정하고 Car(name, speed);
        this("아반떼", speed);
    }

this를 활용하여 default 값을 지정하는 법

this("아반떼", speed);

 

Overloading을 왜 사용하나했더니 메소드의 이름을 재사용하고 가독성을 높히기 위해서라고 합니다.

하지만 coupling이 심해질 수 있다고 합니다.

 

나> drive와 getDriveInfo의 유의미한 차이가 있나(출력값이 같다) 궁금해서 질문했습니다.

강사님> 굳이 따지자면 getDriveInfo가 더 효용성이 높다고 할 수 있지만 예시를 든 이유는 이런 방식으로도 Overloading이 가능하다는 것을 알려드릴려고 예시를 들었습니다.

 

2) 정적 멤버(Static)

---

• static메소드에서 non-static 필드에 접근과 call이 불가능하다
• 객체로부터 접근 : 실행은 되나 올바르지 않다.

의문점> 클래스나 메서드가 생성되자마자 실행되는걸까?

 

3) final 필드 선언

나> final int num;은 null로 초기화 되나요?

강사님> 일단 int는 null로 초기화 되지 않습니다. final은 값이 없이 만들어지지 않습니다.

• method에 final이 붙으면 재정의가 불가능합니다.
• class에 final이 붙으면 상속이 불가능합니다.

4) 패키지

    public static void main(String[] args) {
        // String class import
        String str = "Hello";
        
        // package를 import 해야 한다
        Random ran = new Random();
        
        // 컴파일러가 java.lang package를 자동으로 import 해 준다.
    }

★ 패키지는 클래스의 일부입니다. 패키지는 주로 개발 회사 도메인 이름의 역순으로 만듭니다.

 

WorkShop> 나만의 패키지와 클래스를 만들고, 자료 파일로 만들어서 다른 사람들이 그 패키지를 사용해보자

Library > ClassPath > 파일 찾아서 import 하기

 

5) 접근 제한자

package ch06.A;

public class a {
    private int n;
    public int n2;
    int n3;            // default
    protected int n4; // protected

    private void m() {
        System.out.println(n);
    }
    
}
===========================================================
package ch06.B;

import ch06.A.a;

// 상속 관계에서 protected에 접근 가능하다는 같은 객체 내에서만 허용
public class b extends a{

//  a AA = new a();
    public void m() {
        a A = new a();
//      int x = A.n4; // 접근
    }

    public void m2() {
        int x = super.n4; // 부모 protected 클래스는 super로 접근
    }
}

• A (a,b), B (a,b,c) 일때
• (default)는 서로 접근이 불가능하다.
• private는 A가 B로 상속 받았을 때 A(하위) -> B(상위)로 접근이 가능하다.

 

6) Getter와 Setter

• Encapsulation : 필드를 private화 해서 감추고 해당 필드에 대한 접근은 getter, setter를 통해서 한다.
• 필드를 외부에서 직접 read/update하지 못하게 하고 메소드를 통해서 가능하게 구조를 만든다.

 

2.2.  CH07 상속

1) 상속 개념

WorkShop> Has A, Is A 관계가 있는데 알아봐라

 

2) 메소드 Overriding

• 메소드 시그니처가 동일해야한다. (지켜야하는 규칙 3가지 : return type, access modifier, exception 처리)
• 접근 제한을 더 강하게 오버라이딩 할 수 없다. (public -> private 불가)
• 새로운 예외를 throws 할 수 없다.

 

3) 자동 타입 변환

 

4) 다형성

package ch07.typepoly;

public class test {
    public static void main(String[] args) {
        // 타입 다형성 = assign
        {
            A a = new A(); // 부모 - 부모
            B b = new B(); // 자식 - 자식
            A ab = new B(); // 부모 - 자식
//          B ba = new A(); // 자식 - 부모 (X)
        }
        
        // 타입 다형성 : parameter
        {
            A a = new A();
            B b = new B();

            m1(a);
            m1(b);
//          m2(a); // X
            m2(b);
        }
    }
    // 타입 다형성 : parameter
    static void m1(A a) {}
    static void m2(B b) {}
    
    // 타입 다형성 : return type
    static A m3() {return new A();}
    static A m4() {return new B();}
//  static A m5() {return new A();} // X
    static A m6() {return new B();}
}

사용 방법은 동일하지만 실행 결과가 다양하게 나오는 성질.

자동차 부품 바꾸면 성능이 다르듯 객체를 바꾸면 프로그램 실행 성능이 달라짐

 

강사님> 컴파일러가 자동으로 하는 일을 알아두세요

• 생성자가 없으면 추가
• java.lang 자동 import
• 생성자에 super()가 없으면 자동으로 추가
• 아무것도 상속받지 않는 Class는 자동으로 extends Object를 추가한다. (Object는 모든 클래스가 상속받는다)

 

3.  마무리

1) WorkShop

이제 다들 친해져서 잡담을 하는 시간이 많아졌습니다.

워크샵 목적이 애초에 친해지는 시간이라 목적에 달성한것 같습니다.

그치만 할건 해야죠!

• 나만의 패키지와 클래스를 만들고, 자료 파일로 만들어서 다른 사람들이 그 패키지를 사용해보자
• Has A, Is A 관계가 있는데 알아보자

package Ureka;

import Ureka.Student.Team1;
import Ureka.Student.Team2;
import Ureka.Student.Team3;
import Ureka.Student.Team4;
import Ureka.Student.Team5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class RandomTeamShuffle {
    public static void main(String[] args) {
        // 모든 조원들을 하나의 리스트로 합치기
        List<String> allMembers = new ArrayList<>();
        Collections.addAll(allMembers, Team1.members);
        Collections.addAll(allMembers, Team2.members);
        Collections.addAll(allMembers, Team3.members);
        Collections.addAll(allMembers, Team4.members);
        Collections.addAll(allMembers, Team5.members);

        // 리스트 섞기
        Collections.shuffle(allMembers);

        // 팀 수 계산
        int totalTeams = 5;
        int totalMembers = allMembers.size();
        int baseSize = totalMembers / totalTeams; // 기본적으로 팀에 들어갈 인원 수
        int extraMembers = totalMembers % totalTeams; // 나머지 인원 수

        // 팀 나누기
        List<List<String>> teams = new ArrayList<>();
        int index = 0;
        for (int i = 0; i < totalTeams; i++) {
            int currentTeamSize = baseSize + (extraMembers > 0 ? 1 : 0); // 나머지가 있는 경우 한 명 추가
            extraMembers--;
            teams.add(new ArrayList<>(allMembers.subList(index, index + currentTeamSize)));
            index += currentTeamSize;
        }

        // 각 팀 출력
        for (int i = 0; i < teams.size(); i++) {
            System.out.println("Team " + (i + 1) + ":");
            for (String member : teams.get(i)) {
                System.out.println("- " + member);
            }
            System.out.println();
        }
    }
}

이렇게 패키지를 만들고 공유해봤습니다.

 

조원분들과 웃고 떠들면서 많이 친해진것 같습니다.

다들 '대면이었다면 더 좋았을텐데'라며 아쉬워했습니다.

그만큼 다들 좋은사람들이라는 뜻이죠.

언젠간 한번 다 모여서 봤으면 좋겠습니다.