day 0516 정렬_객체와 클래스

package com.kosta.exam;

public class D01MethodTest {

	// 점수가 가장 높은 학생의 이름을 반환하기
	public static String getFirstName(String[] name, int[] score){
		String result = "";
		int max = score[0];
		int idx = 0;
		for(int i = 0; i < score.length; i++) {
			if( score[i] > max) {
				max = score[i];
				idx = i;
                /*
                dx = i; 는 현재 가장 높은 점수를 가진 학생의 인덱스를 기록하는 데 사용됩니다. 
                이 코드는 주어진 학생들의 점수 배열을 순회하면서 가장 높은 점수를 가진 학생의 인덱스를 찾습니다. 
                그 인덱스를 idx 변수에 저장하여 후에 해당 인덱스에 해당하는 학생의 이름을 반환할 때 사용됩니다.
                */
			}
		}
		result = name[idx];
		return result;
	}
	public static void main(String[] args) {
		String[] name = {"홍길동", "이순신", "유관순", "김유신", "강감찬"};
		int[] score = {80, 90, 95, 70, 60};
		
		System.out.println(getFirstName(name, score));
	}
}

 
<< 배열의 정렬하기 >>
값을 순서대로 오도록 배치하는 것
 
오름차순 : 값이 작은것부터 순서대로 오도록
내림차순 : 값이 큰것부터 순서대로 오도록

package com.kosta.exam;

public class D02SortArray {

	public static void main(String[] args) {
		int[] a = {17, 16, 15, 7,9,11};
		
		// 오름차순 정렬
		for(int i = 0; i < a.length; i++) {
			for(int j = i+1; j < a.length; j++) {
				if(a[j] < a [i]) {
					int temp = a[i];
					a[i] = a[j];
					a[j] = temp;
				}
			}
		}
		System.out.println("*** 이번주 추천번호 ***");
		for(int i = 0; i < a.length; i++) {
			System.out.printf("%5d", a[i]);
		}
	}
}

 
<< 메소드 호출 >>
1. 값에 의한 호출(Call By Value)
    메소드 호출시에 기본자료형이 전달되는 것을 말하며
    메소드 안에서 매개변수로 전달된 값이 변경되더라도 호출한 쪽에서는 적용되지 않아요
2. 참조에 의한 호출(Call By Reference)
    메소드 호출시에 참조자료형이 전달되는 것을 말하며
    메소드 안에서 매개변수로 전달된 변수의 내용이 변경이 될 때에 호출한 쪽에서 적용이 되어요

package com.kosta.exam;

// 값에 의한 호출의 특징 알아보기
public class D03MethodCallByValueTest {
	// 정수형 변수 하나를 매개변수로 전달받아 1증가하여 출력하는 메소드
	public static void add(int n) {
		n = n + 1; // a = 5;의 값을 복사해서 받고 n은 5가되고 +1을 한다
		System.out.println("n : " + n); // n : 6
		// return; 값이 없을때는 생략
	}
	public static void main(String[] args) {
		// 기본 자료형은 변수 자신이 값을 가진다
		int a;
		a = 5;
		
		// a가 int n을 복사하러간다
		add(a);
		System.out.println("a : " + a); // n : 5
	}
}

package com.kosta.exam;

public class D04MethodCallByReferenceTest {
	// 정수형 배열을 매개변수로 전달받아 배열의 요소를 모두 1씩 증가하는 메소드
	public static void add(int[] arr) { // data와 같은 주소값을 갖는다
		
		for(int i = 0; i < arr.length; i++) {
			arr[i] = arr[i] + 1;
		}
		
		for(int i = 0; i < arr.length; i++) {
			System.out.printf("%5d", arr[i]);
		}
		System.out.println();
		
		return;
	}
	public static void main(String[] args) {
		int[] data = {10, 20, 30, 40, 50}; 
		add(data); // data가 있는 주소값을 참조 (참조에 의한 호출)
		for(int i = 0; i < data.length; i++) {
			System.out.printf("%5d", data[i]);
		}
	}
}

package com.kosta.exam;

import java.util.Scanner;

public class D05StudentSortTest {

	// 5명학생의 이름, 국어, 영어, 수학을 입력받아 총점, 평균을 구하고 성적순으로 정렬하여 출력
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		String[] name = new String[5];
		int[] kor = new int[5];
		int[] eng = new int[5];
		int[] math = new int[5];
		int[] tot = new int[5];
		double[] avg = new double[5];
		
		for(int i = 0; i < name.length; i++) {
			System.out.printf("%d번째 학생의 이름 : ", i+1);
			name[i] = sc.next();
			
			// 국어, 영어, 수학을 입력받고 총점과 평균을 계산하여 배열에 담아 봅니다.
			System.out.printf("%d번째 학생의 국어 점수 : ", + i+1);
			kor[i] = sc.nextInt();
			System.out.printf("%d번째 학생의 영어 점수 : ", + i+1);
			eng[i] = sc.nextInt();
			System.out.printf("%d번째 학생의 수학 점수 : ", + i+1);
			math[i] = sc.nextInt();
			
			tot[i] = kor[i] + eng[i] + math[i];
			avg[i] = tot[i] / 3.0;
			
		}
		System.out.println("*** 성적 처리 결과 ***");
		System.out.println("이름\t국어\t영어\t수학\t총점\t평균");
		System.out.println("==========================");
		for(int i = 0; i < name.length; i++) {
			System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\n", name[i], kor[i], eng[i], math[i], tot[i], avg[i]);
		}
		// 성적이 높은순으로 정렬하기
		for(int i = 0; i < tot.length; i++) {
			for(int j = i+1; j < tot.length; j++) {
				if(tot[j] > tot [i]) {
					String temp_name = name[i];
					name[i] = name[j];
					name[j] = temp_name;
				
					int temp = kor[i];
					kor[i] = kor[j];
					kor[j] = temp;
					
					temp = eng[i];
					eng[i] = eng[j];
					eng[j] = temp;
					
					temp = math[i];
					math[i] = math[j];
					math[j] = temp;
					
					temp = tot[i];
					tot[i] = tot[j];
					tot[j] = temp;
					
					double temp_avg = avg[i];
					avg[i]  = avg[j];
					avg[j] = temp_avg;
				} // end if
			} // end for j
		} // end for i
		System.out.println("*** 성적순으로 정렬 처리 결과 ***");
		System.out.println("이름\t국어\t영어\t수학\t총점\t평균");
		System.out.println("==========================");
		for(int i = 0; i < name.length; i++) {
			System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\n", name[i], kor[i], eng[i], math[i], tot[i], avg[i]);
		}
	}
}

 

ㅎㅏ,, \t가 이름만 되고 나머지는 안되서ㅓ 강박으로 미쳐도라버리기일보직전😫😫😫😫😫
 

for(int i = 0; i < tot.length; i++) {
	for(int j = i+1; j < tot.length; j++) {
		if(tot[j] > tot [i]) {
			String temp_name = name[i];
			name[i] = name[j];
			name[j] = temp_name;
		
			int temp = kor[i];
			kor[i] = kor[j];
			kor[j] = temp;
			
			temp = eng[i];
			eng[i] = eng[j];
			eng[j] = temp;
			
			temp = math[i];
			math[i] = math[j];
			math[j] = temp;
			
			temp = tot[i];
			tot[i] = tot[j];
			tot[j] = temp;
			
			double temp_avg = avg[i];
			avg[i]  = avg[j];
			avg[j] = temp_avg;
		} // end if
	} // end for j
} // end for i

// 들여쓰기 tab, 내어쓰기 shift+tab

==> 위의 코드는 성적순으로 정렬하는 코드 입니다.

 

==> 총점을 비교 하여 비교하는 학생의 총점이 i번째 학생의 총점보다 더 크다면

이름도 바꾸고

국어도 바꾸고

영어, 수학, 총점, 평균을 각각 바꿔줘야 합니다.

이것은 상당히 번거로운 일입니다.

 

==> 위와 같이 "기본자료형"만으로 프로그래밍 할 때에 "불가능"한 것은 아니지만

정렬하고자 할 때 일일이 바꿔줘야 하는 것은 시간이 오래걸리고 번거로워요.

 

==> 이럴때에 한명의 한생의 정보

(이름, 국어, 영어, 수학, 총점, 평균)을 하나의 세트로 하는

"새로운 자료형"을 만들면 보다 더 간결하게 표현 할 수 있어요.

class 새로운자료형 {
	세트를 이루는 구성요소(들)
}

class Student{ // Student로 된 새로운 자료형을 만든다
	String name;
	int kor;
	int eng;
	int math;
	int tot;
	double avg;
}

int year; // 변수를 선언한다 (기본 자료형)
yrar = 2024; // 값을 바로 가질 수 있다

Student data; // 변수를 선언한다 (참조 자료형)
data = new Student // 값을 바로 가질 수 없다. new  객체 생성하여 사용한다. Student 메모리를 할당하여 참조한다.
 
data.name = "홍길동";
data.kor = 100; 
각각의 구성요소를 변경하기 위해서는 참조변수를 통해서 가능하다.

package com.kosta.exam;

class Student {
	String name;
	int kor;
	int eng;
	int math;
	int tot;
	double avg;
}

public class D06StudentClassTest {

	public static void main(String[] args) {
		int year;
		year = 2024;
		// 클래스 참조변수는 new에 의하여 객체를 생성하고 사용할 수 있어요
		Student data;
		data = new Student();
		
		data.name = "홍길동";
		data.kor = 100;
		data.eng = 80;
		data.math = 90;
		data.tot = data.kor + data.eng + data.math;
		data.avg = data.tot / 3.0;
		System.out.println(data.name + "," + data.kor + "," + data.eng + "," + data.math + "," + 
											  data.tot + "," + data.avg);
	}
}

 
/같은 이름의 class는 사용할 수 없다. 새로운 package를 만든다/

package com.kosta.exam01;

import java.util.Scanner;

class Student {
	String name;
	int kor;
	int eng;
	int math;
	int tot;
	double avg;
}

public class D07StudentClassTest {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		Student data;
		data = new Student();
	
		System.out.print("학생의 이름 : ");
		data.name = sc.next();		
		System.out.print("학생의 국어점수 : ");
		data.kor = sc.nextInt();
		System.out.print("학생의 영어점수 : ");
		data.eng = sc.nextInt();
		System.out.print("학생의 수학점수 : ");
		data.math = sc.nextInt();
		
		data.tot = data.kor + data.eng + data.math;
		data.avg = data.tot / 3.0;
		System.out.println(data.name + "," + data.kor + "," + data.eng + "," + data.math + "," + 
											  data.tot + "," + data.avg);
	}
}

 
int[] a;
a = new int[5]
==> int의 변수 5개를 만들었어요.
 
 
Student[] data; 
data = new Student[5];
==> Student의 변수 5개를 만들었어요.
       Student의 객체가 생성된 것은 아닙니다.

package com.kosta.exam02;

import java.util.Scanner;

class Student {
	String name;
	int kor;
	int eng;
	int math;
	int tot;
	double avg;
}

public class D08StudentClassTest {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		Student[] data;
		data = new Student[5]; // int[] a; a = new int[5]와 같다. 참조변수를 5개 만든거 객체 생성 아님.
	
		// 반복문 안에서 Student의 객체를 생성해야한다.
		for(int i = 0; i < data.length; i++) {
			data[i] = new Student(); // 객체 생성
				
				System.out.printf("%d번째 학생의 이름 : ", i + 1);
				data[i].name = sc.next();
				System.out.print("학생의 국어점수 : ");
				data[i].kor = sc.nextInt();
				System.out.print("학생의 영어점수 : ");
				data[i].eng = sc.nextInt();
				System.out.print("학생의 수학점수 : ");
				data[i].math = sc.nextInt();
				
				data[i].tot = data[i].kor + data[i].eng + data[i].math;
				data[i].avg = data[i].tot / 3.0;
				
		}
		
		System.out.println("*** 성적 처리 결과 ***");
		System.out.println("이름\t국어\t영어\t수학\t총점\t평균");
		System.out.println("==========================");
		for(int i =0; i < data.length; i++) {
			System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\n", 
												data[i].name, data[i].kor, data[i].eng, data[i].math, data[i].tot, data[i].avg);
		}
	}
}

\t 〰〰😫😫😫😫😫😫😫😫😫😫😫😫😫😫😫😫😫😫😫😫
 

package com.kosta.exam02;

import java.util.Scanner;

class Student {
	String name;
	int kor;
	int eng;
	int math;
	int tot;
	double avg;
}

public class D09StudentClassTest {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		Student[] data;
		data = new Student[5]; // int[] a; a = new int[5]와 같다. 참조변수를 5개 만든거 객체 생성 아님.
	
		// 반복문 안에서 Student의 객체를 생성해야한다.
		for(int i = 0; i < data.length; i++) {
			data[i] = new Student(); // 객체 생성
				
				System.out.printf("%d번째 학생의 이름 : ", i + 1);
				data[i].name = sc.next();
				System.out.print("학생의 국어점수 : ");
				data[i].kor = sc.nextInt();
				System.out.print("학생의 영어점수 : ");
				data[i].eng = sc.nextInt();
				System.out.print("학생의 수학점수 : ");
				data[i].math = sc.nextInt();
				
				data[i].tot = data[i].kor + data[i].eng + data[i].math;
				data[i].avg = data[i].tot / 3.0;
				
		}
		
		System.out.println("*** 성적 처리 결과 ***");
		System.out.println("이름\t국어\t영어\t수학\t총점\t평균");
		System.out.println("==========================");
		for(int i =0; i < data.length; i++) {
			System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\n", 
												data[i].name, data[i].kor, data[i].eng, data[i].math, data[i].tot, data[i].avg);
		}
		
		for(int i = 0; i < data.length; i++) {
			for(int j = 0; j <data.length; j++) {
				if(data[j].tot > data[i].tot) {
					Student temp = data[i];
					data[i] = data[j];
					data[j] = temp;
				}
			}
		}
		System.out.println("*** 성적순으로 정렬한 결과 ***");
		System.out.println("이름\t국어\t영어\t수학\t총점\t평균");
		System.out.println("==========================");
		for(int i =0; i < data.length; i++) {
			System.out.printf("%s\t%d\t%d\t%d\t%d\t%.2f\n", 
												data[i].name, data[i].kor, data[i].eng, data[i].math, data[i].tot, data[i].avg);
		}
	}
}

 

---

 
14:00 ~
 
객체와 클래스
 
c++, 자바
==> 객체 지향 프로그래밍(Object Oriented Programming)
==> 현실세계의 모든 것을 객체화 할 수 있다.
 
객체
==> 이 세상에서 유일한 것.
==> 이 세상은 수 많은 객체들로 구성이 되어있어요.
==> 여기에 앉아 있는 여러분 한명한명이 모두 객체입니다.
==> 내 책상에 놓여 있는 "에이스" 과자도 객체이고
==> A 책상에 놓여 있는 4색볼펜이 객체이고
==> B 책상에 놓여있는 리모콘도, 선풍기도 모두 객체 입니다.
==> 제 책상에 놓여 있는 리모콘도, 선풍기도 모두 객체 입니다 
==> 각각의 객체 그 객체를 나타내기 위한 여러가지 "속성"들로 구성되 있어요. 
==> 선풍이기는 날개 펜이 있고, 덮게가 있고 받침대도 있고 동작시키기 위한 버튼으로 구성되 있어요. 
==> 에이스 과자에서 날개 펜을 찾을 수는 없어요.
 
자바 언어로 "객체지향 프로그래밍을 할 때에는"
먼저, 내가 표현하고자 하는 객체에 대하여 "속성"과 "동작"을 분석합니다.
클래스를 만들어요.
 
- 클래스 : 객체를 만들기 위한 틀(설계도)에 해당 합니다.
- 객체 : 설계도에서 생산된 하나하나가 객체이다.
 
- 클래스
    속성 : 멤버변수
    동작 : 멤버메소드(어떤 기능을 할 수 있는지)
 
- 손에 아이폰을 들고 이스백을 메고 은행에 들어간다.
사람
        속성
                손
        동작
               든다
               맨다
 
class 사람(person)
==>다른 형태의 다른 속성과 다른 동작을 가진 person이 나올 수 있다
        속성
                이름 String name   "구체적인 값";
                성별 String gender "남자","여자";
                나이 int age;           "25살"
        동작
                먹는다 void eat(String food); // 무엇을 먹는지
                걷는다 void walk(String where); // 어디를 걷는지

package com.kosta.exam04;
/*
        속성
                이름 String name   "구체적인 값";
                성별 String gender "남자","여자";
                나이 int age;           "25살"
        동작
                먹는다 void eat(String food); // 무엇을 먹는지
                걷는다 void walk(String where); // 어디를 걷는지
*/

class Person {
	String name;
	String gender;
	int age;
	public void eat(String food) {
		System.out.printf("%s %d살 %s이(가) %s를(을) 먹어요\n", gender, age, name, food);
	}
	public void walk(String where) {
		System.out.printf("%s %d살 %s이(가) %s를(을) 걸어요\n",gender, age, name, where);
	}
}

public class PersonTest {

	public static void main(String[] args) {
		int data; // 기본 자료형
		Person lee; // 참조 자료형
		data = 2024; // 기본자료형은 바로 값을 저장할 수 있다
		lee = new Person(); // 참조자료형은 객체를 사용하고 사용할 수 있다 . 
		Person kim = new Person(); // 참조변수를 선언하면서 바로 생성할 수 있다.
		lee.name = "A";
		lee.gender = "남자";
		lee.age = 28;
		
		kim.name = "B";
		kim.gender="여자";
		kim.age =26;
		
		lee.eat("빙빙바");
		lee.walk("청계천");
		
		kim.eat("에이스");
		kim.walk("광화문");	
	}
}

 
객체지향 프로그래밍의 특징
    1) 은닉성(encapsulation) : 외부의 다른 클래슬 부터 속성(멤버변수)를 보호하는 것을 말합니다.
            접근 명시자 : 
                private (전용부) : 클래스 자신만 접근할 수 있어요. (외부로부터 클래스를 보호한다)
                public (공용부)  : 외부의 어떤 클래스라도 접근할 수 있어요.
 
객체지향 프로그래밍의 첫번째 특징이ㅣ 은닉성에 맞추어 Person 클래스를 만들면
다음과 같이 모든 속성들을 private 영역에 둡니다.

private String name;

private String gender;

private int age;

 

위와같이 모든 속성들이 private 영역에 있으면 외부의 다른 클래스에서는

직접 멤버변수에 접근할 수 없고

public에 있는 메소드를 통해서 접근할 수 있도록 만들어야 합니다.

접근하여 길을 변경시키는 동작도 필요하고 접근하여 값을 읽어 오는 동작도 필요합니다.

 

값을 변경하는 동작  ==>  setXxx()  setter  설정자

값을 읽어오는 동작  ==>  getXxx()  getter  접근자

package com.kosta.exam05;

class Person {
	// private : 직접 접근 못함. 값 설정 : setter 값 읽어오기 : getter
	private String name;
	private String gender;
	private int age;

	// 접근해서 값 읽어오기 getter
	public String getName() {
		return name;
	}
	public String getGender() {
		return gender;
	}
	public int getAge() {
		return age;
	}
	
	// 값을 변경시키는 동작이 속성의 수 만큼 필료하다
	// 변경은 public method를 통해서 할 수 있다.
	public void setName(String n) {
		name = n;
	}
	public void setGender(String g) {
		gender = g;
	}
	public void setAge(int a) {
		age = a;
	}
	
	public void eat(String food) {
		System.out.printf("%s %d살 %s이(가) %s를(을) 먹어요\n", gender, age, name, food);
	}
	public void walk(String where) {
		System.out.printf("%s %d살 %s이(가) %s를(을) 걸어요\n",gender, age, name, where);
	}
}

public class PersonTest {

	public static void main(String[] args) {
		
		Person lee; // 참조 자료형
		lee = new Person(); // 참조자료형은 객체를 사용하고 사용할 수 있다 . 
		
		Person kim = new Person(); // 참조변수를 선언하면서 바로 생성할 수 있다.
		
		/*
		lee.name = "A"; // private 하면 사용 못한다. setter로 호출 할 수 있다
		lee.gender = "남자";
		lee.age = 28;
		*/
		
		lee.setName("A");
		lee.setGender("남자");
		lee.setAge(28);
		
		lee.eat("빙빙바");
		lee.walk("청계천");

		// 읽어오는 기능은 getter 
		System.out.println("이름 : " + lee.getName() );
		System.out.println("성별 : " + lee.getGender() );
		System.out.println("나이 : " + lee.getAge() );
	}
}

/*
PROGRAMMING 1.
사각형을 나타내는 Rectangle이라고 이름 붙여진 클래스를 설계하여 보자.
Rectangle은 사각형의 가로를 나타내는 width와 length를 필드로 가진다. // 속성을 가진다
또한 사각형의 넓이를 계산하여서 반환하는 calcArea()를 메소드로 가진다.
Rectangle 클래스를 UML로 그리고 접근자, 설정자를 추가하여서 자바로 구현하여 보라.
*/

package com.kosta.exam06;

	class Rectangle {
		private double width;
		private double length;

		public double calcArea() {
			double area = width * length;
			return area;
		}
		public double getLength() {
			return length;
		}
		public double getWidth() {
			return width;
		}
		public void setLength(double b){
			length = b;
		}
		public void setWidth(double a){
			width = a;
		}
	}
	public class RectangleTest {
    
		public static void main(String[] args) {
			Rectangle  r1 = new Rectangle();
			r1.setWidth(200);
			r1.setLength(300);
			System.out.println("가로 : " + r1.getWidth());
			System.out.println("세로 : " +  r1.getLength());
			System.out.println("면적 : " + r1.calcArea());
	}
}

/*
PROGRAMMING 5.
직원을 나타내는 Employee 클래스를 작성항 보자.
직원은 이름, 전화 번호, 연봉을 필드로 가지고 있다.
각 필드에 대하여 접근자와 설정자를 작성하라.
EmployeeTest클래스를 작성하여서 Employee 객체를 생성하고 테스트하라.
*/

package com.kosta.exam07;

class Employee {
	private String name;
	private String phone;
	private int salary;
		
	public String getName() {
		return name;
	}
	public String getPhone() { // String을 반환
		return phone;
	}
	public int getSalary() { // int를 반환
		return salary;
	}
	public void setName(String n) {
		name = n;
	}
	public void setPhone(String p) {
		phone = p;
	}	
	public void setSalary(int s) { // 반환하는 값이 없어서 void
		salary = s;
	}
}

public class EmployeeTest {

	public static void main(String[] args) {
		Employee ee = new Employee();
		ee.setName("이름");
		ee.setPhone("01022222222");
		ee.setSalary(3000);

		System.out.println("이름 : " + ee.getName());
		System.out.println("번호 : " + ee.getPhone());
		System.out.println("연봉 : " + ee.getSalary());
	}
}

 
생성자(Constructor)
==> 클래스 이름과 같은이름의 특수한 메소드를 말하며
       객체 생성시에 자동 수행되어 멤버변수들의 값을 초기화 할 목적으로 사용합니다.
 
==> 일반 메소드는 호출문에 의해 동작하지만
        생성자는 객체 생성시에 자동 수행되기 때문에 return의 개념이 없어요.
        따라서 생성자 옆에는 일반 메소드처럼 return type을 쓰지 않아요.
        (void라고 쓰면 잘못된거에요. 생성자 앞에 쓰면 안된다)

package com.kosta.exam08;

class Employee {
	private String name;
	private String phone;
	private int salary;
		
	// 생성자, class 이름과 똑같은 이름의 public 생성자
	// 초기화 하고싶은 명령어 
	public Employee() { // Employee ee = new Employee();의 값
		name = "초기화";
		phone = "01023456789";
		salary = 7000;
	}
	
	public String getName() {
		return name;
	}
	public String getPhone() { // String을 반환
		return phone;
	}
	public int getSalary() { // int를 반환
		return salary;
	}
	public void setName(String n) {
		name = n;
	}
	public void setPhone(String p) {
		phone = p;
	}	
	public void setSalary(int s) { // 반환하는 값이 없어서 void
		salary = s;
	}
}

public class EmployeeTest {
	public static void main(String[] args) {
		Employee ee = new Employee();
		
		/*
		ee.setName("이름");
		ee.setPhone("01022222222");
		ee.setSalary(5000);
		*/ 
		
		System.out.println("이름 : " + ee.getName());
		System.out.println("번호 : " + ee.getPhone());
		System.out.println("연봉 : " + ee.getSalary());
	}
}

 
- 오늘 학습한 내용에 대하여 요약 및 정리하고 궁금한 점 질문합니다.
- 요약 및 정리가 다 된 사람은 pdf "객체와 클래스"의 프로그래밍 6번, 8번을 작성 해 봅니다.

오늘 열시미 숙면해또니 ꕀ 단골손님이 되어버린,, 🤗
책상에 놓여 있던 에이스는 우리집으로 귀ㄱㅏ중 ꕀ