'Computer Language' 카테고리의 글 목록

Computer Language

[240905~240908] 스프링 입문 - 미니 프로젝트(1/3) 2024.09.05 1
[240615] Method 2024.06.18
[240615] Array 2024.06.15
[240614] Scanner 2024.06.14
[240614] Scope & Casting 2024.06.14
[240614] Loop 2024.06.14 1
[240611] Conditional Statements 2024.06.14
[240610] Operator 2024.06.11 1

[240905~240908] 스프링 입문 - 미니 프로젝트(1/3)

westwith 2024. 9. 5. 23:06

2024. 9. 5. 23:06

728x90

0. 스프링 강의 듣는 공부 일지

강의 주소 :

https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EC%9E%85%EB%AC%B8-%EC%8A%A4%ED%94%84%EB%A7%81%EB%B6%80%ED%8A%B8/dashboard

[지금 무료] 스프링 입문 - 코드로 배우는 스프링 부트, 웹 MVC, DB 접근 기술 강의 | 김영한 - 인프

김영한 | 스프링 입문자가 예제를 만들어가면서 스프링 웹 애플리케이션 개발 전반을 빠르게 학습할 수 있습니다., 스프링 학습 첫 길잡이! 개발 공부의 길을 잃지 않도록 도와드립니다. 📣 확

www.inflearn.com

1. 스프링을 왜 공부해야 하는가...

=> 실무에서 제대로 동작하는 웹 애플리케이션을 개발하기 위해서

강의 목표 : 스프링을 어떻게 사용해야 하는가

미니 프로젝트 주제 : 간단한 웹 애플리케이션 개발

+a) 추후과제

+a) 추후과제

퍼블릭 클라우드 위에 서비스 배포 및 유지 보수(CI/CD를 이용한)

React Native를 이용한 Android, ios 등 기기 상관없는 서비스 배포...(표현 용어 있었던 것 같은데)

2. Index

프로젝트 주제 : 간단한 웹 애플리케이션 개발

1. 스프링 프로젝트 생성 및 스프링 부트로 웹 서버 실행

2. 회원 도메인 개발

3. 웹 MVC 개발

4. DB연동 - JDBC, JPA, 스프링 데이터 JPA

5. 테스트 케이스 작성

3. Tool stack

- spring boot

- Gradle

- Thymeleaf

- JPA ( Java Persistence API )

- Hibernate

- Tomcat

4. Project Setting

하지만 나는 기존에 java22를 사용하기에 일단 22로 하기로 함...

다운 받은 후, 압축을 풀어서 인텔리제이에서 프로젝트로 실행한다.

위와 같이 계속해서 외부에서 라이브러리를 다운받아 열리는 과정이 계속된다

프로젝트 폴더 구성
- src 하위 폴더의 main과 test는 Maven과 Gradle 둘 다 표준화 되어 있다.
  test 하위의 테스트 코드가 중요하다는 얘기 ( 테스트코드와 관련된 소스들이 들어가는 폴더)

main 폴더의 이미 생성된 클래스의 메인메서드를 실행

현재 아무것도 작성한 것이 없어서 위의 에러 페이지가 정상인 모습.

1. 스프링 프로젝트 생성 및 웹 서버 실행

(1) Welcome page 만들기

<!--파일경로 : resources/static/index.html -->

<!DOCTYPE HTML>
<html>
<head>
 <title>Hello</title>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
Hello
<a href="/hello">hello</a>
</body>
</html>

welcome page와 관련된 spring boot의 docs 링크
https://docs.spring.io/spring-boot/docs/2.3.1.RELEASE/reference/html/spring-boot-features.html#boot-features-spring-mvc-welcome-page

Spring Boot Features

Graceful shutdown is supported with all four embedded web servers (Jetty, Reactor Netty, Tomcat, and Undertow) and with both reactive and Servlet-based web applications. It occurs as part of closing the application context and is performed in the earliest

docs.spring.io

static/index.html 을 올려두면 welcome page를 제공한다.

hello를 클릭하면 이전의 404에러의 페이지가 나오도록 했다

이전 포스팅과 다르게 페이지의 주소 가장 마지막 부분이 '/hello'가 추가 된 것을 확인 할 수 있다.

(1)-1. Thymeleaf (타임리프)

: JSP, Freemarker와 같은 템플릿 엔진.

템플릿 엔진은 서버에서 HTML 파일을 생성하고 동적으로 데이터를 삽입하여 클라이언트에게 전달하는 데 사용.

쉽게 말해, HTML 문서 안에 Java 코드의 데이터를 결합해 최종적으로 사용자가 볼 수 있는 완성된 웹 페이지를 만들도록 도와줌.

주요 특징
1. HTML 기반 템플릿 엔진: Thymeleaf는 HTML 문서와 아주 비슷한 구조.
  즉, 개발자가 기존 HTML 파일을 사용하면서 필요한 부분에만 동적인 데이터를 삽입 가능.
  일반 HTML 파일처럼 브라우저에서 확인할 수 있어 템플릿 작성이 매우 직관적.
2. 스프링 부트와 통합이 용이: Thymeleaf는 스프링 부트와 자연스럽게 통합.
  스프링 부트에서 제공하는 컨트롤러에서 데이터를 Thymeleaf로 전달하고, 해당 데이터를 웹 페이지에 표시하는 구조를 쉽게 만들 수 있음.
3. 표현식 지원: Thymeleaf는 ${} 같은 표현식을 사용하여 서버에서 전달된 데이터를 HTML 문서 안에 삽입.
  예를 들어, Java 객체의 데이터를 HTML에 쉽게 바인딩 가능.
  여기서 th:text는 Thymeleaf의 속성으로, ${message}의 값을 HTML에 표시.
4. 동적 콘텐츠 생성: Thymeleaf는 조건부 렌더링(조건에 따라 HTML의 일부를 표시하거나 숨김), 반복문 등을 지원하여, 동적인 HTML을 쉽게 생성할 수 있음

참고

https://hstory0208.tistory.com/entry/Thmeleaf%ED%83%80%EC%9E%84%EB%A6%AC%ED%94%84%EB%9E%80-%ED%83%80%EC%9E%84%EB%A6%AC%ED%94%84%EC%9D%98-%EA%B8%B0%EB%B3%B8-%EA%B8%B0%EB%8A%A5%EC%95%8C%EC%95%84%EB%B3%B4%EA%B8%B0

Thymeleaf(타임리프)란 ? 타임리프의 기본 기능알아보기

Thymeleaf(타임리프)란 ? 타임리프는 JSP, Freemarker와 같은 템플릿 엔진의 일종으로 다음과 같은 특징을 갖고 있습니다. 서버 사이드 HTML 렌더링 (SSR) 백엔드 서버에서 HTML을 동적으로 렌더링 하는 용

hstory0208.tistory.com

<!-- 경로 : java/controller/HelloController -->
package hello.hello_spring.controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.stereotype.Controller;

@Controller
public class HelloController {
    @GetMapping("hello")
    public String hello(Model model) {
        model.addAttribute("data", "hello!!");
        return "hello";
    }
}

<!-- 경로 : resoucres/static/hello-static.html -->
<HTML>
<head>
    <title>
        static content
    </title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
정적 컨텐츠 입니다.
</body>
</HTML>

(1)-2. 정적 컨텐츠

<!--파일경로 : resources/static/index.html -->
<HTML>
<head>
    <title>
        static content
    </title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
정적 컨텐츠 입니다.
</body>
</HTML>

(1)-3. 정적 컨텐츠와 동적 컨텐츠를 제공하는 방식의 차이

정리정리 채워넣쟈

(2) MVC 와 템플릿 엔진

MVC : Model, View, Controller

<-> 정적 컨텐츠와의 차이 : 그냥 간단하게 파일을 고객에게 전달해주는게 정적, mvc와 템플릿 엔진을 이용한 방식은 서버에서 변형을 통하여 HTML을 좀 바꿔서 내려주는 방식

API
: 안드로이드나 아이폰 클라이언트랑 개발을 하기 위하여 JSON 데이터포맷으로 클라이언트에게 데이터를 전달하기 위한 방식 ( Vue, React 등등)

이전에는 JSP를 가지고도 뷰와 모델을 구분하지 않았지만 요즘 MVC 방식에는 뷰와 모델을 분리해야한다.

간단히,

> 뷰 : 화면을 그리는데 모든 역량을 집중

> 모델 : 컨트롤러와 같은 비즈니스와 관련된 로직이나 내부 처리에 집중

구분하면 좋은 장점 :
>> 규모가 큰 프로젝트나 기업에서 유지보수하기에 개발자들의 접근이 용이하다,
>> 즉 내가 작성한 것이 아닌 다른 사람이 작성한 수천라인의 코드라도 접근하기가 상대적으로 쉬워질 수 있다.

Thymeleaf 템플릿의 장점인 사용하여 html를 쓰고 서버없이 열어도 코드를 볼 수 있음

<!-- 파일경로 : resoureces/templates/hello-template.html >
<html xmlns:th="http://www.thymeleaf.org">
<body>
<p th:text="'hello ' + ${name}">hello! empty</p>
</body>
</html>

?name=spring!이라고 하니 hello 끝에 spring!이 생겼다

=> 템플릿 엔진을 통해서 동적이 아닌 정적인 방법으로 값을 넘겨줘(치환)
아까와 다른 (empty)가 아닌 spring이라고 출력된 것임

(2)-1. 스프링 웹 개발에서 이야기하는 API 방식

=>객체반환

<!-- 객체반환 : @Controller-->
  @GetMapping("hello-api")
  @ResponseBody
  public Hello helloApi(@RequestParam("name") String name) {
    Hello hello = new Hello();
    hello.setName(name);
    return hello;
 }
  static class Hello {
    private String name;
    public String getName() {
    return name;
 }
  public void setName(String name) {
    this.name = name;
  }
}

@ResponseBody

과거 html에서 주로 사용되던 XML방식보다(코드상 <html/></html>열고닫고하는구조)
key:value 형식인 JSON 형식으로 더 많이 사용되고 있음.

스프링에서 문자를 반환할 때 >
@Responsebody에 따라 http응답에 데이터를 return
스프링에서 객체를 반환할때 >
json 형식으로 데이터를 만들어서 http 응답에 반응하는 것이 기본 정책

(2)-3. 정리하기 - 강의자료 참고 ★

@ResponseBody 를 사용
HTTP의 BODY에 문자 내용을 직접 반환
viewResolver 대신에 HttpMessageConverter 가 동작
기본 문자처리: StringHttpMessageConverter
기본 객체처리: MappingJackson2HttpMessageConverter
byte 처리 등등 기타 여러 HttpMessageConverter가 기본으로 등록되어 있음

참고: 클라이언트의 HTTP Accept 해더와 서버의 컨트롤러 반환 타입 정보 둘을 조합해서 HttpMessageConverter 가 선택된다. 더 자세한 내용은 스프링 MVC 강의에서 설명하겠다

728x90

[240615] Method

westwith 2024. 6. 18. 23:52

2024. 6. 18. 23:52

728x90

0. 김영한님의 자바 강의 듣는 공부 일지

강의 주소 :

[지금 무료] 김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 | 김영한 - 인프런

김영한 | 프로그래밍에 처음 입문하는 분들을 위한 자바 강의입니다. 코드를 따라하면서 손쉽게 자바를 배울 수 있습니다., 국내 개발 분야 누적 수강생 1위, 제대로 만든 김영한의 자바 입문[사

www.inflearn.com

1. 메서드

메서드 시작

package method; // 패키지 선언

public class Method1 { // 클래스 Method1 시작
    public static void main(String[] args) { // main 메서드 시작
        //계산1
        int a = 1;
        int b = 2;
        System.out.println(a + "+" + b + "연산 수행");

        int sum1 = a + b;
        System.out.println("결과1 출력: " + sum1);

        //계산2
        int x = 10;
        int y = 20;
        System.out.println(x + "+" + y + "연산 수행");

        int sum2 = x + y;
        System.out.println("결과1 출력: " + sum2);

    } // main 메서드 끝
} // 클래스 Method1 끝
---
1+2연산 수행
결과1 출력: 3
10+20연산 수행
결과1 출력: 30

메서드 사용

package method; // 패키지 선언

public class Method1Ref { // 클래스 Method1Ref 시작
    public static void main(String[] args) { // main 메서드 시작
        int sum1 = add(5, 10);
        System.out.println("결과1 출력 = " + sum1);

        int sum2 = add(15, 20);
        System.out.println("결과2 출력 = " + sum2);
    } // main 메서드 끝

    //add메서드
    public static int add(int a, int b) {
        System.out.println(a + "+" + b + "연산 수행");
        int sum = a + b;
        return sum;
    }
} // 클래스 Method1Ref 끝
---
5+10연산 수행
결과1 출력 = 15
15+20연산 수행
결과2 출력 = 35

메서드 호출과 용어정리

- 인수

- 매개변수

메서드 정의

-제어자

- 반환타입

- 메서드 이름

- 매개변수

- 메서드 본문

매개변수가 없거나 반환타입이 없는 경우

// 매개변수가 없고 반환타입이 없는 경우
package method;

public class Method2 {
    public static void main(String[] args) { //main 메서드 시작
        printHeader();
        System.out.println("program on");
        printFooter();

    }

    public static void printHeader() {
        System.out.println("program start");
        return; //void의 경우 생략 가능
    }

    public static void printFooter() {
        System.out.println("program finish");
    }
}
---
program start
program on
program finish

2. 반환 타입

(1) 반환 타입이 있으면 반드시 값을 반환해야 한다.

package method;

public class MethodReturn1 {
    public static void main(String[] args) {
        boolean result = odd(2);
        System.out.println(result);
    }

    public static boolean odd(int i) {
        if (i % 2 == 1) {
            return true;
        } else { // 조건을 만족하지 않아도 else를 통해 false를 반환하는 return문이 실행됨
            return false;
        }
    }
}
---
false

(2) return 문을 만나면 그 즉시 메서드를 빠져나간다.

package method;

public class MethodReturn2 {
    public static void main(String[] args) {
        checkAge(10);
        checkAge(20);
    }

    public static void checkAge(int age) {
        if (age < 18) {
            System.out.println(age + "살, 미성년자는 출입이 불가능합니다.");
            return;
        }
        System.out.println(age + "살, 입장하세요");
    }
}
---
10살, 미성년자는 출입이 불가능합니다.
20살, 입장하세요

3. 메서드 호출과 값 전달

자바는 항상 변수의 값을 복사해서 대입한다.

(1) 변수와 값 복사

package method;

public class MethodValue0 {
    public static void main(String[] args) {
        int num1 = 5;
        int num2 = num1;
        num2 = 10;
        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
    }
}
---
num1 = 5
num2 = 10

(2) 메서드 호출과 값 복사

package method;

public class MethodValue1 {
    public static void main(String[] args) {
        int num1 = 5;
        System.out.println("1, changeNumber 호출 전, num1: " + num1);
        changeNumber(num1);
        System.out.println("4, changeNumber 호출 후, num1: " + num1);

    }

    public static void changeNumber(int num2) {
        System.out.println("2. changeNumber 변경 전, num2: " + num2);
        num2 = num2 * 2;
        System.out.println("3, changeNumber 변경 후, num2: " + num2);
        
    }
}
---
1, changeNumber 호출 전, num1: 5
2. changeNumber 변경 전, num2: 5
3, changeNumber 변경 후, num2: 10
4, changeNumber 호출 후, num1: 5

(3) 메서드 호출과 이름이 같은 변수

// 이름이 같아도 다른 변수
package method;

public class MethodValue2 {
    public static void main(String[] args) {
        int number = 5;
        System.out.println("1, changeNumber 호출 전, number: " + number);
        changeNumber(number);
        System.out.println("4, changeNumber 호출 후, number: " + number);

    }

    public static void changeNumber(int number) {
        System.out.println("2. changeNumber 변경 전, number: " + number);
        number = number * 2;
        System.out.println("3, changeNumber 변경 후, number: " + number);

    }
}
---
1, changeNumber 호출 전, number: 5
2. changeNumber 변경 전, number: 5
3, changeNumber 변경 후, number: 10
4, changeNumber 호출 후, number: 5

(4) 메서드 호출과 값 반환받기

package method;

public class MethodValue3 {
    public static void main(String[] args) {
        int num1 = 5;
        System.out.println("changeNumber 호출 전, num1: " + num1);
        num1 = changeNumber(num1);
        System.out.println("changeNumber 호출 후, num1: " + num1);

    }

    public static int changeNumber(int num2) {
        num2 = num2 * 2;
        return num2;
    }
}
---
changeNumber 호출 전, num1: 5
changeNumber 호출 후, num1: 10

4. 메서드와 형변환

(1) 명시적 형변환

package method;

public class MethodCasting1 {
    public static void main(String[] args) {
        double number = 1.5;
        // printNumber(number);
        printNumber((int) number);
    }

    public static void printNumber(int n) {
        System.out.println("숫자 : " + n);
    }
}
---
숫자 : 1

(2) 자동 형변환

package method;

public class MethodCasting2 {
    public static void main(String[] args) {
        int number = 100;
        printNumber(number); // int에서 double로 자동 형변환
    }

    public static void printNumber(double n) {
        System.out.println("숫자 : " + n);
    }
}

---
숫자 : 100.0

5. 메서드 오버로딩

매개변수의 갯수가 다른 오버로딩

package method;

public class MethodOverloading1 {
    public static void main(String[] args) {
        System.out.println("1: " + add(1, 2));
        System.out.println("2: " + add(1, 2, 3));
    }

    // 첫번째 add 메서드 : 두 정수를 받아서 합을 반환함
    public static int add(int a, int b) {
        System.out.println("1번 호출");
        return a + b;
    }

    // 두번째 add 메서드 : 세 정수를 받아서 합을 반환함
    // 첫번째 메서드와 이름은 같지만, 매개변수 목록이 다르다
    public static int add(int a, int b, int c) {
        System.out.println("2번 호출");
        return a + b + c;
    }
}
---
1번 호출
1: 3
2번 호출
2: 6

매개변수의 타입이 다른 오버로딩

package method;

public class MethodOverloading2 {
    public static void main(String[] args) {
        myMethod(1, 1.2);
        myMethod(1.2, 2);
    }

    public static void myMethod(int a, double b) {
        System.out.println("int a, double b");
    }

    public static void myMethod(double a, int b) {
        System.out.println("double a, int b");
    }
}
---
int a, double b
double a, int b

package method;

public class MethodOverloading3 {
    public static void main(String[] args) {
        System.out.println("1: " + add(1, 2));
        System.out.println("2: " + add(1.2, 1.5));
    }

    // 첫번째 add 메서드 : 두 정수를 받아서 합을 반환함
    public static int add(int a, int b) {
        System.out.println("1번 호출");
        return a + b;
    }

    // 두번째 add 메서드 : 세 정수를 받아서 합을 반환함
    // 첫번째 메서드와 이름은 같지만, 매개변수 유형이 다르다
    public static double add(double a, double b) {
        System.out.println("2번 호출");
        return a + b;
    }
}
---
1번 호출
1: 3
2번 호출
2: 2.7

6. 문제 풀이

7. 정리

<오늘의 단축키>

⭐ 한 줄 복사 (ctl + D)

⭐ psvm (public static void main)

⭐ sout (systemout.println)

728x90

'Computer Language > JAVA' 카테고리의 다른 글

[240615] Array (0)	2024.06.15
[240614] Scanner (0)	2024.06.14
[240614] Scope & Casting (0)	2024.06.14
[240614] Loop (1)	2024.06.14
[240611] Conditional Statements (0)	2024.06.14

[240615] Array

westwith 2024. 6. 15. 19:11

2024. 6. 15. 19:11

728x90

0. 김영한님의 자바 강의 듣는 공부 일지

강의 주소 :

[지금 무료] 김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 | 김영한 - 인프런

www.inflearn.com

1. 배열

배열 시작

package array; // 패키지 선언

public class Array1 { // 클래스 Array1 시작
    public static void main(String[] args) { // main 메서드 시작
        int student1 = 90;
        int student2 = 80;
        int student3 = 70;
        int student4 = 60;
        int student5 = 50;

        System.out.println("학생1 점수 : " + student1);
        System.out.println("학생2 점수 : " + student2);
        System.out.println("학생3 점수 : " + student3);
        System.out.println("학생4 점수 : " + student4);
        System.out.println("학생5 점수 : " + student5);


    } // main 메서드 끝
} // 클래스 Array1 끝
---
학생1 점수 : 90
학생2 점수 : 80
학생3 점수 : 70
학생4 점수 : 60
학생5 점수 : 50

배열의 선언과 생성

package array; // 패키지 선언

public class Array1Ref1 { //클래스 Array1Ref1 시작
    public static void main(String[] args) { // main 메서드 시작
        int[] students; //배열 변수 선언
        students = new int[5];

        // 변수 값 대입
        students[0] = 90;
        students[1] = 80;
        students[2] = 70;
        students[3] = 60;
        students[4] = 50;

        // 변수 값 사용
        System.out.println("학생1 점수 :" + students[0]);
        System.out.println("학생2 점수 :" + students[1]);
        System.out.println("학생3 점수 :" + students[2]);
        System.out.println("학생4 점수 :" + students[3]);
        System.out.println("학생5 점수 :" + students[4]);

    } // main 메서드 끝
} // 클래스 Array1Ref1 끝
---
학생1 점수 :90
학생2 점수 :80
학생3 점수 :70
학생4 점수 :60
학생5 점수 :50

배열 리펙토링

package array; // 패캐지 선언

public class Array1Ref2 { // 클래스 Array1Ref2 시작
    public static void main(String[] args) { // main 메서드 시작
        int[] students; // 배열 변수 선언

        students = new int[5]; // 배열 생성

        // 변수 값 대입
        students[0] = 90;
        students[1] = 80;
        students[2] = 70;
        students[3] = 60;
        students[4] = 50;

        // 변수 값 사용
        for (int i = 0; i < students.length; i++) {
            System.out.println("학생" + (i + 1) + "점수 :" + students[i]);
        }

    } // main 메서드 끝
} // 클래스 ArrayRef2 끝
---
학생1점수 :90
학생2점수 :80
학생3점수 :70
학생4점수 :60
학생5점수 :50

package array; // 패키지 선언

public class Array1Ref3 { // 클래스 Array1Ref3 시작
    public static void main(String[] args) { // main 메서드 시작
        int[] students;
        students = new int[]{90, 80, 70, 60, 50}; // 배열 생성과 초기화

        for (int i = 0; i < students.length; i++) {
            System.out.println("학생" + (i+1) + "점수 : " + students[i]);
        }
    } // main 메서드 끝
} // 클래스 Array1Ref3 끝
---
학생1점수 : 90
학생2점수 : 80
학생3점수 : 70
학생4점수 : 60
학생5점수 : 50

2. 2차원 배열

package array; // 패키지 선언

public class ArrayDi0 { // 클래스 ArrayDi0 시작
    public static void main(String[] args) { // main 메서드 시작
        // 2X3 2차원 배열을 만든다.
        int[][] arr = new int[2][3]; // 행(row), 열(column)

        arr[0][0] = 1; //0행, 0열
        arr[0][1] = 2; //0행, 1열
        arr[0][2] = 3; //0행, 2열
        arr[1][0] = 4; //1행, 0열
        arr[1][1] = 5; //1행, 1열
        arr[1][2] = 6; //1행, 2열

        // 0행 출력
        System.out.print(arr[0][0] + " "); // 0열 출력
        System.out.print(arr[0][1] + " "); // 0열 출력
        System.out.print(arr[0][2] + " "); // 0열 출력
        System.out.println(); // 한 행이 끝나면 라인을 변경한다.


        // 1행 출력
        System.out.print(arr[1][0] + " "); // 0열 출력
        System.out.print(arr[1][1] + " "); // 0열 출력
        System.out.print(arr[1][2] + " "); // 0열 출력
        System.out.println(); // 한 행이 끝나면 라인을 변경한다.

    } // main 메서드 끝
} // 클래스 ArrayDi0 끝
---
1 2 3  // 0행 출력 [0][0] [0][1] [0][2]
4 5 6  // 1행 출력 [1][0] [1][1] [1][2]

리펙토링1 - 구조개선 : 행 출력 반복

package array; // 패키지 선언

public class ArrayDi1 { // 클래스 ArrayDi1 시작
    public static void main(String[] args) { // main 메서드 시작
        // 2X3 2차원 배열을 만든다.
        int[][] arr = new int[2][3]; // 행(row), 열(column)

        arr[0][0] = 1; //0행, 0열
        arr[0][1] = 2; //0행, 1열
        arr[0][2] = 3; //0행, 2열
        arr[1][0] = 4; //1행, 0열
        arr[1][1] = 5; //1행, 1열
        arr[1][2] = 6; //1행, 2열

        for (int row = 0; row < 2; row++) {
            System.out.print(arr[row][0] + " "); // 0열 출력
            System.out.print(arr[row][1] + " "); // 1열 출력
            System.out.print(arr[row][2] + " "); // 2열 출력
            System.out.println(); // 한 행이 끝나면 라인을 변경함
        }

    } // main 메서드 끝
} // 클래스 ArrayDi1 끝
---
1 2 3 
4 5 6

리펙토링1 - 구조개선 : 열 출력 반복

package array; // 패키지 선언

public class ArrayDi2 { // 클래스 ArrayDi2 시작
    public static void main(String[] args) { // main 메서드 시작
        // 2X3 2차원 배열을 만든다.
        int[][] arr = new int[2][3]; // 행(row), 열(column)

        arr[0][0] = 1; //0행, 0열
        arr[0][1] = 2; //0행, 1열
        arr[0][2] = 3; //0행, 2열
        arr[1][0] = 4; //1행, 0열
        arr[1][1] = 5; //1행, 1열
        arr[1][2] = 6; //1행, 2열

        for (int row = 0; row < 2; row++) {
            for (int colume = 0; colume < 3; colume++) {
                System.out.print(arr[row][colume] + " ");
            }
            System.out.println(); // 한 행이 끝나면 라인을 변경한다.
        }
    } // main 메서드 끝
} // 클래스 ArrayDi2 끝
---
1 2 3 
4 5 6

리펙토링2 - 구조개선 : 초기화, 배열의 길이

package array; // 패키지 선언

public class ArrayDi3 { // 클래스 ArrayDi3 시작
    public static void main(String[] args) { // main 메서드 시작
        // 2X3 2차열 배열, 초기화
        int[][] arr = {
                {1, 2, 3},
                {4, 5, 6}
        };
        
        // 2차원 배열의 길이를 활용
        for (int row = 0; row < arr.length; row++) {
            for (int column = 0; column < arr[row].length; column++) {
                System.out.print(arr[row][column] + " ");
            }
            System.out.println();
        }
    } // main 메서드 끝
} // 클래스 ArrayDi3 끝
---
1 2 3 
4 5 6

리펙토링2 - 구조개선 : 값 입력

package array; // 패키지 선언

public class ArrayDi4 { // 클래스 ArrayDi4 시작
    public static void main(String[] args) { // main 메서드 시작
        // 2X3 2차원 배열, 초기화
        int[][] arr = new int[4][5];

        int i = 1;
        //순서대로 1씩 증가하는 값을 입력한다.
        for (int row = 0; row < arr.length; row++ ) {
            for (int colunm = 0; colunm < arr[row].length; colunm++) {
                arr[row][colunm] = i++;
            }
        }

        // 2차원 배열의 길이를 활용
        for (int row = 0; row < arr.length; row++) {
            for (int column = 0; column < arr[row].length; column++) {
                System.out.print(arr[row][column] + " ");
            }
            System.out.println(); // 한 행이 끝나면 라인을 변경한다.
        }

    } // main 메서드 끝

} // 클래스 ArrayDi4
---
1 2 3 4 5 
6 7 8 9 10 
11 12 13 14 15 
16 17 18 19 20

3. 향상된 for문

package array; // 패키지 선언

public class EnhancedFor1 { // 클래스 EnhancedFor1 시작
    public static void main(String[] args) { // main 메서드 시작
        int[] numbers = {1, 2, 3, 4, 5};

        //일반 for문
        for (int i = 0; i < numbers.length; ++i) {
            int number = numbers[i];
            System.out.println(number);
        }

        //향상된 for문
        for (int number : numbers) {
            System.out.println(number);
        }

        //for-each 문을 사용할 수 없는 경우, 증가하는 index 값 필요
        for (int i = 0; i < numbers.length; ++i) {
            System.out.println("number" + i + "번의 결과는 " + numbers[i]);
        }


    } // main 메서드 끝
} // 클래스 EnhancedFor1 끝
---
1
2
3
4
5
1
2
3
4
5
number0번의 결과는 1
number1번의 결과는 2
number2번의 결과는 3
number3번의 결과는 4
number4번의 결과는 5

4. 문제풀이

5. 정리

<오늘의 단축키>

⭐ 한 줄 복사 (ctl + D)

⭐ psvm (public static void main)

⭐ sout (systemout.println)

728x90

'Computer Language > JAVA' 카테고리의 다른 글

[240615] Method (0)	2024.06.18
[240614] Scanner (0)	2024.06.14
[240614] Scope & Casting (0)	2024.06.14
[240614] Loop (1)	2024.06.14
[240611] Conditional Statements (0)	2024.06.14

[240614] Scanner

westwith 2024. 6. 14. 17:03

2024. 6. 14. 17:03

728x90

0. 김영한님의 자바 강의 듣는 공부 일지

강의 주소 :

[지금 무료] 김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 | 김영한 - 인프런

www.inflearn.com

1. Scanner

package scanner; // 패키지 선언

import java.util.Scanner;

public class Scanner1 { // 클래스 Scanner1 시작
    public static void main(String[] args) { // main 메서드 시작
        Scanner scanner = new Scanner(System.in);

        System.out.println("문자열을 입력하세요: ");
        String str = scanner.nextLine(); // 입력을 String으로 가져옵니다.
        System.out.println("입력한 문자열 : " + str);

        System.out.println("정수을 입력하세요: ");
        int intValue = scanner.nextInt(); // 입력을 int로 가져옵니다.
        System.out.println("입력한 정수 : " + str);

        System.out.println("실수를 입력하세요: ");
        double doubleVaule = scanner.nextDouble(); //입력을 double로 가져옵니다.
        System.out.println("입력한 실수 : " + doubleVaule);

    } // main 메서드 끝
} // 클래스 Scanner1 끝
---
문자열을 입력하세요: 
taylor
입력한 문자열 : taylor
정수을 입력하세요: 
1989
입력한 정수 : 1989
실수를 입력하세요: 
12.13
입력한 실수 : 12.13
---
문자열을 입력하세요: 
hello
입력한 문자열 : hello
정수을 입력하세요: 
10
입력한 정수 : 10
실수를 입력하세요: 
1.5
입력한 실수 : 1.5

package scanner; // 패키지 선언

import java.util.Scanner;

public class Scanner2 { // 클래스 Scanner2 시작
    public static void main(String[] args) { // main 메서드 시작
        Scanner scanner = new Scanner(System.in);

        System.out.println("첫 번째 숫자를 입력하세요:");
        int num1 = scanner.nextInt();

        System.out.println("두 번째 숫자를 입력하세요:");
        int num2 = scanner.nextInt();

        int sum = num1 + num2;
        System.out.println("두 숫자의 합: " + sum);

    } // main 메서드 끝
} // 클래스 Scanner2 끝

---
첫 번째 숫자를 입력하세요:
10
두 번째 숫자를 입력하세요:
20
두 숫자의 합: 30

package scanner; // 패키지 선언

import java.util.Scanner;

public class Scanner3 { // 클래스 Scanner3 시작
    public static void main(String[] args) { // main 메서드 시작
        Scanner scanner = new Scanner(System.in);

        System.out.println("첫 번쨰 숫자를 입력하세요:");
        int num1 = scanner.nextInt();

        System.out.println("두 번째 숫자를 입력하세요:");
        int num2 = scanner.nextInt();

        if (num1 > num2) {
            System.out.println("더 큰 숫자 :" +  num1);
        } else if (num2 > num1) {
            System.out.println("더 큰 숫자 :" + num2);
        } else {
            System.out.println("두 숫자는 같습니다");
        }
    } // main 메서드 끝
} // 클래스 Scanner3 끝
---
첫 번쨰 숫자를 입력하세요:
10
두 번째 숫자를 입력하세요:
20
더 큰 숫자 :20
---
첫 번쨰 숫자를 입력하세요:
5
두 번째 숫자를 입력하세요:
5
두 숫자는 같습니다

Scanner 반복예제

package scanner; // 패키지 선언

import java.sql.SQLOutput;
import java.util.Scanner;

public class ScannerWhile1 { // 클래스 ScannerWhile1 시작
    public static void main(String[] args) { // main 메서드 시작
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("문자열을 입력하세요(exit: 종료) : ");
            String str = scanner.nextLine();

            if (str.equals("exit")) {
                System.out.println("프로그램을 종료합니다");
                break;
            }
            System.out.println("입력한 문자열 : " + str);
        }
    } // main 메서드 끝
} // 클래스 ScannerWhile1 끝
---
문자열을 입력하세요(exit: 종료) : 
hello
입력한 문자열 : hello
문자열을 입력하세요(exit: 종료) : 
안녕?
입력한 문자열 : 안녕?
문자열을 입력하세요(exit: 종료) : 
exit
프로그램을 종료합니다

package scanner; // 패키지 선언

import java.util.Scanner;

public class ScannerWhile2 { // 클래스 ScannerWhile2 시작
    public static void main(String[] args) { // main 메서드 시작
        Scanner scanner = new Scanner(System.in);

        System.out.println("첫 번째 숫자와 두 번째 숫자 모두 0을 입력하면 프로그램을 종료합니다");
        while (true) {
            System.out.println("첫 번째 숫자를 입력하세요:");
            int num1 = scanner.nextInt();

            System.out.println("두 번째 숫자를 입력하세요:");
            int num2 = scanner.nextInt();

            if (num1 == 0 && num2 == 0) {
                System.out.println("프로그램 종료");
                break;
            }
            int sum = num1 + num2;
            System.out.println("두 숫자의 합 :" + sum);
        }
    } // main 메서드 끝
} // 클래스 ScannerWhile2 끝

---
첫 번째 숫자와 두 번째 숫자 모두 0을 입력하면 프로그램을 종료합니다
첫 번째 숫자를 입력하세요:
10
두 번째 숫자를 입력하세요:
20
두 숫자의 합 :30
첫 번째 숫자를 입력하세요:
0
두 번째 숫자를 입력하세요:
0
프로그램 종료

package scanner; // 패키지 선언

import java.util.Scanner;

public class ScannerWhile3 { // 클래스 ScannerWhile3 시작
    public static void main(String[] args) { // main 메서드 시작
        Scanner input = new Scanner(System.in);

        int sum = 0;

        while (true) {
            System.out.print("정수를 입력하세요 (0을 입력하면 종료) : ");
            int number = input.nextInt();

            if (number == 0) {
                break;
            }
            sum += number;
        }
        System.out.println("입력한 모든 정수의 합 : " + sum);
    } // main 메서드 끝
} // 클래스 ScannerWhile3 끝

---
정수를 입력하세요 (0을 입력하면 종료) : 1
정수를 입력하세요 (0을 입력하면 종료) : 2
정수를 입력하세요 (0을 입력하면 종료) : 3
정수를 입력하세요 (0을 입력하면 종료) : 0
입력한 모든 정수의 합 : 6

2. 문제풀이

3. 정리

<오늘의 단축키>

⭐ 한 줄 복사 (ctl + D)

⭐ psvm (public static void main)

⭐ sout (systemout.println)

728x90

'Computer Language > JAVA' 카테고리의 다른 글

[240615] Method (0)	2024.06.18
[240615] Array (0)	2024.06.15
[240614] Scope & Casting (0)	2024.06.14
[240614] Loop (1)	2024.06.14
[240611] Conditional Statements (0)	2024.06.14

[240614] Scope & Casting

westwith 2024. 6. 14. 16:11

2024. 6. 14. 16:11

728x90

0. 김영한님의 자바 강의 듣는 공부 일지

강의 주소 :

[지금 무료] 김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 | 김영한 - 인프런

www.inflearn.com

1. Scope - 지역 변수와 스코프

스코프 : 변수의 접근 가능한 범위

package scope; //패키지 선언

public class Scope1 { // 클래스 Scope1 시작
    public static void main(String[] args) { // main 메서드 시작
        int m = 10; // m 생존시작
        if (true) {
            int x = 20; // x 생존 시작
            System.out.println("if m =" + m); // 블록 내부에서 블록 외부는 접근 가능
            System.out.println("if x =" + x);
        } // x 생존 종료

        //System.out.println("main x = " + x); // 오류, 변수 x에 접근 불가
        System.out.println("main m = " + m);

    } // main 메서드 끝
} // 클래스 Scope1 끝

---
if m =10
if x =20
main m = 10

package scope; // 패키지 선언

public class Scope2 { // 클래스 Scope2 시작
    public static void main(String[] args) { // main 메서드 시작
        int m = 10;
        for (int i = 0; i < 2; i++) { // 블록 내부, for문 내
            System.out.println("for m =" + m); // 블록 내부에서 외부는 접근 가능
            System.out.println("for i =" + i);
        } // i 생존 종료
        //System.out.println("main i = " + i); //오류 , i에 접근 불가
        System.out.println("main m =" + m);
    } // main 메서드 끝
} // 클래스 Scope2 끝
---
for m =10
for i =0
for m =10
for i =1
main m =10

2. Scope - 스코프 존재 이유

//비효율적인 메모리 사용
//코드 복잡성 증가
package scope; // 패키지 선언

public class Scope3_1 { // 클래스 Scope3_1 시작
    public static void main(String[] args) { // main 메서드 시작
        int m = 10;
        int temp = 0;
        if (m > 0) {
            temp = m * 2;
            System.out.println("temp = " + temp);
        }
        System.out.println("m =" + m);
    } // main 메서드 끝
} // 클래스 Scope3_1 끝
---
temp = 20
m =10

// temp의 스코프를 꼭 필요한 곳으로 한정
package scope; // 패키지 선언

public class Scope3_2 { // 클래스 Scope3_2
    public static void main(String[] args) { // main 메서드 시작
        int m = 10;
        if (m > 0) {
            int temp = m * 2; // if 블록 안에서 선언, temp의 스코프가 if 블록 안으로 줄어듦
            System.out.println("temp =" + temp);
        }
        System.out.println("m =" + m);
    } // main 메서드 끝
} // 클래스 Scope3_2 끝

---
temp =20
m =10

3. 형변환

작은 범위에서 큰 범위로 대입은 허용.

(1) 자동 형변환

package casting; // 패키지 선언

public class Casting1 { // 클래스 Casting 시작
    public static void main(String[] args) { // main 메서드 시작
         int intValue = 10;
         long longValue;
         double doubleValue;

         longValue = intValue; // int -> long
        System.out.println("longValue = " + longValue);

        doubleValue = intValue; // int -> double
        System.out.println("doubleValue1 = " + doubleValue); // doubleValue1 = 10.0

        doubleValue = 20L; // long -> double
        System.out.println("doubleValue2 = " + doubleValue); // doubleValue2 = 20.0
    } // main 메서드 끝
} // 클래스 Casting 끝
---
longValue = 10
doubleValue1 = 10.0
doubleValue2 = 20.0

큰 범위에서 작은 범위 대입은 명시적 형변환이 필요.

(2) 명시적 형변환

package casting; // 패키지 선언

public class Casting2 { // 클래스 Casting2 시작
    public static void main(String[] args) {  // main 메서드 시작
        double doubleValue = 1.5;
        int intValue = 0;

        //intValue = doubleValue; // 컴파일 오류 발생
        intValue = (int) doubleValue; // 형변환
        System.out.println(intValue); // 출력:1

    } // main 메서드 끝
} // 클래스 Casting2 끝

---
1

- 형변환과 오버플로우

package casting; // 패키지 선언

public class casting3 { // //클래스 casting3 시작
    public static void main(String[] args) { // main 메서드 시작
        long maxIntValue = 2147483647; //int 최고값
        long maxIntOver = 2147483648L; //int 최고값 + 1 (초과)
        int intValue = 0;

        intValue = (int) maxIntValue; //형변환
        System.out.println("maxIntValue casting = " + intValue); // 출력:2147483647

        intValue = (int) maxIntOver; //형변환
        System.out.println("maxIntOver casting = " + intValue); // 출력:-2147483648
    } // main 메서드 끝
} // 클래스 casting3 끝
---
maxIntValue casting = 2147483647
maxIntOver casting = -2147483648 //int의 가장 작은 값부터 다시 시작, 오버플로우

4. 계산과 형변환

< 자바에서 계산은 다음 2가지를 기억할 것>

1. 같은 타입끼리의 계산은 같은 타입의 결과를 낸다.

2. 서로 다른 타입의 계산은 큰 범위로 자동 형변환이 일어난다.

ex) int + long => long + long , int + double => double + double

package casting; // 패키지 선언

public class Casting4 { // 클래스 Casting4 시작
    public static void main(String[] args) { // main 메서드 시작
        int div1 = 3 / 2;
        System.out.println("div1 = " + div1); //1

        double div2 = 3 / 2;
        System.out.println("div2 = " + div2); //1.0

        double div3 = 3.0 / 2;
        System.out.println("div3 = " + div3); //1.5

        double div4 = (double) 3 / 2;
        System.out.println("div4 = " + div4); //1.5

        int a = 3;
        int b = 2;
        double result = (double) a / b;
        System.out.println("result = " + result); //1.5
    } // main 메서드 끝
} // 클래스 Casting4 끝
---
div1 = 1
div2 = 1.0
div3 = 1.5
div4 = 1.5
result = 1.5

5. 정리

<오늘의 단축키>

⭐ 한 줄 복사 (ctl + D)

⭐ psvm (public static void main)

⭐ sout (systemout.println)

728x90

'Computer Language > JAVA' 카테고리의 다른 글

[240615] Array (0)	2024.06.15
[240614] Scanner (0)	2024.06.14
[240614] Loop (1)	2024.06.14
[240611] Conditional Statements (0)	2024.06.14
[240610] Operator (1)	2024.06.11

[240614] Loop

westwith 2024. 6. 14. 12:57

2024. 6. 14. 12:57

728x90

0. 김영한님의 자바 강의 듣는 공부 일지

강의 주소 :

[지금 무료] 김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 | 김영한 - 인프런

www.inflearn.com

1. while문

package loop; //패키지 선언

public class While1_1 { // 클래스 While1_1 시작
    public static void main(String[] args) { // main 메서드 시작
        int count = 0;
        count = count + 1;
        System.out.println("현재 숫자는 : " + count);
        count = count + 1;
        System.out.println("현재 숫자는 : " + count);
        count = count + 1;
        System.out.println("현재 숫자는 : " + count);

        //증감연산자를 이용한 개선
        count++;
        System.out.println("현재 숫자는 : " + count);
        count++;
        System.out.println("현재 숫자는 : " + count);
        count++;
        System.out.println("현재 숫자는 : " + count);

    } // main 메서드 끝
} // 클래스 Whiel1_1 끝
---
현재 숫자는 : 1
현재 숫자는 : 2
현재 숫자는 : 3
현재 숫자는 : 4
현재 숫자는 : 5
현재 숫자는 : 6

package loop; // 패키지 선언

public class While1_2 { // 클래스 While1_2 시작
    public static void main(String[] args) { // main 메서드 시작
        int count = 0;

        while (count < 3) {
            count++;
            System.out.println("현재 숫자는 : "+ count);
        }
    } // main 메서드 끝
} // 클래스 While1_2 끝
---
현재 숫자는 : 1
현재 숫자는 : 2
현재 숫자는 : 3

//while문 사용하지 않고
package loop; // 패키지 선언

public class While2_1 { // 클래스 While2_1
    public static void main(String[] args) { // main 메서드 시작
        int sum = 0;
        sum = sum + 1; // sum(0) + 1 -> sum(1)
        System.out.println("i=" + 1 + " sum=" + sum);
        sum = sum + 2; // sum(1) + 2 -> sum(3)
        System.out.println("i=" + 2 + " sum=" + sum);
        sum = sum + 3; // sum(3) + 3 -> sum(6)
        System.out.println("i=" + 3 + " sum=" + sum);
    } // main 메서드 끝
} // 클래스 While2_1 끝
---
i=1 sum=1
i=2 sum=3
i=3 sum=6

package loop; // 패키지 선언

public class While2_2 { // 클래스 While2_2 시작
    public static void main(String[] args) { // main 메서드 시작
        int sum = 0;
        int i = 1;

        sum = sum + i; // sum(0) + i(1) -> sum(1)
        System.out.println("i=" + i + " sum=" + sum);
        i++; // i=2

        sum = sum + i; // sum(1) + i(2) -> sum(3)
        System.out.println("i=" + i + " sum=" + sum);
        i++; // i=3

        sum = sum + i; // sum(3) + i(3) -> sum(6)
        System.out.println("i=" + i + " sum=" + sum);
    } // main 메서드 끝
} // 클래스 While2_2 끝
---
i=1 sum=1
i=2 sum=3
i=3 sum=6

package loop; // 패키지 선언

public class While2_3 { // 클래스 While2_3 시작
    public static void main(String[] args) { // main 메서드 시작
        int sum = 0;
        int i = 1;
        int endNum = 10;

        /*
        sum = sum + i;
        System.out.println("i=" + i + " sum=" + sum);
        i++;

        sum = sum + i;
        System.out.println("i=" + i + " sum=" + sum);
        i++;

        sum = sum + i;
        System.out.println("i=" + i + " sum=" + sum);
        i++;
        */

        //코드 변경
        while (i <= endNum) {
            sum = sum + i;
            System.out.println("i=" + i + " sum=" + sum);
            i++;
        }

    } // main 매서드 끝
} // 클래스 While2_3 끝
---
i=1 sum=1
i=2 sum=3
i=3 sum=6
i=4 sum=10
i=5 sum=15
i=6 sum=21
i=7 sum=28
i=8 sum=36
i=9 sum=45
i=10 sum=55

2. do-while 문

//while문
package loop; // 패키지 선언

public class DoWhile1 { // 클래스 DoWhile1 시작
    public static void main(String[] args) { // main 메서드 시작
        int i = 10;
        while (i < 3) {
            System.out.println("현재 숫자는 : " + i);
            i++;
        }

    } // main 메서드 끝
} // 클래스 DoWhile1 끝

---
//출력결과 없음

package loop; //패키지 선언

public class DoWhile2 { // 클래스 DoWhile2 시작
    public static void main(String[] args) { // main 메서드 시작
        int i = 10;
        do {
            System.out.println("현재 숫자는 : " + i);
            i++;
        } while (i < 3);
    } // main 메서드 끝
} // 클래스 DoWhile2 끝
---
현재 숫자는 : 10

3. break, continue

break : 반복문을 즉시 종료하고 나감
continue : 반복문의 나머지 부분을 건너뛰고 다음 반복으로 진행하는데 사용

package loop; // 패키지 선언

public class Break1 { // 클래스 Break1 시작
    public static void main(String[] args) { // main 메서드 시작
        int sum = 0;
        int i = 1;

        while (true) {
            sum += i;
            if (sum > 10) {
                System.out.println("합이 10보다 크면 종료 : i=" + i + " sum=" + sum);
                break;
            }
            i++;
        } //while문 끝

    } // main 매서드 끝
} // 클래스 Break1 끝

---
합이 10보다 크면 종료 : i=5 sum=15

package loop; // 패키지 선언

public class Continue1 { // 클래스 Continue1 시작
    public static void main(String[] args) { // main 메서드 시작
        int i = 1;

        while (i <= 5) {
            if (i == 3) {
                i++;
                continue;
            }
            System.out.println(i);
            i++;
        }
    } // main 메서드 끝
} // 클래스 Continue1 끝
---
1
2
4
5

4. for 문

package loop; // 패키지 선언
 
public class For1 { // 클래스 For1 시작
    public static void main(String[] args) { // main 메서드 시작
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
        
    } // main 메서드 끝
} // 클래스 For1 끝

package loop; // 패키지 선언

public class For2 { // 클래스 For2 시작
    public static void main(String[] args) { // main 메서드 시작
        int sum = 0;
        int endNum = 3;

        for (int i = 1; i <= endNum; i++) {
            sum = sum + i;
            System.out.println("i=" + i + " sum=" + sum);
        }
    } // main 매서드 끝
} // 클래스 For2 끝

---
i=1 sum=1
i=2 sum=3
i=3 sum=6

//break1 while문을 for문으로바꾸기
package loop; // 패키지 선언

public class Break2 { // 클래스 Break2 시작
    public static void main(String[] args) { // main 메서드 시작
        int sum = 0;
        int i = 1;

        for (; ;) {
            sum += i;
            if (sum > 10) {
                System.out.println("합이 10보다 크면 종료 : i=" + i + " sum=" + sum);
                break;
            }
            i++;
        }
    } // main 메서드 끝
} // 클래스 Break2 끝

--
합이 10보다 크면 종료 : i=5 sum=15

//코드개선
package loop; // 패키지 선언

public class Break3 { // 클래스 Break3 시작
    public static void main(String[] args) { // main 메서드 시작
        int sum = 0;
        for (int i = 1; ; i++) {
            sum += i;
            if (sum > 10) {
                System.out.println("합이 10보다 크면 종료: i=" + i + " sum=" + sum);
                break;
            }
        }

    } // main 메서드 끝
} // 클래스 Break3 끝

---
//반복횟수가 정해진 경우에는 for문을 사용하는것이 구조적으로 깔끔하고 유지보수에 좋다
합이 10보다 크면 종료: i=5 sum=15

5. 중첩 반복문

package loop; //패키지 선어

public class Nested1 { // 클래스 Nested1 시작
    public static void main(String[] args) { // main 메서드 시작
        for (int i = 0; i < 2; i++) {
            System.out.println("외부 for 시작 i:" + i);
            for (int j = 0; j < 3; j++) {
                System.out.println("-> 내부 for" + i + "-" + j);
            }
            System.out.println("외부 for 종료 i:" + i);
            System.out.println(); //라인 구분을 위해 실행 (줄바꿈)
        }
    } // main 메서드 끝
} // 클래스 Nested1 끝

---
외부 for 시작 i:0
-> 내부 for0-0
-> 내부 for0-1
-> 내부 for0-2
외부 for 종료 i:0

외부 for 시작 i:1
-> 내부 for1-0
-> 내부 for1-1
-> 내부 for1-2
외부 for 종료 i:1

6. 문제 풀이

7. 정리

<오늘의 단축키>

⭐ 한 줄 복사 (ctl + D)

⭐ psvm (public static void main)

⭐ sout (systemout.println)

728x90

'Computer Language > JAVA' 카테고리의 다른 글

[240614] Scanner (0)	2024.06.14
[240614] Scope & Casting (0)	2024.06.14
[240611] Conditional Statements (0)	2024.06.14
[240610] Operator (1)	2024.06.11
[240610] Variable (1)	2024.06.10

[240611] Conditional Statements

westwith 2024. 6. 14. 11:44

2024. 6. 14. 11:44

728x90

0. 김영한님의 자바 강의 듣는 공부 일지

강의 주소 :

[지금 무료] 김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 | 김영한 - 인프런

www.inflearn.com

1. if문 1 - if , else

// if문 2개 사용
package cond; //패키지 선언

public class If1 { // 클래스 If1 시작
    public static void main(String[] args) { // main 메서드 시작
        int age = 20; // 사용자 나이

        if (age >= 18) {
            System.out.println("성인입니다.");
        }

        if (age < 18){
            System.out.println("미성년자입니다.");
        }
        

    } // main 메서드 끝
} // 클래스 If1 끝

---
성인입니다.

// else를 사용해서 if 1개만 사용하기
package cond; //패키지 선언

public class If2 { // 클래스 If2 시작
    public static void main(String[] args) { // main 메서드 시작
        int age = 20; //사용자 나이

        if (age >= 18) {
            System.out.println("성인입니다"); //참일때 실행
        } else {
            System.out.println("미성년자입니다"); // 만족하는 조건이 없을때 실행
        }
    } // main 메서드 끝
} // 클래스 If2 끝

---
성인입니다

// 불필요한 조건 검사 및 코드의 효율성이 떨어지는 예시
package cond; // 패키지 선언

public class If3 { // 클래스 If3 시작
    public static void main(String[] args) { // main 메서드 시작
        int age = 14; //사용자 나이

        if (age <= 7) {
            System.out.println("미취학");
        }

        if (age >= 8 && age <= 13) {
            System.out.println("초등햑생");
        }

        if (age >= 14 && age <= 16) {
            System.out.println("중학생");
        }

        if (age >= 17 && age <= 19) {
            System.out.println("고등학생");
        }

        if (age >= 8 && age <= 16) {
            System.out.println("성인");
        }
    } // main 매서드 끝
} // 클래스 If3 끝
---

2. if문 2 - else if

package cond; // 패키지 선언

public class If4 { // 클래스 If4 시작
    public static void main(String[] args) { // main 함수 시작
        int age =14;
        if(age <= 7){ // ~7: 미취학
            System.out.println("미취학");
        } else if (age <= 13) { // 8~13: 초등학생
            System.out.println("초등학생");
        } else if (age <= 16) { // 14~16: 중학생
            System.out.println("중학생");
        } else if (age <= 19) { // 17~19 : 고등학생
            System.out.println("고등학생");
        } else { // 20~ : 성인
            System.out.println("성인");
        }

    } // main 함수 끝
} // 클래스 If4 끝

---
중학생

3. if문 3 - if문과 else if문

if-else 사용 : 서로 연관된 조건이어서, 하나로 묶을때
if 각각 사용 : 독립조건일때

//독립조건일때, if문 각각 사용
package cond; // 패키지 선언

public class If5 { // 클래스 If5 시작
    public static void main(String[] args) { // main 메서드 시작
        int price = 10000;
        int age = 10;
        int discount = 0;

        if (price >= 10000) {
            discount = discount + 1000;
            System.out.println("10000원 이상 구매, 1000원 할인");
        }

        if (age <= 10) {
            discount = discount + 1000;
            System.out.println("어린이 1000원 할인");
        }
        System.out.println("총 할인 금액 :" + discount+ "원" ) ;
    } // main 메서드 끝
} // 클래스 If5 끝
---
10000원 이상 구매, 1000원 할인
어린이 1000원 할인
총 할인 금액 :2000원

//독립조건에서 else if를 사용하게 된다면
package cond; // 패키지 선언

public class If6 { // 클래스 If6 시작
    public static void main(String[] args) { // main 메서드 시작
        int price = 10000;
        int age = 10;
        int discount = 0;

        if (price >= 10000) {
            discount = discount + 1000;
            System.out.println("10000원 이상 구매, 1000원 할인");
        } else if (age <= 10) { //앞선 if에서 참이면 실행하지 않고 if문을 빠져나감
            discount = discount + 1000;
            System.out.println("어린이 1000원 할인");
        } else {
            System.out.println("할인없음");
        }
        System.out.println("총 할인 금액 :" + discount+ "원" ) ;
    } // main 메서드 끝
} // 클래스 If6 끝

---
10000원 이상 구매, 1000원 할인
총 할인 금액 :1000원

4. switch문

//우선 if문으로 풀어보기
package cond; // 패키지 선언

public class Switch1 { //클래스 Switch1 시작
    public static void main(String[] args) { // main 함수 시작
        //grade 1:1000 , 2:2000 ,  3:3000 , 나머지: 500
        int grade = 2;

        int coupon;
        if (grade == 1) {
            coupon = 1000;
        } else if (grade == 2) {
            coupon = 2000;
        } else if (grade == 3) {
            coupon = 3000;
        } else {
            coupon = 500;
        }
        System.out.println("발급받은 쿠폰: " + coupon);

    } // main 함수 끝
} // 클래스 Switch1 끝
---
발급받은 쿠폰: 2000

//Switch1을 Switch문으로 풀어보기
package cond; // 패키지 선언

public class Switch2 { // 클래스 Switch2 시작
    public static void main(String[] args) { // main 메서드 시작
        // grade 1:1000, 2:2000, 3:3000, 나머지:500
        int grade = 2;
        int coupon;

        switch (grade) {
            case  1:
                coupon = 1000;
                break;
            case 2:
                coupon = 2000;
                break;
            case 3:
                coupon = 3000;
                break;
            default:
                coupon = 500;
        }
        System.out.println( "발급받은 쿠폰 : " + coupon);

    } // main 메서드 끝
} // 클래스 Switch2 끝

//case에 break가 없을떄
package cond; //패키지 선언

public class Switch3 { // 클래스 Switch3 시작
    public static void main(String[] args) { // main 메서드 시작
        //grade 1:1000, 2:2000, 3:3000, 나머지:500
        int grade = 2;
        int coupon;
        switch (grade) {
            case 1:
                coupon = 1000;
                break;
            case 2:
            case 3:
                coupon = 3000;
                break;
            default:
                coupon = 500;
                break;
        }
        System.out.println("발급받은 쿠폰 : " + coupon);

    } // main 메서드 끝
} // 클래스 Switch3 끝

--- 
발급받은 쿠폰 : 3000

- 참고 : 자바14 새로운 Switch문

5. 삼항 연산자

삼항 연산자(조건 연산자) : 참과 거짓에 따라서 특정 값을 구하는 경우 -> ?

(조건)? 참_표현식 : 거짓_표현식

package cond; // 패키지 선언

public class CondOp1 { // 클래스 CondOp1 시작
    public static void main(String[] args) { // main 메서드 시작
        int age = 18;
        String status;
        if (age <= 18) {
            status = "성인";
        } else {
            status = "미성년자";
        }

        System.out.println("age = " + age + " status = " + status);
    } // main 메서드 끝
} // 클래스 CondOp1 끝

---
age = 18 status = 성인

//삼항연산자 사용
package cond; // 패키지 선언

public class CondOp2 { // 클래스 CondOp2 시작
    public static void main(String[] args) { // main 메서드 시작
        int age = 18;
        String status = (age >= 18)? "성인" : "미성년자";
        System.out.println("age = " + age + " status = " + status);
    } // main 메서드 끝
} // 클래스 CondOp2 끝
---
age = 18 status = 성인

6. 문제풀이

package cond;

public class ScoreEx {
    public static void main(String[] args) {
        int score = 55;

        // 불필요한 조건...을 쓰지 않도록 하자
        if (score >= 90) {
            System.out.println("학점은 A입니다.");
        } else if (score < 90 && score >= 80) {
            System.out.println("학점은 B입니다.");
        } else if (score < 80 && score >= 70) {
            System.out.println("학점은 C입니다.");
        } else if (score < 70 && score >= 60) {
            System.out.println("학점은 D입니다.");
        } else if (score < 60) {
            System.out.println("학점은 F입니다.");
        }

        /*
        if (score >= 90) {
            System.out.println("학점은 A입니다.");
        } else if (score >= 80) {
            System.out.println("학점은 B입니다.");
        } else if (score >= 70) {
            System.out.println("학점은 C입니다.");
        } else if (score >= 60) {
            System.out.println("학점은 D입니다.");
        } else {
            System.out.println("학점은 F입니다.");
        }
        */

    }
}

package cond;

public class DistanceEx {
    public static void main(String[] args) {
        int distance = 150;

        if (distance <= 1) {
            System.out.println("도보");
        } else if (distance <= 10) {
            System.out.println("자전거");
        } else if (distance <= 100) {
            System.out.println("자동차");
        } else if (distance > 100) {
            System.out.println("비행기");
        }
    }
}

package cond;

public class ExchangeRate {
    public static void main(String[] args) {
        int dollar = 10;
        if (dollar < 0) {
            System.out.println("잘못된 금액입니다");
        } else if (dollar == 0){
            System.out.println("환전할 금액이 없습니다.");
        } else if (dollar > 0) {
            int result = dollar*1300;
            System.out.println("환전금액은 " + result + "원 입니다.");
        }
    }
}

package cond;

public class MovieRateEx {
    public static void main(String[] args) {
        double rating = 7.0;
        if(rating <= 9){
            System.out.println("어바웃타임을 추천합니다");
        }
        if(rating <= 8){
            System.out.println("토이스토리을 추천합니다");
        }
        if(rating <= 7){
            System.out.println("고질라을 추천합니다");
        }
    }
}

package cond;

public class GradeSwitchEx {
    public static void main(String[] args) {
        String grade = "G";
        switch (grade) {
            case "A":
                System.out.println(grade + ": 탁월한 성과입니다");
                break;
            case "B":
                System.out.println(grade + ": 좋은 성과입니다");
                break;
            case "C":
                System.out.println(grade + ": 준수한 성과입니다");
                break;
            case "D":
                System.out.println(grade + ": 향상이 필요합니다");
                break;
            case "F":
                System.out.println(grade + ": 불합격입니다");
                break;
            default:
                System.out.println(grade + ": 잘못된 학점입니다");
                break;
        }
    }
}

package cond;

public class CondOpEx {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        int result = (a > b)? a : b;
        System.out.println("result : " + result);
    }
}

package cond;

public class EvenOddEx {
    public static void main(String[] args) {
        int x = 3;
        String result = (x % 2 == 0) ? "짝수" : "홀수";
        System.out.println("출력: x =" + x +" , "+ result );
    }
}

7. 정리

<오늘의 단축키>

⭐ 한 줄 복사 (ctl + D)

⭐ psvm (public static void main)

⭐ sout (systemout.println)

728x90

'Computer Language > JAVA' 카테고리의 다른 글

[240614] Scope & Casting (0)	2024.06.14
[240614] Loop (1)	2024.06.14
[240610] Operator (1)	2024.06.11
[240610] Variable (1)	2024.06.10
[240608] Hello Java (1)	2024.06.08

[240610] Operator

westwith 2024. 6. 11. 00:38

2024. 6. 11. 00:38

728x90

0. 김영한님의 자바 강의 듣는 공부 일지

강의 주소 :

[지금 무료] 김영한의 자바 입문 - 코드로 시작하는 자바 첫걸음 | 김영한 - 인프런

www.inflearn.com

1. 산술 연산자

+ , - , * , /, %

package operator; //패키지 선언

public class Operator1 { //클래스 Operator1 시작
    public static void main(String[] args) { //main 매서드 시작
        //변수 초기화
        int a = 5;
        int b = 2;

        //덧셈
        int sum = a + b;
        System.out.println("a + b = " + sum); //출력 a + b = 7

        //뺄셈
        int diff = a - b;
        System.out.println("a - b = " + diff);

        //곱셈
        int multi = a * b;
        System.out.println("a * b = " + multi);

        //나눗셈
        int div = a / b; //int 형 계산에서 소숫점 표기 불가
        System.out.println("a / b = " + div);

        //나머지
        int mod = a % b;
        System.out.println("a % b = " + mod);
    } // main 매서드 끝
} // 클래스 Operator1 끝
---
a + b = 7
a - b = 3
a * b = 10
a / b = 2
a % b = 1

2. 문자열 더하기

자바는 문자열에도 + 연산을 사용할 수 있음
자바에서 문자와 숫자를 더하면 숫자를 문자열로 변경한 다음에 서로 더함
- 문자열에 더하는 것은 다 문자열이 됨

package operator; //패키지 선언

public class Operator2 { //클래스 Operator2 시작
    public static void main(String[] args) { // main 매서드 시작

        //문자열과 문자열 더하기1
        String result1 = "hello" + "world";
        System.out.println(result1);

        //문자열과 문자열 더하기2
        String s1 = "string1";
        String s2 = "string2";
        String result2 = s1 + s2;
        System.out.println(result2);

        //문자열과 숫자 더하기1
        String result3 = "a + b =" + 10;
        System.out.println(result3);

        //문자열과 숫자 더하기2
        int num = 20;
        String str = "a + b =";
        String result4 = str + num;
        System.out.println(result4);

    } // main 매서드 끝
} // 클래스 Operator2 끝
---
helloworld
string1string2
a + b =10
a + b =20

3. 연산자 우선순위

package operator; //패키지 선언

public class Operator3 { // 클래스 Operator3 시작
    public static void main(String[] args) { // main 매서드 시작
        int sum1 = 1 + 2 * 3; // 1 + (2 * 3)
        int sum2 = (1 + 2) * 3;
        System.out.println("sum1 = " + sum1); // 7
        System.out.println("sum2 = " + sum2); // 9
    } // main 매서드 끝
} // 클래스 Operator3 끝
---
sum1 = 7
sum2 = 9

package operator; //패키지 선언

public class Operator4 { // 클래스 Operator4 시작
    public static void main(String[] args) { // main 매서드 시작
        int sum3 = 2 * 2 + 3 * 3; // (2 * 2) + (3 * 3)
        int sum4 = (2 * 2) + (3 * 3); //sum3과 같다
        System.out.println("sum3 = " + sum3);
        System.out.println("sum4 = " + sum4);
        //복잡하면 괄호를 넣는게 낫다
    } // main 매서드 끝
} // 클래스 Opterator4 끝

---
sum3 = 13
sum4 = 13

연산이 복잡하면 괄호를 넣는게 낫다

<연산자 우선순위 암기법>

1. 상식선에서 우선순위를 생각하자

2. 애매하면 괄호()를 사용하자

4. 증감 연산자

++ , --

package operator; //패키지 선언

public class OperatorAdd1 { //클래스 OperatorAdd1 시작
    public static void main(String[] args) { // main 매서드 시작
        int a = 0;

        a = a + 1;
        System.out.println("a =" + a); //1

        a = a + 1;
        System.out.println("a =" + a); //2

        //증감연산자
        ++a; // a = a + 1;
        System.out.println("a = " + a); //3
        ++a; // a = a + 1;
        System.out.println("a = " + a); //4


    } // main 매서드 끝
} // 클래스 OperatorAdd1 끝

---
a =1
a =2
a = 3
a = 4

전위/후위 증감연산자
=> ++a , a++

package operator; //패키지 선언

public class OperatorAdd2 { // 클래스 OperatorAdd2 시작
    public static void main(String[] args) { // main 매서드 시작
        //전위 증감 연산자 사용 예
        int a = 1;
        int b = 0;
        
        b = ++a; // a의 값으 먼저 증가시키고 , 그 결과를 b에 대입
        System.out.println("a = " + a + ",b = " + b);

        //후위 증감 연산자 사용 예
        a = 1; //a 값을 다시 1으로 지정
        b = 0; //b 값을 다시 0으로 지정

        b = a++; //a 의 현재 값을 b에 먼저 대입하고, 그 후 a값을 증가시킴
        System.out.println("a = " + a +",b = " + b); // a = 2, b = 1

    } // main 매서드 끝
} // 클래스 OperatorAdd2 끝
---
a = 2,b = 2
a = 2,b = 1

5. 비교 연산자

== , != , > , < , >= , <=
결과는 참(true) 이나 거짓(false)이 나옴, boolean형을 사용

package operator; // 패키지 선언

public class Comp1 { // 클래스 Comp1 시작
    public static void main(String[] args) { // main 매서드 시작
        int a = 2;
        int b = 3;
        System.out.println(a == b); // false, a와 b는 같지 않음
        System.out.println(a != b); // true, a와 b는 다르다
        System.out.println(a > b); // false , a는 b보다 크지 않다.
        System.out.println(a < b); // true, a는 b보다 작다
        System.out.println(a >= b); // false, a는 b보다 크거나 같지 않다
        System.out.println(a <= b); // true, a는 b보다 작거자 같다.

        //결과는 boolean 변수에 담기
        boolean result = a == b; // a == b : false
        System.out.println(result); //false

    } // main 매서드 끝
} // 클래스 Comp1 끝
---
false
true
false
true
false
true
false

문자열 비교
.equals() 메서드 사용

package operator; // 패키지 선언

public class Comp2 { // 클래스 Comp2 시작
    public static void main(String[] args) { //main 메서드 시작
        String str1 = "문자열1";
        String str2 = "문자열2";

        boolean result1 = "hello".equals("hello"); // 리터럴 비교
        boolean result2 = str1.equals("문자열1"); // 문자열 변수, 리터럴 비교
        boolean result3 = str1.equals(str2); // 문자열 변수 비교

        System.out.println(result1);
        System.out.println(result2);
        System.out.println(result3);


    } // main 메서드 끝
} // 클래스 Comp2 끝

---
true
true
false

6. 논리 연산자

&& , || , !

package operator; // 패키시 선언

public class Logical1 { //클래스 Logical1 시작
    public static void main(String[] args) { // main 메서드 시작
        System.out.println("&& : AND 연산");
        System.out.println(true && true); //true
        System.out.println(true && false); //false
        System.out.println(false && false); // false

        System.out.println("|| : OR 연산");
        System.out.println(true || true); //true
        System.out.println(true || false); //true
        System.out.println(false || false); //false

        System.out.println("! 연산");
        System.out.println(!true); //false
        System.out.println(!false); //true

        System.out.println("변수활용");
        boolean a = true;
        boolean b = false;
        System.out.println(a && b); //false
        System.out.println(a || b); //true
        System.out.println(!a); //false
        System.out.println(!b); //true
    } // main 메서드 끝
} // 클래스 Logical1 끝
---
&& : AND 연산
true
false
false
|| : OR 연산
true
true
false
! 연산
false
true
변수활용
false
true
false
true

package operator; //패키지 선언

public class Logical2 { //클래스 Logical2 시작
    public static void main(String[] args) { //main 메서드 시작
        int a = 15;
        // a는 10보다 크고 20보다 작다
        boolean result = a > 10 && a < 20; // ( a > 10) && ( a < 20 )
        System.out.println("result =" + result);
    } // main 메서드 끝
} // 클래스 Logical2 끝
---
result =true

7. 대입 연산자

축약(복합) 대입 연산자 : += , -= , *=, /= , %=

package operator; // 패키지 선언

public class Assign1 { //클래스 Assign1 시작
    public static void main(String[] args) { // main 메서드 시작
        int a = 5; //5
        a += 3; //8
        a -= 2; //6
        a *= 4; //24
        a /= 3; //8
        a %= 5; //3
        System.out.println(a); //3
    } // main 메서드 끝
} // 클래스 Assign1 끝
---
3

8. 문제와 풀이

package operator; //패키지 선언

public class OperationEx1 { //클래스 OperationEx1 시작
    public static void main(String[] args) { // main 메서드 시작
        int num1 = 10;
        int num2 = 20;
        int num3 = 30;

        int sum = num1 + num2 + num3 ;
        int average = (sum)/3;

        System.out.println("sum = " + sum);
        System.out.println("average = " + average);
    } // main 메서드 끝
} // 클래스 OperationEx1 끝
---
sum = 60
average = 20

package operator; // 패키지 선언

public class OperationEx2 { // 클래스 OperationEx2 시작
    public static void main(String[] args) { // main 메서드 시작
        double val1 = 1.5;
        double val2 = 2.5;
        double val3 = 3.5;
        
        double sum = val1 + val2 + val3;
        double average = sum/3;

        System.out.println("sum = " + sum);
        System.out.println("average = " + average);
        
    } // main 메서드 끝
} // 클래스 OperationEx2 끝

---
sum = 7.5
average = 2.5

package operator; // 패키지 선언

public class OperationEx3 { //클래스 OperationEx3 시작
    public static void main(String[] args) { // main 메서드 시작
        int score = 80;
        System.out.println( 80 <= score && score <= 100);

        /* 정답예시
        boolean result = score >= 80 && score <= 100;
        System.out.println(result);
        */
    } // main 메서드 끝
} // 클래스 OperationEx3

---
true

<오늘의 단축키> *Window 기준

⭐ 한 줄 복사 (ctl + D)

⭐ 한 줄 삭제 (ctl + Y)

⭐ 마지막에 실행한 것을 다시 실행 (ctl + R)

⭐ ctl + shift + F10

⭐ 줄 끝에 세미콜론 ( ctl + shift + enter)

⭐ psvm (public static void main)

⭐ sout (system.out.println)

⭐ soutv (value)

728x90

'Computer Language > JAVA' 카테고리의 다른 글

[240614] Scope & Casting (0)	2024.06.14
[240614] Loop (1)	2024.06.14
[240611] Conditional Statements (0)	2024.06.14
[240610] Variable (1)	2024.06.10
[240608] Hello Java (1)	2024.06.08

PREV 이전 1 2 NEXT 다음