JAVA에서 DB에 접근할 수 있게 해주는 API로 JDBC API를 사용해 자바 언어로 DB에 접근하고 읽고 쓸 수 있다.

DRIVER

JDBC API로 DB에 접근할 때 DRIVER를 통해 DBMS에 접근한다.

DRIVER는 각 DBMS 회사에서 제공한다.

😎 DRIVER를 찾는 방법은 자신이 쓰는 DBMS의 '회사명 JDBC'처럼 검색해보자 예시) ORACLE JDBC, MySQL JDBC

Libraries 등록

다운받은 DRIVER를 이클립스 Library에 등록해보자

- Project 생성할 때 등록

• NEXT로 다음 페이지로 넘어가기

• ① Libraries 탭 선택
• ② 다운받은 DRIVER 경로에 가서 .jar파일 가져오기
• ③ Finish 선택하면 끝

- 생성된 Project에 등록

• 생성된 Project 우클릭 -> Build Path -> Configure Build Path 선택

• ① Libraries 탭 선택
• ② Classpath 선택
• ③ 다운받은 DRIVER 경로에 가서 .jar파일 가져오기
• ④ Finish 선택하면 끝

Character Set 설정

DB와 문자 인코딩 방식이 다를 경우 문자가 제대로 출력되지 않는다. 이를 방지하기 위해 이클립스 문자셋을 UTF-8로 일치시켜줘야 한다.

끝

DML(Data Manipulation Language)은 DB에 데이터를 조회, 삽입, 수정, 삭제하는 작업을 수행하는 구문으로, 크게 SELECT, INSERT, UPDATE, DELETE 4가지로 나뉜다. (TABLE을 조작하는 언어)

SELECT

DB에 데이터를 조회하는데 사용되며 SELECT 구문은 다음과 같다.

-- SELECT 구문
SELECT 컬럼명        -- FROM TABLE의 조회하고 싶은 컬럼명

FROM 테이블명         -- 데이터를 조회하고 싶은 TABLE명

WHERE 조건            -- 조회하고 싶은 데이터의 조건

GROUP BY 컬럼명        -- 특정 컬럼을 기준으로 데이터를 그룹화(주로 그룹함수와 사용)

HAVING 그룹함수        -- 그룹화된 데이터에 대한 조건

ORDER BY 컬럼명        -- 정렬하고 싶은 컬럼명

🙄 WHERE이랑 HAVING의 차이점은 뭐야? 😎 그룹화된 데이터의 유무이며, 유사한 역할을 한다. 하지만 WHERE절은 그룹화 이전에 필터링을 수행하고, HAVING 절은 그룹화 이후에 조건을 적용한다.

SELECT문 실행순서 FROM -> WHERE -> GROUP BY -> HAVING -> SELECT -> ORDER BY

SELECT 키워드

-- EMPLOYEE 테이블 전체 조회
SELECT *
FROM EMPLOYEE;

-- 산술연산 가능
SELECT 10 + 10
FROM DUAL;

-- 별칭
SELECT EMP_NAME AS 사원이름, EMP_NO AS "사원 번호"
FROM EMPLOYEE;

-- 리터럴
SELECT SALARY AS 월급, '원' AS 단위
FROM EMPLOYEE;

-- DISTINCT
-- 중복값을 한번씩만 표시 (SELECT절에 1회만 가능)
SELECT DISTICT 컬럼명
FROM 테이블명;

SELECT DISTINCT EMP_NAME AS 사원이름
FROM EMPLOYEE;

WHERE 키워드

-- WHERE
SELECT 컬럼명
FROM 테이블명
WHERE 조회하고 싶은 데이터의 조건

-- 이름이 '핑구'인 직원 찾기
SELECT EMP_NAME AS 사원이름
FROM EMPLOYEE
WHERE EMP_NAME = '핑구';

-- 이름이 '핑구'이며 월급이 3,000,000원 이상인 사원 찾기
-- AND | OR
SELECT *
FROM EMPLOYEE
WHERE EMP_NAME = '핑구' AND SALARY >= 3000000;
-- 이름이 '핑구'이거나 '펭구'인 사원 찾기
WHERE EMP_NAME = '핑구' OR EMP_NAME = '펭구';

-- LIKE & NOT LIKE
SELECT 컬럼명
FROM 테이블명
WHERE 컬럼명 LIKE 리터럴;
-- % : 포함된 문자 조회
-- _ : _ 개수만큼 문자 조회
SELECT EMP_NAME AS 사원이름
FROM EMPLOYEE
WHERE EMP_NAME LIKE '핑%';        -- 핑씨 사원
WHERE EMP_NAME LIKE '%핑%';        -- 핑이 포함된 이름
WHERE EMP_NAME LIKE '핑_';        -- 핑씨 외자
WHERE EMP_NAME LIKE '_핑_';        -- 가운데 핑이들어간 3글자 이름

-- 🙄 %, _ 둘 다 사용할 때는??
-- 😎 ESCAPE문을 쓰면 된다.

-- ESCAPE
SELECT EMP_NAME
FROM EMPLOYEE
WHERE EMP_NAME LIKE '__|_%' ESCAPE '|';

-- IS NULL & IS NOT NULL
SELECT 컬럼명
FROM 테이블명
WHERE 컬럼명 IS NULL || IS NOT NULL

SELECT *
FROM EMPLOYEE
WHERE MANAGER_ID IS NULL;        -- 매니저가 없는 직원 조회

-- IN
-- OR 연산자를 많이 쓸 때
SELECT 컬럼명
FROM 테이블명
WHERE 컬럼명 IN (리터럴, 리터럴 . . .);

SELECT *
FROM EMPLOYEE
WHERE DEPT_CODE IN ('D6', 'D7');     -- 부서코드가 D6, D7인 직원

-- BETWEEN AND
SELECT 컬럼명
FROM 테이블명
WHERE 컬럼명 BETWEEN 최소범위 AND 최대범위;

SELECT *
FROM EMPLOYEE
-- 월급이 2,000,000원 ~ 4,000,000원인 사원
WHERE SALARY BETWEEN 2000000 AND 4000000;

INSERT

TABLE에 새로운 행을 삽입하는 명령어

-- INSERT
INSERT INTO 테이블명 VALUES(컬럼대입 값, 컬럼대입 값...)

-- 테이블 생성
CREATE TABLE TEST(
    NAME VARCHAR2(15),
    AGE NUMBER
);

-- TEST 테이블에 행(ROW) 삽입
INSERT INTO TEST VALUES('핑구펭구', 5);

-- 특정컬럼에 값을 대입
INSERT INTO 테이블명(특정컬럼...) VALUES(컬럼대입 값, ...)

INSERT INTO TEST(NAME) VALUES('뽀로로');

이 때 지정된 컬럼 수와 VALUES()의 컬럼 수, 데이터 타입이 같아야한다. 지정되지 않은 컬럼의 값은 NULL이 대입

INSERT(SUBQUERY)

SUBQUERY를 통해 TABLE에 조건을 걸어 행을 삽입할 수 있다.

-- SUBQUERY 사용
INSERT INTO 테이블명 (SUBQUERY)

-- 테이블 생성
CREATE TABLE TEST AS SELECT ANIMAL_NAME, ANIMAL_AGE, ZOOKEEPER_NAME
FROM ANIMAL JOIN ZOOKEEPER ON ANIMAL_CODE = ZOOKEEPER_ID 
WHERE 0 = 1;    -- FALSE를 통해 값을 가져오지 않는다.

-- SUBQUERY를 통해 행(ROW) 삽입
-- 나이가 10살 이상인 동물이름, 나이, 사육사이름 삽입
INSERT INTO TEST (
SELECT ANIMAL_NAME, ANIMAL_AGE, ZOOKEEPER_NAME
FROM ANIMAL 
    JOIN ZOOKEEPER ON ANIMAL_CODE = ZOOKEEPER_ID
WHERE ANIMAL_AGE >= 10);

위와 똑같이 지정된 컬럼 수와 SUBQUERY 컬럼 수와 타입이 같아야한다.

INSERT ALL

하나의 TABLE로 여러 TABLE의 값을 삽입할 수 있다.

-- INSERT ALL
INSERT ALL 
    INTO 테이블명 VALUES(컬럼대입 값, 컬럼대입 값 . . .)
    INTO 테이블명 VALUES(컬럼대입 값, 컬럼대입 값 . . .)
SELECT 컬럼명, 컬럼명 . . .
FROM 테이블명;

-- 테이블 생성
CREATE TABLE ANIMAL_TYPE_TB
    AS SELECT ANIMAL_NAME, ANIMAL_AGE, ANIMAL_TYPE FROM ANIMAL
    WHERE 0 = 1;

CREATE TABLE ANIMAL_CODE_TB
    AS SELECT ANIMAL_NAME, ANIMAL_AGE, ANIMAL_CODE FROM ANIMAL
    WHERE 0 = 1;

-- ANIMAL_TYPE_TB랑 ANIMAL_CODE_TB에 데이터 한번에 삽입
INSERT ALL
    INTO ANIMAL_TYPE_TB VALUES(ANIMAL_NAME, ANIMAL_AGE, ANIMAL_TYPE)
    INTO ANIMAL_CODE_TB VALUES(ANIMAL_NAME, ANIMAL_AGE, ANIMAL_CODE)
SELECT ANIMAL_NAME, ANIMAL_AGE, ANIMAL_TYPE, ANIMAL_CODE
FROM ANIMAL;

UPDATE

TABLE에 있는 데이터를 수정하는 명령어 WHERE절을 이용해 특정 데이터를 수정할 수 있다.

INSERT INTO TEST VALUES('핑구', 150);

-- UPDATE
UPDATE 테이블명
SET 열1 = 값1, 열2 = 값2, ...
WHERE 조건식;

UPDATE TEST 
SET AGE = 5
WHERE NAME = '핑구'

만약 WHERE을 사용하지 않으면 전체 ROW를 수정한다. 따라서 WHERE은 필수 👍

DELETE

TABLE에 있는 행(ROW)을 삭제하는 명령어 WHERE절을 이용해 특정 ROW를 삭제할 수 있다.

INSERT INTO TEST VALUES('펭구', 200);

-- DELETE
DELETE FROM 테이블명
WHERE 조건식;

DELETE FROM TEST
WHERE NAME = '펭구';

만약 WHERE을 사용하지 않으면 전체 ROW를 삭제한다. 이 때, ROLLBACK을 통해 COMMIT하기전으로 되돌릴 수 있다.

TRUNCATE

TABLE의 전체 행(ROW)을 삭제할 때 사용하는 명령어 DELETE보다 수행 속도가 빠르지만 ROLLBACK을 통해 복구 불가능

TRUNCATE TABLE 테이블명;

끝

SQL(Structured Query Language)은 DB에서 데이터를 검색하고 조작하기 위한 표준 검색 언어로, DB에서 TABLE을 생성하고 수정, 삭제, 검색 등의 작업에 쓰인다.

한마디로 DB에서 사용하는 명령어들을 SQL이라한다.

ORACLE

오라클은 대규모 데이터베이스 처리를 위한 기능과 기술을 제공한다.

DBA(Database Administrator)

DB에 대한 모든 권한을 가진 DB의 관리자 역할을 한다.

DBA가 계정을 생성하면서 저장 공간을 같이 생성해준다. 다른 응용 프로그램에서 사용하는 생성 방법은 사용할 공간을 만들고 해당 공간을 쓸 계정을 부여하는 방식이다. - (lee_bb님 벨로그 참고)

계정을 생성할 때도 DBA를 통해 생성하고 생성한 계정으로 TABLE을 만들 때도 DBA의 권한을 받아야 사용가능

계정생성 & 권한부여

-- 계정생성 명령어
CREATE USER 계정명 IDENTIFIED BY 비밀번호
DEFAULT TABLESPACE ON USERS;

-- 18C 버전부터 계정생성할 때 ##을 붙여줘야된다.
-- _oracle_script 설정을 true로 변경하면 ##을 안붙여도 된다.
-- 프로그램 종료하면 다시 SESSION에 접근해줘야 함
ALTER SESSION SET"_ORACLE_SCRIPT"=TRUE;

-- 계정권한 부여
-- CONNECT : 계정연결 권한
-- RESOURCE : 객체생성,수정,삭제 권한
GRANT CONNECT, RESOURCE 권한명 OR 롤(역할) TO 사용자 계정명;

-- DB 사용자 조회
SELECT * FROM DBA_USERS; 

끝

DATABASE(DB)는 조직에 필요한 연관된 데이터를 모으고 중복되는 데이터를 최소화하여 구조적으로 통합/저장 해놓은 것이다.

예를 몇가지 들면

• 쇼핑몰 : 상품정보, 구매자정보, 판매자정보
• 병원 : 환자정보, 진단정보
• 학교 : 학생정보, 수강정보

DB는 연관된 데이터를 묶어서 정리해놓은 데이터 '창고'

DB 특징

1. 계속적인 변화
2. 실시간접근에 용이
3. 동시 공유
4. 내용에 따른 참조

DB는 데이터를 실시간으로 공유해서 사용할 수 있다는 특징이 있다. 또한 프로그램을 종료해도 다시 데이터를 불러올 수 있다.

DBMS

DB의 단점을 보완하며 DB를 관리할 수 있게 여러 기능을 제공하는 데이터베이스 전용 프로그램(ORACLE, MYSQL, MONGODB...)

😕 그럼 DB랑 DBMS의 차이점이 뭐야?? 😀 DBMS = DB를 관리하는 프로그램 | DB = DBMS에 의해 관리되는 데이터집합

위에서 DB의 특징에 대해 적어놨는데 여기에는 단점이 있다.

1. 동시성 : 같은 파일에 대한 수정, 삭제 (병목현상)
2. 성능 : 여럿이서 쓰다보니 기다려야함
3. 보안 : 네트워크 기반으로 접근하다보니 보안 능력 저하

이를 해결하기 위해 DBMS를 사용한다.

DBMS의 특징

1. 데이터 독립화로 동시성 해결
2. 데이터 중복 최소화, 무결성 보장
3. 데이터 보안 향상(권한부여)
4. 관리 편의성 향상

바로 DB에 접근하는 것이 아닌, DBMS에 접근해서 관리자가 허락할 경우 DB에 접근하는 방식

아래는 내가 이해하기 위해 예제를 만들었다.

병원을 예로 들어

• 환자정보
• 진료정보
• 처방정보

한 환자가 병원에 찾아와 진료를 받고 처방을 받았다.

• 환자정보 : 환자이름, 환자나이, 환자증상
• 진료정보 : 환자나이, 환자증상, 소견서
• 처방정보 : 환자이름, 소견서, 처방약

위의 예시를 보면 같은 데이터가 각 정보에 중복되어 있는걸 볼 수 있는데 이를 해결할 수 있는게 DBMS다.

• 환자정보 : 환자이름, 환자나이, 환자증상
• 진료정보 : 환자정보(나이, 증상), 소견서
• 처방정보 : 진료정보(환자정보, 소견서), 처방약

더 깔끔해져서 보기도 쉽다. ✌️ 또한 JAVA처럼 접근권한이 필요해서 함부로 '환자정보'나 '진료정보'를 확인할 수 없게 할 수 있다.

끝

왜 equals(), toString(), hashCode()를 오버라이딩 하는 걸까??

내가 생성한 클래스들은 Object를 최상위 클래스로 상속받고 있다. 그래서 내 클래스에서도 Object 클래스의 메서드를 사용할 수 있다.

Object 클래스 중 equals() toString() hashCode()을 왜 오버라이딩 해야하는지 궁금증이 생겨 정리해보았다.

.equals()

equals() 메서드는 '객체간의 동등성 비교를 boolean 타입으로 반환' 하는 기능을 한다.

즉, 객체간의 '주소 값'을 비교한다.

public class Food {
    public String food;
    public int spicy;

    public Food() {}

    public Food(String food, int spicy) {
        this.food = food;
        this.spicy = spicy;
    }
}

public class Eat {
    public static void main(String[] arg) {
        Food food = new Food("떡볶이", 3);
        Food food2 = new Food("떡볶이", 5);
        Food food3 = new Food("떡볶이", 3);

        System.out.println(food == food2);
        System.out.println(food == food3);
        System.out.println(food2 == food3);

        System.out.println(food.equals(food2));
        System.out.println(food.equals(food3));
        System.out.println(food2.equals(food3));
        // 전부 false
    }
}

위의 예제에 food 와 food3처럼 사람이 보기엔 같은 데 주소 값이 다르기에 false가 출력된다.

😵‍💫 ==와 .equals()가 헷갈려... 😃 일단 .equals()가 두 종류 있다는 걸 알아야한다.

• String타입.equals()
• Object타입.equals()

먼저 == 연산자는 두 객체의 주소 값을 비교한다. String타입.equals()는 실제 값을 비교한다. Object타입.equals()는 두 객체의 주소 값을 비교한다.

String타입.equals()는 equals()가 오버라이딩 되어있기 때문이다.

.equals() 오버라이딩

위의 예제처럼 .equals()를 통해 내용을 비교하고 싶다면 오버라이딩을 사용하면 해결된다. (음식 이름과 매운 정도가 같으면 같다고 정의한다.)

public class Food {
    public String food;
    public int spicy;

    public Food() {}

    public Food(String food, int spicy) {
        this.food = food;
        this.spicy = spicy;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Food) {
            Food fd = (Food) obj;
            if(this.food == fd.food && this.spicy == fd.spicy) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }
}

public class Eat {
    public static void main(String[] arg) {
        Food food = new Food("떡볶이", 3);
        Food food2 = new Food("떡볶이", 5);
        Food food3 = new Food("떡볶이", 3);

        System.out.println(food.equals(food2));        // false
        System.out.println(food.equals(food3));        // true
        System.out.println(food2.equals(food3));    // false
    }
}

.toString()

toString() 메서드는 '객체가 가지고 있는 값을 문자열로 반환' 하는 기능을 한다.

즉, 참조형 변수를 toString 하면 참조형 변수의 주소 값을 반환한다. (정확히는 클래스명@주소 값 처럼 반환한다.)

public class Food {
    public String food;

    public Food() {}

    public Food(String food) {
        this.food = food;
    }
}

public class Eat {
    public static void main(String[] arg) {

        Food favorite = new Food("떡볶이");

        System.out.println(favorite);                // Food@24d46ca6
        System.out.println(favorite.toString());    // Food@24d46ca6
    }
}

😕 왜 favorite은 favorite.toString()과 같은 값을 출력한걸까??

😀 System.out.print()을 사용할 때 참조형 변수를 넣으면 자동으로 toString()메서드가 작동한다.

✌️ 참고로 String과 File 클래스는 이미 재정의 되어있다.

• String : 값을 반환

• File : 주소 값을 반환

  public class Test {
    public static void main(String[] arg) {
        String food = "매운 떡볶이";
        File foodFile = new File("C\\떡볶이 레시피.txt");
  
        System.out.println(food);        // 떡볶이
        System.out.println(foodFile);    // C\떡볶이레시피.txt
    }
  }

.toString() 오버라이딩

내가 만든 Food 클래스 또한 Object 클래스를 상속받고 있기에 오버라이딩을 사용해 Food만의 toString을 재정의 할 수 있다.

public class Food {
    public String food;

    public Food() {}

    public Food(String food) {
        this.food = food;
    }

    @Override
    public String toString() {
        return "나는 " + this.food + "를(을) 정말 좋아한다.";
    }
}

public class Eat {
    public static void main(String[] arg) {

        Food favorite = new Food("떡볶이");

        System.out.println(favorite);                // 나는 떡볶이를(을) 정말 좋아한다.
        System.out.println(favorite.toString());    // 나는 떡볶이를(을) 정말 좋아한다.
    }
}

.hashCode()

hashCode()가 제일 이해가 안갔다...

hashCode() 메서드는 '객체를 지칭하는 고유한 값을 정수 값으로 반환' 하는 기능을 한다.

즉, 객체의 주소 값이다.

hashCode() 메서드를 이해하기 힘들었던 부분은 equals()를 오버라이딩하면 hashCode() 또한 재정의를 꼭 해야한다는 부분이 어려웠다.

예시를 봐보자

public class Food {
    public String food;
    public int spicy;

    public Food() {}

    public Food(String food, int spicy) {
        this.food = food;
        this.spicy = spicy;
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Food) {
            Food fd = (Food) obj;
            if(this.food == fd.food && this.spicy == fd.spicy) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }
}

public class Eat {
    public static void main(String[] arg) {
        Food food = new Food("떡볶이", 3);
        Food food2 = new Food("떡볶이", 5);
        Food food3 = new Food("떡볶이", 3);

        System.out.println(food.equals(food2));        // false
        System.out.println(food.equals(food3));        // true
        System.out.println(food2.equals(food3));    // false

        System.out.println(food.hashCode());        // 6179012
        System.out.println(food2.hashCode());        // 1159190
        System.out.println(food3.hashCode());        // 9258584
    }
}

food와 food3를 비교하면 true가 나온다. 하지만 .hashCode()를 사용하면 서로 다른 정수 값을 가진다.

🙄 결국 true를 출력했으니 된게 아닐까? 🤐 아니었다. equals()와 hashCode()를 같이 재정의 해야되는 이유는 자바의 라이브러리, 컬렉션 프레임워크가 equals()와 hashCode() 둘 다 사용하기 때문이다.

.hashCode() 오버라이딩

위와 같은 문제는 .equals()만 재정의할 경우다.

아래와 같이 hashCode() 또한 재정의해주면 해결된다.

public class Food {
    public String food;
    public int spicy;

    public Food() {}

    public Food(String food, int spicy, int num) {
        this.food = food;
        this.spicy = spicy;
    }

    @Override
    public int hashCode() {
        return Objects.hash(food, spicy);
    }

    @Override
    public boolean equals(Object obj) {
        if(obj instanceof Food) {
            Food fd = (Food) obj;
            if(this.num == fd.num) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }
}

public class Eat {
    public static void main(String[] arg) {
        Food food = new Food("떡볶이", 3, 1);
        Food food2 = new Food("떡볶이", 5, 2);
        Food food3 = new Food("떡볶이", 3, 1);

        System.out.println(food.equals(food2));        // false
        System.out.println(food.equals(food3));        // true
        System.out.println(food2.equals(food3));    // false

        System.out.println(food.hashCode());        // 1433263365
        System.out.println(food2.hashCode());        // 1433263367
        System.out.println(food3.hashCode());        // 1433263365
    }
}

끝!

JAVA 객체에 대한 문제를 보면서 아직 내 것으로 만들지 못했다고 느꼈다... 똑같은 문제, 똑같은 로직인데도 코드를 짜다가 멈추고를 반복했다.

- 내가 어느 부분을 어려워 했는지 - 내가 어느 부분을 대충 넘어갔는지 위의 두 가지를 계속 생각하며 혼자 찾아보거나, 코드를 짜거나 강사님께 질문했다. 복습하면서 나중에 잊더라도 찾아보자

Overloading과 Overriding

개념을 배울 때 이해가 안되는 건 아니였지만, 막상 코드를 짜다보니 두 개념이 헷갈렸다.

Overloading

한 클래스 내에 동일한 이름의 메소드를 여러 개 작성하는 것이다. 아래의 예시 코드를 보면 나는 delete의 이름을 가진 메소드를 2개 생성했다.

    // 회원정보 하나 삭제
    public boolean delete(String id) {    
        for(int i=0; i<m.length; i++) {
            if(m[i] != null && m[i].getId().equals(id)) {
                m[i] = null;
                return true;
            }
        }
        return false;
    }

    // 전체회원정보 삭제
    public void delete() {
        for(int i=0; i<m.length; i++) {
            m[i] = null;
        }
    }

하지만 매개변수의 개수와 타입이 다르다면 같은 이름의 메소드를 사용할 수 있다. (단, return 값만 다르다면 오버로드할 수 없다.)

Overriding

상속관계인 클래스에서 부모클래스에 선언된 메소드를 자식클래스가 재정의하는 것 (부모클래스에 선언된걸 자식클래스에서 덮어쓰기)

// 부모 클래스
public class OverrideParent {
    public void print() {
        System.out.println("!이건 부모클래스 함수!");
    }
 }

// 자식 클래스
public class OverrideChild extends OverrideParent {
    @Override
    public void print() {
        System.out.println("!이건 자식클래스 함수!");
    }
}

// 실행
OverrideParent op = new OverrideParent();
op.printMsg();            // !이건 부모클래스 함수!

OverrideChild oc = new OverrideChild();
oc.printMsg();            // !이건 자식클래스 함수!

(단, 메소드, 매개변수 개수, 매개변수 타입, 리턴 타입이 동일해야하고, private와 final 메소드는 오버라이딩 불가능)

Static

• static을 이용하면 정적필드와 정적메소드를 만들 수 있다.

• static은 클래스로 인식하기에 클래스의 로딩이 끝나는 즉시 사용할 수 있다. 또 static은 힙 영역이 아닌 static 영역에 할당된다.

• static 영역의 장점으로 여러 객체가 공유해서 접근할 수 있는 장점이 있지만 static 영역은 GC가 관여하지 못하기에 프로그램이 종료될 때까지 메모리가 할당된 채로 존재하기에 너무 static을 많이 쓰면 시스템에 악영향을 끼칠 수 있다.

• static을 선언한 클래스 맴버는 new로 인해 인스턴스를 생성하지 않아도 접근할 수 있다.

public class Test() {
    public void testPrint() {
        System.out.println("생성자를 만들어야함!");
    }

    public static void staticTestPrint() {
        System.out.println("생성자 안만들어도 돼!");
    }
}

public class StaticTest {
    public static void main(String[] args) {
        // static을 선언안한 경우 생성해서 사용
        Test test = new Test();
        test.testPrint();

        // static을 선언한 경우
        Test.staticTestPrint();
    }
}

StackOverflow

스택 영역의 메모리 크기보다 더 많이 사용할 경우 발생하는 에러로, 보통 스택 영역은 원시 타입, 또는 객체의 주소 값을 저장하는 데 GC에 의해 관리된다.

학원과제를 풀던 중 아래와 같은 코드를 작성했을 때, 왜 이런 에러가 뜨는지 몰랐다.

// 학생 화면을 담당하는 클래스
public class MainView {
    Scanner sc = new Scanner(System.in);
    StudentController controller = new StudentController();
    ...
}

// 학생 관리 프로그램의 기능을 담당하는 클래스
public class StudentController {
    MainView mv = new MainView();
    ...
}

위의 MainView와 StudentController를 보면, new 생성자를 통해 서로를 계속 실행시켜 무한루프에 빠진다. 처음에 이해가 안가서 그림을 그리고 보니 이해가 갔다. (아래 그림처럼 계속 서로를 new 생성자로 호출)

return

return도 학원과제를 풀던 중 이해를 잘 하지못하고 사용하다 이해했다.

public void inputMenu() {
        while(true) {
        System.out.println("===== 도형 프로그램 =====");
        System.out.println("3. 삼각형");
        System.out.println("4. 사각형");
        System.out.println("9. 프로그램 종료");
        System.out.print("메뉴 번호 : ");
        int choiceMenu = sc.nextInt();

        switch(choiceMenu) {
            case 3 : triangleMenu(); break;
            case 4 : squareMenu(); break;
            case 9 : System.out.println("프로그램 종료"); return;
            default : System.out.println("잘못된 번호입니다. 다시 입력해주세요."); break;
            }
        }
    }

    public void triangleMenu() {
        while(true) {
        System.out.println("===== 삼각형 =====");
        System.out.println("1. 삼각형 면적");
        System.out.println("2. 삼각형 색칠");
        System.out.println("3. 삼각형 정보");
        System.out.println("9. 메인으로");
        System.out.print("메뉴 번호 : ");
        int choiceMenu = sc.nextInt();

        switch(choiceMenu) {
            case 1 : inputSize(3, 1); break;
            case 2 : inputSize(3, 2); break;
            case 3 : printlnformation(3); break;
            // 여기가 문제!!
            case 9 : System.out.println("메인으로 돌아갑니다."); inputMenu(); return;
            default : System.out.println("잘못된 번호입니다. 다시 입력해주세요.");
            }
        }
    }

위처럼 코드를 짜고 실행해보니 9번을 입력하면 inputMenu()로 돌아가길 바랬다.

하지만 계속 inputMenu()가 두 번 실행되어 종료를 두 번해야지 종료가 되었는데... 알고보니 위의 주석처리처럼 문제가 있었다.

return을 사용하면 그 즉시 해당 메소드를 중지하고 호출한 메소드로 돌아가는 것, 이걸 나는 해당 메소드를 중지하는 것으로 끝인줄 알고 있었다... (그림참고)

덕분에 잘못된 개념도 고치고 배우게 된 점도 있었다.

끝!

접근제한자는 이름 그대로 어디까지 접근을 허용하는지를 나타낸다. (한 개의 프로젝트 내에서 패키지단위로 범위 표현)

- 클래스 접근제한자

- 필드 접근제한자

- 메소드 접근제한자

객체는 현실에 존재하는 사물이나 개념으로, 객체지향 언어에서의 객체는 클래스에 정의된 내용대로 메모리에할당된 결과물이다.

얼굴을 예로 들면, '얼굴'에는 '눈', '코', '입'등 여러 기관들이 있다. 여기서 '눈', '코', '입'은 얼굴을 표현하기 위한 객체다.

프로그래밍에서 객체는 무언가를 코딩으로 표현하는 것

- 객체의 할당

객체는 할당할 때 new 연산자와 생성자를 사용해 클래스 자료형을 갖는다. 이 때, new연산자를 사용하면 힙 영역에 새로운 저장공간을 생성하게 된다.

- 클래스란?

클래스는 객체를 생성하기 위한 설계도라고 생각하면 된다.

예를 들어 의류 공장이 있고 의류 공장에서 '패딩', '상의', '하의' 등을 생산해낸다고 가정하자. 여기서 의류 공장은 클래스이고, 의류 공장에서 생성한 옷들은 객체다.

🙄 그럼 클래스를 왜 쓰는걸까? 😀 만약 학생 정보를 입력한다고 가정하자 그리고 학생 수가 1000명이라면 변수 하나 하나에 학생 정보를 입력해야된다.

배열을 사용할 수 있겠지만 기능까지 추가한다고 한다면 복잡해질거다. 하지만 학생 클래스를 만들고 학생 정보객체를 간단하게 뽑아낼 수 있다면 조금 덜 고생할 수 있을거다. 그래서 클래스를 사용한다.

// 학생 입력
String student1 = "이름은 둘리, 나이는 100살, 성별 남";
String student2 = "이름은 또치, 나이는 6살, 성별 여";
String student3 = "이름은 도우너, 나이는 200살, 성별 남";
String student4 = "이름은 마이콜, 나이는 20살, 성별 남";

System.out.print(student1);
System.out.print(student2);
System.out.print(student3);
System.out.print(student4);

// 학생 클래스
Student student = new Student();
student.print();

✌️ 추상화 : 프로그램에서 필요한 정보만 찾아 공통점을 추출하는 것 위의 그림처럼 추상화를 할 때 필요한 곳에 필요한 값만 받으면 된다. 이 때, 받아야할 값이 저장된 변수이름은 알아보기 쉽게 작성하는게 좋다.

- 클래스 선언

// 클래스 선언
[접근제한자][예약어] class 클래스명 { }
public class ClassName{
    // 속성값 설정(맴버변수 || 필드)
    // [접근제한자] [예약어] 자료형 변수명;
    private String userName;
    private int user_No;


    // 생성자
    // [접근제한자] 생성자명(){}
    public ClassName(){}


    // 기능정의 설정(메소드)
    // [접근제한자] 반환형 메소드명(매개변수) { 기능 정의 }
    public void printName(String name) {
        System.out.print(name);
    }
}

배열은 같은 자료형을 묶어 저장하는 참조자료형이다. 배열은 생성할 때 주의할 점으로 두가지가 있다. ① 크기를 지정해야한다. ② 지정한 크기를 절대 변경할 수 없다는 특징을 가진다.

- 배열 선언

배열을 선언하는 방법은 2가지가 있다. int[] array;처럼 자료형 뒤에 [ ]로 표시하거나 char array[];처럼 변수명 뒤에 [ ]로 표시할 수 있다.

😕 array자료형으로 만들면 편했을텐데 왜 안그럴까?? 😀 배열은 동일한 자료형만 묶을 수 있는데, array로 적어두면 어떤 자료형끼리 묶은건지 알 수 없다.

- 배열 길이 선언

배열에 값을 할당하는 방법은 변수랑 동일하다. 단, new 키워드를 함께 사용해야하며 배열의 길이를 지정하지 않으면 오류가 발생한다.

// 자료형 변수명[] = new 자료형[배열의 길이];
String studentArray[];
student = new String[3];

int array[] = new int[5];                // int형 배열로 길이는 5다.
char array2[] = new char[2];            // char형 배열로 길이는 2다.
String array3[] = new String[4];        // String 배열로 길이는 4다.

// 배열의 길이를 지정하지 않았을 경우
int numArr[] = new int[];            // 오류 발생

- 배열 할당

배열에 값을 할당하는 방법을 간단하게 알아보자

// 배열 객체를 생성하고 각 인덱스 위치마다 값 대입
int[] a = new int[3];
a[0] = 3;
a[1] = 5;
a[2] = 1;

// 배열 객체를 생성하고 함께 값 대입하기
int[] b = new int[] {1, 2, 3, 4};
int[] c = {1, 2, 3, 4, 5};

// 배열 객체를 생성하고 for문으로 인덱스 위치 접근해서 값 대입
int[] d = new int[5];
for(int i=0; i<d.length; i++){
    d[i] = i++;
}

- 배열 저장구조

모든 참조 자료형의 실제 데이터(객체)는 Heap 영역에 저장된다. (new 키워드) 따라서 배열 자료형 변수의 저장공간에는 객체의 주소값을 가지고 객체는 실제 Heap영역에 저장된다. (배열 공간의 주소를 이용해 인덱스를 참조) 위의 그림에서 array 변수는 참조변수라고 불린다. 😵‍💫 변수에 빈 값을 할당하면 오류가 나는데, 배열은 왜 오류가 안날까? 😀 배열의 길이를 지정하고 값을 넣지않아도 오류가 나지않는다. 그 이유는 스택 영역은 값을 초기화하지 않으면 빈 공간으로 인식해 변수를 출력하면 오류가 발생한다.

하지만 힙 영역은 어떤 상황에서도 빈 공간이 존재하지 않는다. 그래서 값을 주지 않아도 컴파일러가 값을 강제로 초기화하기 때문이다. (정수형 = 0, 실수형 = 0.0, 문자열 = null, 문자 = ' ', 불값 = false)

- 배열 복사 (얕은 복사)

기본 자료형과 참조 자료형에서 복사할 때를 알아보자 기본 자료형은 '='을 사용해 값을 복사할 때 변수에 포함된 스택 영역의 실제 데이터 값을 복사한다. 그래서 기본 자료형 변수를 복사하면 실제 데이터 값이 1개 더 복사되는 것이다.

int a = 3;
int b = a;            // a의 값은 3    b의 값은 3
b = 7;                // a의 값은 3    b의 값은 7

반면 참조 자료형은 스택 영역에 실제 데이터 값이 아닌 힙 영역에 저장된 객체의 주소 값을 저장한다. 따라서 참조 자료형 변수를 복사하면 실제 데이터 값이 복사되는게 아닌 실제 데이터의 주소 값이 복사된다. 그래서 참조 자료형 변수 데이터를 수정하면 다른 참조 변수가 가르키는 데이터도 함께 변한다. (원본 값을 공유)

int[] a = {3, 4, 5};        // a 주소 값 : 0x111
int[] b = a;                // b 주소 값 : 0x111
b[0] = 7;                    // b 주소 값 : 0x111에 0번째 인덱스 값 변경

System.out.print(a[0]);        // 7 출력
System.out.print(b[0]);        // 7 출력

- 배열 복사 (깊은 복사)

위의 문제점을 해결하는 방법으로 새로운 배열을 생성해서 기존 데이터를 복사하면 된다.

새로운 배열에 기존 배열 값을 넣는 방법을 알아보자

// for문을 이용
int arr1[] = {100, 200, 300};
int arr2[] = new int [arr1.length];

for(int i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[i];
    System.out.print(arr1[i] + " ")        // 100 200 300
    System.out.print(arr2[i] + " ")        // 100 200 300
}



// Arrays.copyof 이용
// 자료형 변수명[] = Arrays.copyOf(복사할 참조변수, 복사할 길이)
String name1[] = {"선인장", "무궁화", "제비꽃"};

String name2[] = Arrays.copyOf(name1, name1.length);

for(int i = 0; i < name1.length; i++) {
    System.out.print(name1[i] + " ")        // 선인장 무궁화 제비꽃
    System.out.print(name2[i] + " ")        // 선인장 무궁화 제비꽃
}

-끝-