체대생에서 개발자로

[문제 설명]

한 자리 정수로 이루어진 문자열 num_str이 주어질 때, 각 자리수의 합을 return하도록 solution 함수를 완성해주세요.

[입출력 예]

[차근 차근 생각해보기]

1. num_str을 한자리 씩 나눈 후
2. String 배열에 담아준 다음
3. str의 길이 만큼 돌면서
4. str의 i번째 요소를 정수로 변환하여 answer에 더해준다.

[결과]

class Solution {
    public int solution(String num_str) {
        int answer = 0;
        
        String[] str = num_str.split("");

        for(int i = 0; i < str.length; i++){
            answer += Integer.parseInt(str[i]);
        }
        
        return answer;
    }
}

[반성할 점]

• 처음에 split메소드로 나누어 주지 않고 num_str 길이까지 돌면서 charAt()으로 요소를 가져왔다.
• 하지만 char 타입은 정수로 파싱이 되지 않아
• split으로 나눈 다음 배열에 담아주고 i번째 요소를 정수로 변환하여 더해주는 방식을 택했다.
• 찾아보니 charAt()으론 Character.getNumericValue() 메소드로 정수를 변환해 줄 수 있다고 한다.
  • 대신 주어진 문자가 0 ~ 9사이의 숫자인 경우에만 해당 숫자를 반환하고 그 외엔 -1을 반환한다.

[문제 설명]

정수 리스트 num_list가 주어질 때, 첫 번째로 나오는 음수의 인덱스를 return하도록 solution 함수를 완성해주세요. 음수가 없다면 -1을 return합니다.

[입출력 예]

[차근 차근 생각해보기]

1.  num_list의 길이 만큼 돌면서
2.  num_list의 i번째 요소가 음수이면
3. 인덱스를 반환하고
4.  음수가 없으면 -1을 반환하기

[결과]

class Solution {
    public int solution(int[] num_list) {
        int answer = -1;
        
        for(int i = 0; i < num_list.length; i++){
            if(num_list[i] < 0){
                return i;
            }
        }
        return answer;
    }
}

[반성할 점]

• num_list의 i번째 요소가 음수이면 [answer = i] 를 해주었더니 테스트 통과가 되지 않았다.
• 문제에서 '첫번째'로 나오는 음수의 인덱스를 return하도록 해주어라 라고 조건이 명시 되어 있었고
• 나는 한 배열에서 음수가 여러개 나올 것이라는 것을 고려하지 못했다.
• 앞으로는 문제 잘 읽고 조건 하나하나 생각해보기..

[조건]

- 인터페이스를 이용하여 놀이공원 티켓 구입 하는 프로그램 만들기

public interface AmusementPark{
    void buyTicket();
}

public class TicketBox implements AmusementPark{
    @Override
    public void buyTicket(){
        System.out.println("티켓을 구입합니다.");
    }
}

public class Adult{
    private AmusementPark amusementPark;

    public void setAmusementPark(AmusementPark amusementPark){
        this.amusementPark = amusementPark;
    }

    public void price(){
        System.out.println("입장료는 50000원 입니다.");
    }

    public void buyTicket(){
       this.amusementPark.buyTicket();
    }
}

public static void main(String[] args){
    Adult adult = new Adult();
    adult.setAmusementPark(new TicketBox());
    adult.buyTicket();
}

// 실행 결과 => 티켓을 구입합니다.

[반성할 점]

아직 인터페이스에 대해 개념이 잘 안잡힌 것 같다.

조금 더 공부 후에 간단한 프로그램을 다시 만들어봐야할 것 같다.

• 기존의 클래스는 하나의 클래스만 상속 받을 수 있는 단일 상속의 특징을 갖고 있었지만
• 인터페이스는 다중 상속이 가능하다.
• 클래스들이 필수로 구현해야하는 추상 메서드와 상수만 사용가능하다.

즉, 추상 클래스는 미완성된 클래스라고 하면 인터페이스는 뼈대만 제공하는 클래스라고 할 수 있다.

지금부터 코드를 통해 인터페이스에 대해 공부해보자..!

public class Adult {
    public void buyTicket(){
        System.out.println("티켓을 구입합니다.");
    }
}

public class Child{
    public void buyTicket(){
    	System.out.println("티켓을 구입합니다.");
    }
}

두개의 클래스는 buyTicket을 하는 공통된 기능을 사용하고 있다. 

구현해야할 코드가 많아진다면 중복 되는 코드도 많아질 것이기 때문에

공통되는 'buyTicket'을 인터페이스로 만들 수 있다.

// 인터페이스
public interface BuyTicket{ 
    void buyTicket();
}

public class TicketBox implements BuyTicket{
    @Override
    public void buyTicket(){
        System.out.println("티켓을 구입합니다.");
    }
}

public static void main(String[] args){
    TicketBox ticketBox = new TicketBox();
    ticketBox.buyTicket();
}

// 실행 결과 => 티켓을 구입합니다.

위와 같이 동일한 기능을 하는 코드를 중복해서 사용하기 보다는

인터페이스를 통해 중복 코드를 줄일 수 있다.

1. 추상클래스

• 추상 클래스는 아직 완성되지 않은 클래스라고 할 수 있다.
• 추상 클래스는 객체를 생성할 수 없고, 추상 클래스를 상속한 자식 클래스만 객체를 생성 할 수 있다.
• 추상 클래스에는 추상 메소드를 만들 수 있다.

2. 추상 메소드

• 추상 클래스 혹은 인터페이스에서 사용 가능한 메소드이다.
• 껍데기만 있는 메소드라고 할 수 있다.
• 추상 메소드는 상속한 자식 클래스에서 반드시 구현해야한다.

public abstract class AmusementPark{ // 추상 클래스
    public void isChild(){
        System.out.println("어린이가 입장합니다.")
    }

    public void isAdult(){
        System.out.println("어른이 입장합니다.")
    }

    public abstract void price(); // 추상 메소드
    
}

public class AdultTicket extends AmusementPark{
    @Override
    public void price(){ // 추상 클래스를 상속 받은 자식은 반드시 추상 메소드를 구현해야함
        System.out.println("어른의 입장료는 50000원 입니다.");
    }
}

public class ChildTicket extends AmusementPark{
    @Override
    public void price(){
        System.out.println("어린이의 입장료는 30000원 입니다.");
    }
}

위와 같이 'abstract' 키워드를 사용하여 추상 클래스와 추상 메소드를 만들 수 있다.

public static void main(String[] args){

    // AmusmentPark amusementPark = new AmusementPark();처럼 추상 클래스는 객체 생성 불가
    AdultTicket adult = new AdultTicket();
    adult.price();

    ChildTicket child = new ChildTicket();
    child.price();
}

// 출력 결과 
// 어른의 입장료는 50000원 입니다.
// 어린이의 입장료는 30000원 입니다.

메인 메소드에서는 위와 같이 사용할 수 있다.

[조건]

• 각각의 클래스 생성
• 샌드위치 재료를 표시하는 메소드 정의
• 공통 부분은 오버라이딩

public static void main(String[] args){
    Sandwich sandwiches = new Sandwich[3];
    sandwiches[0] = new EggSandwich();
    sandwiches[1] = new ChickenSandwich();
    sandwiches[2] = new BeefSandwich();

    for(Sandwich sandwich : sandwiches){
        sandwich.cook();
        System.out.println("-------------");
    }
}

class EggSandwich{
    public String name;

    public EggSandwich(){
        this("계란 샌드위치")
    }

    public EggSandwich(String name){
        this.name = name;
    }

    public void cook(){
        System.out.println(this.name + "의 재료는?");
        System.out.println("식빵");
        System.out.println("양상추");
        System.out.println("피클");
        System.out.println("계란");
    }
}

class ChickenSandwich extends EggSandwich{
    public ChickenSandwich(){
        super("치킨 샌드위치")
    }

	@Overriding
    public void cook(){
        super.cook();
        System.out.println("치킨");
    }
}

class BeefSandwich extends EggSandwich{
    public BeefSandwich(){
        super("소고기 샌드위치")
    }

    @Overriding
     public void cook(){
        super.cook();
        System.out.println("소고기");
    }
}

[반성할 점]

• 오버라이딩 후 부모 클래스의 메소드를 가져올때 super.메소드 이름을 하여 가져올 수 있다.

1. 접근제어자(Access Modifier)

• 멤버 또는 클래스에 사용되어 해당하는 멤버 또는 클래스를 외부에서 접근하지 못하도록 제한하는 역할을 함
• 접근제어자는 클래스 / 멤버변수 / 메서드 / 생성자에서 사용된다.
• 클래스 내부에서 선언된 데이터를 보호하기 위해 사용함(객체지향의 캡슐화에 해당됨)
• 데이터를 외부에서 함부로 변경하지 못하도록 하기 위함

2. 상속(Inheritance)

• 자식 클래스가 부모 클래스의 기능을 사용할 수 있는 것.
• 접근 제어자가 private을 갖는 필드나 메서드는 상속 불가
• 패키지가 다를 경우 접근제어자가 default인 경우 상속 불가
• 중복된 코드를 줄일 수 있고, 유지보수가 편리한 장점이 있음

public class Cafe{
    String coffee;
    int price;
    
    public void menu(){
    	System.out.println(coffe + "는 " + price + "원 입니다.");
    }
}

public class HelloCafe extends Cafe{
    HelloCafe(String coffee, int price){
        this.coffee = coffee;
        this.price = price;
    }
}

public static void main(String[] args){
    HelloCafe hc = new HelloCafe("아메리카노", 1500);
    hc.menu();
}

// 출력결과 ==> 아메리카노는 1500원 입니다.

3. 메소드 오버라이딩

• 부모 클래스로부터 상속받은 메소드를 자식 클래스에서 재정의 하여 사용하는 것.
• 부모 메소드의 이름, 리턴 타입, 매개변수의 개수, 자료형과 순서를 동일하게 해야한다.
• 자식 클래스에서 부모의 메소드를 수정해야할 때 사용한다.
• 부모 메소드는 은닉되고, 자식 클래스에서 재정의된 메소드만 호출된다.(super로 부모 메소드 호출 가능)

public class Exercise {
	public String name;
    
    public Exercise(){
    	this("운동")
    }
    
    public Exercise(String name){
    	this.name = name;
    }
    
    public void effective(){
    	System.out.println(this.name + "의 주요 효과는 다이어트입니다.");
    }
}

public class Soccer extends Exercise {
    public Soccer(){
        super("축구");
    }

    @Override
    public void effective(){
        System.out.println(this.name + "의 주요 효과는 심폐지구력 향상입니다.");
    }
}

4. 열거형(Enum)

• 클래스 처럼 보이게 하는 상수, 서로 관련 있는 상수들끼리 모아 상수들을 정의 한 것이다.
• 열거형으로 선언된 순서에 따라 0부터 index의 값을 가진다.
• 열거형으로 지정된 상수는 모두 대문자로 선언한다.
• 열거형 변수 선언 후 세미콜론은 사용하지 않는다.
• 상수와 특정 값을 연결 시킬 경우 마지막에 세미콜론을 붙여주어야 한다.

enum Phone{
    GB(512), TB(1);

    private final int capacity;

    Phone(int capacity){
        this.capacity = capacity
    }
    
    public int getCapacity(){
    	return capacity;
    }
}

public static void main(String[] args){
    Phone phone = Phone.GB;
    System.out.println("휴대폰의 용량은 " + phone);

    for(Phone cp : Phone.values()){
        System.out.println("휴대폰의 용량은 " + cp.getCapacity);
    }

}

1. 메소드 오버로딩

• 같은 이름의 메소드를 여러 번 선언
• 매개변수의 타입이나, 개수가 달라야 한다.
• 매번 메소드를 호출할 때마다 값을 넣어주지 않고 고정 하고 싶다면 info(값) 처럼 작성할 수 있음

void info(String manufacture, int capacity){
    System.out.println("휴대폰 제조사는 " + manufacture + " 입니다");
    System.out.println("휴대폰 용량은 " + capacity + "GB 입니다");
}

void info(){
    info("애플", 256); // 위의 info 메소드 호출
}

2. 클래스 메소드

static void serviceCenter(){
    System.out.println("서비스 센터의 전화번호는 02-1234-1234 입니다");
}

// 사용법
클래스이름.메소드이름(); // 호출 가능

• static이 붙지 않은 메소드는 객체마다 서로 다른 동작을 한다.(인스턴스 변수의 값이 다르기 때문에)
• static이 붙은 클래스 메소드는 항상 같은 동작만 한다.
• 객체를 생성하지 않더라도 호출할 수 있다.
• 메소드 내에서 인스턴스 변수가 사용되지 않을 경우,
• 전달 받은 값만 처리하고 반환하려고 할때  클래스 메소드를 사용한다.

3. This

public class Phone {
    String name;

    void phoneInfo(String name){
        this.name += name;
    }
}

public static void main(String[] args){
	Phone phone = new Phone();
	phone.name = "아이폰14Pro";
	phone.phonInfo(" 2023년형");
}

// 출력 결과 ==> 아이폰14Pro 2023년형

• 객체, 자기 자신을 나타낸다
• this.name은 클래스 인스턴스 변수로 선언된 name을 말한다.
• name은 전달 값으로 전달 받은 String name을 나타낸다.

4. 생성자(Constructor)

• new연산자를 통해 인스턴스가 생성될 때 호출되고 제일 먼저 실행되는 메서드
• 인스턴스 변수를 초기화 시키는 역할을 한다.
• new 연산자가 인스턴스 생성 하는 것 (생성자가 인스턴스 생성하는 것은 아님!)
• 생성자가 정의 되어 있지 않을 경우 컴파일러가 알아서 기본 생성자를 추가해서 컴파일 한다.

// 클래스이름(){}
Phone(){ // 기본 생성자

}

// 클래스이름(매개변수){}
Phone(String name, int capacity){ // 매개변수가 있는 생성자
    this.name = name;
    this.capacity = capacity;
}

5. Getter & Setter

• OOP에서는 객체 외부에서 직접적인 접근을 막는다.
  • 외부에서 데이터를 읽고 변경 시 객체의 무결성이 깨질 수 있기 때문
  • 메소드를 통해 데이터를 변경한다.
• 접근제어자 private은 해당 클래스 내에서만 접근 가능함
• Setter : private으로 선언된 변수의 값을 수정할때 사용
• Getter : 데이터를 읽어올때 사용

class Phone(){
    private String name;
    private int capacity;

    public String getName(){
        return name;
    }

    public String setName(String name){
        this.name = name;
    }

     public int getcapacity(){
        return capacity;
    }

    public int setcapacity(int capacity){
        this.capacity = capacity;
    }
}

public static void main(String[] args){
    Phone phone = new Phone();
    phone.setName("아이폰14Pro Max");
    phone.setCapacity(512);

    System.out.println("이름 : " + phone.getName());
    System.out.println("용량 : " + phone.getCapacity() + "GB");
}

1. 클래스

• 흔히 설계도와 같다고 이야기 함
• 객체를 생성하는데 사용됨

class Phone{
	String name = "아이폰";
	int price = 1000000;
	String color = "화이트";
}

2. 객체지향 프로그래밍 (OOP, Object-Oriented Programming)

• 객체 지향은 유지보수에 용이하다.
• 높은 재사용성의 특징이 있다.

3. 객체

• 객체는 클래스의 인스턴스
• 실재로 존재하는 것, 사물 또는 개념
• 생성 방법 👉 클래스명 변수명 = new 클래스명();

4. 인스턴스(Instance)

• 인스턴스는 클래스의 객체가 메모리에 할당되어 실제로 존재하는 상태를 의미

Phone phone = new Phone(); // 객체 생성(인스턴스)
phone.name = "아이폰"; // 인스턴스의 멤버변수에 접근
phone.price = "1000000";
phone.color = "화이트";

5. new 연산자

• 인스턴스를 생성해주는 역할
• 메모리에 데이터를 저장할 공간을 할당 받아
• 할당 받은 공간에 참조값을 객체에 반환하여 생성자를 호출한다.

6. 메서드

• 함수(function)라고도 한다.
• 특정 작업(기능)을 처리하기 위해 정의한 코드들의 묶음
• 반환 타입이 void가 아닐 경우 꼭! return(반환값)이 있어야 한다.

반환타입 메소드이름(자료형 변수명, ...){
	// 구현 코드
}

[조건]

• 개인 정보를 비공개 하는 메소드 작성

[예시]

홍길동 -> 홍**

230607-1234567 -> 230607-*******

010-1234-5678 -> 010-1234-****

[차근 차근 생각해보기]

1. 개인 정보 비공개 메소드 만들기
2. String 타입의 정보(info)와, int 타입의 비공개 시작 위치(split)을 매개 변수로 넘겨주기
3. info의 길이만큼 돌면서 split의 위치부터 *로 치환하기
4. return 하여 출력하기

public static void main(String[] args){
    String name = "홍길동";
    String id = "230607-1234567";
    String phone = "010-1234-5678";

    System.out.println("이름 = " + hidden(name, 1);
    System.out.println("이름 = " + hidden(id, 7);
    System.out.println("이름 = " + hidden(phone, 9);
}
public static String hidden(String info, int split){
    String result = info.substring(0, split);
    String str = info.substring(split);

    for(int i = 0; i < str.length(); i++){
        result += "*";
    }
    return result;
}

[반성해야할 점]

for(int i = 0; i < str.length(); i++){
    str += "*";
}

• 맨 처음에 위와 같은 코드로 작성했음 (str에 *을 더해줘야 한다고 생각)
• str은 길동이 나오게 되는데 위와 같은 코드로 작성하게 되면 길동* -> 길동** 이런 식으로 반복되게 됨.
• 때문에 result에 *을 더해주어야 str의 길이 만큼 *이 더해지게 된다.
• 즉, 정리하자면 연산할 변수를 잘못 파악하였음😭