231220 Java

자바 인터페이스

package com.poseidon.inter;
// 인터페이스
/* 자바 기초, 제어문, || 객체 지향 프로그래밍 -> 클래스, 메소드, 상속, 추상화
 * 자료 구조 : R/P 타입, 배열, 스트링, SB
 * 알고리즘 :
 *
 * 상속 -> 추상화 -> 인터페이스
 *    class        interface
 *   단일상속        다중상속
 *
 *
 * 인터페이스는 다른 언어에서 찾기 힘든 자바의 고급 기능
 * 왜, 어떻게 사용하는지, 특징 설명
 *
 * 인터페이스 란 ?
 *  클래스 : 일반 메소드를 가질 수 있음
 *  추상 클래스 : 일반 메소드와 추상 메소드를 가질 수 있음
 *  인터페이스 : 오직 추상 메소드만 가질 수 있음
 *  인터페이스 내에 존재하는 메소드는 무조건 public abstract 로 선언 (abstract 는 제외 가능)
 *  인터페이스 내에 존재하는 변수는 무조건 public static final 로 선언
 * 
 * 인터페이스 내에 가질 수 있는 것 : 추상 메소드, 상수
 * 
 * 인터페이스는 다중 상속과 비슷한 기능을 제공
 * 
 * interface 인터페이스명 {
 *      void 추상 메소드(); // 바디가 없음 = 구현부가 없음
 * }
 * class 클래스명 implements 인터페이스명 {
 *      인터페이스에 있는 미구현 메소드 오버라이드 (필수)
 * }
 * 
 * 상속과 인터페이스의 차이점
 *  상속 : class A extends B
 *        B 라는 클래스를 상속받아 A 의 기능을 더함
 *  순수 상속, 부모로부터 모든 권한과 재산 능력을 가져옴
 *  ----------------------------------------------
 *  인터페이스 : class A implements B
 *             B 라는 인터페이스를 구현
 *  권한 상속, 인터페이스만 가져오기 : 비어있는 것을 가져와 속을 채워 완성하는 느낌
 */
// 인터페이스 만들기
interface Do {
    // 메소드 : 인터페이스가 가지는 메소드는 모두 추상 메소드
    public abstract void attack();
    // public abstract void play() { System.out.println("플레이"); } // 메소드가 완성되면 안됨
    public void play();
}
abstract class Hero { // 추상 클래스 = 미완성된 클래스
    String name;
    public abstract void attack(); // 추상 메소드 = 미완성된 메소드
}
class Superman extends Hero implements Do{
    @Override // 부모의 메소드를 자식이 재정의하여 자신이 원하는 내용으로 수정
    public void attack() { // 바디만 ({}) 열어도 수정한 것으로 봄

    }
    @Override
    public void play() {

    }
}

public class Inter01 {
}

 

자바 상속과 인터페이스 활용하기

package Zoo;
// 클래스 1 번
public class Animal {
    String name;
    int age;
    public void setName(String name) { // 이름 저장
        this.name = name;
    }
}

package Zoo;
// 인터페이스
public interface Predator {
    public abstract String getName(); // 이름 불러오기, 추상 메소드
    // 바디가 없음, 구현할 수 없음
}

package Zoo;
// 클래스 2 번
public class Dog extends Animal implements Predator{
    @Override
    public String getName() {
        return name;
    }
}

package Zoo;
// 클래스 3 번
public class Cat extends Animal implements Predator{
    @Override
    public String getName() {
        return name;
    }
}

package Zoo;
// 클래스 4 번
public class Mouse extends Animal implements Predator{
    @Override
    public String getName() {
        return name;
    }
}

package Zoo;
// 클래스 5 번
public class ZooTrainer {
    // 밥주기 기능
    public void feed(Predator predator) {
        System.out.println(predator.getName() + " 에게 먹이를 줍니다.");
    }
}

package Zoo;

public class Zoo {
    public static void main(String[] args) {
        ZooTrainer zooTrainer = new ZooTrainer();
        Dog dog = new Dog();
        dog.setName("3PO");
        zooTrainer.feed(dog); // 3PO 에게 먹이를 줍니다. 출력
        Cat cat = new Cat();
        Mouse mouse = new Mouse();
        cat.setName("야옹이");
        mouse.setName("찍찍이");
        zooTrainer.feed(cat); // 야옹이 에게 먹이를 줍니다.
        zooTrainer.feed(mouse); // 찍찍이 에게 먹이를 줍니다.
    }
}

 

Is a, Has a

/*
 * 상속 관계 중 is a, has a 관계가 있음
 * 
 * 말 그대로 is a -> ~ 는 ~ 다.
 *          has a -> ~ 는 ~ 를 가지고 있다.
 * 
 * class Human {
 *      String name;
 *      int age;
 * }
 * 
 * class Student extends Human {
 *      int number;
 *      int major;
 * }
 * 
 * Student 클래스가 Human 클래스를 상속 받고 있음
 * 학생은 사람이다.
 * 
 * class Gun {
 *      String name;
 *      int shot;
 * }
 * 
 * class Police {
 *      Gun gun; // 멤버 객체로 총을 가져감
 * }
 * 
 * 경찰은 총을 가지고 있음
 * Police 클래스 안에 Gun 클래스 객체를 멤버로 가지고 있는 경우 has a
 */
public class IsAHasA {
    
}

 

 메모리 구조

package memory;
// 메모리 구조
/*
 * 중요 : 호출 스택은 예외처리 할 때 필요
 *
 * 메소드 영역 : 클래스 데이터 (클래스 변수)
 *             프로그램 실행 중 어떤 클래스가 사용되면 JVM 은 해당 클래스 파일을 읽어
 *             클래스 데이터를 이곳에 저장, 동시에 클래스 변수도 이곳에 생성
 *
 * 호출 스택 : 메인 메소드 (지역 변수)
 *           메소드가 작업에 필요한 메모리 공간을 제공
 *           메소드가 호출되면 호출 스택에 메소드 활용을 위한 메모리가 할당
 *           메모리에서 메소드가 작업을 수행하는 동안 지역 변수와 연산의 중간 결과가 저장
 *           메소드가 작업을 마치면 할당되었던 메모리 공간은 반환 - > 비워짐
 *           호출 스택은 제일 상위에 있는 메소드가 지금 실행중인 메소드
 *           나머지는 모두 대기, 언제나 호출 스택 최상위에 있는 메소드가 현재 실행 중인 메소드
 *           아래에 있는 메소드는 바로 위에 있는 메소드를 호출한 메소드
 *
 * 힙 : 인스턴스가 생성되는 공간
 *     인스턴스 변수
 *
 * 리턴 타입이 있는 메소드는 종료되기 직전 자신을 호출한 메소드에게 결과 값을 반환
 * 대기하고 있는 호출 메소드가 값을 받아 프로그램을 진행
 */
public class Memory {
    public static void main(String[] args) {
        System.out.println("main method start");
        System.out.println("메인 메소드 작업 중");
        first();
        System.out.println("main method end");
    }
    static void first() {
        System.out.println("first method start");
        System.out.println("first 메소드 작업 중");
        second();
        System.out.println("first method end");
    }
    static void second() {
        System.out.println("second method start");
        System.out.println("second 메소드 작업 중");
        System.out.println("second method end");
    }
}
/* 출력 결과
main method start
메인 메소드 작업 중
first method start
first 메소드 작업 중
second method start
second 메소드 작업 중
second method end
first method end
main method end
 */

 

열거형 enum

package enumEx;
// 열거형 타입
/*
 * 열거한 값만 사용할 수 있음
 * static final 값 = 상수, 대문자로 작성
 * enum 은 클래스 이름과 중복될 수 없고 같은 값을 가질 수 없음
 */
public enum Week {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}