*생성자
메소드명이 클래스명과 동일하고 리턴 자료형이 없는 public 메소드
객체가 생성될 때 (new문을 쓸 때) 호출되는 메소드
[ 표현법 ]
public 클래스명(매개변수 => 생략 가능) {
객체를 생성할 때 내가 실행하고자 하는 코드;
(내가 원하는 값으로 필드를 초기화하는 코드를 주로 씀)
}
생성자를 작성하는 목적
1. 객체를 생성해 주기 위한 목적(new문을 쓸때 함께 쓰임) // Product p1 = new Product(); 구문에서 new 뒤의 Product()생성자임!
2. 객체 생성뿐 아니라 매개변수로 전달한 값을 곧바로 필드에 초기화할 목적
*생성자 작성 시 주의사항
1. 반드시 클래스명과 이름이 동일해야 함 (대소문자 구분)
2. 반환형이 존재하지 않음 (메소드와 유사하게 생겨서 헷갈릴 수 있으므로) // 반환형 없다고 냅다 void 쓰면 안 됨!
3. 여러 개 작성이 가능하지만 매개변수가 중복되면 안 됨(이름은 중복 가능하나, 매개변수를 다르게 적어 줌) => 오버로딩
4. 매개변수가 없는 기본 생성자는 작성하지 않는다면 JVM에 의해 자동으로 만들어짐
단, 다른 생성자들과 같이 작성할 경우에는 매개변수가 없는 기본 생성자를 꼭 명시해 줘야 함!
1. 기본 생성자 형태
User 클래스
package com.kh.chap05.constructor.model.vo;
import com.kh.chap03.class_.model.vo.Product;
public class User {
// 필드부
private String userId;
private String userPwd;
private String userName;
private int age;
private char gender;
// 가장 기본적인 형태의 생성자: 기본 생성자
// => 매개변수가 없는 형태
// => 작성하지 않는다면 JVM에 의해 자동으로 생성됨
public User() { // user01에 적용, 필수는 아니지만 당분간은 무조건 만들어 놓을 것!
// 기본 생성자 == 매개변수가 없는 생성자
// 단지 객체를 생성(공간을 확보)만을 목적으로 할 때 사용
// => 그래서 보통의 경우는 아무 코드도 작성하지는 않음
// 기본 생성자를 생략하는 경우 => 오류도 나지 않고, 객체를 생성하는 데 문제도 없엇음
// 그동안 알게 모르게 JVM이 자동으로 만들어 줬기 때문에 가능
// 단 JVM이 매번 기본 생성자를 만들어 주는 것은 아니고
// 매개변수가 있는 다른 생성자를 내가 직접적으로 작성했을 때에는 JVM에 기본 생성자를 만들어 주지 않음
// => 즉, 어찌되었든 간에 기본 생성자는 항상 작성하는 습관을 들이자!
System.out.println("잘 출력이 되나...?");
}
}ConstructorRun 클래스
package com.kh.chap05.constructor.run;
import com.kh.chap05.constructor.model.vo.User;
public class ConstructorRun {
public static void main(String[] args) {
// User 클래스의 기본 생성자를 이용해서 객체 생성
User u1 = new User();
u1.setUserId("user01");
u1.setUserPwd("pass01");
u1.setUserName("김말똥");
u1.setAge(20);
u1.setGender('남');
System.out.println(u1.information()); // 기본값만 출력
}
}출력물
userId: user01, userPwd: pass01, userName: 김말똥, age: 20, gender: 남
2. 매개변수가 있는 생성자 형태
User 클래스
// 매개변수가 있는 생성자: 필드값을 "내가 원하는 값으로" 초기화하고자 할 때 주로 쓰임
public User(String userId) { // 객체 생성과 동시에 userId 필드에만 값을 내가 원하는 형태로 초기화할 목적
this.userId = userId; // user02에 적용
}ConstructorRun 클래스
User u2 = new User("user02");
System.out.println(u2.information()); // userId만 내가 원하는 값으로 초기화
// User 클래스의 String userId, String userPwd, String userName을
// 초기화해줄 수 있는 매개변수 생성자를 이용해서 객체 생성출력물
userId: user02, userPwd: null, userName: null, age: 0, gender:
3. 매개변수 생성자로 객체 생성과 동시에 몇 개의 필드 초기화
User 클래스
// 객체 생성과 동시에 userId, userPwd, userName 필드만 초기화해 주는 생성자
public User(String userId, String userPwd, String userName) {
// 관례상 매개변수 생성자의 매개변수명도 필드명과 일치되게끔 작성함
this.userId = userId;
this.userPwd = userPwd;
this.userName = userName; // user03에 적용
}ConstructorRun 클래스
// User 클래스의 String userId, String userPwd, String userName을
// 초기화해줄 수 있는 매개변수 생성자를 이용해서 객체 생성
User u3 = new User("user03", "pass03", "홍길동");
System.out.println(u3.information());출력물
userId: user03, userPwd: pass03, userName: 홍길동, age: 0, gender:
4. 매개변수 생성자로 객체 생성과 동시에 모든 필드를 초기화
User 클래스
// 객체 생성과 동시에 모든 필드에 대해서 내가 원하는 값으로 한 번에 초기화까지 해 줄 수 있는 생성자, 필수는 아니지만 있으면 편하므로 당분간 만들어 버릇 해 놓을 것!
public User(String userId, String userPwd, String userName, int age, char gender) {
/*
this.userId = userId;
this.userPwd = userPwd;
this.userName = userName;
*/
// 위와 같이 중복되는 동일한 초기화하는 구문이 있을 경우
// 해당 코드를 대체할 수 있는 생성자를 호출 가능함
// => this(== 나의 주소값) 생성자 호출하면 됨
// 주의사항: this 생성자 호출 시에는 반드시 생성자 내부 첫 줄에 기술해야 함
this(userId, userPwd, userName);
this.age = age;
this.gender = gender; // user04에 적용
// this(userId, userPwd, userName);
// Constructor call must be the first statement in a constructor: this 생성자는 첫 줄에 기술해야 함
}
// 메소드부
public void setUserId(String userId) {
this.userId = userId;
}
public void setUserPwd(String userPwd) {
this.userPwd = userPwd;
}
public void setUserName(String userName) {
this.userName = userName;
}
public void setAge(int age) {
this.age = age;
}
public void setGender(char gender) {
this.gender = gender;
}
public String getUserId() {
return userId;
}
public String getUserPwd() {
return userPwd;
}
public String getUserName() {
return userName;
}
public int getAge() {
return age;
}
public char getGender() {
return gender;
}
public String information() {
return "userId: " + userId + ", userPwd: " + userPwd + ", userName: " + userName +
", age: " + age + ", gender: " + gender;
}
}ConstructorRun 클래스
// User 클래스의 모든 필드에 대해서 객체 생성과 동시에 내가 원하는 값으로
// 초기화할 수있는 매개변수 생성자를 이용해서 객체 생성
User u4 = new User("user04", "pass04", "박개순", 21, '여');
// 만약에 이 시점에서 비밀번호를 바꾸고 싶음
// -> setter 메소드를 써야만 함!
u4.setUserPwd("password04!");
// 매개변수 생성자가 있다 하더라도 setter 메소드는 반드시 필요함!
System.out.println(u4.information());
}
}출력물
userId: user04, userPwd: password04!, userName: 박개순, age: 21, gender: 여
*이미 만들어 놓은 this 생성자를 이렇게 다시 쓸 수도 있음!
메소드
*메소드: 하나의 기능 단위
입력을 가지고 어떤 일을 수행한 다음 결과물을 내어놓는 것
메인 메소드와 일반 메소드로 나뉨
그동안 썼던 가장 기본적인 메소드의 표현법
public void 메소드명() {
실행할 코드;
}
[ 표현법 ]
접근제한자 예약어(생략가능) 반환할값의자료형 메소드명(매개변수 => 생략 가능) {
수행할 코드;
return 반환할값; (생략 가능: 반환할 자료형이 void일 경우에만)
}
=> 메소드를 정의한 후 항상 얼마든지 호출해서 쓸 수 있음
1. 매개변수가없고 반환값도 없는 메소드(입력(매개변수, 받아올 값) X, 출력(반환값) X)
public void method1() {
System.out.println("매개변수와 반환값이 둘 다 없는 메소드입니다.");
// 1부터 10까지 합계를 구해서 출력하는 기능
int sum = 0;
for(int i = 1; i <= 10; i++) {
sum += i;
}
System.out.println("총 합계: " + sum);
// return; // 반환형이 void라서 빈손으로 돌아간다는 의미! 뒤에 sum 적으면 오류 뜸
// void 메소드일 경우에는 알게 모르게 return; 구문이 생략되어 있음
// JVM이 자동으로 생성해 주는 구문
}
}package com.kh.chap06.method.run;
import com.kh.chap06.method.controller.MethodTest1;
public class MethodRun {
public static void main(String[] args) {
// 1. MethodTest1 클래스 테스트
MethodTest1 m1 = new MethodTest1();
m1.method1();
}
}
2. 매개변수가 없고 반환값은 있는 메소드
public int method2() { // ++ 얘만 썼을 때는 오류가 나는데 이건 이클립스가 return int값; 까먹지 말라고 힌트 주는 거라고 생각하면 됨!
System.out.println("매개변수는 없고 반환값은 있는 메소드입니다.");
// 1에서부터 100까지의 랜덤값을 발생시켜서 돌려주는 기능 추가
// int random = (int)(Math.random() * 100) + 1;
// return random;
return (int)(Math.random() * 100) + 1; // return int값;을 입력하면 method2()에 생겼던 빨간 밑줄은 자동으로 사라짐!
}// m1.method2(); // 매개변수는 없고 반환값은 있는 메소드입니다.
// 라는 출력문만 나옴! int형으로 받을 수 있는 공간이 없기 때문
// int random = m1.method2();
//이렇게 자료형을 맞춰서 random값을 불러올 공간을 마련해 줘야 함
//System.out.println("랜덤값: " + random);
// 랜덤값 출력 가능해짐
// 혹은 이렇게 한 큐로도 출력 가능! --------- 그럼 이건 int형 공간 안 만들어 줘도 되는 거...?
System.out.println("랜덤값: " + m1.method2());
3. 매개변수가 있고 반환값은 없는 메소드
public void method3(int num1, int num2) {
System.out.println("매개변수가 있고 반환값이 없는 메소드입니다.");
// num1과 num2의 값을 비교하여 결과를 출력해 주는 기능 추가
// 최소값: xx
// 최대값: xx
int min = 0; // 두 수 중 작은 값을 보관할 용도
int max = 0; // 두 수 중 큰 값을 보관할 용도
if(num1 > num2) {
max = num1;
min = num2;
}
else if(num1 < num2) {
max = num2;
min = num1;
}
else {
System.out.println("두 정수가 같습니다.");
return;
}
System.out.println("최대값: " + max);
System.out.println("최소값: " + min);
// return; // 이 생략되어 있는 구조
}m1.method3(20, 10);
// 매개변수가 여러 개인 경우에는
// 호출 시의 전달값의 순서, 개수, 자료형이 정확히 일치해야 함
4. 매개변수도 있고 반환값도 있는 메소드
public int method4(int a, int b) {
System.out.println("매개변수도 있고 반환값도 있는 메소드입니다.");
// 두 매개변수를 곱한 결과값을 리턴
return a * b;
}m1.method3(20, 10);
// 매개변수가 여러 개인 경우에는
// 호출 시의 전달값의 순서, 개수, 자료형이 정확히 일치해야 함
System.out.println("-------------------------");
// int result = m1.method4(42, 2);
// System.out.println("두 수의 곱: " + result); // 처럼 출력해 주거나
System.out.println(m1.method4(42, 2)); // 처럼 출력해 주거나
// 반환값이 있는 경우: 호출 부분에서 반환값을 받아 줄 변수를 미리 선언하고 대입하는 구문을 쓰거나
// 출력문 내부에서 호출하는 식으로 활용
// 반환값이 없는 경우: 연산 결과를 사용자에게 보여 주고자 한다면 메소드 내부에서 출력문 활용
static 메소드
package com.kh.chap06.method.controller;
public class MethodTest2 {
// static 메소드
// => 호출할 때 객체를 생성할 필요가 없음
public static void method1() {
System.out.println("매개변수와 반환값이 없는 static 메소드");
}
public static String method2() {
return "매개변수는 없지만 반환값은 있는 static 메소드";
}
// 매개 변수는 있지만 반환값이 없는 static 메소드
public static void method3(String name, int age) {
// xx살의 xxx 님 환영합니다.
System.out.println(age + "살의 " + name + " 님 환영합니다.");
}
public static int method4(int num1, int num2, char op) {
/* 도전 과제!!! switch 문과 if 문을 이용해서
* return; 으로 진행될 수 있도록 풀어 보시오
switch(op) {
case '+': +;
break;
}
*/
// op: 연산자
// => 연산자 종류(+, -, *, /, %)에 따른 연산 결과를 return
// return; //This method must return a result of type int: 지정한 return 자료형 값 넣어 줘야 함! 로직 안 짰다고 안 넣으면 오류 남!
// 반환 자료형과 리턴되는 값의 자료형을 항상 맞춰 줘야 함
return num1 + num2;
}
}// 2. MethodTest2 클래스 테스트
// static 메소드이므로 대변할 이름 필요 없이 바로 호출 가능
MethodTest2.method1();
System.out.println("-------------------------");
// MethodTest2.method2(); // 값만 담기고 String에 해당하는 출력문이 없으므로 출력되지 않음
System.out.println(MethodTest2.method2());
System.out.println("-------------------------");
MethodTest2.method3("홍길동", 20); // 이미 출력문이 존재하는 상태이므로 자료형 맞춰서 값만 잘 입력해 주면 됨
System.out.println("-------------------------");
System.out.println(MethodTest2.method4(5, 11, '+'));
}
}
오버로딩(Overloading)
메소드 오버로딩 (Overloading)
- 한 클래스 내에 같은 메소드명으로 정의할 수 있는 방법
- 매개변수의 자료형의 개수, 순서가 다르게 작성되어 있어야 함
- 단, 매개변수의 이름, 접근제한자, 반환형은 메소드 오버로딩에 영향을 주지 않음
package com.kh.chap06.method.controller;
public class OverloadingTest {
public void test() { // 매개변수 0개
// 메소드 오버로딩이 아주 잘되어 있는 예시
System.out.println(); // 매개변수 없는 상태
System.out.println(1); // 매개변수 int 타입 1개
System.out.println(true); // 매개변수 boolean 타입의 값 하나
System.out.println("안녕하세요"); // 매개변수 String 타입의 값 하나
System.out.printf("%d", 1); // 매개변수의 개수가 2개
System.out.printf("%d %d", 1, 2); // 매개변수의 개수가 3개(String, int, int)
System.out.printf("%d %c", 1, 'a'); // 매개변수의 개수가 3개(String, int, char)
}
// Duplicate method test() in type OverloadingTest
/*
public void test() {
}
*/
public void test(int a) { // 매개변수 int 타입 1개
}
// Duplicate method test(int) in type OverloadingTest 에러 발생
// 매개변수 이름이 다르더라도 int형 1개는 이미 있으므로 오버로딩 안됨!
/*
public void test(int b) {
}
*/
public void test(int a, String s) { // 매개변수 int형 1개, 문자열 1개! 자료형의 개수 달라서 오버로딩 잘됨!
}
public void test(String s, int a) { // 매개변수 문자열 1개, int형 1개! 위와 순서 달라서 오버로딩 잘됨!
}
public void test(int a, int b) { // 매개변수 int형 2개! 자료형의 종류 일치하는 게 없으므로 오버로딩 잘됨!
}
// Duplicate method test(int) in type OverloadingTest 에러 발생
// - 매개변수명과는 상관없이 자료형의 개수와 순서가 같기 때문에 동일한 메소드로 판별됨 (중복 오류)
// - 즉, 매개변수의 자료형의 개수와 순서를 다르게 작성해야 함!
/*
* public void test(int c, int d) { // 매개변수 int형 2개! 이름이 달라도 int형 2개는 이미 존재하기 때문에 오버로딩 안 됨!
*
* }
*/
public void test(int a, int b, String s) {
}
// 에러가 발생
// - 반환형이 다르다고 오버로딩이 적용되지는 않음
// - 메소드를 호출하는 시점에서 매개변수가 동일하기 때문에 에러 발생
// - 즉, 반환형과 상관없이 매개변수의 자료형의 개수와 순서가 다르가 작성되어야 함
/*
* public int test(int a, int b, String s) {
*
* return a + b;
* }
*/
// 에러가 발생
// - 접근제한자가 다르다고 해서 오버로딩이 적용되지 않음
// - 즉, 접근제한자와 상관없이 매개변수의 자료형 개수와 순서가 다르게 작성되어야만 오버로딩이 가능함
/*
private void test(int a, int b, String s) {
}
*/
}
오버로딩 테스트 문제!
package com.kh.chap01.oneVsmany.model.vo;
public class Book {
// 필드부
// 도서명, 저자명, 가격, 출판사
private String title;
private String author;
private int price;
private String publisher;
// 생성자부
// 매개변수가 없는 기본 생성자
public Book() {
}
// 모든 필드에 대해서 동시에 초기화해 줄 수 있는 매개변수 생성자
public Book(String title, String author, int price, String publisher) {
this.title = title;
this.author = author;
this.price = price;
this.publisher = publisher;
}
// 메소드부
public String getTitle() {
return title;
}
public String getAuthor() {
return author;
}
public int getPrice() {
return price;
}
public String getPublisher() {
return publisher;
}
public void setTitle(String title) {
this.title = title;
}
public void setAuthor(String author) {
this.author = author;
}
public void setPrice(int price) {
this.price = price;
}
public void setPublisher(String publisher) {
this.publisher = publisher;
}
// 모든 필드의 값을 하나의 문자열로 연이어서 리턴해 주는 information
public String information() {
return "title: " + title + ", author: " + author + ", price: " + price + ", publisher: " + publisher;
}
}package com.kh.chap01.oneVsmany.run;
import java.util.Scanner;
import com.kh.chap01.oneVsmany.model.vo.Book;
public class ObjectRun {
public static void main(String[] args) {
/*
// 1. 기본 생성자로 객체 생성 후 setter 메소드를 통해 각 필드 값 대입
Book bk1 = new Book(); // JVM에 의해서 기본값이 세팅
bk1.setTitle("자바의 정석");
bk1.setAuthor("김자바");
bk1.setPrice(20000);
bk1.setPublisher("KH출판사");
// 2. 매개변수 생성자를 이용해서 객체 생성과 동시에 각 필드에 값 대입
Book bk2 = new Book("수학익힘책", "홍길동", 15000, "수학출판사");
System.out.println(bk1.information());
System.out.println(bk2.information());
*/
/*
// 3. 사용자가 입력한 값들로 객채 생성
Scanner sc = new Scanner(System.in);
// 제목, 저자명, 가격 정보, 출판사명을 입력받아 각각 변수에 담기
System.out.print("제목: ");
String title = sc.nextLine();
System.out.print("저자: ");
String author = sc.nextLine();
System.out.print("가격: ");
int price = sc.nextInt();
sc.nextLine();
System.out.print("출판사: ");
String publisher = sc.nextLine();
// Book 객체 만들기
Book bk3 = new Book(title, author, price, publisher);
System.out.println(bk3.information());
*/
// 세 개의 Book 개체가 필요하다라는 가정 하에
// 각 Book 개체를 따로따로 관리
// 단, 사용자에게 입력받은 정보를 기준으로 객체를 만들 것
Book bk1 = null;
Book bk2 = null;
Book bk3 = null; // 주소값 들어갈 공간을 세팅해 놓는 과정
Scanner sc = new Scanner(System.in);
System.out.println("제목: ");
String title = sc.nextLine();
System.out.println("저자명: ");
String author = sc.nextLine();
System.out.println("가격: ");
int price = sc.nextInt();
sc.nextLine();
System.out.println("출판사: ");
String publisher = sc.nextLine();
현재까지의 상태!
stack에 null값만 있고 heap영역에는 아무것도 없는 상태임
bk1 = new Book(title, author, price, publisher);
Book bk1 = null;
Book bk2 = null;
Book bk3 = null; // 주소값 들어갈 공간을 세팅해 놓는 과정
for(int i = 0; i < 3; i++) { // i: 0, 1, 2
Scanner sc = new Scanner(System.in);
System.out.println("제목: ");
String title = sc.nextLine();
System.out.println("저자명: ");
String author = sc.nextLine();
System.out.println("가격: ");
int price = sc.nextInt();
sc.nextLine();
System.out.println("출판사: ");
String publisher = sc.nextLine();
bk1 = new Book(title, author, price, publisher);
}
for문에 넣게 되면 bk1에 값이 3번 들어감!
즉, 2번째 값을 돌릴 때는 1번째 값과의 연결고리가 끊기고
3번째 값을 돌릴 때는 2번째 값과의 연결고리가 끊기게 됨
이 연결고리를 끊기지 않게 하려면?
if문 추가함으로써 필드의 이름을 바꿔 줌
=> for문이 돌 때마다 서로 다른 필드에 값이 담기게 함!
Book bk1 = null;
Book bk2 = null;
Book bk3 = null; // 주소값 들어갈 공간을 세팅해 놓는 과정
for(int i = 0; i < 3; i++) { // i: 0, 1, 2
Scanner sc = new Scanner(System.in);
System.out.println("제목: ");
String title = sc.nextLine();
System.out.println("저자명: ");
String author = sc.nextLine();
System.out.println("가격: ");
int price = sc.nextInt();
sc.nextLine();
System.out.println("출판사: ");
String publisher = sc.nextLine();
if(i == 0) {
bk1 = new Book(title, author, price, publisher);
}
else if (i == 1) {
bk2 = new Book(title, author, price, publisher);
}
else {
bk3 = new Book(title, author, price, publisher);
}
} // 사용자에게 검색할 도서 제목을 입력받아
// 각 전체 도서들의 제목과 일일이 비교하여 일치하는 도서의 가격을 알려 주는 기능
// => 가격 조회 기능
Scanner sc = new Scanner(System.in);
System.out.print("검색할 책 제목: ");
String searchTitle = sc.nextLine();
if(bk1.getTitle().equals(searchTitle)) {
System.out.println(bk1.getPrice());
}
if(bk2.getTitle().equals(searchTitle)) {
System.out.println(bk2.getPrice());
}
if(bk3.getTitle().equals(searchTitle)) {
System.out.println(bk3.getPrice());
}
*객체 배열
package com.kh.chap01.oneVsmany.run;
import java.util.Scanner;
import com.kh.chap01.oneVsmany.model.vo.Book;
public class ObjectArrayRun {
public static void main(String[] args) {
// 배열: 한 번에 같은 자료형의 여러 개의 값들을 동시에 보관
// 배열의 선언과 동시에 할당
// 자료형[] 배열명 = new 자료형[사이즈];
Book[] arr = new Book[3]; // arr[0], arr[1], arr[2]
// null, null, null
Scanner sc = new Scanner(System.in);
// 3개의 전체 도서 정보를 입력받은 후 각 인덱스에 해당 객체를 생성
for(int i = 0; i < arr.length; i++) {
System.out.print("제목: ");
String title = sc.nextLine();
System.out.print("저자명: ");
String author = sc.nextLine();
System.out.println("가격: ");
int price = sc.nextInt();
sc.nextLine();
System.out.println("출판사: ");
String publisher = sc.nextLine();
arr[i] = new Book(title, author, price, publisher); // 객체가 heap 영역에 생성됨
// 전체 도서 정보 출력하기
for(int i = 0; i < arr.length; i++) {
// System.out.println(arr[i]); // Book 타입의 주소값을 출력
System.out.println(arr[i].information());
}
// 검색 기능
// 사용자에게 검색할 도서 제목을 입력받아
// 각 전체 도서들의 제목과 일일이 비교하여 일치하는 도서의 가격을 알려 주기
System.out.print("검색할 책 제목: ");
String searchTitle = sc.nextLine();
for(int i = 0; i < arr.length; i++) {
if(arr[i].getTitle().equals(searchTitle)) {
System.out.println(arr[i].getPrice());
}
}
다시 연습해 봅시다
package com.kh.chap02.objectArray.model.vo;
public class Phone {
// 필드부
// 이름, 시리즈, 브랜드명, 가격
private String name;
private String series;
private String brand;
private int price;
// 생성자부
public Phone() {
}
public Phone(String name, String series, String brand, int price) {
this.name = name;
this.series = series;
this.brand = brand;
this.price = price;
}
// 메소드부
public String getName() {
return name;
}
public String getSeries() {
return series;
}
public String getBrand() {
return brand;
}
public int getPrice() {
return price;
}
public void setName(String name) {
this.name = name;
}
public void setSeries(String series) {
this.series = series;
}
public void setBrand(String brand) {
this.brand = brand;
}
public void setPrice(int price) {
this.price = price;
}
public String information() {
return "name: " + name + ", series: " + series + ", brand: " + brand + ", price: "+ price;
}
}package com.kh.chap02.objectArray.run;
import com.kh.chap02.objectArray.model.vo.Phone;
public class ObjectArrayRun {
public static void main(String[] args) {
// "Phone 타입의 주소값만" 담을 수 있는 배열 생성
Phone[] arr = new Phone[3]; // JVM에 의해 모든 방이 null 값으로 초기화된 상태
System.out.println(arr); // 주소값
System.out.println(arr.length); // 배열의 사이즈: 3
System.out.println(arr[0]); // null
arr[0] = new Phone();
arr[0].setName("아이폰");
System.out.println(arr[0].getName());
arr[0] = new Phone();다시 arr[0]을 선언하면
arr[1] = new Phone("갤럭시", "10", "삼성", 1000000);
arr[2] = new Phone("아이폰", "11pro", "애플", 800000);
arr[0].setName("아이폰");
arr[0].setSeries("8");
arr[0].setBrand("애플");
arr[0].setPrice(500000); // 직접 접근 하여 값을 넣는 과정
System.out.println("---------------------------");
int sum = 0;
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i].information());
sum += arr[i].getPrice();
}
System.out.println("총 가격: " + sum + "원");
System.out.println("평균가: " + sum / arr.length + "원");전체 출력값
[Lcom.kh.chap02.objectArray.model.vo.Phone;@6d06d69c
3
null
아이폰
---------------------------
name: 아이폰, series: 8, brand: 애플, price: 500000
name: 갤럭시, series: 10, brand: 삼성, price: 1000000
name: 아이폰, series: 11pro, brand: 애플, price: 800000
총 가격: 2300000원
평균가: 766666원