메서드
: 자주 사용되는 기능은 미리 만들어 놓고 필요시 처리할 데이터만 전달해 주면 쉽게 원하는 결과를 얻게 해 주는 기능 제공
크게 선언부(header)와 구현부(body)로 나눌 수 있다.
리턴타입 메서드이름([매개변수1, 매개변수2,…])
{
지역변수
구현코드
리턴 문
}
- 선언부에서 매개변수나 리턴 타입은 생략 가능
- 구현부에서 리턴문 생략 가능
메서드 명명 규칙
- 첫 글자는 알파벳과 특수문자 ‘$’, ‘_’만 가능
- 대문자와 소문자 구분
- 카멜표기법 사용
- 가능한한 기능을 잘 나타내는 동사형으로 → calcScore()
예)
int increase(int x)
{
int result; //지역변수 : 메서드 구현 블록 내에서 선언한 변수, 구현 블록 내에서만 사용 가능
result = x + 1;
return result;
}
package sec01.ex01;
public class MethodEx1 {
public static void main(String[] args) {
MethodEx1 m = new MethodEx1();
m.print();
m.print();
m.print();
System.out.println("종료");
}
public void print() {
System.out.println("메서드를 호출합니다.");
}
}궁금한 점 : 변수와 달리 메서드는 왜 나중에 정의해도 앞에서 읽힐 수 있는가?
자바는 순차적으로 run 실행하긴 하지만 가장 먼저 전체를 한 번 훑는다.(컴파일)
컴파일 후에 실행을 하므로 메서드는 정의만 돼있다면 어디서든지 호출 가능
(변수는 값을 메모리에 저장해야하는데 먼저 변수가 쓰이고 나중에 선언이 되면 값이 없기 때문에 에러)
+
클래스 = 설계도 (자동차를 정의, 실제로 자동차가 있는 것은 아니다)
public class Car{
String color;
void drive() {
System.out.println(”달립니다.”);
}
}
인스턴스 = 클래스로부터 만들어낸 객체(object), 즉, 설계도로 찍어낸 실제 물건
Car myCar = new Car();
인스턴스를 생성하면 다음이 가능하다.
myCar.color = “빨강”; → 변수 값 저장 및 조작
- myCar.drive(); → 메서드 사용 : 자동차가 실제로 달리는 기능 수행
- Car yourCar = new Car() → 여러 개 생성 가능
예제) 직육면체 3개 입력받아 부피값 구하기
package sec01.ex01;
import java.util.*;
public class Test2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Test2 m = new Test2();
System.out.println("width, length, height를 입력해주세요. (공백 구분)");
System.out.println("------------------------------------------");
for(int i = 1; i<=3; i++) {
System.out.print("직육면체" + i + " : ");
int width = sc.nextInt();
int length = sc.nextInt();
int height = sc.nextInt();
System.out.println("직육면체" + i + "의 부피는 : "
+ m.calcVolume(width, length, height));
}
}
public int calcVolume (int width, int length, int height) {
return width * length * height;
}
}예제 ) 두 수의 정수를 입력받고 사이의 정수 합 구하기
package sec01.ex01;
import java.util.*;
public class Test3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Test3 m = new Test3();
System.out.println("두 정수를 입력하세요.");
System.out.print("시작 정수 : ");
int start = sc.nextInt();
System.out.print("끝 정수 : ");
int end = sc.nextInt();
m.sum(start, end);
}
public void sum(int start, int end) {
int sum =0;
for(int i = start + 1; i <end; i++) {
sum += i;
}
System.out.println("--------------결과 출력--------------");
System.out.println(start + "와 " + end + "사이의 정수들의 합 : " + sum);
}
}start와 end 수를 받아서 sum이라는 int를 리턴하는 메서드만 생각했는데,
void로 지정해서 sysout으로 출력하는 기능을 넣을 수도 있구나!
문제4) 배열의 평균(실수형)을 구하는 메서드
package sec01.ex01;
import java.util.*;
public class Test4 {
public static void main(String[] args) {
Test4 m = new Test4();
int[] score1 = {45,67,78,89,91};
int[] score2 = {62,65,76,77,88};
System.out.println("score1의 평균 : " + m.average(score1));
System.out.println("score2의 평균 : " + m.average(score2));
}
public double average(int[] arr) {
double average = 0;
int sum = 0;
for(int i =0; i<arr.length; i++) {
sum += arr[i];
}
average = sum/(double)arr.length;
return average;
}
}절차 지향 프로그래밍
- 일을 처리하는 순서와 과정이 중요
- 순서, 과정이 달라지면 새로운 작업 모델이 필요
- 컴퓨터의 작업 방식을 프로그래밍에 적용
- 기존 코드의 재사용성이 매우 낮음
객체 지향 프로그래밍
- 사람이 생각하고 행동하는 방식으로 프로그래밍
- 순서, 과정이 중요하지 않음
- 이해하기 쉽고, 모듈화(조립화)가 쉽다
- 기존 코드의 재사용성이 높고, 유지보수가 용이
- 설계 중심 언어
객체 지향 프로그래밍에서 자동차의 각각의 기능을 수행하는 부품이 클래스
각 기능을 클래스로 나누어 개발한 후 조립한다.
결론적으로 객체 지향 프로그래밍은 현실의 객체를 코드화(클래스화)시켜서 컴퓨터 시스템에서 실행되는 가상현실을 만드는 과정
단계
- 아이디어 도입 : 구현할 대상을 정한다.
- 아이디어 분석 : 주체의 관점에서 대상 분석
- 객체 추출 후 속성과 기능 찾기
- 객체 모델링 : 개발자 관점에서 객체의 속성과 행위를 정제한다.
- 클래스 변환 : 객체를 클래스로 변환한다.
- 인스턴스 생성 및 사용
클래스
= 객체 모델링을 통해 추출된 객체의 속성과 기능을 → 필드와 메서드로 변환한 것.
설계도(붕어빵 틀) → 이 틀을 가지고 만들어내는게 인스턴스(실제 객체)
클래스명 작성 규칙
- 클래스명의 첫 글자는 반드시 대문자이어야 한다.
- 하나 이상의 단어로 이루어져야한다.
- 첫 글자는 숫자가 사용될 수 없다.
- ‘_’, ‘$’ 외의 특수 문자를 사용할 수 없다.
- 자바 키워드나 자바에서 제공하는 클래스명은 사용할 수 없다.(MyString(O), String(x))
접근제한자 종류
+: public
#: protected
-: private
필드
필드는 클래스 내에 선언된 변수
멤버 변수, 속성(attribute)라고도 부른다.
접근 : 도트(.)연산자를 사용하여 접근한다.
필드의 타입에 따른 기본 초기값 : 0, false, null…정도이다.
필드와 지역(로컬) 변수의 차이점
| 지역변수 | 필드 | |
| 선언 위치 | 메서드나 생성자 블록 | 클래스 블록 |
| 메모리 생성 시점 | 메서드나 생성자 호출 시 생성 | 인스턴스 생성 시 생성 |
| 메모리 소멸 시점 | 메서드나 생성자 종료 시 소멸 | 인스턴스가 메모리에서 삭제 시 소멸 |
| 접근 범위 | 메서드나 생성자 내부에서만 접근 가능 | 클래스 내부와 클래스 외부에서 접근 가능 |
메서드
메서드는 객체의 기능이 변환되어 구현된다
실행 클래스
클래스들을 조립하는 기능
main() 메서드를 포함하고 있으므로 가장 먼저 실행된다.
생성자
인스턴스 생성 시 new 다음에 ‘클래스명()’이라고 썼는데 이것이 생성자(기본 생성자)
즉, 클래스 인스턴스를 메모리에 생성하려면 생성자를 호출해야 한다.
생성자 정의
- 최초로 호출되면서 클래스 인스턴스를 생성한다.
- 반드시 클래스명과 동일해야 한다.
특징
- 메서드와 비슷한 기능을 가진다.
- 리턴 타입이 없다.
- 생성자를 구현해 주지 않으면 컴파일러가 컴파일 시 자동으로 기본 생성자를 추가
- 직접 생성자를 구현해준 경우 컴파일러는 더 이상 기본 생성자를 자동으로 추가해 주지 않는다.
- 생성자를 직접 구현할 경우 기본 생성자를 함께 만들어주는 것을 습관화하는 것이 좋다!
오버로딩 over loading
클래스 이름을 재사용해 여러 개의 생성자가 존재할 수 있다.
반드시 매개 변수의 타입, 개수, 순서가 달라야 한다.
메서드 오버로딩 또한 마찬가지
+) 리턴 타입만 다르면 같은 메서드로 인식한다.
패키지
클래스들을 기능별로 묶어서 관리
패키지의 물리적인 형태는 파일 시스템의 폴더로 나타낸다.
package 상위패키지명.하위패키지명;
- 최상단에 한 번만 선언해야 한다
- 숫자로 시작하면 안되고 ‘_’, ‘$’ 이외의 특수문자를 사용해선 안된다.
- 소문자로 작성하는 것이 관례
예) www.oracle.com 이라는 도메인명을 사용하는 회사에서 개발하는 프로그램에 대한 패키지명을 만들때 도메인명을 역순으로 배열
→ com.oracle.프로젝트명.기능명.클래스명
import문
다른 패키지에 있는 클래스를 이용하려면 import문 작성하여 미리 선언
*: 해당 패키지의 모든 클래스들을 컴파일 시 import
기본 타입 변수 : 변수에 실제 값을 저장
참조 타입 변수 : 변수에 인스턴스의 위치값을 저장
참조 타입 변수를 null로 초기화하면 어떤 인스턴스도 위치값도 지정되지 않았으므로 예외 발생
+) 같은 파일에 다른 클래스 작성 시 public으로 선언하지 않고 작성해야 한다.
문자열 매개변수
자바에서 매개변수 타입이 문자열인 경우 예외적으로 기본 타입 매개변수처럼 동작한다.
문자열은 참조 타입(String 객체) 이지만 불변(immutable) 이라서 기본타입처럼 보이는 것
기본 타입 매개변수의 경우
public void changeValue(int num) {
num = 100;
}
//호출시
int x = 10;
changeValue(x);
System.out.println(x); // 10x의 복사본 값 10이 전달되므로 num을 변경해도 x는 변하지 않는다!
참조 타입 매개변수 경우
public void changeArray(int[] arr) {
arr[0] = 100;
}
//호출 시
int[] nums = {1, 2, 3};
changeArray(nums);
System.out.println(nums[0]); // 100nums의 주소가 전달되므로 배열 값을 변경하면 원본도 바뀐다.
String은 왜 ‘예외적으로’ 기본 타입처럼 동작할까?
불변 객체(immutable)이기 때문! → 내부값 변경 불가, 다른 객체 참조시 원본에 영향 없음.
자바에서 String은 참조형이지만 실제로는 마치 값 타입처럼 동작한다.
클래스 실습
car, main, member,res 4개의 패키지 생성 후
각 패키지에 하나씩 클래스 생성 (Car, RentCarApp, Member, Reserve 생성)
RestCarApp (main)
package main;
import car.Car;
import member.Member;
import res.Reserve;
public class RentCarApp {
public static void main(String[] arg) {
//회원, 차, 예약 인스턴스 생성
Member member = new Member();
Car car = new Car();
Reserve reserve = new Reserve();
//회원, 차, 예약 정보 등록
member.regMember("lee", "1234", "이순신", "서울시 도봉구", "010-1111-2222");
car.regCarInfo("11가 1111", "소나타", "검정", 2000, "현대");
reserve.resCar("20220708", "11가1111", "2020-04-30", "2020-05-01", "2020-05-08");
//회원 정보 조회
String memberInfo = member.viewMember();
System.out.println(memberInfo);
//렌터카 정보 조회
String carInfo = car.checkCarInfo();
System.out.println(carInfo);
//예약 정보 조회
String resInfo = reserve.checkResInfo();
System.out.println(resInfo);
//회원, 차, 예약 정보 수정
//회원, 차 예약 정보 삭제
}
}Car
package car;
public class Car {
String carNumber;
String carName;
String carColor;
int carSize;
String carMaker;
//생성자
public Car() {
}
public Car(String _carNumber, String _carName, String _carColor, int _carSize, String _carMaker) {
carNumber = _carNumber;
carName = _carName;
carColor = _carColor;
carSize = _carSize;
carMaker = _carMaker;
}
//차 정보 조회
public String checkCarInfo() {
System.out.println("\n렌터카 정보를 조회합니다.");
System.out.println("---------------------------");
String carInfo = "차 번호: " + carNumber
+"\n차 이름: " + carName
+"\n차 색상: " + carColor
+"\n차 크기: " + carSize
+"\n차 제조사: " + carMaker;
return carInfo;
}
//차 정보 등록
public void regCarInfo(String _carNumber, String _carName, String _carColor, int _carSize, String _carMaker) {
System.out.println("차 정보를 등록합니다.");
carNumber = _carNumber;
carName = _carName;
carColor = _carColor;
carSize = _carSize;
carMaker = _carMaker;
}
//차 정보 수정
public void modCarInfo() {
System.out.println("\n렌터카 정보를 수정합니다.");
}
//차 정보 삭제
public void delCarInfo() {
System.out.println("\n\n렌터카 정보를 삭제합니다.");
}
}Member
package member;
public class Member {
String id;
String password;
String name;
String adress;
String phoneNum;
//생성자
public Member() {
}
public Member(String _id, String _password, String _name, String _adress, String _phoneNum) {
id = _id;
password = _password;
name = _name;
adress = _adress;
phoneNum = _phoneNum;
}
//회원정보 조회
public String viewMember() {
System.out.println("\n회원정보를 조회합니다.");
System.out.println("-----------------------");
String memberInfo = "아이디: " + id
+"\n비밀번호: " + password
+"\n이름: " + name
+"\n주소: " + adress
+"\n전화번호: " + phoneNum;
return memberInfo;
}
//회원정보 등록
public void regMember(String _id, String _password, String _name, String _adress, String _phoneNum) {
System.out.println("회원 가입합니다.");
id = _id;
password = _password;
name = _name;
adress = _adress;
phoneNum = _phoneNum;
}
//회원정보 수정
public void modMember() {
System.out.println("\n회원정보를 수정합니다.");
}
//회원정보 삭제
public void delMember() {
System.out.println("\n\n회원정보를 삭제합니다.");
}
}Reserve
package res;
public class Reserve {
String resNumber;
String resCarNumber;
String resDate;
String useBeginDate;
String useEndDate;
public Reserve() {
}
public Reserve(String _resNumber, String _resCarNumber, String _resDate, String _useBeginDate, String _useEndDate) {
resNumber = _resNumber;
resCarNumber = _resCarNumber;
resDate = _resDate;
useBeginDate = _useBeginDate;
useEndDate = _useEndDate;
}
//차 예약 정보 조회 가능
public String checkResInfo() {
System.out.println("\n차 예약 정보를 조회합니다.");
System.out.println("----------------------");
String resInfo = "예약 번호 : " + resNumber
+"\n예약 차 번호 : " + resCarNumber
+"\n예약일자 : " + resDate
+"\n차 사용 시작 일자 : " + useBeginDate
+"\n차 반납 예정 일자 : " + useEndDate;
return resInfo;
}
//차 예약 기능
public void resCar(String _resNumber, String _resCarNumber, String _resDate, String _useBeginDate, String _useEndDate) {
System.out.println("차 예약 정보를 등록합니다.");
resNumber = _resNumber;
resCarNumber = _resCarNumber;
resDate = _resDate;
useBeginDate = _useBeginDate;
useEndDate = _useEndDate;
}
//차 예약 정보 수정
public void modResInfo() {
System.out.println("\n차 예약 정보를 수정합니다.");
}
//차 예약 정보 취소 기능
public void delResInfo() {
System.out.println("\n\n차 예약을 취소합니다.");
}
}
클래스 사이의 관계
- is-a 관계 : 한 클래스가 다른 클래스를 구체적으로 설명한다.
- use- a 관계 : 클래스가 다른 클래스를 사용
- has-a 관계 : 다른 클래스를 소유하는 관계
- 더 많은 관계들이 존재…
클래스 상속
정의
- is-a 관계가 성립되는 클래스 관계가 변환된 것
- 특정 클래스가 가지는 속성과 기능을 다른 클래스가 사용할 수 있게
용도
- 다른 클래스의 속성과 기능을 재사용 가능하다.
- 중복 코드 제거 → 가독성과 유지보수성이 높아지고 개발 기간 단축
만드는 법
- 일반화 : 공통점을 모아 놓은 클래스가 부모 클래스가 된다.
- 전문화 : 특정 클래스에서 각각의 하위 클래스로 분화 (자동차 → 승용차, 버스, 트럭)
형식
extends 키워드
+) 자바는 단일 상속만 지원하고, 다중 상속은 지원하지 않는다.
생성자는 상속되지 않는다.
일반적으로 부모 클래스 필드는 protected 접근 제한자 사용
예)
Student라는 부모 클래스를 만들고
Middle과 College라는 자식 클래스를 만든다.
이때 자식 클래스의 생성자를 호출하면 자동으로 부모 클래스의 생성자르 먼저 호출해서 부모 클래스의 인스턴스 생성 후, 자식 클래스 인스턴스가 생성된다.
- Student 생성자 호출
- Student 인스턴스 생성
- College 생성자 호출
- College 인스턴스 생성
- (부모 인스턴스가 먼저 생성된 후, 자식 인스턴스가 생성된다)
+) UML(Unified Modeling Language)
= 소프트웨어를 설계할 때 사용하는 표준화된 시각적 언어
그 중에서도 “클래스 다이어그램”이 가장 많이 쓰이며, 그 안에 클래스 계층도가 있다.
클래스 계층도 = 상속관계를 트리구조로 보여주는 다이어그램
예)
class Animal { }
class Dog extends Animal { }
class Cat extends Animal { }
class Bulldog extends Dog { }→ UML 클래스 계층도
Animal
▲
┌────┴────┐
Dog Cat
▲
Bulldog
UML 클래스 계층 구조는 사용자 입장에서 쉽게 이해하기 위한 표현일 뿐
실제 메모리에선 각각의 하위 클래스에 대해서 부모 클래스 인스턴스가 생성된다.
(자식 인스턴스들이 메모리에서 부모 인스턴스를 공유하는 것이 아님)
클래스 계층도를 그릴 수 있는 도구들:
-
StarUML (많이 쓰는 설계 툴)
-
PlantUML (코드로 UML 그리기)
-
Lucidchart, draw.io (웹 기반 다이어그램 도구)
super
자식 클래스에서 부모 클래스 인스턴스를 가리킬 때 사용하는 키워드
명시적으로 호출하지 않으면 컴파일 시 컴파일러가 자동으로 super() 추가
반드시 생성자의 첫 줄에 작성해야 한다.
this
자기 자신의 인스턴스를 가리킬 때 사용
- 자신의 다른 생성자 호출(생성자 첫 줄에서)
- 자신의 필드 호출
오버라이딩 메서드
메서드의 이름만 빌려온 후, 매서드의 구현은 자식 클래스에서 재정의해서 사용
- 매서드의 이름, 리턴 타입, 매개변수(순서 개수, 타입)이 동일해야 한다.
- static, final, private가 지정된 메서드는 오버라이딩 할 수 없다.
- @Override 어노테이션(annotation)은 생략 가능하지만 가독성을 위해 적는다.
오버라이딩 메서드의 접근 제한자
- 일반적으로 부모 메서드의 접근 제한자를 그대로 사용
- 단, 변경하는 경우 부모 메서드의 접근 제한자보다 더 넓은 접근을 허용하는 제한자만 가능
예시 : 도형의 넓이를 구하는 오버라이딩 메서드
부모 클래스 Shape
Rect
Tri ← override 사용 (사용하지 않으면 실행 클래스가 복잡해진다)
실행 클래스
접근 제한자
아무것도 지정하지 않으면 default 제한자로 지정
정의 : 클래스와 클래스의 멤버(필드, 메서드, 생성자)에 접근하는 범위를 제한하는 용도로 사용하는 지정자
- public : 모든 외부 클래스에서 접근 가능
- protected : 같은 패키지에 있는 클래스와 상속 관계의 클래스들만 접근 가능
- default : 같은 패키지에 있는 클래스만 접근 가능
- private : 같은 클래스 내에서만 접근 가능
캡슐화
객체 지향 개념 중에 하나
정의 : 접근 지정자를 사용하여 클래스의 필드나 메서드에 접근하는 방법을 일정하게 함으로써프로그램이 일관성있게 동작 및 관리되도록 한다.
(사용자가 임의로 조작하는 것을 배제)
예:
- 캡슐화를 사용하지 않을때
→ 이렇게 되면 + 자리에 실수로 *를 넣을 수도 있고 코드 자체가 복잡해진다.
하지만 캡슐화를 사용하면
Data의 x, y값을 private으로 만들어서 메서드로 간접접근할 수 있도록 한다.
package sec04.ex02;
public class DateTest {
public static void main(String[] args) {
Data d = new Data(5,5);
d.setValue(); //메서드를 통해 value에 값을 저장
int value = d.getValue(); //메서드를 통해 값을 가지고 온다
System.out.println("value = " + value);
}
}즉, 사용자는 내부의 세부적인 사항은 모르더라도 정해진 규칙대로만 실행문을 작성하면 원하는 기능을 얻을 수 있게 만든다.
이렇게 클래스의 필드에 접근할 땐 메서드를 통해 간접접근하는 것이 일반적.
이때 사용되는 메서드를 getter/setter 메서드
getter & setter
+)
| charAt(i) | 문자열에서 i번째 문자 하나 반환 |
| indexOf("a") | "a"라는 문자의 위치 반환 |
| substring(a,b) | a부터 b 전까지 문자열 잘라내기 |
get, set 메서드 활용해서 주민번호 “*” 처리해서 불러오기 예제
실행문
자동차를 이용한 상속 실습
Car 클래스
package sec05.ex01;
public class Car {
protected String carName;
protected String carNumber;
protected String carColor;
protected int velocity;
protected int carSize;
public Car() {
System.out.println("Car 클래스 생성자 호출");
}
public void speedUp(int speed) {
velocity += speed;
}
public void speedDown(int speed) {
velocity -= speed;
}
public void stop() {
velocity = 0;
}
//차 정보를 출력하는 메서드
public String getCarInfo() {
return "차 이름: " + carName +
", 차 번호: " + carNumber +
", 차 색상: " + carColor +
", 속도: " + velocity + "km/h" +
", 차 크기: " + carSize + "cc";
}
}Sedan 클래스
package sec05.ex01;
public class Sedan extends Car{
public Sedan(String carName, String carNumber, String carColor, int velocity, int carSize) {
System.out.println("Sedan 클래스 생성자 호출");
super.carName = carName;
super.carNumber = carNumber;
super.carColor = carColor;
super.velocity = velocity;
super.carSize = carSize;
}
}Truck 클래스
package sec05.ex01;
public class Truck extends Car{
private int load; //적재화물량
public Truck(String carName, String carNumber, String carColor, int carSize, int velocity, int load) {
System.out.println("Truck 클래스 생성자 호출");
super.carName = carName;
super.carNumber = carNumber;
super.carColor = carColor;
super.velocity = velocity;
super.carSize = carSize;
this.load = load;
}
public int getLoad() {
return load;
}
public void setLoad(int load) {
this.load = load;
}
//화물을 운반하는 메서드
public void carryLoad() {
if (load >0) {
load ++;
} else {
load = 0;
}
}
@Override
public String getCarInfo() {
return "차 이름: " + carName +
", 차 번호: " + carNumber +
", 차 색상: " + carColor +
", 속도: " + velocity + "km/h" +
", 차 크기: " + carSize + "cc" +
", 적재량: " + getLoad() + "톤";
}
}Bus 클래스
package sec05.ex01;
public class Bus extends Car {
private int passenger; //승객 수
private int fee;
public Bus(String carName, String carNumber, String carColor,
int carSize, int velocity, int passenger, int fee) {
System.out.println("Bus 클래스 생성자 호출");
super.carName = carName;
super.carNumber = carNumber;
super.carColor = carColor;
super.velocity = velocity;
super.carSize = carSize;
this.passenger = passenger;
this.fee = passenger * fee;
}
public int getPassenger() {
return passenger;
}
public void setPassenger(int passenger) {
this.passenger = passenger;
}
public int getFee() {
return fee;
}
public void setFee(int fee) {
this.fee = fee;
}
//승객을 태우는 메서드
public void ridePassenger() {
if(passenger > 0) {
passenger++;
fee += 1000;
}
}
public void ridePassenger(int newPassenger) {
if(passenger > 0) {
passenger+= newPassenger;
fee += newPassenger * 1000;
}
}
@Override
public String getCarInfo() {
return "차 이름: " + carName +
", 차 번호: " + carNumber +
", 차 색상: " + carColor +
", 속도: " + velocity + "km/h" +
", 차 크기: " + carSize + "cc"+
", 승객 수: " + getPassenger() +"명, 승차 요금: " + getFee() + "원";
}
}실행 클래스
package sec05.ex01;
public class CarTest {
public static void main(String[] args) {
//1. 변수 선언
Sedan myCar = null;
Truck truck = null;
Bus bus = null;
//2. 인스턴스 생성
myCar = new Sedan("아반떼", "111가 1111", "은색", 60, 2000);
truck = new Truck("1톤 포터", "222나 2222", "청색", 3000, 60, 1);
bus = new Bus("1001번 버스", "333다 3333", "노란색", 4000, 60, 20, 1000);
//3.메서드 호출
System.out.println(myCar.getCarInfo());
System.out.println(truck.getCarInfo() + ", 적재량: " + truck.getLoad() + "톤");
System.out.println();
truck.speedUp(10);
truck.carryLoad();
System.out.println("트럭과 버스 정보를 출력");
System.out.println(truck.getCarInfo());
System.out.println(bus.getCarInfo() );
//승객 여러명 탑승 후 버스 정보
System.out.println("\n승객 여러명 탑승 : 메서드 오버로딩 이용");
bus.ridePassenger(10);
System.out.println(bus.getCarInfo());
}
}'멀티캠퍼스-JAVA 풀스택 > JAVA' 카테고리의 다른 글
| Java 기초(7) - 인터페이스 (0) | 2025.11.25 |
|---|---|
| Java 기초(6)- 객체지향(2) (0) | 2025.11.18 |
| Java 기초(4) - 배열 (0) | 2025.11.12 |
| Java 기초(3) (0) | 2025.10.28 |
| JAVA 기초(2) (1) | 2025.10.23 |