Java 프로그래밍 기초 수업 3일차

자바 수업 3일차

☞ 반복문 이어서...

* 프로그램의 특정 부분을 레이블 블록으로 지정할 수 있다.

  - break, continue문 등에서 사용 가능

  - 추천하는 방법은 아니다.

* break문

  - 레이블이 있는 곳에서, 잘못된 break문의 예

ff : {
    ......
}
 
gg : {
    ......
    hh : {
        ......
        if (a == 10) break ff;  // 오류 발생. 내포된 블록만 break 사용 가능.
    }
}

* continue문

  - 프로그램의 제어를 반복 블록 처음으로 이동시킨다.

  - 반복문 안에서만 사용할 수 있다.

☞ 여기부터는 '배열'

* 배열

  - 같은 형의 데이터를 하나의 자료 구조에 저장할 수 있게 만든 것이다.

  - 데이터가 여러 개일 때, 변수를 단독으로 쓰는 것보다 관리하기가 편하다.

* 배열은 기본 자료형이 아니라 참조 자료형이다.

  - 배열 각각의 요소는 기본 자료형, 참조 자료형 모두 가능하다.

* 자바에서 배열 사용 : 선언, 생성 필요

  - 배열의 선언

type name[];     // 1차원 배열
type[] name;  
type[][] name;   // 2차원 배열
type name[][];
type[] name[];

   - 배열의 생성

name = new type[size];         // size 크기의 1차원 배열 생성
name = new type[size][size];   // size 크기의 1차원 배열 생성

  - 배열의 선언과 생성 : 한 문장으로 가능

type[] name = new type[size];
type name[] = new type[size];
type[][] name = new type[size][size];
type name[][] = new type[size][size];
type[] name[] = new type[size][size];

  - 배열의 선언과 생성의 예

int[] id;
id = new int[3];   // 3개의 int 요소를 가진 배열 생성
 
또는
 
int[] id = new int[3];
String[] student_name;
student_name = new String[3];   // 3개의 문자열 요소를 가진 배열 생성
 
또는
 
String[] student_name = new String[3];
int[][] id_and_score = new int[5][2];   // 5행 2열의 정수 2차원 배열 생성
String add_and_name[][] = new String[10][10];   // 10행 10열의 문자열 배열 생성

  - 배열 요소의 사용 : 배열 이름과 첨자를 이용하여 접근

int[] id = new int[3];       // 3개의 요소를 가진 int 배열
int sum = int[0] + int[1];   // 첨자는 0부터 시작
int[][] stnum = new int[3][3];
stnum[0][2] = stnum[0][0] + stnum[0][1];   // 2차원 배열 첨자 사용

* 2차원 배열은 1차원 배열의 배열이다.

예)

a. 2차원 배열과 메모리

int[][] num2 = new int[3][2]
 
num2        // 주소
 
num2[0][]   // 주소
num2[1][]
num2[2][]
 
num2[0][0]  // 데이터
num2[0][1]
 
num2[1][0]  // 데이터
num2[1][1]
 
num2[2][0]  // 데이터
num2[2][1]

b. 배열의 요소 수가 다른 2차원 배열과 메모리

int[][] num3 = new int[3][];
num3[0] = new int[2];
num3[1] = new int[3];
num3[2] = new int[4];
 
num3        // 주소
 
num3[0][]   // 주소
num3[1][]
num3[2][]
 
num3[0][0]  // 데이터
num3[0][1]
 
num3[1][0]  // 데이터
num3[1][1]
num3[1][2]
 
num3[2][0]  // 데이터
num3[2][1]
num3[2][2]
num3[2][3]

* 배열의 초기화 : 처음 생성된 배열에 데이터를 저장하는 과정

  - 변수와 달리 배열은 초기화하지 않아도 사용이 가능하다. (오류 발생 안 한다.)

  - 배열이 초기화되지 않을 경우에는 묵시적인 값으로 자동 설정된다.

  - 가능하면 초기화는 해 주는 것이 좋다.

* 배열의 생성과 초기화

int[] id = new int[5];   // 1차원 배열 선언과 생성
id[0] = 201195041;       // 각 요소에 값을 하나씩 저장하여 초기화.
id[1] = 201195042;
id[2] = 201195043;
id[3] = 201195044;
id[4] = 201195045;
 
또는
 
int id[] = {201195041, 201195042, 201195043, 201195044, 201195045}
// 배열의 선언과 생성. 초기화 과정을 한 문장으로 작성.
String[][] name_addr = new String[3][2]   // 2차원 배열 선언과 생성
name_addr[0][0] = "kim";                  // 초기화
name_addr[0][1] = "seoul";
name_addr[1][0] = "park";
name_addr[1][1] = "busan";
name_addr[2][0] = "hong";
name_addr[2][1] = "daegu";
 
또는
 
String[][] name_addr = {{"kim","seoul"},{"park","busan"},{"hong","daegu"}};
// 배열의 선언과 생성, 초기화 과정을 한 문장으로 작성

* 배열이 초기화되지 않을 경우 가지는 묵시적인 값

  - byte, short, int, long : 0

  - float, double : 0.0

  - char : 공백 문자

  - boolean : 거짓(false)

  - 참조 자료형 : null

* 배열의 길이를 나타내는 length 속성

int a[] = { 10, 20, 30, 40, 50 };
System.out.println(a.length);   // 5를 출력
 
int b[][] = {{10, 20, 30}, {40, 50, 60, 70}};
System.out.println(b.length);      // 배열 b의 행의 길이 2를 출력
System.out.println(b[0].length);   // 배열 b 첫 번째 행의 길이 3을 출력
System.out.println(b[1].length);   // 배열 b 두 번째 행의 길이 4를 출력

* 확장된 for문

  - 자바는 배열의 처리를 편리하게 하기 위해 제공

  - 배열의 요소를 순차적으로 처리하는 간결한 구문 제공

  - 형식

for (type 변수명 : 배열 이름)

※ 배열 이름으로 지정된 배열의 첫 번째 요소부터 마지막 요소까지를 변수명에 배정하여 반복 처리 수행.

예)

sum = 0;
int[] inum = { 10, 20, 30, 40, 50 };
for (int x : inum)   // inum 배열의 첫 번째 요소부터 마지막 요소까지를
                     // 차례로 변수 x에 저장하여 반복 처리한다.
    sum = sum + x;
System.out.println(sum);

* 변수의 복사와 배열의 복사

  (a) 변수의 복사

int a = 100;
int b = 200;
b = a;     // b에 a의 값을 복사
a = 300;   // a에 300을 배정
// a=300, b=100

  (b) 배열의 복사

  - 값이 복사되기는 하지만, 배열은 참조 자료형이므로 그 값을 주소로 취급하게 되어 두 배열명은 같은 기억 장소를 가리키게 된다.

    이 경우 한 쪽 배열 요소의 변경이 발생하면 다른 한 쪽도 변경되는 부작용(side effect)이 발생하게 된다.

  - 의도적으로 잘 사용하면 문제 없다.

int num1[] = {10, 20, 30};   // 40200번지
int num2[] = {40, 50, 60};   // 50012번지
num2 = num1;     // num2에 num1을 복사
                 // 주소가 복사되어 둘 다 40200번지를 가리킨다.
                 // 50012번지는 접근 불가
num2[2] = 200;   // num2[2]에 200을 저장
                 // 50012번지는 자바의 쓰레기 수집 기능에 의해 제거된다.

* 실습

import java.util.Random;  // 랜덤 기능을 가진 클래스 추가
public class MultiArraysTest1 {
    public static void main(String[] args) {
        // 배열 : 복수개의 데이터를 한꺼번에 모아서 지정할 수 있는 공간 생성
        // 16개의 정수를 저장 -> 정수 4개씩 그룹지어서 4개의 그룹으로 생성
        Random ran = new Random();  // Random 클래스 내의 메소드를 사용하기 위해
                                    // 복사본(객체, 인스턴스) 생성
        int score[][] = new int[4][4];  // 4개의 그룹, 각 그룹은 4개씩
                                        // 2차원 배열 score 생성
        
        for (int i=0; i<4; i++)  // 그룹을 순회(0~3번 그룹까지)
            for (int j=0; j<4; j++)  // 각 그룹 내에서 4개의 저장 공간을 순회
                score[i][j] = ran.nextInt(10);  // 임의의 숫자(0~9 사이의 정수) 배정
        
        // 배열의 각 저장 장소의 내용을 꺼내어, 표시하고, 그 총합을 표시.
        for (int k=0; k<4; k++) {  // 그룹 순회
            System.out.print((k+1) + "번째 { ");
            int sum=0;  // 각 행의 합계를 구하기 위한 변수
            for (int value : score[k]) {        // 각 그룹 내의 저장 공간 순회
                System.out.print(value + " ");  // 저장된 데이터를 출력
                sum = sum + value;
            }
            System.out.println("} 그룹의 데이터 합계는 " + sum);  // 각 행의 합계를 출력
        }
    }
}
 

* 로또 번호 생성기 만들기

  - 배운 것 써먹어 보자.

※ 주의! 아래 코드는 미완성입니다.

  실행 결과, 중복값도 튀어나옵니다. ㅠ

import java.util.Random;
public class Lotto_645 {
    public static void main(String[] args) {
        // Lotto 6/45 번호 생성기
        
        // Random 클래스 객체 생성
        Random Ball = new Random();
        
        // 1차원 배열을 사용할 경우
        // 1~45까지의 공을 한 그릇(배열)에 저장한다.        
        int Lotto[] = new int[45];
        
        for (int i=0; i<45; i++)
            Lotto[i] = i+1;
        
        // 중복되지 않은 정수 6개를 저장할 공간을 만든다.
        int Selected[] = new int[6];
        int count = 0;
        int curNum;
        
        while (count <= 5) {
        // 중복되지 않은 숫자 6개가 모두 나올 때까지 번호를 랜덤 생성한다.
        // Random 클래스 메소드 사용
            curNum = 1 + Ball.nextInt(45);
            
            // 중복되지 않은 공 비교, 숫자가 다 나올 때까지 반복.
            for (int oldNum : Selected) {
                if(curNum != oldNum) {  // 방금 뽑은 숫자가, 과거에 뽑힌 숫자가 아니면
                    System.out.println(curNum + "가 선택되었습니다.");
                    Selected[count] = curNum;
                    count++;
                    break;
                }  // 방금 뽑은 숫자가, 과거에 이미 뽑힌 숫자라면(중복이면)
            }
        }
 
        // 6개의 공간에 들어있는 숫자를 다 빼서 출력한다.
        System.out.println("이번 주의 로또 번호는 아래와 같습니다.");
        for(int y : Selected)
            System.out.print(y + " ");
    }
}

* 랜덤도 프로그램 상에서 패턴이 존재한다. (!!!)

  - 돌리다 보면, 동일한 패턴이 다시 나온다.

  - 패턴을 깨기 위해서는, 랜덤 시드 값을 변경해야 한다.

* 자바의 배열 관련 라이브러리 클래스

  - Arrays 클래스와, 배열을 복사하기 위한 메소드(arraycopy())을 제공하는 System 클래스를 제공한다.

  - Arrays 클래스 사용 예

int[] a = new int[10];
Arrays.fill(a, 1);   // 배열 a의 모든 요소를 1로 채운다.
Arrays.fill(a,1,5,10);   // a[1]부터 a[4]까지의 값을 10으로 채운다.
System.out.println(Arrays.toString(a));   // 배열 a를 문자열로 출력한다.
 
int[] b = { 3, 7, 1, 0, 8, 9 };
Arrays.sort(b);   // 배열 b의 요소들을 오름차순으로 정렬한다.
System.out.println(Arrays.toString(b));   // 정렬된 결과를 출력한다.
System.out.println(Arrays.binarySearch(b, 7));   // 7의 인덱스 값 3을 출력한다.
 
int[] c = {1, 2, 3};
int[] d = {1, 2, 3};
int[] e = {4, 5, 6};
System.out.println(Arrays.equals(c, d));   // true 출력
System.out.println(Arrays.equals(c, e));   // false 출력

☞ 객체지향

* 객체지향(Object-Oriented) 이론

  - 컴퓨터를 통하여 실세계와 같은 환경을 흉내(simulation)내기 위해 발전한 이론

  - (실세계의) 사물 = 속성 + 기능

* 1960년 노르웨이의 달Dahl과 뉘고르Nygaard가 개발한 시뮬라Simula라는 언어를 최초의 객체 지향 언어라 할 수 있다.

* 객체지향의 장점

  - 문제를 쉽고 자연스럽게 프로그램화(모델링) 할 수 있다.

  - 쉬운 프로그램의 개발로 인한 생산성을 향상시킬 수 있다.

  - 프로그램 모듈을 재사용할 수 있다.

* 클래스

  - 하나의 클래스로부터 여러 개의 객체를 생성하기 위해 사용하는 형판이다.

  - 먹을 수 없는 붕어빵 틀(클래스)로부터 먹을 수 있는 붕어빵(객체)를 만들어 낸다.

* 객체

  - "속성 + 기능"으로 구성된다.

  - 객체를 생성하는 클래스 역시 "속성 + 기능"으로 구성된다.

* 실체화(instantiation)

  - 클래스로부터 객체를 생성하는 과정이다.

  - 객체를 인스턴스(instance)라고 부르기도 한다.

  - 즉, 객체 = 인스턴스

class PlusMinusTest1 {
    public static void main(String args[]) {
        PlusMinus ob1 = new PlusMinus();   // PlusMinus 클래스로부터 ob1 객체 생성
        String sum, minus;
        sum = ob1.plus(50, 30);   // 생성된 객체에 메시지를 보내 합과 차를 구한다.
        minus = ob1.minus(50, 30);
        System.out.println(sum);   // 합과 차를 출력한다.
        System.out.println(minus);
    }
}

* 기존 클래스의 기능을 가지면서 추가적인 기능을 가진 클래스를 만들려면?

  - 기존 클래스를 그대로 복사하고, 추가적인 기능을 넣을 수도 있지만, 코드의 중복과 중복으로 인해 추후 수정이 힘들어진다.

  - 객체지향에서는 이러한 문제를 상속이라는 기능으로 해결한다.

  - 즉, 새로운 클래스를 만들 때 상위 클래스를 지정함으로써 상위 클래스의 모든 속성과 기능을 상속받고, 자신의 클래스에는 추가적인 속성과 기능만을 추가하는 방법이다.

예)

class A {
    int a;
    int b;
    public int A1() {
        return 7;
    }
    public int A2() {
        return 8;
    }
}

class B extends A {
    int x;
    int y;
    public int B1() {
        return 11;
    }
    public int B2() {
        return 12;
    }
}

public class ClassObjectInheritanceTest1 {
    public static void main(String[] args) {
        B objB = new B();
        int aa = objB.B2();
        int bb = objB.A1();
        System.out.println(aa);
        System.out.println(bb);
    }
}

* 클래스 예제

class PlusMinus {
    int plus, minus;
    public String plus(int x, int y) {
        plus = x + y;
        return "두 수의 합은 " + plus;
    }
    public String minus(int x, int y) {
        minus = x - y;
        return "두 수의 차는 " + minus;
    }
}

class MultiDiv extends PlusMinus {   // MultiDiv 클래스의 상위 클래스로 PlusMinus 클래스 지정
    int multi;   // 두 개의 속성을 지정
    double div;
    public String multi(int x, int y) {   // multi 메소드 지정
        multi = x * y;
        return "두 수의 곱은 " + multi;
    }
    public String div(int x, int y) {   // div 메소드 지정
        div = (double) x / y;
        return "두 수의 나눈 값은 " + div;
    }
}
 
public class FourRulesTest1 {
    public static void main(String[] args) {
        String plus, minus, multi, div;
        MultiDiv ob1 = new MultiDiv();   // MultiDiv 클래스로부터 객체 생성
        plus = ob1.plus(50, 30);   // 객체의 메소드 호출
        minus = ob1.minus(50, 30);
        multi = ob1.multi(50, 30);
        div = ob1.div(50, 30);
        System.out.println(plus);   // 결과 출력
        System.out.println(minus);
        System.out.println(multi);
        System.out.println(div);
    }
}

* 과제

  - 엘리베이터를 코딩해 봐라.

오늘도 수고하셨습니다.