체대생에서 개발자로

[문제]

식사 다 마친 테이블을 조회하는 프로그래 만들기

[조건]

- 테이블은 총 10개 
- 식사를 다마친 테이블을 출력하기     
- 3개의 테이블이 식사를 다 마치면 치워주기 

- 10개의 테이블이 식사를 마치면 영업 종료 

[차근 차근 생각해보기]

1. 다양한 코드 구현을 해보기 위해 람다식 사용해보기
2. Runnable을 사용하여 테이블  식사 다 마친 테이블 찾아보기
3. 조건문을 사용하여 3개의 테이블이 식사를 마치면 치워주는 문구 출력
4. 모든 테이블이 식사를 마치면 마지막 테이블까지 치운 후 영업 종료  

[코드]

public static void main(String[] args) {
    Runnable table = () -> {
        System.out.println("DDONY의 식당 운영 시작");
        System.out.println("----------------------");
        for (int i = 1; i <= 10; i++) {
            System.out.println(i + "번 째 테이블 식사 완료");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if(i%3 == 0){
                System.out.println("====================");
                System.out.println("3개의 테이블 치우기 완료");
                System.out.println("====================");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        System.out.println("==== 오늘 영업은 종료 되었습니다. ====");
    };

    Thread thread = new Thread(table);
    thread.start();

}

<실행 결과>

[반성할 점]

아직 스레드에 대한 이해도가 많이 부족하다.

그래도 써봤다는 것에 의의를 두었고 배웠던 람다식도 최대한 활용해보려고 노력하였다.

다양한 방법을 사용하여 간단한 다양한 프로그램을 만드려고 노력해봐야겠다.   

[멀티스레드]

멀티 스레드는 하나의 프로세스 내에서 여러 개의 동시 실행 흐름(스레드)을 가지는 것이다.

멀티스레딩은 동시에 여러 작업을 처리하거나 동시에 실행되어야 하는 작업을 관리한다.

하지만 이러다 보면 멀티스레딩 환경에서 스레드 간의 동시 접근으로 인해 발생할 수 있는 문제가 생길 수 있다.

이를 방지하기 위해 스레드 동기화를 사용한다. 

[스레드 동기화]

스레드동기화는 위에서 말한 멀티스레딩 환경에서 스레드 간의 동시 접근으로 인해 발생할 수 있는 문제를 해준다.

즉, 하나의 프로세스에 동시에 접근하지 못하도록 막는 것을 말한다.

[Synchronized 사용방법]

class Hello {
    synchronized public void hello(String name){
         System.out.println("내 이름은 : " + name);
    }
}

•  메소드 앞에 synchronized 키워드를 사용하여 사용할 수 있다.  

[스레드(Thread)]

Java에서 여러가지 일을 동시에 처리하기 위해 사용되는 것.

• 실행 가능한 프로그램(.exe)이 실행되어 돌아가는 것을 프로세스라고 한다.
• 프로그램을 실행하게 되면 하나의 프로세스가 수행된다.
• 프로세스는 자원을 통해 실제로 작업을 수행하는 것을 스레드한다.
• 프로세스는 여러개의 스레드가질 수 있다. 

즉, 스레드는 프로세스 안에서 실질적으로 작업을 실행하는 단위를 말한다.

[스레드 사용방법]

<Thread 클래스 상속>

public static void main(String[] args) {
    HelloThread thread = new HelloThread();
    hread.start();
}

class HelloThread extends Thread{
    public void run(){
        System.out.println("스레드야 안녕");
    }
}

• Thread 클래스를 상속받은  클래스 만들기
• run()을 오버라이드 하여 코드 구현
• 생성한 클래스 객체 만들어서 스레드 사용하기

<Runnable 인터페이스>

public static void main(String[] args) {
    HelloThread hello = new HelloThread();
    Thread thread = new Thread(hello);
    thread.start();
}

class HelloThread implements Runnable{
    @Override
    public void run(){
        System.out.println("스레드야 안녕");
    }
}

• Runnable 인터페이스를 구현한 클래스 만들기
• run()을 오버라이드 하여 코드 구현
• 만든 클래스 객체 생성하고, Thread 객체 만들어서 스레드 사용하기

Runnable 인터페이스를 사용하는 이유는 상속은 단일 상속만 가능하지만,

인터페이스는 여러개의 상속이 가능하기 때문에 사용한다. 

[문제]

예외 처리로 파스타 집 대기 알림 프로그램 만들기

대기 손님이 10명 이상일 경우 기다려 달라고 하기

10명 이하일 경우 입장 시키기  

[차근 차근 생각해보기]

1. Excpetion 클래스를 상속받는 PleaseWait 클래스 하나 만들기
2. customer 변수 선언하기
3. try - catch문 사용하여 조건문과 throw문 사용해보기  
4. finally 블록으로 감사하다는 문구 출력하기

[코드]

public static void main(String[] args) {
    int customer = 11;

    System.out.println("DDONY의 파스타 집 오픈!!");
    System.out.println("총 대기 인원 : " + customer + "명");
    System.out.println("----------------------");
    try {
        if(customer <= 10) {
            System.out.println("차례대로 입장 도와드리겠습니다.");
        }else{
            throw new PleaseWait("한번에 입장 가능한 최대 인원은 10명 입니다.");
        }
    }catch (PleaseWait e){
        System.out.println(e.getMessage());
        System.out.println("조금만 기다려주세요ㅠㅠ");
    }finally {
        System.out.println("\n감사합니다. 좋은 서비스 제공해드리겠습니다");
    }
}


class PleaseWait extends Exception{
    public PleaseWait(String message) {
        super(message);
    }
}

[반성할 점]

아직 어디서 어떻게 실전에서 사용해야할지 감이 오질 않는다..

조금 익숙해져 보려고 최대한 여러가지 방법을 사용하여 예외처리를 해보았다.  

[오류]

Java에서 오류는 크게 두 가지로 나눌 수 있다.

컴파일 오류와 런타임 오류이다.

1. 컴파일 오류

int num = "String";

코드에 문제가 있어 프로그램이 실행 되지 않은 것을 말한다. 

정수 타입 num에 문자열이 들어가려 하면 오류가 날 것이다.

이처럼 코드에 문제가 있어 실행이 되지 않는 것을 컴파일 오류라고 한다.  

2. 런타임 오류 

int[] arr = {1, 2, 3};
int arrNum = arr[3];

컴파일은 되지만 실행되는 과정에서 문제가 발생하는 것을 말한다.

위 코드처럼 코드에서 작성은 되지만 실행 시켜 보면 인덱스의 범위를 벗어났기 때문에

ArrayIndexOutOfBounds 오류가 날 것이다. 

또, 런타임 오류에는 error(에러)와 exception(예외)로 나눌 수 있다.

에러는 메모리 부족이나 스택 오버 플로우와 같은 것을 말하며 작성한 코드로 해결 할 수 없다. 

예외는 NullPointException / ArrayIndexOutOfBoundsException 같은 것들을 말하며 작성한 코드로 해결 할 수 있다.

[예외 처리 사용방법]

예외가 발생 하였을때 java에서는 try - catch로 예외 처리를 하거나 throw를 통해 처리할 수 있다. 

1. try - catch문

try{

}catch(Exception e){

}finally{

}

• try 블록에서는 예외가 발생할 수있는 코드를 작성한다.  
• catch 블록은 예외가 발생했을 때 실행된다. 
  • printStackTrace() 혹은 getMessage()로 에러 메세지를 확인할 수 있다.
  • catch 블록은 여러개 사용할 수 있으며
  •   ArrayIndexOutOfBoundsException, Exception 등 다양한 예외 유형을 넣어 예외 처리할 수 있다. 
• fianlly블록은 예외가 발생해도 하지 않아도 무조건 실행되는(수행되어야 하는)  블록이다.
• try - catch 블록은 중첩해서 사용도 가능하다.

2. throw 문

public static void main(String[] args) {
    try{
        System.out.println(3 / 0);
        throw new Exception("잘못된 계산 입니다.");
    } catch(ArithmeticException e){
        e.printStackTrace();
    }
}


public static num(int a, int b) throws Exception{
	// 코드..
}

• throw는 예외를 강제로 발생시킬때 사용된다.
• 예외가 발생할 경우, 예외 객체를 생성하고 예외를 호출자에게 던진다.
• throw는 위와 같이 두 가지 방식으로 사용할 수 있고 catch 블록에서 예외를 다시 던질 때 사용될 수 있다.   

[문제]

나이가 20미만인 사람들은 무료 입장

나이가 20 이상이면 입장료 10000원을 나타내는 프로그램 만들기  

<이름 : 나이>

김씨: 40

이씨: 35

박씨: 20

송씨: 15

나씨 : 5

[차근 차근 생각해보기]

1. 손님의 이름과 나이 정보가 있는 클래스 하나 만들기
2. ArrayList를 사용하여 손님의 이름과 나이 정보 넣어주기
3. 스트림을 이용하여 나이가 20 이상이면 10000원을 붙여주고    
4. 미만이면 무료라고 표시해주기

[코드]

 public static void main(String[] args) {
 
    ArrayList<User> list = new ArrayList<>();
    list.add(new User("김씨", 40));
    list.add(new User("이씨", 35));
    list.add(new User("박씨", 20));
    list.add(new User("송씨", 15));
    list.add(new User("나씨", 5));

    list.stream()
            .map(x -> x.age >= 20 ? x.name + " 10000원" : x.name + " 무료")
            .forEach(System.out::println);
 
 }
 
 class User{
    public String name;
    public int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
 }

[반성할 점]

User 클래스에 담겨 있는 name과 age의 정보를 어떻게 가져와야할지 몰라 한참 풀지 못하였다.

x는 User를 뜻하는 것이기 때문에 x.name과 x.age로 정보를 가져올 수 있었다.     

[스트림]

스트림은 Java 8에서 추가된 기능으로 컬렉션 데이터를 선언형으로 쉽게 처리할 수 있다.

복잡한 반복문을 사용하지 않아도 된다.

많은 데이터를 원하는 조건에 따라 1차 필터링, 2차 필터링 ... 원하는 만큼 필터링을 하여 데이터를 가공할 수 있고,

데이터 중 필요한 요소만 꺼내오도록 할 수 있다.

그러기 때문에 데이터 가공이 편리하다는 이점이 있다. 

[스트림 생성]

public static void main(String[] args) {

    // 스트림 생성
    int[] num = {1, 2, 3, 4, 5};
    IntStream numStream = Arrays.stream(num);

    String[] str = {"A", "B", "C"};
    Stream<String> strStream = Arrays.stream(str);

    // Collection 스트림 생성
    ArryaList<String> list = new ArrayList<>();
    list = Arrays.asList("A", "B", "C");
    Stream<String> listStream = list.stream();
    
    // Stream.of()
    Stream<String> str2 = Stream.of(("A", "B", "C");
}

• Arrays.stream을 사용하여 스트림을 생성할 수 있다.
• Collection도 변수명.stream()을 사용하여 스트림을 생성할 수 있다.
• Stream.of()를 통해 무자열 요소를 포함하는 스트림을 생성할 수 있다.   

[스트림 사용]

public static void main(String[] args) {

    // 스트림 생성
    int[] num = {10, 20, 30, 40, 50};
    IntStream numStream = Arrays.stream(num);

    // 스트림 사용
    // 30 이상만 출력
    Arrays.stream(num)
        .filter(x -> x >= 30)
        .forEach(x -> System.out.println(x));

    // 30이상인 수의 개수
    int count = (int)Arrays.stream(num)
        .filter(x -> x >= 30)
        .count(); // count는 long타입
	System.out.println(count);


    // num 배열 요소의 합
    int sum = Arrays.stream(num)
    	.sum();
    System.out.println(sum);

}

정렬 -> .sorted()

특정 글자로 시작 -> .startsWith("문자")

특정 글자 포함 -> .contains("문자") 

등의 메소드를 사용하여 데이터를 가공할 수 있다.

추가로 map()을사용하여 문자를 더하거나, 대소문자로 바꾸는 등 다양한 데이터 가공을 할 수 있다.       

[함수형 인터페이스]

• 함수형 인터페이스는 하나의 추상메서드가 있는 인터페이스를 말한다. (2개 이상이면 함수형 인터페이스가 아님)
• @FunctionalInterface 어노테이션을 갖고 있다.
• 람다식과 함께 사용된다.
• 기본 메소드와 정적 메소드도 가질 수 있다.  
  • 기본메소드는 인터페이스의 일반적인 동작을 제공한다.
  • 정적 메소드는 인터페이스와 관련된 메소드를 제공한다. 

[함수형 인터페이스 사용방법]

// 함수형 인터페이스
@FunctionalInterface
public interface FunctionalInterface {
	void hi(String s);
}

// 메인 메소드
public static void main(String[] args) {

    // 익명 클래스 활용
    FunctionalInterface f = new FunctionalInterface(){
        @Override
        public void hi(String s){
            System.out.println(s);
        }
    }
    f.hi("Hi!");

     // 람다식 활용
    FunctionalInterface f1 = s -> {
        System.out.println(s);
    };
    f1.hi("Hi!");
    

}

 아직 람다식과 함수형 인터페이스에 관해 제대로 이해를 하지 못한 것 같다..(더 어떻게 설명해야할지..ㅠㅠ)  

조금 더 공부해보고 다시 정리를 해야겠다..

일단 공부한 내용은 기록으로 남겨둬야지..  

[람다식]

람다식은 익명 함수를 지칭하는 용어이며 간결한 방법으로 함수를 정의할 수 있다.  

[람다식 사용방법] 

public void Phone(){
    String phone = "아이폰";
    System.out.println(phone);
}

// 방법 1
() -> {
    String phone = "아이폰";
    System.out.println(phone);
}

public void Phone(String phone){
    System.out.println(phone);
}

// 방법 2
phone -> System.out.println(phone)

public int sum (int x, int y){
    return x + y;
}

// 방법 3
(x, y) -> x + y

• 람다식은 (전달값1, 전달값2, ...)  -> { 코드 }와 같이 사용할 수 있다.
• 접근제어자 반환타입 메소드명은 생략 가능하다.
• 전달값이 1개일 경우 괄호도 생략 가능하며, 전달값의 타입도 생략 가능하다. (중괄호와 세미콜론도 생략 가능)
• return이 있을 경우 중괄호는 생략할 수 없다. (return을 제외하면 중괄호 생략 가능 자동으로 return 해줌)         

[익명클래스]

익명 클래스는 이름 없는 클래스라고 한다.

클래스 내에서 클래스를 정의할 수 있으며, 클래스 내부에 정의 되기 때문에 내부 클래스라고도 한다.

간단한 기능을가진 클래스를 임시로 정의하고 사용할 때 편리하고,

클래스를 따로 정의하지 않고도 필요한 동작을 구현할 수 있어 코드의 가독성과 유지보수에 편리하다는 장점이있다. 

[익명클래스 선언 방법] 

<방법 1>

public static void main(String[] args) {

    Phone phone = new Phone(){
        @Override
        public void type(String type){
            super.type(type);
        }
    };
    
    phone.type("아이폰");

}

class Phone{

    public void type(String type){
        System.out.println("이 휴대폰의 기종은 " + type + " 입니다.");
    }

}

<방법 2>

public static void main(String[] args) {

    HowToMadePasta pasta = madePasta();
    pasta.made();

    // 클래스안에서 익명 클래스 선언
    private static HowToMadePasta madePasta(){
        return new HowToMadePasta(){
            @Override
            public void made(){
                System.out.println("파스타 레시피 입니다.");
            }
        }
    }

}

// 클래스 생성 
abstract class HowToMadePasta{
	public abstract void made();
}

<부모클래스 혹은 인터페이스> 변수명 = new <부모클래스 혹은 인터페이스>() {

	// 익명 클래스 내용

} ;

위와 같이 선언하여 사용할 수 있다. 중괄호 내부에는 부모클래스 또는 인터페이스의 메서드를 오버라이드한다.