풀스택 개발자 과정 46일차

SuperTest

package Day09;

class A {
    A(int a) {

    }
}

class B extends A {
    B() {
        super(5); // 부모 생성자 호출
    }
}

public class SuperTest {
}

AbstractClassTest

package Day09;

abstract class P {
    // 멤버 변수
    int a;
    // 일반 메서드
    void print() {
        System.out.println("출력합니다.");
    }
    abstract void abc(); // 추상 메서드
}

class C extends P {
    void abc() {

    }
}

public class AbstractClassTest {
    static void main() {
        // P p = new P(); // 에러가 난다.

        C c = new C(); // 문제가 없다.

        P p1 = new C();
    }
}

InterfaceTest

package Day09;

interface Pi {
    void abc();
    int def(int a);
    String print(String str);
}

interface Pi1 {
    void kor();
}

class Ci implements Pi, Pi1 {
    public void abc() {

    }
    public int def(int a) {
        return 5;
    }
    public String print(String str) {
        return "hello";
    }

    public void kor(){

    }
}

public class InterfaceTest {
    static void main() {
        Pi pi = new Ci(); // 참조자료형변환
    }
}

Q1

package Day09;

import java.util.Random;

// 동물 - 색깔, abstract talk()
abstract class Animal {
    String color;
    Animal() {
        Random r = new Random();
        String[] colors = {"빨간색", "파란색", "노란색", "초록색", "파란색", "남색", "보라색"};
        color = colors[r.nextInt(colors.length)];
    }
    abstract void talk();
}
// 강아지(동물) talk 오버라이딩
class Dog extends Animal {
    @Override
    void talk() {
        System.out.println("나는 " + color + " 강아지 입니다.");
    }
}
// 고양이(동물) talk 오버라이딩
class Cat extends  Animal {
    @Override
    void talk() {
        System.out.println("나는 " + color + " 고양이 입니다.");
    }
}
// 미어캣(동물) talk 오버라이딩
class Miacat extends  Animal {
    @Override
    void talk() {
        System.out.println("나는 " + color + " 미어캣 입니다.");
    }
}
// 판다(동물) talk 오버라이딩
class Panda extends  Animal {
    @Override
    void talk() {
        System.out.println("나는 " + color + " 판다 입니다.");
    }
}
public class Q1 {
    static void main() {
        Animal[] woori = new Animal[10];
        Random r = new Random();
        for (int i = 0; i < woori.length; i++) {
            int select = r.nextInt(4); // 0, 1, 2, 3
            if (select == 0) {
                woori[i] = new Dog();
            } else if (select == 1) {
                woori[i] = new Cat();
            } else if (select == 2) {
                woori[i] = new Miacat();
            } else {
                woori[i] = new Panda();
            }
        }
        for (int i = 0; i < woori.length; i++) {
            woori[i].talk();
        }
    }
}

AbstractTest

package Day09;

// 태그 # interface 다중상속 가능해서
interface Repairable {}
interface Heal{}

class Unit {
    int attack;
    int hitPoint;
    final int MAX_HP; // 상수

    Unit(int hp, int attack) {
        MAX_HP = hp;
        this.attack = attack;
    }
}

class GroundUnit extends Unit {
    GroundUnit(int hp, int attack) {
        super(hp, attack);
    }
}

class AirUit extends Unit {
    AirUit(int hp, int attack) {
        super(hp, attack);
    }
}

class Marine extends GroundUnit implements Heal {
    Marine() {
        super(40, 6);
        hitPoint = MAX_HP;
    }
}

class Medic extends GroundUnit implements Heal {
    Medic() {
        super(80, 0);
        hitPoint = MAX_HP;
    }
    // 힐을 가지고 있는 객체만 통과 시킨다.
    void heal(Heal h) {
        if (h instanceof Unit) {
            Unit u = (Unit)h; // 참조자료형 변환
            if (u != null && u.MAX_HP != u.hitPoint) {
                u.hitPoint += 2;
            }
        }
    }
}

class Tank extends GroundUnit implements Repairable {
    Tank() {
        super(150, 10);
        hitPoint = MAX_HP;
    }
    //
    public String toString() {
        return "Tank";
    }
}

class SCV extends GroundUnit implements Repairable {
    SCV() {
        super(60, 5);
        hitPoint = MAX_HP;
    }
    void repair(Repairable r) {
        if (r instanceof Unit) {
            Unit u = (Unit) r; // 참조 자료형 변환
            if (u != null && u.MAX_HP != u.hitPoint) {
                u.hitPoint +=2;
            }
        }
    }
}

public class AbstractTest {
    static void main() {
        Tank tank = new Tank();
        Marine marine = new Marine();
        SCV scv = new SCV();
        Medic medic = new Medic();

        scv.repair(tank); // 된다.
        medic.heal(marine); // 된다.
        // scv.repair(marine); // 에러
        // medic.heal(tank); // 에러

        System.out.println(medic);

    }
}

GenericTest

package Day09;

class Box<T> {
    T vol;

    void setVol(T v) {
        vol = v;
    }
    T getVol() {
        return vol;
    }
}

public class GenericTest {
    static void main() {
        Box<Integer> ibox = new Box<>();
        ibox.setVol(200);
        System.out.println(ibox.getVol());
        Box<Double> dbox = new Box<>();
        dbox.setVol(2.78);
        System.out.println(dbox.getVol());
        Box<String> sbox = new Box<>();
        sbox.setVol("안녕하세요");
        System.out.println(sbox.getVol());
    }
}

ListTest1

package Day09;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class ListTest1 {
    static void main() {
        // TODO Auto-generated method stub
        String[] name = {"kim", "lee", "park", "jung", "oh"}; // 문자열 배열
        // 배열리스트 객체를 만드는 데이터 값으로 String[] name
        ArrayList<String> lname = new ArrayList<>(Arrays.asList(name));
        System.out.println("초기 값: " + lname);
        lname.add("ha");
        System.out.println("\"ha\" 추가된 후의 값: " + lname);
        lname.set(0, "김");
        lname.set(3, "곽");
        System.out.println("\"김\"으로 변경되고 \"곽\"이 추가된 값: " + lname);
        Collections.shuffle(lname);
        System.out.println("shuffle() 메서드가 적용된 값: " + lname);
        Collections.sort(lname);
        System.out.println("sort() 메서드가 적용된 값: " + lname);
        System.out.println("5번째 요소의 값: " + lname.get(4));
        Collections.fill(lname, "김");
        System.out.println("모든 요소를 \"김\" 으로 설정된 값: " + lname);
    }
}

ListTest2

package Day09;

import java.sql.Array;
import java.util.ArrayList;

class KOR {
    int a;
    int b;
    KOR(int a, int b) {
        this.a = a;
        this.b = b;
    }
    void print() {
        System.out.println("a: " + a + " b: " + b);
    }
}

public class ListTest2 {
    static void main() {
        ArrayList<KOR> list = new ArrayList<>();
        list.add(new KOR(1, 3));
        list.get(0).a = 30;
        list.get(0).print(); // a: 30 b: 3

        // list.get(1).a = 40;

        for (int i = 0; i < 10; i++) {
            list.add(new KOR(i, i+i));
        }

        for (int i = 0; i < list.size(); i++) {
            list.get(i).print();
        }
    }
}

SetTest1

package Day09;

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;

public class SetTest1 {
    static void main() {
        // TODO Auto-generated method stub
        HashSet<Integer> odd = new HashSet<Integer>();
        HashSet<Integer> even = new HashSet<Integer>();

        for (int i = 0; i < 5; i = i+2) {
            odd.add(i);
            even.add(i+1);
        }

        boolean setChanged = odd.add(5);
        System.out.println("odd에 5 추가 성공?: " + setChanged);
        setChanged = even.add(12);
        System.out.println("even에 12 추가 성공?: " + setChanged);
        System.out.println("odd 집합: " + odd);
        System.out.println("even 집합: " + even);
        System.out.println("odd에서 가장 작은 값은: " + Collections.min(odd));
        System.out.println("even에서 가장 작은 값은: " + Collections.min(even));

        // set은 인덱스 순서가 없어서
        // 반복을 돌리면 iterator를 사용해야 한다.
        Iterator<Integer> it = even.iterator();
        int sum = 0;
        while (it.hasNext()) {
            sum = sum + it.next();
        }
        System.out.println("even 집합의 합은: " + sum);
    }
}

SetTest2

package Day09;

import java.util.HashSet;
import java.util.Iterator;

public class SetTest2 {
    static void main() {
        HashSet<KOR> set = new HashSet<>();
        set.add(new KOR(5, 6));
        set.add(new KOR(7,8));
        Iterator<KOR> it = set.iterator();
        int num = 1;
        while (it.hasNext()) {
            KOR kor = it.next();
            if (kor.a == 8 || kor.b == 8) {
                System.out.println(num + "번째 있습니다.");
            }
            num++;
        }
    }
}

Q2

package Day09;

import java.util.ArrayList;
import java.util.Scanner;

class PhoneData{
    String name;
    String tel;
    String addr;
    String age; // 20세

    PhoneData(String name, String tel, String addr, String age){
        this.name = name;
        this.tel = tel;
        this.addr = addr;
        this.age = age;
    }
}


public class Q2 {
    static void main() {
        //문제점 1번 -> 중복된 이름 이거에 대한 해결
        //문제점 2번 -> 전체출력 바로 시전 아무것도 안나와요
        //1. 입력
        Scanner sc = new Scanner(System.in);
        //2. List
        ArrayList<PhoneData> telList = new ArrayList<>();

        while(true){
            System.out.print("1.추가 2.삭제 3.전체출력 4.이름검색 5.종료 : ");
            int num = sc.nextInt();
            if(num == 1){
                System.out.print("이름:");
                String name = sc.next();
                System.out.print("전화번호:");
                String tel = sc.next();
                System.out.print("주소:");
                String addr = sc.next();
                System.out.print("나이:");
                String age = sc.next();
                telList.add(new PhoneData(name,tel,addr,age));
                System.out.println(name+"을 추가했습니다.");
            }
            else if(num == 2){
                System.out.print("이름 : ");
                String name = sc.next();
                // 공부하세요
                ArrayList<Integer> checkList = new ArrayList<>();
                for(int i = 0;i<telList.size();i++){
                    if(telList.get(i).name.equals(name)){
                        checkList.add(i);
                    }
                }
                if(checkList.size() == 0){
                    System.out.println("삭제할 이름이 없습니다.");
                }
                else{
                    for(int i = checkList.size()-1;i>=0;i--){
                        System.out.println(telList.get(checkList.get(i)).name+"삭제 했습니다.");
                        //System.out.println(checkList.get(i));
                        telList.remove(checkList.get(i).intValue());
                        //telList.remove(0);
                    }
                }
            }
            else if(num == 3){
                if(telList.size() == 0){
                    System.out.println("전화번호부가 없습니다.");
                    continue;
                }
                for(int i = 0;i<telList.size();i++){
                    System.out.println("이름 : "+telList.get(i).name+", 전화번호 : "+telList.get(i).tel+
                                ", 주소 : "+telList.get(i).addr+", 나이 : "+telList.get(i).age);

                }
            }
            else if(num == 4){
                System.out.print("이름 : ");
                String name = sc.next();
                boolean check = true;
                for(int i = 0;i<telList.size();i++){
                    if(telList.get(i).name.equals(name)){
                        System.out.println("이름 : "+telList.get(i).name+", 전화번호 : "+telList.get(i).tel+
                                ", 주소 : "+telList.get(i).addr+", 나이 : "+telList.get(i).age);
                        check = false;
                    }
                }
                if(check){
                    System.out.println("찾는 이름이 없습니다.");
                }
            }
            else if(num == 5){
                System.out.println("프로그램을 종료합니다.");
                break;
            }
            else{
                System.out.println("잘못된 입력입니다.");
            }
        }
    }
}

개인 공부

Q1

package Practice5;

/*
    [인터페이스 기초]

    - Animal 인터페이스 생성
    - sound() 메서드 선언
    - Dog 클래스에서 implements
    - sound() 오버라이딩 ("멍멍")
    - main()에서 객체 생성 후 sound() 호출
*/

// 인터페이스 선언
interface Animal {
    // 추상 클래스
    void sound();
}

class Dog implements Animal {
    // 오버라이딩
    @Override
    public void sound() {
        System.out.println("멍멍");
    }
}

public class Q1 {
    static void main() {
        Dog dog = new Dog();

        dog.sound();
    }
}

Q2

package Practice5;

/*
    [인터페이스 기초 2]

    - Moveable 인터페이스 생성
    - move() 메서드 선언
    - Car, Person 클래스에서 implements
    - 각자 다른 내용 출력
    - main()에서 두 객체 생성 후 move() 호출
*/

interface Moveable {
    void move();
}

class Car implements Moveable {
    @Override
    public void move() {
        System.out.println("자동차가 달립니다.");
    }
}

class Person implements Moveable {
    @Override
    public void move() {
        System.out.println("사람이 걷습니다.");
    }
}

public class Q2 {
    static void main() {
        Car c1 = new Car();
        Person p1 = new Person();

        c1.move();
        p1.move();
    }
}

Q3

package Practice5;

/*
    [인터페이스 활용]

    - Animal 인터페이스 생성
    - sound() 메서드 선언

    - Dog 클래스 구현 ("멍멍")
    - Cat 클래스 구현 ("야옹")

    - Animal 타입의 변수로
      Dog 객체와 Cat 객체를 각각 저장

    - sound() 호출
*/

interface Animal1 {
    void sound();
}

class Dog1 implements Animal1{
    public void sound() {
        System.out.println("멍멍");
    }
}

class Cat1 implements Animal1{
    public void sound() {
        System.out.println("야옹");
    }
}

public class Q3 {
    static void main() {
        Animal1 a1 = new Dog1();
        Animal1 a2 = new Cat1();

        a1.sound();
        a2.sound();
    }
}

Q4

package Practice5;

interface Animal2 {
    void sound();
}

class Dog2 implements Animal2 {
    public void sound() {
        System.out.println("멍멍");
    }
}

class Cat2 implements Animal2 {
    public void sound() {
        System.out.println("야옹");
    }
}

public class Q4 {
    static void playSound(Animal2 animal2) {
        animal2.sound();
    }
    static void main() {
        Dog2 dog2 = new Dog2();
        Cat2 cat2 = new Cat2();

        playSound(dog2);
        playSound(cat2);
    }
}

Q5

package Practice5;

/*
    [추상 클래스 기초]

    - Animal 추상 클래스를 만든다.
    - name 필드를 만든다.
    - eat() 일반 메서드를 만든다.
      → "먹이를 먹습니다." 출력

    - sound() 추상 메서드를 만든다.

    - Dog 클래스는 Animal 상속
      → sound() 오버라이딩
      → "멍멍" 출력

    - main()에서 Dog 객체 생성
    - eat(), sound() 호출
*/

// 추상 클래스
abstract class Animal3 {
    // 이름
    String name;
    // 일반 메서드
    void eat() {
        System.out.println("먹이를 먹습니다.");
    }
    // 추상 메서드
    abstract void sound();
}

class Dog3 extends Animal3 {
    // 오버라이딩
    @Override
    public void sound() {
        System.out.println("멍멍");
    }
}

public class Q5 {
    static void main() {
        // 객체 생성
        Dog3 dog3 = new Dog3();

        // 불러오기
        dog3.sound();
        dog3.eat();
    }
}

Q6

package Practice5;

abstract class Shape {
    String name;
    abstract void draw();
}

class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("원을 그린다.");
    }
}

class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("사각형을 그린다.");
    }
}

public class Q6 {
    static void main() {
        Shape a1 = new Circle();
        Shape a2 = new Rectangle();

        a1.draw();
        a2.draw();
    }
}

마무리

오늘은 추상과 List에 대해 배웠다.
아직 좀 많이 어려워서 개인 공부를 많이 해야 될 거 같다.