명품 자바 프로그래밍 4장 241~247쪽 연습문제 실습문제 정답

명품 자바 프로그래밍 4장 241~247쪽 연습문제 실습문제 정답

luxury java programming ch4 p241~247 exercise practice correct answer

 

1. 답:

class TV { // TV 클래스 구현 시작
    private int size; // private int형 멤버변수 size 선언
    private int year; // private int형 멤버변수 year 선언
    private String manufacturer; // private String형 객체에 대한 레퍼런스 변수 선언
    
    public TV() {} // public으로 선언된 기본생성자
    public TV(String manufacturer, int year, int size) { // public으로 선언된 매개변수가 String, int, int 3개인 생성자
        this.manufacturer = manufacturer; // 매개변수 manufacturer를 멤버변수 manufacturer에 대입연산
        this.year = year; // 매개변수 year를 멤버변수 year에 대입연산
        this.size = size; // 매개변수 size를 멤버변수 size에 대입연산
    }
    
    public void show() { // public으로 선언된 리턴값이 없는 멤버함수 show() 정의 시작
        System.out.println(manufacturer + "에서 만든 " + year + "년형 " + size + "인치 TV"); // 멤버변수 manufacturer, year, size에 저장된 값 출력
    }
}
 
public class Ch4_1 { // public으로 선언된 Ch4_1 클래스 구현 시작
 
    public static void main(String[] args) { // main() 메소드 정의 시작
        // TODO Auto-generated method stub
        TV myTV = new TV("LG", 2017, 32); // TV 클래스로 만든 객체를 가리키는 레퍼런스 변수 myTV 선언 동시에 객체 생성하여 초기화, 매개변수가 String, int, int 3개인 생성자 호출하여 초기화
        myTV.show(); // myTV 객체의 멤버함수 show() 호출하여 출력
        
    } // main() 메소드 정의 끝
 
} // 클래스 구현 끝
 

 

2. 답:

import java.util.Scanner; // Scanner 클래스 사용하기위해 컴파일러에게 경로명 알려줌
 
class Grade { // default로 선언된 Grade 클래스 구현 시작 
    private int math; // private으로 선언된 int형 필드 math 선언
    private int science; // private으로 선언된 int형 필드 science 선언 
    private int english; // private으로 선언된 int형 필드 english 선언
    private int average; // private으로 선언된 int형 필드 average 선언
    
    public Grade(int math, int science, int english) { // public으로 선언된 매개변수가 int, int, int 3개인 생성자 
        this.math = math; // 매개변수 math를 객체의 필드 math에 대입연산
        this.science = science; // 매개변수 science를 객체의 필드 science에 대입연산
        this.english = english; // 매개변수 english를 객체의 필드 english에 대입연산
    }
    
    public int average() { // public으로 선언된 리턴값이 int형인 average() 메소드 정의 시작
        this.average = (math + + science + english)/3; //3과목 평균 계산하여 객체 필드 average에 대입연산
        return average; // 객체 필드 average 리턴
    }
}
 
public class Ch4_2 { // public으로 선언된 Ch4_2 클래스 구현 시작
 
    public static void main(String[] args) { // main() 메소드 정의 시작
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in); // 사용자로부터 입력받기위해 scanner 객체 생성
        
        System.out.print("수학, 과학, 영어 순으로 3개의 점수 입력>>"); // 점수 입력 안내 메세지 출력
        int math = scanner.nextInt(); // int형 변수 math 선언 동시에 사용자로부터 입력 받은 정수로 초기화 
        int science = scanner.nextInt(); // int형 변수 science 선언 동시에 사용자로부터 입력 받은 정수로 초기화 
        int english = scanner.nextInt(); // int형 변수 english 선언 동시에 사용자로부터 입력 받은 정수로 초기화 
        
        Grade me = new Grade(math, science, english); // Grade 클래스로 만든 객체에대한 레퍼런스 변수 me 선언 동시에 객체 생성하여 초기화, 매개변수가 int, int, int 3개인 생성자 호출하여 초기화 
        System.out.println("평균은 " + me.average()); // 객체 me의 메소드 average() 호출하여 평균 출력
        
        scanner.close(); // scanner 객체 닫기
    } // main() 메소드 정의 끝
 
} // 클래스 구현 끝

 

3. 답:

public class Song { // public으로 선언된 Song 클래스 구현 시작
    private String title; // private으로 선언된 String형 객체에대한 레퍼런스 필드 title 선언
    private String artist; // private으로 선언된 String형 객체에대한 레퍼런스 필드 artist 선언
    private String country; // private으로 선언된 String형 객체에대한 레퍼런스 필드 country 선언
    private int year; // private으로 선언된 int형 필드 year 선언
    
    public Song() { // public으로 선언된 매개변수가 없는 기본 생성자
    }
    
    public Song(String title, String artist, String country, int year) { // public으로 선언된 매개변수가 String, String, String, int 4개인 생성자
        this.title = title; // 매개변수 title을 객체 필드 title에 대입연산
        this.artist = artist; // 매개변수 artist을 객체 필드 artist에 대입연산
        this.country = country; // 매개변수 country을 객체 필드 country에 대입연산
        this.year = year; // 매개변수 year를 객체 필드 year에 대입연산
    }
    
    public void show() { // public으로 선언된 리턴타입이 void인 show() 메소드 정의 시작
        System.out.println(year + "년 " + country + "국적의 " + artist + "가 부른 "+ title); // 객체의 필드 출력
    }
    
    public static void main(String[] args) { // main() 메소드 정의 시작
        Song dancingQueen = new Song("DancingQueen", "ABBA", "스웨덴", 1978); // Song 클래스로 만든 객체에대한 레퍼런스 변수 dancingQueen 선언 동시에 객체 생성하여 초기화, 매개변수가 String, String, String, int 4개인 생성자 호출하여 초기화
        dancingQueen.show(); // dancingQueen의 메소드 show() 호출하여 객체 필드 출력
    } // main() 메소드 정의 끝
} // 클래스 구현 끝

 

4. 답:

class Rectangle { // default로 선언된 Rectangle 클래스 구현 시작
    private int x; // private으로 선언된 int형 필드 x 선언, 왼쪽 아래 점 x좌표
    private int y; // private으로 선언된 int형 필드 y 선언, 왼쪽 아래 점 y좌표
    private int width; // private으로 선언된 int형 필드 width 선언, 너비
    private int height; // private으로 선언된 int형 필드 width 선언, 높이
    
    public Rectangle(int x, int y, int width, int height) { // public으로 선언된 매개변수가 int, int, int, int 4개인 생성자
        this.x = x; // 매개변수 x를 객체 필드 x에 대입연산
        this.y = y; // 매개변수 y를 객체 필드 y에 대입연산
        this.width = width; // 매개변수 width를 객체 필드 width에 대입연산
        this.height = height; // 매개변수 height를 객체 필드 height에 대입연산
    }
    
    public int square() { // public으로 선언된 리턴타입이 int인 square() 메소드 정의 시작
        return width*height; // 너비*높이 = 사각형의 넓이 리턴
    }
    
    public void show() { // public으로 선언된 리턴타입이 void인 show() 메소드 정의 시작
        System.out.println("(" + x + "," + y + ")에서 크기가 " + width + "x" + height + "인 사각형"); // 객체 필드 출력
    }
    
    public boolean contains(Rectangle r) { // public으로 선언된 리턴타입이 boolean인 contains() 메소드 정의 시작
        if((x < r.x)&&(r.x < x+width)) { // Rectangle 클래스로 만든 객체에 대한 레퍼런스 변수 r이 가리키고 있는 객체의 필드 x가 사각형의 가로 범위 안에 있으면
            if((y < r.y)&&(r.y < y+height)) { // Rectangle 클래스로 만든 객체에 대한 레퍼런스 변수 r이 가리키고 있는 객체의 필드 y가 사각형의 세로 범위 안에 있으면
                if((x < r.x + r.width)&&(r.x + r.width< x+width)) { // Rectangle 클래스로 만든 객체에 대한 레퍼런스 변수 r이 가리키고 있는 객체의 필드 x + width, 즉 다른 점의 x좌표가 사각형의 가로 범위 안에 있으면
                    if((y < r.y + r.height)&&(r.y + r.height < y+height)) { // Rectangle 클래스로 만든 객체에 대한 레퍼런스 변수 r이 가리키고 있는 객체의 필드 y + height, 즉 다른 점의 y좌표가 사각형의 세로 범위 안에 있으면
                        return true; // 사각형 r을 포함하고 있으므로 true를 리턴
                    }
                }
            }
        }
        return false; // 그렇지 않으면, 즉 사각형 r을 포함하고 있지 않으면 false를 리턴
    }
    
}
 
public class Ch4_4 { // public으로 선언된 Ch4_4 클래스 구현 시작
 
    public static void main(String[] args) { // public으로 선언된 main() 메소드 정의 시작
        // TODO Auto-generated method stub
        Rectangle r = new Rectangle(2, 2, 8, 7); // Rectangle 클래스로 만든 객체에 대한 레퍼런스 변수 r 선언 동시에 객체 생성하여 초기화, 매개변수가 int형 4개인 생성자가 호출되어 초기화
        Rectangle s = new Rectangle(5, 5, 6, 6); // Rectangle 클래스로 만든 객체에 대한 레퍼런스 변수 s 선언 동시에 객체 생성하여 초기화, 매개변수가 int형 4개인 생성자가 호출되어 초기화
        Rectangle t = new Rectangle(1, 1, 10, 10); // Rectangle 클래스로 만든 객체에 대한 레퍼런스 변수 t 선언 동시에 객체 생성하여 초기화, 매개변수가 int형 4개인 생성자가 호출되어 초기화
        
        r.show(); // 객체 r의 메소드 show() 호출하여 필드 출력
        System.out.println("s의 면적은 " + s.square()); // 객체 s의 메소드 square() 호출하여 면적 출력
        if(t.contains(r)) System.out.println("t는 r을 포함합니다."); // 만약 t가 r을 포함하고 있으면 출력
        if(t.contains(s)) System.out.println("t는 s을 포함합니다."); // 만약 t가 s을 포함하고 있으면 출력
        
    } // main() 메소드 정의 끝
 
} // 클래스 구현 끝

 

5. 답: 

import java.util.Scanner; // Scanner 클래스 사용하기위해 컴파일러에게 경로명 알려줌
 
class Circle { // default로 선언된 Circle 클래스 구현 시작
    private double x, y; // private으로 선언된 double형 필드 x, y 선언
    private int radius; // private으로 선언된 int형 필드 radius 선언
    
    public Circle(double x, double y, int radius) { // public으로 선언된 매개변수가 double, double, int 3개인 생성자
        this.x = x; // 객체 필드 x에 매개변수 x를 대입연산
        this.y = y; // 객체 필드 y에 매개변수 y를 대입연산
        this.radius = radius; // 객체 필드 radius에 매개변수 radius를 대입연산
    }
    public void show() { // public으로 선언된 리턴타입이 void인 show() 메소드 정의 시작
        System.out.println("(" + x + "," + y +")" + radius); // 객체 필드 출력
    }
}
 
public class CircleManager { // public으로 선언된 CircleManager 클래스 구현 시작
    
    public static void main(String[] args) { // public으로 선언된 main() 메소드 정의 시작
        // TODO Auto-generated method stub 
        Scanner scanner = new Scanner(System.in); // 사용자로부터 입력받기위해 Scanner 객체 생성
        Circle[] c = new Circle[3]; // Circle 클래스로 만든 객체 배열에 대한 레퍼런스 변수 c 선언 동시에 크기가 3인 레퍼런스 배열 생성하여 초기화
        for(int i = 0; i<c.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 c.length, 즉 c의 크기보다 작을동안 반복, i에 +1
            System.out.print("x, y, radius >>"); // x, y, radius 입력 안내 메세지 출력
            double x = scanner.nextDouble(); // double형 변수 y 선언 동시에 사용자로부터 입력받은 실수 대입연산하여 초기화
            double y = scanner.nextDouble(); // double형 변수 y 선언 동시에 사용자로부터 입력받은 실수 대입연산하여 초기화
            int radius = scanner.nextInt(); // int형 변수 radius 선언 동시에 사용자로부터 입력받은 정수 대입연산하여 초기화
            c[i] = new Circle(x, y, radius); // Circle 클래스로 만든 객체에 대한 레퍼런스를 저장하는 c[i] 원소에 Circle 클래스로 만든 객체 생성하여 초기화
        }
        for(int i = 0; i<c.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 c.length, 즉 배열 c의 크기보다 작을동안 반복, i에 +1
            c[i].show(); // c[i] 원소에 저장된 레퍼런스가 가리키는 객체의 메소드 show() 호출하여 필드 출력
        }
        
        scanner.close(); // scanner 객체 닫기
    } // main() 메소드 정의 끝
 
} // 클래스 구현 끝
 

 

6. 답: 

import java.util.Scanner; // Scanner 클래스 사용하기위해 컴파일러에게 경로명 알려줌
 
class Circle { // default로 선언된 Circle 클래스 구현 시작
    private double x, y; // private으로 선언된 double형 필드 x, y 선언
    private int radius; // private으로 선언된 int형 필드 radius 선언
    private double area; // private으로 선언된 double형 필드 area 선언
    
    public Circle(double x, double y, int radius) { // public으로 선언된 매개변수가 double, double, int 3개인 생성자
        this.x = x; // 객체 필드 x에 매개변수 x를 대입연산
        this.y = y; // 객체 필드 y에 매개변수 y를 대입연산
        this.radius = radius; // 객체 필드 radius에 매개변수 radius를 대입연산
    }
    public void show() { // public으로 선언된 리턴타입이 void인 show() 메소드 정의 시작
        System.out.println("(" + x + "," + y +")" + radius); // 객체 필드 출력
    }
    public void setArea() { // public으로 선언된 리턴타입이 void인 setArea() 메소드 정의 시작
        area = 3.14*radius*radius; // 원의 면적 계산하여 객체 필드 area에 대입연산
    }
    public double getArea() { // public으로 선언된 리턴타입이 double인 getArea() 메소드 정의 시작
        return area; // 원의 면적이 저장된 객체 필드 area에 대입연산
    }
    public static int getMaxIndex(Circle[] c) { // public으로 선언된 static 리턴타입이 int인 getMaxIndex() 메소드 정의 시작
        int maxIndex = 0; // int형 변수 maxIndex 선언 동시에 0으로 초기화
        for(int i = 1; i<c.length; i++) { // int형 변수 i 선언 동시에 1로 초기화, i가 c.length, 즉 배열 c의 크기보다 작을동안 반복, i에 +1
            if(c[i].getArea() > c[maxIndex].getArea()) { // 만약 c[i]의 면적이 c[maxIndex]의 면적보다 크면
                maxIndex = i; // maxIndex에 i 대입연산
            }
        } // 배열 c 처음부터 끝까지 검사 끝
        return maxIndex; // maxIndex를 리턴
    }
} // Circle 클래스 구현 끝
 
public class CircleManager { // public으로 선언된 CircleManager 클래스 구현 시작
    
    public static void main(String[] args) { // public으로 선언된 main() 메소드 정의 시작
        // TODO Auto-generated method stub 
        Scanner scanner = new Scanner(System.in); // 사용자로부터 입력받기위해 Scanner 객체 생성
        Circle[] c = new Circle[3]; // Circle 클래스로 만든 객체 배열에 대한 레퍼런스 변수 c 선언 동시에 크기가 3인 레퍼런스 배열 생성하여 초기화
        for(int i = 0; i<c.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 c.length, 즉 c의 크기보다 작을동안 반복, i에 +1
            System.out.print("x, y, radius >>"); // x, y, radius 입력 안내 메세지 출력
            double x = scanner.nextDouble(); // double형 변수 y 선언 동시에 사용자로부터 입력받은 실수 대입연산하여 초기화
            double y = scanner.nextDouble(); // double형 변수 y 선언 동시에 사용자로부터 입력받은 실수 대입연산하여 초기화
            int radius = scanner.nextInt(); // int형 변수 radius 선언 동시에 사용자로부터 입력받은 정수 대입연산하여 초기화
            c[i] = new Circle(x, y, radius); // Circle 클래스로 만든 객체에 대한 레퍼런스를 저장하는 c[i] 원소에 Circle 클래스로 만든 객체 생성하여 초기화
            c[i].setArea(); // c[i] 원소의 메소드 setArea() 호출하여 객체 필드 area 설정
        }
        
        System.out.print("가장 면적이 큰 원은 "); // 가장 면적이 큰 원 안내 메세지 출력
        int maxIndex = Circle.getMaxIndex(c); // int형 변수 maxIndex 선언 동시에 Circle클래스의 static 메소드 getMaxIndex() 호출하여 배열 c의 원소 중 가장 면적이 큰 원소의 인덱스로 초기화
        c[maxIndex].show(); // c[maxIndex]의 메소드 show() 호출하여, 가장 큰 면적이 큰 원의 필드 출력
        
        scanner.close(); // scanner 객체 닫기
    } // main() 메소드 정의 끝
 
} // 클래스 구현 끝

 

7. 답:

import java.util.Scanner; // Scanner 클래스 사용하기위해 컴파일러에게 경로명 알려줌
 
class Day { // default로 선언된 Day 클래스 구현 시작
    private String work; // private으로 선언된 String형 객체에대한 레퍼런스 변수 work 선언
    public void set(String work) { this.work = work; } // public으로 선언된 리턴타입이 void인 메소드 set() 정의, 매개변수 work를 필드 worrk에 대입연산
    public String get() { return work; } // public으로 선언된 리턴타입이 String인 메소드 get() 정의
    public void show() { // public으로 선언된 리터타입이 void인 메소드 show() 정의
        if(work == null) System.out.println("없습니다."); // 만약 work가 null이면, 즉 work에 저장된 문자열 객체가 없으면 없습니다. 메세지 출력
        else System.out.println(work + "입니다."); // 그렇지 않으면, 즉 work에 저장된 문자열 객체가 있으면 할 일 메세지 출력
    }
} // Day 클래스 구현 끝
 
class MonthSchedule { // default로 선언된 MonthSchedule 구현 시작
    private Scanner scanner; // private으로 선언된 Scanner 클래스로 만든 객체에 대한 레퍼런스 변수 scanner 선언
    private Day[] month; // private으로 선언된 Day 클래스로 만든 객체 배열에 대한 레퍼런스 변수 month 선언
    
    public MonthSchedule(int size) { // public으로 선언된 매개변수가 int 1개인 생성자
        month = new Day[size]; // 레퍼런스 배열 만들어 레퍼런스 변수 month 초기화
        for(int i = 0; i<month.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 month.length, 즉 배열 month의 크기보다 작을동안 반복, i에 +1
            month[i] = new Day(); // month[i] 원소에 Day 클래스로 만든 객체 대입연산하여 초기화
        }
        scanner = new Scanner(System.in); //사용자로부터 입력받기위해 scanner 객체 생성
    }
    
    public void input() { // public으로 선언된 리턴타입이 void인 input() 메소드 정의, 할일 입력 기능
        System.out.print("날짜(1~30)>?"); // 날짜 입력 메세지 출력
        int date = scanner.nextInt(); // int형 변수 date 선언 동시에 사용자로부터 입력받은 정수를 대입연산
        System.out.print("할일(빈칸없이입력)?"); // 할일 입력 메세지 출력
        month[date].set(scanner.next()); // month[date] 원소에 저장된 레퍼런스가 가리키는 객체의 메소드 set() 호출하여 사용자가 입력한 문자열 저장
        
    }
    public void view() { // public으로 선언된 리턴타입이 void인 view() 메소드 정의, 저장된 할일 출력
        System.out.print("날짜(1~30)>?"); // 날짜 입력 메세지 출력
        int date = scanner.nextInt(); // int형 변수 date 선언 동시에 사용자로부터 입력받은 정수를 대입연산
        System.out.print(date + "일의 할 일은 "); // 할일 메세지 출력
        month[date].show(); // month[date] 원소에 저장된 레퍼런스가 가리키는 객체의 메소드 show() 호출하여 저장된 문자열이 있다면 출력
        
    }
    public void finish() { // public으로 선언된 리턴타입이 void인 finish() 메소드 정의 시작
        scanner.close(); // scanner 객체 닫기
        System.out.println("프로그램을 종료합니다."); // 프로그램 종료 메세지 출력
        
    }
    public void run() { // public으로 선언되 리턴타입이 void인 run() 메소드 정의 시작
        System.out.println("이번달 스케쥴 관리 프로그램"); // 이번달 스케쥴 관리 프로그램 안내 메세지 출력
        int menu; // int형 변수 menu 선언
        while(true) { // 무한반복
            System.out.print("할일(입력:1, 보기:2, 끝내기:3) >>"); // 메뉴 입력 안내 메세지 출력
            menu = scanner.nextInt(); // 사용자로부터 입력 받은 정수를 menu에 대입연산
            switch(menu) { // menu가
            case 1: // 1인 경우
                input(); // input() 메소드 호출
                break; // switch-case문 빠져나감, 다음 반복으로 감
            case 2: // 2인 경우
                view(); // view() 메소드 호출
                break; // switch-case문 빠져나감, 다음 반복으로 감
            case 3: // 3인 경우
                finish(); // finish() 메소드 호출
                return; // run() 메소드 호출된 곳으로 되돌아감
            } // switch-case문 끝
        } // while문 끝
    } // run() 메소드 끝
} // MonthSchedule 클래스 구현 끝
 
public class Ch4_7 { // public으로 선언된 Ch4_7 클래스 구현 시작
    public static void main(String[] args) { // main() 메소드 정의 시작
        // TODO Auto-generated method stub
        MonthSchedule april = new MonthSchedule(30); // MonthSchedule 클래스로 만든 객체에대한 레퍼런스 변수 april 선언 동시에 객체 생성하여 초기화, 매개변수가 int 1개인 생성자 호출하여 초기화
        april.run(); // april 레퍼런스 변수가 가리키는 객체의 메소드 run() 호출
        
    } // main() 메소드 끝
 
} // 클래스 구현 끝

 

8. 답: 

import java.util.Scanner; // Scanner 클래스 사용하기위해 컴파일러에게 경로명 알려줌
 
class Phone { // default로 선언된 Phone 클래스 구현 시작
    private String name; // private으로 선언된 String 클래스로 만든 객체에대한 레퍼런스 변수 필드 name 선언
    private String tel; // private으로 선언된 String 클래스로 만든 객체에 대한 레퍼런스 변수 필드 tel 선언
    public Phone() { // public으로 선언된 기본 생성자
    }
    public void setName(String name) { // public으로 선언된 리턴타입이 void이고 매개변수가 String 클래스로 만든 객체에 대한 레퍼런스 변수 name인 setName() 메소드 정의 시작
        this.name = name; // 객체 필드 name에 매개변수 name을 대입연산, 레퍼런스가 복사되어 전달된다.
    }
    public void setTel(String tel) { // public으로 선언된 리턴타입이 void이고 매개변수가 String 클래스로 만든 객체에 대한 레퍼런스 변수 tel인 setTel() 메소드 정의 시작
        this.tel = tel; // 객체 필드 tel에 매개변수 tel을 대입연산, 레퍼런스가 복사되어 전달된다.
    }
    public String getName() { // public으로 선언된 리턴타입이 String 클래스로 만든 객체에 대한 레퍼런스인 getName() 메소드 정의 시작
        return name; // 객체 필드 name 리턴
    }
    public String getTel() { // public으로 선언된 리턴타입이 String 클래스로 만든 객체에 대한 레퍼런스인 getTel() 메소드 정의 시작
        return tel; // 객체 필드 tel 리턴
    }
    
} // 클래스 구현 끝
 
class PhoneBook { // default로 선언된 PhoneBook 클래스 구현 시작
    private Scanner scanner; // private으로 선언된 Scanner 클래스로 만든 객체에 대한 레퍼런스 변수인 필드 scanner 선언
    private Phone[] phoneArray; // private으로 선언된 Phone 클래스로 만든 객체 배열에 대한 레퍼런스 변수인 필드 phoneArray 선언
    
    public PhoneBook() { // public으로 선언된 기본 생성자
        scanner = new Scanner(System.in); // scanner 필드에 Scanner 클래스로 만든 객체 생성하여 초기화
        
        System.out.print("인원수>>"); // 인원수 입력 안내 메세지 출력
        int size = scanner.nextInt(); // private으로 선언된 int형 변수 size 선언 동시에 사용자로부터 입력 받은 정수로 초기화, 객체 배열의 크기
        phoneArray = new Phone[size]; // phoneArray 필드에 크기가 size인 Phone 클래스로 만든 객체 배열에 대한 레퍼런스 배열 객체 생성하여 초기화
 
        for(int i = 0; i<phoneArray.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 phoneArray.length, 배열 phoneArray의 크기보다 작을동안 반복, i에 +1
            phoneArray[i] = new Phone(); // phoneArray[i] 원소에 저장된 레퍼런스에 Phone 클래스로 만든 객체 생성하여 대입연산
            
            System.out.print("이름과 전화번호(이름과 번호는 빈 칸없이 입력)>>"); // 이름과 전화번호 입력 안내 메세지 출력
            phoneArray[i].setName(scanner.next()); // 사용자로부터 입력받은 문자열을 phoneArray[i] 원소의 메소드 setName() 호출하여 name 필드에 저장
            phoneArray[i].setTel(scanner.next()); // 사용자로부터 입력받은 문자열을 phoneArray[i] 원소의 메소드 setTel() 호출하여 tel 필드에 저장
        }
        System.out.println("저장되었습니다..."); // 저장 안내 메세지 출력
    }
    public void run() { // public으로 선언된 리턴타입이 void인 메소드 run() 정의 시작
        Boolean exist = false; // Boolean형 변수 exist 선언 동시에 초기화
        
        while(true) { // 무한반복
            System.out.print("검색할 이름>>"); // 검색할 이름 입력 안내 메세지 출력
            String name = scanner.next(); // String 클래스로 만든 객체에 대한 레퍼런스 변수 name 선언 동시에 사용자로부터 입력 받은 문자열로 초기화
            
            if(name.equals("그만")) { // 만약 name이 그만이면, 즉 사용자가 그만을 입력했으면
                scanner.close(); // scanner 객체 닫기
                return; // run() 메소드 호출한 곳으로 돌아간다.
            }
            
            for(int i = 0; i<phoneArray.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 phoneArray.length 즉 phoneArray의 크기보다 작을동안 반복, i에 +1
                if(name.equals(phoneArray[i].getName())) { // 만약 name이 phoneArray[i] 원소에 저장된 레퍼런스가 가리키는 객체의 필드 name과 같으면
                    exist = true; // exist에 true 대입연산
                    System.out.print( name + "의 번호는 "); // name의 번호 출력 안내 메세지
                    System.out.println(phoneArray[i].getTel() + " 입니다."); // phoneArray[i] 원소에 저장된 레퍼런스가 가리키는 객체의 메소드 getTel()을 호출하여 필드 tel 출력
                }
            }
            
            if(exist == false) { // 만약 exist가 false이면, 즉 사용자가 입력한 name이 phoneArray에 없으면
                System.out.println( name + " 이 없습니다."); // 없습니다. 출력
            }
            
            exist = false; // exist에 저장된 true를 false로 바꾼다. 초기화 작업
        }
    }
}
 
public class Ch4_8 { // public으로 선언된 Ch4_8 클래스 구현시작 
 
    public static void main(String[] args) { // main() 메소드 정의 시작
        // TODO Auto-generated method stub
        PhoneBook phoneBook = new PhoneBook(); // PhoneBook클래스로 만든 객체에대한 레퍼런스 변수 phoneBook 선언 동시에 객체 생성하여 초기화
        phoneBook.run(); // phoneBook 객체의 메소드 run() 호출
        
    } // main() 메소드 끝
 
} // 클래스 구현 끝

 

9. 답:

class ArrayUtil { // default로 선언한 ArrayUtil 클래스 구현 시작
    public static int[] concat(int[] a, int[] b) { // public으로 선언된 static멤버 리턴타입이 int형 배열에 대한 레퍼런스인 concat() 메소드 정의 시작
        int[] temp = new int[a.length +b.length]; // int형 배열에대한 레퍼런스 변수 temp 선언 동시에 크기가 a.length+b.length, 즉 배열 a, b의 크기를 합한 크기의 배열 생성하여 초기화
        int index; // int형 변수 index 선언
        
        for(int i = 0; i<a.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 a.length 즉 a의 크기보다 작을동안 반복, i에 +1
            index = i; // index에 i 대입연산
            temp[index] = a[i]; // temp[index] 원소에 a[i] 원소 대입연산
        }
        for(int i = 0; i<b.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 b.length 즉 b의 크기보다 작을동안 반복, i에 +1
            index = a.length + i; // index에 a.length+i 대입연산
            temp[index] = b[i]; // temp[index] 원소에 b[i] 원소 대입연산
        }
        
        return temp; // 배열에 대한 레퍼런스 변수 temp 리턴
    }
    public static void print(int[] a) { // public으로 선언된 static 멤버 리턴타입이 void인 print() 메소드 정의 시작
        System.out.print("[ "); // [ 출력
        for(int i = 0; i<a.length; i++) { // int형 변수 i 선언 동시에 0으로 초기화, i가 a.length 즉 배열 a의 크기보다 작을동안 반복, i에 +1
            System.out.print(a[i] + " "); // a[i] 원소 출력
        }
        System.out.println("]"); // ] 출력
    }
} // 클래스 구현 끝
 
public class StaticExd { // public으로 선언된 StaticEx 클래스 구현 시작
 
    public static void main(String[] args) { // main() 메소드 정의 시작
        // TODO Auto-generated method stub
        int[] array1 = {1, 5, 7, 9}; // int형 배열에대한 레퍼런스 변수 array1 선언 동시에 배열 생성하여 초기화
        int[] array2 = {3, 6, -1, 100, 77}; // int형 배열에 대한 레퍼런스 변수 array2 선언 동시에 배열 생성하여 초기화
        int[] array3 = ArrayUtil.concat(array1, array2); // int형 배열에 대한 레퍼런스 변수 array3 선언 동시에 ArrayUtil 클래스의 static 메소드 concat() 호출하여 array1, array2 합친 배열 리턴하여 초기화 
        ArrayUtil.print(array3); // ArrayUtil 클래스의 static 멤버 메소드 print() 호출하여 array3 배열 출력
    } // main() 메소드 정의 끝
 
} // 클래스 구현 끝

 

10. 답:

import java.util.Scanner; // Scanner 클래스 사용하기위해 컴파일러에게 경로명 알려줌
 
class Dictionary { // default로 선언된 클래스 Dictionary 구현 시작
    private static String[] kor = { "사랑", "아기", "돈", "미래", "희망" }; // private으로 선언된 static 멤버 String형 클래스로 만든 객체 배열에 대한 레퍼런스 kor 선언 동시에 배열 생성하여 초기화
    private static String[] eng = {"love", "baby", "money", "future", "hope" }; // private으로 선언된 static 멤버 String형 클래스로 만든 객체 배열에 대한 레퍼런스 kor 선언 동시에 배열 생성하여 초기화
    public static String kor2Eng(String word) { // public으로 선언된 static 멤버 리턴타입이 String형 클래스로 만든 객체에 대한 레퍼런스 변수인 kor2Eng() 메소드 정의 시작
        String answer = ""; // String형 클래스로 만든 객체에 대한 레퍼런스 변수 answer 선언 동시에 "" 대입연산
        Boolean exist = false; // Boolean형 변수 exist 선언 동시에 false 대입연산
        
        for(int i = 0; i<kor.length; i++) { // int형 변수 i 선언 동시에 0으로 선언, i가 kor.length 죽 kor 배열의 크기보다 작을동안 반복, i에 +1
            if(word.equals(kor[i])) { // 만약 word가 kor[i] 원소와 같으면
                exist = true; // exist에 true 대입연산
                answer = eng[i]; // answer에 eng[i] 대입연산
                break; // 영어단어 찾는 for문 빠져나감
            }
        }
        if(exist == false) { // 만약 exist가 false이면
            System.out.println(word + "는 저의 사전에 없습니다."); // 사전에 없습니다. 출력
        }
        else { // 그렇지 않으면, 즉 exist가 true이면
            System.out.println(word + "은 " + answer); // 한글단어에 맞는 영어단어 출력
        }
        
        exist = false; // exist는 false로 초기화
        
        return answer; // answer 리턴
    } 
} // 클래스 구현 끝
 
class DicApp { // default로 선언된 DicApp 클래스 구현 시작
    private Scanner scanner; // private으로 선언된 Scanner 클래스로 만든 객체에 대한 레퍼런스 필드 scanner 선언
    private String search; // private으로 선언된 String 클래스로 만든 객체에 대한 레퍼런스 필드 search 선언
    public DicApp() { // public으로 선언된 기본 생성자
        scanner = new Scanner(System.in); // scanner에 Scanner 클래스로 만든 객체 생성하여 대입연산
    }
    public void run() { // public으로 선언된 리턴타입이 void인 run() 메소드 정의 시작
        System.out.println("한영 단어 검색 프로그램입니다."); // 한영 단어 검색 프로그램 입니다. 출력
        
        while(true) { // 무한반복
            System.out.print("한글 단어?"); // 한글 단어 입력 메세지 출력
            search = scanner.next(); // 사용자로부터 입력받은 문자열을 search에 대입연산
            
            if(search.equals("그만")) { // 만약 search가 그만이면, 즉 사용자가 그만을 입력했으면
                break; // 단어 찾는 반복문 while문을 빠져나감
            }
            
            Dictionary.kor2Eng(search); // Dictionary 클래스의 static 메소드 kor2Eng() 호출하여 search에 저장된 단어 찾기
        }
        
        scanner.close(); // scanner 객체 닫기
        return; // 함수 호출한 곳으로 다시 되돌아감
    }
}
 
public class Ch4_10 { // public으로 선언된 Ch4_10 클래스 구현 시작
 
    public static void main(String[] args) { // main() 메소드 정의 시작
        // TODO Auto-generated method stub
        DicApp dicApp = new DicApp(); // DicApp 클래스로 만든 객체에 대한 레퍼런스 변수 dicApp 선언 동시에 객체 생성하여 초기화
        dicApp.run(); // dicApp 객체 메소드 run() 호출
    } // main() 메소드 정의 끝
    
} // 클래스 구현 끝
 

 

11. 답:

import java.util.Scanner; // Scanner 클래스 사용하기위해 컴파일러에게 경로명 알려줌
 
class Add { // default로 선언된 Add 클래스 구현 시작
    private int a, b; // private으로 선언된 int형 필드 a, b 선언
    public void setValue(int a, int b) { // public으로 선언된 리턴타입이 void인 setVaule() 메소드 정의 시작
        this.a = a; // 필드 a에 매개변수 a를 대입연산
        this.b = b; // 필드 b에 매개변수 b를 대입연산
    }
    public int calculate() { // public으로 선언된 리턴타입이 int인 calculate() 메소드 정의 시작
        return a+b; // a+b 리턴
    }
}
class Sub { // default로 선언된 Sub 클래스 구현 시작
    private int a, b; // private으로 선언된 int형 필드 a, b 선언
    public void setValue(int a, int b) { // public으로 선언된 리턴타입이 void인 setVaule() 메소드 정의 시작
        this.a = a; // 필드 a에 매개변수 a를 대입연산
        this.b = b; // 필드 b에 매개변수 b를 대입연산
    }
    public int calculate() { // public으로 선언된 리턴타입이 int인 calculate() 메소드 정의 시작
        return a-b; // a-b 리턴
    }
}
class Mul { // default로 선언된 Mul 클래스 구현 시작
    private int a, b; // private으로 선언된 int형 필드 a, b 선언
    public void setValue(int a, int b) { // public으로 선언된 리턴타입이 void인 setVaule() 메소드 정의 시작
        this.a = a; // 필드 a에 매개변수 a를 대입연산
        this.b = b; // 필드 b에 매개변수 b를 대입연산
    }
    public int calculate() { // public으로 선언된 리턴타입이 int인 calculate() 메소드 정의 시작
        return a*b; // a*b 리턴
    }
}
class Div { // default로 선언된 Sub 클래스 구현 시작
    private int a, b; // private으로 선언된 int형 필드 a, b 선언
    public void setValue(int a, int b) { // public으로 선언된 리턴타입이 void인 setVaule() 메소드 정의 시작
        this.a = a; // 필드 a에 매개변수 a를 대입연산
        this.b = b; // 필드 b에 매개변수 b를 대입연산
    }
    public int calculate() { // public으로 선언된 리턴타입이 int인 calculate() 메소드 정의 시작
        if(b==0) { // 만약 나누는 수가 0이면
            System.out.println("0으로 나눌 수 없습니다."); // 0으로 나눌수 없습니다. 안내 메세지 출력
            return -1; // -1 리턴
        }
        return a/b; // a*b 리턴
    }
}
 
public class Ch4_11 { // public으로 선언된 Ch4_11 클래스 구현 시작
 
    public static void main(String[] args) { // main() 메소드 정의 시작
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in); // Scanner 클래스로 만든 객체에대한 레퍼런스 변수 scanner 선언 동시에 객체 생성하여 초기화
        
        System.out.print("두 정수와 연산자를 입력하시오>>"); // 입력 안내 메세지 출력
        int a = scanner.nextInt(); // int형 변수 a 선언 동시에 사용자로부터 입력 받은 정수를 대입연산
        int b = scanner.nextInt(); // int형 변수 b 선언 동시에 사용자로부터 입력 받은 정수를 대입연산
        char operator = scanner.next().charAt(0); // char형 변수 operator 선언 동시에 charAt() 메소드 호출하여 사용자로부터 입력 받은 문자열의 0번째 인덱스를 문자형 변수로 변환한 뒤 대입연산
        int answer = 0; // int형 변수 answer 선언 동시에 0으로 초기화
        
        switch(operator) { // operator에 저장된 문자열이
        case '+': // +인 경우
            Add add = new Add(); // Add 클래스로 만든 객체에 대한 레퍼런스 변수 add 선언 동시에 객체 생성하여 초기화
            add.setValue(a, b); // add의 메소드 setValue() 호출하여 객페 필드 a, b 설정
            answer = add.calculate(); // add의 메소드 calculate() 호출하여 계산되어 리턴된 값을 answer에 대입연산
            break; // switch-case문 빠져나감
        case '-':
            Sub sub = new Sub();
            sub.setValue(a, b);
            answer = sub.calculate();
            break;
        case '*':
            Mul mul = new Mul();
            mul.setValue(a, b);
            answer = mul.calculate();
            break;
        case '/':
            Div div = new Div();
            div.setValue(a, b);
            answer = div.calculate();
            break;
        }
        System.out.println(answer); // answer에 저장된 값 출력
        
        scanner.close(); // scanner 객체 닫기
    } // main() 메소드 정의 끝
 
} // 클래스 구현 끝
 

 

12. 답: