비슷한 성격의 클래스를 모아둔 자바의 "폴더"와 같은 개념
같은 이름의 클래스도 서로 다른 패키지에 존재 가능
패키지는 폴더의 개념과 같음.
해당 하위패키지에 접근하기 위해서는
상위패키지명. 하위패키지명.클래스명
서로 다른 클래스를 사용하기 위해서는 임포트해줘야 한다!
단, 같은 패키지 내에서는 import 없이도 사용 가능
(예)
import 상위패키지명.하위패키지명; : 해당 하위패키지 임포트
or
import 상위패키지명.* : 해당 상위패키지 밑의 모든 패키지 사용 가능
1. 클래스의 분류가 용이하다
2. 패키지가 다르다면 동일 클래스명 사용이 가능하다
파일을 생성하고, 그 파일에 어떠한 내용을 입력하는 방법
- 파일 생성 코드의 입력값에 ', true' 추가!!
(예) Filewriter fw = new FileWriter("c:/out.txt", true);
- 단, PrintWriter를 이용하고 싶다면 생성자의 파라미터로 filewriter의 객체를 전달해야 한다.
(예) Printwriter pw = new PrintWriter(new FileWriter("c:/out.txt", true));
객체.close()
자바에서는 프로그램 종료 시 파일 객체를 자동으로 닫는 기능이 있으나,
닫지 않고 다시 사용하려는 경우 오류가 발생하기 쉽다.
사용자의 입력을 받거나 사용자에게 문자열을 출력해주는 역할을 하는
컴퓨터와 사용자 사이의 상호작용을 담당하는 장치
사용자가 직접 무언가를 입력하는 것.
★ "System.in" 을 사용하여 사용자로부터 입력을 받음.
import java.io.IOException;
import java.io.BufferedReader; // 문자열(Strint)을 읽는다 | 입력값을 길이에 상관없이 받음
import java.io.InputStream; // byte를 읽는다 | 입력값 받아 아스키코드로 출력
import java.io.InputStreamReader; // 문자(character)를 읽는다 | 입력값 받아 값 그래로 출력
import java.util.Scanner;
public class Day19 {
public static void main(String[] args) throws IOException { // IOException 예외 처리를 뒤로 미룬다(throws)
InputStream in = System.in; //System.in은 InputStream의 객체
int a;
System.out.println("1byte만 입력");
a = in.read(); //read() : 1byte 입력 받음 >> int로 저장 (0~255정수값, 아스키코드값)
System.out.println(a); // 1byte 이상 입력해도 1byte만 받아서 출력함
System.out.println();
int b;
int c; // 2개의 변수 선언하면 2byte 입력값을 받을 수 있음
System.out.println("2byte 입력");
b = in.read();
c = in.read();
System.out.println(b);
System.out.println(c);
System.out.println();
byte[] d = new byte[3];
System.out.println("3byte짜리 배열 입력");
in.read(d);
System.out.println(d[0]);
System.out.println(d[1]);
System.out.println(d[2]);
System.out.println();
// InputStreamReader : 입력한 값을 아스키코드가 아니라 그대로 출력할 수 있음
InputStreamReader reader = new InputStreamReader(in); // 입력값으로 InputStream 객체인 'in' 필요
char[] e = new char[3];
System.out.println("3byte짜리 배열 입력 - 그대로 출력");
reader.read(e);
System.out.println(e);
System.out.println();
// BufferedReader : 길이에 상관없이 모든 입력 받음
BufferedReader br = new BufferedReader(reader); // 입력값으로 InputStreamReader의 객체인 'reader' 필요
String f = br.readLine(); // readLine() : 사용자가 입력한 문자열 전부를 읽음
System.out.println("문자열 입력");
System.out.println(f);
// Scanner
Scanner sc = new Scanner(System.in);
System.out.println(sc.next()); // 한개의 토큰을 읽어 출력 (토큰 : 정보의 최소 단위)
// System.out.println(sc.nextLine()); // 한 라인을 읽어 출력
// System.out.println(sc.nextInt()); // 정수를 읽어 출력
}
}
인터페이스의 역할도 하면서 클래스의 기능도 가지고 있는 클래스.
'abstract' 키워드를 사용해 선언해야 함
유사한 기능을 가지고 있으나, 추상 클래스는 일반 클래스처럼 객체변수, 생성자, private 메서드 등을 가질 수 있음
그러나 다중 상속은 불가능함!
추상클래스 사용 예
abstract class Predator extends Animal {
abstract String getFood();
void printFood() {
Systehttp://m.out.printf("my food is %s\n", getFood());
}
static int LEG_COUNT = 4;
static int speed() {
return LEG_COUNT * 30;
}
}
interface Barkable {
void bark();
}
class Animal {
String name;
void setName(String name) {
this.name = name;
}
}
class Tiger extends Predator implements Barkable {
public String getFood() {
return "apple";
}
public void bark(){
System.out.println("어흥");
}
}
class Lion extends Predator implements Barkable {
public String getFood() {
return "banana";
}
public void bark() {
System.out.println("으르렁");
}
}
class Zookeeper {
void feed(Predator predator){
System.out.println("feed "+ predator.getFood());
}
}
class Bouncer {
void barkAnimal(Barkable animal) {
animal.bark();
}
}
public class Day17 {
public static void main(String[] args) {
Zookeeper zookeeper = new Zookeeper();
Tiger tiger = new Tiger();
Lion lion = new Lion();
tiger.printFood();
zookeeper.feed(tiger); //feed apple 출력
System.out.println();
lion.printFood();
zookeeper.feed(lion); // feed banana 출력
System.out.println();
Predator.speed();
System.out.println(Predator.LEG_COUNT);
System.out.println();
Bouncer bouncer = new Bouncer();
tiger.bark();
zookeeper.feed(tiger);
lion.bark();
bouncer.barkAnimal(tiger);
}
}
하나의 객체가 여러 개의 자료형 타입을 가질 수 있는 것
>> 복잡한 형태의 분기문을 간단하고 효율적으로 처리할 수 있다.
1) 확장성 : 상위클래스나 인터페이스의 기능을 가지는 하위클래스를 생성하여 기존 코드를 변경하지 않고 확장할 수 있다.
2) 유지관리 용이 : 클래스 간의 결합도를 낮춰 코드가 유연해지므로 수정이 필요한 해당 클래스만 수정할 수 있음
3) 유연성 : 한 타입의 참조 변수로 여러 타입의 객체를 참조할 수 있음
Java에서 클래스는 다른 클래스를 다중 상속할 수 없고 오직 1개만 상속이 가능하다.
그러나 인터페이스는 다중 상속을 지원한다!
(예시)
interface BarkablePredator extends Barkable, Predator {
}
아래 코드에서,
Tiger클래스의 객체인 tiger는 여러 가지 자료형으로 표현할 수 있다.
Tiger tiger = new Tiger(); → Tiger is a Tiger
Animal animal = new Tiger(); → Tiger is a Animal
Predator predator = new Tiger(); → Tiger is a Predator
Barkable barkable = new Tiger(); → Tiger is a Barkable
interface Predator {
String getFood(); // 메서드 추가 (몸통이 없음)
default void printFood() { // 디폴트 메서드
System.out.printf("my food is %s\n", getFood());
}
int LEG_COUNT = 4; // 인터페이스 상수
static int speed() { // 스태틱 메서드
return LEG_COUNT * 30;
}
}
interface Barkable {
void bark();
}
interface BarkablePredator extends Barkable, Predator{
}
class Animal {
String name;
void setName(String name) {
this.name = name;
}
}
class Tiger extends Animal implements BarkablePredator {
public String getFood() {
return "apple";
}
public void bark(){
System.out.println("어흥");
}
}
class Lion extends Animal implements BarkablePredator {
public String getFood() {
return "banana";
}
public void bark() {
System.out.println("으르렁");
}
}
class Zookeeper {
void feed(Predator predator){
System.out.println("feed "+ predator.getFood());
}
}
class Bouncer {
void barkAnimal(Barkable animal) {
animal.bark();
}
}
public class Day17 {
public static void main(String[] args) {
Zookeeper zookeeper = new Zookeeper();
Tiger tiger = new Tiger();
Lion lion = new Lion();
tiger.printFood();
zookeeper.feed(tiger); //feed apple 출력
System.out.println();
lion.printFood();
zookeeper.feed(lion); // feed banana 출력
System.out.println();
Predator.speed();
System.out.println(Predator.LEG_COUNT);
System.out.println();
Bouncer bouncer = new Bouncer();
tiger.bark();
zookeeper.feed(tiger);
lion.bark();
bouncer.barkAnimal(tiger);
}
}
interface Predator {
void sleep();
String getFood();
}
클래스가 가져야 할 구조를 정의하는 추상 타입
클래스를 생성할 때마다 그 안에 공통적인 특성을 넣어야 할 때 효율적으로 사용할 수 있다.
- 여러 클래스가 같은 방식으로 동작하도록 강제하고 싶을 때
- 클래스를 사용하는 쪽과 구현하는 쪽을 구분하여 독립시키고 싶을 때
- 여러 클래스 사이에서 공통적인 특성을 추출하고 싶을 때
- 인터페이스는 "규칙"이다!
- 메서드와 상수만 정의될 수 있고, 항상 public으로만 선언된다.
- 메서드도 메서드명과 반환타입 정도만 "규정" 할 수 있다.
디폴트 메서드
인터페이스를 구현하는 클래스들이 공통으로 사용할 수 있게 해준다.
인터페이스에 해당 메서드를 만들어두면, 각 클래스에서 구현하지 않아도 사용이 가능한 메서드.
스태틱 메서드
인터페이스 이름으로 직접 호출할 수 있는 메서드이다.
인터페이스명.스태틱메서드명 으로 호출 가능
interface Predator {
String getFood(); // 메서드 추가 (몸통이 없음)
default void printFood() { // 디폴트 메서드
Systehttp://m.out.printf("my food is %s\n", getFood());
}
int LEG_COUNT = 4; // 인터페이스 상수
static int speed() { // 스태틱 메서드
return LEG_COUNT * 30;
}
}
class Animal {
String name;
void setName(String name) {
this.name = name;
}
}
class Tiger extends Animal implements Predator {
public String getFood() {
return "apple";
}
}
class Lion extends Animal implements Predator {
public String getFood() {
return "banana";
}
}
class Zookeeper {
void feed(Predator predator){
System.out.println("feed "+ predator.getFood());
}
}
public class Day16 {
public static void main(String[] args) {
Zookeeper zookeeper = new Zookeeper();
Tiger tiger = new Tiger();
Lion lion = new Lion();
tiger.printFood();
zookeeper.feed(tiger); //feed apple 출력
lion.printFood();
zookeeper.feed(lion); // feed banana 출력
Predator.speed();
System.out.println(Predator.LEG_COUNT);
}
}
클래스의 인스턴스를 새롭게 생성할 때 사용되는 메서드의 일종
- 클래스명과 메서드명이 같음
- 반환 타입이 없음(void조차 없음)
인스턴스의 초기화 작업에 사용됨.
객체 생성 시 반드시 정해진 타입의 입력값을 받고자 할 때 사용
(예시)
Dog(String name) { → Dog자료형의 객체 생성 시 문자열로 된 이름을 반드시 입력하도록 강제
this.setName(name);
}
....생략....
Dog dog1 = new Dog("Geun"); → main 메서드에서 dog1 개체 생성 시 이름을 반드시 넣어 생성해야함
생성자의 받을 입력항목이 없고 생성자 내부에도 아무런 코드가 없는 생성자
클래스에 생성자가 없을 때, 컴파일러가 자동으로 만드는 생성자임
클래스 내부에 생성자가 있을 때, 입력값이 없는 인스턴스를 새로 정의할 수 없음.
사용하기 위해서는 직접 디폴트생성자를 만들어 주어야 함
(예시)
Dog() { → 입력항목도 없고, 내부에도 아무 내용이 없음
}
받을 입력값을 다르게 한다면, 같은 이름의 생성자를 여러 개 만들 수있음
(예시)
class Dog extends Animal {
Dog(String name) { → 문자열 타입 생성자 Dog
this.setName(name);
}
Dog(int type){ → 정수 타입 생성자 Dog
if (type==1) {
this.setName("Yorkshire");
} else if (type==2) {
this.setName("bulldog");
}
class Vehicle{
String name;
void setName(String name) {
this.name = name;
}
}
class Car extends Vehicle {
void run() {
System.out.println(this.name + " is running");
}
}
class Benz extends Car {
void run() {
System.out.println(this.name + " is running on the road");
}
void run(int hour) {
System.out.println(this.name + " is running for " + hour + " hours on the road");}
Benz(String name) { // 생성자 : 클래스명과 동일하고 void 형태인 메서드=
this.setName(name);
}
Benz(int grade) {
if(grade == 1) {
this.setName("S Class");
} else if(grade == 2) {
this.setName("E Class");
} else if(grade == 3) {
this.setName("C Class");
}
}
}
public class Day15 {
public static void main(String[] args) {
Benz benz = new Benz("Pang");
benz.run();
benz.run(3);
System.out.println(benz.name);
System.out.println();
Benz eClass = new Benz(2);
System.out.println(eClass.name);
System.out.println();
benz.setName("Benz S class");
benz.run();
benz.run(3);
System.out.println(benz.name);
}
}
자식 클래스가 부모 클래스의 기능을 그대로 물려받을 수 있는 기능.
자식클래스에 굳이 메서드를 넣지 않아도 자식 클래스의 인스턴스를 생성 하고 부모클래스의 메서드 사용 가능
>> 자식클래스에서 부모클래스의 기능에 더하여 더 많은 기능을 갖도록 만들 수 있음
class 자식클래스명 extends 부모클래스명 {
}
상속 관계를 의미함.
자식클래스의 객체는 부모클래스의 자료형인 것처럼 사용 가능
(예시)
Animal : 부모클래스, Dog : 자식클래스 일떄
Animal dog = new Dog(); → Dog is a Animal (O)
Dog dog = new Animal(); → Animal is a Dog (X)
자식클래스가 우선!!
부모클래스와 자식클래스에 같은 이름의 메서드가 정의되었을 때, 메서드를 호출하면 자식클래스의 메서드가 작동한다.
같은 이름의 메서드라도 받는 입력값의 형태가 다르면 같은 클래스 안에 생성 가능
하나의 클래스가 둘 이상의 클래스를 상속받을 수 없음
class A extends B, C { → 불가능
}
/* 5-5 상속\
"extends" 자식 클래스가 부모 클래스의 기능을 그대로 물려받을 수 있는 기능 */
class Animal {
String name; // 객체변수 생성
void setName(String name) { → 메서드(setName) 생성, 입력값 문자열
this.name = name; → 객체의 객체변수값에 이름 저장
}
}
class Dog extends Animal { → Animal 클래스를 상속한다
void sleep() {
System.out.println(this.name+" zzz");
}
}
class HouseDog extends Dog {
void sleep(){
System.out.println(this.name+" zzz in house");
}
void sleep(int hour){
System.out.println(this.name+" zzz in house for " + hour + " hours");
}
}
public class Day14_2 {
public static void main(String[] args) {
Dog dog = new Dog();
dog.setName("poppy");
System.out.println(dog.name);
dog.sleep();
HouseDog houseDog = new HouseDog();
houseDog.setName("happy");
houseDog.sleep(); → 메소드 오버라이딩 : 자식 클래스의 메서드가 더 우선순위 >> zzz in house 출력
houseDog.sleep(3); → 메서드 오버로딩 : 같은 메서드명에서도 입력값에 차이를 두어 생성 가능
>> zzz in house for 3 hours 출력
}
}
메서드 호출 시, 입력값으로 값을 전달하는 것과 객체를 전달하는 것의 차이가 있다.
class Updater {
void update(int count) { → update라는 메서드를 생성 (입력값으로 정수값을 전달받음)
count++; → 전달받은 값에 +1
}
}
class Counter {
int count = 0; →객체변수 생성
}
public class Day14 {
public static void main(String[] args) {
Counter myCounter = new Counter(); → Counter클래스의 인스턴스인 myCounter 생성
System.out.println("before update:"+myCounter.count); → myCounter객체의 객체변수값 호출 = 0
Updater myUpdater = new Updater(); →Updater 클래스의 인스턴스인 myUpdater 생성
myUpdater.update(myCounter.count); →update메서드 호출 (입력값 myCounter.count = 0 )
System.out.println("after update:"+myCounter.count);
→ myCounter의 객체변수 자체를 넣은 것이 아닌 myCounter의 객체변수의 값만을 사용한 것이므로,
myCounter.count값은 그대로 0
}
}
>>실행결과 :
before update:0
after update:0
class Updater {
void update(Counter counter) { → update라는 메서드를 생성 (입력값으로 객체 자체를 전달받음)
counter.count++; → 객체의 객체변수값 자체를 +1
}
}
class Counter {
int count = 0; → 객체변수 생성
}
public class Day14 {
public static void main(String[] args) {
Counter myCounter = new Counter(); → Counter클래스의 인스턴스인 myCounter 생성
System.out.println("before update:"+myCounter.count); → myCounter객체의 객체변수값 호출 = 0
Updater myUpdater = new Updater(); → Updater 클래스의 인스턴스인 myUpdater 생성
myUpdater.update(myCounter); → update메서드 호출 (입력값 myCounter)
System.out.println("after update:"+myCounter.count);
}
}
>>실행결과 :
before update:0
after update:1
클래스 안에 존재하며, 코드들의 집합.
즉 함수라고 생각하면 됨.
다른 언어에는 함수와 메서드가 구분되나, 자바에서는 클래스 밖에 존재하는 것이 없으므로 구분하지 않음
명칭 확실히 구분할 것!
매개변수 : 메서드에 넣을 입력값을 저장하는 변수 (int a, int b)
인 수 : 메서드를 호출할 때 넣는 입력값 (3, 4)
리턴자료형 메서드명(입력자료형1 매개변수1, 입력자료형2 매개변수2, ...) {
수행할 코드 1;
수행할 코드 2;
....
return 리턴값;
}
1) 입력값 O, 리턴값 O : 메서드 만들 때 리턴자료형 넣어줌, 마지막에 return 코드 사용
int sum(int a, int b) {
return a+b;
}
2) 입력값 X, 리턴값 O : 입력값에 빈칸, return코드 및 리턴자료형 사용
String say() {
return "Hi";
}
3) 입력값 O, 리턴값 X : 리턴자료형 void 사용
void sum(int a, int b) {
System.out.println("a와 b의 합은 "+(a+b)+"입니다.");
}
4) 입력값 X, 리턴값 X
void say() {
System.out.println("Bye");
}
※ void 인 메서드(=리턴값이 없는 메서드)에서는 중간에 return; 사용 시 마치 break;처럼 해당 메서드를 빠져나옴
public class Day13 {
/* 5-3 메서드 더 알아보기
구조 :
리턴자료형 메서드명(입력자료형1 매개변수1, 입력자료형2, 매개변수2, ...) {
...
return값; */
int a;
void varTest(Day13 sample) {
sample.a++;
}
void varTest1() {
this.a++; // 굳이 입력값으로 객체를 안 받고 this를 활용할 수도 있음
}
// 입력값O 리턴값O 메서드
int sum(int a, int b) { //a, b는 매개변수
return a+b;
}
// 입력값X 리턴값O 메서드
String open() {
return "Hi";
}
// 입력값O 리턴값X
void multi(int a, int b) {
System.out.println(a+"과 "+b+"의 곱은 "+ (a*b) + "입니다.");
}
// 입력값X 리턴값X
void close(){
System.out.println("Bye");
}
// return의 또 다른 쓰임 : void메서드에서 return; 만 사용 시 해당 메서드를 즉시 빠져나감
void sayNick(String nick) {
if("바보". equals(nick)) {
return;
}
System.out.println("나의 별명은 "+nick+"입니다.");
}
//리턴값 없이 값만 1 증가했으므로 main 메서드값에 영향 X
void varTest(int d) {
d++;
}
public static void main(String[] args) {
int a = 3;
int b = 4;
Day13 sample = new Day13();
int c = sample.sum(a, b);
System.out.println(c); // 입력값O 리턴값O
System.out.println();
String result = sample.open(); // 입력값X 리턴값O
System.out.println(result);
System.out.println();
sample.multi(a, b); //입력값O 리턴값X
System.out.println();
sample.close(); //입력값X 리턴값X
System.out.println();
sample.sayNick("야호");
sample.sayNick("바보"); // 출력되지 않음
System.out.println();
int d = 1;
sample.varTest(d);
System.out.println(d);
System.out.println();
sample.a = 1; //객체변수에 접근하여 1 값을 대입
sample.varTest(sample); // varTest메서드에 입력값으로 sample객체 넣음 >> sample의 객체변수 a에 1 더해짐
System.out.println(sample.a); // 2 출력
}
}