[정보처리기사] 자바(Java)

2023-04-07

자바 기본 구조

Java에서 모든 소스 코드는 클래스 단위로 구성된다.

프로그램은 public static void main부터 시작한다.

public class Soojebi {
public static void main(String[] args){
  System.out.println("Hello");
}
}

출력
Hello

자료형

자료형(Data Type)의 개념

자료형은 프로그래밍 언어에서 실수, 정수 자료형과 같은 여러 종류의 데이터를 식별하는 형태이다.
메모리 공간을 효율적으로 사용하고 2진수 데이터를 다양한 형태로 사용하기 위해 존재한다.
- 문자형(Character) : 문자 하나를 저장하고자 할 때 사용하는 자료형, 메모리에는 숫자로 저장됨 char
- 문자열형(String) : 문자 여러 개를 저장하고자 할 때 사용하는 자료형 String
- 정수형(Integer) : 정숫값을 저장하고자 할 때 사용하는 자료형 byte, short, int, long
- 부동 소수점형(Floating Point) : 소수점을 포함하는 실숫값을 저장하고자 할 때 사용하는 자료형 float, double
- 논리형(Logical; Boolean) : 변수의 참. 거짓을 나타낼 때 사용하는 자료형, true(참), false(거짓) 두 가지 값을 저장 boolean

자료형	바이트 크기
byte	1
short	2
int	4
long	8

변수

변수(Variable)의 개념

변수는 저장하고자 하는 어떠한 값이 있을 때, 그 값을 주기억장치에 기억하기 위한 공간이다.
자바의 변수는 초기화하지 않으면 정수형은 0, 실수형은 0.0, 문자형은 NULL로 초기화된다.

변수 유효범위(Variable Scope)

1) 클래스 변수(Class Variable)

클래스 변수는 클래스 블록에 선언하는 변수이다.
클래스 변수는 클래스가 시작되면 변수가 생성되고, 클래스가 종료되면 변수가 소멸된다.

클래스 변수는 클래스 내에서 사용할 수 있다.

public class Soojebi {
int a = 5;   // a는 클래스 변수, a라는 변수에 5를 대입
void fn(){   // fn 함수 호출
 a = a + 3; // a는 10이 저장되어 있으므로 10+3은 13이 되고, 13을 a라는 변수에 저장
}
public static void main(String[] args){ // 프로그램은 main 함수부터 시작
 Soojebi s = new Soojebl();            // Soojebi 클래스를 s라는 변수에 생성
 s.a = s.a + 5;                        // s의 a는 5가 저장되어 있으므로 5+5는 10이 되고, 10을 S의 a라는 변수에 저장
 s.fn();                               // s의 fn 사용자 정의 함수를 호출
 System.out.println(s.a);              // s의 a는 13이므로 13을 출력
}
} 

출력
13
2) 지역 변수(Local Variable)
- 지역 변수는 블록 내에서 선언하는 변수이다.
- 지역 변수는 블록이 시작되는 부분에 바로 선언해주어야 하고, 중괄호가 닫히는 시점에 소멸된다.
- 지역 변수는 해당 블록 안에서만 사용할 수 있다.
3) static 변수(Static Variable)
- static 변수는 변수 선언할 때 static이라는 키워드를 붙여준다.
- static 변수는 프로그램이 시작되면 변수가 생성되고, 프로그램이 종료되면 변수가 소멸된다. static 변수는 프로그램 전체에서 사용할 수 있다.

배열

배열(Array)의 개념

배열은 같은 타입의 변수들로 이루어진 집합이다.

배열선언

1) 1차원 배열 선언
- 초깃값이 없는 경우 : 자료형 []배열명 = new 자료형[배열_요소_개수];, 자료형 배열명[] = new 자료형[배열_요소_개수];
- 초깃값이 있는 경우 : 자료형 []배열명 = {초깃값};
배열 요소 개수에 정의된 숫자만큼 같은 타입의 데이터 공간이 선언된다.
배열 요소 개수를 명시하지 않고 초깃값이 정의되어 있을 경우 초깃값 개수만큼 공간이 선언된다.
초깃값을 선언하지 않을 경우 정수일 때는 0 , 실수일 때는 0.0 , 문자열일 때는 NULL이 저장된다.
불린 , 문자 , 정수 , 실수 등을 배열로 선언할 때 사용한다.

자바에서 배열의 크기를 구할 때는 length 속성을 사용한다.

public class Soojebi {
public static void main(String[] args){ // 프로그램은 main 함수부터 시작
 int []a = new int[3];
 System.out.println(a.length);
}
} 

출력
3

2) 2차원 배열 선언

초깃값이 없는 경우 : 자료형 [][]배열명= new 자료형[행의 개수][열의 개수];, 자료형 배열명[][]= new 자료형[행의 개수][열의 개수];

초깃값이 있는 경우 : 자료형 [][]배열명 = {{초깃값}, {초깃값}, …};

public class Soojebi {
public static void main(String[] args){ // 프로그램은 main 함수부터 시작
 int [][]a = new int[3][2];
 System.out.println(a.length);
 System.out.println(a[0].length);
}
} 

출력
3
2

표준 입출력 함수

표준 출력 함수 표준 출력 함수는 print, printin, printf 함수가 있다.
- System.out.print() : 개행을 하지 않는 출력함수
- System.out.println() : 개행을 하는 출력함수
- System.out.pdntf() : C언어처럼 변수를 출력할 수 있는 출력함수
표준 입력 함수 readLine은 입력장치(키보드)로부터 한 개의 문자를 읽는 함수 라인 전체를 읽는 표준 입력 함수이다.
- System.in.readLine()

연산자

문자열과 문자열, 문자열과 정수, 문자열과 실수를 더하게 되면 문자열이 된다.

자바는 C언어의 연산자와 동일합니다. 다만, 자바는 C와 다르게 String이라는 문자열 타입이 있기때문에 String을 연산할 수 있다는 점이 추가되었습니다.

public class Soojebi {
public static void main(String[] args){ // 프로그램은 main 함수부터 시작
  System.out.println("5 + 2 = " + 3 + 4);
  System.out.println("5 + 2 = " + 3.1 + 4);
  System.out.println("5 + 2 = " + (3 + 4));
  System.out.println(5 + 2 + " = 3 + 4");
}
} 

출력
5 + 2 = 34
5 + 2 = 3.14
5 + 2 = 7
7 = 3 + 4

반복문

for each 문의 개념 for each 문은 배열이나 리스트의 크기만큼 반복하는데, 반복할 때마다 배열이나 리스트의 항목을 순차적으로 변수에 대입하는 반복문이다.

for each 문의 구조

for (제어변수 : 배열){
  문장;
}

public class Soojebi {
  public static void main(String[] args){ // 프로그램은 main 함수부터 시작
 String[] name = {"SOO","JE","BI"};
 for( String nm : name ){
 System.out.println(nm);
 }
  }
} 

출력
SOO
JE
BI

메서드

사용자 정의 함수(메서드)
- 1) 사용자 정의 함수(User-Defined Function) 개념
  - 사용자 정의 함수는 사용자가 직접 새로운 함수를 정의하여 사용하는 방법이다.
- 사용자 정의 함수에서 매개변수나 생성된 변수는 사용자 정의 함수가 종료되면 없어진다.
```
1
2
3
4
자료형 함수명(자료형 변수명, …){
  명령어;
  return 반환값;
} 
```

static 메서드

static 메서드는 클래스가 메모리에 올라갈 때 자동적으로 생성되는 메서드이다.

인스턴스(클래스로부터 만들어진 객체)를 생성하지 않아도 호출이 가능하게 된다.

class Soojebi {
static void print(){ // static으로 print 메서드 선언해서 인스턴스 없이 호출 가능
System.out.println("static method"); // static method 출력
}
}
public class SoojebiMain {
public static void main(String[] args){ // 프로그램은 mair 메서드부터 시작
Soojebi.print(); // 인스턴스(Soojebi soo와 같은 변수 선언)를 생성하지 않고, ”클래스명.메서드명” 형태로 호출 
}
}

출력
SoojebiMain

클래스

개념
클래스는 객체 지향 프로그래밍(OOP; Object-Oriented Programming)에서 특정 객체를 생성하기 위해 변수와 메서드를 정의하는 틀이다.
클래스 접근 제어자(Access Modifier)
접근 제어자는 지정된 클래스, 변수, 메서드를 외부(같은 패키지이거나 다른 패키지)에서 접근할 수 있도록 권한을 설정하는 기능이다.
- public : 외부의 모든 클래스에서 접근이 가능한 접근 제어자
- protected : 같은 패키지 내부에 있는 클래스, 하위 클래스(상속받은 경우)에서 접근이 가능한 접근 제어자, 자기 자신과 상속받은 하위 클래스 둘 다 접근이 가능한 접근 제어자
- default : 접근 제어자를 명시하지 않은 경우로 같은 패키지 내부에 있는 클래스에서 접근이 가능한 접근 제어자
- private : 같은 클래스 내에서만 접근이 가능한 접근 제어자
클래스 정의
- 클래스에서 변수는 변수 선언과 동일하고, 메서드는 사용자 정의 함수와 문법이 동일하다.
- 일반적으로 변수는 private 접근 제어자를 사용하여 외부에서 접근하지 못하게 하며, 메서드는 외부에 공개할 것만 public 접근 제어자를, 그렇지 않으면 protected나 private 접근 제어자를 사용하여 정보은닉을 한다.
  - 정보 은닉(Information Hiding) : 코드 내부 데이터와 메서드를 숨기고 공개 인터페이스를 통해서만 접근이 가능하도록 하는 코드 보안 기술

클래스 변수 생성

클래스는 객체를 생성하기 위해 변수와 메서드를 정의하는 틀이므로 실제 변수에 들어갈 인스턴스를 new 키워드로 생성해주어야 한다.

변수를 이용해 클래스의 메서드에 접근한다.

클래스명 변수명 = new 클래스명(파라미터);
변수명.메서드명();

클래스 this

this는 현재 객체를 가리키는 키워드이다.

클래스 내부의 변수와 메서드를 가리킬 수 있다.

this.변수;
this.함수(매개변수);

public class Soojebi {
private int a;
public void setA(int a){
 this.a = a;
}
public int getA( ){
 return a;
}
public static void main(String[] args){
 Soojebi soo = new Soojebi();
 soo.setA(5);
 System.out.print(soo.getA());
}
}

출력
5

생성자(Constructor)
- 생성자는 해당 클래스의 객체가 생성될 때 자동으로 호출되는 특수한 종류의 메서드이다.
- 생성자는 일반적으로 클래스의 멤버 변수를 초기화하거나 클래스를 사용하는 데 필요한 설정이 필요한 경우 사용한다.
- 생성자는 클래스 명과 동일한 메서드명을 가지고, 반환 값이 없다.
- 생성자가 없을 경우 public 클래스명(){}이라는 아무 일도 하지 않는 생성자가 있는 것처럼 동작한다.
- 생성자 정의
```
1
2
3
4
5
public class 클래스명{
public 클래스명(매개변수){
 명령어;
}
}
```
- 생성자 호출
```
1
클래스명 클래스변수 = new 클래스명(매개변수);
```

소멸자(Destructor) - finalize 메서드

finalize 메서드는 객체의 수명이 끝났을 때 객체를 제거하기 위한 목적으로 사용되는 메서드이다.
반환 값이 없다.

소멸자 정의

public class 클래스명{
public void finalize(매개변수){
 명령어;
}
}

소멸자 호출

클래스변수.finalize(매개변수)

public class Soojebi{
public Soojebi(){
 System.out.println("A");
}
public Soojebi(int a){
 System.out.println("B: "+a);
}
public void finalize(){
 System.out.println("C");
}
public void fn(){
 System.out.println("D");
}
public static void niain(String[] args){ // 프로그램은 main 메서드부터 시작
 Soojebi s1 = new Soojebi(); // A 출력, 매개변수가 없는 Soojebi 생성자 호출
 Soojebi s2 = new Soojebi(5); // B: 5 출력 (정수 값을 매개변수로 받는 생성자를 호출)
 s1.fn(); // s1의 fn 메서드를 호출
 s1.finalize();
}
}

출력
A
B: 5
D
C

클래스 상속

클래스 상속(Inheritance) 개념
- 상속은 어떤 객체가 있을 때 그 객체의 변수와 메서드를 다른 객제가 물려받는 기능이다.
- 자식 클래스를 생성하면 무조건 부모 클래스의 생성자를 실행한 후에 자식 클래스의 생성자를 실행한다.

클래스 상속 문법

class 부모_클래스명{
}
class 자식_클래스명 extends 부모클래스명{
}

자바 상속

Class A{
public void fnA(){
 System.out.print1n("A");
}
}
class B extends A{
public void fnB(){
 System.out.print1n("B");
}
}
public class Soojebi {
public static void main(String[] args){
 B b = new B();
 b.fnA();
 b.fnB();
} 

출력
A
B

오버로딩(Overloading)

오버로딩은 동일 이름의 메서드를 매개변수만 다르게 하여 여러 개 정의할 수 있는 기능이다.
오버로딩의 특징
- 메서드 이름이 같아야 한다.
- 매개변수 개수가 달라야 한다.
- 매개변수 개수가 같을 경우 데이터 타입이 달라야 한다.
- 반환형은 같거나 달라도 된다.

생성자와 오버라이딩을 헷갈려하는데, 생성자는 클래스명과 동일한 이름의 메서드이고, 오버라이딩은 부모, 자식 간 동일한 이름의 메서드입니다. (생성자는 오버라이딩이 안 됩니다.)

class A {
public void fn( ){
 System.out.println("A");
}
public void fn(int i){
 System.out.println(i);
}
public void fn(double d){
 System.out.println(d);
}
public int fn(int a, int b){
 return a+b;
}
}
public class Soojebi{
public static void main(String args[]){ 
 A a = new A();
 a.fn();
 a.fn(7);
 a.fn(10.0);
 System.out.println(a.fn(2, 3));
}
}

출력
A
7
10.0
5

오버라이딩(Overriding)
오버라이딩은 하위 클래스에서 상위 클래스 메서드를 재정의할 수 있는 기능이다.

오버라이딩의 특징
- 오버라이드하고자 하는 메서드가 상위 클래스에 존재하여야 한다.
- 메서드 이름은 같아야 한다.
- 메서드 매개변수 개수, 데이터 타입이 같아야 한다.
- 메서드 반환형이 같아야 한다.

오버라이딩 구문

class 부모_클래스명{
public 반환_자료형 메서드명(자료형 변수명){ }
}
class 자식_클래스명 extends 부모_클래스명{
Public 반환_자료형 메서드명(자료형 변수명){
// 부모 클래스의 메서드명. 매개변수가 동일해야 함
} 
}

자바 오버라이딩

class A{
public void fn(){
 System.out.println("A");
}
}
class B extends A{
public void fn(){
 System.out.println("B");
}
}
public class Soojebi{
public static void main(String args[]){ 
 A a = new B(); // B 클래스를 a라는 변수로 생성, B 클래스를 a 변수에 생성하므로 B의 생성자 B()와 B의 부모인 A의 생성자 A()를 호출해야 하지만, 둘 다 없으므로 클래스 생성 시 아무 일도 일어나지 않음
 a.fn(); // a는 B 클래스이므로 B 클래스의 fn()을 호출
}
}

출력
B

자바 생성자, 오버라이딩

class Parent{
public Parent(){         // 생성자는 클래스와 이름이 똑같은 메서드로 Parent 클래스의 생성자는 Parent 메서드
 System.out.println("A");
}
public void fn(){
 System.out.println("B");
}
}
class Child extends Parent{
public Child(){          // 자식 클래스인 Child 클래스의 생성자를 호출
 System.out.println("C");
}
public void fn(){
 System.out.println("D");
}
}
public class Soojebi{
public static void main(String args[]){
 Child c = new Child(); // Child 클래스를 C라는 변수로 생성, Child 클래스를 C 변수에 생성하므로 Child와 부모 클래스인 Parent 클래스의 생성자를 호출
 c.fn(); // c라는 변수는 Child 클래스이므로 Child 클래스에 있는 fn() 메서드를 호출
}
}

A
C
D

부모 클래스 접근
자바는 super 키워드를 이용하여 상위 클래스의 변수나 메서드에 접근할 수 있다.

부모 클래스 접근 구문 : super.메서드명();

자바 상위 클래스 접근

Class A{
public void fn( ){
 System.out.println("A");
}
}
class B extends A{
public void fn(){
 super.fn();
 System.out.println("B");
}
}
public class Soojebi {
public static void main(String args[]){
 A a = new B();
 a.fn();
}
}

출력
A
B

추상 클래스

추상 클래스(Abstract Class) 개념
- 추상 클래스는 미구현 추상 메서드를 한 개 이상 가지며, 자식 클래스에서 해당 추상 메서드를 반드시 구현하도록 강제하는 기능이다.

추상 클래스 구문

abstract class 추상_클래스명 {
  abstract 자료형 메서드명(); // 메서드 내부는 정의하지 않음
}
class 자식_클래스명 extends 추상_클래스명{
  자료형 메서드명(){
  명령어； // 메서드를 상속받아 메서드 내부를 정의
  }
}

메서드 내부를 정의하지 않는다는 의미는 메서드 내부에 소스 코드를 이용해서 구현하지 않는다는 의미이고. 메서드 내부를 정의한다는 의미는 메서드 내부를 소스 코드를 이용해서 구현한다는 의미.

인터페이스

인터페이스(Interface) 개념
- 인터페이스는 자바의 다형성을 극대화하여 개발코드 수정을 줄이고 프로그램 유지보수성을 높이기 위한 문법이다. (인터페이스는 일종의 추상 클래스이다.)
- 오직 추상 메서드와 상수만을 멤버로 가질 수 있으며, 그 외의 다른 어떠한 요소도 허용하지 않는다.
- 인터페이스는 구현된 것은 아무것도 없고 밑그림만 그려져 있는 ‘기본 설계도’ 라고 할 수 있다.

인터페이스 구문

interface 인터페이스_클래스명{
  자료형 메서드명(); // 메서드 내부는 정의하지 않음
}
class 자식_클래스명 implements 인터페이스_클래스명{
  자료형 메서드명(){
  //interface의 메서드를 상속받아 내부를 정의
  }
}

자바 인터페이스

interface A{
void fn();
}
class B implements A{
public void fn(){ // B 클래스의 fn() 메서드 호출 
System.out.println("B"); 
}
}
class C implements A{
public void fn(){
 System.out.println("C"); // C 클래스의 fn() 메서드 호출
}
}
class Soojebi{
public static void main(String args[]){
 A b = new B(), // B 클래스를 b라는 변수로 생성, B 클래스를 b 변수에 생성하므로 B의 생성자 B()와 B의 부모인 A의 생성자 A()를 호출해야 하지만, 둘 다 없으므로 클래스 생성 시 아무 일도 일어나지 않음
 A c = new C(); // C 클래스를 C라는 변수로 생성, C 클래스를 c 변수에 생성하므로 C의 생성자 C()와 B의 부모인 A의 생성자 A()를 호출해야 하지만, 둘 다 없으므로 클래스 생성 시 아무 일도 일어나지 않음
 b.fn(); // b라는 변수는 B 클래스이므로 B 클래스에 있는 fn() 메서드를 호출
 c.fn(); // c라는 변수는 C 클래스이므로 C 클래스에 있는 fn() 메서드를 호출
}
} 

출력
B
C

스레드

스레드(Thread) 개념
스레드는 프로세스보다 가벼운, 독립적으로 수행되는 순차적인 제어의 흐름이며, 실행 단위이다.
스레드 구현
Thread 클래스 상속, Runnable 인터페이스 상속

Thread 클래스 상속

Thread 클래스 상속 부분

스레드를 만들기 위해서는 Thread 클래스를 상속받고, run() 메서드에 스레드 동작 시 수행할 코드를 작성한다. (run 메서드오버라이딩)

class T_Soojebi extends Thread{ //  T_Soojebi라는 클래스를 생성
public void run(){            // Thread 클래스의 run() 메서드를 상속받아 재정의
 // 스레드 동작 시 수행할 코드
}
}

Thread 클래스 호출 부분

스레드 클래스를 생성하여 스레드변수에 저장한다.
Thread 스레드변수 = new 상속받은스레드클래스();
Thread 스레드변수 = new Thread(new 상속받은스레드클래스());
스레드변수.start()를 통해 스레드의 run() 메서드를 실행한다.

자바 Thread 클래스 상속을 통한 스레드 구현

class T_Soojebi extends Thread{
public void run(){ // run 함수는 외부에서 thread를 start하면 실행하는 메서드
 System.out.println("Run"); // 스레드 내에서 Run을 출력
}
}
public class Soojebi{
public static void main(String[] args){
 Thread t1 = new T_Soojebi(); // t1 변수에 스레드 클래스 선언 
 Thread t2 = new Thread(new T_Soojebi()); // t2 변수에 스레드 클래스 선언 
 t1.start(); // t1의 run 메서드 실행
 t2.start(); // t2의 run 메서드 실행
 System.out.println("Main");
}
} 

출력
Run
Main
Run
- t1 변수에 의한 스레드, t2 변수에의한 스레드 main 함수가 동시에 수행되는데, 컴퓨터의 상태에 따라서 t1의 스레드가 먼저 실행될 수도 있고, t2의 스레드가 먼저 실행될 수도 있고 main이 먼저 실행될 수도 있습니다. 그래서 출력 결과는 다를 수 있다.
- main 함수에서 tl.start();를 하고, t2.start();를 하면 main 함수와 t1 스레드, t2 스레드가 동시에 동작하게 되므로 출력 결과는 달라질 수 있다.

Runnable 인터페이스 상속

Runnable 인터페이스 상속 부분

스레드를 만들기 위해서는 Runnable 인터페이스 상속받고, run() 메서드에 스레드 동작 시 수행할 코드를 작성한다. (run 메서드 오버라이딩)

Class T_Soojebi implements Runnable{ // T_Soojebi라는 클래스를 생성
public void run(){  // Runnable 클래스의 run() 메서드를 상속받아 재정의
 // 스레드 동작 시 수행할 코드
}
}

Thread 클래스 호출 부분

스레드 클래스를 생성하여 스레드변수에 저장한다.
Thread 스레드변수 = new Thread(new 상속받은스레드클래스());
스레드변수.start()를 통해 스레드의 run() 메서드를 실행한다.

자바 Thread 클래스 상속을 통한 스레드 구현

class T_Soojebi implements Runnable{
public void run(){ // run 함수는 외부에서 thread를 start하면 실행하는 메서드
 System.out.println("Run"); // 스레드 내에서 Run을 출력
}
}
public class Soojebi{
public static void main(String[] args){ // 프로그램은 main 메서드부터 시작
 Thread t = new Thread(new T_Soojebi( )); // t 변수에 스레드 클래스 선언
 t.start(); // t의 run 메서드 실행
 System.out.println("Main"); // Main을 출력
}
}

출력
Run
Main
- main 함수에서 t.star1();를 하면 main 함수와 t 스레드가 동시에 동작하게 되므로 출력 결과는 달라질 수 있다.

컬렉션

컬렉션 프레임워크(Collection Framework)의 개념
- 컬렉션 프레임워크는 다수의 데이터를 효과적으로 처리할 수 있는 표준화된 방법을 제공하는 클래스의 집합이다.
- 자바에서는 컬렉션 프레임워크를 통해 모든 컬렉션 클래스와 인터페이스를 제공한다.
  - 컬렉션(Collection) :데이터의 집합 또는 그룹을 의미한다.
컬렉션 프레임워크 특징
- 배열의 단점을 보완 : 배열(Array)의 단점을 보완하여 만들어진 클래스로, 메모리 낭비를 방지하고 동적인 크기 변경이 가능
- 자료구조의 구현 : 자료구조 형태인 List, Set, Map 등이 클래스로 구현
- 일관된 인터페이스 : 대량의 데이터를 일관된 인터페이스를 제공하여 하여 쉽고 효율적으로 프로그램 작성이 가능

컬렉션 프레임워크의 구조

자바에서 컬렉션 프레임워크는 인터페이스로 List, Set, Map 등을 제공한다.

인터페이스	구현 클래스	특징
List	`LinkedList`, `ArrayList`	중복이 가능하고, 순서가 있는 데이터의 집합
Set	`HashSet`, `TreeSet`	중복이 불가능하고, 순서가 없는 데이터의 집합
Map	`Hashtable`, `HashMap`, `TreeMap`	<키, 값>의 구조로 키는 중복이 불가능하고 값은 중복이 가능한 데이터의 집합

LinkedList

LinkedList는 데이터의 삽입 삭제가 빈번한 경우 ArrayList보다 효율적으로 사용할 수 있는 클래스이다,

리스트의 처음과 끝, 양쪽에서 데이터를 추가, 제거하는 메서드를 제공한다.
Stack, Queue, Deque와 같은 자료구조를 쉽게 구현할 수 있게 한다.

LinkedList 선언
- LinkedList의 선언 방법은 타입을 설정하지 않는 방법, 타입을 설정하는 방법이 있다.
- 자료형은 Class, Integer, String, Character 등의 선언이 가능하다.
  - List 변수명 = new LinkedList();
  - LinkedList 변수명 = new LinkedList();
  - List<자료형> 변수명 = new LinkedList<자료형> ();
  - LinkedList<자료형> 변수명 = new LinkedList<자료형> ();
- LinkedList로 생성하기 위해서는 LinkedList 변수명 = new LinkedList로();로 선언해야 하지만, LinkedList 대신에 상위 클래 스인 List를 사용하여 List 변수명 = new LinkedList로();로 선언할 수 있습니다.
LinkedList 메서드
- add(값) : 값을 추가하는 메서드
- add(인덱스, 값) : 해당 인덱스(번지)에 값을 추가하는 메서드
- remove(인덱스) : 해당 인덱스(번지)에 값을 제거하는 메서드
- size() : 원소 개수를 출력하는 메서드
- get(인덱스) : 해당 인덱스(번지)에 값을 얻는 메서드

public class Soojebi {
  public static void main(String[] args) {
    List<String> list = new LinkedList<String>(); // String 타입을 갖는 링크드 리스트 객체 list를 생성
    list.add("Hello");    // list에 Hello 문자열을 추가(0번지에 추가됨)
    list.add("Hello");    // list에 Hello 문자열을 추가(1번지에 추가됨)
    list.add(1, "World"); // list의 1번지에 World 문자열을 추가, 기존의 0번지와 1번지 사이에 값 추가
    System.out.print(List);
    }
}

출력
[Hello. World, Hello]

ArrayList

ArrayList는 List의 자식 클래스로 크기가 가변적으로 변하는 선형리스트의 성질을 가지고 있는 자료형이며 클래스이다.

ArrayList 선언
- List 변수명 = new ArrayList();
- ArrayList 변수명 = new ArrayList();
- List<자료형> 변수명 = new ArrayList<자료형> ();
- ArrayList<자료형> 변수명 = new ArrayList<자료형> ();
ArrayList 메서드
- add(값) : 값을 추가하는 메서드
- add(인덱스, 값) : 해당 인덱스(번지)에 값을 추가하는 메서드
- remove(인덱스) : 해당 인덱스(번지)에 값을 제거하는 메서드
- size() : 원소 개수를 출력하는 메서드
- get(인덱스) : 해당 인덱스(번지)에 값을 얻는 메서드

public class Soojebi {
  public static void main (String[] args){
    List a = new ArrayList();     // a라는 변수에 ArrayList 클래스 생성
    a.add(2);                     // ArrayList에 2 추가
    System.out.println(a);        // [2]가 출력됨 
    a.add(1);                     // ArrayList에 1이 추가
    System.out.println(a);        // [2, 1]이 출력됨(순서가 중요함)
    a.add (1);                    // ArrayList에 1이 추가
    System.out.println(a);        // [2, 1, 1]이 출력됨(중복 값 허용)
    a.add(1, 3);                  // ArrayList의 1번지에 3이라는 값이 추가되어 현재 0번지인 2와 1번지인 1 사이에 값 추가
    System.out.println(a);        // [2, 3, 1, 1]이 출력됨
    a.remove(2);                  // ArrayList의 2번지에 있는 값인 1을 제거 
    System.out.println(a);        // [2, 3, 1]이 출력됨
    System.out.println(a.get(2)); // ArrayList의 2번지에 있는 값 출력
    System.out.println(a.size()); // 원소 개수 출력
  }
}

출력
[2]
[2, 1]
[2, 1, 1]
[2, 3, 1, 1]
[2, 3, 1]
[1]
3

HashSet

HashSet은 Set의 자식 클래스(하위 클래스; 파생 클래스)로 중복된 원소를 허용하지 않는 집합의 성질을 가지고 있는 자료형이며 클래스이다.

HashSet 선언
- Set 변수명 = new HashSet();
- HashSet 변수명 = new HashSet();
- Set<자료형> 변수명 = new HashSet<자료형> ();
- HashSet<자료형> 변수명 = new HashSet<자료형> ();
HashSet 메서드
- add(값) : 값을 추가하는 메서드, 중복된 값이 들어오면 추가하지 않음
- remove(값) : 값을 제거하는 메서드
- size() : HashSet에 들어있는 원소의 개수를 얻는 메서드

public class Soojebi {
  public static void main (String[] args){
    Set h = new HashSet();
    h.add(2);
    System.out.println(h);
    h.add(1);
    System.out.println(h);
    h.add(1);
    System.out.println(h);
    h.remove(1);
    System.out.println(h);
    System.out.println(h.size());
  }
} 

출력
[2]
[2, 1]
[2, 1]
[2]
1
집합에서 순서는 중요하지 않음
Set 클래스를 사용하기 위해서는 java.util.Set을 import해야 하고, HashSet 클래스를 사용하기 위해서는 java.util.HashSet을 import 해야합니다.
실제 동작을 위해서는 소스코드의 맨 위에 다음 코드의 입력 필요.
import java.util.Set; import java.util.HashSet;

TreeSet

TreeSet은 이진 검색 트리라는 자료구조 형태로 데이터를 저장하는 자료형이며 클래스이다.

Set 인터페이스를 구현하여 중복된 데이터의 저장을 허용하지 않으며, 정렬된 위치에 저장하여 저장순서를 유지하지 않는 특성을 가진다.
이진 검색 트리(Binary Search Tree) : 이진 탐색과 연결리스트를 결합한 자료구조로, 모든 노드가 최대 두개의 자식노드를 가질 수 있는 트리이다.

TreeSet 선언
- Set 변수명 = new TreeSet ();
- TreeSet 변수명 = new TreeSet ();
- Set<자료형> 변수명 = new TreeSet<자료형> ();
- TreeSet<자료형> 변수명 = new TreeSet<자료형> ();
TreeSet 메서드
- add(값) : 값을 추가하는 메서드, 중복된 값이 들어오면 추가하지 않음
- remove(값) : 값을 제거하는 메서드
- size() : TreeSet에 들어있는 원소의 개수를 얻는 메서드
- headSet(값) : 값보다 작은 객체들을 반환하는 메서드
- tailSet(값) · 값보다 큰 객체들을 반환하는 메서드

public class Soojebi {
  public static void main (String[] args){
    TreeSet set = new TreeSet();
    set.add(89);
    set.add(32);
    set.add(71);
    System.out.println("50 미만의 값 :" + set.headSet(50));
    System.out.println("50 이상의 값 :" + set.tailSet(50)); 
  }
} 

출력
50 미만의 값 :[32]
50 이상의 값 :[71, 89]
자바에서 TreeSet 클래스를 사용하기 위해서는 java.util.TreeSet을 import 해야 합니다.
실제 동작을 위해서는 소스코드의 맨 위에 다음 코드의 입력 필요.
import java.util.TreeSet;

HashMap

HashMap은 키와 값으로 구성된 객체를 저장하는 구조로 되어 있는 자료구조를 구현한 클래스이다.

HashMap은 Map 컬렉션 중 가장 많이 사용되는 클래스입니다. 검색과 정렬을 제외한 작업에 대부분 HashMap을 사용합니다.

HashMap 선언
- Map 변수명 = new HashMap();
- HashMap 변수명 = new HashMap();
- Map<자료형> 변수명 = new HashMap<자료형> ();
- HashMap<자료형> 변수명 = new HashMap<자료형＞ ();
HashMap 메서드
- put(키, 값) : 해당 키에 해당하는 값을 추가하는 메서드
- remove(키) : 해당 키에 해당하는 값을 제거하는 메서드
- get(키) : 해당 키에 해당하는 값을 얻는 메서드
- size() : HashMap에 들어있는 원소의 개수를 얻는 메서드

public class Soojebi {
  public static void main (String[] args){
    Map h = new HashMap();
    h.put(1, "A");
    System.out.println(h);
    h.put(1, "C");
    System.out.println(h);
    h.put(2, "D");
    System.out.println(h);
    h.remove(1);
    System.out.println(h);
    System.out.println(h.get(2));
    System.out.println(h.size());
  }
}

출력
{1=A}
{1=C}
{1=C, 2=D}
{2=D}
D
1
- Map 클래스를 사용하기 위해서는 java.util.Map을 import 해야하고, HashMap 클래스를 사용하기 위해서는 Java.util.HashMap을 import 해야합니다.
- 실제 동작을 위해서는 소스코드의 맨 위에 다음 코드의 입력 필요.
  import java.util.Map;, importJava.util.HashMap;

TreeMap

TreeMap은 키와 값으로 구성된 객쳬를 저장하는 구조로 되어 있는 자료구조를 구현한 자료형이며 클래스이다.

TreeMap은 이진 검색 트리 형태로 데이터를 저장하여 저장 시 자동 정렬되는 특성을 가진다.
TreeMap은 즉시 정렬하는 특성으로 인해 추가, 삭제 작업이 HashMap보다 오래걸립니다. 정렬, 검색 작업에서는 TreeMap을 활용하고 그 외에는 HashMap을 주로 활용합니다.

TreeMap 선언
- Map 변수명 = new TreeMap();
- TreeMap 변수명 = new TreeMap();
- Map<자료형> 변수명 = new TreeMap<자료형> ();
- TreeMap<자료형> 변수명 = new TreeMap<자료형> ();
TreeMap 메서드
- put(키, 값) : 해당 키에 해당하는 값을 추가하는 메서드
- remove(키) : 해당 키에 해당하는 값을 제거하는 메서드
- get(키) : 해당 키에 해당하는 값을 얻는 메서드
- size() : TreeMap에 들어있는 원소의 개수를 얻는 메서드

public class Soojebi {
  public static void main (String[] args){
    Map t = new TreeMap();
    t.put(1, "A");
    System.out.println(t);
    t.put(1, "C");
    System.out.println(t);
    t.put(2, "D");
    System.out.println(t);
    t.remove(1);
    System.out.println(t);
    System.out.println(t.get(2));
    System.out.println(t.size());
  }
}

출력
{1=A}
{1=C}
{1=C, 2=D}
{2=D}
D
1
- Map 클래스를 사용하기 위해서는 java.util.Map을 import 해야하고, TreeMap 클래스를 사용하기 위해서는 Java.util.TreeMap을 import 해야합니다.
- 실제 동작을 위해서는 소스코드의 맨 위에 다음 코드의 입력 필요.
  import java.util.Map;, importJava.util.TreeMap;

예외 처리

예외 처리(Exception Handling) 개념
예외 처리는 프로그램이 동작 중에 의도하지 않은 비정상적인 동작을 처리하는 기법이다.

예외 처리 구문
예외 처리는 try, catch, finally 로 구성된다.

try 다음에 수행할 명령문에서 예외가 발생하면 catch에서 예외를 처리
catch는 하나 이상 작성하며, 상황에 맞는 예외처리가 수행됨

finally 문장은 예외처리가 끝나고 반드시 실행되어야 하는 명령문을 수행함

public class Soojebi {
public static void main (String[] args){
 try {
 int a = 4/0;
 }
 catch (Exception e) {
 System.out.println(e.getMessage());
 }
 finally {
 System.out.println("finally")
}

출력
/ by zero
finally

throw

throw는 의도적으로 예외를 던지는 예약어이다.

컴파일에는 문제가 없지만 런타임에 발생된 에러를 처리하기 위해 사용한다.

public class Soojebi {
public static void main (String[] args){
 try {
 throw new Exception();
 }
 catch (Exception e) {
 System.out.println("강제 예외 발생");
 }
}
}

출력
강제 예외 발생

throws

throws는 메서드에서 발생하는 예외를 던지는 예약어이다.

throws 뒤에 발생할 예외를 명시한다.

접근제어자 자료형 메서드명(매개변수) throws 예외처리명{
명령문
}

public class Soojebi{
public void divide(int a, int b) throws Exception{
 System.out.println(a/b);
}
public static void main (String[] args){
 Soojebi a = new Soojebi();
 try {
 a.divide(4, 0);
 }
 catch (Exception e) {
 System.out.println(e.getMessage());
 }
}
}

출력
/ by zero

Twitter Facebook LinkedIn

Yuhui Seo