gayeong.log

한국어 깨짐

Sun, 27 Oct 2024 18:30:44 GMT

인텔리제이에서 입력을 한국어로 작성하면 글자가 깨져서 영어로 작성함. -> 낼 때 영어로 작성해서 냄

우테코 프리코스 진짜 답(한국어로).

package racingcar;

import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Application {
    public static void main(String[] args) {
        //Todo 프로그램 구현
        Scanner scanner = new Scanner(System.in);

        try {
            System.out.println("경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)");
            String inputNames = scanner.nextLine();
            List carNames = validateCarNames(inputNames);

            System.out.println("시도할 횟수는 몇 회인가요?");
            int moves = Integer.parseInt(scanner.nextLine());

            Racing racing = new Racing(carNames);
            racing.startRace(moves);
            List winners = racing.getWinners();
            System.out.println("최종 우승자 : " + String.join(", ", winners));

        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }

    private static List validateCarNames(String inputNames) {
        List carNames = Arrays.stream(inputNames.split(","))
                .map(String::trim)
                .collect(Collectors.toList());

        if (carNames.isEmpty() || carNames.stream().anyMatch(name -> name.length() > 5)) {
            throw new IllegalArgumentException("자동차 이름은 5자 이하로 입력해야 합니다.");
        }

        return carNames;
    }
}

package racingcar;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

public class Racing {
    private final List cars;
    private static final int FORWARD_THRESHOLD = 4;
    private final Random random;
    private boolean isFirstRound = true; // 첫 번째 라운드인지 확인하는 변수

    public Racing(List carNames) {
        this.cars = carNames.stream()
                .map(Car::new)
                .collect(Collectors.toList());
        this.random = new Random();
    }

    public void startRace(int moves) {
        for (int i = 0; i < moves; i++) {
            for (Car car : cars) {
                if (random.nextInt(10) >= FORWARD_THRESHOLD) {
                    car.move();
                }
            }
            displayRaceStatus();
        }
    }

    private void displayRaceStatus() {
        if (isFirstRound) {
            System.out.println("실행 결과");
            isFirstRound = false;
        }

        for (Car car : cars) {
            System.out.println(car.getName() + " : " + "-".repeat(car.getPosition()));
        }
        System.out.println();
    }

    public List getWinners() {
        int maxPosition = cars.stream()
                .mapToInt(Car::getPosition)
                .max()
                .orElse(0);

        return cars.stream()
                .filter(car -> car.getPosition() == maxPosition)
                .map(Car::getName)
                .collect(Collectors.toList());
    }

    private static class Car {
        private final String name;
        private int position;

        public Car(String name) {
            this.name = name;
            this.position = 0;
        }

        public String getName() {
            return name;
        }

        public int getPosition() {
            return position;
        }

        public void move() {
            position++;
        }
    }
}

pwd

src/main/java/racingcar/Application.java src/main/java/racingcar/Racing.java

[Error] 윈도우11 WSL 에러

Thu, 17 Oct 2024 09:14:56 GMT

PowerShell에서 wsl 관련 명령어를 치면 이런 에러가 발생했습니다.

해결하기 위해 윈도우에서 WSL 관련된 것들을 모두 삭제하였습니다.

WSL 완전히 삭제

1. 리눅스 배포판 제거

'설정->앱->앱 및 기능'을 간다 설치되어 있는 배포판 제거

2. wsl 제거

Windows Subsystem for Linux Update와 같이 관련 항목들을 제거한다.

3. window11에서 wsl 제거

'제어판-프로그램 및 기능 - windows 기능 켜기/끄기'로 간다 'Linux용 Windows 하위 시스템'을 선택 해제 후 확인을 누른다. 그리고 컴퓨터를 재부팅 하면 wsl이 완전히 삭제되어 있다.

WSL 비활성화

1. PowerShell(관리자 권한)에서 WSL 기능을 완전히 비활성화

.\dism.exe /online /disable-feature /featurename:Microsoft-Windows-Subsystem-Linux /norestart

2. 가상 머신 플랫폼 비활성화 (WSL 2 사용 시)

.\dism.exe /online /disable-feature /featurename:VirtualMachinePlatform /norestart

3. 컴퓨터 재부팅

4. WSL 상태 확인

wsl --status

만약 WSL 기능이 여전히 활성화되어 있다면, WSL 관련 구성 요소가 완전히 제거되지 않은 것이므로, 제어판의 "프로그램 및 기능" > "Windows 기능 켜기/끄기" 메뉴로 이동하여 "Windows Subsystem for Linux"가 체크 해제되었는지 확인하세요

wsl --status 명령어를 실행했을 때 아무 출력도 없는 경우, WSL이 제대로 제거되었을 가능성이 높습니다

그래도 안 된다면 wsl 명령어 앞에 .\를 넣어보세요!

WSL 설치

wsl --install

객체 지향 설계의 5가지 원칙

Sun, 29 Sep 2024 16:14:33 GMT

1. SRP : 단일 책임 원칙 (single responsibility principle)

한 클래스는 하나의 책임만 가져야 한다.
하나의 책임이라는 것은 모호하다.
클 수 있고, 작을 수 있다.
문맥과 상황에 따라 다르다.
중요한 기준은 변경이다. 변경이 있을 떄 파급 효과가 적으면 단일 책임 원칙을 잘 따른 것이다.
예) UI 변경, 객체의 생성과 사용을 분리

2. OCP : 개방-폐쇄 원칙 (Open/Closed principle)

소프트웨어 요소는 확장에는 열려 있으나 변경에는 닫혀 있어야 한다.
이런 거짓말 같은 말이? 확장을 하려면, 당연히 기존 코드를 변경?
다형성을 활용
인터페이스를 구현한 새로운 클래스를 하나 만들어서 새로운 기능을 구현
역할과 구현의 분리를 생각

문제점

MemberService 클라이언트가 구현 클래스를 직접 선택
MemberRepository m = new MemoryMemberRepository(); //기존코드
MemberRepository m = new JdbcMemberRepository();  //변경코드

**구현 객체를 변경하려면 클라이언트 코드를 변경해야 한다.**
**분명 다형성을 사용했지만 OCP 원칙을 지킬 수 없다.**
해결 : 객체를 생성하고, 연관관계를 맺어주는 별도의 조립, 설정자가 필요

-------

### 3. LSP : 리스코프 치환 원칙 (Liskov substitution principle)
- 프로그램 객체는 프로그램의 정확성을 깨뜨리지 않으면서 하위 타입의 인스턴스로 바꿀 수 있어야 한다. 
- 다형성에서 하위 클래스는 인터페이스 규약을 다 지켜야 한다는 것, 다형성을 지원하기 위한 원칙, 인터페이스를 구현한 구현체는 믿고 사용하려면, 이 원칙이 필요
- 단순히 컴파일에 성공하는 것을 넘어선다.
- 예) 자동차 인터페이스의 엑셀을 앞으로 가라는 기능, 뒤로 가게 구현하aus LSP 위반, 느리더라도 앞으로 가야함

-----


### 4. ISP : 인터페이스 분리 원칙 (Interface segregation principle)
- 특정 클라이언트를 위한 인터페이스 여러 개가 범용 인터페이스 하나보다 낫다.
- 자동차 인터페이스 -> 운전 인터페이스, 정비 인터페이스로 분리
- 사용자 클라이언트 -> 운전자 클라이언트, 정비사 클라이언트로 분리
- 분리하면 정비 인터페이스 자체가 변해도 운전자 클라이언트에 영향을 주지 않음
- 인터페이스가 명확해지고, 대체 가능성이 높아진다.

-----

### 5. DIP : 의존관계 역전 원칙 (Dependency inversion principle)
- 프로그래머는 "추상화에 의존해야지, 구체화에 의존하면 안된다." 의존성 주입은 이 원칙을 따르는 방법 중 하나다.
- 쉽게 얘기해서 구현 클래스에 의존하지 말고, 인터페이스에 의존해라
- **역할(Role)에 의존해야 한다는 것과 같다.** 객체 세상도 클라이언트가 인터페이스에 의존해야 유연하게 구현체를 변경할 수 있다. 구현체에 의존하게 되면 변경이 아주 어려워진다. 
- 그런데 OCP에서 설명한 MemberService는 인터페이스에 의존하지만, 구현 클래스도 동시에 의존한다. 
- MemberService 클라이언트가 구현 클래스를 직접 선택

```java
MemberRepository m = new MemoryMemberRepository(); //DIP가 구체화에 의존
// MemberRepository라는 추상화 인터페이스에 의존하고있다.
// 하지만 MemoryMemberRepository라는 구체화에도 의존하고 있어서 DIP위반이다.

DIP 위반 (=추상화에 의존, 구체화 의존X)

정리

객체 지향의 핵심은 다형성
다형성 만으로는 쉽게 부품을 갈아 끼우듯이 개발할 수 없다.
다형성 만으로는 구현 객체를 변경할 때 클라이언트 코드도 함께 변경된다.
다형성 만으로는 OCP, DIP를 지킬 수 없다.
더 필요

[JAVA] 클래스

Fri, 05 Jan 2024 04:24:07 GMT

클래스

객체

우리가 생각할 수 있는 어떤 사물이나 동물 ex) 컴퓨터, 모닡, 키보드, 마우스, 책, 선풍기, 가방... 등
클래스로부터 만들어지는 것

객체지향 프로그래밍

객체들끼리 서로 어우러진 형태로 프로그램을 구성
Java는 객체지향 프로그래밍 언어이고 이런 객체지향 프로그래밍 언어는 특징이 작성한 코드에 변경이 필요할 때 굉장히 편리하다. + 유지보수 용이, 높은 재사용성

Black Box Class

만든 이유 : 4개의 서로 다른 데이터를 한꺼번에 관리하고자 만듦

String modelName2 = "하양이";
String resolution2 = "UHD";
int price2 = 300000;
String color2 = "화이트";

블랙박스라는 클래스로부터 bbox라는 객체를 만드는 과정
```
BlackBox bbox = new BlackBox();
```

클래스

예를 들어 설명서나 설계도 같은 거
설계도를 클래스로 보면 되고 객체는 그 설계도로부터 만들어진 어떤 결과물이라 생각

인스턴스 변수

블랙박스라는 클래스는 이렇게 정의하는 것을 인스턴스 변수라고 한다.

public class BlackBox{
    String modelName;
    String resolution;
    int price;
    String color;
}

-> 4개의 인스턴스 변수를 가지게 되는 것이다.

밑에서 블랙박스 객체를 만듦

블랙박스 클래스로부터 b1이라는 객체가 만들어졌는데 이 객체가 가지고 있는 4가지 인스턴스 변수에 대해 각각 접근을 해서 값을 설정할 수 있다.
```
b1.modelName = "까망이";
...
```

클래스 변수

블랙박스가 기능이 굉장히 좋아 어떤 충돌이 있었을 때 그 충돌이 어떤 정해진 범위를 초과한다고 하면, 충돌이 컸다고 하면은 자동으로 경찰서에 신고를 해주는 기능을 추가
직전 30초 정도의 영상하고 지금 차량이 위치하고 있는 GPS 정보를 함께 전송해 주는 것이다.

메소드

메소드 오버로딩

같은 클래스 내에서 똑같은 이름을 가진 메소드를 파라미터의 개수나 파라미터의 타입을 다르게 함으로써 여러 개를 정의할 수 있다.
녹화를 하는 메소드
블랙박스를 보면 녹화를 할 때 어떤 정보들이 함께 표시가 되고 있다. 왼쪽 위에는 녹화를 하는 시간 정보, 왼쪽 아래는 그때 당시 속도를 표현하기도 한다. 오른쪽에는 현재 위치가 어딘지 gps 정보도 함께 표시를 하는 그런 장치들도 있다.
레코드라는 메소드를 만들어 처리

매개변수, 파라미터의 타입이 다르거나 또는 개수가 다르면 method of loading이 가능하다.

비슷한 동작을 서로 다른 코드로 별도로 작성을 하게 되면 여기에서 만약에 어떤 수정이 발생한다 그러면 또 찾아 가지고 바꿔야 하는 불편함이 있다.
밑에 있는 4줄을 다 지우고

-> 레코드 위에 있는 메소드를 호출해주면 된다. (레코드라는 메소드를 호출하는데 거기에다가 기본 값으로 true, showDateTime/showSpeed은 true, minute 정보는 5라고 넣어주면 이 레코드라는 메소드가 호출될 때 여기 내에서는 또 위에 있는 record라는 메소드를 다시 새롭게 호출하면서 여기의 동작을 가지고 위에서 적었는 print문 4줄에 해당하는 것을 똑같이 해줄 수 있다.

-> 레코드라는 메소드를 똑같은 동작을 2번 정의하지 않고 새롭게 메소드를 호출하는데 그때 값만 기본적으로 정의된 값을 던져주는 거고 그러면 이 객체를 통해서 메소드를 호출할 때는 아무 값을 몰라도 그냥 비워둔 채로 호출하게 되면 기본적인 값을 통해서 동작을 하게 된다.

클래스 메소드

블랙박스를 사용하다 만약에 어떤 문제가 생겼다. 그러면 블랙박스를 통해서 바로 고객센터에 전화를 할 수 있다. 원격으로 붙어서 조치를 해주던지 아니면 고객에게 직접 어떻게 하라고 안내를 해줄 수 있다.
고객센터에 전화하는 기능을 메소드로 만듦(모든 객체에 공통으로 사용)

*클래스 메소드를 사용할 때는 메소드 내에서 인스턴스 변수의 사용이 필요없는 경우에 공통적으로 적용되는 기능을 클래스 메소드를 사용해 볼 수 있을 것이다. *

String s = String.valueOf(3);

ctrl 누르고 valueOf누르면 알려줌
![](https://velog.velcdn.com/images/swk_x/post/89c4da31-4408-4e5d-ab9b-f36fab109a11/image.png)
String 앞에 static이 있다. -> 클래스 메소드로 정의됨.
valueOf라는 메소드는 결국 그냥 전달값으로 받은 이 i값만 가지고 어떤 처리를 하고 나서 반환을 해주는 것이다.
**-> 그러니까 string클래스 내에서 어떤 정의되어 있는 인스턴스 변수는 상관없이 전달받은 값 하나만 가지고 처리를 하고 결과를 내뱉어 준다.**
이런 경우에 인스턴스 메소드 대신에 클래스 메소드의 사용을 고려해 볼 수 있다.
- 일반적으로 만드는 메소드가 인스턴스 메소드이고 각 개체마다 서로 다른 동작을 하게 되고, static 키워드가 붙은 것은 클래스 메소드이다.
- 개체가 만들어지지 않고도 클래스 이름 점 그리고 이 메소드 이름으로 바로 접근해 볼 수 있다. 

![](https://velog.velcdn.com/images/swk_x/post/5f5eaad9-6276-47f5-9bc9-2bd963a339ae/image.png)
-> 이 둘의 차이를 알아야 한다

------------
## This
- 블랙박스 모델명이 까망이, 이런식으로 정의됨. 이렇게만 하니까 물건이 잘 안 팔림. 까망이 뒤에 (최신형) 이렇게 적으면 사람들이 주목해서 볼 수 있음. 
-> 모델명을 업데이트 하자
- 모델명 뒤에다가 바로 넣어줘도 되긴 하는데 그냥 블랙박스 하나의 클래스에 이걸 추가해주는 메소드를 정의 

![](https://velog.velcdn.com/images/swk_x/post/2d636a12-31ab-4e4a-9a43-792d560c261b/image.png)
-> 위 코드는 모델명을 추가하는 메소드다. 여기로 전달되는 model name을 원래 가지고 있는 modelName에 추가하면 알아보기가 더 편하다.



>### 메소드 보기
![](https://velog.velcdn.com/images/swk_x/post/ca7cf839-7647-4f1e-b742-0c48a1b6cb5d/image.png)
appendModelName 부분에 컨트롤 클릭하면 메소드로 바로 이동할 수 있고 아니면 이걸 클릭하고 ctrl+shift+i 누르면 이 메소드가 어떻게 생겼는지 볼 수 있다.
>> ```java
modelName += modelName;

앞에 있는 것은 클래스 인스턴스 변수로 만들어진 모델네임이고 뒤에 있는 모델네임은 전달값으로 전달받은 모델네임을 뜻한다.
이렇게만 두면 지금 메소드 내에서는 모델네임(앞)에다가 모델네임(뒤)을 다시 한번 더하는 즉, 최신형+최신형은 이라고 하고 끝나게 된다. 그러니까 인스턴스 변수 모델네임이 아니고 그냥 전달받은 파라미터 값을 한 번 더 업데이트를 하고 끝나게 된다.
모델네임(앞)을 파라미터가 아니고 이름이 똑같은 경우에는 클래스가 가지고 있는 인스턴스 변수의 모델네임을 명시하고 싶으면 앞에다가 this. 을 붙여주면 된다.
this. 을 붙여주면 클래스의 인스턴스 변수에 직접 바로 접근할 수 있게된다.
this.modelName(앞) : 클래스 인스턴스 변수 modelName(뒤) : 파라미터로 전달받은 모델네임

※인스턴스 변수하고 전달받은 파라미터의 변수이름이 똑같다면 앞에 this. 을 꼭 붙여줘야 한다!!!

생성자

생성자 : 객체가 만들어질 떄 자동으로 호출되는 메소드

생성자를 만드는 방법

클래스명과 똑같이 적어주면 된다.

생성자를 따로 정의를 해 가지고 한 번에 값을 바로 전달 받고, 그 값들을 인스턴스 변수에다가 직접 넣거나 또 다른 초기 작업을 생성자 내에서 할 수 있다. 그러면 객체를 만들 때마다 매번 인스턴스 변수에다가 값을 넣어주는 작업을 밑에서는 그냥 한 줄로 내 처리를 할 수 있다.

 BlackBox b2 = new BlackBox("하양이", "UHD", 300000, "화이트");

블랙박스에 시리얼 넘버라는 것을 넣기로 했다고 가정 (똑같은 제품이라 하더라도 각각 고유한 번호가 있다.)

기본 생성자

-> 처음으로 객체가 만들어질 때는 카운터 값이 0이었을 거니까 0에다가 ++해줘서 1이 들어간다. 그 다음에 새로운 객체가 만들어질 때는 카운터 값은 인스턴스 변수가 아니가 때문에 지금 1로 업데이터 되어 있는 상태인 거고 이거는 모든 객체에서 다 똑같이 공통적으로 사용되는 값이다. 그래서 1이었던 값이 2로 될 거고 또 새로운 기체를 만들면 3이 될 거고 그렇게 업데이트가 된다.

기본 생성자가 호출이 될 때는 시리얼 넘버를 자동으로 발급을 받게 된다. 그러면 생성자2를 호출하는 B2 객체인 경우에는 시리얼 넘버를 발급 못 받게 된다.

생성자2
생성자2를 호출할 때도 기본 생성자에서 하는 동작을 먼저 하고 나서 여기 생성자2의 동작을 하도록 처리해 줄 수 있다.
생성자2, 사용자 정의 생성자의 맨 첫 위치에 this()를 쓰면 된다.

this()

기본 생성자를 바로 접근. 기본 생성자의 동작을 그대로 수행하고 나서 아래쪽에 있는 생성자2의 동작을 하게 된다.

요약

생성자는 개체가 만들어질 때 자동으로 호출이 되는 부분. 기본적인 동작이 되는 부분이 있다고 하면 생성자에 명시를 해주면 되고 또는 개체가 생성됨과 동시에 우리가 전달하는 값으로 초기화를 하고자 할 때에도 생성자를 활용할 수가 있다. 그리고 생성자 간에도 서로를 호출하기 위해서는 this()를 활용할 수 있다.

Getter & Setter

Getter : 값을 가지고 오는 메소드 Setter : 값을 설정하는 메소드

만약 모델네임을 가져오는 메소드라면(Getter), (Setter)

isEmpty가 빈 문자일 때는 True가 된다. 그래서 값이 아예 없거나 아니면 값이 비어 있거나 이 둘 중에 하나라고 하면 리턴 해서 해결 가능
그러면 이 제품이 가지고 있는 객체 통해서 인스턴스 변수를 받아 왔을 때는 값을 알 수 없으니까 "판매자에게 문의하세요"라고 하면 일하는 직원을 통해 물어볼 수 있다.

요약

getter와 setter를 이용하게 되면 어떤 이상한 값이 들어간다던지 값 설정하다가 발생할 수 있는 오류를 줄일 수 있고 또 값을 가져오는 과정에서도 그 값이 없다거나 이상하다거나 할 때 대안으로 줄 수 있는 값을 설정할 수가 있다.

BlackBox.java code

접근 제어자

접근 제어자

private : 해당 클래스 내에서만 접근 가능
public : 모든 클래스에서 접근 가능 default : (아무것도 적지 않았을 때) 같은 패키지 내에서만 접근 가능 protected : 같은 패키지 내에서, 다른 패키지인 경우 자식 클래스에서 접근 가능

블랙박스 판매를 할 때 너무 할인을 크게 하기에는 아까워서 리퍼 제품에 대해서만 할인을 적용한다고 가정
BlackBoxRefurbish.java 파일

BlackBox를 Ctrl C + Ctrl R

위쪽에 뭐가 뜨는데 첫번째 부분에 붙여넣기를 하면 BlackBox라는 문구를 찾는다. 두번째 부분에 BlackBoxRefurbish를 치면, 위에 있는 소스코드에서 위에 있는 문구를 모두 찾아가지고 아래 문구로 한번에 바꿔달라는 의미가 된다. esc 누르면 창 닫힘 BlackBox -> BlackBoxRefurbish로 바꿈

가격을 -5000으로 설정하는 것을 못하게 하기 위해서는 프라이스 변수 앞에다가 접근 제어자 중에서 private을 붙여주면 된다.
Get Price와 Set Price만을 통해서 접근할 수 있다.
price라는 변수는 해당 클래스 내에서만 즉, BlackBoxRefurbish라는 클래스 내에서만 접근이 가능하다.

※ public은 어디서든지 접근 가능하다.

※ Default는 같은 패키지 내에서만 접근이 가능하다.

클래스에도 public을 붙이던지 또는 아무것도 붙이지 않은 디폴트 클래스일지를 통해 가지고 다른 패키지에서 접근 가능할 지 여부를 설정할 수 있다.
참고로 java 파일 내에서는 클래스를 여러 개 정의할 수 있다.
하지만 퍼블릭 클래스로 정의를 하게 되는 경우에는 반드시 java 파일명하고 똑같아야 된다.

캡슐화(Encapsulation)

서로 관련 있는 데이터 즉 변수 그리고 서로 관련 있는 기능들, 메소드를 블랙박스와 관련된 만큼만의 하나의 클래스로 정의하는 것

정보은닉(Information hiding)

정보를 숨기는 것
객체 내에 있는 어떤 변수나 메소드의 직접적인 접근을 막고 객체에서 허용해주는 형태로만 허용하는 메소드를 통해서만 접근이 가능하게 하는 것

-> 캡슐화, 정보은닉을 할 수 있게 해주는 게 접근 제어자, 주로 private을 통해 가지고 외부에서 접근을 못하도록 하는 거고 Getter와 Setter를 통해 가지고 어느 정도까지만 허용해가지고 사람들이 그걸 사용할 수 있도록 해주는 것이다.

BlackBoxRefurbish.java Code

패키지

어떤 폴더 구조
Java 클래스들을 비슷한 것들끼리 정리해주는 하나의 폴더
서로 연관된 클래스끼리 묶어두는 역할

import chap_07.BlackBoxRefurbish

-> chapter_07에 있는(다른 패키지에 있는) BlackBoxRefurbish이라는 클래스를 사용하겠다는 의미 ※위 코드가 없으면 바로 에러 발생

import chap_07.*;

-> 챕터 07에 있는 모든 클래스를 갖다 쓰겠다는 의미

Random Class

랜덤 클래스를 이용하면 어떤 값을 랜덤으로 뽑을 수 있게 된다.
랜덤 클래스를 쓰기 위해서는 대문자 R로 시작하는 랜덤 객체를 만들면 된다.
패키지 아래에 이 코드를 써줘야 Random 클래스를 쓸 수 있다.
쓰는 방법은 객체 이름을 랜덤으로 적어준다.
```
Random random = new Random();
```

상속

부모 클래스에서 제공되는 모든 것들을 자식 클래스에서 갖다 쓴다.

Camera code

기본적으로 사진을 촬영할 수 있고 또 동영상을 녹화할 수 있는 기본적인 동작을 수행

SpeedCam code_과속 단속 카메라

속도를 체크해서 만약 이 차가 과속이다라고 하면은 차량의 번호를 인식해 가지고 과태료를 부과하는 작업 추가

FactoryCam code_공장 카메라

화재 감지 기능 추가
화재 감지를 해 자동으로 119에 신고

-> 위 3개의 객체 생성

상속 쓰는 이유

기본적인 카메라 모듈에서 제공해주는 Take Picture, Record Video 라는 메소드는 카메라의 것을 그대로 갖다 쓴다.
공장 카메라에서 두 메소드는 카메라에 있는 것을 그대로 갖다 쓰고 추가적으로 화재 감지하는 기능만 따로 정의를 할 수 있다.
과속 단속 카메라 같은 경우에도 그대로 쓰고 속도 체크하는 부분과 번호 인식하는 기능만 추가해가지고 카메라를 만들면 더 편할 것이다.
그러면 문제가 생겼을 때 또는 수정이 필요할 때도 카메라 내에서 한쪽만 수정을 하게 되면 factoryCam과 SpeedCam도 여기 있는 기능을 그대로 쓰기 때문에 함께 수정사항이 적용되는 효과를 볼 수 있다.
이럴 때 사용하는 것이 바로 상속이다.*

상속 하기 위해서는??

상속 관계에서 기능을 물려주는 입장이 되는 클래스가 부모 클래스이다. 그리고 이 기능들을 물려받는 클래스가 자식 클래스이다.
카메라 : 부모 클래스
팩토리 캠과 스피드 캠은 이 카메라의 기능을 그대로 이어받아서 쓰게 되는 자식 클래스가 된다.
팩토리 캠과 스피드 캠에서 카메라를 상속하기 위해서는 클래스 명 팩토리 캠 뒤에다가 한 칸 띄우고 extends하고 나서 부모 클래스를 적어주면 된다.
부모 클래스 이름인 카메라를 적게 되면 이 카메라로부터 상속을 하게 된 것이다.

※참고로 상속은 한 부모로부터만, 하나의 부모 클래스로부터만 가능하다

메소드 오버라이딩

자식 클래스에서 부모 클래스의 메소드를 덮어쓰는 동작을 하게 된다.
부모 클래스에 정의되어 있는 어떤 메소드를 자식 클래스에서 재정의함으로써 자식 클래스의 메소드가 호출되도록 동작하는 것이다.

SpeedCam code

@Override // annotation

부모 클래스에 이런 메소드가 없다면 오버라이딩 대상이 되는 메소드가 없으면 에러를 내뱉어 주는 것이다.

다형성

factoryCam, speedCam으로 관리할 필요 없이 Camera라는 이름의 부모 클래스로 서로 다른 형태의 객체를 만들 수 있다. -> 다형성

Camera[] cameras = new Camera[3];
        cameras[0] = new Camera();
        cameras[1] = new FactoryCam();
        cameras[2] = new SpeedCam();
for(Camera cam : cameras){
    cam.showMainFeature();
}

-> 카메라라는 이름으로 배열을 만들었고 서로 다른 형태의 개체를 집어넣음으로써 반복문을 통해서 우리는 그냥 ShowMainFeature 메소드를 한번 호출함으로써 위에서 했던 동작을 똑같이 할 수 있게된다. 

※ SpeedCam speedCam = new SpeedCam();과 같이 생성된 객체도 cameras 배열로 관리는 할 수 있다. 

->> 즉, 부모 클래스를 먼저 앞에 적어 줌으로써 부모 클래스 개체 이름은 New 부모 클래스 또는 자식 클래스 이렇게 개체를 만들 수 있다. 

> ```java
((FactoryCam) factoryCam).detectFire();

-> FactoryCam(뒤) 객체는 FactoryCam(앞)이라는 클래스로 형변환이 된 것이다. ※ 공장 카메라에서 제공해주는 클래스를 ㅡㅆ기 위해서는 이런 식으로 형변환을 해야 한다.

위처럼 해주면 형변환된 상태에서 각각의 객체가 가지는 주요 기능들을 써볼 수 있다.

instanceof를 통해서 객체가 이 클래스의 인스턴스 인지 여부를 확인하고 그렇다고 할 때는 형 변환을 통해 가지고 클래스의 메소드에 접근할 수 있다.

Super

앞에서 상속을 한 이유

부모 클래스에 있는 변수나 모든 메소드 동작을 자식 클래스에서 그대로 사용하기 위해서 또 공통적인 부분을 사용을 하고 추가적인 부분만 자식 클래스에서 만들어 쓰기 위해서 상속을 했었는데 지금은 부모 클래스에 있는 recordVideo 또 takePicture를 다시 만들게 된 것이다. -> 상속을 하는 의미가 사라질 수도 있다. 왜냐하면 부모 클래스에서 takePicture의 동작을 바꾼다던지 추가를 하게 되면 speedCam이나 factoryCam의 자식 클래스에서도 똑같이 바꿔줘야 되는 일이 생기기 때문 *->이럴때 사용하는 것이 Super이다. *

super.recordVideo //부모 클래스에 있음

메소드를 호출 해주면 끝!!
factoryCam의 recordVideo라는 메소드가 호출되고 나면 먼저 super.recordVideo라는 동작을 수행하고 나서 추가로 자식 클래스에서 제공하는 화재 감지 기능을 함께 수행하게 되는 것이다. 
자식 클래스에서 오버라이딩을 하긴 했지만 그렇다고 해서 부모 클래스에 정의되어 있는 메소드를 완전히 뒤바꾸는 것이 아니다. 부모 클래스에 있는 내용을 그대로 쓰면서 거기 뒤에서 추가적인 기능을 사용하겠다고 명시를 해주는 것이다. 
-> 부모 클래스에서 recordVideo라는 메소드의 동작을 바꾼다고 해도 자식 클래스에서는 따로 해줄 거 없이 바로 부모 클래스의 이 메소드만 호출해주면 변경된 내용이 바로 적용된다. 

![](https://velog.velcdn.com/images/swk_x/post/0668c611-c724-4619-96fa-ae2a705ffbd4/image.png)

![](https://velog.velcdn.com/images/swk_x/post/3b0e9ff8-90b0-481a-9fc4-0277274781f6/image.png)

-------------
## 참조

#### 기본 자료형
-> 따로 값을 지정하지 않아도 0이나 0.0과 같은 기본값을 항상 가지게 된다. 메소드가 없다. 모두 소문자로 시작
#### 참조 자료형
-> 값을 따로 지정하지 않으면 모두 NULL로 들어간다. 메소드를 가질 수 있다. 모두 대문자로 시작

![](https://velog.velcdn.com/images/swk_x/post/41da16bc-7c3e-4197-af94-00a4ccd4a043/image.png)

![](https://velog.velcdn.com/images/swk_x/post/82f86232-4934-41fb-9955-ad6558a3940c/image.png)

**※ 중요하니까 꼭 이해하기!!**

---------
## Final

- 어떤 변수를 파이널로 선언하게 되면 선언과 동시에 추계를 하고 그 이후에는 값을 사용할 수는 있지만 값을 변경하는 것은 불가능하다. 

![](https://velog.velcdn.com/images/swk_x/post/5e2af203-5ec5-436b-8db2-bed01cb236e3/image.png) ![](https://velog.velcdn.com/images/swk_x/post/af448e09-8e79-458b-b6db-b7daf0455be2/image.png) ![](https://velog.velcdn.com/images/swk_x/post/5345d4ce-6c39-4d4c-9fc0-f2c499947c2c/image.png)

-> 어떤 클래스의 변수를 한 번 더 정해진 값으로 고정하고 싶을 때는 파이널 키워드를 이용할 수 있다. 

![](https://velog.velcdn.com/images/swk_x/post/ebe8921c-9892-4e98-9e97-00f864093ec3/image.png)
-> 메소드 오버라이딩을 통해 가지고 멋진 슬로우모드 비디오를 만듦 

>```java
public final void makeVideo

makeVideo라는 메소드는 자식 클래스에서는 오버라이딩을 할 수가 없게 된다.

메소드는 절대 변경하지 말고 무조건 이걸 써야 하는 경우에는 final 키워드를 넣어 줄 수 있다.

앞에 public final class를 넣으면 이제 이 클래스를 아예 상속할 수 없게 된다.

열거형

정의하는 방법

enum 열거형 이름

getwith

지금 상수값이 가지는 진짜 값을 얻을 수가 있다.

Quiz

Q. 클래스를 이용하여 햄버거를 자동으로 만드는 프로그램을 작성

조건

햄버거의 종류는 햄버거, 치즈버거, 새우버거 3가지
각 버거는 각각의 클래스로 생성
버거 이름을 담기 위한 name 변수 정의
재료 정보를 표시하는 cook() 메소드 정의
공통 부분은 상속 및 메소드 오버라이딩으로 처리
모든 클래스는 하나의 파일에 정의
각 버거의 재료 정보

[JAVA] 메소드

Wed, 27 Dec 2023 13:45:30 GMT

메소드

어떤 기능을 하는 코드들의 묶음 (=함수와 유사)

전달값

거듭제곱을 계산해주는 메소드

반환값

메소드를 수행했을 때 메소드 내에서 동작들을 수행하고 끝내는 게 아니고, 어떤 값을 반환해주고 메소드를 호출한 곳에서 반환된 값을 받아서 뭔가를 처리함
특정 호텔 정보를 관리하는 프로그램

메소드 동작을 수행하고 나서 반환해 줄 자료형 또는 그 형태를 적어주면 된다. -> void라고 적는 이유는 반환값이 없는 메소드라는 의미 void : 아무런 값을 반환하지 않는 메소드

호텔 전화번호라는 문자열 형태의 값을 반환하기 위해서는 void 대신에 string을 적어줘야 함

전달값과 반환값

메소드 오버로딩

이름이 같은 메소드를 여러 개 만드는 것

getPower(String strNumber)

문자열을 정수로 바꿔주는 작업을 함

Integer.parseInt(strNumber);

숫자형의 문자열을 인자값으로 받으면 해당 값을 10진수의 Integer 형으로 반환

-> 메소드 오버로딩은 전달값의 타입이 다르거나 전달값의 자료형이 다르거나 또는 전달값의 개수가 다르면 똑같은 이름의 메소드를 얼마든지 중복해서 선언할 수가 있다.

-> 반환형이 다른 형태로는 메소드를 중복정의 할 수 없다.

메소드가 필요한 이유

비슷한 동작을 하는 것 또는 같은 동작을 하는데 값만 조금 바뀐다고 하면 이런 부분을 메소드로 만들어 가지고 코드를 간소하게 하면 또 다른 데서도 이 메소드가 필요하다고 할 때 그 메소드만 호출하면 된다. 또 수정이 필요하다고 하면 그 메소드 내에 있는 코드 딱 한 번만 수정하면 되기 때문에 코드 유지 보수를 할 때 굉장히 용이하다.

메소드 내에서도 또 다른 메소드를 호출할 수 있다.

변수의 범위 (Scope)

지역 변수는 이 변수가 선언된 그 영역 내에서만 사용할 수 있는 변수이다. 그래서 여기에서는 지금 method b 내에서 중괄호 열고 닫고 안에서 이게 선언이 되었다. 그러면 이 중괄호 속에서만 쓸 수 있게 되는 것이다. 여기를 벗어나게 되면 다른 곳에서는 쓸 수가 없다.
number, result는 지역변수
넘버도 중간으로 열고 닫고 여기에서만 쓸 수 있다.

-> 만약에 여기에서 만든 변수를 다른 곳에서 쓰고 싶다고 하면은 전달값을 이용해 인트, 넘버 이런 식으로 전달값을 정의를 해주고 매소드를 호출할 때 그 값을 전달하는 식으로 사용할 수 있다.

Main 메소드

우리가 지금까지 써왔던 메인 영역은 사실은 하나의 메소드인 거고 이 메소드는 문자열을 여러 개 가지고 있는 string 배열을 전달값으로 받는 메소드이다.

string 값을 전달 받는 방법?

프로그램을 실행할 때 전달해주는 값이 될 수 있는데 이거를 한번 정의해 보자.

Current 파일(오른쪽 위) -> Edit Configurations -> +클릭(왼쪽 위) -> 어플리케이션 선택 -> name에 test라고 적음 -> 빨갛게 표시된 main class(우리가 지금 실행할 클래스를 정해 줌) 선택 -> program argument(프로그램을 실행할 때 우리가 전달해주는 전달값이 된다.)클릭 -> 테스트 전달값 입니다 작성 - 오른쪽 위가 원래는 current file이었는데 지금은 Test로 바뀜

edit configurations들어가서 "테스트 전달값 입니다"를 빼고 1을 입력한다.
edit configurations들어가서 "1"를 빼고 2을 입력한다.
edit configurations들어가서 "2"를 빼고 3을 입력한다.
만약 4를 입력한다면...
1, 3 둘 다 입력한다면...

이런식으로 메인 메소드를 호출할 떄도 프로그램이 처음 실행될 때도 Edit 컴퓨레이션을 통해 어떤 값을 전달해서 똑같은 소스코드이지만 입력되는 값에 따라서 특정 기능을 서로 다르게 수행하도록 할 수 있다.

Quiz

Q. 개인 정보 중 일부를 비공개로 전환하는 프로그램을 작성

조건

개인정보를 비공개로 전환하는 메소드 작성
하나의 메소드에서 모든 동작 처리
각 정보는 아래 위치부터 비공개 적용

[JAVA] 배열

Tue, 26 Dec 2023 10:29:47 GMT

배열

-> 같은 자료형의 값 여러 개를 저장하는 연속된 공간

변수 vs 배열

변수 : 하나의 자료 배열 : 여러 개의 자료

배열 순회

for i 와 for-each는 어떻게 서로 다르게 쓸 수 있을까?

for-each *: 배열의 요소를 처음부터 끝까지 다 순회 *for i *: 인덱스 값을 우리가 알 수 있다. 만약 커피 주문 10명치를 받았다고 하자. 선착순 3명까지 커피 사줄게. 인덱스 값을 이용해서 i가 3이면 그 부분은 커피를 사주지 않고 바로 반복문을 탈출한다. i기준으로 0, 1, 2까지만 커피를 사주게 된다. *인덱스의 값을 이용해서 처리할 때 사용

다차원 배열

-> 주로 2차원 배열

-> 배열은 0부터 시작 [][] : [세로][가로]

에러

-> 배열의 인덱스가 배열의 범위를 벗어나서 생긴 오류

다차원 배열 순회

eng[i] : A, B, C... -> 세로 (j + 1) : 숫자 1, 2, 3...15 -> 가로

아스키 코드

String.valueOf(ch) : ch를 문자열로 변환할 때 사용 ch++ : A, B, C... 이렇게 더해줌

Quiz

Q. 배열을 활용하여 쇼핑몰에서 구매 가능한 신발 사이즈 옵션을 출력하는 프로그램을 작성

조건

신발 사이즈는 250부터 295까지 5 단위로 증가
신발 사이즈 수는 총 10가지

[JAVA] 제어문

Wed, 29 Nov 2023 12:23:40 GMT

조건문 If

if(조건) { //조건식이 true일 때 아래 실행문 동작, false면 미실행
    실행문;
    실행문;
    ...
}

package chap_04;

public class _01_If {
    public static void main(String[] args) {
        // 조건문 If
        int hour = 15; // 오후 3시

        // if 문 내에서 하나의 문장을 실행할 때는 { } 생략 가능
        if (hour < 14)
            System.out.println("아이스 아메리카노 +1");

        // if 문 내에서 2개 이상의 문장을 실행할 때는 { } 생략 불가
        if (hour < 14) {
            System.out.println("아이스 아메리카노 +1");
            System.out.println("샷추가");
        }
        System.out.println("커피 주문 완료 #1");

        // 오후 2시 이전, 모닝 커피를 마시지 않은 경우?
        hour = 10;
        boolean morningCoffee = false; // 모닝 커피
        // if (hour < 14 && morningCoffee == false) {
        if (hour < 14 && !morningCoffee) {
            System.out.println("아이스 아메리카노 +1");
        }
        System.out.println("커피 주문 완료 #2");

        // 오후 2시 이후이거나 모닝 커피를 마신 경우?
        hour = 15;
        morningCoffee = true;
        // if (hour >= 14 || morningCoffee == true) {
        if (hour >= 14 || morningCoffee) {
            System.out.println("아이스 아메리카노 (디카페인) +1");
        }
        System.out.println("커피 주문 완료 #3");
    }
}

If Else

if(조건) { 
    실행문; //조건식이 true일 경우 실행
}
else {
    실행문; //조건식이 false일 경우 실행
}

package chap_04;

public class _02_Else {
    public static void main(String[] args) {
        // 조건문 If Else
        int hour = 10;
        if (hour < 14) { // 오후 2시 이전이면
            System.out.println("아이스 아메리카노 +1");
        } else { // 그 외의 경우이면
            System.out.println("아이스 아메리카노 (디카페인) +1");
        }
        System.out.println("커피 주문 완료 #1");

        // 오후 2시 이후이거나 모닝 커피를 마신 경우?
        hour = 10;
        boolean morningCoffee = false;
        if (hour >= 14 || morningCoffee == true) { // 오후 2시 이후이거나 모닝 커피를 마신 경우?
            System.out.println("아이스 아메리카노 (디카페인) +1");
        } else { // 그 외의 경우이면
            System.out.println("아이스 아메리카노 +1");
        }
        System.out.println("커피 주문 완료 #2");
    }
}

ElseIf

if(조건식 1) { 
    실행문; //조건식 1이 true일 때 실행
}
else if(조건식2) {
    실행문2; //조건식 1이 false이고 조건식 2가 true일 때 실행
}
else {
    실행문; //조건식 1과 2가 false일 때 실행
}

※else if절은 여러 번 정의할 수 있고, else절은 생략이 가능 단, if문이 처음에 나오고 그 다음에 else if문, 제일 마지막에 else문이 나와야 한다.

package chap_04;

public class _03_ElseIf {
    public static void main(String[] args) {
        // 조건문 ElseIf

        // 한라봉 에이드가 있으면 +1
        // 또는 망고 주스가 있으면 +1
        // 또는 아이스 아메리카노 +1

        boolean hallabongAde = true; // 한라봉 에이드
        boolean mangoJuice = true; // 망고 주스

        if (hallabongAde) {
            System.out.println("한라봉 에이드 +1");
        } else if (mangoJuice) {
            System.out.println("망고 주스 +1");
        } else {
            System.out.println("아이스 아메리카노 +1");
        }
        System.out.println("커피 주문 완료 #1");

        // else if 는 여러번 사용 가능
        hallabongAde = false;
        mangoJuice = false;
        boolean orangeJuice = true;

        if (hallabongAde) {
            System.out.println("한라봉 에이드 +1");
        } else if (mangoJuice) {
            System.out.println("망고 주스 +1");
        } else if (orangeJuice) {
            System.out.println("오렌지 주스 +1");
        } else {
            System.out.println("아이스 아메리카노 +1");
        }
        System.out.println("커피 주문 완료 #2");

        // else 는 없어도 가능
        hallabongAde = false;
        mangoJuice = false;
        orangeJuice = false;

        if (hallabongAde) {
            System.out.println("한라봉 에이드 +1");
        } else if (mangoJuice) {
            System.out.println("망고 주스 +1");
        } else if (orangeJuice) {
            System.out.println("오렌지 주스 +1");
        }
        System.out.println("커피 주문 완료 #3");
    }
}

Switch Case문

switch(입력변수) {
    case 입력값1: ...
         break;
    case 입력값2: ...
         break;
    ...
    default: ...
         break;
}

package chap_04;

public class _04_SwitchCase {
    public static void main(String[] args) {
        // Switch Case

        // 석차에 따른 장학금 지급
        // 1등 : 전액 장학금
        // 2등 : 반액 장학금
        // 3등 : 반액 장학금
        // 그 외 : 장학금 대상 아님

        // If Else 문을 이용 (여러 조건 또는 범위에 해당하는 조건)
        int ranking = 4; // 등수
        if (ranking == 1) {
            System.out.println("전액 장학금");
        } else if (ranking == 2 || ranking == 3) {
            System.out.println("반액 장학금");
        } else {
            System.out.println("장학금 대상 아님");
        }
        System.out.println("조회 완료 #1");

        // Switch Case 문을 이용 (명확한 케이스가 있는 경우)
        ranking = 2;
        switch (ranking) {
            case 1:
                System.out.println("전액 장학금");
                break;
            case 2:
                System.out.println("반액 장학금");
                break;
            case 3:
                System.out.println("반액 장학금");
                break;
            default:
                System.out.println("장학금 대상 아님");
        }
        System.out.println("조회 완료 #2");

        // case 2 와 3 을 통합
        ranking = 3;
        switch (ranking) {
            case 1:
                System.out.println("전액 장학금");
                break;
            case 2:
            case 3:
                System.out.println("반액 장학금");
                break;
            default:
                System.out.println("장학금 대상 아님");
        }
        System.out.println("조회 완료 #3");

        // 중고상품의 등급에 따른 가격을 책정 (1급 : 최상, 4급 : 최하)
        int grade = 1; // 등급
        int price = 7000; // 기본 가격
        switch (grade) {
            case 1:
                price += 1000; // price = price + 1000;
                //break;없음
            case 2:
                price += 1000;
                //break;없음
            case 3:
                price += 1000;
                break;
        }
        System.out.println(grade + "등급 제품의 가격 : " + price + "원");
        // 1등급 제품의 가격 : 10000원
        // 2등급 제품의 가격 : 9000원
    }
}

For문

for (초기식; 조건문; 증감식) {
    ... //조건식이 참일 동안만 반복
}

반복순서 구조화

초기식 -> 반복조건 -> 참인경우 for문 안으로(거짓인 경우 for문을 빠져 나감) -> 증감식 -> 반복조건 -> 참인경우 for문 안으로 -> 증감식 -> 반복조건 -> ...

무한루프

-> 반복조건에 세미콜론 두개나 true를 직접 넣게되면 무한루프가 실행

for(;;){
    ...
}

for(true){
    ...
}

package chap_04;

public class _05_For {
    public static void main(String[] args) {
        // 반복문 For
        // 나코 매장
        System.out.println("어서오세요. code._caine입니다.");
        // 또다른 손님이 들어오면?
        System.out.println("어서오세요. code._caine입니다.");
        System.out.println("어서오세요. code._caine입니다.");
        System.out.println("어서오세요. code._caine입니다.");
        System.out.println("어서오세요. code._caine입니다.");
        System.out.println("어서오세요. code._caine입니다.");
        System.out.println("어서오세요. code._caine입니다.");
        // 만약에 인사 법이 바뀌면?
        System.out.println("환영합니다. code._caine입니다.");
        System.out.println("환영합니다. code._caine입니다.");
        System.out.println("환영합니다. code._caine입니다.");
        // 매장 이름이 바뀌면?
        // 나코 -> 코나
        System.out.println("환영합니다. code._caine입니다.");
        System.out.println("환영합니다. code._caine입니다.");
        System.out.println("환영합니다. code._caine입니다.");

        System.out.println(" ---- 반복문 사용 ---- ");

        // 반복문 사용 For
        for (int i = 0; i < 10; i++) {
            // System.out.println("어서오세요. code._caine입니다. " + i);
            // System.out.println("환영합니다. code._caine입니다. " + i);
            System.out.println("환영합니다. code._caine입니다. " + i);
        }

        // 짝수만 출력 (fori 만 적고 엔터)
        // 0, 2, 4, 6, 8
        for (int i = 0; i < 10; i += 2) {
            System.out.print(i);
        }

        System.out.println();

        // 홀수만 출력
        // 1, 3, 5, 7, 9
        for (int i = 1; i < 10; i += 2) {
            System.out.print(i);
        }

        System.out.println();

        // 거꾸로 숫자
        // 5, 4, 3, 2, 1
        for (int i = 5; i > 0; i--) {
            System.out.print(i);
        }

        System.out.println();

        // 1부터 10까지의 수들의 합
        // 1 + 2 + ... + 10 = 55
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            sum += i;
            System.out.println("현재까지 총합은 " + sum + "입니다.");
        }
        System.out.println("1부터 10까지의 모든 수의 총합은 " + sum + "입니다.");
    }
}

while

while 조건이 true(참)이면 반복문이 계속 실행

while 조건이 false(거짓)이면 반복문은 종료

while (조건문) {
  <수행할 문장1>;
  <수행할 문장2>;
  <수행할 문장3>;
  ...
}


```java
package chap_04;

public class _06_While {
    public static void main(String[] args) {
        // 반복문 While
        // 수영장에서 수영을 하는 모습
        int distance = 25; // 전체 거리 25m
        int move = 0; // 현재 이동 거리 0m
        while (move < distance) { // 현재 이동 거리가 전체 거리보다 작다는 조건이 참인 동안 반복 수행
            System.out.println("발차기를 계속 합니다.");
            System.out.println("현재 이동 거리 : " + move);
            move += 3; // 3미터 이동
        }
        System.out.println("도착하였습니다.");

        // 무한 루프
        move = 0;
        while (move < distance) { // 현재 이동 거리가 전체 거리보다 작다는 조건이 참인 동안 반복 수행
            System.out.println("발차기를 계속 합니다.");
            System.out.println("현재 이동 거리 : " + move);
        }
        System.out.println("도착하였습니다.");
    }
}

// 무한루프

Do While

do {
    반복 실행할 문장;
} while(조건식) //조건식이 true일 경우 실행, false일 경우 종료(미실행)

조건식이 true이든 false이든 상관없이 중괄호({}) 안의 문장을 무조건 한번 실행시킨 후 조건을 검사하여 반복을 결정한다.

예제

public class DoWhileEx01 {
    public static void main(String[] args) {
        int i = 1; // 초기값 설정
        do {
            System.out.println(i + ". joker"); // 실행문
            i++; // 증감식
        } while (i <= 10); // 조건식
    }
}

-> 결과는 실행할 문장이 10번동안 반복되어 출력된다.

package chap_04;

public class _07_DoWhile {
    public static void main(String[] args) {
        // 반복문 DoWhile
        int distance = 25; // 전체 거리 25m
        int move = 0; // 현재 이동 거리 0m
        int height = 2; // 키 2m
        while (move + height < distance) {
            System.out.println("발차기를 계속 합니다.");
            System.out.println("현재 이동 거리 : " + move);
            move += 3; // 3m 이동
        }
        System.out.println("도착했습니다.");

        System.out.println(" --- 반복문 #1 ---");

        // 키가 엄청나게 큰 사람?
        move = 0;
        height = 25; // 키가 25m
        while (move + height < distance) {
            System.out.println("발차기를 계속 합니다.");
            System.out.println("현재 이동 거리 : " + move);
            move += 3; // 3m 이동
        }
        System.out.println("도착했습니다.");

        System.out.println(" --- 반복문 #2 ---");

        // Do While 반복문
        do {
            System.out.println("발차기를 계속 합니다.");
            System.out.println("현재 이동 거리 : " + move);
            move += 3;
        } while (move + height < distance);
        System.out.println("도착했습니다.");
    }
}

이중 반복문

package chap_04;

public class _08_NestedLoop {
    public static void main(String[] args) {
        // 이중 반복문

        // 별 (*) 사각형 만들기
        /*

        *****
        *****
        *****
        *****
        *****

         */
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("-----------------");

        // 별 (*) 왼쪽 삼각형 만들기
        /*

        *
        **
        ***
        ****
        *****

         */
        for (int i = 0; i < 5; i++) {
            // for (int j = 0; j < i + 1; j++) {
            for (int j = 0; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        System.out.println("-----------------");

        // 별 (*) 오른쪽 삼각형 만들기
        /*

             *
            **
           ***
          ****
         *****

         SSSS*
         SSS**
         SS***
         S****
         *****

         */
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 4 - i; j++) {
                System.out.print(" ");
            }
            for (int k = 0; k <= i ; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

※무조건 이해하는 게 중요!!

구구단 출력

package chap_04;

public class _09_MultipleTable {
    public static void main(String[] args) {
        // 구구단
        // 2 * 1 = 2
        // 2 * 2 = 4

        for (int i = 2; i < 10; i++) {
            for (int j = 1; j < 10; j++) {
                System.out.println(i + " x " + j + " = " + (i * j));
            }
            System.out.println();
        }
    }
}

2 X 1 = 2
2 X 2 = 4
2 X 3 = 6
2 X 4 = 8
2 X 5 = 10
2 X 6 = 12
2 X 7 = 14
2 X 8 = 16
2 X 9 = 18

3 X 1 = 3
3 X 2 = 6
3 X 3 = 9
3 X 4 = 12
3 X 5 = 15
3 X 6 = 18
3 X 7 = 21
3 X 8 = 24
3 X 9 = 27

4 X 1 = 4
4 X 2 = 8
4 X 3 = 12
4 X 4 = 16
4 X 5 = 20
4 X 6 = 24
4 X 7 = 28
4 X 8 = 32
4 X 9 = 36

5 X 1 = 5
5 X 2 = 10
5 X 3 = 15
5 X 4 = 20
5 X 5 = 25
5 X 6 = 30
5 X 7 = 35
5 X 8 = 40
5 X 9 = 45

6 X 1 = 6
6 X 2 = 12
6 X 3 = 18
6 X 4 = 24
6 X 5 = 30
6 X 6 = 36
6 X 7 = 42
6 X 8 = 48
6 X 9 = 54

7 X 1 = 7
7 X 2 = 14
7 X 3 = 21
7 X 4 = 28
7 X 5 = 35
7 X 6 = 42
7 X 7 = 49
7 X 8 = 56
7 X 9 = 63

8 X 1 = 8
8 X 2 = 16
8 X 3 = 24
8 X 4 = 32
8 X 5 = 40
8 X 6 = 48
8 X 7 = 56
8 X 8 = 64
8 X 9 = 72

9 X 1 = 9
9 X 2 = 18
9 X 3 = 27
9 X 4 = 36
9 X 5 = 45
9 X 6 = 54
9 X 7 = 63
9 X 8 = 72
9 X 9 = 81


Process finished with exit code 0

Break

switch문에서 break문은 현재 위치에서 가장 가까운 switch문 또는 반복문을 벗어나는데 사용된다. 주로 if문과 함께 사용되어 if문의 조건식에 따라 for문과 while문을 종료할 떄 사용
반복문 전체 중단

package chap_04;

public class _10_Break {
    public static void main(String[] args) {
        // Break
        // 치킨 집에서 매일 20마리만 판매 (1인당 1마리만 구매 가능)
        // 손님이 50명 대기

        // For 문
        int max = 20;
        for (int i = 1; i <= 50; i++) {
            System.out.println(i + "번 손님, 주문하신 치킨 나왔습니다.");
            if (i == max) {
                System.out.println("금일 재료가 모두 소진되었습니다.");
                break; // 반복문을 탈출
            }
        }
        System.out.println("영업을 종료합니다.");

        System.out.println("---------------------");

        // While 문
        int index = 1; // 손님 대기 번호
        while (index <= 50) {
            System.out.println(index + "번 손님, 주문하신 치킨 나왔습니다.");
            if (index == max) {
                System.out.println("금일 재료가 모두 소진되었습니다.");
                break;
            }
            index++;
        }
        System.out.println("영업을 종료합니다.");
    }
}

1번 손님, 주문하신 치킨 나왔습니다.
2번 손님, 주문하신 치킨 나왔습니다.
3번 손님, 주문하신 치킨 나왔습니다.
4번 손님, 주문하신 치킨 나왔습니다.
5번 손님, 주문하신 치킨 나왔습니다.
6번 손님, 주문하신 치킨 나왔습니다.
7번 손님, 주문하신 치킨 나왔습니다.
8번 손님, 주문하신 치킨 나왔습니다.
9번 손님, 주문하신 치킨 나왔습니다.
10번 손님, 주문하신 치킨 나왔습니다.
11번 손님, 주문하신 치킨 나왔습니다.
12번 손님, 주문하신 치킨 나왔습니다.
13번 손님, 주문하신 치킨 나왔습니다.
14번 손님, 주문하신 치킨 나왔습니다.
15번 손님, 주문하신 치킨 나왔습니다.
16번 손님, 주문하신 치킨 나왔습니다.
17번 손님, 주문하신 치킨 나왔습니다.
18번 손님, 주문하신 치킨 나왔습니다.
19번 손님, 주문하신 치킨 나왔습니다.
20번 손님, 주문하신 치킨 나왔습니다.
금일 재료가 모두 소진되었습니다.
영업을 종료합니다.
---------------------
1번 손님, 주문하신 치킨 나왔습니다.
2번 손님, 주문하신 치킨 나왔습니다.
3번 손님, 주문하신 치킨 나왔습니다.
4번 손님, 주문하신 치킨 나왔습니다.
5번 손님, 주문하신 치킨 나왔습니다.
6번 손님, 주문하신 치킨 나왔습니다.
7번 손님, 주문하신 치킨 나왔습니다.
8번 손님, 주문하신 치킨 나왔습니다.
9번 손님, 주문하신 치킨 나왔습니다.
10번 손님, 주문하신 치킨 나왔습니다.
11번 손님, 주문하신 치킨 나왔습니다.
12번 손님, 주문하신 치킨 나왔습니다.
13번 손님, 주문하신 치킨 나왔습니다.
14번 손님, 주문하신 치킨 나왔습니다.
15번 손님, 주문하신 치킨 나왔습니다.
16번 손님, 주문하신 치킨 나왔습니다.
17번 손님, 주문하신 치킨 나왔습니다.
18번 손님, 주문하신 치킨 나왔습니다.
19번 손님, 주문하신 치킨 나왔습니다.
20번 손님, 주문하신 치킨 나왔습니다.
금일 재료가 모두 소진되었습니다.
영업을 종료합니다.

Process finished with exit code 0

Continue

반복문의 현재 단계를 중단
반복문 안에서 어떤 조건을 충족하였을 때 수행문을 수행하지 않고 다시 조건을 검토하는 기능을 한다.
continue문은 반복문 내에서만 사용될 수 있으며, 반복이 진행되는 도중에 continue문을 만나면 아래 문장은 실행하지 않고 반복문의 끝으로 이동하여 다음 반복으로 넘어간다.

package chap_04;

public class _11_Continue {
    public static void main(String[] args) {
        // Continue

        // 치킨 주문 손님중에 노쇼 손님이 있다고 가정
        // For
        int max = 20; // 최대 치킨 판매 수량
        int sold = 0; // 현재 치킨 판매 수량
        int noShow = 17; // 대기번호 17번 손님이 노쇼
        for (int i = 1; i <= 50; i++) {
            System.out.println(i + "번 손님, 주문하신 치킨 나왔습니다.");

            // 손님이 없다면? (noShow)
            if (i == noShow) {
                System.out.println(i + "번 손님, 노쇼로 인해 다음 손님에게 기회가 넘어갑니다.");
                continue;
            }

            sold++; // 판매 처리
            if (sold == max) {
                System.out.println("금일 재료가 모두 소진되었습니다.");
                break;
            }
        }
        System.out.println("영업을 종료합니다.");

        System.out.println("------------------");
        // While 문
        sold = 0;
        int index = 0; // 손님 번호
        // while (index <= 50) {
        while (true) {
            index++;
            System.out.println(index + "번 손님, 주문하신 치킨 나왔습니다.");

            // 손님이 없다면 (noShow)
            if (index == noShow) {
                System.out.println(index + "번 손님, 노쇼로 인해 다음 손님에게 기회가 넘어갑니다.");
                continue;
            }

            sold++; // 판매 처리
            if (sold == max) {
                System.out.println("금일 재료가 모두 소진되었습니다.");
                break;
            }
        }
        System.out.println("영업을 종료합니다.");
    }
}

1번 손님, 주문하신 치킨 나왔습니다.
2번 손님, 주문하신 치킨 나왔습니다.
3번 손님, 주문하신 치킨 나왔습니다.
4번 손님, 주문하신 치킨 나왔습니다.
5번 손님, 주문하신 치킨 나왔습니다.
6번 손님, 주문하신 치킨 나왔습니다.
7번 손님, 주문하신 치킨 나왔습니다.
8번 손님, 주문하신 치킨 나왔습니다.
9번 손님, 주문하신 치킨 나왔습니다.
10번 손님, 주문하신 치킨 나왔습니다.
11번 손님, 주문하신 치킨 나왔습니다.
12번 손님, 주문하신 치킨 나왔습니다.
13번 손님, 주문하신 치킨 나왔습니다.
14번 손님, 주문하신 치킨 나왔습니다.
15번 손님, 주문하신 치킨 나왔습니다.
16번 손님, 주문하신 치킨 나왔습니다.
17번 손님, 주문하신 치킨 나왔습니다.
17번 손님, 노쇼로 인해 다음 손님에게 기회가 넘어갑니다.
18번 손님, 주문하신 치킨 나왔습니다.
19번 손님, 주문하신 치킨 나왔습니다.
20번 손님, 주문하신 치킨 나왔습니다.
21번 손님, 주문하신 치킨 나왔습니다.
금일 재료가 모두 소진되었습니다.
영업을 종료합니다.
------------------
1번 손님, 주문하신 치킨 나왔습니다.
2번 손님, 주문하신 치킨 나왔습니다.
3번 손님, 주문하신 치킨 나왔습니다.
4번 손님, 주문하신 치킨 나왔습니다.
5번 손님, 주문하신 치킨 나왔습니다.
6번 손님, 주문하신 치킨 나왔습니다.
7번 손님, 주문하신 치킨 나왔습니다.
8번 손님, 주문하신 치킨 나왔습니다.
9번 손님, 주문하신 치킨 나왔습니다.
10번 손님, 주문하신 치킨 나왔습니다.
11번 손님, 주문하신 치킨 나왔습니다.
12번 손님, 주문하신 치킨 나왔습니다.
13번 손님, 주문하신 치킨 나왔습니다.
14번 손님, 주문하신 치킨 나왔습니다.
15번 손님, 주문하신 치킨 나왔습니다.
16번 손님, 주문하신 치킨 나왔습니다.
17번 손님, 주문하신 치킨 나왔습니다.
17번 손님, 노쇼로 인해 다음 손님에게 기회가 넘어갑니다.
18번 손님, 주문하신 치킨 나왔습니다.
19번 손님, 주문하신 치킨 나왔습니다.
20번 손님, 주문하신 치킨 나왔습니다.
21번 손님, 주문하신 치킨 나왔습니다.
금일 재료가 모두 소진되었습니다.
영업을 종료합니다.

Process finished with exit code 0

Quiz

Q. 조건문을 활용하여 주차 요금 정산 프로그램을 작성

조건

주차요금은 시간당 4000 원 (일일 최대 요금은 30000 원)
경차 또는 장애인 차량은 최종 요금에서 50% 할인

package chap_04;

// 주차요금은 시간당 4000 원 (일일 최대 요금은 30000 원)
// 경차 또는 장애인 차량은 최종 요금에서 50% 할인

//예시
// 일반 차량 5시간 주차 시 20000 원
// 경차 5시간 주차 시 10000 원
// 장애인 차량 10시간 주차 시 15000 원

// 실행결과 : 주차 요금은 xx 원입니다.

public class _Quiz_04 {
    public static void main(String[] args) {
        int hour = 10; // 주차 시간
        boolean isSmallCar = false; // 경차 여부
        boolean withDisabledPerson = true; // 장애인 차량 여부

        int fee = hour * 4000; // 주차 정산 요금 (시간당 4000 원 곱하기)

        // 30000 원 초과 시 일일 최대 요금으로 수정
        if (fee > 30000) {
            fee = 30000; // 일일 최대 요금 적용
        }

        // 경차 또는 장애인 차량인 경우 50% 할인
        if (isSmallCar || withDisabledPerson) {
            fee /= 2; // 50% 할인 적용
        }

        // 실행 결과 출력
        System.out.println("주차 요금은 " + fee + " 원입니다.");
    }
}

[JAVA] 문자열

Thu, 23 Nov 2023 12:43:32 GMT

String클래스의 메소드로 문자열 다루기

int length()

-> 현재 문자열의 길이 값을 반환

String a1 = "ABC";
System.out.println(a1, length());

[실행결과]
3

String toUpperCase(), String toLowerCase()

-> 현재 문자열을 전부 대문자, 소문자로 반환

String a1 = "abcABC";
System.out.println(a1.toUpperCase());
System.out.println(a1.toLowerCase());

[실행결과]
ABCABC
abcabc

Boolean contains

-> 현재 문자열에 매개변수 s의 문자열이 포함되어 있는지 여부를 검사 후 결과를 반환

포함되어 있으면 true

포함되어 있지 않으면 false

String a1 = "APPLE";
System.out.println(a1.contains("A"));
System.out.println(a1.contains("a"));
System.out.println(a1.contains("Z"));

[실행결과]
true
false
false

int indexOf(String str)

-> 현재 문자열내에 있는 첫번째 str 문자열의 시작위치를 찾아서 그 결과값을 반환합니다. fromIndex를 사용하면 해당 인덱스의 위치에서부터 검색을 시작

포함되어 있으면 : 해당위치의 index값

포함되어 있지 않으면 : -1

String s1 = "ABCDE-ABCDE";
System.out.print(s1.indexOf("D") + ", ");
System.out.print(s1.indexOf("d") + ", ");
System.out.print(s1.indexOf("Z") + ", ");
System.out.print(s1.indexOf("DE"));
System.out.printf("%n--------------%n");
System.out.print(s1.indexOf("D",2) + ", ");
System.out.print(s1.indexOf("D",3) + ", ");
System.out.print(s1.indexOf("D",4) + ", ");
System.out.print(s1.indexOf("D",5) + ", ");
System.out.print(s1.indexOf("D",10));

[실행결과]
3, -1, -1, 3

3, 3, 9, 9, -1


>###  int lastIndexOf(String str)
-> 현재 문자열내에 있는 마지막 str 문자열의 시작위치를 찾아서 그 결과값을 반환합니다. fromIndex를 사용하면 해당 인덱스의 위치에서부터 거꾸로 검색을 시작
- 포함되어 있으면 : 해당위치의 index값 
- 포함되어 있지 않으면 : -1
```java
String s1 = "ABCDE-ABCDE";
System.out.print(s1.lastIndexOf("D") + ", ");
System.out.print(s1.lastIndexOf("d") + ", ");
System.out.print(s1.lastIndexOf("Z") + ", ");
System.out.print(s1.lastIndexOf("DE"));
System.out.printf("%n--------------%n");
System.out.print(s1.lastIndexOf("D",2) + ", ");
System.out.print(s1.lastIndexOf("D",3) + ", ");
System.out.print(s1.lastIndexOf("D",4) + ", ");
System.out.print(s1.lastIndexOf("D",5) + ", ");
System.out.print(s1.lastIndexOf("D",10));

[실행결과]
9, -1, -1, 9
--------------
-1, 3, 3, 3, 9

boolean startsWith(String prefix)

-> 현재 문자열이 prefix 문자열로 시작하는지 검사 후 결과를 반환합니다. toffset을 사용할 경우 해당 숫자 만큼 건너뛴후 검사를 진행

포함되어 있으면 : true

포함되어 있지 않으면 : false

String s1 = "HelloJavaWorld";
System.out.println(s1.startsWith("Hello"));
System.out.println(s1.startsWith("hello"));
System.out.println(s1.startsWith("Java"));
System.out.println(s1.startsWith("Java", 5));

[실행결과]
true
false
false
true

boolean endsWith(String suffix)

-> 현재 문자열이 suffix 문자열로 끝나는 검사후 결과를 반환

포함되어 있으면 : true

포함되어 있지 않으면 : false

String s1 = "HelloJavaWorld";
System.out.println(s1.endsWith("World"));
System.out.println(s1.endsWith("world"));
System.out.println(s1.endsWith("Java"));

[실행결과]
true
false
false

연습문제

package chap_03;

public class _01_String1 {
    public static void main(String[] args) {
        String s = "I like Java and Python and C.";
        System.out.println(s);

        // 문자열의 길이
        System.out.println(s.length()); // 29

        // 대소문자 변환
        System.out.println(s.toUpperCase()); // 대문자로
        System.out.println(s.toLowerCase()); // 소문자로

        // 포함 관계
        System.out.println(s.contains("Java")); // 포함된다면 true
        System.out.println(s.contains("C#")); // 포함되지 않는다면 false
        System.out.println(s.indexOf("Java")); // 위치 정보 7
        System.out.println(s.indexOf("C#")); // 포함되지 않는다면 -1
        System.out.println(s.indexOf("and")); // 처음 일치하는 위치 정보 (12)
        System.out.println(s.lastIndexOf("and")); // 마지막 일치하는 위치 정보 (23)
        System.out.println(s.startsWith("I like")); // 이 문자열로 시작하면 true (아니면 false)
        System.out.println(s.endsWith(".")); // 이 문자열로 끝나면 true (아니면 false)
    }
}

String replace(CharSequence target, CharSequence replacement)

-> 현재 문자열에 있는 target문자열을 replacement 문자열로 변경하여 반환

String s1 = "A+B+C+D+E";
System.out.println(s1.replace("+", "-"));

[실행결과]
A-B-C-D-E

String substring(int beginIndex)

-> 현재 문자열의 beginIndex 위치부터 마지막까지 문자열을 반환합니다. endIndex를 사용하면 beginIndex부터 endIndex - 1 까지의 문자열을 반환

String s1 = "ABCDEFG";
System.out.println(s1.substring(2));
System.out.println(s1.substring(2,4));

[실행결과]
CDEFG
CD

※주의 -> s 변수에 변환 결과가 반영되는 것은 아니다. s = s.substring(7); ㄴ이렇게 해야 변환 결과가 s변수에 반영된다.

연습문제

package chap_03;

public class _02_String2 {
    public static void main(String[] args) {
        String s = "I like Java and Python and C.";

        // 문자열 변환
        System.out.println(s.replace(" and", ",")); // " and" 를 "," 로 변환
        System.out.println(s.substring(7)); // 인덱스 기준 7 부터 시작 (이전 내용은 삭제)
        System.out.println(s.substring(s.indexOf("Java")));
        // "Java" 가 시작하는 위치부터, "." 이 시작하는 위치 바로 앞까지
        System.out.println(s.substring(s.indexOf("Java"), s.indexOf("."))); // 시작 위치부터 끝 위치 "직전" 까지

        // 공백 제거
        s = "        I love Java.      ";
        System.out.println(s);
        System.out.println(s.trim()); // 앞뒤 공백 제거

        // 문자열 결합
        String s1 = "Java";
        String s2 = "Python";
        System.out.println(s1 + s2); // JavaPython
        System.out.println(s1 + "," + s2); // Java,Python
        System.out.println(s1.concat(",").concat(s2)); // Java,Python
    }
}

문자열 비교

boolean equals(Object anObject)

-> 두 문자열이 같은지 여부를 비교한 후 그 결과를 반환

포함되어 있으면 : true

포함되어 있지 않으면 : false

String s1 = "ABC";
System.out.println(s1.equals("ABC"));
System.out.println(s1.equals("abc"));
System.out.println(s1.equals("XYZ"));

[실행결과]
true
false
false

boolean equalsIgnoreCase(String anotherString)

-> 대소문자의 구분없이 두 문자열이 같은지 여부를 비교한 후 그 결과를 반환

포함되어 있으면 : true

포함되어 있지 않으면 : false

String s1 = "ABC";
System.out.println(s1.equalsIgnoreCase("ABC"));
System.out.println(s1.equalsIgnoreCase("abc"));
System.out.println(s1.equalsIgnoreCase("XYZ"));

[실행결과]
true
true
false

int compareTo(String anotherString)

-> 두 문자열을 사전 순으로 비교한 결과를 반환

두 문자열이 같을 경우 : 0
현재 문자열이 anotherString 문자열보다 먼저인 경우 : 음수(-)

현재 문자열이 anotherString 문자열보다 나중인 경우 : 양수(+)

String s1 = "E";
System.out.println(s1.compareTo("A"));
System.out.println(s1.compareTo("a"));
System.out.println(s1.compareTo("E"));
System.out.println(s1.compareTo("e"));
System.out.println(s1.compareTo("Z"));
System.out.println(s1.compareTo("z"));

```java [실행결과] 4

28 0
32
21
53

연습문제

package chap_03;

public class _03_StringCompare {
    public static void main(String[] args) {
        // 문자열 비교
        String s1 = "Java";
        String s2 = "Python";

        System.out.println(s1.equals("Java")); // 문자열 내용이 같으면 true, 다르면 false

        // 대소문자 구분 없이 문자열 내용이 같은지 여부 체크
        System.out.println(s2.equalsIgnoreCase("python"));

        // 문자열 비교 심화
        s1 = "1234"; // 벽에 붙은 메모지의 비밀번호 정보 (참조)
        s2 = "1234";
        // s1과 s2는 같은 곳을 참조한다.
        System.out.println(s1.equals(s2)); // true (내용 비교)
        System.out.println(s1 == s2); // true (참조하는 곳 비교)

        s1 = new String("1234"); //메모지에 저장
        s2 = new String("1234"); //또 다른 메모지에 저장
        //이 두 메모지는 서로 다른 것이다.(서로 다른 곳에 데이터 저장)
        // 1234라는 메모지는 하나만 있고 메모지의 값을 s1과 s2라는 string 변수(문자열 변수)가 참조하는 것이다.
        System.out.println(s1.equals(s2)); // true -> 내용이 같으니까
        System.out.println(s1 == s2); // false -> 등호를 이용할 때는 서로 다른 메모리 공간에 각각 존재하는 데이터니까

    }
}

특수 문자(Escape Sequence)

-> 문자열을 사용할 때 어떤 약속이 되어 있는 특별한 기능을 하는 문자

연습문제

package chap_03;

public class _04_EscapeSequence {
    public static void main(String[] args) {
        // 특수문자, 이스케이프 문자 (Escape Sequence, Escape Character, Special Character)
        // \n \t \\ \" \'
        System.out.println("자바가");
        System.out.println("너무");
        System.out.println("재밌어요");

        // \n : 줄바꿈
        System.out.println("자바가\n너무\n재밌어요");

        // \t : 탭
        // 해물파전     9000원
        // 김치전      8000원
        // 부추전      8000원
        System.out.println("해물파전\t\t9000원");
        System.out.println("김치전\t\t8000원");
        System.out.println("부추전\t\t8000원");

        // \\ : 역슬래시
        System.out.println("C:\\Program Files\\Java");

        // \" : 큰따옴표
        // 단비가 "냐옹" 이라고 했어요
        System.out.println("단비가 \"냐옹\" 이라고 했어요");

        // \' : 작은따옴표
        // 단비가 '뭘 봐?' 라는 표정을 지었어요
        System.out.println("단비가 \'뭘 봐?\' 라는 표정을 지었어요");
        System.out.println("단비가 '뭘 봐?' 라는 표정을 지었어요");

        char c = 'A';
        c = '\'';
        System.out.println(c);
    }
}

Quiz

Q. 주민등록번호에서 생년월일 및 성별까지만 출력하는 프로그램을 작성

참고

주민등록변호는 13자리의 숫자로 구성
앞 6자리는 생년월일 정보, 뒷 7자리 중 첫 번째 숫자는 성별 정보
입력 데이터는 -을 포함한 14자리의 문자열 형태

예시

"901231-1234567"인 경우 901231-1까지 출력
"030708-4567890"인 경우 030708-4까지 출력

[JAVA] 연산자

Thu, 23 Nov 2023 10:22:06 GMT

산술 연산자

"+" : 더하기
"-" : 빼기
"*" : 곱하기
"/" : 나누었을 때의 몫 출력
"%" : 나누었을 때의 나머지 출력

증감 연산자

val++
이 문장의 연산을 먼저 수행하고 나서 value에다가 1이 더해짐
++val
value에다가 1을 더하는 연산을 먼저 하고 나서 다른 문장이 수행

연습문제

package chap_02;

public class _01_Operator1 {
    public static void main(String[] args) {
        // 산술 연산자

        // 일반 연산
        System.out.println(4 + 2); // 6
        System.out.println(4 - 2); // 2
        System.out.println(4 * 2); // 8
        System.out.println(4 / 2); // 2
        System.out.println(5 / 2); // 2
        System.out.println(2 / 4); // 0
        System.out.println(4 % 2); // 0
        System.out.println(5 % 2); // 1

        // 우선 순위 연산
        System.out.println(2 + 2 * 2); // 6
        System.out.println((2 + 2) * 2); // 8
        System.out.println(2 + (2 * 2)); // 6

        // 변수를 이용한 연산
        int a = 20;
        int b = 10;
        int c;

        c = a + b;
        System.out.println(c); // 30

        c = a - b;
        System.out.println(c); // 10

        c = a * b;
        System.out.println(c); // 200

        c = a / b; //나누었을 때의 몫 출력
        System.out.println(c); // 2

        c = a % b; //나누었을 때의 나머지 출력
        System.out.println(c); // 0

        // 증감 연산 ++, --
        int val;
        val = 10;
        System.out.println(val); // 10
        System.out.println(++val); // 11
        System.out.println(val); // 11

        val = 10;
        System.out.println(val); // 10
        System.out.println(val++); // 10 -> 출력한다음 더해줌
        System.out.println(val); // 11

        val = 10;
        System.out.println(val); // 10
        System.out.println(--val); // 9
        System.out.println(val); // 9

        val = 10;
        System.out.println(val); // 10
        System.out.println(val--); // 10
        System.out.println(val); // 9

        // 은행 대기번호 표
        int waiting = 0;
        System.out.println("대기 인원 : " + waiting++); // 대기 인원 : 0
        System.out.println("대기 인원 : " + waiting++); // 대기 인원 : 1
        System.out.println("대기 인원 : " + waiting++); // 대기 인원 : 2
        System.out.println("총 대기 인원 : " + waiting); // 총 대기 인원 : 3
    }
}

대입 연산자

num = num + 1;
num = num - 1;
num = num * 1;
num = num / 1;
num = num % 1;

복합 대입 연산자

num += 1;
num -= 1;
num *= 1;
num /= 1;
num %= 1;

연습문제

package chap_02;

public class _02_Operator2 {
    public static void main(String[] args) {
        // 대입 연산자
        int num = 10;
        num = num + 2;
        System.out.println(num); // 12

        num = num - 2;
        System.out.println(num); // 10

        num = num * 2;
        System.out.println(num); // 20

        num = num / 2;
        System.out.println(num); // 10

        num = num % 2;
        System.out.println(num); // 0

        // 복합 대입 연산자
        num = 10;
        // num = num + 2;
        num += 2;
        System.out.println(num); // 12

        // num = num - 2;
        num -= 2;
        System.out.println(num); // 10

        // num = num * 2;
        num *= 2;
        System.out.println(num); // 20

        // num = num / 2;
        num /= 2;
        System.out.println(num); // 10

        // num = num % 2;
        num %= 2;
        System.out.println(num); // 0
    }
}

비교 연산자

연습문제

package chap_02;

public class _03_Operator3 {
    public static void main(String[] args) {
        // 비교 연산자
        System.out.println(5 > 3); // 5 는 3 보다 크다 (참이면 true, 거짓이면 false)
        System.out.println(5 >= 3); // 5 는 3 보다 크거나 같다 (true)
        System.out.println(5 >= 5); // 5 는 5 보다 크거나 같다 (true)
        System.out.println(5 >= 7); // 5 는 7 보다 크거나 같다 (false)

        System.out.println(5 < 3); // 5 는 3 보다 작다 (false)
        System.out.println(5 <= 3); // 5 는 3 보다 작거나 같다 (false)

        System.out.println(5 == 5); // 5 는 5 와 같다 (true)
        System.out.println(5 == 3); // 5 는 3 과 같다 (false)
        System.out.println(5 != 5); // 5 는 5 와 같지 않다 (false)
        System.out.println(5 != 3); // 5 는 3 과 같지 않다 (true)
    }
}

논리 연산자

연습문제

package chap_02;

public class _04_Operator4 {
    public static void main(String[] args) {
        // 논리 연산자
        boolean 김치찌개 = true;
        boolean 계란말이 = true;
        boolean 제육볶음 = true;

        System.out.println(김치찌개 || 계란말이 || 제육볶음); // 하나라도 true 이면 true (괜찮은 식당)
        System.out.println(김치찌개 && 계란말이 && 제육볶음); // 모두 true 이면 true (최고의 식당)

        // And 연산
        System.out.println((5 > 3) && (3 > 1)); // 5 는 3 보다 크고, 3 은 1 보다 크다 (true)
        System.out.println((5 > 3) && (3 < 1)); // 5 는 3 보다 크고, 3 은 1 보다 작다 (false)

        // Or 연산
        System.out.println((5 > 3) || (3 > 1)); // 5 는 3 보다 크거나, 3 은 1 보다 크다 (true)
        System.out.println((5 > 3) || (3 < 1)); // 5 는 3 보다 크거나, 3 은 1 보다 작다 (true)
        System.out.println((5 < 3) || (3 < 1)); // 5 는 3 보다 작거나, 3 은 1 보다 작다 (false)

        // System.out.println(1 < 3 < 5); // 불가능한 코드

        // 논리 부정 연산자
        System.out.println(!true); // false
        System.out.println(!false); // true
        System.out.println(!(5 == 5)); // false
        System.out.println(!(5 == 3)); // true
    }
}

삼항 연산자

-> 조건 연산자라고도 볼 수 있다. 어떤 조건을 만족하면 이 값을 넣고 그 조건을 만족하지 않으면 저 값을 넣는 식으로 처리된다.

연습문제

package chap_02;

public class _05_Operator5 {
    public static void main(String[] args) {
        // 삼항 연산자
        // 결과 = (조건) ? (참의 경우 결과값) : (거짓의 경우 결과값)
        int x = 3;
        int y = 5;
        int max = (x > y) ? x : y;
        System.out.println(max); // 5

        int min = (x < y) ? x : y;
        System.out.println(min); // 3

        boolean b = (x == y) ? true : false;
        System.out.println(b); // false

        String s = (x != y) ? "달라요" : "같아요";
        System.out.println(s); // 달라요
    }
}

Quiz

Q. 어린이 키에 따른 놀이 기구 탑승 가능 여부를 확인하는 프로그램을 작성하시요

조건

키가 120cm 이상인 경우에만 탑승 가능
삼항 연산자 이용

실행결과

[JAVA] 형 변환

Thu, 23 Nov 2023 09:16:35 GMT

형 변환

package chap_01;

public class _07_TypeCasting {
    public static void main(String[] args) {
        // 형변환 TypeCasting
        // 정수형에서 실수형으로
        // 실수형에서 정수형으로

        // int to float, double
        int score = 93;
        System.out.println(score); // 93
        System.out.println((float) score); // 93.0
        System.out.println((double) score); // 93.0

        // float, double to int
        float score_f = 93.3F;
        double score_d = 98.8;
        System.out.println((int) score_f); // 93
        System.out.println((int) score_d); // 98

        // 정수 + 실수 연산
        score = 93 + (int) 98.8; // 93 + 98
        System.out.println(score); // 191

        score_d = (double) 93 + 98.8; // 93.0 + 98.8
        System.out.println(score_d); // 191.8

        // 변수에 형변환된 데이터 집어넣기
        double convertedScoreDouble = score; // 191 -> 191.0
        // int -> long -> float -> double (자동 형변환)

        int convertedScoreInt = (int) score_d; // 191.8 -> 191
        // double -> float -> long -> int (수동 형변환)

        // 숫자를 문자열로
        String s1 = String.valueOf(93);
        s1 = Integer.toString(93);
        System.out.println(s1); // 93

        String s2 = String.valueOf(98.8);
        s2 = Double.toString(98.8);
        System.out.println(s2); // 98.8

        // 문자열을 숫자로
        int i = Integer.parseInt("93");
        System.out.println(i); // 93
        double d = Double.parseDouble("98.8");
        System.out.println(d); // 98.8

        int error = Integer.parseInt("자바");
    }
}

Quiz

Q. 버스 도착 정보를 출력하는 프로그램 작성 각 정보는 적절한 자료형의 변수에 정의

정보

버스 번호는 "1234", "상암08"과 같은 형태
남은 시간은 분 단위(예: 3분, 5분)
남은 거리는 km 단위(예: 1.5km, 0.8km)

[JAVA] 변수

Thu, 23 Nov 2023 08:32:27 GMT

자료형

int 자료형

-> -21억 ~ 21억 사이의 값일 때 사용

long 자료형

-> -21억 ~ 21억보다 큰 범위의 값일 때 사용

실수형

float

-> 상대적으로 그렇게까지 깊은 소수점이 필요 없을 때 사용

double

-> 소수점 아주 많은 자릿수까지 정밀한 데이터를 요구할 때 사용

문자형

character

-> 하나의 문자 표현

string

-> 여러 문자 표현

Boolean

True

-> 참

False

-> 거짓

연습문제

package chap_01;

public class _03_Variables {
    public static void main(String[] args) {
        String name = "이가영";
        int hour = 15;

        System.out.println(name + "님, 배송이 시작됩니다. " + hour + "시에 방문 예정입니다.");
        System.out.println(name + "님, 배송이 완료되었습니다.");

        double score = 90.5;
        char grade = 'A';
        name = "강백호"; //name은 변수니까 바꿀 수 있다.
        System.out.println(name + "님의 평균 점수는 " + score + "점입니다.");
        System.out.println("학점은 " + grade + "입니다.");

        boolean pass = true;
        System.out.println("이번 시험에 합격했을까요? " + pass);

        double d = 3.14123456789;
        float f = 3.14123456789F;
        System.out.println(d);
        System.out.println(f);

        long l = 1000000000000L; //long = int보다 더 큰 범위의 자료형을 가질 수 있다.
        l = 1_000_000_000_000L;
        System.out.println(l);
    }
}

변수

-> 변하는 수. 데이터를 한번 집어넣었다가 또 필요하면 업데이트를 하고 얼마든지 바꿀 수 있다.

변수 이름 짓는 법

저장할 값에 어울리는 이름
밑줄(_), 문자(abc), 숫자(123) 사용 가능 (공백 사용 불가)
밑줄 또는 문자로 시작 가능
한 단어 또는 2개 이상 단어의 연속
소문자로 시작, 각 단어의 시작 글자는 대문자 (첫 단어는 제외)
예약어 사용 불가 (public, static, void, int, double, float, ...)

package chap_01;

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

        // 입국 신고서 (여행)
        String nationality = "대한민국"; // 국적
        String firstName = "현성"; // 이름
        String lastName = "김"; // 성
        String dateOfBirth = "2001-12-31"; // 생년월일
        String residentialAddress = "무슨 호텔"; // 체류지
        String purposeOfVisit = "관광"; // 입국목적
        String flightNo = "KE657"; // 항공 편명
        String _flightNo = "KE657"; // 밑줄 시작
        String flight_no_2 = "KE657"; // 밑줄과 숫자 포함
        // String -flightNo = "KE657";

        int accompany = 2; // 동반 가족 수
        int lengthOfStay = 5; // 체류 기간

        String item1 = "시계";
        String item2 = "가방";
        // String 3item = "전자제품";

        // 프로그램의 흐름을 위해 사용되는 경우 등 (크게 이름이 중요하지 않을 때)
        int i = 0;
        String s = "";
        String str = "";

        // 절대 변하지 않는 상수는 대문자로
        final String CODE = "KR";
    }
}

상수

한번 딱 정의하고 나면 절대 수정을 못 함
상수를 만들 때는 모두 대문자로 적어야 함 (두 개 이상의 단어가 포함된다면 밑줄로 구분을 한다.)

package chap_01;

public class _06_Constants {
    public static void main(String[] args) {
        final String KR_COUNTRY_CODE = "+82"; // 국가 번호 (빨리)
        // final = 상수로 변화시킴
        // KR_COUNTRY_CODE = "+8282"; -> 상수니까 문장 변경 못 함
        System.out.println(KR_COUNTRY_CODE);

        final double PI = 3.141592; // 원주율
        final String DATE_OF_BIRTH = "2001-12-31"; // 생년 월일
    }
}

[JAVA] Intellij 단축키

Thu, 23 Nov 2023 08:16:13 GMT

Ctrl + D

복사하고자 하는 문장을 클릭한 후 ctrl + D를 누르면 다음줄에 똑같은 문장이 복사가 된다.

sout

sout을 치고 엔터키를 누르면 이 문장이 자동생성된다.

System.out.println();

psvm

psvm을 치고 엔터키를 누르면 이 문장이 자동생성된다.

public static void main(String[] args) {

    }

Ctrl + /

-> 한 줄 주석 단축키

Ctrl + Shift + /

-> 여러 줄 주석 단축키

연습문제

package chap_01;

public class _04_Comment {
    public static void main(String[] args) {
        System.out.println("(10분 전) 잠시 후 결혼식 시작 예정이오니 착석 부탁드립니다.");
        //System.out.println("(5분 전) 잠시 후 결혼식 시작 예정이오니 착석 부탁드립니다.");
        System.out.println("지금부터 결혼식을 시작하겠습니다.");

        int size = 120;
        size = size + 10; // 어린이는 발이 빨리 자라기 때문에 사이즈 10만큼 더 큰 신발을 구매
        System.out.println("신발 사이즈 " + size + "으로 보여주세요");

        // 한 줄 주석 단축키 : Ctrl + /
        // 여러 줄 주석 단축키 : Ctrl + Shift + /
        int a = 10;
        int b = 20;
        System.out.println(a + b);
    }
}

[C언어] 응용포인터

Sun, 22 Oct 2023 15:53:28 GMT

포인터의 핵심 정리

포인터는 다음의 두 가지만 이해하면 응용이 가능하다

포인터가 가리키는 자료형은 무엇인가? -> "실체가 무엇인가?"

int val;
&val -> int형 변수
포인터의 &val은 int형을 가리킨다.

double val
&val -> double형 변수
포인터 &val은 double형을 기리킨다.

포인터는 같은 자료형을 가리키는 포인터변수에 저장해야 한다.
```
int * ip;
가리키는 자료형  ip=포인터 변수
```

ip=&val; //포인터를 포인터변수에 대입 -> 가리키는 자료형은 모두 int형으로 같다.


## 다중 포인터
- 포인터변수도 하나의 기억공간이므로 포인터(물리적 주소)를 구할 수 있다.
포인터변수의 포인터 -> **이중포인터**
```c
int *ip;
&ip       ->  (int *)형 변수  //포인터 &ip는 (int*)형을 가리킨다
이중포인터        포인터변수

이중포인터로 변수를 참조할 때는 참조연산자를 두 변 사용해야 한다.

이중포인터변수

이중포인터 또한 하나의 포인터이므로 포인터변수에 저장하여 사용한다.

int *ip;
int **ipp; //integer포인터에 주소값을 저장시킬 애가 ipp이다.
가리키는 자료형 / ipp는 포인터변수다. / 변수의 이름

ipp = &ip; //이중포인터를 이중표인터변수에 대입 -> 가리키는 자료형은 모두 (int *)형으로 같다

- 이중포인터변수도 참조연산자를 두 번 사용하여 변수를 참조한다.
```c
int val = 10;
int *ip;  //포인터변수
int **ipp;  //이중포인터변수
int = &val;  //주소값 저장
ipp = &ip;
printf("%d\n", **ipp);

*(*ipp) => *(100) => 10

이중포인터변수의 사용 예

두 포인터변수의 값을 바꾸는 함수를 만들어보자 ```c char *ap = "success"; char *bp = "failure";

변경하지 못하는 임시데이터메모리에 success, failure 생기고, 여기에 있는 주소값이 success에 치환돼서 컴파일된다.

![](https://velog.velcdn.com/images/swk_x/post/7945b00c-389f-4db5-b4be-2e83af7706d6/image.png)
```c
함수의 호출 -> exchange ptr(&ap, &bp); //이중포인터를 전달인자로 준다
//exchange함수에 ap와 bp의 주소값을 줌 -> 이 값을 exchange_ptr이라는 애가 값을 바꾸므로
함수의 선언 -> void exchange_ptr(char **app, char **bpp);
//이중포인터가 전달인자로 넘어오므로 매개변수로 이중포인터 변수를 선언
함수가 호출된 후 ->

함수 안에서는 임시 포인터변수를 선언하여 ap, bp의 값을 바꾼다.
```
char *tp;  //임시 포인터변수의 선언
```

함수를 사용하여 포인터변수의 값을 바꾸는 프로그램

#include 

void exchange_ptr(char **, char **);  //함수의 선언
int main()
{
    char *ap = "success";
    char *bp = "failure";
    printf("*ap -> %s, bp -> %s\n", ap, bp);  //바꾸기 전의 문자열 출력
    exchange_ptr(&ap, &bp);  //함수의 호출
    printf("ap -> %s, bp -> %s\n", ap, bp);  //바꾼 후에 문자열 출력
    return 0;
}

void exchange_ptr(char **app, char **bpp) //함수의 정의
{
    char *tp;  //임시 포인터변수
    tp=*app;
    *app=*bpp;  //메인함수에 있는
    *bpp=*tp;   //ap, bp의 값을 바꾼다.
}

출력결과
ap -> success, bp -> failure
ap -> failure, bp -> success

연습문제

포인터 배열에 저장된 문자열을 출력하는 프로그램
char *spp** -> 이 매개변수를 어떻게 만들지를 이해해야 함!!

배열 포인터

배열명의 정체

배열명은 첫 번째 배열요소를 가리키는 포인터의 기능을 한다.

int nums[5] = {10, 20, 30, 40, 50};
int *ip=nums;  //배열명은 포인터이므로 포인터변수에 저장
printf("%d\n", *nums);  //첫 번째 기억공간을 참조하여 10이 출력
printf("%d\n", *(nums+4));  //nums의 값이 100이면 116번지를 참조

nums      10  20  30  40  50
 ㄴ------| 배열명은 첫번째 배열요수를 가리키는 포인터

배열의 기억공간 전체를 나타내는 논리적 변수의 기능을 한다.
논리적 변수(상수)이므로 -> 직접 데이터를 저장할 수는 없으나 응용 자료형으로서 -> 변수가 가지는 형태와 그기에 대한 정보를 가진다.

배열포인터가 가리키는 것은?

배열포인터는 배열명에 주소연산을 수행하면 구해진다.
이 때 배열명은 논리적변수의 기능이며 그 배열 전체를 가리키는 포인터가 구해진다.
```
int ary[5];
&ary    -->    int  int  int  int  int
배열포인터        배열의 전체를 가리킨다
```
배열포인터에 정수값을 더하면 배열 전체의 크기를 곱해서 더해주게 된다.

2차원 배열의 배열명은 배열포인터이다

2차원 배열에서 배열명으로 기억을 참조하는 공간

1차원의 물리적 기억공간을 행렬의 2차원 구조로 참조할 수 있는 것은 2차원 배열의 배열명과 부분배열명이 각각 배열포인터와 포인터로서 적절한 기능을 수행하기 때문이다.

2차 배열포인터변수

2차 배열포인터를 저장 -> 배열포인터변수

ap에는 int[4] type의 배열 포인터가 저장된다.

배열포인터변수가 2차원 배열의 배열명을 저장하면 2차원 배열처럼 사용된다.

int any[3][4]={{1,2,3,4}, {5,6,7,8},{9,10,11,12}};
int (*ap)[4]; ★ 
int i, j;
ap=ary;  //배열명을 배열포인터변수에 저장
for(i=0; i<3; i++)
{
   for(j=0; j<4; j++)
   {
       printf("%5d", ap[i][j]); //ap를 배열명처럼 사용
   }
   printf("\n");
}

출력결과
1   2   3   4  
5   6   7   8
9   10  11  12

배열 포인터

해석 방법 : 단항 -> 후치 -> 근치
```
int ap[][4]
4   1 2  3
```

연습문제

5개의 문자열을 2차원 배열에 입력 받아 출력하는 프로그램 단,

2차원 문자배열은 메인함수에서 선언
입출력 작업은 각각 함수를 호출해서 수행
문자열의 길이는 최대 80자로 제한

함수 포인터

함수포인터는 함수의 이름이다.
함수명은 함수의 정의가 있는 메모리의 위치값이며 함수를 가리킨다.

-> 함수명이 포인터라는 증거는 참조연산자를 사용하면 알 수 있다.

(*sum)(10, 20); //10과 20을 전달인자로 주고 sum함수를 호출한다.
(함수를 참조한 후에 호출해야 하므로 참조연산에 괄호를 사용한다.)

함수포인터변수

함수 포인터가 가리키는 자료형은 함수의 형태이다.
함수의 형태를 매개변수의 개수와 형태, 리턴값의 형태이다.
함수포인터를 함수포인터변수에 저장하여 호출할 수 있다.
```
fp(10, 20); //= sum(10, 20);
```

함수포인터변수로 sum함수를 호출하는 프로그램

함수포인터는 어디에 사용?

함수포인터변수는 함수의 형태만 같으면 기능과 상관없이 모든 함수포인터를 저장할 수 있다. ```c int sum(int, int); //두 정수값을 더해서 리턴하는 함수 int mul(int, int); //두 정수값을 곱해서 리턴하는 함수 int max(int, int); //두 정수값 중에서 큰 값을 리턴하는 함수

세 개 모두 형태가 같다

```c
int (*fp)(int, int); -> fp = sum; 
                       fp = mul;  // 모두 사용 가능
                       fp = max;

형태가 같은 다양한 기능의 함수를 선택적으로 호출하는데 사용할 수 있다.
다음과 같은 기능을 수행하는 함수를 만들자
func함수에서 2번 연산과정은 함수를 호출할 때 필요한 연산이 수행되도록 만들자

func함수를 사용한 프로그램

연습문제

exchange함수와 func함수를 만들어 프로그램을 완성
func함수는 전달인자로 받은 두 값을 출력한 후에 exchange함수를 사용하여 두 값을 바꾸고 다시 출력
exchange함수는 포인터를 전달인자로 받아서 그들이 가리키는 두 값을 바꾼다.

void 포인터

가리키는 자료형에 대한 정보가 없는 포인터이다.

int a; //int형 변수 선언
(void*) &a; //int형 변수의 포인터를 void 포인터로 강제 형변환

void포인터변수는 가리키는 자료형이 정해져 있지 않으므로 모든 포인터를 저장할 수 있다.

void * vp;
가리키는 자료형이 정해져 있지 않다/vp=포인터변수/변수의 이름

int in;  //int형 변수
double db; //double형 변수
void *vp; //void포인터 변수
vp=∈ //int형 변수의 포인터를 저장할 수 있고
vp=&db; //double형 변수의 포인터도 저장할 수 있다.

#include 도 있어야 함 type은 자료형 구분을 위한 매개변수

[C언어] 2차원 배열과 배열포인터

Fri, 22 Sep 2023 16:16:07 GMT

2차원 배열의 선언과 초기화

2차원 배열은 1차원 배열을 배열요소로 갖는 새로운 배열이다.
3명의 학생에 대한 4과목의 학생 점수를 처리하는 예

2차원 배열의 선언과 구조

2차원 배열은 1차원 배열처럼 배열명과 첨자를 사용하여 선언
각 배열요소의 형태는 int형 변수 4개짜리 1차원 배열이다.
전체 배열은 12개의 int형 기억공간이 1차원 배열의 형태로 할당된다.
2차원 배열은 논리적으로 행렬로 표현된다.

배열요소는 1차원 배열이므로 부분배열이라고 한다.

int score1[4];
int score2[4];  => int score[3][4];
int score3[4];         배열명 배열요소의 개수
// int [4] -> 배열요소의 형태
// int형 변수 4개짜리 1차원 배열이 2차원 배열의 배열요소가 된다.

배열요소의 참조

2차원 배열은 부분배열의 배열요소를 다시 참조해야 한다.

첫 번째 부분배열에 4과목의 점수를 입력하는 예

int score[3][4];   //2차원 배열 선언
int j;             //반복 제어변수
printf("네 과목의 점수를 입력 : ");
for(j=0; j<4; j++)  //i는 0부터 3까지 4번 반복
{
   scanf("%d", &score[0][j]);
}  //첫 번째 부분배열의 배열요소에 각각 점수 입력
  //결국 한 학생의 모든 점수를 입력 받는다.

2중 for문으로 모든 배열요소를 처리한다.

나머지 두 명의 점수를 입력 받기 위해 점수를 입력 받는 과정을 반복

2차원 배열을 사용하여 학생들의 점수를 처리하는 프로그램

2차원 배열의 sizeof

#include 
int main()
{
    int score[3][6];
    printf("%d\n", sizeof(score));  //72=3*6*4(int) 배열 전체의 크기
    //배열요소 3개, 각각의 배열요소는 6개의 배열로 이루어진 부분배열, 부분배열의 각각의 요소는 int
    printf("%d\n", sizeof(score[0])); //24=6*4
    // 부분배열이니까 int 6개
    printf("%d\n", sizeof(score[0][0])); //4 부분배열요소
    return 0;
|

2차원 배열의 초기화

기본적으로 1차원 배열을 초기화하는 방식과 같다.
초기화 값은 행 단위로 차례로 저장된다.

```c int nums[3][4]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
```
          nums[0]    |  nums[1]   |     nums[2]
```
1 2 3 4 5 6 7 8 => 첫번째 행이 먼저 초기화된 후에 두 번째, 세 번째 행이 차례로 초기화됨 9 10 11 12 ```
기억공간의 수보다 초기화 값이 적으면 남는 기억공간은 0으로 초기화 ```c int nums[3][4]={1, 2, 3, 4, 5, 6}; 만약 전체를 0으로 초기화 하고 싶다면 ={0}; 하면 된다.
1 2 3 4 5 6 0 0 0 0 0 0 ```

초기화 값을 논리적 구조에 맞게 행으로 구분하고자 하면 중괄호를 한번 더 사용

int nums[3][4]={{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
              // 첫번째행      두번째 행        세번쨰 행

행 초기화 괄호를 사용하면 행 단위로 초기값을 생략할 수 있다. -> 부족분은 0으로 초기화 ```c int nums[3][4]={{1}, {5, 6}, {9, 10, 11}};
1 0 0 0 5 6 0 0 9 10 11 0 ```
1차원 배열과 마찬가지로 배열의 첨자를 생략할 수 있다.
행 초기화 괄호를 사용한 경우 ```c int nums[][4]={{1}, {2, 3}, {4, 5, 6}}; //행의 수 3개
```
  행 열(열 첨자는 생략 불가능)
```
1 0 0 0 2 3 0 0 //3행 4열의 기억공간 할당 4 5 6 0
행 초기화 괄호를 사용하지 않은 경우c int nums[][4] = {1, 2, 3, 4, 5, 6};
```
     //첫번째 행 초기값 / 두 번째 초기값
```
1 2 3 4
5 6 0 0 //2행 4열의 기억공간 할당

2차원 문자배열

여러 개의 문자열을 저장하기 위해서는 2차원 문자배열이 필요
5개의 문자열을 저장할 2차원 문자배열
```
char animals[5][20];
```

마지막 부분배열에 문자열을 입력할 때(부분배열명을 전달인자로 준다)

scanf("%s", animal[4]); //gets함수를 사용하면 gets(animal[4])
          // 전체가 배열명임
 ★부분배열명 = 포인터★

반복문을 사용하여 모든 부분배열에 문자열을 입력

for(i=0; i<5; i++)
{
   printf("문자열을 입력 : ");
   scanf("%s", animal[i]); //i의 값이 변하면서 각 부분배열명이 된다.
}

2차원 문자배열의 초기화

기본적으로 각 기억공간들을 문자상수로 초기화할 수 있다.
```
char animal[5][10]={{'c', 'a', 't', '\0'}, {'t', 'i', 'g', 'e', 'r', '\0'}};
```
각 행은 문자열상수로 직접 초기화할 수 있다. ```c char str[10]="cat"; //하나의 문자열 상수는 1차원 문자배열을 초기화할 수 있다. char animal[5][10]={"cat", "tiger", "dog", "lion", "turtle"};
```
      ㄴ5개의 문자열 상수는 5개의 부분배열을 초기화한다.
```
cat \0 \0 \0 \0 \0 \0 \0 tiger \0 \0 \0 \0 \0 dog \0 \0 \0 \0 \0 \0 \0 -> 남은 기억공간들은 널문자로 채워진다. lion \0 \0 \0 \0 \0 \0 turtle \0 \0 \0 \0

2차원 문자배열을 초기화하고 출력하는 프로그램

문자열 개수 계산 ->sizeof(animal) / sizeof(animal[0]);
                전체 배열의 크기    부분배열 하나의 크기

포인터 배열

포인터배열 = 포인터변수들을 배열요소로 갖는 배열
배열에 저장되는 데이터가 특정 타입의 포인터
```
특정 타입 : 배열은 동일 형태의 데이터를 저장하기 때문
```
```c char *ptr_ary[5];
char *ptr : 배열요소의 자료형 ptr_ary : 배열명 [5] : 배열요소의 개수 ```

세 번째 배열요소에 문자열상수를 대입하고 출력할 때

ptr_ary[2]="tiger";  //문자열상수는 포인터이므로 포인터만을 저장하는 것이다.
printf("%s", ptr_ary[2]);

#include 
int main()
{
    char *ptr_ary[5];
    int i;
    ptr_ary[0]="dog";
    ptr_ary[1]="elephant";
    ptr_ary[2]="horse";
    ptr_ary[3]="tiger";
    ptr_ary[4]="lion";
    for(i=0; i<5; i++)
    {
        printf("%s\n", ptr_ary[i]);
        //배열요소를 하나씩 참조하여 모든 문자열을 출력
    }
    return 0;
}

포인터배열의 초기화

문자열상수는 포인터이므로 포인터배열에 초기값으로 사용 ```c char *ptr_ary[5]={"dog", "elephant", "horse", "tiger", "lion"};
"dog"은 임시영역에 저장
"dog"가 저장된 임시 영역의 주소값이 ptr_ary[0]에 저장 ```
문자배열 초기화와 포인터배열 초기화의 차이점 ```c char animal[5][10]={"dog", "elephant", "horse", "tiger", "lion"}; char *ptr_ary[5]={"dog", "elephant", "horse", "tiger", "lion"};
char animal[5][10] char *ptr_ary[5] //배열의 형태에 따라 문자열을 복사하거나 포인터를 저장 ```
2차원 문자배열에 초기화하는 것은 모든 문자열이 배열에 복사되는 것이고
포인터배열에 초기화하는 것은 포인터만 초기화되는 것이다. ★위 2개의 차이를 이해해야 함★

포인터배열은 2차원 배열처럼 활용된다

1차원 배열의 배열명을 포인터배열에 저장하면 포인터배열을 2차원 배열처럼 사용할 수 있다.

int ary1[4]={1,2,3,4};
int ary2[4]={11,12,13,14};
int ary3[4]={21,22,23,24};
int *ptr_ary[3]={ary1, ary2, ary3};
//각 배열명을 포인터배열에 초기화한다.

ary3배열의 세 번째 배열요소(23값)을 참조하는 과정

먼저 ptr_ary배열의 세 번째 배열요소를 참조 -> ptr_ary[2] -> 부분배열명
참조된 배열요소 ptr_ary[2]는 배열명 ary3를 저장한 포인터변수이므로 배열명처럼 사용하여 ary3의 세 번째 배열요소를 참조 -> printf("%d", ptr_ary[2][2]);

반복문으로 모든 배열요소의 값을 출력

연습문제

4행 5열의 2차원 배열 두 개를 선언, 1부터 20까지 저장한 후 출력하는 프로그램

연습문제

2차원 배열의 초기화와 행/열의 합

연습문제

기억 공간의 몇 퍼센트를 차지하는지 계산하는 프로그램

연습문제

2차원 문자배열과 포인터배열이 연결될 수 있도록 배열을 선언하고 초기화하는 프로그램 (1) 포인터배열을 이용하여 가장 길이가 긴 동물 이름 출력 (2) 포인터배열을 이용하여 문자열을 사전 순서에 따라 sorting한다.

[C언어] 변수의 영역과 데이터 전달

Mon, 18 Sep 2023 07:14:50 GMT

자동변수

지금까지 하나의 함수 안에서 선언한 변수는 자동변수이다.
함수 input 값으로 선언된 변수
함수 내부에서 선언된 변수
사용볌위는 하나의 함수 내부이다.
중괄호 {} 내부
생존기간은 함수가 호출되어 실행되는 동안이다.
메모리에서의 위치는 스택영역이다.
LIFO (last-in-first-out)
자동초기화 되지 않으므로 쓰레기값이 존재

자동변수의 생존기간

자동변수는 함수가 호출되어 변수 선언문이 실행될 때 메모리에 기억공간이 할당된다.

세 개의 자동변수를 사용하는 함수의 예(매개변수==자동변수)

int sum(int a, int b)
{
   int res; //메모리가 stack에서 생성
   res=a+b;
   return res;
}

자동변수는 함수가 리턴되고 나면 더 이상 사용되지 않는 기억공간이므로 리턴될 때 메모리에서 사라진다.

기억공간의 할당과 회수

자동변수의 할당과 회수는 하나의 함수 내에서도 발생

함수 내에서 새로운 블록을 열고 변수를 선언하면 그 블록이 끝날 때 변수는 사라진다. 결국 변수의 사용범위는 블록 내부이다.

#include 
int main()
{
   int a=10, b=20;  //메인함수 블록에 선언된 변수
   printf("바꾸기 전 a : %d, b : %d\n", a, b);
   {                 //새로운 블록의 시작
       int temp;     //안쪽 블록에 선언된 변수
       temp = a;   //temp는 이 블록에서만 사용가능, 나가면 사용 불가능
       a=b;
       b=temp;
   }               //블록이 끝나면서 temp변수는 사라진다.
   printf("바꾼 후 a : %d, b : %d\n", a, b); 
   return 0;
}

중첩된 블록에서 같은 이름의 변수를 사용할 경우

중첩된 블록에서 같은 이름의 변수를 선언하면 가장 가까운 블록에 선언된 변수에 우선권이 있다. ```c #include
int main() { int val=10; //1번 각 변수의 사용범위는 { // 변수가 선언된 블록의
```
  int val=20;  //2번        끝까지이다.
  {
      val++;  //가장 가까이 선언된 2번 변수를 사용
  }
  printf("val : %d\n", val);
```
} printf("val : %d\n", val); return 0; }
출력결과 val : 21 //2번 출력 val : 10 //1번 출력

자동변수가 메모리에 할당되는 방법

자동변수는 함수의 호출 순서에 따라 할당되고 리턴될 때 회수된다. 따라서 가장 나중에 할당된 자동변수가 가장 먼저 사라진다. -> 메인함수 A, B로 구성된 함수들의 호출과 리턴 예
자동변수는 함수의 호출과 리턴 규칙에 맞게 메모리의 스택 영역에 할당된다.

함수들 간의 데이터 전달 방법

자동변수는 사용범위가 하나의 함수로 제한되기 때문에 함수들 간의 데이터 공유 방법이 필요하다.
값을 복사해서 넘겨주는 방법 : call by value
포인터를 사용하는 방법 : call by pointer

값을 복사해서 넘겨준다(call by value)

일반적인 함수의 호출방법으로 호출함수의 전달인자가 피호출함수의 매개변수에 복사된다.

피호출함수는 리턴할 때 리턴값을 복사하여 호출함수로 전달한다.

#include 
int add_ten(int);
int main()
{
  int a=10;
  a=add_ten(a);
  printf("a : %d\n", a);
  return 0;
}
int add_ten(int b)
{
  b=b+10;
  return b;
}

포인터를 사용한다(call by pointer)

호출함수에서 변수의 포인터를 전달인자로 주고

피호출함수에서는 이 포인터를 받아 호출함수의 변수를 참조하는 방식이다.

#include 
void add_ten(int *);
int main()
{
  int a=10;
  a=add_ten(&a);
  printf("a : %d\n", a);
  return 0;
}
void add_ten(int *b)
{
  *b = *b+10;
}

연습문제

메인함수에서 숫자 두 개 입력받고 곱하여 출력하는 프로그램

포인터를 리턴하는 함수

피호출함수에서 포인터를 리턴하여 호출함수가 피호출함수의 기억공간을 참조할 수 있도록 할 수 있다.
포인터를 리턴하는 함수는 리턴값의 형태가 포인터형이 된다.

int형 변수의 포인터를 리턴하는 경우

int *add_ten(int);  //int형 기억공간의 포인터를 리턴

자동변수의 포인터를 리턴하여 호출함수에서 다시 참조하는 것은 위첨하다
변수 lifetime

```c #include int *add_ten(int); int main() { int a=10; int *ap; ap=add_ten(a); printf("a : %d\n", *ap); //포인터 변수 ap로 add_ten함수의 변수를 참조 return 0; } int *add_ten(int b) { b+=10; return &b; //add_ten함수의 자동변수 b의 포인터를 리턴 }
오류발생 ```
포인터를 리턴하는 경우는 함수가 리턴된 후에도 그 기억공간이 계속 유지되는 경우만 가능하다.

호출함수로부터 포인터를 받아서 다시 리턴하는 경우(문자열 처리 함수들의 예)

char *strcpy(char *A, char *B); //B의 문자열을 A에 복사하고 A를 리턴
char *strcat(char *A, char *B); //B의 문자열을 A에 붙인 후에 A를 리턴
char *gets(char *A); //A에 문자열을 입력하고 A를 리턴

포인터를 리턴하면 좀더 다양한 방식으로 프로그램을 작성할 수 있다.

두 문자열을 붙인 후에 그 결과를 바로 확인하는 예

#include 
#include 
int main()
{
   char src[80]="빈대";
   printf("결과 : %s\n", strcat(src, "떡"));
   return 0;
}

정적 변수(static variable)

정적변수는 함수가 리턴된 후에도 기억공간이 존재
정적변수는 자료형 앞에 static 예약어를 사용하여 선언
```
static int sum; -> 정적 변수의 선언
```
정적 변수는 기억공간의 할당과 초기화가 함수의 호출과 무관하다. ```c #include
void increase(); int main() { int i; for(i=0; i<5; i++) {
```
  increase();
```
} return 0; } void increase() { static int sum=0; //함수가 호출될 때 싱행하는 게 아니라 프로그램이 시작될 때 실행됨 sum++; printf("sum : %d\n", sum); }
출력결과 sum : 1 sum : 2 sum : 3 sum : 4 sum : 5

정적변수는 포인터를 리턴할 수 있다.

정적변수는 함수가 리턴된 후에도 그 기억공간이 유지되기 때문에 그 포인터를 리턴하여 호출하는 함수에서 참조할 수 있다. ```c #include
int *increase(); int main() { int i; int *sp; for(i=0; i<5; i++) {
```
  sp=increase();
  printf("sum : %d\n", *sp);
```
} return 0; } int *increase() { static int sum=0; //함수가 호출될 때 싱행하는 게 아니라 프로그램이 시작될 때 실행됨 sum++; return ∑ }

출력결과 sum : 1 sum : 2 sum : 3 sum : 4 sum : 5

★자동변수는 메모리에서 변수가 사라지기 때문에 더이상 포인터를 가지고 접근할 수 없었는데 정적변수는 리턴 후에도 변수가 유지되기 때문에 포인터를 사용해서 접근할 수 있다.★

연습문제

함수가 호출될 때마다 배열요소의 값을 차례로 리턴하는 함수
즉, 함수가 처음 호출되면 0.1을 리턴하고, 두번쨰 호출되면 0.3을 리턴한다. 줄8 -> 0.1이 시작주소값이 됨 줄20 -> 순서를 기억하도록 사용됨

외부변수

외부변수도 기억공간의 생존기간이 함수의 호출여부와 무관하다.
외부변수는 변수를 함수 밖에 선언
외부변수는 하나의 함수에 속해 있지 않으므로 여러 함수에서 자유롭게 사용할 수 있다.

외부변수를 사용하여 두 변수의 값을 바꾸는 예

#include 
void exchange();
int a, b; //변수를 함수 밖에 선언
int main()
{
  printf("정수값 두 개를 입력 : ");
  scanf("%d%d", &a, &b);
  exchange(); //전달인자 없이 호출된다.
  printf("a : %d, b: %d\n", a, b);
  return 0;
}
void exchange()
{
  int temp; 
  temp=a;  //외부변수 a, b를
  a=b;  //자신의 변수인 것처럼
  b=temp;  //사용한다.
}

외부변수를 사용할 때 주의할 점

외부변수는 여러 함수가 공유하므로 데이터의 안전성을 보장 받을 수 없다. 따라서 외부변수의 값에 변화가 생긴다면 다른 함수에 미치는 영향도 살펴야 한다.
외부변수와 같은 이름의 변수를 함수 내에서 선언하는 경우는 함수내에서 선언된 변수를 우선적으로 참조한다.

연습문제

값을 처리하는 함수

get_next함수 현재 배열요소의 값을 리턴하고 다음 배열 요소로 이동 get_before함수 현재 배열요소의 값을 리턴하고 이전 배열 요소로 이동
.

extern 지정자

extern 지정자는 컴파일러에게 변수가 현재 범위가 아닌 다른 곳에서 선언되어 있음을 알리는 역할을 한다.
지정된 변수는 반드시 다른 소스 파일에 정의되어 있어야 한다.
주로 외부파일에서 정의된 전역 변수를 현재 파일에서 사용하려고 할 때 사용되는 경우가 많다.

register 지정자

register 지정자는 변수를 레지스터 변수로 만든다.
레지스터 변수는 지역변수만 가능하다.
레지스터 변수는 메모리에 저장되는 것이 아니라 레지스터에 저장된다.

레지스터는 cpu내부에 위치하는 입출력 속도가 매우 빠른 임시 저장 장소라 할 수 있다.

//register1.c
#include 
int main()
{
  register int i;
  int j;
  for(i=0; i<100; i++) j+=i;
  printf("%u %u\n", &i, &j);
  return 0;
}

변수의 유효 범위

[C언어] 문자열의 처리

Sat, 16 Sep 2023 17:08:55 GMT

문자열의 연산

문자열은 배열의 형태로 구현된 응용자료형이므로 연산을 자유롭게 할 수 없다.

배열에 저장된 문자열의 길이를 계산하는 작업도 간단하지 않다.

char str[80]="dream";
int count=0;
int i=0;
while(str[i] != '\0')
{
  count++;
  i++;
}
printf("배열에 저장된 문자열의 길이 : %d", count);

문자열의 연산에는 문자열 복사, 길이 계산, 대소비교, 문자열 붙이기 등이 있다.
프로그램에서 사용된 모든 문자열은 메모리에 배열의 형태로 저장된다.
문자열이 컴파일되면 첫 번째 문자를 가리키는 포인터로 치환된다.
결국 문자열상수는 char형을 가리키는 포인터이다.
```
#include 
```

int main() { printf("주소값을 출력 : %u\n", "dream"); printf("첫번째 문자를 출력 : %c\n", *"dream"); printf("세번째 문자를 출력 : %c\n", "dream"[2]); return 0; }

-> 68 69 70 71 72 73 "dream" == 'd' 'r' 'e' 'a' 'm' '\0' 주소값을 출력 : 4350068 첫번째 문자를 출력 : d 세번째 문자를 출력 : c

★문자열은 컴파일이 되면 문자열이 저장되어 있는 임시메모리(임시버퍼)의 시작주소값으로 치환이 된다.★


> ### 포인터변수로 문자열 처리하기
- 문자열상수가 포인터이므로 포인터변수에 저장하여 사용할 수 있다.
```c
#컴파일 전
char *name;            //포인터변수 선언
name = "Lee Gayeong";  //포인터변수에 포인터 저장
#컴파일 후
포인터변수 name   ->  Lee Gayeong
포인터변수는 문자열의 첫 번째 문자를 가리킨다.

printf("이름 : %s\n", name);
printf("여섯번째 문자 : %c\n", name[5]);

문자열 상수는 상수이므로 포인터변수로 그 값을 바꿀 수 없다. ```c char * name = "Lee Gayeong"; name[5] = 'K' //오류
문자열이 상수이므로 'G'를 'K'로 바꿀 수 없다. ```
그러나 포인터변수의 값을 바꿀 수 있으므로 포인터변수가 문자열상수의 중간을 가리키게끔 할 수 있다.

포인터변수는 여러 개의 문자열을 선택하여 처리할 수 있다.

#include 
int main()
{
  int age;
  char *greeting;  //포인터 변수 선언
  printf("나이를 입력 : ");
  scanf("%d", &age);
  if(age>30) greeting="처음 뵙겠습니다.";
  else greeting="반가워요"; //나이에 따라 서로 다른 문자열을 저장
  printf("인사말 ; %s\n", greeting);
  return 0;
}

연습문제

문자열에서 원하는 문자만 골라서 출력 출력된 값 : wtreo

문자열상수의 두 얼굴

문자열상수를 포인터변수에 초기화하는 것과 배열에 초기화하는 것은 서로 다른 의미를 가짐

char *fruit = "strawberry";    //포인터변수에 포인터를 초기화
char fruit[20] = "strawberry"; //배열에 문자열상수와 데이터를 복사

배열에 문자열상수로 초기화하는 것은 특별한 경우로 선언과 동시에 초기화할 때만 가능하다. ```c char fruit[20]; fruit = "strawberry"; (X) 배열명 주소상수 문자열 주소상수
상수를 상수에 대입하는 것이므로 불가능하다!

문자배열에 문자열상수를 저장하려면?

문자열상수의 문자들을 직접 하니씩 배열해 복사해야 한다.

문자열을 복사하는 함수를 만들어보자

user_srtcpy(fruit, "strawberry");  //함수 호출
         배열명    문자열상수
void user_strcpy(char *des, char *src);  //함수의 원형 선언
               복사될 배열   복사할 문자열

함수로 문자열을 복사하는 프로그램

#include 
void user_strcpy(char *, char *);
int main()
{
    char fruit[20]; //fruit="strawberry";와 같이 사용할 수 없으므로
    user_strcpy(fruit, "strawberry"); //함수를 만들어 문자열을 일일이 배열에 복사한다.
    printf("배열에 저장된 문자열 : %s\n", fruit);
    return 0;
}
void user_strcpy(char *des, char *src)
{
    while(*src!='\0')
    {
        *des = *src;
        src++;
        des++;
    }
    *des = '\0';
}

중요한 문자열 처리 함수

문자열 복사 함수(strcpy)

문자열 상수나 배열에 저장된 문자열을 다른 배열에 복사 ```c char *strcpy(char *, char *); //문자열의 복사, string copy
```
      배열주소  배열, string..등
```
두 번째 전달인자로 주어지는 문자열을 첫번째 전달인자의 위치에 복사 ```

두 배열에 저장된 문자열을 바꾸는 프로그램

#include 
#include 
int main()
{
  char str1[20]="apple";
  char str2[20]="banana";
  char temp[20];
  strcpy(temp, str1);
  strcpy(str1, str2);
  strcpy(str2, temp);
  printf("str1 : %s\n", str1);
  printf("str2 : %s\n", str2);
  return 0;
}

연습문제

문자열 교환 프로그램

문자열의 길이를 계산하는 함수(strlen)

문자열상수나 배열에 저장된 문자열의 길이를 계산해준다.
```
unsigned int strlen(char *); //문자열의 길이 계산, string length
```

전달인자로 주어지는 문자열의 길이를 계산하여 리턴한다.(널문자 제외)

char fruit[80]="apple";
int len;
len = strlen(fruit);
printf("문자열의 길이 : %d\n", len);  //문자열의 길이 : 5

배열에 저장된 문자열의 길이만을 계산해 준다.

sizeof(fruit) -> 80 //배열 전체의 크기
strlen(fruit) -> 5  //배열에 저장된 문자열의 크기

문자열 상수나 문자열을 가리키는 포인터 변수를 사용할 수도 있다.
```
char *strp = "apple";
strlen(strp);
strlen("banana");
```

연습문제

strlen 함수 사용

연습문제

user_strlen 함수 사용

문자열을 비교하는 함수(strcmp)

두 문자열의 사전적 순서를 따진다.

int strcmp(char *str1, char *str2); //문자열의 비교, string compare

두 문자열을 비교하여 리턴하는 값(사전의 뒤에 나오는 것이 큰 문자열임)

크기 비교    str1 > str2     str1 < str2      str1 == str2
리턴값           1               -1                0

사전적 순서
프로그램에서는 알파벳 순서가 빠르면 아스키코드 값이 작으므로 사전에 먼저 나오는 문자열이 작은 문자열로 처리된다.

두 문자열의 순서를 따져서 사전순서로 바꾸는 예

#include 
#include 
int main()
{
  char str1[20]="banana";
  char str2[20]="apple";
  char temp[20];
  int res;
  res = strcmp(str1, str2);
  if(res>0)   //str1이 더 크면 문자열을 바꾼다
  {
      strcpy(temp, str1);
      strcpy(str1, str2);
      strcpy(str2, temp);
  }
  printf("str1 : %s\n", str1);
  printf("str2 : %s\n", str2);
  return 0;
}

연습문제

strcmp 함수 사용

두 개의 문자열을 붙이는 함수(strcat)

두 문자열을 붙여서 하나의 문자열을 만든다.

char *strcat(char *str1, char *str2); //string concatenation

str2의 문자열을 str1의 문자열 뒤에 붙인다.

#include 
#include 
int main()
{
   char fruit[80]="straw";
   strcat(fruit, "berry");
   printf("연결된 문자열 : %s\n", fruit);
   return 0;
}

연습문제

strcat 함수 사용

문자열의 입출력

scanf함수는 빈칸이 포함된 문자열은 입력할 수 없다. ```c char str[80]; printf("문자열을 입력하세요 : "); scanf("%s", str); printf("입력된 문자열 : %s\n", str);
문자열을 입력하세요 : 백번 보는 것보다 한번 짜보는 것이 낫다. 입력된 문자열 : 백번 //첫번째 빈칸 이후의 문자열은 입력되지 않았다. ```
문자열의 입출력은 전용함수를 사용한다.
한 줄을 모두 입력하는 함수(gets)
문자열을 출력하는 함수(puts)

한 줄을 모두 입력하는 함수(gets)

gets함수는 빈칸을 포함하여 한 줄을 입력할 수 있다. -> "Enter"
```
char *gets(char *); //문자열의 입력. get string
```
전달인자는 입력 받을 배열의 주소이다.
입력된 문자열이 충분히 저장될 수 있도록 배열을 선언해야 한다.
데이터를 입력한 후에 마지막에 널문자를 붙여서 문자열을 완성한다.

```c char str[80]; printf("문자열을 입력 : "); gets(str); printf("입력된 문자열 : %s\n", str);
문자열을 입력하세요 : 백번 보는 것보다 한번 짜보는 것이 낫다. 입력된 문자열 : 백번 보는 것보다 한번 짜보는 것이 낫다.

문자열을 출력하는 함수(puts)

puts함수는 문자열만을 출력하는 전용 함수이다.
```
int puts(char *); //문자열의 출력, put string
```
문자열만을 출력하므로 printf함수보다 훨씬 작고 간편하다.
출력할 문자열이 저장된 배열명을 전달인자로 준다.
문자열을 출력한 후에는 자동으로 줄이 바뀐다.

```c char str[80]; printf("문자열을 입력하세요 : "); gets(str); printf("입력된 문자열 ; "); puts(str); //printf("%s\n", str);
문자열을 입력하세요 : 백번 보는 것보다 한번 짜보는 것이 낫다. 입력된 문자열 : 백번 보는 것보다 한번 짜보는 것이 낫다. _ //커서의 위치

연습문제

소설 이어쓰기 프로그램

연습문제

소설 이어쓰기 프로그램

문자 입출력 함수

하나의 문자만을 전용으로 입출력하는 함수들이 있다.

하나의 문자를 입출력

하나의 문자를 입출력할 때는 문자 전용 입출력함수를 사용하는 것이 효율적이다.

int getchar();  //하나의 문자를 입력, get character
int putchar(int);  //하나의 문자를 출력, put character

getchar함수는 키보드로부터 문자를 입력 받아서 리턴한다.
putchar함수는 전달인자로 주어지는 문자를 화면에 출력한다.

두 함수 모두 stdio.h 헤더파일을 include하면 사용할 수 있다.

#include
int main()
{
   int ch;
   printf("문자 하나를 입력하세요 : ");
   ch=getchar();
   printf("입력된 문자 : ");
   putchar(ch);
   return 0;
}

문자열을 입출력

하나의 문자를 반복적으로 입출력하려면 문자열의 입출력이 된다.
문자열을 입력할 때는 마지막에 반드시 널문자를 채워준다.

배열에 "love"문자열을 입력하는 예

#include
int main()
{
   char str[80];  //문자열을 저장할 배열
   int ch;    //getchar함수의 리턴값을 지정할 변수
   int i;  //반복 제어변수
   printf("문자열을 입력하세요 : ");
   for(i=0; i<4; i++)  //i는 0부터 3까지 변하려면 4번 반복
   {  
       ch=getchar();   //키보드로부터 문자를 입력 받아 리턴
       str[i]=ch;    //리턴된 문자를 배열에 차례로 저장
   }
   str[i]='\0';    //마지막에 널문자를 저장하여 문자열을 완성
   printf("입력된 문자열 : ");
   i=0;           //제어변수를 다시 0으로 초기화
   while(str[i]='\0')  //배열요소가 널문자가 아닌 동안 반복
   { 
       putchar(str[i]);  //화면에 문자 출력
       i++;     //다음 문자로 이동
   }
   return 0;
}

데이터의 입력은 버퍼를 사용

키보드에서 입력되는 데이터는 일단 버퍼에 저장되고 getchar함수는 버퍼로부터 데이터를 가져오므로 문자열은 한번에 입력한다.
```
문자열을 입력하세요 : love
입력된 문자열 : love
```

문자를 하나씩 입력하면 새줄문자로 입력되므로 문제가 발생한다.

문자열을 입력하세요 : l
0       //두 번째 문자를 입력할 때 입력이 끝난다
입력된 문자열 : l
0

한 줄을 입력

getchar함수가 새줄문자(\n)도 하나의 문자로 입력하므로 이 문자를 이용하여 한 줄을 입력 받을 수 있다.

printf("문자열을 입력하세요 : ");
while(1)  //무한 반복
{
  ch = getchar();   //버퍼로부터 문자 하나를 입력
  if(ch=='\n') break; //그 문자가 새줄문자이면 입력 종료
  str[i]=ch;  //배열요소에 입력한 문자 저장
  i++;   //다음 배열요소를 이동
}
str[i]='\0';  //마지막에 널문자를 넣어 문자열을 완성한다

여러 줄을 입력

새줄문자도 하나의 문자로 입력하면 여러 주릉ㄹ 하나의 문자열로 입력할 수 있다. 단, 입력의 종료는 ctrl+z키를 누른다.
getchar함수는 키보드에서 ctrl+Z키가 눌려지면 '-1'을 리턴하므로 이 값을 비교하여 입력을 종료할 수 있다.

``` printf("문자열을 입력하세요 : "); while(1) { ch=getchar(); if(ch==-1) break; //getchar함수가 -1을 리턴하면 입력을 종료 str[i]=ch; 9++; } str[i]='\0'; printf("입력된 문자열 : "); puts(str);
문자열을 입력하세요 : 지금 열심히 살면 나의 미래가 바뀐다. ^Z 입력된 문자열 : 지금 열심히 살면 나의 미래가 바뀐다.

연습문제

소설 이어쓰기 프로그램

[C언어] 퍼즐 게임 만들기 실습

Sun, 10 Sep 2023 15:56:40 GMT

소스 파일들

puzzle(1차원 배열)

int getKey()
void init(int *puzzle)
int check(int *puzzle)
void display(int *puzzle)
void getIndex(int key, int currentIndex, int *changeIndex)
void change(int *puzzle, int currentIndex, int changeIndex)

change

puzzle배열에서 puzzle[currentIndex]와 puzzle[changeIndex]값을 상호교환한다.

getIndex

key와 currentIndex(0의 위치)를 입력받음
0의 위치를 key값에 따라 새로 계산하여 그 결과를 changeIndex가 가르키는 주소에 저장
index가 수정되었으면 1을 리턴하고 수정되지 않았으면 0을 리턴

[up]

changeIndex <- currentIndex-3
단, currentIndex > 2 이면 변경하지 않는다.

[down]

changeIndex <- currentIndex+3
단, currentIndex > 5 이면 변경하지 않는다.

[right]

changeIndex <- currentIndex+1
단, currentIndex == 2,5,8 이면 변경하지 않는다. currentIndex%3==2

[left]

changeIndex <- currentIndex-1
단, currentIndex == 0,3,6 이면 변경하지 않는다. currentIndex%3==0

display

system("cls")함수를 호출하여 콘솔 화면을 지운 후, puzzle 배열의 값을 콘솔 창에 출력함.

check

puzzle 배열에 저장된 값이 {1,2,3,4,5,6,7,8,0}인지 확인
순서가 맞으면 1을 리턴하고, 맞지 않으면 0을 리턴한다.

init

0~8사이의 서로 다른 난수 9개를 생성
생성한 난수를 puzzle배열에 저장

getKey

상/하/좌/우 키를 입력 받아 그 키 값을 리턴한다.

getch()

콘솔에서 단일 문자를 읽는다. 이 중 어느것도, CTRL+C를 읽을 수 없다.
화살표 키 또는 기능 키를 읽을 때, 각 함수는 두 번 호출되어야 한다.

kbhit()

콘솔에서 최근 키 입력을 확인한다. 이 함수가 0이 아닌 값을 반환하면 키 입력이 버퍼에서 대기 중인 것이다.

게임 실행

이동키를 사용하여 별을 움직여 숫자들을 순서대로 이동시킨다.

비슷한 게임으로는 숫자 퍼즐게임이 있다.

[C언어] 배열과 포인터

Sun, 10 Sep 2023 10:32:03 GMT

포인터로 배열 다루기

배열의 모든 값을 출력하는 함수를 만들 때 -> 배열요소의 값을 일일이 전달인자로 주는 것은 한계가 있다.

배열의 선언 int ary[5] = {10, 20, 30, 40, 50}
함수의 호출 ary_prn(ary[0], ary[1], ary[2], ary[3], ary[4]);
     -> 모든 배열요소를 일일이 전달인자로 줘야 한다.

함수의 정의 void ary_prn(int a, int b, int c, int d, int e) { printf("%d, %d, %d, %d, %d\n", a, b, c, d, e); }

- 포인터를 사용하면 배열요소의 값을 간단히 처리할 수 있다.

> ### 포인터로 배열요소를 참조하자
- 배열은 연속된 기억공간이 할당된다.
- 배열은 첫번째 배열요소의 포인터만 알면 -> 나머지 배열요소의 포인터도 쉽게 알 수 있다.
```c
                x     x+4   x+8    x+12   x+16
int ary[5];    int    int   int    int    int
               [0]    [1]   [2]    [3]    [4]

포인터 연산 : 포인터에 정수값을 더할 때는 포인터가 가리키는 크기를 곱해서 더해준다.

예를 들어 4를 더하면 마지막 배열요소의 포인터가 구해진다.

포인터 + (정수값 * 포인터가 가리키는 자료형의 크기)
&ary[0] + 4 = &ary[0] + (4*sizeof(int)) = 36 + 16 = 52번지
★포인터 연산의 결과는 "저장위치"

모든 배열요소의 포인터는 첫번째 배열요소의 포인터에 정수값을 차례로 더하면 구해진다.

int ary[5] = {10, 20, 30, 40, 50};

&ary[0] + 0 = 36 ----> 10  ary[0]
&ary[0] + 1 = 40 ----> 20  ary[1]
&ary[0] + 2 = 44 ----> 30  ary[2]
&ary[0] + 3 = 48 ----> 40  ary[3]
&ary[0] + 4 = 52 ----> 50  ary[4]

각 배열요소의 포인터에 참조연산자를 사용하면 모든 값을 참조할 수 있다. ```c
(&ary[0] + i) //i는 반복 제어변수 ㄴ-포인터가 가리키는 기억공간 참조 ( ~ ) -> 각 배열 요소를 가리키는 포인터를 차례로 계산
for(i=0; i<5; i++){ printf("%d\n", *(&ary[0]+i)); } ```
배열명을 포인터 변수에 저장하면 포인터 변수도 배열명처럼 사용.
이 때 포인터 변수는 첫번째 배열요소를 가리킨다.
```
int *ap = ary; //배열명을 포인터변수에 저장
```

배열명 = 포인터

배열명은 첫 번째 배열요소를 가리키는 포인터를 기호화한 것이다.
```
★ ary == &ary[0] ★
★ ary + i == &ary[0] + i ★
```
따라서 배열명으로 주소값을 계산하여 모든 배열요소를 참조할 수 있으며 의미상 이해하기 쉽게 배열표현을 주로 사용하는 것이다. ```c for(i=0; i<5; i++){ printf("%d\n", *(ary+i)); }
배열표현 포인터표현 ary[0] == *(ary+0) ary[1] == *(ary+1) ary[2] == *(ary+2)

연습문제

배열의 평균값 구하기
평균값 : 8.76

포인터를 사용한 배열요소의 참조 정리

포인터(변수)로 배열요소를 참조하는 방법

배열명(ary)을 사용한 배열표현
배열명(ary)을 사용한 포인터표현
배열명을 저장한 포인터변수(ap)를 사용한 포인터표현
배열명을 저장한 포인터변수(ap)를 사용한 배열표현
```
int ary[5] = {10, 20, 30, 40 50};
int *ap = ary;
```

배열명 != 포인터변수

배열명은 포인터 상수이므로 자신의 값을 바꿀 수 없다.

ary += 2;
ary++;     //배열명은 변수가 아니므로 자신의 값을 바꾸는 거 불가능

포인터변수는 기억공간이므로 자신의 값을 바꿀 수 있다.

int ary[5]={10, 20, 30, 40, 50};
int *ap=ary;
int i;
for(i=0; i<5; i++)
{
  printf("%5d", *ap);
  ap++;
}

연습문제

배열값 거꾸로 출력 ```c
ap = ary + 4 //ap선언, ary+4해서 초기화 시킴. 3.5를 가리키는 주소값이 ap에 들어감. ap-- //ap=ap-1;과 같은 의미. 아까 +4씩해서 주소를 연산했는데 지금은 -4씩 해서 주소를 연산할 것이다. 그 전에 저장되어 있는 위치. 그럼 3.5 전에 있는 위치인 2.3을 출력...이렇게 계속 하면 1.5까지 출력됨

배열의 값을 출력하는 함수

배열명을 전달인자로 받으므로 매개변수는 포인터변수를 선언
```
#include 
void ary_prn(int *);  //함수 선언
```

int main() { int ary[5]={10, 20, 30, 40, 50}; //배열의 선언과 초기화 ary_prn(ary); //배열명을 전달인자로 주고 호출함 ★ return 0; }

void ary_prn(int *ap) //배열명을 저장할 포인터변수 선언, ap에 ary들어감★ { int i; for(i=0; i<5; i++) { printf("%5d", ap[i]); //포인터변수를 마치 배열명처럼 사용 //ap[i] = *(ap+i) } }


- 포인터변수는 배열명이 아니므로 sizeof연산시 포인터변수의 크기만 계산된다. 
따라서 포인터변수로 배열요소의 개수를 구할 수 없다. 
**※ 포인터 변수는 무조건 4바이트!!! ※**
```c
sizeof(ap)는 포인터변수의 크기만 계산
//sizeof(ary)/sizeof(ap[0])

배열의 크기가 바뀌어도 출력할 수 있는 함수를 만들 때는 배열요소의 개수를 전달인자로 받아야 한다.

호출할 때 -> ary_prn(ary, sizeof(ary)/sizeof(ary[0]));
                배열명,    배열요소의 개수

void ary_prn(int *ap, int an) //배열요소의 개수를 받을 매개변수를 추가한다.
{
  int i;
  for(i=0; i



배열에 값을 입력하는 함수

배열에 값을 입력할 때는 scanf함수에 각 배열요소의 포인터만을 전달인자로 준다. 
(즉, 주소연산자 (&)를 사용하지 않는다.)void ary_input(int *ap) //배열명을 지정할 포인터변수 선언. ap <- ary, ap에 36번지들어감
{
  int i;
  for(i=0; i<5; i++) //배열요소의 개수만큼 반복
  {
      scanf("%d", ap+i); //각 배열요소의 포인터를 구해서 전달인자로 줌
      //i가 0이면 36번지, i가 1(x4)이면 40번지...etc. 주소값이므로 &연산자 안 붙는다.
  }
}



연습문제


배열의 평균값 구하기

배열의 평균 : 86.60



연습문제


배열의 최소값 구하기

배열의 최소값 : 1.5



[JAVA] 주석문&변수
Wed, 30 Aug 2023 15:51:55 GMT
주석문

프로그램의 코드와 실행에는 영향을 주지 않는 문장


주석의 종류


구현 주석
-행단위 주석(//를 해주면 ,해당 행이 주석 처리됨)
-블럭단위 주석(주석으로 사용할 내용 -> /**/)
문서화 주석(/****/)
문서에 포함할 내용을 작성함
문서화 주석을 클래스, 인터페이스 그리고 멤버 당 하나씩 가질 수 있고, 선언 바로 전에 작성



public class AddNum{
    /**
    * Hello
    * World
    */
}

실습_주석문
public class HelloWorld {
    public static void main(String[] args) {
        /*
        *System.out.println("HelloWorld");
        */
    }
}

변수

값을 저장할 수 있는 메모리의 공간을 의미


변수의 선언


타입 변수이름;
-int cnt;  //정수 값을 담을 수 있는 cnt라는 이름의 변수를 선언
-double avg;  //실수 값을 담을 수 있는 avg라는 변수를 선언 
명명규칙
변수의 이름을 정할 때 자바 언어에서 정해놓은 규칙
식별자는 클래스, 매소드, 변수 등 다양한 대상에 대해 이름이 붙여지는 경우


java 식별자 명명 규칙


하나 이상의 글자로 이루어져야 함
첫 번째 글자는 문자 이거나 '$', '_'이어야 함
두번째 이후의 글자는 숫자, 문자, '$', '_'이어야 함
'$', '_' 이외의 특수문자 사용 불가능
길이 제한이 없음
키워드는 식별자로 사용할 수 없음
상수 값을 표현하는 단어 true, false, null은 식별자로 사용 불가능


변수 명명 관례


첫 번째 문자가 소문자인 명사로 정함
여러 단어로 구성된 이름의 경우 두 번째 단어부터 첫글자를 대문자로 함
'_'을 쓰지 않음
규칙은 반드시 지켜야 한다. 지키지 않으면 컴파일시 에러가 발생
관례는 지키지 않아도 컴파일에러가 발생하지는 않지만, 약속이기 때문에 지켜주는 것이 좋음


변수의 사용


변수명 = 값;cnt = 10;  //cnt라는 int형 변수에 정수값 10을 담음
cnt = 20;  //cnt라는 int형 변수에 정수값 20을 담음, 원래 있던 10은 사라짐
avg = 11.1  //avg라는 double형 변수에 실수값 11.1을 담음



실습_변수
public class VariableExam {
    public static void main(String[] args) {
        // 정수형 변수, number를 선언하고 3을 저장해보세요.
        int number = 3;

        System.out.println(number);
    }
}



[JAVA] 자바 개발순서
Wed, 30 Aug 2023 08:36:51 GMT
자바 개발순서

소스 작성
작성한 소스 컴파일
컴파일한 소스를 JVM을 이용하여 실행


소스 작성

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

컴파일


윈도우 버튼 -> 실행 -> cmd를 입력한 후 엔터 입력
cd c:\tmp로 이동
javac HelloWorld.java로 컴파일


실행


HelloWorld.java 우클릭 -> run as -> 1 java application 클릭
java HelloWorld로 실행


이클립스를 이용하여 똑같이 실행해 보기

eclipse.exe를 실행

사용자 홈디렉토리 아래에 workspace 폴더를 지정
(이클립스를 처음 실행하면 워크스페이스 경로를 물어봅니다. 워크스페이스란 이클립스로 작성한 프로젝트가 저장되는 경로입니다. )

first 프로젝트 생성



소스 작성


src폴더에서 HelloWorld.java파일 생성
앞에서 만들었던 파일과 똑같은 파일을 HelloWorld.java파일로 작성
워크스페이스 경로를 파일탐색기로 열어보면 src폴더에 HelloWorld.java파일 확인 가능


컴파일


bin폴더를 열어보면 HelloWorld.class파일 생성되어있음 (이클립스는 소스파일에 문제가 없다면 자동으로 컴파일하여 bin폴더에 클래스를 만들게 됩니다.)


실행


클래스를 선택한 후 우측버튼을 클릭하고 자바 어플리케이션을 실행하는 메뉴를 선택

gayeong.log

한국어 깨짐

pwd

[Error] 윈도우11 WSL 에러

WSL 완전히 삭제

1. 리눅스 배포판 제거

2. wsl 제거

3. window11에서 wsl 제거

WSL 비활성화

1. PowerShell(관리자 권한)에서 WSL 기능을 완전히 비활성화

2. 가상 머신 플랫폼 비활성화 (WSL 2 사용 시)

3. 컴퓨터 재부팅

4. WSL 상태 확인

그래도 안 된다면 wsl 명령어 앞에 .\를 넣어보세요!

WSL 설치

객체 지향 설계의 5가지 원칙

1. SRP : 단일 책임 원칙 (single responsibility principle)

2. OCP : 개방-폐쇄 원칙 (Open/Closed principle)

문제점

정리

[JAVA] 클래스

클래스

객체

객체지향 프로그래밍

Black Box Class

클래스

인스턴스 변수

클래스 변수

메소드

메소드 오버로딩

클래스 메소드

생성자

생성자를 만드는 방법

기본 생성자

생성자2

this()

요약

Getter & Setter

요약

BlackBox.java code

접근 제어자

접근 제어자

BlackBox를 Ctrl C + Ctrl R

※ public은 어디서든지 접근 가능하다.

캡슐화(Encapsulation)

정보은닉(Information hiding)

BlackBoxRefurbish.java Code

패키지

Random Class

상속

Camera code

SpeedCam code_과속 단속 카메라

FactoryCam code_공장 카메라

상속 쓰는 이유

상속 하기 위해서는??

메소드 오버라이딩

SpeedCam code

다형성

Super

앞에서 상속을 한 이유

열거형

정의하는 방법

getwith

Quiz

[JAVA] 메소드

메소드

전달값

반환값

전달값과 반환값

메소드 오버로딩

getPower(String strNumber)

Integer.parseInt(strNumber);

메소드가 필요한 이유

변수의 범위 (Scope)

Main 메소드

string 값을 전달 받는 방법?

Quiz

[JAVA] 배열

배열

변수 vs 배열