1. 객체지향 이론, 언어

객체지향 이론

객체 지향 이론은 '실제 세계는 사물(객체)로 이루어져 있으며 발생하는 모든 사건들은 사물간의 상호작용이다.'를 기본개념으로 한다.
객체 지향 이론은 상속, 캡슐화, 추상화 개념을 중심으로 발전하였다.

객체지향 언어

1. 코드의 재사용성이 높다.
   • 새로운 코드를 작성할 때 기존의 코드를 이용하여 쉽게 작성할 수 있다.
2. 코드의 관리가 용이하다.
   • 코드간 관계를 이용하여 적은 노력으로 쉽게 코드를 변경할 수 있다.
3. 신뢰성 높은 프로그래밍을 가능하게 한다.
   • 제어자와 메서드를 이용하여 데이터를 보호하고 올바른 값을 유지하도록 하며, 코드의 중복을 제거하여 코드의 불일치로 인한 오동작을 방지할 수 있다.

2. 클래스, 객체

• 클래스 : 객체를 정의해 놓은것, 객체를 생성할 때 사용된다.
• 객체(인스턴스) : 실제로 존재하는 것, 사물 또는 개념

2.1 객체의 구성요소

• 속성 : member variable, attribute, field, state
• 기능 : method, function, behavior

// class
class Tv {
   // member variable
   String color;
   boolean power;
   int channel;

   // method
   void power() {power = !power; }
   void channelUp (){ ++this.channel; }
   void channelDown() { --this.channel; }
}

class TvTest {
   public static void main(String args[]) {
      Tv t;          // t : Tv인스턴스를 참조하기위한 변수 t
      t = new Tv();  // 인스턴스 생성
      t.channel = 7;
      t.channelDown();
      ...
   }
}

📋 자바 명명 규칙 가이드

1. Class, Interface : 명사여야 하며 대문자로 시작하여야 한다.
2. Method : 동사여야하며, 소문자로 시작한다. 붙이는 단어의 경우 붙이는 단어 첫문자를 대문자로 쓴다. ex) isFunny(){}
3. 변수 : 소문자로 시작하며, 두글자 이상을 권장한다.
4. 상수 : 모든 글자에 대문자를 사용한다.
5. 패키지 : 모든 글자를 소문자로 사용한다.

2.2 인스턴스 생성시 메모리 구조

| color         | <-지역변수-> <--0x100-->
| power         |
| channel       | 
| power()       | <--메서드-->
| channelUp()   |
| channelDown() |

2.3 인스턴스 생성 및 사용

1. Tv t;
   • 참조 변수 t를 위한 공간 생성
2. t = new Tv();
   • 연산자 new에 의해 인스턴스가 메모리의 빈공간에 할당.
   • 멤버변수는 각 자료형의 기본값으로 초기화
   • 생성된 인스턴스의 주소값은 참조변수 t에 저장(t를 통해 객체에 접근 가능)

Tv t1 = new Tv();
Tv t2 = new Tv();

3. t2 = t1
   • t1는 참조변수이므로 인스턴스의 주소를 저장하고있다.
   • t2는 대입연산자에 의해 t1의 주소를 t2에 저장한다.
   • 기존 t2가 가리키고 있던 인스턴스(객체)는 참조변수가 하나도 없게 된다.
     • 이러한 인스턴스는 Garbage Collector에 의해 자동적으로 메모리에서 제거된다.

2.4 프로그래밍 관점에서의 클래스에대한 정의

객체지향이론의 관점에서 클래스는 객체를 생성하기 위한 틀로 속성과 기능으로 정의되어있다.

프로그래밍적 관점에서의 클래스는 다음과 같은 발전과정을 거쳤다.

변수 -> 배열 -> 구조체(자료형이 다른 변수) -> 클래스(구조체 + 함수)

함수는 많은 경우에 있어데이터를 가지고 작업을 하기 때문에 데이터와 함수는 관계가 깊다. 따라서 자바와 같은 객체지향 언어에서는 변수와 함수를 하나의 클래스에 정의하여 서로 관계가 깊은 변수와 함수들을 함께 다룰 수 있게 하였다.

다음과 같이 클래스의 멤버 변수를 직접 접근하지 않고 get(), set()메서드를 통해 접근하게 하면, 보다 정확한 데이터를 유지하는데 도움이 된다.

public class Time() {
   private hour;
   ...
   public int getHour();
   public int setHour();
   ...
}

3. 변수와 메서드

3.1 선언 위치에 따른 변수의 종류

class Variable {
   static int cv;    // 클래스 변수
   int iv;           // 인스턴스 변수

   void method() {
      int lv = 0;    // 지역변수 
   }
}

클래스 변수

• 인스턴스를 생성하지 않고도 언제든지 사용할 수 있다.
• 메모리에 로딩되어 프로그램이 종료될 때 까지 유지된다.
• 클래스 변수를 통해 모든 인스턴스가 하나의 저장공간을 공유하게 하여 공통된 값을 갖도록 할 수 있다.

인스턴스 변수

• 인스턴스가 생성될 때 마다 생성되므로 각기 다른 값을 유지할 수 있다.

3.2 메서드

메서드를 사용하는 이유

1. 높은 재사용성
2. 중복된 코드의 제거
3. 프로그램의 구조화

• 같은 클래스 내의 메서드 끼리는 참조변수를 사용하지 않고도 서로 호출이 가능하지만, static메서드는 같은 클래스 내의 인스턴스 메서드를 호출할 수 없다.
  • 인스턴스 변수는 인스턴스가 생성된 후에나 사용할 수 있음.

3.3 JVM 메모리 구조

1. Method Area(메서드 영역)
   • 프로그램 실행 중 어떤 클래스가 사용되면, JVM은 해당 클래스의 클래스 파일을 읽어서 분석하여 클래스에 대한 정보를 이곳에 저장한다. 이때 클래스 변수도 이영역에 함께 생성된다.
2. Call Stack(호출 스택)
   • 메서드의 작업에 필요한 메모리 공간을 제공함. 메서드가 작업을 수행하는 동안 지역 변수, 연산의 중간 결과를 저장하는데 사용되며, 메서드가 반환되면, 메모리공간도 반환되어 비워진다.
   • 참조변수 또한 이영역에 저장되어 힙영역의 인스턴스를 가리키는 역할을 한다.
3. Heap(힙)
   • 인스턴스가 생성되는 공간으로 인스턴스 변수가 이곳에 생성된다.

3.4 매개변수 : 참조형, 기본형

static void change(int x)              // x는 기본형 매개변수
static void changeClass(Data d)        // d(클래스 인스턴스)는 참조형 매개변수
static void changeArray(int add[] arr) // arr(배열)은 참조형 매개변수

메서드 호출시 매개변수의 타입이 기본형(primitive type)이면 매개변수의 값이 복사되지만, 참조형(reference type)이면 인스턴스의 주소가 복사된다.

기본형 매개변수는 변수의 값을 읽기만 할 수 있지만, 참조형 매개변수는 변수의 값을 읽고 변경할 수 있다.

4. 오버로딩

4.1 오버로딩 조건

1. 메서드 이름이 같아야 한다
2. 매개변수의 개수 또는 타입이 달라야 한다.

void println();
void println(boolean x);
void println(char x);
void println(char[] x);
void println(double x);
void println(float x);
...

4.2 가변인자 오버로딩

<타입>... 변수명의 형식으로 선언한다.

public PrintStream printf(String format, Object... args);

가변인자는 매개변수들 중 가장 마지막에 선언되어야 한다.

가변인자는 내부적으로 배열을 이용한다. 하지만 매개변수 타입을 배열로 하는것과 달리 인자를 생략할 수도있고, null이나 길이가 0인 배열도 인자로 포함할 수 있다.

인자로 배열을 사용한 경우

String concatenate(String[] str);
String result = concatenate(new String[0]);
String result = concatencate(null);
String result = concatenate();

가변인자를 사용한 메서드는 가능하면 오버로딩 하지 않는게 좋다. 다음과 같은 경우에 에러가 발생할 수 있다.

static String concatenate(String delim, String... args) {...}
static String concatenate(String... args) {...}

컴파일시 두 오버로딩된 메서드가 구분되지 않아 에러가 발생할 수 있다. 따라서 가능하면 가변인자를 사용한 메서드는 오버로딩 하지 않는것이 좋다.

5. 생성자

5.1 생성자 기본

1. 생성자의 이름은 클래스의 이름과 같아야 한다.
2. 생성자는 반환 값이 없다.

class Card {
   Card() { // class name = method(constructor) name
      ...
   }
   Card(String k, int num) {
      ...
   }
}

모든 클래스에는 하나 이상의 생성자가 정의되어있어야 한다. 하지만 실제로 인스턴스 생성시 생성자 없이도 인스턴스를 생성할 수 있었는데 이는 기본 생성자 덕분이다.

기본생성자는 컴파일러가 자동적으로 추가하는 생성자로, 특별히 인스턴스 초기화 작업이 필요하지 않다면, 기본생성자를 사용하는 것도 좋다.

class Data {
   int val;

   Data(int x) {
      this.val = x;
   }
}

class Test {
   public static void main(String argsp[]) {
      Data d1 = new Data();      // 컴파일 에러 발생 
      Data d2 = new Data(5);
   }
}

위의 Data클래스에 대한 인스턴스를 매개변수 없이 생성할때 컴파일 에러가 발생한다. 매개변수가 있는 생성자가 존재하므로 컴파일러는 기본 생성자를 추가하지 않아 매개변수가 없는 생성자는 정의되지 않는다.

즉 기본 생성자가 컴파일러에 의해서 추가되는 경우는 클래스에 정의된 생성자가 하나도 없을 때 뿐이다.

5.2 다른 생성자 호출

• 생성자의 이름으로 클래스이름 대신 this를 사용한다.
• 한 생성자에서 다른 생성자를 호출할 때는 반드시 첫 줄에서만 호출이 가능하다.

에러가 발생하는 경우

Car(String color) {
   door = 5;
   Car(color, "auto", 4);
}

수정

Car(String color) {
   this(color, "auto", 4);
   door = 5;
}

this는 참조변수로 인스턴스 자신을 가리킨다. 참조변수를 통해 인스턴스의 멤버에 접근할 수 있듯, this를 통해 인스턴스 변수에 접근할 수 있다.

5.3 생성자를 통한 인스턴스 복사

class Car {
   int a;
   String b;
   float c;
   Car() {
      this(10, "kk", "5.1");
   }
   Car(Car ca) {
      /*
      a = ca.a;
      b = ca.b;
      c = ca.c;
      */
      this(ca.a, ca.b, ca.c); // 기존의 코드를 재활용하는것이 바람직 하다
   }
}

6. 변수의 초기화

6.1 초기화 블럭

클래스 초기화 블럭

• 클래스 변수의 복잡한 초기화에 사용된다
• 클래스 로드시 한번만 수행
• 인스턴스 초기화 블럭*
• 인스턴스 변수의 복잡한 초기화에 사용된다
• 인스턴스가 생성될때 마다 수행된다.

  // 클래스 초기화 블럭
  static {
   ...
  }
  

// 인스턴스 초기화 블럭
{
...
}

```java
class BlockTest {
   int a;
   static int[] arr = new int[10];
   static {
      for(int i = 0; i < 10; i++) {
         arr[i] = (int)(Math.random() * 10 + 1);
      }
   }

   {
      a = (int)(Math.random() * 10 + 1);
   }
}

class Car {
    static int num = 0;
    static { 
        System.out.println("Class loaded");
    }

    {
        System.out.println(num++ + "번째 차");

    }
}
public class App {
    public static void main(String[] args) {
        Car c1 = new Car();
        Car c2 = new Car();

    }
}

6.2 초기화 시기와 순서

컬렉션 프레임 워크는 데이터 군을 저장하는 클래스를 표준화한 프레임워크로, 데이터를 저장하는 자료구조와 알고리즘을 클래스로 구현해놓은것입니다.
제네릭과 다형성을 이용한 객체지향 설계로 표준화 되어있어 사용법을 익히기도 편리하며, 재사용성이 높은 코드를 작성할 수 있다는 장점이 있습니다.

컬렉션 프레임워크 인터페이스

컬렉션 프레임 워크에는 대표적으로 다음의 3가지 인터페이스가 존재합니다.

• List
• Set
• Map

List와 Set을 구현한 컬렉션 클래스들은 공통점이 많아 공통된 부분을 Collection이라는 새로운 인터페이스로 정의하여 놓았습니다. 반면 Map을 구현한 클래스들은 전혀 다른 형태로 컬렉션을 다루기 때문에 Collection을 상속하지 않습니다.

컬렉션 프레임 워크의 구현클래스들은 인터페이스의 이름을 포함하는 명명법을 따르지만 Vector, Stack, HashTable, Properties와 같은 클래스들은 컬렉션 프레임워크 이전부터 존재하였던 것이기 때문에 컬렉션 프레임워크의 명명법을 따르지 않습니다.

자바 컬렉션 프레임워크를 사용할 때 List, Set, Map과 같은 인터페이스가 아닌 ArrayList, Vector, HashMap, HashTable과 같은 구현체로 선언할 때가 있는데 이는 객체의 결합도를 매우 강하게 유지하여 비효율적이며, 추상화에 의존해야한다는 SOLID의 DIP원칙을 위반합니다.

import java.util.*;

class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();   // Bad usecase
        List<Integer> list2 = new ArrayList<>();        // Good usecase
    }
}

Vector, HashTable은 Backward Compatibility를 위해 존재하는것으로 가능하면 사용하지 않는것을 권장합니다.

Collection

Collection은 List와 Set의 조상 인터페이스로 컬렉션 클래스에 저장된 데이터를 조회하고 추가 삭제하는등의 기본적인 메서드들을 정의하고 있습니다.

contains의 경우 구현에 따라 시간복잡도가 달라집니다. ArrayList의 경우 O(n)시간에 확인하며, HashMap의 경우 O(log n)의 시간에 확인합니다.

equals의 경우 내부의 값을 비교하는데, 값의 순서가 달라도 false를 반환합니다. 따라서 값의 포함 여부를 확인하고 싶으면 contains를 사용하면 됩니다.

import java.util.*;

class Main {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();

        for(int i = 0; i < 10; i++) {
            list1.add(i);
            list2.add(i);
        }

        for(int i = 0; i < 8; i++) {
            list3.add(i);
        }

        list3.add(9);
        list3.add(8);

        System.out.println(list1.equals(list2));
        System.out.println(list1.equals(list3));
    }
}

List Interface

List인터페이스는 중복을 허용하고 저장순서가 유지되는 자료구조를 가집니다. Collection인터페이스를 상속합니다.

순서가 유지되는 만큼 인덱스로 데이터에 접근할 수 있는 메서드들이 존재합니다.

다음의 구현 클래스를 가집니다.

• ArrayList
• LinkedList
• Vector
• Stack

ArrayList vs LinkedList

ArrayList의 경우 저장공간이 부족하면, 현재사이즈 * 2만큼의 새로운 저장공간을 확보한 후 데이터를 추가합니다. 반면, LinkedList의 경우 저장공간을 따로 확보하는것이 아니라 새로운 노드를 생성하여 연결하는 방식입니다. 따라서 충분한 공간을 확보해 준다면 순차적인 추가/삭제는 ArrayList가 더 빠릅니다.

반면 중간의 데이터를 추가/삭제하는 경우 ArrayList는 모든 요소를 재배치해야 하기 때문에 LinkedList에 비해 속도가 느립니다.

ArrayList의 경우 사용하지 않는 공간도 할당 될 수 있기 때문에 메모리 사용이 비효율적이라는 단점이 있으며, LinkedList의 경우 각 요소들이 연결되어있는 형태이기 때문에 데이터가 많을수록 읽어오는 시간이 길어진다는 단점이 있습니다.

Stack

Stack클래스는 Vector클래스를 상속하며, Last In First Out의 자료구조입니다.

import java.util.Stack;

class Main {
    public static void main(String[] args) {
        Stack<String> animals= new Stack<>();

        animals.push("Dog");
        animals.push("Horse");
        animals.push("Cat");
        System.out.println("Stack: " + animals);

        // Search an element
        int position = animals.search("Horse");
        System.out.println("Position of Horse: " + position);
    }
}

Stack: [Dog, Horse, Cat]
Position of Horse: 2

Queue Interface

Queue인터페이스는 Collection인터페이스를 상속하며 First In First Out의 자료구조입니다.

구현체는 다음과 같습니다.

• ArrayDequeue
• LinkedList
• PriorityQueue
  • 저장한 순서에 관계없이 우선순위가 높은 것부터 꺼내는 형태로, 힙 자료구조 형태로 저장합니다.

이외에도 Queue인터페이스를 상속하는 다음과 같은 인터페이스들이 있습니다

• Deque
  • 기존의 큐와 달리 앞뒤로 삽입 삭제를 할 수 있습니다.
• BlockingQueue
• BlockingDeque

Set Interface

List인터페이스와 동일하게 Set인터페이스도 Collection인터페이스를 상속합니다. 하지만 중복 요소를 허용하지 않으며, 저장순서 또한 유지되지 않습니다.

• HashSet
  • HashSet은 Set인터페이스를 구현한 가장 대표적인 컬렉션입니다. add나 addAll메서드를 통해 새로운 요소를 추가하며, 중복된 요소를 허용하지 않기 위해 equals를 호출하여 중복된 요소가 컬렉션 내에 존재하는지 확인합니다.
  • HashSet은 저장된 순서를 유지하지 않기 때문에, 저장한 순서를 유지하고자 한다면, LinkedHashSet을 사용하여 저장순서를 유지할 수 있습니다.
• TreeSet
  • 이진 탐색 트리의 일종인 레드-블랙트리로 구현된 컬렉션 클래스 입니다.

Map Interface

Map은 key-value의 형태로 요소를 저장하는 인터페이스입니다. 중복된 key를 허용하지 않고, 각 키는 하나의 값에 대응됩니다.

Map은 다음의 5개 구현 클래스를 가집니다

• HashMap
  • 해싱을 사용하여 많은 양의 데이터를 검색하는데 좋은 성능을 보입니다.
• EnumMap
• LinkedHashMap
• WeakHashMap
• TreeMap
  • 이진 탐색트리의 형태로 탐색과 정렬에 적합한 클래스입니다.

Map은 다음과 같이 3개의 확장 인터페이스를 가집니다.

• SortedMap
• NavigableMap
• ConcurrentMap

Reference

• Java의 정석
• https://docs.oracle.com/javase/7/docs/api/
• https://www.programiz.com/java-programming

[Java] 추상클래스와 인터페이스

Goal

• 추상클래스와 인터페이스에 대한 이해

추상클래스(Abstract Class)

추상클래스는 구현부가 없어 인스턴스를 생성할 수 없고, 상속을 통한 자손클래스로만 구현이 가능합니다. 이러한 추상클래스의 존재이유는 객체지향 설계의 추상 개념과 맞닿아 있습니다.

추상 개념은 구체적인 사물들의 공통적인 특징을 파악해서 이를 하나의 개념으로 나타내는것을 말합니다. 예를들어 구, 사면체, 육면체 등과 같은 도형은 입체라는 공통적인 특징을 통해 입체도형이라는 개념으로 나타낼 수 있습니다. 하지만, 이러한 도형의 겉넓이, 부피를 구하는 구체적인 행동을 구현하고자 한다면, 도형의 형태에 따라 겉넓이와 부피를 구하는 방식이 다르기 때문에 입체도형의 입장에서는 이러한 행동을 구현하기 어렵습니다.

이렇게 각각의 도형의 상위 클래스의 입장에서 하위클래스의 구체적인 행동내용을 정의 할 수 없기 때문에 추상클래스를 사용합니다.

abstract class Figure {
    abstract int getSurfaceArea();  // 추상 메서드
    abstract int getVolume();       // 추상 메서드
}

class Ball extends Figure {
    int getSurfaceArea() { ... };   // 추상 메서드 구현
    int getVolume() { ... };        // 추상 메서드 구현
}

class Tetrahedron extends Figure {
    int getSurfaceArea() { ... };   // 추상 메서드 구현
    int getVolume() { ... };        // 추상 메서드 구현

}

추상화는 구체화와 반대되는 의미로 이해할 수 있습니다. 상속 계층도에서 상위에 위치할 수록 추상화 정도가 심해져 공통요소만 남게 되며, 하위에 위치할 수록 구체화 정도가 심해져 세분화 된다고 할 수 있습니다.

인터페이스(Interface)

추상클래스가 정의한 타입을 구현하는 클래스는 반드시 추상 클래스의 하위 클래스가 되어야 합니다. 자바는 단일 상속만을 지원하기 때문에 추상클래스를 통한 설계 방식은 새로운 타입을 정의하는데 큰 제약을 받게 됩니다.

abstract class TV {
    void show();
}

abstract class VCR {
    void scanTape();
}

class TVCR extends TV,VCR { // 이와 같은 다중 상속은 허용하지 않습니다.
    ...
}

반면 인터페이스의 경우 선언한 추상메서드를 모두 정의하고 일반 규약만 잘 지킨다면 어떤 클래스를 상속했든 같은 타입으로 취급되어 다중 상속이 가능합니다.

interface TV {
    void show();
}

interface VCR {
    void scanTape();
}

interface TVCR extends TV, VCR {

}

이러한 다중 상속의 특성 때문에 인터페이스로는 계층구조가 없는 타입 프레임 워크를 만들 수 있습니다.

다음 코드에서 가수(Singer)와 작곡가(Songwriter)는 어느 쪽이 상위 개념이라 명확하게 구분하기 어렵습니다. 이때 작곡도 하는 가수를 구현하고자 하는 경우 가수에 작곡가의 코드를 구현해도 문제되지 않지만, 다중 상속을 통해 제 3의 인터페이스를 정의할 수도 있습니다.

public interface Singer {
    AudioClip sing(Song s);
}

public interface Songwriter {
    Song compose(int chartPosition);
}

public interface SingerSongwriter extends Singer, Songwriter {
    AudioClip strum();
    void actSensivitve();
}

인터페이스는 추상클래스보다 추상화 정도가 높아 일반 메서드나 멤버변수를 구성원으로 가질 수 없습니다. 오직 추상 메서드와 상수만을 허용합니다.

• 인터페이스 작성시 모든 멤버변수는 public static final이어야 하며, 이를 생략할 수 있다.
• 모든 메서드는 public abstract이어야 하며, 이를 생략할 수 있다.

추상클래스가 상속을 통해 추상 메서드를 완성하는 것 처럼, 인터페이스도 추상메서드를 구현하는 클래스를 작성해야 합니다. 다만 클래스는 확장한다는 의미의 키워드 extends를 사용하지만, 인터페이스는 구현한다는 의미의 implements를 사용합니다.

interface TV {
    void show();
}

interface VCR {
    void scanTape();
}

interface TVCR extends TV, VCR {

}

class LGTV implements TVCR {
    public void show() { ... }
    public void scanTape() { ... }
}

Reference

• Java의 정석
• Effective Java