※ 변수명 짓는 규칙

1.  숫자로 시작 불가
2.  특수문자는 _  &  만 가능
3.  int, class, return 등 키워드는 변수명으로 사용 불가
4.  카멜 케이스   ex) getBackGround

※ 클래스명 짓는 규칙

1.  명사로 할 것
2.  대문자로 시작
3.  파스칼케이스   ex) ChocoCookie

※ 메서드명짓는 규칙

1.  동사로 할 것
2.  소문자로 시작
3.  카멜 케이스   ex) getBackGround

■ 원시 자료형(Primitive type) 과 참조 자료형(Reference type):

• 원시자료형 : 변수에 실제 값을 가지는 자료형
• 참조자료형 : 실제 값을 갖는 것이 아닌 데이터가 저장된 메모리의 주소 값을 가지는 자료형

■ 리터럴 표기란?

객체를 생성하지 않고 고정된 값을 그대로 대입하는 방식. 원시자료형에서 사용

    ex) String a = "Geun's blog"

          >> a라는 변수에 "Geun's blog"라는 문자열 값을 그대로 대입

■ 참조자료형에서는?

 new키워드를 사용하여 객체 만들어 사용. 객체 중심으로 코드 작성에 유리

    ex) String a = new String("Geun's blog")

          >> 항상 새로운 String 객체를 만든다.

■ Wrapper 클래스

  원시자료형을 객체로 다루기 위해 객체화 시키는 클래스. 객체 지향 프로그래밍의 모든 기능을 활용할 수 있게 한다.

■ 형 변환

 (1) 문자열 → 정수 

       int n = Integer.parseInt(문자열)               

                 *정수 형태로 이루어진 문자열이어야 한다. (실수형태의 문자열은 정수형태로 변환 불가)

 (2) 정수 → 문자열

       String num = "" + (정수)                           *정수 앞에 빈 문자열("") 더하기

       String num = String.valueOf(정수)  

       String num = Integer.toString(정수)   

 (3) 실수 → 정수

       int n = (int) (실수)                                     *실수 앞에 (int) 붙임

만들 프로그램

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

내가 작성한 코드

• 메서드명 : 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() {
        // 메서드 내용
    }
}