9시 24분
객체지향 입문 본문
패스트캠퍼스 '한번에 끝내는 Java/Spring 웹 개발 마스터 초격차 패키지 Online'의 Part2 - Ch 02. 객체지향 입문을 수강하며 내용을 정리한 글입니다.
객체와 객체지향 프로그래밍
객체 (Object) : 구체적, 추상적 데이터의 단위 ( ex. 학생, 회원, 주문 등등 ... )
객체 지향 프로그래밍 vs 절차 지향 프로그래밍
아침에 일어나 학교를 가는 과정을 예로 들어보자.
- 절차 지향 프로그래밍: 일어난다 > 씻는다 > 밥을 먹는다 > 버스를 탄다 > 요금을 지불한다 > 학교에 도착
- 객체 지향 프로그래밍: 객체와 객체들 간의 관계를 사용하여 프로그래밍
객체 지향 프로그램의 구현
- 객체를 정의
- 각 객체가 제공하는 기능을 구현
- 각 객체가 제공하는 기능들 간의 소통을 통하여 객체 간의 협력을 구현
생활 속에서 객체를 찾아 클래스로 구현해보기
객체의 속성은 클래스의 멤버 변수(member variable)로 선언한다.
public class UserInfo {
String userId;
String userPassWord;
String userName;
String userAddress;
int phoneNumber;
}
** 클래스는 대문자로 시작하는 것이 좋다
** java 파일 하나에 클래스는 여러 개가 있을 수 있지만, public 클래스는 하나이고 public 클래스와 .java 파일의 이름은 동일해야 한다.
** camel notation 방식으로 명명 ( likeThis )
함수와 메서드
함수란, ( function )
- 하나의 기능을 수행하는 일련의 코드
- 구현된 함수를 호출하여 사용하고 호출된 함수는 기능이 끝나면 제어가 반환됨
- 함수로 구현된 하나의 기능은 여러 곳에서 동일한 방식으로 호출되어 사용될 수 있음
함수 정의 : 이름, 매개변수, 반환 값, 함수 몸체(body)로 구성됨
package basicStudy;
public class HelloJava {
public static int add(int a, int b) {
return a + b;
}
public static void sayHello(String name) {
System.out.println("Hello, "+ name);
}
public static void main(String[] args) {
int sum = add(1, 3);
System.out.println(sum);
sayHello("yeon");
};
}
함수 호출과 스택 메모리
스택 : 함수가 호출될 때 지역 변수들이 사용하는 메모리, 함수의 수행이 끝나면 자동으로 반환됨
메서드(method)
- 객체의 기능을 구현하기 위해 클래스 내부에 구현되는 함수 ( cf. '함수'는 어딘가에 속하지 않는 반면 메서드는 클래스에 속함 )
- 멤버 함수라고도 함
- 메서드를 구현함으로써 객체의 기능을 구현
멤버 변수와 메서드로 구현하는 객체의 속성 & 기능
객체의 속성은 멤버 변수로, 기능은 메서드로 구현한다.
basicStudy 패키지에 클래스를 하나 만들고, Student 객체를 만들어보자.
package basicStudy;
public class Student {
public int studentID;
public String studentName;
public String address;
public void showStudentInfo() {
System.out.println("학번: "+studentID);
System.out.println("이름: "+studentName);
System.out.println("주소: "+address);
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String name) {
studentName = name;
}
}
이렇게 만든 객체는 아래와 같이 main 함수에서 사용한다.
package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Student student = new Student();
student.setStudentName("Lee");
student.studentID = 1234;
student.address = "서울 강남구";
student.showStudentInfo();
}
}
생성된 객체를 인스턴스라고 하며, 인스턴스인 student를 참조 변수라고 하기도 한다.
인스턴스 생성과 힙 메모리
인스턴스 (instance)
- 실제 클랙스 기반으로 생성된 객체
- 각각 다른 멤버 변수를 가지게 됨 ( 객체 A와 객체 B에 담긴 정보는 다름 )
- new 키워드를 사용하여 생성 ( 동적 메모리 )
힙 메모리
- 생성된 인스턴스는 동적 메모리 ( heap memory )에 할당됨
- 자바에서는 Garbage Collector가 주기적으로 사용하지 않는 메모리를 수거 ( C나 C++는 직접 사용한 동적 메모리를 해제하여야 함. - free(), delete 사용 )
- 하나의 클래스로부터 여러 개의 인스턴스가 생성되고, 각각 다른 메모리 주소를 가지게 된다.
System.out.println(student);
student 인스턴스 자체를 출력하면 아래와 같은 문자열이 출력된다. 이것은 student 객체가 담긴 주소를 가리킨다. ( 물리적인 주소 X, JDM이 준 가상 주소 )
** 참조 변수: 메모리에 생성된 인스턴스를 가리키는 변수
** 참조 값: 생성된 인스턴스의 메모리 주소 값
생성자와 생성자 오버로딩
생성자
- 객체를 생성할 때 new 키워드와 함께 사용 - new Student();
- 객체가 생성될 때 변수나 상수를 초기화하거나 다른 초기화 기능을 수행하는 메서드를 호출
- 반환 값이 없고, 클래스의 이름과 동일
- 대부분 외부에서 접근 가능하나, 필요에 의해 private으로 선언되는 경우도 있음
기본 생성자( default constructor )
- 클래스에는 반드시 적어도 하나 이상의 생성자가 존재
- 생성자를 구혀낳지 않아도 new 키워드와 함께 생성자를 호출할 수 있음
- 생성자가 없는 경우 컴파일러가 생성자 코드를 넣어줌 - 매개 변수와 구현부 X
앞서 작성해봤던 Student 객체는 생성자가 없어 기본 생성자를 이용하고 '.'을 이용하여 멤버 변수에 값을 대입해보자.
이번에는 생성자를 이용하여 Student 객체를 만들어보자.
// Student.java
package basicStudy;
public class Student {
public int studentID;
public String studentName;
public double gpa;
public Student(int studentID, String studentName, double gpa) {
this.studentID = studentID;
this.studentName = studentName;
this.gpa = gpa;
}
public String StudentInfo() {
return studentID + " / " + studentName + " / " + gpa;
}
}생성자 구현부에서 앞에 'this'가 붙은 것들은 클래스의 멤버변수이고, 붙지 않은 것은 생성자의 매개변수이다. 변수 이름이 동일할 때 'this'를 사용해서 구분한다.
// HelloJava.java
package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Student student = new Student(123456, "yeon", 4.5);
System.out.println(student.StudentInfo());
}
}
생성자 오버로딩
- 생성자를 여러 개를 정의할 수 있다.
- 클라이언트는 여러 생성자 중 필요한 생성자를 호출하여 사용할 수 있다.
public class UserInfo {
public String userId;
public String userPassWord;
public String userName;
public String userAddress;
public String phoneNumber;
public UserInfo(){}
public UserInfo(String userId, String userPassWord, String userName) {
this.userId = userId;
this.userPassWord = userPassWord;
this.userName = userName;
}
public String showUserInfo() {
return "고객님의 아이디는 " + userId + "이고, 등록된 이름은 " + userName + "입니다.";
}
}구현부가 없는 기본 생성자와 id, 이름, 비밀번호가 담긴 두 가지 생성자를 만들었다.
복습 - 객체 구현하기
이제까지 배운 내용을 복습해보자.
1.
// Person.java
package basicStudy;
public class Person {
public int height;
public int weight;
public String sex;
public String name;
public int age;
public Person(int height, int weight, String sex, String name, int age) {
this.height = height;
this.weight = weight;
this.sex = sex;
this.name = name;
this.age = age;
}
public void printInfo() {
System.out.println("키가 "+height+"이고 몸무게가 "+weight+"킬로인 "+sex+"이 있습니다.");
System.out.println("이름은 "+name+"이고 나이는 "+age+"세입니다.");
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Person tomas = new Person(180, 78, "남성", "Tomas", 37);
tomas.printInfo();
}
}
2.
// Order.java
package basicStudy;
public class Order {
public long orderNumber;
public String phoneNumber;
public String address;
public int date;
public int time;
public int price;
public String menuNumber;
public Order(long orderNumber, String phoneNumber, String address, int date, int time, int price, String menuNumber) {
this.orderNumber = orderNumber;
this.phoneNumber = phoneNumber;
this.address = address;
this.date = date;
this.time = time;
this.price = price;
this.menuNumber = menuNumber;
}
public void printOrderInfo(){
System.out.println("주문 접수 번호: " + orderNumber);
System.out.println("주문 핸드폰 번호: " + phoneNumber);
System.out.println("주문 집 주소: " + address);
System.out.println("주문 날짜: " + date);
System.out.println("주문 시간: " + time);
System.out.println("주문 가격: " + price);
System.out.println("주문 메뉴 번호: " + menuNumber);
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Order order = new Order(202011020003L, "01012345678", "서울시 강남구", 20201102, 130258, 35000, "0003");
order.printOrderInfo();
}
}
참조 자료형 변수
참조 자료형 변수: 클래스형으로 변수를 선언하며, 참조 자료형을 사용할 때는 해당 변수에 대해 클래스를 생성해야 함 ( String 클래스는 예외 )
참조 자료형을 정의하여 사용해보자. 학생과 과목에 대한 클래스를 분리하여 사용하자.
// Subject.java
package basicStudy;
public class Subject {
String subjectName;
int score;
}// Student.java
package basicStudy;
public class Student {
int studentID;
String studentName;
Subject korean;
Subject math;
Student(int studentID, String studentName){
this.studentID = studentID;
this.studentName = studentName;
korean = new Subject();
math = new Subject();
}
public void setKorean(String name, int score) {
korean.subjectName = name;
korean.score = score;
}
public void setMath(String name, int score) {
math.subjectName = name;
math.score = score;
}
public void showScoreInfo() {
int total = korean.score + math.score;
System.out.println(studentName+" 학생의 총점은 "+total+"점입니다.");
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Student student = new Student(123, "Kim");
student.setKorean("국어", 90);
student.setMath("수학", 98);
student.showScoreInfo();
}
}
접근 제어 지시자와 정보은닉
접근 제어 지시자 (access modifier)
- 클래스 외부에서 클래스의 멤버 변수, 메서드, 생성자를 사용할 수 있는지 여부를 지정하는 키워드
- private: 같은 클래스 내부에서만 접근 가능 ( 외부 클래스, 상속 관계 클래스에서도 접근 불가 )
- 아무것도 없음 (default): 같은 패키지 내부에서만 접근 가능
- protected: 같은 패키지나 상속 관계의 클래스는 접근 가능, 외부에서는 접근 불가
- public: 클래스의 외부 어디서나 접근할 수 있음
get() / set() 메서드
- private으로 선언된 멤버 변수에 대해 접근, 수정할 수 있는 메서드를 public으로 제공
- get() 메서드만 제공 - read only
정보 은닉: private으로 제어한 멤버 변수도 public 메서드가 제공되면 접근 가능하지만, 변수가 public으로 공개되었을 때보다 private일 때 각 변수에 대한 제한을 public 메서드에서 제어할 수 있다.
// Birthday.java
package basicStudy;
public class Birthday {
private int day;
private int month;
private int year;
private boolean isValid; // default: false
public int getDay() {
return day;
}
public int getMonth() {
return month;
}
public int getYear() {
return year;
}
public void setDay(int day) {
this.day = day;
}
public void setMonth(int month) {
if(month < 1 || month > 12){
isValid = false;
}
else{
isValid = true;
this.month = month;
}
}
public void setYear(int year) {
this.year = year;
}
public void showDate() {
if(isValid) {
System.out.println(year+"년 "+month+"월 "+day+"일");
}
else {
System.out.println("유효하지 않은 날짜입니다.");
}
}
}set, get 메서드는 인텔리제이에서 자동완성되는 기능을 제공한다. (이클립스에서도 마찬가지)
package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Birthday bday = new Birthday();
bday.setYear(2001);
bday.setMonth(13);
bday.setDay(24);
bday.showDate();
}
};
캡슐화 (encapsulation)
- 꼭 필요한 정보와 기능만 외부에 오픈
- 대부분의 멤버 변수와 메서드를 감추고 외부와 통합된 인터페이스만은 제공하여 일관된 기능을 구현하게 함
- 각각의 메서드나 멤버 변수를 접근함으로써 발생하는 오류를 최소화
// MakeReport.java
package basicStudy;
public class MakeReport {
StringBuffer buffer = new StringBuffer();
private String line = "===========================================\n";
private String title = " 이름\t 주소 \t\t 전화번호 \n";
private void makeHeader()
{
buffer.append(line);
buffer.append(title);
buffer.append(line);
}
private void generateBody()
{
buffer.append("James \t");
buffer.append("Seoul Korea \t");
buffer.append("010-2222-3333\n");
buffer.append("Tomas \t");
buffer.append("NewYork US \t");
buffer.append("010-7777-0987\n");
}
private void makeFooter()
{
buffer.append(line);
}
public String getReport()
{
makeHeader();
generateBody();
makeFooter();
return buffer.toString();
}
}- buffer - ( 메모리 오버를 예방 ) 늘어날 수 있는 버퍼를 가진 class에 스트링을 쭉 연결하고, 스트링 타입으로 리턴하는 방법
- getReport 메서드만 공개
package basicStudy;
public class HelloJava {
public static void main(String[] args) {
MakeReport report = new MakeReport();
System.out.println(report.getReport());
}
};
this
- 인스턴스 자신의 메모리를 가리킴
- 생성자에서 또 다른 생성자를 호출할 때 사용
- 자신의 주소(참조값)을 반환
1) 인스턴스 메모리의 주소를 가지는 this
public void setYear(int year)
{
this.year = year;
}
2) 생성자에서 다른 생성자를 호출하는 this
public class Person {
String name;
int age;
public Person() {
this("이름없음", 1);
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}** 생성자에서 다른 생성자를 호출하는 경우, 인스턴스의 생성이 완전하지 않은 상태이므로 this statement 이전에 다른 statement를 쓸 수 없음
3) 자신의 주소를 반환화는 this
// Person.java
package basicStudy;
public class Person {
String name;
int age;
public Person() {
this("no name", 1);
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void printInfo() {
System.out.println(name+", "+age);
}
public Person getPerson() {
return this;
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Person me = new Person();
me.printInfo();
System.out.println(me.getPerson());
}
};
객체 간의 협력
- 다른 객체와 유기적으로 연동
- 필요한 메세지를 전송하고 이를 처리하는 기능 구현이 필요
- 매개 변수로 객체가 전달되는 경우가 발생
ex)
이 상황을 객체지향 프로그래밍으로 구현해보자.
James와 Tomas는 각각 버스와 지하철을 타고 학교에 갑니다.
James는 5000원을 가지고 있었고, 100번 버스를 타면서 1000원을 지불합니다.
Tomas는 10000원을 가지고 있었고, 초록색 지하철을 타면서 1200원을 지불합니다.
두 학생이 버스와 지하철을 타는 상황을 구현해 봅시다.
// Student.java
package basicStudy;
public class Student {
String name;
int money;
public Student(String name, int money) {
this.name = name;
this.money = money;
}
public void takeBus(Bus bus) {
bus.take(1000);
this.money -= 1000;
}
public void takeSubway(Subway subway) {
subway.take(1200);
this.money -= 1200;
}
public void printInfo() {
System.out.println(name+"님의 남은 돈은 "+money+"원입니다.");
}
}// Bus.java
package basicStudy;
public class Bus {
int busNumber;
int passengerCount;
int money;
public Bus(int busNumber) {
this.busNumber = busNumber;
}
public void take(int money) {
this.money += money;
passengerCount++;
}
public void showBusInfo() {
System.out.println(busNumber+"번의 승객 수는 "+passengerCount+"명이고, 수입은 "+money+"원입니다.");
}
}// Subway.java
package basicStudy;
public class Subway {
int subwayNumber;
int passengerCount;
int money;
public Subway(int subwayNumber) {
this.subwayNumber = subwayNumber;
}
public void take(int money) {
this.money += money;
passengerCount++;
}
public void showSubwayInfo() {
System.out.println(subwayNumber+"번의 승객 수는 "+passengerCount+"명이고, 수입은 "+money+"원입니다.");
}
}
package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Student james = new Student("James", 5000);
Student tomas = new Student("Tomas", 10000);
Bus bus100 = new Bus(100);
Subway green = new Subway(2);
james.takeBus(bus100);
tomas.takeSubway(green);
james.printInfo();
tomas.printInfo();
bus100.showBusInfo();
green.showSubwayInfo();
}
};
복습 - 객체 간 협력
앞의 예제에서 Edward는 지각을 해서 택시를 타야 했습니다. 20000원을 가지고 있었는데 10000원을 택시비로 사용했습니다. 택시는 '잘나간다 운수' 회사 택시를 탔습니다.
// Taxi.java
package basicStudy;
public class Taxi {
String companyName;
int money;
Taxi(String companyName) {
this.companyName = companyName;
}
public void take(int money) {
this.money += money;
}
public void showTaxiInfo() {
System.out.println(companyName+"택시의 수입은 "+money+"원입니다.");
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Student edward = new Student("Edward", 20000);
Taxi taxi = new Taxi("잘 간다 운수");
edward.takeTaxi(taxi);
edward.printInfo();
taxi.showTaxiInfo();
}
};
static 변수
static 변수: 여러 인스턴스에서 공통으로 사용하는 변수 ( 여러 인스턴스가 공유하는 기준 값이 필요한 경우 )
- static 키워드를 사용
- 인스턴스가 생성될 때 만들어지는 변수가 아닌, 처음 프로그램이 메모리에 로딩될 때 메모리를 할당
- 클래스 변수, 정적 변수라고도 함
- 인스턴스 생성과 상관 없이 사용 가능하므로 클래스 이름으로 직접 참조 ( ex. student.number = 100; )
// Employee.java
package basicStudy;
public class Employee {
public static int serialNum = 1000;
private int employeeId;
private String employeeName;
private String department;
public int getEmployeeId() {
return employeeId;
}
public String getEmployeeName() {
return employeeName;
}
public String getDepartment() {
return department;
}
public void setEmployeeId(int employeeId) {
this.employeeId = employeeId;
}
public void setEmployeeName(String employeeName) {
this.employeeName = employeeName;
}
public void setDepartment(String department) {
this.department = department;
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Employee lee = new Employee();
lee.setEmployeeName("Lee");
System.out.println(lee.serialNum);
Employee kim = new Employee();
kim.setEmployeeName("Kim");
kim.serialNum++;
System.out.println(lee.serialNum);
System.out.println(kim.serialNum);
}
};
두 개의 인스턴스가 하나의 메모리를 공유한다는 것을 알 수 있다.
앞에 예제에서 회사원이 입사할 때마다 새로운 사번을 부여하도록 하고 싶다.
Employee 클래스에 생성자를 추가하고, main 함수를 수정해주자.
public Employee() {
serialNum++;
employeeId = serialNum;
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Employee lee = new Employee();
lee.setEmployeeName("Lee");
Employee kim = new Employee();
kim.setEmployeeName("Kim");
System.out.println(lee.getEmployeeName()+"님의 사번은 "+lee.getEmployeeId()+"입니다.");
System.out.println(kim.getEmployeeName()+"님의 사번은 "+kim.getEmployeeId()+"입니다.");
}
};
static 메서드
변수뿐만 아니라 메서드도 static하게 만들 수 있다.
이 때 주의할 것은, static 메서드는 인스턴스 변수(멤버 변수)를 사용할 수 없다.
- static 메서드는 인스턴스 생성과 무관하게 클래스 이름으로 호출될 수 있음
- 인스턴스 생성 전에 호출될 수 있으므로 static 메서드 내부에서는 인스턴스 변수를 사용할 수 없음
변수의 유효 범위와 메모리
- static 변수는 프로그램이 메모리에 있는 동안 계속 그 영역을 차지하므로 너무 큰 메모리를 할당하는 것은 좋지 않음
- 클래스 내부의 여러 메서드에서 사용하는 변수는 멤버 변수로 선언하는 것이 좋음
- 멤버 변수가 너무 많으면 인스턴스 생성 시 쓸데없는 메모리가 할당됨
static 응용 - 싱글톤 패턴
싱글톤 패턴( singleton pattern ) : 프로그램에서 인스턴스가 단 한 개만 생성되어야 하는 경우 사용하는 디자인 패턴으로, static 변수&메서드를 활용하여 구현할 수 있다.
ex) Calender 클래스
// Company.java
package basicStudy;
public class Company {
private static Company instance = new Company();
private Company() {}
public static Company getInstance() {
if(instance == null) {
instance = new Company();
}
return instance;
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Company company1 = Company.getInstance();
Company company2 = Company.getInstance();
System.out.println(company1);
System.out.println(company2);
}
};
- 생성자는 private으로 선언
- 클래스 내부에 유일한 인스턴스를 private으로 생성
- 외부에서 유일한 인스턴스에 접근할 수 있도록 public 메서드 제공
복습 - static & 싱글톤 패턴
자동차 공장이 있습니다. 자동차 공장은 유일한 객체이고, 이 공장에서 생산되는 자동차는 제작될 때마다 고유의 번호가 부여됩니다. 자동차 번호가 10001부터 시작되어 자동차가 생산될 때마다 10002, 10003 이렇게 번호가 붙도록 자동차 공장 클래스, 자동차 클래스를 구현하세요 다음 CarFactoryTest.java 테스트 코드가 수행 되도록 합니다.
< 테스트 코드 >
public class CarFactoryTest {
public static void main(String[] args) {
CarFactory factory = CarFactory.getInstance();
Car mySonata = factory.createCar();
Car yourSonata = factory.createCar();
System.out.println(mySonata.getCarNum()); //10001 출력
System.out.println(yourSonata.getCarNum()); //10002 출력
}
}
< 내 답안 코드 >
// CarFactory.java
package basicStudy;
public class CarFactory {
private static CarFactory instance = new CarFactory();
private CarFactory() { }
public static CarFactory getInstance() {
if(instance == null) {
instance = new CarFactory();
}
return instance;
}
public Car createCar() {
Car car = new Car();
return car;
}
}// Car.java
package basicStudy;
public class Car {
private static int initialNum = 10000;
private int carNum;
public Car() {
initialNum ++;
carNum = initialNum;
}
public int getCarNum() {
return carNum;
}
}- 아쉬운 점 : Car.java에서 set 메서드를 추가하지 않았음
< 개선 >
// Car.java
package basicStudy;
public class Car {
private static int initialNum = 10000;
private int carNum;
public Car() {
initialNum ++;
carNum = initialNum;
}
public int getCarNum() {
return carNum;
}
public void setCarNum(int carNum) {
this.carNum = carNum;
}
}
배열 (Array)
배열이란?
- 동일한 자료형의 순차적 자료 구조
- 인덱스 연산자 []를 이용하여 빠른 참조가 가능
- 순서가 0부터 시작
- 자바에서는 객체 배열을 구현한 ArrayList를 많이 활용함
배열 선언/초기화/사용
// 배열 선언
int[] arr1 = new int[10];
int arr2[] = new int[10];- C++과 달리 new 키워드 필요
// 배열 초기화
int[] numbers = new int[] {10, 20, 30}; //개수 생략해야 함
int[] numbers = {10, 20, 30}; // new int[] 생략 가능
int[] ids;
ids = new int[] {10, 20, 30}; // 선언후 배열을 생성하는 경우는 new int[] 생략할 수 없음// 배열 사용
int[] arr = new int[10];
int total = 0;
for(int i=0, num=1; i< arr.length; i++, num++) {
arr[i] = num;
}
for( int i =0; i<arr.length; i++) {
total += arr[i];
}
System.out.println(total);
** 배열의 길이와 요소가 동일하지 않다. ( length 속성은 배열의 개수이므로 요소의 개수와 다르다 ! )
향상된 for문 사용하기
- 배열의 n개 요소를 0부터 n-1까지 순차적으로 순회할 때 간단하게 사용할 수 있음
for(변수 : 배열) {
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
char[] alphabets = new char[26];
char ch = 'A';
for(int i=0; i<alphabets.length; i++) {
alphabets[i] = ch++;
}
for(char alpha : alphabets) {
System.out.println(alpha+", "+(int)alpha);
}
}
}
객체 배열
기본 자료형 배열은 선언과 동시에 배열의 크기만큼 메모리가 할당되지만,
객체 배열의 경우엔 요소가 되는 객체의 주소가 들어갈 메모리(null)만 할당되고 각 요소 객체는 생성하여 저장해야 함
// Book.java
package basicStudy;
public class Book {
private String title;
private String author;
public Book() {}
public Book(String title, String author) {
this.title = title;
this.author = author;
}
public void setTitle(String title) {
this.title = title;
}
public void setAuthor(String author) {
this.author = author;
}
public String getTitle() {
return title;
}
public String getAuthor() {
return author;
}
public void showInfo() {
System.out.println(title+", "+"author");
}
}package basicStudy;
public class HelloJava {
public static void main(String[] args) {
Book[] library = new Book[5];
library[0] = new Book("one", "me");
library[1] = new Book("two", "me");
library[2] = new Book("three", "me");
library[3] = new Book("four", "me");
library[4] = new Book("five", "me");
for(Book book : library) {
book.showInfo();
}
}
}
21 - 9분부터 다시 듣기 ㅜㅜ
'JAVA' 카테고리의 다른 글
| 자바 프로그래밍 기초 (0) | 2021.08.30 |
|---|
'JAVA' Related Articles
more
