2026. 1. 12. 17:01ㆍ대우개발원 수업 내용/Java 정리
[클래스 맴버]
클래스에 선언된 필드와 메소드가 모두 객체 내부에 포함되는 것은 아니다.
객체가 있어야 사용 가능한 멤버가 있고, 그렇지 않는 멤버도 있다.
인스턴스 멤버
- 객체 마다 가지고 있는 멤버
- 인스턴스 필드: 힙 영역의 객체 마다 가지고 있는 멤버, 객체마다 다른 데이터를 저장
- 인스턴스 메소드: 객체가 있어야 호출 가능한 메소드,
클래스 코드(메소드 영역)에 위치하지만, 이해하기 쉽도록 객체 마다 가지고 있는
메소드라고 생각해도 됨
정적 멤버
- 객체와 상관없는 멤버, 클래스 코드(메소드 영역)에 위치
정적 필드 및 상수: 객체 없이 클래스만으로도 사용 가능한 필드
정적 메소드: 객체가 없이 클래스만으로도 호출 가능한 메소드
[인스턴스 멤버와 this]
- 인스턴스 (instance) 멤버
객체를 생성한 후 사용할 수 있는 필드와 메소드
객체에 소속된 멤버
public class Car {
//필드
int gas;
//메소드
void setSpeed(int speed) { · }
}Car myCar = new Car();
myCar.gas = 10;
myCar.setSpeed(60);
Car yourCar = new Car();
yourCar.gas = 20;
yourCar.setSpeed(80);
this
- 객체 내부에서는 인스턴스 멤버에 접근하기 위해 this를 사용. 객체는 자신을 ‘this’라고 지칭
- 생성자와 메소드의 매개변수명이 인스턴스 멤버인 필드명과 동일한 경우,
인스턴스 필드 임을 강조하고자 할 때 this를 주로 사용
Car(String model) {
this.model = model;
}
void setModel(String model) {
this.model = model;
}예시 Car, CarEx 코드
package sec01;
public class Car {
// 필드
String model;
int speed;
// 생성자
Car(String model) {
this.model = model;
//this.model의 model은 필드의 String model
}
// 메서드
void setSpeed(int speed) {
this.speed = speed; // 여기에 있는
//this.speed의 speed는 필드의 int speed
}
void run() {
for(int i=0; i<=50; i++) {
this.setSpeed(i); //여기에 있는 setSpeed는 메서드의 setSpeed (여기는 this생략가능)
System.out.println(this.model + "가 달립니다. (시속:" + this.speed + "km/h)");
//this.model의 model은 필드의 String model (여기는 this생략가능)
//this.speed의 speed는 필드의 int speed (여기는 this생략가능)
}
}
}package sec01;
public class CarEx {
public static void main(String[] args) {
Car myCar = new Car("포르쉐");
Car yourCar = new Car("벤츠");
myCar.run();
yourCar.run();
}
}[정적 멤버 선언]
- 정적 멤버: 메소드 영역의 클래스에 고정적으로 위치하는 멤버
- static 키워드를 추가해 정적 필드와 정적 메소드로 선언
public class 클래스 {
//정적 필드 선언
static 타입 필드 [= 초기값];
//정적 메소드
static 리턴타입 메소드( 매개변수, … ) { … }
}
[정적 멤버와 static]
정적 멤버 사용
- 클래스 이름과 함꼐 도트 연산자로 접근
클래스, 필드;
클래스. 메소드( 매개값, … );public class Calculator {
static double pi = 3.14159;
static int plus(int x, int y) { ... }
static int minus(int x, int y) { ... }
}double result1 = 10 * 10 * Calculator.pi;
int result2 = Calculator.plus(10, 5);
int result3 = Calculator.minus(10, 5);
위의 내용을 정리한 Calculator, CalculatorEx
package sec01;
public class Calculator {
static double pi = 3.14159;
static int plus(int x, int y) {
return x + y;
}
static int minus(int x, int y) {
return x - y;
}
}package sec01;
public class CalculatorEx {
public static void main(String[] args) {
double result1 = 10 * 10 * Calculator.pi;
int result2 = Calculator.plus(10, 5);
int result3 = Calculator.minus(10, 5);
System.out.println("result1 : " + result1);
System.out.println("result2 : " + result2);
System.out.println("result3 : " + result3);
}
}[정적 멤버와 static]
- 인스턴스 멤버와 정적 멤버 선택 기준
객체마다 다를 수 있는 필드값 -> 인스턴스 필드로 선언
그렇지 않고 객체마다 다를 필요가 없는 필드값 -> 정적 필드로 선언
public class Calculator {
String color; //계산기별로 색깔이 다를 수 있습니다.
static double pi = 3.14159; //계산기에서 사용하는 파이(π) 값은 동일합니다.
}
- 메소드 블록에 인스턴스 필드 또는 인스턴스 메소드를 사용할 경우 -> 인스턴스 메소드로 선언
그렇지 않을 경우 -> 정적 메소드로 선언
public class Calculator {
String color; //인스턴스 필드
void setColor(String color) { this.color = color; } //인스턴스 메소드
static int plus(int x, int y) { return x + y; } //정적 메소드
static int minus(int x, int y) { return x - y; } //정적 메소드
}
정적 메소드 선언 시 주의할 점
- 정적 메소드 선언 시 그 내부에 인스턴스 필드 및 메소드 사용 불가
- 정적 메소드 선언 시 그 객체 자신 참조인 this 키워드 사용 불가
public class ClassName {
//인스턴스 필드와 메소드
int field1;
void method1() { }
//정적 필드와 메소드
static int field2;
static void method2() { ... }
//정적 메소드
static void Method3 {
this.field1 = 10; //(x)←컴파일 에리
this.method1(); //(x)←컴파일 에리
field2 = 10; //(o)
method2(); //(0)
}
}- 정적 메소드에서 인스턴스 멤버 사용하려는 경우
객체 우선 생성 후 참조 변수로 접근
static void Method3() {
ClassName obj = new ClassName();
obj.field1 = 10;
obj.method1();
}[정적 멤버 사용]
클래스가 메모리로 로딩되면 정적 멤버를 바로 사용할 수 있음
▪ 클래스 이름과 함께 도트(.) 연산자로 접근
▪ 정적 필드와 정적 메소드는 객체 참조 변수로도 접근
[정적 블록]
- 정적 필드를 선언할 때 복잡한 초기화 작업이 필요하다면 정적 블록을 이용
- 정적 블록은 클래스가 메모리로 로딩될 때 자동으로 실행
- 정적 블록이 클래스 내부에 여러 개가 선언되어 있을 경우에는 선언된 순서대로 실행
- 정적 필드는 객체 생성 없이도 사용할 수 있기 때문에 생성자에서 초기화 작업을 하지 않음
예제 코드 Television, TelevisionEx
package sec01;
public class Television {
static String company = "MyCompany";
static String model = " LCD";
static String info;
static {
info = company + "-" + model;
}
}package sec01;
public class TelevisionEx {
public static void main(String[] args) {
System.out.println(Television.info);
}
}
[인스턴스 멤버 사용 불가]
- 정적 메소드와 정적 블록은 내부에 인스턴스 필드나 인스턴스 메소드를 사용할 수 없으며 this도 사용할 수 없음
- 정적 메소드와 정적 블록에서 인스턴스 멤버를 사용하고 싶다면 객체를 먼저 생성하고 참조 변수로 접근
예시 Car2
package sec01;
public class Car2 {
// 인스턴스 필드 선언
int speed;
// 인스턴스 메소드 선언
void run() {
System.out.println(speed + "로 달립니다.");
}
static void simulate() {
//객체 생성
Car2 myCar = new Car2();
//인스천스 맴버 사용
myCar.speed = 200;
myCar.run();
}
public static void main(String[] args) {
// ↑ main 메소드에 static이 있기때문에 정적 메소드이다
simulate(); // simulate();는 정적 메소드라 바로 호출 가능
// 객체 생성
Car2 myCar = new Car2();
// 인스턴스 맴버 사용
myCar.speed = 60; // 인스턴스 맴버를 사용할때는 객체를 생성해서 사용해야한다
myCar.run();
}
}[final 필드와 상수]
final 필드
- 초기값이 저장되면 최종값이 되어 프로그램 실행 도중 수정 불가
final 필드의 초기값 주는 방법
- 단순 값일 경우 필드 선언 시 초기화(주로 정적 필드(상수)일 경우)
- 객체 생성 시 외부 데이터로 초기화 필요한 경우 생성자에서 초기화(주로 인스턴스 필드일 경우)
인스턴스 final 필드
- 객체에 한번 초기화된 데이터를 변경 불가로 만들 경우: ex) 주민 번호
final 타입 필드 [ = 초기값]; ex) final String ssn; //생성자에서 초기화
- 정적 final 필드 (관례적으로 모두 대문자로 작성)
불편의 값인 상수를 만들 경우: ex) PI
static final 타입 상수 = 초기값;
final필드 예제 Korean, KoreanEx
package sec01;
public class Korean {
// 인스턴스 final 필드 선언
final String nation = "대한민국";
final String ssn;
// 인스턴스 필드 선언
String name;
// 생성자 선언
public Korean(String ssn, String name) {
this.ssn = ssn;
this.name = name;
}
}package sec01;
public class KoreanEx {
public static void main(String[] args) {
// 객체 생성시 주민번호와 이름 전달
Korean k1 = new Korean("123456-1234567", "김자바");
// 필드값 읽기
System.out.println(k1.nation);
System.out.println(k1.ssn);
System.out.println(k1.name);
// Final 필드는 값을 변경 x
// k1.nation = "USA";
// k1.ssn = "123-12-1234";
// 비 final 필드는 값 변경 가능
k1.name = "김자바2";
}
}상수 에제 Earth, EarthEx
package sec01;
public class Earth {
// 상수 선언 및 초기화
static final double EARTH_RADIUS = 6400;
// 상수 선언
static final double EARTH_SURFACE_AREA;
// 정적 블록에서 상수 초기화
static {
EARTH_SURFACE_AREA = 4 * Math.PI * EARTH_RADIUS * EARTH_RADIUS;
}
}package sec01;
public class EarthEx {
public static void main(String[] args) {
// 상수 읽기
System.out.println("지구의 반지름 : " + Earth.EARTH_RADIUS + " km");
System.out.println("지구의 표면적 : " + Earth.EARTH_SURFACE_AREA + " km^2");
}
}Quiz. Circle. Java, CircleArray.java (class)
Circle클래스로 객체 5개를 가지는 배열을 생성하고, Circle 객체의
반지름(매개변수)을 0에서 4까지 각각 지정한 후, 면적을 출력하세요.
면적 = 3.14 * 반지름 * 반지름
출력:
반지름0 원의 넓이 : 0
반지름1 원의 넓이 : 3
반지름2 원의 넓이 : 12
반지름3 원의 넓이 : 28
반지름4 원의 넓이 : 50
package sec01;
class Circle {
// 필드
int radius;
// 생성자
public Circle(int radius) {
this.radius = radius;
}
// 메서드
public double getArea() {
return (int)(3.14 * radius * radius);
}
}package sec01;
public class CircleArray {
public static void main(String[] args) {
// 객체 인스턴스 생성(array로 선언)
Circle[] circles = new Circle[5];
// 반지름 0 ~ 4인 Circle 객체 생성
for (int i = 0; i < circles.length; i++) {
circles[i] = new Circle(i);
}
// 면적 출력
for (int i = 0; i < circles.length; i++) {
System.out.println(
"반지름" + circles[i].radius + " 원의 넓이 : " + circles[i].getArea()
);
}
}
}Quiz. Tv.java, TvEx.java (class)
다음 main() 메소드를 실행하였을 때 예시와 같이 출력되도록 TV 클래스를
작성하세요. brand, year, inch 필드, 생성자, show()메서드 구성.
출력:
LG에서 만든 2017년형 32인치 TV
package sec01;
public class Tv {
//필드 선언
String brand;
int year;
int inch;
// 생성자
public Tv(String brand, int year, int inch) {
this.brand = brand;
this.year = year;
this.inch = inch;
}
// show() 메서드
void show() {
System.out.println(
brand + "에서 만든 " + year + "년형 " + inch + "인치 TV"
);
}
}package sec01;
public class TvEx {
public static void main(String[] args) {
Tv tv = new Tv("LG", 2017, 32);
tv.show();
}
}[패키지]
프로젝트 개발 시 클래스를 체계적으로 관리하기 위해 패키지를 사용한다.
클래스와 클래스의 멤버를 사용 범위에 맞게 접근 제한자를 활용한다.
- 패키지의 물리적인 형태는 파일 시스템의 폴더
- 패키지는 클래스의 일부분으로, 클래스를 유일하게 만들어주는 식별자 역할
- 클래스 이름이 동일하더라도 패키지가 다르면 다른 클래스로 인식
- 클래스의 전체 이름은 패키지+클래스 사용해서 다음과 같이 표현
상위패키지.하위패키지.클래스
com.mycompany.A
com.yourcompany.B
[패키지 선언]
- 클래스 작성 시 해당 클래스가 어떤 패키지에 속할 것인지를 선언
package 상위 패키지, 하위패키지;
public class Class { ... }
예시)
package com.mycompany;
public class Car { ... }- 패키지 이름 규칙
숫자로 시작 불가
_ 및 $ 제외한 특수문자 사용 불가
java로 시작하는 패키지는 자바 표준 API 에서만 사용하므로 사용 불가
모두 소문자로 작성하는 것이 관례
import문
- 사용하고자 하는 클래스 또는 인터페이스가 다른 패키지에 소속된 경우
- 해당 패키지 클래스 또는 인터페이스 가져와 사용할 것임을 컴파일러에 통지
import 상위패키지,하위패키지,클래스이름;
import 상위패키지,하위패키지,*;
예시)
package com.mycompany;
import com.hankook.Tire;
[ 또는 import com.hankook.*; ]
public class Car {
Tire tire = new Tire();
}
- 패키지 선언과 클래스 선언 사이에 작성
- 하위 패키지는 별도로 import를 해야함
import com.hankook.*;
import com.hankook.project.*;
- 다른 패키지에 동일한 이름의 클래스가 있을 경우
import와 상관없이 클래스 전체 이름을 기술
[접근 제한자]
▪ 중요한 필드와 메소드가 외부로 노출되지 않도록 해 객체의 무결성을 유지하기 위해서 접근 제한자 사용
▪ 접근 제한자는 public, protected, private의 세 가지 종류
| 접근 제한자 | 제한 대상 | 제한 범위 |
| public | 클래스, 필드, 생성자, 메소드 | 없음 |
| protected | 필드, 생성자, 메소드 | 같은 패키지이거나, 자식 객체만 사용가능 |
| (default) | 클래스, 필드, 생성자, 메소드 | 같은 패키지 |
| private | 필드, 생성자, 메소드 | 객체 내부 |
[ public [ protected [default [ private] ] ] ] <- 범위 예시
[클래스의 접근 제한]
- 같은 패키지 내에서만 사용할 것인지 다른 패키지 내에서도 사용할 수 있도록 할 것인지 결정
[생성자의 접근 제한]
- 생성자는 public, default, private 접근 제한을 가질 수 있음
| 접근 제한자 | 생성자 | 설명 |
| public | 클래스(...) | 모든 패키지에서 생성자를 호출 가능 = 모든 패키지에서 객체를 생성 가능 |
| 클래스(...) | 같은 패키지에서만 생성자 호출 가능 = 같은 패키지에서만 객체를 생성 가능 |
|
| private | 클래스(...) | 클래스 내부에서만 생성자 호출 가능 = 클래스 내부에서만 객체를 생성 가능 |
[Getter와 Setter 메소드]
Setter
- 데이터를 검증해서 유효한 값만 필드에 저장하는 메소드
Getter
- 필드값이 객체 외부에서 사용하기에 부적절한 경우, 적절한 값으로 변환해서 리턴할 수 있
외부에서 객체에 마음대로 접근할 경우 객체의 무결성 깨질 수 있음
Setter 메소드
- 외부의 값을 받아 필드의 값을 변경하는 것이 목적
- 매개값 검증하여 유효한 값만 필드로 저장할 수 있음
Getter 메소드
- 외부로 필드값을 전달하는 것이 목적
- 필드값을 가공해서 외부로 전달할 수도 있음
예제 Car , CarEx 코드
package sec03;
public class Car {
// 필드 선언
private int speed;
private boolean stop;
// public int getSpeed() {
// return speed;
// }
// public void setSpeed(int speed) {
// this.speed = speed;
// }
// public boolean isStop() {
// return stop;
// }
// public void setStop(boolean stop) {
// this.stop = stop;
// }
//speed 필드의 Getter / Setter 선언
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
if(speed <= 0) {
this.speed = 0;
return;
} else {
this.speed = speed;
this.stop = false;
}
}
// stop 필드의 Getter/Setter 선언
public boolean isStop() {
return stop;
}
public void setStop(boolean stop) {
this.stop = stop;
if(stop == true) this.speed = 0;
}
}package sec03;
public class CarEx {
public static void main(String[] args) {
// 객체 생성
Car myCar = new Car();
//잘못된 속도 변경
myCar.setSpeed(-50);
System.out.println("현재속도: " + myCar.getSpeed());
//올바른 속도 변경
myCar.setSpeed(60);
System.out.println("현재속도: " + myCar.getSpeed());
//멈춤
if(!myCar.isStop()) {
myCar.setStop(true);
}
System.out.println("현재속도: " + myCar.getSpeed());
}
}[싱글톤 패턴]
- 생성자를 private 접근 제한해서 외부에서 new 연산자로 생성자를 호출할 수 없도록 막아서
외부에서 마음대로 객체를 생성하지 못하게 함
- 대신 싱글톤 패턴이 제공하는 정적 메소드를 통해 간접적으로 객체를 얻을 수 있음
public class 클래스 {
//private 접근 권한을 갖는 정적 필드 선언과 초기화
private static 클래스 singleton = new 클래스();
//private 접근 권한을 갖는 생성자 선언
private 클래스() {}
//public 접근 권한을 갖는 정적 메소드 선언
public static 클래스 getInstance() {
return singleton;
}
}
[싱글톤 (singleton)]
- 전체 프로그램에서 단 하나의 객체만 만들도록 보장하는 코딩 기법
- 싱글톤 작성 방법
클래스 외부에서 new 연산자 통해 생성자 호출하는 것 불가하도록 private 접근 제한자 사용
자신의 타입인 정적 필드 선언 후 자신의 객체 생성해 초기화
외부에서 호출할 수 있는 getInstance() 선언
정적 필드에서 참조하는 자신의 객체 리턴
예제 Singleton, SingletonEx 코드
package sec03;
public class Singleton {
//private 접근 권한을 갖는 정적 필드 선언과 초기화
private static Singleton singleton = new Singleton();
//private 접근 권한을 갖는 생성자 선언
private Singleton() {
}
//public 접근 권한을 갖는 정적 메소드 선언
public static Singleton getInstance() {
return singleton;
}
}package sec03;
public class SingletonEx {
public static void main(String[] args) {
// Singleton obj1 = new Singleton(); //컴파일 에러
Singleton obj1 = Singleton.getInstance();
Singleton obj2 = Singleton.getInstance();
// 동일한 객체를 참조하는지 확인
if(obj1 == obj2) {
System.out.println("같은 Singleton 객체 입니다.");
} else {
System.out.println("다른 Singleton 객체 입니다.");
}
}
}=> 오로지 한개의 객체만 생성해서 구현하고 싶을때 싱글톤 패턴을 사용한다.
quiz
getInstance 구현하는 코드 Singleton, SingletonEx
package quiz;
public class Singleton {
private static Singleton a = new Singleton();
private Singleton() {}
private int number;
public int getNumber() {
return number;
}
public void setNumber(int number) {
this.number = number;
}
public static Singleton getInstance() {
return a;
}
}package quiz;
public class SingletonEx {
public static void main(String[] args) {
Singleton s = Singleton.getInstance();
s.setNumber(100);
System.out.println(s.getNumber());
}
}Quiz.SongEx.java (class)
노래 한곡을 나타내는 song 클래스를 작성하세요.
Song은 다음 필드로 구성됩니다.
- 노래의 제목을 나타내는 title
- 가수를 나타내는 artist
- 노래가 발표된 연도를 나타내는 year
- 국적을 나타내는 country
또한 Song 클래스에 다음 생성자와 메소드를 작성하세요
- 생성자 2개 : 기본 생성자와 매개변수로 모든 필드를 초기화 하는 생성자
this("title", "artist", 0000, "country");
- 노래 정보를 출력하는 show() 메소드
출력 :
1978년 스웨덴국적의 ABBA가 부른 Dancing Queen
package quiz;
public class Song {
String title;
String artist;
int year;
String country;
// 기본 생성자
Song() {
this("title", "artist", 0000, "country");
}
// 모든 필드를 초기화하는 생성자
Song(String title, String artist, int year, String country) {
this.title = title;
this.artist = artist;
this.year = year;
this.country = country;
}
// 노래 정보 출력 메소드
void show() {
System.out.println(
year + "년 " + country + "국적의 "
+ artist + "가 부른 " + title
);
}
}package quiz;
public class SongEx {
public static void main(String[] args) {
Song song = new Song("Dancing Queen", "ABBA", 1978, "스웨덴");
song.show();
}
}quiz.StudentEx,java (class)
아래 테이블과 같은 맴버 필드를 가지는 Student(라이브러리)클래스를 작성하세요.
| 타입 | 필드명 | 설명 |
| String | name | 학생 이름 |
| int | ban | 반 |
| int | no | 번호 |
| int | kor | 국어점수 |
| int | eng | 영어점수 |
| int | math | 수학점수 |
Student클래스에 다음 내용이 포함된 3개의 메소드를 작성하시오
| 메소드 명 | 반환타입 | 매개변수 | 기능 |
| getTotal | int | 없음 | 국어, 영어, 수학 점수를 모두 더해서 반환한다 |
| getAverage | float | 없음 | 총점을 과목수로 나눈 평균을 반환 |
| info | void | 없음 | 모든 필드와 메서드를 호출 |
출력:
package quiz;
public class Student {
String name; // 학생 이름
int ban; // 반
int no; // 번호
int kor; // 국어 점수
int eng; // 영어 점수
int math; // 수학 점수
//생성자
public Student() {}
// 생성자 오버로딩
public Student (String name, int ban, int no, int kor, int eng, int math) {
this.name = name;
this.ban = ban;
this.no = no;
this.kor = kor;
this.eng = eng;
this.math = math;
}
// 총점 반환
public int getTotal() {
int sum = this.kor + this.eng + this.math;
return sum;
}
// 평균 반환
public float getAverage() {
float avg = getTotal() / 3.0f;
return avg;
}
// 모든 필드와 메소드 출력
public void info() {
System.out.println("이름 : " + name);
System.out.println("반 : " + ban);
System.out.println("번호 : " + no);
System.out.println("국어점수 : " + kor);
System.out.println("영어점수 : " + eng);
System.out.println("수학점수 : " + math);
System.out.println("총점 : " + getTotal());
System.out.println("평균 : " + getAverage());
}
}package quiz;
public class StudentEx {
public static void main(String[] args) {
Student s = new Student();
s.name = "고길동";
s.ban = 3;
s.no = 17;
s.kor = 92;
s.eng = 63;
s.math = 74;
s.info();
}
}Quiz. BankEx.java (class)
1.Bank,java 라이브러리 클래스에 예금 기능 / 출금 기능 / 조회 / 종료 기능을 각각 메서드를 만듬
2. 실행 클래스의 메인 메서드에서 종료(메서드)를 선택하지 않으면 메뉴가 반복적으로 출력되도록
3. 각각의 메뉴 선택시 메서드를 통해서 해당 기능을 구현
4. 출금기능은 잔액보타 큰 액수는 출금 x
5. 잔액이 1,000,000원이 넘어서도록 입금 x
예) 잔액이 900,000원 있는데 110,000원을 입금하면 잔액이 1,010,000으로 1,000,000원을 초과하므로 입금을 거부해야 합니다.
출력 예시:
안녕하세요 MIT BANK입니다.
*********************************
MIT 뱅크에 오신것을 환영합니다.
메뉴를 선택해 주세요
1. 예금
2.출금
3.잔액조회
4.종료
>1
예금할 금액을 입력해주세요.
860000
860000원을 입금하였습니다.
총 금액은: 860000입니다.
*********************************
package quiz;
import java.util.Scanner;
public class Bank{
int balance = 0;
final int MAX_BALANCE = 1_000_000;
Scanner scan = new Scanner(System.in);
// 예금
void deposit(){
System.out.println("예금할 금액을 입력해주세요.");
int money = scan.nextInt();
if (balance + money > MAX_BALANCE) {
System.out.println("잔액이 1,000,000원을 초과할 수 없습니다.");
return;
}
balance += money;
System.out.println(money + "원을 입금하였습니다.");
System.out.println("총 금액은: " + balance + "입니다.");
}
// 출금
void withdraw(){
System.out.println("출금할 금액을 입력해주세요.");
int money = scan.nextInt();
if (money > balance) {
System.out.println("잔액이 부족합니다.");
return;
}
balance -= money;
System.out.println(money + "원을 출금하였습니다.");
System.out.println("총 금액은: " + balance + "입니다.");
}
// 잔액 조회
void check(){
System.out.println("현재 잔액은: " + balance + "입니다.");
}
// 종료
void exit(){
System.out.println("프로그램을 종료합니다.");
}
}package quiz;
import java.util.Scanner;
public class BankEx{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
Bank bank = new Bank();
boolean run = true;
System.out.println("안녕하세요 MIT BANK입니다.");
while (run) {
System.out.println("*********************************");
System.out.println("MIT 뱅크에 오신것을 환영합니다.");
System.out.println("메뉴를 선택해 주세요");
System.out.println("1. 예금");
System.out.println("2. 출금");
System.out.println("3. 잔액조회");
System.out.println("4. 종료");
System.out.print("> ");
int menu = scan.nextInt();
switch (menu) {
case 1:
bank.deposit();
break;
case 2:
bank.withdraw();
break;
case 3:
bank.check();
break;
case 4:
bank.exit();
run = false;
break;
default:
System.out.println("메뉴를 다시 선택해주세요.");
}
}
scan.close();
}
}안녕하세요 MIT BANK입니다.
*********************************
MIT 뱅크에 오신것을 환영합니다.
메뉴를 선택해 주세요
1. 예금
2. 출금
3. 잔액조회
4. 종료
> 1
예금할 금액을 입력해주세요.
1029581929
잔액이 1,000,000원을 초과할 수 없습니다.
*********************************
MIT 뱅크에 오신것을 환영합니다.
메뉴를 선택해 주세요
1. 예금
2. 출금
3. 잔액조회
4. 종료
> 1
예금할 금액을 입력해주세요.
144444
144444원을 입금하였습니다.
총 금액은: 144444입니다.
*********************************
MIT 뱅크에 오신것을 환영합니다.
메뉴를 선택해 주세요
1. 예금
2. 출금
3. 잔액조회
4. 종료
> 2
출금할 금액을 입력해주세요.
14
14원을 출금하였습니다.
총 금액은: 144430입니다.
*********************************
MIT 뱅크에 오신것을 환영합니다.
메뉴를 선택해 주세요
1. 예금
2. 출금
3. 잔액조회
4. 종료
> 3
현재 잔액은: 144430입니다.
*********************************
MIT 뱅크에 오신것을 환영합니다.
메뉴를 선택해 주세요
1. 예금
2. 출금
3. 잔액조회
4. 종료
> 4
프로그램을 종료합니다.
'대우개발원 수업 내용 > Java 정리' 카테고리의 다른 글
| Java 개념정리 12일차 (2) | 2026.01.15 |
|---|---|
| Java 개념정리 11일차 (1) | 2026.01.13 |
| Java 개념정리 9일차 (1) | 2026.01.12 |
| Java 개념정리 8일차 (0) | 2026.01.12 |
| Java 개념정리 7일차 (0) | 2026.01.12 |