만들 프로그램

 양의 정수를 입력받고, 입력받은 수의 자릿수를 출력

내가 작성한 코드

• 메서드명 : getCount
• 입력받는 값은 양의 정수(a)
• 출력하는 값은 숫자 개수

처음엔 10 미만일 경우 1자리, 100 미만일 경우 2자리...로 생각하였으나,

무한한 자릿수를 나타낼 수 없어 문자열로 변환하고 글자수를 세는 방법을 생각하게 됨

public class Problem3 {

    static int getCount(int a) {
        String result = "" + a;
        return result.length();
    }

    public static void main(String[] args) {
        System.out.println("자릿수: "+getCount(3));
        System.out.println("자릿수: "+getCount(23));
        System.out.println("자릿수: "+getCount(2352));
        System.out.println("자릿수: "+getCount(462643));
    }
}

>> 출력:

자릿수: 1
자릿수: 2
자릿수: 4
자릿수: 6

모범 답안

1. 입력값을 몫이 0이 될때까지 10으로 나누고, 나눈 총횟수를 자릿수로서 리턴

public class Problem3_A {
    static int getDigitCount(int n) {
        int count = 1;
        while (true) {
            if (n == 0) {
                break;
            }
            n /= 10;     → 숫자 n을 10으로 나누고 그 값을 다시 숫자 n에 대입
            count++;
        }
        return count;
    }

    public static void main(String[] args) {
        System.out.println("자릿수: "+getDigitCount(3));
        System.out.println("자릿수: "+getDigitCount(23));
        System.out.println("자릿수: "+getDigitCount(2352));
        System.out.println("자릿수: "+getDigitCount(462643));
    }
}

>> 출력:

자릿수: 1
자릿수: 2
자릿수: 4
자릿수: 6

2. 10으로 나눴을 때 몫이 0이 될때까지 계속 나누고, 나눈 총횟수를 자릿수로서 리턴

public class Problem3_A {

    static int getDigitCount(int n) {
        String result = "" + n;    → 정수를 문자열로 변환
        return s.length();     → 문자열의 글자 수를 리턴
    }

    public static void main(String[] args) {
        System.out.println("자릿수: "+getCount(3));
        System.out.println("자릿수: "+getCount(23));
        System.out.println("자릿수: "+getCount(2352));
        System.out.println("자릿수: "+getCount(462643));
    }
}

>> 출력:

자릿수: 1
자릿수: 2
자릿수: 4
자릿수: 6

만들 프로그램

게시물의 총 개수와 한 페이지에 보여 줄 게시물 수를 입력했을 때 총 페이지 수를 출력하는 프로그램

내가 작성한 코드

import java.util.Scanner;

public class Problem2 {
    static int getTotalPage(int m, int n) {
        int result = 0;
        if (m % n == 0) {
            result = m / n;
        } else if(m % n != 0) {
            result = (m / n) + 1;
        }
        return result;
    }

    public static void main(String[] args) {
        Scanner sc1 = new Scanner(System.in);
        Scanner sc2 = new Scanner(System.in);

        System.out.print( "총 게시물 수 : ");
        int m = sc1.nextInt();
        System.out.print( "한 페이지에 보여줄 게시물 수 : ");
        int n = sc2.nextInt();

        System.out.print("총 페이지 수 : " + getTotalPage(m, n));
    }
}

>> 출력:

총 게시물 수 : 102
한 페이지에 보여줄 게시물 수 : 10
총 페이지 수 : 11

모범 답안

public class Problem2_A{
    static int getTotalPage(int m, int n) {     → static 메서드로 생성해야 객체 생성 없이 바로 해당 메서드 호출 가능
        if (m % n == 0) {
            return m / n;       → 굳이 result 변수 생성하지 않고 바로 결과값 반환
        } else {
            return m / n + 1;
        }
    }

    public static void main(String[] args) {
        System.out.println(getTotalPage(5, 10));
        System.out.println(getTotalPage(15, 10));
        System.out.println(getTotalPage(25, 10));
        System.out.println(getTotalPage(30, 10));
    }
}

>> 출력:

1

2

3

3

프로그램을 만들 때 가장 먼저 생각할 것: 입력과 출력

어떤 값이 입력값으로 주어지고, 어떻게 출력되어야 할 지를 가장 먼저 생각하라

구구단 프로그램 만들기

구구단 프로그램 중 2단을 만든다면 2를 입력값으로 주었을 때 어떻게 출력되어야 할지 생각

메서드 이름 ? gugudan

입력값 ? 2

출력값? 2단(2, 4, 6, 8, 10 ..., 18)

결과값 자료형? 배열

(1) gugudan 메서드에 2를 입력값으로 주면 result라는 변수에 결괏값을 넣는 코드 입력해보기

public class Gugudan {
    public static void main(String[] args) {
        result = gugudan(2);
    }
}

(2) 결괏값을 어떤 형태로 받을 것인가?

정수형 배열이 적합하다고 판단, int[] result = {2, 4, 6 ...., 18}과 같은 결과를 얻을 것이라고 생각하고 프로그래밍 시작

(3) 본격적인 프로그램 작성 시작 > gugudan 메서드 만들기

public class Gugudan {

    static int[] gugudan(int dan) {
        System.out.println(dan);
         return null;
    }

public static void main(String[] args) {
       
 result = gugudan(2);
    }
}

>> 출력 : 2

(4) 결과값을 담을 정수 배열 생성

public class Gugudan {

    static int[] gugudan(int dan) {

        int[] result = new int[9];         → 총 9단이므로 [9]배열 생성
        return result;         → 정수형 배열 리턴
    }

    public static void main(String[] args) {
        result = gugudan(2);    }
}

(5) result에 해당 구구단 값을 어떻게 넣어야 할 지 생각해보자. > for문 사용하기

public class Gugudan {
    static int[] gugudan(int dan) {
        int result[] = new int[9];
        for(int i=0; i<result.length; i++) {
            result[i] = dan * (i+1);
        }
        return result; 
    }

    public static void main(String[] args) {
        int[] result = gugudan(2);  
        for (int a:result) {
            System.out.println(a);
        }
    }
}

>> 출력 : 

2

4

6

...

18

(6) 입력받을 수 있도록 Scanner 구문 추가

>> 최종본

import java.util.Scanner;

public class Gugudan {
    static int[] gugudan(int dan) {
        int result[] = new int[9];
        for(int i=0; i<result.length; i++) {
            result[i] = dan * (i+1);
        }
        return result;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("구구단 몇단 출력할까요? : ");
        int[] result = gugudan(sc.nextInt());
        for (int a:result) {
            System.out.println(a);
        }
    }
}

스트림이란?

Java8에서 도입된 새로운 기능

간결하고 가독성 있는 코드 작성 가능

주요 특징

• 데이터의 흐름을 표현하여, 일관되고 간결한 방식으로 다룰 수 있음
• 내부 반복 요소들을 줄여 편리
• 결과가 필요한 시점까지 연산을 수행하지 않음 > 성능 최적화

예시

스트림을 사용하여 배열에서 짝수를 걸러내고, 역순으로 정렬

import java.util.Arrays;
import java.util.Comparator;

public class Stream {
    public static void main(String[] args) {
        int[] data = {5, 6, 4, 2, 3, 1, 1, 2, 2, 4, 8};

        int[] result = Arrays.stream(data)     // IntStream을 생성한다
                .boxed()   // IntStream을 Stream<Integer>로 변경한다.
                .filter((a) -> a % 2 == 0)   // 짝수만 뽑아낸다.
                .distinct()   // 중복을 제거한다.
                .sorted(Comparator.reverseOrder())  // 역순으로 정렬한다.
                .mapToInt(Integer::intValue)  // Stream<Integer>를 IntStream으로 변경한다.
                .toArray()   // int[]배열로 반환한다.
                ;

        for (int value : result) {
            System.out.print(value + " ");}
    }
}

람다(lambda)

• 익명 함수를 의미
• 함수형 프로그래밍을 지원하기 위해 Java8버전부터 도입
• 코드 가독성 상승을 위한 축약된 형태의 문법

람다 표현식 구조

(매개변수) -> 반환할값

입력할 값을 매개변수 란에 입력받아 -> 뒤의 함수식을 거쳐 생성된 값으로 반환

단, 인터페이스 사용 시 인터페이스의 메서드가 1개 이상이면 람다 함수 사용 불가

>> 람다함수로 사용할 인터페이스는 @FunctionalInterface 어노테이션 사용

@FunctionalInterface     //함수형 인터페이스: 단 한개의 메서드만 가질 수 있음.

interface Cal_2 {
    int sum(int a, int b);
}

public class Lambda {
    public static void main(String[] args) {
        Cal_2 mc1 = (a, b) -> a+b;     //인터페이스에 이미 입력값의 자료형이 정의되어 있으므로 (a, b)만 써도 가능
        Cal_2 mc2 = Integer::sum;     //Integer.sum(int a, int b)과도 동일하므로 Integer::sum으로도 요약 가능
        int result1 = mc1.sum(3, 4);
        int result2 = mc2.sum(3, 4);
        System.out.println(result1);
        System.out.println(result2);
    }
}

함수형 인터페이스 : BiFunction, BinaryOperator

두 인수를 받아 하나의 결과를 생성하는 기능 구현 시 사용

인터페이스 선언 없이 사용하여

더 축약하여 표현 가능한 방법이다.

BiFunction은 <>제네릭스 안에 입력항목 2개, 출력항목 1개의 자료형을 입력,

BinaryOperator는 입출력항목의 자료형이 모두 동일한 경우 <>제네릭스 안이 1가지만 사용

import java.util.function.BiFunction;
import java.util.function.BinaryOperator;  //입출력항목이 모두 동일할 경우

public class Lambda {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> mc3 = (a, b) -> a+b;  
                                                                    //제공되는 인터페이스인 BiFunction으로 더 축약 표현 가능
                                                                    // BiFunction<입력자료형1, 입력자료형2, 출력자료형3>
        int result3 = mc3.apply(3,4);       // sum이 아닌 apply메서드를 사용해야 함
        System.out.println(result3);

        BinaryOperator<Integer> mc4 = (a, b) -> a+b;
        int result4 = mc4.apply(3, 4);
        System.out.println(result4);
    }
}

스레드란?

한 프로세스 내에서 두 가지 이상의 일을 동시에 수행하는 것

      *프로세스: 동작하고 있는 프로그램을 말함

스레드 구현 시 필수 사용 메서드

• run() : Thread를 상속할 경우 필수적으로 구현해야 함. 동시에 수행할 코드들을 입력하는 곳
• start() : 스레드를 실행할 때 사용

    <예시>

public class Day24 extends Thread {
   public void run() {     // Thread를 상속하면 run 메서드를 구현해야 함
        System.out.println(this.seq + "thread start.");     //스레드 시작
        try {
             Thread.sleep(1000);     //1초 대기한다.
         } catch (Exception e) {
         }        System.out.println(this.seq + "thread end.");     //스레드 종료
    }

  public static void main(String[] args) {
       for (int i=0; i<10; i++) {      // 총 10개의 스레드를 생성하여 실행한다.
           Thread t = new Day24(i);
           t.start();    // start로 스레드를 실행
       }
        System.out.println("main end.");   // main메서드 종료

        → 0~9까지 동시에 실행되어 무작위 순서로 출력됨

Join 메서드

스레드가 모두 종료된 후 다음 작업을 진행해야 할 때 반드시 사용

스레드가 종료되지 않았는데 다음 작업을 진행 시 오류 발생 가능성 높아짐.

import java.util.ArrayList;     // Join메서드 사용 시

public class Day24 extends Thread {
    int seq;

    public Day24(int seq) {
        this.seq = seq;
    }

    public void run() {     
        System.out.println(this.seq + "thread start.");     //스레드 시작
        try {
            Thread.sleep(1000);     //1초 대기한다.
        } catch (Exception e) {
        }
        System.out.println(this.seq + "thread end.");     //스레드 종료
    }

    public static void main(String[] args) {
        ArrayList<Thread> threads = new ArrayList<>();  //
        for (int i=0; i<10; i++) {
            Thread t = new Day24(i);
            t.start();
            threads.add(t);
        }

        for (int i=0; i<threads.size(); i++) {
            Thread t = threads.get(i);
            try {
                t.join();       // 스레드가 종료할 떄까지 기다린다.
            } catch (Exception e) {
            }
        }
        System.out.println("main end.");
    }

Runnable 인터페이스 (Thread 상속 대신)

보통 Thread를 상속하기보단 Runnable인터페이스를 사용

Thread클래스를 상속 시 다른 클래스를 상속하지 못하기 때문

Runnable 인터페이스 사용 시 더 유연한 프로그램 제작 가능

import java.util.ArrayList; 


public class Day24 implements Runnable{
    int seq;

    public Day24(int seq) {
        this.seq = seq;
    }

    public void run() {     
        System.out.println(this.seq + "thread start.");    
        try {
            Thread.sleep(1000);   
        } catch (Exception e) {
        }
        System.out.println(this.seq + "thread end.");    
    }

    public static void main(String[] args) {
        ArrayList<Thread> threads = new ArrayList<>();
        for (int i=0; i<10; i++) {
            Thread t = new Thread(new Day24(i));
            t.start();
            threads.add(t);
        }

        for (int i=0; i<threads.size(); i++) {
            Thread t = threads.get(i);
            try {
                t.join();  
            } catch (Exception e) {
            }
        }
        System.out.println("main end.");
    }
}

예외 발생 예 3가지

• FileNotFoundException : 파일을 찾을 수 없을 때 발생
• ArithmeticException : 산술에 문제가 있을 때 발생
• ArrayIndexOutOfBoundsException : 배열의 범위 바깥을 가리키는 경우 발생

예외 처리 (try ~ catch ~ finally)

try문 안의 문장을 수행할 때 예외 발생하면 catch문 수행

어떤 예외가 발생하든 반드시 수행되어야하는 구문은 finally문

try {
    <수행할 문장 1>;
    <수행할 문장 2>;
} catch(예외 1) {
    <수행할 문장 A>;
    <수행할 문장 B>;
} catch(예외 2) {
    <수행할 문장 a>;
    <수행할 문장 b>;
} finally {
    <수행할 문장 I>;
    <수행할 문장 II>;
}

RuntimeException & Exception

• RuntimeException : 실행 시 발생하는 예외  (= Unchecked Exception)
• Exception : 컴파일 시 발생하는 예외  (= Checked Exception)

예외 던지기 - throw, throws

• throw: 메서드 내에서 예외 강제로 발생시키는 데 사용
• throws: 메서드 선언부에 사용되어, 해당 메서드가 처리하지 않은 예외를 호출하는 쪽에서 처리하도록 전달

import java.io.*;

class FoolException extends Exception {
}

public class Day23 {

    public void sayNick(String nick) throws FoolException{
        if("바보".equals(nick)) {
            throw new FoolException();
        }
        System.out.println("당신의 별명은 "+nick+"입니다.");

    }
    public void shouldBeRun() {
        System.out.println("Ok, Thanks!");
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("나없는파일"));
        br.readLine();
        br.close();   // 존재하지 않는 파일 오류 : FileNotFoundException

        int c = 4/0;    // 산술에 문제 발생 오류 : ArithmeticException

        int[] a = {1, 2, 3};
        System.out.println(a[3]);   // 배열의 범위 밖을 가리킬 때 오류 : ArrayIndexOutOfBoundsException

        // 예외처리 : try ~ catch 구조
        int d1;
        try {
            d1 = 4 /0;
        } catch (ArithmeticException e) {
            d1 = -1;     // 예외가 발생하므로 이 문장이 수행됨
        }
        System.out.println(d1);

        // finally : 어떤 에러가 발생해도 반드시 실행되어야하는 경우 처리
        Day23 day23 = new Day23();
        int d2;
        try {
            d2 = 4 /0;
        } catch (ArithmeticException e) {
            d2 = -1;     // 예외가 발생하므로 이 문장이 수행됨
        } finally {
            day23.shouldBeRun();
        }

        /*
            예외 활용하기
             RuntimeException : 실행 시 발생하는 예외  = Unchecked Exception
             Exception : 컴파일 시 발생하는 예외   =  Checked Exception
                                                                              */
        try {
            day23.sayNick("바보");    // 바보 입력 시 return으로 메서드 종료되어 출력 X
            day23.sayNick("야호");    // 바보 외의 입력값이므로 출력 O
        } catch (FoolException e) {
            System.err.println("FoolException이 발생했씁니다.");
        }

    }
}

static 키워드란?

• 클래스에서 공유되는 변수나 메서드를 정의할 때 사용하는 키워드
• 클래스의 인스턴스를 생성하지 않고도 클래스 자체에서 접근할 수 있도록 함
• 값을 공유할 수 있다.
• 메모리 할당을 최소화

static 변수

• 클래스영역에서 static키워드 사용 변수 선언
• 해당 클래스의 모든 객체가 해당 static 변수를 공유하게 됨

class HouseLee{
    static String lastname = "이";     → static 변수 선언
}

public class House {
    public static void main(String[] args) {
        HouseLee lee1 = new HouseLee();      
        HouseLee lee2 = new HouseLee();     → 객체 lee1, lee2 모두 lastname으로 "이"를 갖게됨
    }
}

static 메서드

• 메서드 앞 static 키워드를 붙여 생성
• 객체 생성 없이도 클래스를 통해 메서드 직접 호출 가능
• 유틸리티성 메서드 작성에 많이 사용

import java.text.SimpleDateFormat; 
import java.util.Date;

class Util {
    public static String getCurrentDate(String fmt) {
        SimpleDateFormat sdf = new SimpleDateFormat(fmt);
        return sdf.format(new Date());
    }
}

public class Sample {
    public static void main(String[] args) {

        System.out.println(Util.getCurrentDate("yyyyMMdd"));      →오늘 날짜 출력

    }
}

싱글톤 패턴

•  소프트웨어의 디자인 패턴 중 하나
•  클래스가 단 하나의 객체만을 생성하도록  만드는 패턴
•  클래스의 인스턴스가 한 번만 생성되고, 그 이후에는 이미 생성된 인스턴스르 반환
•  프로그램의 오류 확률을 줄일 수 있다.

class Singleton {
    public static Singleton one;    → singleton클래스에 one이라는 static변수 작성
    private Singleton() {      → new 객체 생성을 막기 위해 생성자 private 만듦
    }

    public static Singleton getInstance() {
        if (one == null) {
            one = new Singleton();
        }
        return one;
    }
}

public class Sample {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();     →one값이 null이므로 객체 생성
        Singleton singleton2 = Singleton.getInstance();     →one객체가 이미 생성되었으므로 one값 리턴
        System.out.println(singleton1 == singleton2);     →true 출력
    }
}

접근제어자란?

변수나 메서드, 생성자 등의 앞에 붙어 사용 권한을 설정하는 용도로 사용됨.

접근제어자는 다음과 같은 순서로 접근권한이 더 약해짐

private → default(기본)  → protected → public

private

- 해당 클래스 안에서만 접근이 가능

- 같은 패키지도 다른 클래스에서는 접근 불가

public class AnotherClass {
    private int privateVariable;
    
    private void privateMethod() {
        System.out.println("private모드입니다")
    }
}

default

- 가장 기본적인 권한 상태, 아무것도 안쓰면 default접근제어자가 자동 설정됨

- 동일 패키지 내에서 접근 가능

package house;     → 패키지가 동일

class HousePark {
    String lastname = "park";
    
public static void main(String[] args) {
    HouseKim kim = new HouseKim();
    System.out.println(kim.lastname);   → HouseKim 클래스의 lastname 변수 사용 가능
}

protected

- 동일 패키지 또는 해당 클래스를 상속한 자식 클래스에서만 접근 가능

package house.person;    → 서로 다른 패키지

import house.HousePark;

public class Geuns extends HousePark {     → HousePark 상속
    public static void main(String[] args) {     
        Geuns gp = new Geuns();
        System.out.println(gp.lastname);   → 상속한 클래스의 protected 변수는 접근 가능
    } 
}

public

- 어디서든 접근 가능함

public class MyClass {
    public int publicVariable;
    
    public void publicMethod() {
        // 메서드 내용
    }
}

패키지란

비슷한 성격의 클래스를 모아둔 자바의 "폴더"와 같은 개념

같은 이름의 클래스도 서로 다른 패키지에 존재 가능

서브 패키지(하위 패키지)

패키지는 폴더의 개념과 같음.

해당 하위패키지에 접근하기 위해서는

상위패키지명. 하위패키지명.클래스명

패키지 사용 시

서로 다른 클래스를 사용하기 위해서는 임포트해줘야 한다!

단, 같은 패키지 내에서는 import 없이도 사용 가능

(예)

import 상위패키지명.하위패키지명;   : 해당 하위패키지 임포트

                                                          or

import 상위패키지명.*   : 해당 상위패키지 밑의 모든 패키지 사용 가능

패키지 사용 이유

1. 클래스의 분류가 용이하다

2. 패키지가 다르다면 동일 클래스명 사용이 가능하다