• 클래스 간의 상속이란?

  -> 클래스간에는 부모-자식의 상속 관계를 설정할 수 있다.

  -> 부모 클래스 A를 자식 클래스 B가 상속받을 때, B는 A의 모든 멤버변수와 메서드를 자신의 것으로 상속받게 된다. (단, private으로 설정된 기능은 상속되지 않는다.) -> B는 A의 public, protected 기능들은 직접적으로 코딩하지 않더라도 자신의 것으로 사용할 수 있게 된다.

📌 상속 정의 방법

• extends 키워드를 사용하여 부모 클래스의 이름을 명시한다.

public class 자식클래스 extends 부모클래스 { ... }

📌 클래스 다이어그램을 통한 상속의 표현

• 클래스의 구조를 표현하는 클래스 다이어그램에서, 상속은 자식 클래스가 부모 클래스를 가리키는 화살표로 표현한다.

• 클래스 다이어그램에는 상속관계, 클래스이름, 생성자, 메서드 등을 표현한다.
• 상속관계가 이루어 질 때 부모클래스를 super 클래스라 한다.

📌 상속의 활용

• 기존에 존재하는 클래스의 소스 수정없이 기능을 확장하고자 하는 경우 -> CalcChild 클래스는 CalcParent 클래스를 상속받기 때문에, 별도의 소스코딩 없이도 plus() 메서드와 minus() 메서드를 포함하게 된다 -> CalcChild 클래스에 times()메서드와 divide() 메서드를 추가하면, 상속받는 메서드에 새로운 기능을 추가하는 효과를 얻을 수 있다.

// CalcParent 클래스
package extandsclass;
// 덧셈과 뺄셈의 기능을 갖는 클래스를 준비한다
public class CalcParent {
    // 생성자를 특별히 정의하지 않은 경우
    // 자바 컴파일러가 기본 생성자가 있다고 간주하기 때문에,
    // 클래스 다이어그램에서는 기본 생성자를 명시한다
    public int plus(int x, int y) {
        return x + y;
    }
    public int minus(int x, int y) {
        return x - y;
    }
}
// -------------------------------------------
// CalcChild클래스
package extandsclass;
// CalcParent를 상속받는 클래스
// 부모의 모든 기능을 상속받고 있으며,
// 곱셈과 나눗셈을 추가하여 부모의 기능을 확장
public class CalcChild extends CalcParent{
    public int times(int x, int y) {
        return x * y;    
    }
    public int divide(int x, int y) {
        int result = 0;
        if(y != 0) {
            result = x / y;
        }    
        return result;
    }
}
// -------------------------------------------
// 출력 Main클래스
package extandsclass;
public class Main01 {
    public static void main(String[] args) {
        CalcParent parent = new CalcParent();
        System.out.println(parent.plus(100, 50));
        System.out.println(parent.minus(100, 50));
        System.out.println("------------------------------");
        CalcChild child = new CalcChild();
        System.out.println(child.divide(200, 100));
        System.out.println(child.times(200, 100));
        System.out.println(child.plus(200, 100));
        System.out.println(child.minus(200, 100));    
    }    
}

• 여러개의 클래스에서 공통되는 기능을 추출하여 공유하기 -> 질문/ 답변 게시물의 한 단위를 표현하기 위한 QNAArticle 클래스와 자료실의 게시물을 표현하기 위한 FileArticle은 글 번호와 제목이라는 공통된 특성을 갖는다 -> Article 클래스는 QNAArticle 클래스와 FileArticle 클래스가 공통적으로 포함하고 있는 멤버변수인 "글번호(num)", "제목(title)"과 이 변수들에 대한 getter, setter를 추출한 것이다 -> 이와 같이 공통 기능을 별도의 클래스로 추출해 내면, 코드의 재사용 및 수정이 용이하다

  // Article 클래스
  package extandsclass;
  /*
  * 게시판의 일반적인 기능을 구현한다
  * 자료실과 질문/답변 게시판은 기본적인 게시판의 기능을 포함하고 있기 때문에,
  * 이 클래스는 두 가지 클래스의 공통 기능을 추출한 개념이다
  */
  public class Article {
  private int num;         // 글번호
  private String title;     // 제목
  public int getNum() {
      return num;
  }
  public void setNum(int num) {
      this.num = num;
  }
  public String getTitle() {
      return title;
  }
  public void setTitle(String title) {
      this.title = title;
  }    
  }
  // -------------------------------------------
  // QNAArticle 클래스
  package extandsclass;
  /*
  * Article 클래스 상속받고, 
  * 부모클래스의 title을 질문으로 보고, 답변을 추가
  * main 메서드를 포함하고 있는 class생성, 
  * 글번호, 질문(글 제목), 답변 데이터 set
  * 글번호, 질문(글 제목), 답변 데이터 get으로 출력
  */
  public class QNAArticle extends Article{
  private String answer;
  public String getAnswer(){
      return answer;
  }
  public void setAnswer(String answer) {
      this.answer = answer;
  }
  public String toString() {
      return "질문/답변 [글번호 = " + getNum() 
          + ", 제목 = " + getTitle()
          + ", 답변 = " + getAnswer();
  }
  }
  // -------------------------------------------
  // FileArticle 클래스
  package extandsclass;
  public class FileArticle extends Article {
  private String fileName;
  public String getFileName() {
      return fileName;
  }
  public void setFileName(String fileName) {
      this.fileName = fileName;
  }
  public String toString() {
      return "자료실[번호 = " + getNum()
      + " , 제목 = "+ getTitle()
      + " , 첨부파일 = " + getFileName()
      + " ] ";
  }
  }
  // -------------------------------------------
  // 출력 Main클래스
  package extandsclass;
  public class Main02 {
  public static void main(String[] args) {
      QNAArticle qna = new QNAArticle();
      qna.setNum(1);
      qna.setTitle("첫 번째 질문입니다.");
      qna.setAnswer("첫 번째 답변입니다.");
  //        System.out.println(qna.getNum());
  //        System.out.println(qna.getTitle());
  //        System.out.println(qna.getAnswer())    
      System.out.println("질문/답변 [글번호 = " + qna.getNum() 
      + ", 제목 = " + qna.getTitle() 
      + ", 답변 =" + qna.getAnswer());
      System.out.println(qna.toString());
  System.out.println("=========================================");
      FileArticle file = new FileArticle();
      file.setNum(10);
      file.setTitle("10번째 자료입니다.");
      file.setFileName("dat10.ppt");
      System.out.println(file.toString())    
  }    
  }
  

```

땅 위에 달팽이가 있다. 이 달팽이는 높이가 V미터인 나무 막대를 올라갈 것이다. 달팽이는 낮에 A미터 올라갈 수 있다. 하지만, 밤에 잠을 자는 동안 B미터 미끄러진다. 또, 정상에 올라간 후에는 미끄러지지 않는다. 달팽이가 나무 막대를 모두 올라가려면, 며칠이 걸리는지 구하는 프로그램을 작성하시오.

📌 입력

첫째 줄에 세 정수 A, B, V가 공백으로 구분되어서 주어진다. (1 ≤ B < A ≤ V ≤ 1,000,000,000)

📌 출력

첫째 줄에 달팽이가 나무 막대를 모두 올라가는데 며칠이 걸리는지 출력한다.

📌 코드

package test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
public class test1 {
    public static void main(String[] args) throws IOException {

//         스캐너 사용
//        Scanner in = new Scanner(System.in);
//        
//        int a = in.nextInt(); // 달팽이가 낮에 올라가는 미터
//        int b = in.nextInt(); // 밤에 자는동안 미끄러지는 미터
//        int v = in.nextInt(); // 나무막대의 높이
//        
//        int day = (v - b) / (a - b);
//        
//        if((v - b) % (a - b) != 0) {
//            day++;
//        }
//    
//        System.out.println(day);

//         버퍼 사용                
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine(), " ");

        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        int v = Integer.parseInt(st.nextToken());

        int day = (v - b) / (a - b);

        if((v - b) % (a - b) != 0) {
            day++;
        }

        System.out.println(day);

    }
}

<출처 : https://www.acmicpc.net/problem/2869 >

다솜이는 은진이의 옆집에 새로 이사왔다.
다솜이는 자기 방 번호를 예쁜 플라스틱 숫자로 문에 붙이려고 한다. 다솜이의 옆집에서는 플라스틱 숫자를 한 세트로 판다. 한 세트에는 0번부터 9번까지 숫자가 하나씩 들어있다. 다솜이의 방 번호가 주어졌을 때, 필요한 세트의 개수의 최솟값을 출력하시오. (6은 9를 뒤집어서 이용할 수 있고, 9는 6을 뒤집어서 이용할 수 있다.)

📌 입력

첫째 줄에 다솜이의 방 번호 N이 주어진다. N은 1,000,000보다 작거나 같은 자연수이다.

📌 출력

첫째 줄에 필요한 세트의 개수를 출력한다.

📌 코드

package test;
import java.util.Scanner;
public class test2 {    
    public static void main(String[] args)     
        Scanner sc = new Scanner(System.in);
        // 문자열로 입력받기
        String st = sc.nextLine();
        // 6을 9으로 교체
//        st = st.replaceAll("9", "6");
        st = st.replaceAll("6", "9");
        // 0~9 까지 10개의 int배열
        int[] arr = new int[10];
        // 최댓값 변수 선언
        int max = 0;
        for(int i = 0; i < st.length(); i++) {
            // 숫자에 해당하는 배열 인덱스의 값을 ++함
            // -48 을 하는 이유 : 0의 아스키코드값
            int num = (int)(st.charAt(i)-48);
            arr[num]++;
        }
        // 9의 경우
        if(arr[9] != 0) {
            // 6를 포함하기 때문 2로 나눈후 
            // 반올림을 하여 인덱스 9의 값을 바꿔줌
            arr[9] = Math.round(arr[9]/2.0f);
        }
        for(int i = 0; i < arr.length; i++) {
            // int배열을 확인하면서 최대값을 구함
            max = Math.max(arr[i], max);
        }
        System.out.println(max);
    }
}

<출처 : https://www.acmicpc.net/problem/1475 >

• 멤버변수나 메서드가 객체에 노출되지 않도록 설정하는 기법

• 객체를 사용하는 측의 실수로 인한 기능의 오작동을 방지하기 위해, 클래스 일부를 숨기는 처리를 말한다.

📌 접근한정자

• 변수 이름이나 메서드 이름앞에 "접근 한정자"를 지정한다.

package hiding;
class Student{
    public String name = "자바학생";
    private int weight = 100;
}
public class Main01 {
    public static void main(String[] args) {
        Student std = new Student();
        // public 이므로 접근 가능
        System.out.println(std.name);
        // private 이므로 접근 불가능
        // System.out.println(std.weight
    }    
}

📌 클래스와 접근한정자

• 클래스에 접근 한정자를 지정한 경우
  
  • 클래스의 분리 --> 하나의 소스코드에서 프로그램의 모든 기능을 구현하게 되면 유지보수에 비효율적 이므로, 기능단위로 소스코드를 분리해야 한다. --> 소스코드가 분리된 클래스끼리는 public이 명시되어야만 서로 객체 생성이 가능하다. --> 일반적으로 클래스 정의에는 public 접근 한정자만 사용한다. --> 하나의 소스코드에는 하나의 public 클래스만 존재할 수 있다.

📌 멤버변수의 은닉처리

• 거의 대부분의 멤버변수는 은닉처리를 기본으로 한다.

📌 getter, setter

• 멤버변수가 은닉된 형태로 선언된 경우 프로그램의 가장 근본적인 목적인 데이터에 접근하는 방법이 사라진다.

• 메서드를 통하여 간접적으로 접근하는 방법이 마련되어야 한다.
• getter, setter는 은닉된 멤버변수에 간접적으로 접근하기 위하여 정의된 메서드들을 의미하는 용어이다.
• 메서드 작성 예
• 'get', 'set' 접두사 뒤에 변수이름을 첫 글자가 대문자인 형태로 명시
• getter는 연결된 멤버변수의 데이터 타입을 리턴형으로 명시
• setter는 연결된 멤버변수의 데이터 타입을 파라미터 형으로 명시

  package hiding;
  class StudentJava2{
  // 은닉된 멤버변수 -> 현재 블록 안에서만 접근가능함
  private String name;
  private int age;    
  // getter 메서드 2개
  // 은닉된 멤버변수의 값을 읽는 방법
  public String getName() {
     return this.name;
  }
  public int getAge() {
     return this.age;
  }    
  // setter 메서드 2개
  // 은닉된 멤버변수에 값을 넣는 방법
  public void setName(String name) {
     this.name = name;
  }
  public void setAge(int age) {
     this.age = age;
  }        
  }
  public class Main03 {
  public static void main(String[] args) {
     // 객체생성
     StudentJava2 sj = new StudentJava2();        
     // setter 임의의 데이터 세팅, name, age 모두
     sj.setName("JAVA학생");
     sj.setAge(20);        
     // getter 출력, name, age 모두
     System.out.println(sj.getName());
     System.out.println(sj.getAge())    
  }
  }

📌 자바빈즈(JavaBeans)

• 자바 언어에서 사용하는 복합적인 데이터 표현의 최소 단위로서, 재사용 가능한 컴포넌트(구성요소)를 생성할 수 있다.

• 자바빈즈 클래스로서 작동하기 위해서, 객체 클래스는 명명법, 생성법 그리고 행동에 관련되어 일련의 관례를 따라야만 한다.
• 지켜야할 관례 -> 클래스는 생성자를 가지고 있어야한다. -> 클래스 속성들은 getter, setter 메서드들을 사용해 접근할 수 있어야 한다.

📌 캡슐화 (자바빈즈 사용이유)

• 접근 제한자는 객체지향의 캡슐화, 그리고 그를 통한 은닉화를 위한 도구이다.

• 데이터를 외부로부터 숨기거나, 접근을 막고, 또는 접근에 처리를 강제화한다.
• 유사한 기능이나 변수를 한 집합으로 하여 더 관리하기 쉽게하고 코드를 명확히 함
• 외부에서 멤버를 엑세스하는 방법을 지정할 수 있도록, 직접 접근을 막거나 접근 전 부가적인 처리를 요구함
• 정보를 외부에 은닉하여 외부에서는 해당 집합의 세부 내용에 집중하지 않도록 함

  class Person{
      int age;
      void howOld(){
          system.out.println( age );
      }
  }
  class Main{
      public static void main( String[] args ){
          Person p1 = new Person();
          p1.age = -1;
          p1.howOld();
      }
  }
  //------------------------------------------------------------------
  // setter는 이렇게 변수의 값 대입이 여러 곳에서, 제한 없이 가능한 것을 접근 제한자로 막고,
  // 접근 범위에 한해서 메소드로 대입전 값을 처리 후 대입되게 하기 위해 사용된다.
          class Person{
          private int age;
          public void setAge( int age ){
              if( age >= 0 ){
                  this.age = age;
              } else {
                  this.age = 0;
              }
          }
          void howOld(){
              system.out.println( age );
          }
      }
  class Main{
      public static void main( String[] args ){
          Person p1 = new Person();
          p1.age = -1;
          p1.howOld();
      }
  }
  /* 변수의 접근을 private로 처리해서 해당 클래스 안에서만 노출되게 바꾸고, 
  다른 사람들도 사용할 필요가 있는 변수들만 getter를 이용해서 드러냈다.
  이렇게 변수들의 외부 노출을 제한하고, 노출 범위를 정해주는 것이 getter */
  class Person{
      private int age;
      private String name;
      private String hobby;
      private String gender;
      public void setGender( String gender ){
          this.gender = gender;
      }
      public void setAge( int age ){
          if( age >= 0 ){
              this.age = age;
          } else {
              this.age = 0;
          }
      }
      void howOld(){
          system.out.println( age );
      }
  }

• 클래스안에서 "자기자신"을 표현하는 키워드

📌 this를 사용하여 지역변수와 멤버변수(전역변수) 구분하기

• 멤버변수와 지역변수가 동일한 이름으로 공존할 경우, 유효성 범위가 작은 변수가 우선적으로 인식된다.

class Student{
        String name;
        public void setName(){
            String name;
            name = "자바학생";        // 현재 지역변수 name
            this.name = "JSP학생";    // 클래스 멤버변수로 선언된  name
        }
    }

• this를 사용하여 파라미터와 멤버변수 구하기 -> 파라미터도 해당 메서드 안에서만 유효한 지역변수의 일종이다. -> 파라미터를 사용하여 멤버변수의 값을 간접적으로 설정하고자 할 경우, 이름은 동일하게 지정하고 this 키워드를 사용하여 멤버변수와 파라미터를 구별하는 것이 java언어의 일반적인 처리 방식이다.

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

  • 모든 멤버변수 앞에는 this 키워드를 사용하여 멤버변수임을 직관적으로 표시하는 것이 소스코드의 가독성을 위하여 바람직하다.

📌 this를 사용한 간단한 예제

• StudentUser 클래스를 사용해서 객체를 생성 후 객체의 메서드 만을 사용해서 전역변수 name에 "자바학생"을 할당하고 출력하여라.

package object;
class studentUser{
      String name;    
    public void setName(String name) {
        this.name = name;
    }    
    public String getName() {
        return this.name;
    }
}
public class Main06 {
    public static void main(String[] args) {
        // 객체생성
          studentUser su = new studentUser();
        // 전역변수 name에 "자바학생"할당
          su.setName("자바학생");
        System.out.println(su.getName());    
    }    
}

📌 현재 클래스의 메서드를 의미하는 용도로서의 this

• 메서드의 경우 this.getName()이 아닌, getName()만 사용하더라도 코드 가독성의 문제는 없다.

📌 this 키워드를 활용한 멤버변수와 메서드의 접근

• 멤버변수는 지역변수와 구별하기 위하여 가급적 this를 통하여 접근한다.

• 메서드에 접근할 때 this 키워드를 사용하는 것이 필수적인 것은 아니다.

📌 클래스, 메서드, 상수의 공통 이름 규칙

• 영어, 숫자, 언더바(_)의 조합, 첫 글자는 반드시 영어로 표기한다.

📌 클래스의 이름 규칙

• 첫 글자는 대문자로 시작, 나머지 글자는 소문자로 표시한다.

• 두 개 이상의 단어를 조합해야 할 경우 새로운 단어는 대문자로 시작한다.

📌 메서드, 변수 이름 규칙

• 대부분 소문자로 구성되지만, 두 개 이상의 단어를 조합할 경우 새로운 단어는 대문자로 표기한다.

📌 상수 이름 규칙

• 모두 대문자로 표시한다.

• 프로그래밍에서의 객체는 프로그램에서 표현하고자 하는 기능을 묶기 위한 단위

📌 객체를 구성하는 단위

• 객체를 이루는 것은 데이터와 기능이다.

• 데이터는 변수로 표현된다.
• 객체안에 포함된 변수를 '멤버변수' 혹은 '프로퍼티'라 한다.
• 기능은 메서드(=함수)로 표현된다.

📌 클래스와 객체의 관계

• 객체를 생성하기 위해서 객체의 설계도가 필요하다.

• 객체의 설계도 역할을 하는 프로그램 소스 -> 클래스(Class)
• 공장에서 하나의 설계도를 사용하여 여러 개의 제품을 생산할 수 있는 것처럼 하나의 클래스를 통해 동일한 구조를 갖는 객체를 여러 개 생성할 수 있다.
  • 자동차의 엔진, 문, 바퀴 등은 멤버변수로 존재할 수 있다.
  • 전진, 후진 등은 메서드의 형태로 표현된다.

📌 자동차 클래스의 예

• 동일한 설계로 만들어진 자동차라 하더라도 각각의 자동차를 구성하는 부품들은 그 형태만 같을 뿐, 실제로는 각각 존재하게 된다.

• 클래스를 작성하면서 그 안에 생성되는 멤버변수들은 여러 개의 객체간에 서로 동일한 이름으로 존재하지만 실제로는 서로 다른 값이라는 의미

📌 클래스의 기본 작성 방법

• 'class'라는 예약어와 클래스의 이름을 명시하고 {...} 블록을 구성한다.

• 멤버변수는 여러 개 존재할 수 있다. 이 때, 값을 선언과 동시에 할당할 수도 있고, 객체를 통해 간접적으로 할당할 수 도 있다.
• 메서드는 여러 개 존재할 수 있다.
• 클래스 안에 포함된 멤버변수와 메서드를 특성에 따라 그룹화 하기 위한 기법이 클래스를 작성하는 것이라고 이해할 수 있다.

  class 클래스이름{
      멤버변수;
      void  메서드이름(){
      }
  }

📌 객체의 생성 방법

• 객체의 선언

클래스이름 객체이름;
ex) Student std;

• 객체의 할당

  객체이름 = new 클래스이름();
  ex) std = new Student();

• 선언과 할당의 통합

  클래스이름 객체이름 = new 클래스이름();
  ex) Student std2 = new Student();

📌 객체의 사용

• 객체 안에 포함된 변수나 메서드는 점(.)으로 연결하여 접근한다.
  👉 객체 안에 포함된 변수의 값을 다른 변수에 복사하는 경우

변수 = 객체이름.멤버변수;

👉 객체 안에 포함된 변수의 값에 다른 값으로 대입하는 경우

객체이름.멤버변수 = 값;

👉 객체 안에 포함된 메서드를 호출하는 경우

객체이름.메서드이름();

👉 객체 안에 포함된 메서드에 파라미터를 전달하는 경우

객체이름.메서드이름(값1,값2,...,값n);

📌 클래스를 정의하면서 멤버변수에 값을 직접 대입하는 경우

• 같은 클래스로 객체를 여러개 생성할 경우, 모든 객체가 동일한 값을 갖게된다.

            std        name = "자바학생"
                    age = 19
    Student
            std2    name = "자바학생"
                    age = 19        

• 독립성 : 같은 클래스를 통하여 생성된 객체라 할지라도 서로 다른 값을 대입하면 서로 독립적인 형태로 존재하게 된다.

package object;
class Character{
    // 일반적으로 멤버변수는 선언만 한다
    String name;
    int age;
}
public class Main02 {
    public static void main(String[] args) {
        // 하나의 클래스가 정의되면, 그 클래스의 구조를 기반으로 하는
        // 객체(=Object)를 여러개 생성할 수 있다        
        Character d = new Character();
            d.name = "둘리";
            d.age = 20;        
        Character h = new Character();
            h.name = "희동";
            h.age = 3;
        System.out.println("이름 : " + d.name + " , 나이 : " + d.age);
        System.out.println("이름 : " + h.name + " , 나이 : " + h.age);    
        }
}

• 출력값

📌 값이 대입되지 않은 멤버변수를 갖는 클래스

• 클래스란 객체를 위한 틀을 제공하는 것이기 때문에 클래스 작성과정에서 멤버변수에 대입된 값은, 객체를 통하여 멤버변수의 값을 지정하기 전까지 사용될 "기본값"으로서의 의미이다.

• 객체를 통하여 새로운 값이 대입되면 클래스 작성시에 멤버변수에 대입한 값은 의미를 잃어버리게 된다.
  • 때문에 일반적으로 클래스 작성시에는 멤버변수에 값을 지정하지 않는다.

📌 메서드를 포함하는 클래스

• 메서드란 프로그램에서 하나의 동작 단위를 의미한다.

• 두 개 이상의 메서드가 서로 동일한 대상을 위해서 존재할 경우, 이 메서드들을 클래스에 포함시켜 그룹화 할 수 있다.
  • 클래스에 멤버변수와 메서드가 공존할 경우, 멤버변수는 모든 메서드가 공유하는 전역 변수로 존재하게 된다.
  • 변수의 종류

  • 멤버변수(=전역변수) : 클래스 안에서 선언된 변수로서, 클래스 블록 범위 안에서 유효하다.

  • 지역변수 : 메서드 안에서 선언된 변수로서, 메서드의 블록을 빠져나가지 못한다. 그러므로 다른 메서드는 해당 변수를 인식하지 못한다. 이 규칙은 조건, 반복문과 같은 블록 {}를 형성하는 모든 경우에 해당된다.

    package object;
    class HelloWorld{
    // 멤버변수(전역변수)는 모든 메서드가 공유한다
    String message;    
    void sayHello() {System.out.println(message);}
    void setEng() {message = "Hello Java";}
    void setKor() {message = "안녕하세요. 자바";    }    
    }
    public class Main03 {
    public static void main(String[] args) {
       HelloWorld hello = new HelloWorld()    
       // 메서드 호출 
       hello.sayHello();
       hello.setEng();
       hello.sayHello();
       hello.setKor();
       hello.sayHello();
       hello.setEng();
       hello.setKor();
       hello.setEng();
       hello.setKor();
       hello.sayHello();        
    }    
    }

  • 출력값

📌 참고

• 지역변수와 전역변수가 선언되는 메모리 영역이 다르다.

• 전역변수(멤버변수)는 Heap 영역에 저장
• 지역변수는 Stack영역에 저장 -> 자동으로 초기화 되지 않는다.
• heap : 프로그래머가 원하는 방식으로 쓸 수 있는 공간, 긴 생명주기를 가진 데이터들이 저장
• stack : 아주 잠깐 사용하고 삭제할 데이터의 저장공간

📌 메서드만을 포함하는 클래스

• 객체 안에 멤버변수(=데이터)가 포함되지 않는다.

• 객체 안에 포함된 메서드를 호출하여 결과를 만들기 위한 목적이므로 굳이 여러 개의 객체를 생성할 필요가 없다. 👉 계산기능을 갖는 클래스의 예

  class Calc{
     // plus, parma int x, int y, return
       int plus(int x, int y) {
           return x + y;
       }
   //minus, parma int x, int y, return
       int minus(int x, int y) {
           return x - y;
       }    
   // times, parma int x, int y, return
       int times(int x, int y) {
           return x * y;
       }    
   // divide, parma int x, int y, return
       int divide(int x, int y) {
           int result = 0;
           if(y != 0) { // 0으로 나눌수 없으므로
           result = x / y; 
       }
   }

  👉 기능의 활용 : 두 개의 값을 위하여 객체를 각각 생성하는 경우

   Calc c1 = new Calc();
       int a = c1.sum( 100, 200 );
       System.out.println( a );
   Calc c2 = new Calc();
       int b = c2.sum( 200, 300 );
       System.out.println( b );    

  • 파라미터에 의해 결과를 리턴하는 경우, 서로 다른 값을 위하여 객체를 여러개 생성할 필요가 없다.
  • 자체적으로 데이터를 갖는 형태가 아니라 외부적인 요인인 파라미터에 의해서 결과가 생성되므로, 하나의 객체를 재사용하는 것이 바람직하다. Calc c1 = new Calc(); int a = c1.sum( 100, 200 ); System.out.println( a ); int b = c1.sum( 200, 300 ); System.out.println( b );

• 프로그램의 시작점

• java 프로그램이 시작되는 시작점을 의미하는 main은 public, static, void, main, (String[] args) 라는 키워드로 구성된 하나의 {...} 블록이다.

📌 다른이름의 메서드 만들기

📌 프로그램의 함수 = 메서드

• 특정 기능(=연산)을 그룹화 해서 재사용하기 위한 단위

// 메서드
  public static void f() {
          int x = 100;
          int y = x + 1;
          System.out.println(y);
      }

📌 메서드의 호출

• 정의된 메서드는 다른 메서드를 구성하는 {...} 안에서 다음의 형식으로 사용 될수 있으며, 이를 메서드를 호출한다고 한다.

// 메서드 호출
        // 여러번 사용이 가능하다
        f();
        f();
        f();
        f();

📌 메서드 파라미터

• java 프로그램의 메서드(=함수)는 자신이 실행되는데 필요한 조건값을 메서드 이름 뒤의 괄호안에서 변수 형태로 선언한다.

• 이를 메서드 파라미터라고 한다.

  // 메서드 파라미터 
  public static void f1(int a) {
        int b = 10;
        System.out.println(a + b);
    }

📌 다중 파라미터

• 메서드가 연산을 수행하는데 두 개 이상의 파라미터가 필요하다면 콤마(,)로 구분하여 선언할 수 있다.

// 다중 파라미터
public static void plus (int x, int y) {
        System.out.println(x + y);
    }    
    public static void minus (int x, int y) {
        System.out.println(x - y);
    }

📌 파라미터를 갖는 메서드의 호출

• 메서드 정의하면서 파라미터가 명시되어 있다면 해당 메서드를 호출하면서 파라미터를 전달해 주어야 한다.

📌 메서드의 리턴값

• 메서드가 연산 결과를 자신이 호출된 위치에 반환하는 것을 "리턴"이라고 하며, 반환되는 값을 "리턴 값"이라고 한다.

• 메서드 안에서 값을 리턴하기 위해서는 "return" 이라는 키워드가 사용된다.
• 값을 리턴하는 메서드는 선언시에 "void" 키워드 대신, 리턴하는 값에 대한 변수형이 명시된다. void는 리턴값이 없다는 의미이다.

  // 메서드의 리턴값
  public static void main(String[] args) {
      // 메서드의 리턴값을 변수에 저장
      int z = f1(5);
      System.out.println(z);
      boolean result = f2(10);
      System.out.println(result);
      // 리턴값을 출력에 사용
      System.out.println(f2(2));
  }    
  public static int f1(int x) {
      int y = x + 1;
      return y;
  }
  public static boolean f2(int x) {
      if(x > 5) {
          return true;
      }else {
          return false;
      }
  }

📌 메서드간의 상호 호출

• JAVA의 메서드 역시 서로 호출하는 것이 가능하다.

• 호출된 메서드가 값을 리턴하는 경우, 리턴받은 값을 다른 연산에 사용할 수 있다.

📌 메서드 간단한 예제 풀이

문제 1. "Hello, World~" , "메서드가 호출되었습니다." 를 출력하는 메서드를 각각 만들어 호출하세요

public class Main05 {
    public static void main(String[] args) {
        helloWorld();
         showMsg();
         System.out.println(returnM());
    }    
    public static String returnM() { // String 타입
        return "문자열";
    }
    public static void helloWorld() {
        System.out.println("Hello, World~");
    }    
    public static void showMsg() {
        System.out.println("메서드가 호출되었습니다.");
    }
}

• 출력값
  

  문제 2. 반환값이 없고 받고 인자값(매개변수, 피라미터)이 2개 있는 덧셈 메서드를 구현하여 인자값의 결과값을 출력하여라.

  public class Main06 {
    public static void main(String[] args) {
        plus(10,20);
    }
    public static void plus(int x, int y) {
        int result = x + y;
        System.out.println(result);
    }    
  }

• 출력값

  문제 3. 반환 값이 있고 받는 인자값(매개변수, 피라미터)이 없는 메서드를 구현하세요.

  public class Main07 {
    public static void main(String[] args) {
        System.out.println(returnMethod());
    }
    public static int returnMethod() {
        return 200; // 반환값
    }    
  }

• 출력값

  문제 4. 반환값이 있고, 받는 인자값(매개변수, 피라미터)이 있는 메서드를 구현해보세요.

  public class Main08 {
    public static void main(String[] args) {
        System.out.println(plusM(10, 20));
        System.out.println(plusM(10, 30));
        System.out.println(plusM(10, 40));
        System.out.println(plusM(10, 50));
    }    
    // int a, int b = 인자값
    public static int plusM(int a, int b) {
        return a + b; // 반환값
    }    
  }

• 출력값

// 배열 선언
int[] num = new int[] {22,3,8,12};
int sum = 0;
// 배열의 길이만큼 반복문 돌리기
for(int i = 0; i < num.length; i++) {
    sum += num[i];
}
System.out.println("num의 합 : " + sum);

📌 문제2. num2 배열에 저장된 요소의 합과 평균을 구하시오.

// 배열 선언
int[] num2 = new int[] {60, 95, 88};
int sum1 = 0;
//int avg = 0; 합계함수로 평균도 구할 수 있으므로 평균 변수는 따로 주지 않았습니다.
for(int i = 0; i < num2.length; i++) {
    sum1 += num2[i];
}
//avg = sum1 / num2.length; 위와 동일한 이유로 주석처리
System.out.println("문제 2. num2의 합 : " + sum1);
System.out.println("문제 2. num2의 평균 : " + sum1/num2.length);

📌 문제3. num3 배열에 저장된 요소의 최대값을 출력하시오.

int[] num3 = {94, 85, 95, 88, 90};
int max = num3[0]; 
for(int i = 1; i < num3.length; i++) { 
// int i = 0 라고 했을 때 오류는 없지만 굳이 비교 안해도 되는 값을 비교하기 때문에 int i = 1; 로 한다
    if(num3[i] > max) {
        max = num3[i];
    }
}
System.out.println("문제 3. 최대값 : " + max);

📌 num4 배열에 저장된 요소의 홀수와 짝수의 합을 각각 구하시오.

int[] num4 = new int[] {22, 3, 8, 12};
int even = 0; // 짝수
int odd = 0; // 홀수
for(int i = 0; i < num4.length; i++) {
    if(num4[i] % 2 == 0) {
        even += num4[i];
    }else {  
        odd += num4[i];
    }
}
System.out.println("문제 4. 짝수의 합 : " + even);
System.out.println("문제 4. 홀수의 합 : " + odd);

📌 문제 1~4 출력

• 1차 배열의 각 칸에 새로운 배열을 넣는 형태

• 1차 배열의 각 칸은 행이 되고, 각각의 칸에 추가된 개별적인 배열이 "열"의 개념이 되어 "행렬"을 구성하게 된다.

📌 2차 배열의 크기 할당

• 행과 열에 대한 크기를 명시한다 -> 배열이름 = new 데이터형[행][열];

• 2차원 배열의 선언과 할당의 일괄처리 -> 데이터형[][] 배열이름 = new 데이터형[행][열];

📌 2차원 배열의 선언, 크기 할당, 값의 대입에 대한 일괄처리

• 2차원 배열의 경우 블록 괄호 "{}"를 2중으로 겹쳐서 2차원 배열을 표현한다.

• 행과 열의 구분에는 콤마(,)가 사용된다.
• 컴파일러가 블록괄호 "{}"의 요소를 파악하면 행, 열의 크기가 산출될 수 있으므로 배열의 크기 설정을 위한 [][]에는 배열의 크기를 명시하지 않는다.

📌 2차원 배열에 대한 값의 대입 방법

• 행, 열에 대한 인덱스를 통하여 값을 대입한다.
  
• 일괄지정 하는 경우

📌 2차원 배열의 길이

• 2차원 배열의 길이는 행에 대한 측면과 열에 대한 측면을 나누어서 생각해야 한다.

• 행의 길이 -> 1차 배열의 길이는 2차 배열에서는 행의 크기로 조회가 된다. ex ) int rows = grade.length;
• 열의 길이 -> 열의 길이는 각 행에 대하여 개별적으로 조회해야 한다. ex ) int cols = grade[행].length;

📌 2차 배열의 예시 문제

package array;

public class Main01 {

    public static void main(String[] args) {
        // 성적표에 대한 2차 배열 생성
        // 학급 성적을 위한 배열
        int[][] grade = new int[3][3];

        // 둘리의 과목별 점수
        grade[0][0] = 75;
        grade[0][1] = 82;
        grade[0][2] = 91;

        // 도우너의 과목별 점수
        grade[1][0] = 88;
        grade[1][1] = 64;
        grade[1][2] = 50;

        // 또치의 과목별 점수
        grade[2][0] = 100;
        grade[2][1] = 100;
        grade[2][2] = 90;

        // 2차 배열을 탐색하여 총점과 평균점수 구하기
        for(int i = 0; i < grade.length; i++) { // 행
            // 반복문 안에서 선언된 변수는 매 실행시마다 새로 생성된다
            int sum = 0;
            int avg = 0;

            for(int j = 0; j < grade[i].length; j++) { // 열
                // i번째 행의 j번째 열의 데이터를 누적처리
                sum += grade[i][j];
            }

            // i번째 위치의 평균점수 구하기 = 총점 / 과목수
            // i번째 학생의 과목수는 grade 배열의 i번째에 대한 길이
            avg = sum / grade[i].length;

            System.out.println("총점 = " + sum + ", 평균 = " + avg);
        }

    }

}

• 변수를 그룹으로 묶은 형태의 한 종류로서, 사물함 같은 형태를 갖고 있다.

• 하나의 배열안에는 같은 종류(데이터 형)의 값들만 저장될 수 있다.

📌 배열을 만드는 방법

• 배열의 선언
  

• 배열의 생성 : 변수를 저장할 수 있는 사물함을 생성한다.
  
• 배열 생성의 예 : 3개의 int형 변수를 저장할 수 있는 배열 생성
  
  • 배열의 모양
    
• 배열의 선언과 크기 지정에 대한 일괄처리

📌 배열에 값을 저장하기

• 배열은 값을 저장할 수 있는 공간일 뿐, 그 자체가 값은 아니다.

• 값이 대입되지 않은 경우, 숫자형은 0, boolean형은 false가 자동으로 대입된다.
• 배열안에 값을 저장하기 위해서는 인덱스 번호를 사용하여 각각의 칸에 직접 값을 대입해야 한다.

📌 둘리의 점수를 배열로 표현하기

• 둘리의 점수 표
  

• 점수 표를 배열로 표현

📌 배열의 크기 설정과 값 할당에 대한 일괄처리

• 배열의 크기를 지정하면서 괄호 "{...}"안에 배열에 포함될 각 항목들을 콤마(,)로 나열하면, 배열의 성성과 값의 할당을 일괄처리할 수 있다.

• 이 때는 배열의 크기를 별도로 지정하지 않으며, "new 데이형[]" 부분은 생략 가능하다.

📌 배열값 사용하기

• 배열안에 저장되어 있는 값들을 사용하여 연산이나 출력등의 처리를 위해서는 배열에 부여된 인덱스 값을 통해서 데이터에 접근해야 한다.

📌 배열과 반복문

• 배열의 특성 -> 0 ~ (배열의 크기 -1)만큼의 인덱스 값을 순차적으로 갖는다.

• 특성을 활용한 배열 데이터의 처리 -> 일정 범위를 갖고 순차적으로 증가하는 인덱스 값의 특성을 활용하는 반복문 안에서 배열의 값을 할당하거나, 할당된 값을 읽어들이는 처리가 가능하다.

📌 배열의 크기(길이)

• 배열의 길이를 얻기 위해서는 "배열이름.length" 형식으로 접근한다. ex) grade라는 배열을 생성한 경우 배열의 길이는

📌 배열의 예시 문제

package array;

public class Main01 {

    public static void main(String[] args) {
        // 배열의 생성
        // 배열의 선언과 크기 지정 및 값의 할당에 대한 개별 처리
        int[] dooly; 
        dooly = new int[5];
        dooly[0] = 75;
        dooly[1] = 82;
        dooly[2] = 91;
        dooly[3] = 100;
        dooly[4] = 95;

        // 배열의 선언과 크기 지정의 일괄처리
        int[] douneo = new int[3];
        douneo[0] = 88;
        douneo[1] = 64;
        douneo[2] = 50;

        // ddochy
        // 배열 생성의 일괄처리
        int [] ddochy = new int[] {100, 100, 90};

        // 배열 활용
        // 합을 할당한 변수 선언
        // 같은 종류의 변수들은 콤마로 구별하여 한번에 선언 가능함
        int sum1 = 0, sum2 = 0, sum3 = 0;

        // 각 배열 요소의 값에 대한 합계 구하기
        for(int i = 0; i < dooly.length; i++) {
            sum1 += dooly[i];
        }

        System.out.println("dooly sum1 : " + sum1);

        // sum2, douneo 합계 반복문 생성 및 출력
        for(int i = 0; i < douneo.length; i++) {
            sum2 += douneo[i];
        }
        System.out.println("douneo sum2 : " + sum2);

        // sum3. ddochy 합계 반복문 생성 및 출력
        for(int i = 0; i < ddochy.length; i++) {
            sum3 += ddochy[i];
        }
        System.out.println("ddochy sum3 : " + sum3);

        // 평균
         System.out.println("dooly 평균 : " + sum1 / dooly.length);
         System.out.println("douneo 평균 : " + sum2 / douneo.length);
         System.out.println("ddochy 평균 : " + sum3 / ddochy.length);

         float avg1 = (sum1 / dooly.length);
         System.out.println("avg1 : " + avg1);

    }

}

• 반복문이란 프로그램 내에서 똑같은 명령을 일정 횟수만큼 반복하여 수행하도록 제어하는 명령문입니다.

• 프로그램이 처리하는 대부분의 코드는 반복적인 형태가 많으므로, 가장 많이 사용되는 제어문 중 하나입니다.

📌 반복문의 종류

• for문

• while문
• do ~ while문

📌 for문

• for문은 사람이 직접 처리하기에 부담수러운 반복적인 작업을 처리하기에 매우 용이하다.
  

• for문 예제

  // 반복문
        // 1 ~ 5 까지 합
        // 1 + 2 + 3 + 4 + 5 = 15
        // for문
        int sum = 0;        
        // i 값이 1부터 5까지 증가하는 동안, 
        // i 의 값을 sum에 누적한다.
        for(int i = 1; i <= 10; i++ ) {
            // 결과값 누적
            System.out.println("i : " + i);
            sum += i;
            System.out.println("sum : " + sum);
        }        
        System.out.println(sum);

    // 구구단 7단의 결과 값
        int j = 0;        
        for( int i = 1; i < 10; i++ ) {
            j = 7 * i;
            System.out.println(j);
        }

  📌 while문

  • while문 역시 for문과 마찬가지로 반복적인 처리를 수행하는 문법이다

  • for문은 초기식, 조건식, 증감식을 모두 내장하는 반면, while문은 조건식만을 내장하기 때문에 초기식과 증감식을 외부에 따로 정의해 주어야 한다.
    
  • while문 예제

    // while문으로 구구단 7단 출력
        int j = 0;    
        // 초기값
        int i = 1;        
        while(i < 10) {
            j = 7 * i;
            System.out.println(j);
            i++;
        }

    // 1 ~ 10까지 누적된 합
        int sum = 0;
        int i = 1;    
        while( i <= 100 ) {
            sum += i;
            i++;
        }        
        System.out.println(sum);

📌 do ~ while문

• 조건의 판별을 나중에 수행하는 반복문 형태

• 초기식을 설정한 후 do{...} 안의 문장을 우선적으로 1회 실행하고 조건을 판별하므로 조건이 참이 아니더라도 최소 1회는 실행된다.
  

  • do ~ while문 예제

  // do ~ while문, 1 ~ 100 누적된 합
       int sum = 0;
       // 초기식
       int i = 1;        
       do {
           sum += i;
           i++;
       } while(i <= 100);        
       System.out.println(sum);

  // 구구단 7단, do~while문으로 출력        
       // 초기값
       int i = 1;
       int j = 0;        
       do {
           j = 7*i;
           System.out.println(j);
           i++;
       }while(i <= 9);

📌 반복문에서의 흐름제어

• break : 반복문 안에서 break 키워드를 만나면 반복을 강제로 종료한다.

• continue : 실행흐름이 증감식으로 강제 이동된다.

무조건 실행되는 것이 아니라, 특정 조건을 충족할 경우에만 실행되는 구문

📌 조건문의 종류

• if문 : 주어진 '조건'이 참(true)일 경우에만 실행된다.

• if ~ else 문 : 주어진 조건이 참(true)일 경우 if문이 실행되고, 그렇지 않을 경우 else 문이 실행 된다.
• if ~ else if ~ else 문 : 조건을 여러개로 세분화하여 사용하는 if문이다.
• switch문 : 하나의 '값'에 대하여 여러가지 경우의 수로 나누어 분기한다.

📌 if문

• if문은 주어진 조건이 참 일 경우에 지정된 구문이 실행된다
  

• if문 예제

   int myage = 20;        
       if( myage == 19 ){
           System.out.println("19살 입니다.");
       }        
       if( myage != 20 ) {
           System.out.println("20살이 아닙니다.");
       }    
       if( myage > 19 ) {
           System.out.println("성인입니다.");
       }        
       if( myage <= 19 ) {
           System.out.println("학생입니다.");
       }

  int point = 85;        
       /*
        * point 가 70보다 크고, 80이하이면 "C학점 입니다."를 출력,
        * point 가 70이하 또는 80보다 크면 "범위를 벗어났습니다."
        */        
       // AND(&&) -> 두 조건이 모두 참이어야 전체가 참
       if( point > 70 && point <= 80 ) {
           System.out.println("C학점 입니다.");
       }
       // OR(||) -> 두 조건중 하나라도 참이면 전체가 참
       if( point <= 70 || point > 80 ) {
           System.out.println("범위를 벗어났습니다.");
       }

📌 if ~ else문

• 그렇지 않으면?

• if문이 조건이 참일 경우에 실행되는 구문이라면, if문이 조건과 반대되는 경우에 실행되고 구문이 else 문이다.
• else 문은 독립적으로 실행될 수 없고, 반드시 if문의 뒤에 위치해야 한다.
  
• if ~ else문 예제

  boolean is_korean = true;    
       if( is_korean ) {
           System.out.println("한국사람 입니다.");
       } else {
           System.out.println("한국 사람이 아닙니다.");
       }

  /*
  * 문제2. 만약 돈이 3000원 이상 있거나, 카드가 있다면 택시를 타고 그렇지 않으면 걸어가라.
  */
       int money2 = 2000;
       boolean hasCard = true;    
       if( money2 >= 3000 || hasCard ) {
           System.out.println("택시를 타고가라");
       } else {
           System.out.println("걸어가라");
       }

📌 if ~ else if ~ else문

• 여러 가지 경우의 수를 분기

• if 문과 else 문 사이에 else if 문으로 두 번째 조건, 세번째 조건을 나열할 수 있다.
  • else if 문은 필요한 만큼 나열할 수 있으며, 필요치 않은 경우 else 문은 생략 가능하다.
    
  • if ~ else if ~ else문 예제

    int point = 90;
        if( 90 < point && point <= 100 ) {
            System.out.println("A");
        } else if( 80 < point && point <= 90 ) {
            System.out.println("B");
        } else if( 70 < point && point <= 80 ) {
            System.out.println("C");
        } else {
            System.out.println("F");
        }

📌 모든 종류의 if문을 사용하는 문제

• 문제5-1. 국어, 영어, 수학 점수의 평균이 95점 이상이면 장학색을 출력하여라.

• 문제5-2. 국어점수가 70점 이상이면 "국어 합격" 그렇지 않으면 "국어 불합격"을 출력하여라
  • 문제5-3. 수학점수가 90점 이상이면 "A학점", 80점 이상이면 "B학점", 70점 이상이면 "C학점",
  • 60점 이상이면 "D학점", 나머지 "F학점"을 출력

    // 문제 풀이
    int kor = 100, eng = 100, mat = 89;
      double avg = (kor + eng + mat)/3;        
      // 5-1. 풀이
      if( avg >= 95 ) {
          System.out.println("장학생");
      }        
      // 5-2. 풀이
      if( kor >= 70 ) {
          System.out.println("국어 합격");
      } else {
          System.out.println("국어 불합격");
      }        
      // 5-3. 풀이
      if( mat >= 90 ) {
          System.out.println("수학 : A학점");
      } else if( mat >= 80 ) {
          System.out.println("수학 : B학점");
      } else {
          System.out.println("수학 : F학점");
      }

📌 switch문

• 변수 값에 대한 경우의 수를 처리하는 switch문

• switch문은 하나의 변수(기준값)에 대한 여러가지 case를 정의하는 구문이다.
• if문은 조건식(비교식, 부등식)이 사용될 수 있지만, switch문은 분기 조건이 반드시 일치하는 "값"에 대해서만 처리 가능하다.
  
  • switch문 예제

    char grade = 'F';        
      switch (grade) {
      case 'A':
          System.out.println("91 ~ 100점 사이 입니다.");
          break;
      case 'B':
          System.out.println("81 ~ 90점 사이 입니다.");
          break;
      case 'C':
          System.out.println("71 ~ 80점 사이 입니다.");
          break;
      default :
          System.out.println("70점 이하입니다.");
          break;
      }

    // char grade 선언, A,B,C가 있다.
    // A or B or C : "Pass" 1번 출력
    // A, B, C를 제외한 다른 등급이 올 경우, "Not-Pass" 1번 출력 
      char grade = 'D';        
      switch (grade) {
      case 'A':
      case 'B':
      case 'C':
          System.out.println("Pass");
          break;
      default:
          System.out.println("Not-Pass");
          break;
      }

📌 switch문을 사용한 문제

• 숫자가 3이면 "안녕"이 세줄, 숫자가 2이면 "안녕"이 두줄, 숫자가 1이면 "안녕"이 한줄,그 외는 "잘가"를 출력

int num2 = 5;        
        switch (num2) {
        case 3:
            System.out.println("안녕");
        case 2:
            System.out.println("안녕");
        case 1:
            System.out.println("안녕");
            break;
        default:
            System.out.println("잘가");
            break;
        }

네오는 평소 프로도가 비상금을 숨겨놓는 장소를 알려줄 비밀지도를 손에 넣었다. 그런데 이 비밀지도는 숫자로 암호화되어 있어 위치를 확인하기 위해서는 암호를 해독해야 한다. 다행히 지도 암호를 해독할 방법을 적어놓은 메모도 함께 발견했다.

1. 지도는 한 변의 길이가 n인 정사각형 배열 형태로, 각 칸은 “공백”(“ “) 또는 “벽”(“#”) 두 종류로 이루어져 있다.
2. 전체 지도는 두 장의 지도를 겹쳐서 얻을 수 있다. 각각 “지도 1”과 “지도 2”라고 하자. 지도 1 또는 지도 2 중 어느 하나라도 벽인 부분은 전체 지도에서도 벽이다. 지도 1과 지도 2에서 모두 공백인 부분은 전체 지도에서도 공백이다.
3. “지도 1”과 “지도 2”는 각각 정수 배열로 암호화되어 있다.
4. 암호화된 배열은 지도의 각 가로줄에서 벽 부분을 1, 공백 부분을 0으로 부호화했을 때 얻어지는 이진수에 해당하는 값의 배열이다 네오가 프로도의 비상금을 손에 넣을 수 있도록, 비밀지도의 암호를 해독하는 작업을 도와줄 프로그램을 작성하라.

• 입력 형식 입력으로 지도의 한 변 크기 n 과 2개의 정수 배열 arr1, arr2가 들어온다. 1 ≦ n ≦ 16 arr1, arr2는 길이 n인 정수 배열로 주어진다. 정수 배열의 각 원소 x를 이진수로 변환했을 때의 길이는 n 이하이다. 즉, 0 ≦ x ≦ 2^n - 1을 만족한다.

• 출력 형식 원래의 비밀지도를 해독하여 "#", 공백으로 구성된 문자열 배열로 출력하라.

코드

package test;

public class SecretMap {

    public static void main(String[] args) {
        int n = 5; // 지도의 한 변 크기
        int[] arr1 = {9, 20, 28, 18, 11};
        int[] arr2 = {30, 1, 21, 17, 28};

        int[] map = new int[n]; // 두개의 맵을 합치는 변수

        for(int i = 0; i < n; i++) {
            map[i] = arr1[i] | arr2[i]; // or연산자를 이용해서 두개의 맵이 합쳐진 map 구하기
        }

        for(int i = 0; i < map.length; i++) {
            String a = Integer.toBinaryString(map[i]);
            if(a.length() < n) { // a의 길이가 n의 크기보다 작을때
                int b = n - a.length(); // b = n에서 a의 길이값을 빼준다
                for(int j = 0; j < b; j++) { // b 값보다 작을때 까지
                    a = "0" + a; // 빈 공간에 0을 넣어준다
                }
            }
            a = a.replaceAll("0", " "); // replaceAll => 특정 문자열을 원하는 문자열로 변경해주는 함수
            a = a.replaceAll("1", "#");
            System.out.println(a);
        }    
    }    
}

출력값

<출처 : https://programmers.co.kr/learn/courses/30/lessons/17681 >

타노스는 프로그램의 균형을 위해서는 리스트의 원소 절반을 무작위로 삭제해야 한다고 믿고 있다. 타노스가 손가락을 튕겼을 때(프로그램을 실행했을 때) 입력된 리스트에서 절반의 원소를 무작위로 삭제하여 리턴하는 인피니티 건틀렛 프로그램을 작성하시오. (무작위 삭제이므로 입력값이 같아도 출력값이 매번 달라야 합니다)

입력 예시 [2, 3, 1, 6, 5, 7] 출력 예시 1 [2, 5, 7] 출력 예시 2 [3, 6, 5]

참고: 리스트의 원소가 홀수개일 경우 절반의 확률로 절반보다 많은 원소가 삭제되거나 절반보다 적은 원소가 삭제되어야 합니다. (만약 리스트의 원소가 7개라면 절반의 확률로 3개 또는 4개의 원소가 삭제됨)

코드

package project4;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;


public class Thanos {
      public static void main(String[] args) {
            int[] human = {2,3,1,6,5,7};

            ArrayList<Integer> start = new ArrayList<Integer>();

                  for(int i = 0; i < human.length; i++) {
                start.add(human[i]);
            }

            ArrayList<Integer> finish = infinity(start);

            for(int a = 0; a < finish.size(); a++) {
                System.out.print(finish.get(a)+" ");
            }
        }

        public static ArrayList<Integer> infinity(ArrayList<Integer> input) {
            Random random = new Random();
            int size = input.size();
            for(int i = 0; i < size / 2; i++) {
                input.remove(random.nextInt(input.size()));
            }
            return input;
        }

}    

출력값

<출처 : https://codingdojang.com/scode/592?langby=java >

<문제>

• 2017년에 이어, 2018년에도 카카오 코드 페스티벌이 개최된다!

• 카카오 코드 페스티벌에서 빠질 수 없는 것은 바로 상금이다.

• 2017년에 개최된 제1회 코드 페스티벌에서는, 본선 진출자 100명 중 21명에게 아래와 같은 기준으로 상금을 부여하였다.

• 2018년에 개최될 제2회 코드 페스티벌에서는 상금의 규모가 확대되어, 본선 진출자 64명 중 31명에게 아래와 같은 기준으로 상금을 부여할 예정이다.

• 제이지는 자신이 코드 페스티벌에 출전하여 받을 수 있을 상금이 얼마인지 궁금해졌다.

• 그는 자신이 두 번의 코드 페스티벌 본선 대회에서 얻을 수 있을 총 상금이 얼마인지 알아보기 위해, 상상력을 발휘하여 아래와 같은 가정을 하였다.

• 제1회 코드 페스티벌 본선에 진출하여 a등(1 ≤ a ≤ 100)등을 하였다. 단, 진출하지 못했다면 a = 0으로 둔다.

• 제2회 코드 페스티벌 본선에 진출하여 b등(1 ≤ b ≤ 64)등을 할 것이다. 단, 진출하지 못했다면 b = 0으로 둔다.

• 제이지는 이러한 가정에 따라, 자신이 받을 수 있는 총 상금이 얼마인지를 알고 싶어한다.

• 첫 번째 줄에 제이지가 상상력을 발휘하여 가정한 횟수 T(1 ≤ T ≤ 1,000)가 주어진다.

• 입력

• 다음 T개 줄에는 한 줄에 하나씩 제이지가 해본 가정에 대한 정보가 주어진다.

• 각 줄에는 두 개의 음이 아닌 정수 a(0 ≤ a ≤ 100)와 b(0 ≤ b ≤ 64)가 공백 하나를 사이로 두고 주어진다.

• 출력

• 각 가정이 성립할 때 제이지가 받을 상금을 원 단위의 정수로 한 줄에 하나씩 출력한다.

  상금표

코드

package project2;

import java.util.Scanner;

public class Price_jys {
    public static void main(String[] args) {
        int count;
        Scanner scanner = new Scanner(System.in);

        count = scanner.nextInt();

        int[] sum = new int[count];

        if(count >= 0 && count <= 1000) {
            for(int i = 0; i < count; i++) {
                int first;
                int second;
                int sum2 = 0;

                // 첫번째 대회
                first = scanner.nextInt();
                // 두번째 대회 
                second = scanner.nextInt();

                if(first >= 0 && first <= 100) {
                    if(first == 0) {

                    }else if(first == 1) {
                        sum2 += 5000000;
                    }else if(first <= 3) {
                        sum2 += 3000000;
                    }else if(first <= 6) {
                        sum2 += 2000000;
                    }else if(first <= 10) {
                        sum2 += 500000;
                    }else if(first <= 15) {
                        sum2 += 300000;
                    }else if(first <= 21) {
                        sum2 += 100000;
                    }else if(first >= 22){
                    }
                }

                if(second >= 0 && second <= 64) {
                    if(second == 0) {

                    }else if(second == 1) {
                        sum2 += 5120000;
                    }else if(second <= 3) {
                        sum2 += 2560000;
                    }else if(second <= 7) {
                        sum2 += 1280000;
                    }else if(second <= 15) {
                        sum2 += 640000;
                    }else if(second <= 31) {
                        sum2 += 320000;
                    }else if(second >= 32){
                    }
                    sum[i] = sum2;
                }

            }
            for(int i = 0; i < sum.length; i++) {
                System.out.println(sum[i]);
            }
        }
    }
}

입력값

출력값

<출처 : https://www.acmicpc.net/problem/15953 >

< 문제 > 상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다. 상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다. 상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오

package study;

import java.util.Scanner;

public class sang {

    public static void main(String[] args) {

        // 설탕 kg 입력하기 위한 scanner메서드
        Scanner sc = new Scanner(System.in);
        System.out.println("kg수를 입력해주세요 : ");
        // Nkg = 입력받을 설탕 kg 변수
        int Nkg = sc.nextInt();
        // 봉지 갯수 변수
        int count = 0;

        while(true) {
            // Nkg / 5 의 나머지가 0일때
            if(Nkg % 5 == 0) {
                count = Nkg/5;
                System.out.println(Nkg/5 + count + "봉");
                break;
            // Nkg 가 0 또는 음수일때
            }else if(Nkg < 0) {
                System.out.println(-1);
                break;
            }
            // Nkg를 5로 나눴을 때 나머지가 0이아닌 수를 가져와 3을 뺀후 다시 if문으로 돌아간다
            // count++ 로 3kg 봉지 갯수 하나 세주기
            Nkg = Nkg - 3;
            count++;
    }

}
}

<출처 : https://www.acmicpc.net/problem/2839 >

📌 쇼핑몰 코드 짜기 전 설계도

📌 관리자 메뉴 클래스

package project;

import java.util.Scanner;

public class Manager {

    Scanner sc = new Scanner(System.in);

    private boolean start = true; // start라는 변수를 생성해줌으로 써 주문하기 클래스에서도 사용
    // 비밀번호를 int로 설정할 경우 맨앞자리에 0이 들어갔을때 컴퓨터가 인식이 안될수도 있기 때문에 string으로 설정
    final private String PASSWORD = "8520"; // 관리자 메뉴 비밀번호 설정


    // getter, setter 생성
    public boolean isStart() {
        return start;
    }

    public void setStart(boolean start) {
        this.start = start;
    }

    public void ManagerShop(){
        while(isStart()) {
            System.out.println("비밀번호를 입력해주세요 : ");
            String num = sc.nextLine(); 
            // 비밀번호가 맞을때
            if(num.equals(PASSWORD)) {
                System.out.println("비밀번호가 일치합니다");
                System.out.println("준비된 수량이 마감되어 오늘 하루 주문을 마감하겠습니다.");
                // 비밀번호가 일치하였을 때 while문 종료
                break;
            // 비밀번호가 틀렸을때    
            }else {
                System.out.println("비밀번호가 불일치합니다 다시 입력바랍니다.");
            }
        }
    }        
}

📌 주문하기 메뉴 클래스

package project;

import java.util.Random;
import java.util.Scanner;

// start 라는 변수를 사용하기 위해 Manager 클래스 상속
public class Order extends Manager {

    Scanner sc = new Scanner(System.in);
    // 주문번호를 랜덤으로 받기위한 랜덤메소드 호출
    Random r = new Random();

    private int jeanCnt = 0; // 청바지 갯수
    private int outerCnt = 0; // 가디건 갯수
    private int neatCnt = 0; // 니트 갯수
    private int skirtCnt = 0; // 치마갯수

    public void OrderShop(){

        // 다음 손님을 위한 장바구니 리셋
        jeanCnt = 0; 
        outerCnt = 0; 
        neatCnt = 0; 
        skirtCnt = 0; 

    while(isStart()) {
        // 상품번호 설명하는 출력
        System.out.println("원하시는 상품번호를 입력하시면 장바구니에 추가 됩니다");
        System.out.println("1. 청바지 : 15000원");
        System.out.println("2. 가디건 : 25000원");
        System.out.println("3. 니트 : 20000원");
        System.out.println("4. 치마 : 10000원");
        System.out.println("5. 결제하기");
        System.out.println("6. 장바구니 비우기");
        System.out.print("번호 입력 : ");

        // 관리자 메뉴에서 nextLine을 사용해야 하기때문에 nextInt가 여기서 쓰이면 문제가 발생할 수 있기 때문에
        // 대신 Integer.parseInt를 사용하여 nextLine을 int타입으로 바꿔주기 
        int choice = Integer.parseInt(sc.nextLine());
        if(choice == 1) {
            jeanCnt++;
            System.out.println("청바지 한개가 추가되었습니다.");
        }else if(choice == 2) {
            outerCnt++;
            System.out.println("가디건 한개가 추가되었습니다.");
        }else if(choice == 3) {
            neatCnt++;
            System.out.println("니트 한개가 추가되었습니다.");
        }else if(choice == 4) {
            skirtCnt++;
            System.out.println("치마 한개가 추가되었습니다.");
        }else if(choice == 5) {
            // 결제하기
            int totalCost = jeanCnt*15000 + outerCnt*25000
                     + neatCnt*20000 + skirtCnt*10000;

            System.out.println("총 금액은 " + totalCost + "원 입니다");
            System.out.println("결제를 시작하시겠습니까 ? ");
            System.out.println("1. YES // 2. NO");
            // 결제 여부를 위한 변수선언
            int money = Integer.parseInt(sc.nextLine()); // 위와같은 이유로 Line사용

            while(isStart()) {
                if(money == 1) {// 1. YES를 입력했을때
                    System.out.println("카드결제 하시려면 카드를 입력하시고, 무통장입금은 무통장입금을 입력해주세요");
                    String input = sc.nextLine();
                    if(input.equals("카드")) {
                        System.out.println("주소를 입력해 주세요 : ");
                        String home = sc.nextLine();
                        System.out.printf("주문번호는 " + "%06d번 입니다\n", r.nextInt(999999)+1);
                        System.out.println(home + "으로 배달 예정입니다 주문해주셔서 감사합니다.");
                        return; // 주문이 끝낫으므로 메인메뉴로 이동
                        // %06d 는 랜덤 숫자를 6자리로 받기 위해 printf를 사용 
                        // r.nextInt(999999)+1 는 0부터가 아닌 1부터의 숫자를 받아오기 위해서 +1을 해줌
                    }else if(input.equals("무통장입금")) {
                        System.out.println("주소를 입력해 주세요 : ");
                        String home = sc.nextLine();
                        System.out.printf("주문번호는 " + "%06d번 입니다\n", r.nextInt(999999)+1);
                        System.out.println("3333-12-123-1234로 " + totalCost + "원 입금부탁드리겠습니다");
                        System.out.println(home + "으로 배달 예정입니다 주문해주셔서 감사합니다.");
                        System.out.println("-----------------------------------------------------");
                        return;
                    }else {
                        System.out.println("정확하게 다시 입력해주세요");
                        // 주문하기 창으로 돌아가는데 입력칸으로 돌아가려면 생각해보기
                    }        
                }if(money == 2){// 2. NO를 입력했을때
                    System.out.println("다시 주문화면으로 돌아갑니다");
                    break; // 맨처음 while문으로 즉시 간다
                }
            }
        // 장바구니 비우기     
        }else if(choice == 6) {
            System.out.println("장바구니를 비우겠습니까?");
            System.out.println("1. YES || 2. NO");
            int el = Integer.parseInt(sc.nextLine());
            switch(el) {
                case 1:
                    jeanCnt = 0;
                    outerCnt = 0;
                    neatCnt = 0;
                    skirtCnt = 0;
                default:    
            }
        }else {
            System.out.println("다시 입력해주세요."); // 처음 주문란에서 번호 잘못 입력
        }
        // 장바구니
        System.out.println("---------------------------------------");
        System.out.println("==고객님의 장바구니==");
        System.out.println("청바지 : " + jeanCnt + "개 = 총 " + jeanCnt*15000 + "원");
        System.out.println("가디건 : " + outerCnt + "개 = 총 " + outerCnt*25000 + "원");
        System.out.println("니트 : " + neatCnt + "개 = 총 " + neatCnt*20000 + "원");
        System.out.println("치마 : " + skirtCnt + "개 = 총 " + skirtCnt*10000 + "원");
        System.out.println("총 금액 : " + (jeanCnt*15000 + 
                outerCnt*25000 + neatCnt*20000 + skirtCnt*10000 + "원 입니다"));
        System.out.println("---------------------------------------");

    }


}
}

📌 메인메뉴 클래스

package project;

import java.util.Scanner;

public class main {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        // 주문화면 객체생성 
        Order or = new Order();
        // 관리자메뉴 객체생성
        Manager ma = new Manager();

        while(true) {
            System.out.println("===== 메인화면 =====");
            System.out.println("1. 주문하기");
            System.out.println("2. 관리자모드");
            System.out.print("원하시는 번호를 입력하세요 : ");

            int choice = Integer.parseInt(sc.nextLine());

            if(choice == 1) {
                or.OrderShop();
            }else if(choice == 2) {
                ma.ManagerShop();
                break;
            }else {
                System.out.println("번호를 잘못입력하셧습니다.");
                System.out.println("다시 입력 바랍니다.");
            }

        }
    }

}

📌 출력 값

👉 주문하기 출력해보기

장바구니에 담고싶은 물건의 각 번호(1~4)를 입력 -> 자동으로 장바구니에 담깁니다. 장바구니를 비우고 싶을땐 6번을 입력 -> 장바구니안에 있는 모든 상품들이 초기화됩니다. 결제하기 5번 입력 -> 카드/무통장입금 중 결제할 수단을 입력 후 주소를 입력하면 자동으로 랜덤 주문번호, 주소, 계좌번호(무통장입금만 해당)이 출력된 후 다시 메인메뉴로 돌아갑니다.

👉 관리자메뉴 출력해보기

미리 설정한 비밀번호인 "8520" 이외의 번호를 입력하였을 때에는비밀번호가 불일치합니다 다시 입력바랍니다 출력 후 , 다시 비밀번호 입력칸으로 돌아가게끔 코드작성을 해보았습니다**