반응형
- C20인터페이스
- C2001인터페이스_개념
- 인터페이스_개념01_기본이론1
package C2001인터페이스_개념;
// 상속 , 추상화상속 , 인터페이스상속
//---------------------------------------------
//일반상속 / 자유롭게 가능
class TestA{
void test() {}
}
class TestB extends TestA{
}
//---------------------------------------------
// 일반 클래스도 다 되지만. 명시적으로 abstract interface 사용하는것 . 문법적으로
//---------------------------------------------
//abstract => 추상화 가능. 일반함수 가능
abstract class TestC{
abstract void test();//추상화로 만들 수 있고
void test2() {} //일반 함수도 만들 수 있따.
}
class TestD extends TestC{
@Override
void test() {}
}
//---------------------------------------------
//interface => 순수 추상화
//interface => 추상화만 된다. / 일반함수 못 만듬
//interface => 다중 상속도 된다.
interface TestE {
public void test();
public void test2(); //인터페이스는 앞에 퍼블릭을 붙여야 한다.
}
interface TestE2{
public void test3();
}
//---------------------------------------------
//인터페이스는 다중 상속도 된다.
class TestF implements TestE, TestE2{
@Override
public void test() {}
@Override
public void test2() {}
@Override
public void test3() {}
}
public class 인터페이스_개념01_기본이론1 {
public static void main(String[] args) {
}
}- interface
- 클래스 앞에 interface
- 메서드 앞에 public붙이기
- 완전히 순수하게 추상화만 가능
- 인터페이스_개념02_기본이론2
package C2001인터페이스_개념;
abstract class AA {
public abstract void test1(); // 추상화 클래스는 abstract 를 붙인것과
public void test2() {} // 안붙인 메서드를 섞어서 만들수있다.
}
class BB extends AA{
public void test1() {} // 자식클래스에서는 abstract 가붙어있는 메서드만은 강제구현해야한다.
}
interface EE{
public void test3();
}
interface CC{
public void test1();
public void test2();
}
class DD implements CC, EE { // interface 는 다중상속이 된다.
public void test1() {} // interface 를 상속하면 메서드를 무조건 강제구현한다.
public void test2() {}
public void test3() {}
}
// 인터페이스(Interface) 클래스
// 1. 부모 클래스앞에 interface 를 붙인다.
// 2. interface 상속은 extends 대신 implements 를 붙인다.
// 3. interface 는 다중상속이 가능하여, 여러 interface를 상속할 수 있다.
// 4. 추후에 웹에서 실습한다.
// 인터페이스는 추상클래스보다 더 추상화된 클래스 (전부 강제)
// 1. 실제 구현된 것이 전혀없는 기본 설계도.
// 2. 상수와 추상 메서드만 멤버로 갖는다.
// 3. 인스턴스를 생성할 수 없고, 클래스 작성에 도움을 줄목적으로 사용되는 클래스
// 4. 다중상속이 가능하다.
public class 인터페이스_개념02_기본이론2 {
public static void main(String[] args) {
}
}- 인터페이스_개념03_기본이론3
package C2001인터페이스_개념;
import java.util.Scanner;
interface Shape {
public void draw();
}
// Shape 클래스를 상속받아 Point 클래스를 만든다.
class Point implements Shape {
@Override
public void draw() {
System.out.println("점을 찍는다.");
}
}
// Shape 클래스를 상속받아 Line 클래스를 만든다.
class Line implements Shape {
@Override
public void draw() {
System.out.println("선을 그린다.");
}
}
// Shape 클래스를 상속받아 Circle 클래스를 만든다.
class Circle implements Shape {
@Override
public void draw() {
System.out.println("원을 그린다.");
}
}
// Shape 클래스를 상속받아 Rect 클래스를 만든다.
class Rect implements Shape {
@Override
public void draw() {
System.out.println("사각형을 그린다.");
}
}
// Shape 클래스를 상속받아 TriAngle 클래스를 만든다.
class TriAngle implements Shape {
@Override
public void draw() {
System.out.println("삼각형을 그린다.");
}
}
public class 인터페이스_개념03_기본이론3 {
public static void main(String[] args) {
// === 다형성 ===
// 서로 다른클래스는 배열에 저장불가능하기때문에
// 공통부모를 상속받고
// 부모의 클래스로 배열을 만들면 한배열에 서로다른클래스들을 저장할수있다.
/*
* # 다형성
* 1. 서로 다른 클래스는 배열에 저장이 불가능하기 때문에
* 2. 공통 부모를 상속받아
* 3. 부모 클래스로 배열을 만들면 한 배열에 서로 다른 클래스들을 저장할 수 있다.
*/
Shape[] shapes = {new Point(), new Line(), new Circle(), new Rect(), new TriAngle()};
Scanner sc = new Scanner(System.in);
System.out.print("원하는 작업을 선택하세요 : ");
int menu = sc.nextInt();
shapes[menu - 1].draw();
}
}- 인터페이스_개념04_RPG
package C2001인터페이스_개념;
import java.util.Random;
interface Skill {
public abstract void skill();
public abstract void skillAttack(Unit unit);
public abstract void attack(Unit unit);
}
class Unit implements Skill{
public int MAX_HP;
public int hp;
public int power;
public Unit(int hp, int power) {
MAX_HP = hp;
this.hp = MAX_HP;
this.power = power;
}
@Override
public String toString() {
return hp + "/" + MAX_HP;
}
@Override
public void skill() {}
@Override
public void skillAttack(Unit unit) {}
@Override
public void attack(Unit unit) {}
}
class Wolf extends Unit {
public int leg;
public int bite;
public Wolf(int leg, int bite) {
super(100, 10);
this.leg = leg;
this.bite = bite;
}
public void skill() {
power += leg + bite;
System.out.println("다리개수와 이빨개수만큼 공격력이 향상했다! power =" + power);
}
@Override
public void attack(Unit unit) {
Random ran = new Random();
int rNum = ran.nextInt(10) + 1;
unit.hp -= power;
unit.hp -= rNum;
System.out.println("Wolf가 기본 데미지 " + this.power + "을(를) 입혔습니다.");
System.out.println("Wolf가 추가 데미지 " + rNum + "을(를) 입혔습니다.");
}
@Override
public void skillAttack(Unit unit) {}
}
class Bat extends Unit {
public int fly;
public int poison;
public Bat(int fly, int poison) {
super(50, 5);
this.fly = fly;
this.poison = poison;
}
@Override
public void attack(Unit unit) {
unit.hp -= power;
System.out.println("Bat가 기본 데미지 " + this.power + "을(를) 입혔습니다.");
}
@Override
public void skill() {}
@Override
public void skillAttack(Unit unit) {
unit.hp -= power * 2;
System.out.println("Bat가 스킬 데미지 " + this.power * 2 + "을(를) 입혔습니다.");
}
}
public class 인터페이스_개념04_RPG {
public static void main(String[] args) {
/*
* # 다형성
* 1. 서로 다른 클래스는 배열에 저장이 불가능하기 때문에
* 2. 공통 부모를 상속받아
* 3. 부모 클래스로 배열을 만들면 한 배열에 서로 다른 클래스들을 저장할 수 있다.
*/
Unit[] unitList = new Unit[5];
Wolf wolf = new Wolf(3, 10);
unitList[0] = wolf;
unitList[0].skill();
Bat bat = new Bat(10, 15);
unitList[1] = bat;
unitList[0].attack(unitList[1]);
System.out.println(unitList[1]);
unitList[1].attack(unitList[0]);
}
}반응형