내용 복습

JAVA

클래스

• 메서드 오버로딩(overloading): 입력 매개변수의 개수나 자료형이 다른 여러 개의 동일한 이름을 지닌 메서드를 같은 공간에 정의하는 것
• 메서드 오버라이딩(overriding): 부모 클래스에게 상속받은 메서드와 동일한 이름의 메서드를 재정의하는 것으로, 부모의 메서드를 자신이 만든 메서드로 덮어쓰는 개념. 다음 두 조건을 만족해야 한다.
  • 부모 클래스의 메서드와 시그너처(메서드명, 입력 매개변수의 타입과 개수) 및 리턴 타입이 동일해야 한다.
  • 부모 클래스의 메서드보다 접근 지정자의 범위가 같거나 넓어야 한다.

접근 지정자

	멤버의 접근 지정자 사용 범위
public	모든 클래스
protected	동일 패키지 모든 클래스 + 다른 패키지의 해당 클래스를 상속받은 자식 클래스
default	동일 패키지의 모든 클래스
private	동일 클래스 안에서만

제어자

	제어자
final	상속 불가. 호출은 가능
static	공유 메모리. 한 번 지정하고, 바꾸지 않음. 오버라이딩 불가. 즉 업캐스팅할 때 후에 정의된 자식의 메소드가 아니라, 부모의 메소드가 호출된다.
final static	상수에서 사용

• 상속: 부모 클래스의 멤버를 내려받아 자식 클래스 내부에 포함시키는 자바의 문법 요소

💡 자바의 클래스는 다중 상속(여러 부모)이 불가능하다. 모호성이 발생하기 때문이다.

객체 배열

public class Chunjae {
    private int num;
    private String data;

    public Chunjae() {
    }

    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }

    public void setData(String data) {
        this.data = data;
    }
    public String getData() {
        return this.data;
    }
}

...

Chunjae[] chunjaes = new Chunjae[10];
for(int i=0; i<chunjaes.length; i++){
    chunjaes[i] = new Chunjae();
    chunjaes[i].setNum(i+1);
    chunjaes[i].setData("천재"+(i+1));
    System.out.println(chunjaes[i].getData()+": "+chunjaes[i].getNum());

}

Abstract

• 추상화: 실제 구현 내용을 적지 않고, 상속받는 클래스에서 구현 내용을 기술한다. 이는 물려받는 입장에서 쓰고 싶은 것이 다를 경우 미리 사용처를 정해버리면 그대로 쓰던가, 오버라이딩을 해야 함. 추상 메서드는 자식 클래스에서 반드시 구현되어야 하므로, 필수 기능을 집약할 수 있다.

추상 클래스

• abstract method: 메서드의 본체가 완성되지 않은 미완성 메서드로 중괄호 자체가 없고, 리턴타입과 매개변수만 있다.
• abstract class: 추상 메서드를 1개 이상 포함하고 있는 클래스는 반드시 추상 클래스이다. 추상 클래스는 선언은 할 수 있더라도, 내부의 미완성 메서드로 인해 객체를 직접 생성할 수 없다.
  • Implements: 추상화된 메소드를 상속받아 자식 클래스에서 구현하는 것. 추상 클래스를 상속받은 자식 클래스는 반드시 그 추상 메서드를 모두 구현(오버라이딩)하여야 한다.
  • 일부 추상 메서드를 사용할 때 추상 클래스를 사용한다.
• 추상 클래스는 상속을 통해 자식 클래스로 생성하거나, 익명 이너 클래스를 사용해 추상 메서드를 오버라이딩함으로써 생성된다.
  • 익명 이너 클래스: 컴파일러가 내부적으로 추상 클래스를 상속해 메서드 오버라이딩을 수행한 클래스를 생성하고, 그 클래스로 객체를 생성하는 방법.
  • 상속 생성: 부모 클래스는 자식 클래스의 생성자를 활용해 객체를 생성할 수 있고, 다른 자식 클래스의 생성자로 형 변환도 가능하다.

💡 클래스에서 부모 클래스는 자식 클래스의 생성자로 객체를 생성할 수 있지만(업캐스팅), 자식 클래스는 부모 생성자로 객체를 생성할 수 없다.

💡 추상화된 클래스를 상속받는 경우 반드시 추상 메서드를 모두 구현해야 한다.

abstract class AbstractParent{
    abstract void hello();
}

class Child1 extends AbstractParent{
    @Override
    void hello() {
        System.out.println("Hello Child1");
    }
}

class Child2 extends AbstractParent{
    @Override
    void hello() {
        System.out.println("Hello Child2");
    }
}

public class Textbook {
    public static void main(String[] args) {
        AbstractParent ap = new Child1();
        ap.hello(); // Hello. Child1
        ap = new Child2();
        ap.hello(); // Hello. Child2
        AbstractParent ap2 = new AbstractParent() {
            @Override
            void hello() {
                System.out.println("Hello AbstractParent");
            }
        };
        ap2.hello(); // Hello AbstractParent
    }
}

💡 다형성: 형 변환할 때마다 그 형태가 다양하게 변할 수 있다. Ex) 생성자의 오버로딩, 메소드의 오버로딩, 상속에 의한 오버라이딩, 부모 클래스의 자식 형변환 등

인터페이스

• 인터페이스(interface): 내부의 모든 필드가 public static final로 정의되고, static과 default외의 모든 메서드는 public abstract로 정의된 객체지향 프로그래밍 요소이다.
  • interface 키워드를 사용해 선언한다.
  • 필드의 public static final과 메서드의 public abstract는 생략 가능하다.
  • 인터페이스는 추상 메서드만 포함하므로, 클래스를 상속받을 수 없다.
• implements
  • 클래스가 인터페이스를 상속받을 때 사용하는 키워드
  • 다중 상속이 가능하다는 특징

//클래스명 implements 인터페이스 {}
// 클래스명 extend 클래스명 implements 인터페이스1, 인터페이스2, ..., 인터페이스n {}

• extends: 같은 계층에서 상속받을 때, 즉 클래스에서 클래스, 인터페이스에서 인터페이스를 상속받을 때 사용한다.

이너 클래스

• 이너 클래스란 클래스 내부에 포함되는 인스턴스 멤버 클래스, 정적 멤버 클래스, 지역 클래스로 나뉜다.
  • 인스턴스 멤버 클래스와 정적 멤버 클래스는 필드와 메서드처럼 클래스의 멤버이다.
  • 지역 클래스는 해당 메서드 내부에서만 한정적으로 사용되는 클래스이다.

class Outer{
    public Outer() {
    }

    public void outerMethod(){
        System.out.println("Outer method");
    }
    class Inner{
        public Inner() {
        }
        public void innerMethod(){
            System.out.println("Inner method");
        }
    }
}

public class TextBook {
    public static void main(String[] args) {
        Outer o1 = new Outer();
        o1.outerMethod(); // Outer method
        Outer.Inner i1 = o1.new Inner();
        i1.innerMethod(); // Inner method
    }
}

이너 클래스의 아우터 클래스 사용

• 이너 클래스에서 아우터 클래스의 멤버나 메소드는 기본적으로 그냥 사용 가능하다.
• 하지만 이너 클래스에서 아우터 클래스의 멤버나 메소드를 오버라이딩 하는 경우, 아우터 클래스의 멤버를 호출하기 위해서는 this 키워드를 활용해야 한다.

class Outer{
    public Outer() {
    }
    public int a = 1; }
    class Inner{
        public Inner() {
        }
        public int a = 2;
        public void innerMethod2(){
            System.out.println(a);
            System.out.println(Outer.this.a);
        }
    }
}

public class TextBook {
    public static void main(String[] args) {
        Outer o1 = new Outer();
        Outer.Inner i1 = o1.new Inner();
        i1.innerMethod2(); // 2 다음에 1 출력됨
    }
}

Exception 예외 처리

예외 정의

• 예외(Exception): 연산 오류, 숫자 포맷 오류 등과 같이 상황에 따라 개발자가 해결할 수 있는 오류로, 오류가 발생했을 때 차선책을 선택할 수 있다. 실행 중 오류가 발생하여 출력되지 않는다.
  • 주요 예외: Null pointer, Arithmetic, ArrayIndexBounds, ClassCast, NumberFormat, ClassNotFound
  • 모든 예외는 java.lang.Exception의 서브 클래스로 구성된다
  • 외부 자원(파일, 데이터베이스, 주변 장치 등)을 연동하거나 활용하기 위해서는 반드시 예외 처리가 동반되어야 한다.
• 에러(Error): 에러는 자바 가상 머신 자체에서 발생하는 오류로 ‘개발자가 해결할 수 없는 오류’를 말한다. 실행 자체가 되지 않는다.
  • 문법 상 오류(Syntax Error)

예외 종류

• ClassNotFoundException: Class.forName(”패키지.클래스”)를 호출했을 때 해당 클래스가 존재하지 않을 때 발생하는 예외
• IO Exception: 콘솔이나 파일에 데이터를 쓰거나 write(), 읽을 때 read() 발생하는 예외
• ArithmeticException: 연산이 불가능할 때 발생하는 실행 예외
  • 분모가 0일 때가 대표적인 예시
• ClassCastException: 상속 관계에 있는 클래스 간에 다운캐스팅이 불가능한 상황에서 다운캐스팅을 시도할 때 발생하는 예외
• IndexOutOfBoundsException: 배열이나 문자열의 인덱스 범위를 벗어날 때 발생하는 에러
  • ArrayIndexOutOfBoundsException: 배열의 인덱스 범위를 벗어날 때 발생하는 예외
  • StringIndexOutOfBoundsException: 문자열의 인덱스 범위를 벗어날 때 발생하는 예
• NumberFormatException: Wrapper.parseInt(변수)를 호출했을 때 변수가 wrapper와 일치하지 않 경우 발생한다.
• InputMismatchException: Scanner로 받은 입력 타입이 지정한 변수의 타입과 맞지 않을 때 발생하는 예
• NullPointerException

예외 처리

try{
    // 예외 발생할 가능성이 있는 코드
} catch(예외명 참조변수){
    // 예외 발생 시 처리
} finally {
    //예외 발생 여부에 상관없이 무조건 실행
}

try{
    System.out.println(num1);
    System.out.println(num2);
    System.out.println(num1/num2);

}  catch (Exception e){
    System.out.println(e);
    System.out.println(e.getMessage());
} finally{
    System.out.println("실행 종료");
}

• 예외 처리를 통해 문제 있는 부분만 따로 처리하고, 예외 발생 전의 정상적인 코드를 작동할 수 있다. 예외 처리를 하지 않는다면 모든 코드가 실행이 되지 않는다.
• catch의 참조변수에는 예외의 풀 네임이 들어가고, e.getMessage() 메서드를 통해 예외의 상세 내용을 알 수 있다.

다중 예외 처리

try{
    // 예외 발생할 가능성이 있는 코드
} catch(예외명1 참조변수1){
    // 예외 발생 시 처리
} catch(예외명2 참조변수2){
    // 예외 발생 시 처리
} catch(Exception e){
    // 기타 모든 예외 발생 시 처리
    // 반드시 맨 아래에 오야 한다.
} finally {
    //예외 발생 여부에 상관없이 무조건 실행
}

• catch가 switch문과 같이 작동한다. 해당하는 예외를 처리 후 finally가 실행된다.
• 통합 예외문인 Exception이 맨 아래 없다면, unreachable code 오류가 발생한다.

Exception

• ClassCastException: 상속 관계에 있는 클래스 간에 다운캐스팅이 불가능한 상황에서 다운캐스팅을 시도할 때 발생하는 예외

package sec01;

public class Example5 {
    static class Animal{}
    static class Tiger extends Animal{}
    static class Lion extends Animal{}
    public static void main(String[] args) {
        Animal ani;
        ani = new Tiger();
        ani = new Lion();

        Tiger tiger = new Tiger();
        Lion lion = new Lion();

        changeObject1(tiger);
        changeObject2(lion);
    }

    public static void changeObject1(Animal a){
        try{
            Lion l = (Lion) a;
        } catch (ClassCastException e){
            System.out.println("형 변환 불가");
            System.out.println(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
        }
    }
    public static void changeObject2(Animal a){
        try{
            Tiger t = (Tiger) a;
        } catch (ClassCastException e){
            System.out.println("형 변환 불가");
            System.out.println(e.getMessage());
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

• ClassNotFoundException: Class.forName(”패키지.클래스”)를 호출했을 때 해당 클래스가 존재하지 않을 때 발생하는 예외

package sec01;

public class Example6 {
    public static void main(String[] args) {
        try{
            Class cls = Class.forName("maria.jdbc.driver");
        } catch (ClassNotFoundException e){
            System.out.println("존재하지 않음");
            e.printStackTrace();
        } catch (Exception e){
            System.out.println("원인 불명");
            e.printStackTrace();
        } finally{
            System.out.println("닫기");
        }
    }
}
/* 
존재하지 않음
닫기
java.lang.ClassNotFoundException: maria.jdbc.driver
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)
	at java.base/java.lang.Class.forName0(Native Method)
	at java.base/java.lang.Class.forName(Class.java:375)
	at sec01.Example6.main(Example6.java:6)
*/

• FileNotFoundException: 콘솔이나 파일에 데이터를 쓰거나 write(), 읽을 때 read() 발생하는 예외
  • 드라이버에서 DB 연동할 때 중첩 try문 많이 사용함

package sec01;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class Example7 {
    public static void main(String[] args) {
        // 파일 처리 작업은 반드시 try-catch 문 사용. 파일이 존재하지 않을 수 있다.
        try{
            FileInputStream fis = new FileInputStream("infile.txt");
            try{
                FileOutputStream fos = new FileOutputStream("outfile.txt");
            } catch (FileNotFoundException e) {
                System.out.println(e.getMessage());
            }
        } catch (FileNotFoundException e){
                System.out.println(e.getMessage());
        }
    }
}

예외전가, 사용자 정의 예외

package sec02;

public class UserExceptionEx1 {
    public static void methodException() throws RunException{
        throw new RunException("사용자 정의 실행 예외");
    }
    public static void main(String[] args) {
        try{
            methodException();
        } catch(RunException e){
            e.getMessage(); // 웹에서만 메시지를 볼 수 있음
            e.printStackTrace(); // IDE 콘솔창에서 확인 가능
        }
    }
}

//sec02.RunException: 사용자 정의 실행 예외: 사용자 정의 예외
//at sec02.UserExceptionEx1.methodException(UserExceptionEx1.java:5)
//at sec02.UserExceptionEx1.main(UserExceptionEx1.java:9)

• 예외 전가: 예외가 발생했을 때 자신을 호출한 지점으로 예외를 전가하여, 예외 처리의 의무를 호출한 메서드가 갖게 하는 것을 말한다. 즉 예외가 발생한 함수 내부에서 예외를 처리하는 것이 아니라, 실행문만 쓰고 호출한 부분에 try-catch문의 예외 처리를 하는 것이다.

예외_발생_함수 thorws Exception {};

실행함수(){
    try{
        예외_발생_함수
    } catch(){
    }
}

• 모든 예외 처리는 try-catch-finally 또는 throws Exception으로 처리 가능하다.

쓰레드 Thread

• 쓰레드(Thread): 하나의 실행 작업(Task) 또는 하나의 실행 프로그램(Process)를 자바에서 일컫는 용어. 중앙 처리 장치(CPU)를 사용하는 최소 단위이다.
  • 동시성: CPU의 코어 수가 작업 수 미만일 때, 두 작업이 동시에 실행되는 것처럼 보이도록 하는 방식
  • 병렬성: CPU의 코어 수가 작업 수 이상일 때, 각각의 작업을 각각의 코어에 할당해 동시에 실행하여, 동시에 작업 수행하는 것을 말한다.
• 멀티 쓰레드: 동시에 2개 이상의 쓰레드가 동작하는 것을 말한다. 여러 개의 쓰레드를 동시에 진행 또는 실행할 수 있도록 한 실행 환경을 말한다.

싱글 쓰레드

package sec1;

public class ThreadExample {
    public static void main(String[] args) {
        int[] arr = new int[6];
        int temp = 95;
        for(int i=0; i<arr.length; i++){
            arr[i] = temp-5*i;
            System.out.println(arr[i]);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }
}

멀티 쓰레드

package sec1;

class SMThread extends Thread{
    public synchronized void start(){
        super.start();
        this.method1();
    }

    public SMThread() {
    }

    public void method1(){
        for(int i=1; i<7; i++){
            System.out.println(i);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
    public void run(){
        int[] arr = new int[6];
        int temp = 95;
        for(int i=0; i<arr.length; i++){
            arr[i] = temp-5*i;
            System.out.println(arr[i]);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class MultiThreadExample {
    public static void main(String[] args) {
        Thread th1 = new SMThread();
        th1.start();

    }
}

• synchronized(병행 수행 블록): 동기화는 하나의 작업이 완전히 완료된 후 다른 작업을 수행하는 것을 말한다.
• asynchronous: 비동기는 하나의 작업 명령 이후 완료 여부와 상관없이 바로 다른 작업 명령을 수행하는 것을 말한다.

Thread

Runnable

• 실행 가능한 객체를 만들기 위한 인터페이스로 사용자가 상속받아 새로운 클래스를 생성하여 활용한다.

쓰레드 정보 출력

• Thread 클래스는 static이므로 new 키워드로 생성하지 않는다.

Thread curT = Thread.currentThread(); // 현재 cpu에서 실행되는 Thread의 정
System.out.println(curT.getState()); // RUNNABLE

Generic 제네릭

• 제네릭은 클래스에 자료형을 클래스 내부가 아니라 외부에서 정의하는 것이다. 즉, 클래스를 정의하는 시점이 아니라 객체를 생성하는 시점에 타입을 지정하여, 다양한 타입의 객체를 저장 및 관리할 수 있다.
• Type이라면 T, Element라면 E, Key라면 K. Number라면 N, Value라면 V, Result라면 R, Query라면 Q, Generic이라면 G 등과 같이 표기한다.

class Generic<T>{}
class Generic<K, V>{}

• 일반 클래스로 만들어진 필드의 값은 오로지 한 가지 타입 밖에 지원되지 않는다.

public class Gen1 {
    private String t;
    public String getT() {
        return t;
    }
    public void setT(String t) {
        this.t = t;
    }
}

public class Gen2<T> {
    private T t;
    public T getT() {
        return t;
    }
    public void setT(T t) {
        this.t = t;
    }
}

...

Gen1 g1 = new Gen1();
g1.setT("38");
// g1.setT(38); 오류 발생
System.out.println(g1.getT());

Gen2 g2 = new Gen2();
g2.setT(30);
System.out.println(g2.getT());
g2.setT("천사");
System.out.println(g2.getT());

• 반환 타입을 범용화 할 경우 interface 사용
• Generic의 Type은 기본형(Primitive)가 아닌 참조형(Wrapper, 클래스)로 선언하여야 한다.

interface InterGen3<T>{
    T method1(); // 반환 타입을 범용화 할 경우 interface 사용
}
public class Gen3 implements InterGen3<Integer>{
    @Override
    public Integer method1() {
        return 30;
    }
}

Restrictions on Generic Class

• 제한 클래스의 서브(이하) 클래스로만 생성을 제한할 수 있다.

public class ChildGen<T extends RestrictCls> {
}

// ChildGen<ParentCls> c1 = new ChildGen<ParentCls>(); 오류
ChildGen<RestrictCls> c2 = new ChildGen<>(); // 1.7이상은 뒤에 <제네릭> 생성자 생략 가능
ChildGen<Season> c3 = new ChildGen<>();

컬렉션

• 컬렉션: 동일한 타입을 묶어 관리하는 자료구조를 말한다.
• 컬렉션 프레임워크: 리스트, 스택, 큐, 트리 등의 자료구조에 정렬, 탐색 등의 알고리즘을 구조화해 놓은 것이다.
  • List, Set, Map<K, V>, Stack, Queue가 있다.

ArrayList

• 분리하려면 분리자 컬렉션
• DB의 테이블이 곧 ArrayList이다.

List 인터페이스

• List: 데이터의 순서가 있으며, 순서가 유지된다. ArrayList, Vector, LinkedList 등이 있다. Interface인 List로 선언하고, ArrayList로 생성한다.
  • ArrayList: 모든 데이터를 위치 정보(인덱스)와 값으로 저장
  • Vector: 동기화 메서드로 구현되어 멀티 쓰레드에 적합함
  • LinkedList: 저장 용량을 지정할 수 없고, 앞뒤 객체 정보를 저장함
• “일반적인 속도는 링크리스트 이전 포인터와 다음 포인터가 있어 훨씬 빠르지만, 중간 삽입 삭제에서는 리스트가 더 빠르다.” 라고 강사님은 말씀하셨지만 일반적으로 삽입, 삭제는 LinkedList가, 조회는 ArrayList가 빠르다.

	ArrayList	LinkedList
추가, 삭제	느림	빠름
검색	빠름	느림

• Arrays.asList(배열): 배열을 List 형으로 바꾸는 것으로, 저장 공간의 크기는 기존 배열의 크기와 같다. 따라서 앞에 컬렉션으로 형변환하여 사용해야 add와 remove가 가능하다.

리턴	메서드	기능
boolean	add(E element)	매개변수로 입력된 원소를 리스트 마지막에 추가
void	add(int index, E element)	index 위치에 입력된 원소 추가
boolean	addAll(Collection c)	매개변수로 입력된 컬렉션 전체를 마지막에 추가
boolean	addAll(int index, Collection c)	index 위치에 입력된 컬렉션 전체 추가
E	set(int index, E element)	index 위치의 원솟값을 입력된 원소로 변경
E	remove(int index)	index 위치의 원솟값 삭제
boolean	remove(Object o)	원소 중 매개변수 입력과 동일한 객체 삭제
void	clear()	전체 원소 삭제
E	get(int index)	index 위치의 원솟값을 꺼내 리턴
int	size()	리스트 객체 내 포함된 원소 개수
boolean	isEmpty()	리스트의 원소가 하나도 없는지 여부 리턴
Object[]	toArray()	리스트를 Object배열로 변환
boolean	contains(Object o)	매개변수로 입력된 원소가 있는지 여부 리턴

List<String> ls1 = new ArrayList<>();

List<Integer> aList1 = Arrays.asList(1, 2, 3, 4);
aList1.set(1, 7);
System.out.println(aList1.toString()); // [1, 7, 3, 4]

List<Integer> aList2 = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
aList2.add(5);
System.out.println(aList2.toString()); // [1, 2, 3, 4, 5]

Set 인터페이스

• Set: 집합. 데이터가 중복되지 않는다. HashSet, TreeSet 등이 있다.
  • HashSet: 데이터의 순서가 없어, 입력순서와 다르게 출력될 수 있다.
  • LinkedHashSet: 출력 순서가 항상 입력 순서와 동일하다.
  • TreeSet: 입력순서와 상관없이 크기 순으로 출력한다.

Set set1 = new HashSet();
for(int i=0; i<5; i++){
    set1.add(i);
    System.out.println(Arrays.toString(set1.toArray()));
}

Iterator iter = set1.iterator();
for(int i=0; i<set1.size(); i++){
    System.out.println(iter.next());
}

리턴	메서드	기능
boolean	add(E element)	매개변수로 입력된 원소를 추가
boolean	addAll(Collection c)	매개변수로 입력된 컬렉션 전체를 추가
boolean	remove(Object o)	원소 중 매개변수 입력과 동일한 객체 삭제
void	clear()	전체 원소 삭제
int	size()	객체 내 포함된 원소 개수
boolean	isEmpty()	원소가 하나도 없는지 여부 리턴
Object[]	toArray()	Object배열로 변환
boolean	contains(Object o)	매개변수로 입력된 원소가 있는지 여부 리턴
Iterator	iterator()	Set 객체 내 데이터를 연속해서 꺼내는 Iterator 객체를 리턴
boolean	iterator().hasNext()	다음으로 가리킬 원소의 존재 여부를 리턴
E	iterator().next()	다음 원소 위치에서 읽은 값을 리턴

Map 인터페이스

• Map: 키와 값을 쌍으로 저장하고, 키의 중복은 허용되지 않는다(값은 중복 가능). 입출력의 순서는 일치하지 않을 수 있다. HashMap, HashTable, TreeMap, Properties 등이 있다.
  • HashTable: 비교적 멀티쓰레드에 안전하다. Properties는 HashTable의 하위 클래스로 String 제한되어 있다.
  • LinkedHashMap: HashMap의 기본적 특성에 입력 데이터의 순서 정보를 추가로 가져, 입출력의 순서가 일치한다.
  • TreeMap: 데이터를 Key값의 크기 순으로 저장한다.

리턴	메서드	기능
V	put(K key, V value)	매개변수로 입력된 (key, value)를 추가
void	putAll(Collection c)	매개변수로 입력된 컬렉션 전체를 추가
V	replace(K key, V, value)	Key를 갖는 엔트리를 모두 변경
boolean	replace(K key, V oldValue, V newValue)	(key, oldValue) 쌍을 newValue로 변경
V	get(Object key)	매개변수의 Key 값에 해당하는 value를 리턴 *index가 아니라 key로 가져옴
V	remove(Object key)	key를 갖는 엔트리 삭제
boolean	remove(Object key, Object value)	(key, value)를 갖는 엔트리 삭제
void	clear()	전체 원소 삭제
int	size()	객체 내 포함된 원소 개수
boolean	isEmpty()	원소가 하나도 없는지 여부 리턴
Object[]	toArray()	Object배열로 변환
boolean	containsKey(Object o)	매개변수로 입력된 원소가 있는지 여부 리턴
boolean	containsValue(Object o)	매개변수로 입력된 원소가 있는지 여부 리턴
Set	keySet()	key들을 set 객체로 리턴

Map<String, Integer> map1 = new HashMap<>();
map1.put("no", 1);
map1.put("kor", 100);
map1.containsKey("no");
map1.containsValue(50);
map1.get("kor");
map1.remove("no");
for(Map.Entry<String, Integer> entrySet: map1.entrySet()){
    System.out.println(entrySet.getKey()+" "+entrySet.getValue());
}

Properties map4 = new Properties(); // 속성 String으로 내포되어 있어 지정 안 함
map4.setProperty("나", "총점"); // 무조건 문자열 입력
map4.setProperty("padding", "30px");
System.out.println(map4.getProperty("padding"));

Stack 클래스

• Stack: 일반적, 최신 데이터를 저장하는 자료 구조로, 데이터 입출력이 LIFO(Last In First Out 후입선출)으로 이루어진다. List의 손자, Vector의 자식 클래스이다.
  • Pop (up): 데이터 출력

리턴	메서드	기능
boolean	add(E element)	매개변수로 입력된 원소를 리스트 마지막에 추가
void	add(int index, E element)	index 위치에 입력된 원소 추가
E	push(E item)	item을 stack에 추가. 데이터 입력(push down)
E	pop()	가장 상위에 있는 원소 삭제 및 리턴
E	remove(int index)	index 위치의 원솟값 삭제
boolean	remove(Object o)	원소 중 매개변수 입력과 동일한 객체 삭제
void	clear()	전체 원소 삭제
E	get(int index)	index 위치의 원솟값을 꺼내 리턴
int	size()	리스트 객체 내 포함된 원소 개수
boolean	isEmpty()	리스트의 원소가 하나도 없는지 여부 리턴
Object[]	toArray()	리스트를 Object배열로 변환
boolean	contains(Object o)	매개변수로 입력된 원소가 있는지 여부 리턴
int	search(Object o)	Stack의 원소 o의 위칫값을 리턴. 맨 위가 1이고, 아래로 내려갈 수록 1씩 증가
E	peek()	가장 상위에 있는 원소 값 리턴
boolean	empty()	Stack 객체가 비어있는지 여부 리턴

Stack<String> st1 = new Stack<>();

Queue 인터페이스

• Queue: 데이터 입출력이 FIFO(First In First Out 선입선출)으로 이루어진다. CPU의 스케쥴링이 사용하는 자료구조로, 쓰레드의 우선순위에 사용된다. 가장 먼저 입력되어, 가장 먼저 출력되는 부분을 front이다. 가장 마지막에 입력되어, 가장 나중에 출력되는 부분을 rear라 한다.
• Queue는 LinkedList로 구현되는 인터페이스이다.

Queue q1 = new LinkedList();

리턴	메서드	기능
boolean	add(E element)	매개변수로 입력된 원소를 리스트 마지막에 추가
E	remove()	가장 상위 원소값 리턴
void	clear()	전체 원소 삭제
Object[]	toArray()	리스트를 Object배열로 변환
boolean	contains(Object o)	매개변수로 입력된 원소가 있는지 여부 리턴
E	peek()	가장 상위에 있는 원소 값 리턴. 예외 처리 기능 포함.
boolean	offer(E item)	매개변수 item을 Queue에 추가. 예외 처리 기능 포함.
E	poll()	가장 상위에 있는 원소 값 제거 및 리턴. 예외 처리 기능 포함.

Dequeue 인터페이스

• Deque: 앞뒤 모두로 입출력(FIFO/LIFO)이 가능한 자료구조이다. ArrayDeque, LinkedBlockingDeque, ConcurrentLinkedDeque, LinkedList 등의 클래스가 있다.

Deque<Integer> dq1 = new ArrayDeque<>();
Deque<Integer> dq2 = new LinkedBlockingDeque<>();
Deque<Integer> dq3 = new ConcurrentLinkedDeque<>();
Deque<Integer> dq4 = new LinkedList<>();
  

---

Javascript

변수

	재선언	재할당
var	O	O
let	X	O
const	X	X

• var는 재선언과 재할당이 가능하다.
• let은 재할당만 가능하다.
• const는 둘 다 불가능하다.

document.getElementById(ID) // 하나만 선택됨
document.getElementsByClassName // 배열로 반환됨
document.getElementsByTagName // 배열로 반환됨
document.querySelector("#result"); // css 선택자로 요소 선택
document.querySelectorAll(".lst li"); // 해당 요소 모두 선택

document.innerHTML = "" // 해당 요소에 html 문구를 대입.  태그를 쓰면 html 요소로 변환됨
document.innerText = "" // 해당 요소에 텍스트 대입. 태그를 쓰면 그대로 반영됨.

---

성찰

1. 컬렉션에서 맵을 어떻게 사용할 지가 궁금하다. 파이썬 같은 경우에는 맵의 활용도가 굉장히 높았는데, 자바의 경우 맵의 value에 리스트가 들어가는 것도 어정쩡해보여서 어떻게 쓰이는지 봐야할 것 같다.

2. javascript나 css는 내가 보기에 좀 난잡하다. 뭔가 잘 모듈화되어있지 않다고 느껴져서 답답하다.

---

핵심 정리

• ClassCastException: 상속 관계에 있는 클래스 간에 다운캐스팅이 불가능한 상황에서 다운캐스팅을 시도할 때 발생하는 예외
• 자바에서 예외를 전가하는 키워드는?  [ thorws ]