3/23 , 3/24

* 제네릭스

- ArrayList

 

   <>

# 제네릭 : 안에 어떠한 타입을 선언해주어, ArrayList, List등이 사용할 객체 타입을 지정해준다는뜻

다룰 객체의 타입을 미리 명시해 객체의 형변환을 사용할 필요 없게함.

내가 사용하고 싶은 데이터 타입만 사용할수있게해줌

 

# 메소드 return 타입 : 자료형, void가 올수있음.

자료형이 오면 반환(returen)해주는 값이 있어야하고 void는 값이 없다

반환하고자 하는 데이터가 있다면 데이터의 자료형을 메소드의 자료형으로 적어줘야함

 

# return문: 메소드 내에서 동작하고 얻은 결과(필요한 데이터)를 반환해주는 역할을 한다. return문 뒤에는 어떠한 구문도 올 수 없다.(컴파일 에러 발생) 다르게 말하면 return문을 사용하면 값을 반환해 주고 해당 메소드는 실행이 종료된다.

 

 

#메소드 호출

 

메소드명();

 

https://gangnam-americano.tistory.com/47 참고

// 데이터 추가
pizza.add("햄피자");
pizza.add("치즈피자");
pizza.add("새우피자");
pizza.add("고구마피자");
pizza.add("불고기피자");


    // 전체 삭제
    pizza.clear();
    if(pizza.isEmpty()) {
    System.out.println("메뉴 수 : " + pizza.size());
    System.out.println("메뉴가 비었습니다.");
    }

    메뉴 수 : 0
    메뉴가 비었습니다.


		// 새롭게 메뉴 정하기
        pizza.add("페페로니피자");
        pizza.add("햄피자");
        pizza.add("불고기피자");
        pizza.add("치즈피자");
        pizza.add("파인애플치자");

        // 정렬
        Collections.sort(pizza); // 정렬하기.sort(정렬하고싶은 데이터)
        for (String s : pizza) {
            System.out.println(s);
        }
    }
}

        불고기피자
        치즈피자
        파인애플치자
        페페로니피자
        햄피자

 

문제 2)

// 피자 주재료 정보

// 치즈피자 치즈
// 햄피자 고기
// 불고기피자 고기
// 파인애플피자 파인애플
// 치즈두배피자 치즈

// 고기가 들어간 피자
// 햄피자
// 불고기피자

import java.util.ArrayList;

public class _Quiz_09_2 {
    public static void main(String[] args) {
        ArrayList<pizza> manu = new ArrayList<>();
        manu.add(new pizza ("치즈피자","치즈"));
        manu.add(new pizza ("햄피자","고기"));
        manu.add(new pizza ("불고기피자","고기"));
        manu.add(new pizza ("파인애플피자","파인애플"));
        manu.add(new pizza ("치즈두배피자","치즈"));

        System.out.println("고기가 들어간 피자");
        System.out.println("-----------------");
        for(pizza pitza : manu) {
            if (pitza.ingredient.equals("고기")){
                // == equals와 같음 (String 배열로 ==을 사용 못해서 eqales 로 적어줌)
                System.out.println(pitza.name);
            }
        }
    }
}




class pizza {
    public String name; // 메뉴이름
    public String ingredient; // 재료
    // pizza 안에 넣을 것을 생성

    // △ 둘다 선택하여 alt+insert >> con선택하고 생성자 생성
    public pizza(String name, String ingredient) {
        this.name = name;
        this.ingredient = ingredient;
        // pizza 안에 name과 ingredient 의 자리 생성
    }
}

        고기가 들어간 피자
        -----------------
        햄피자
        불고기피자

 

* 익명 클래스

- 람다식

// 람다식
// (전달값1, 전달값2, ...) -> { 코드 }


    public void pizza() {
        String p = "피자";
        System.out.println(p);
     }
     
 				▽
    () -> {
        String p = "피자";
        System.out.println(p);
     }
    }
        // 접근제어자 public 팔요없음
        // 이름  pizza 필요없음
        // 자동리턴타입 정해줌 void 필요없음

    public void print (String p) {
        System.out.println(p);
    }
//				▽
    p -> System.out.println(p)
        // 문장이 1개만있을때 {중괄호} 없어도됨
        // 문장이 1개만있을때 맨끝 세미클론; 도없어도됨
        // 전달되는값을 미리 알수있기때문에 String 생략가능
        // 전달되는값이 1개일때 () 없어도됨

    public int add (int x, int y) {
        return  x + y;
    }
    
// 			▽
    (x, y) -> x + y
    // return 사용하면 {중괄호} 생략 불가.
    // return 제거하면, {중괄호} ; 제거

 

함수형 인터페이스 미쳤나~~

 

package chap_10;

import chap_10.converter.Convertible;
import chap_10.converter.KRWConverter;

public class _04_FunctionImterface_2 {
    public static void main(String[] args) {
    
    

// 여기에 Convertible 와 KRWConverter

        // conerter 는 여기에서 만든것 (class interface 아님)
        KRWConverter converter = new KRWConverter();

//        converter.convert(2);
//        // 2달러 반환하면?

        convertUSD(public void convert (int USD) {
//            // 1 달러 = 1400 원
            System.out.println(USD + " 달러 = " + (USD * 1400) + " 원");
        }, 2);
        // △ 람다식으로 바꾸면? ▽
                convertUSD((USD) -> System.out.println(USD + " 달러 = " + (USD * 1400) + " 원"), 1);
         // public 접근제어자 필요없음
        // convert 이름 필요없음
        // void 반환형 필요없음
        // int 파라미터 자료형 필요없음
        // 한줄일때 {중괄호} 세미클론; 필요없음
        
        1 달러 = 1400 원

       // Convertible(함수형인터페이스) 이라는것에 (USD) -> System.out.println(USD + " 달러 = " + (USD * 1400) + " 원")란 동작이 정의
        Convertible convertible = (USD) -> System.out.println(USD + " 달러 = " + (USD * 1400) + " 원");
        convertUSD(convertible,1);
        // convertUSD호출
    }
        1 달러 = 1400 원



    public static void convertUSD(Convertible converter, int USD) {
        converter.convert(USD);
    }
}

△ (USD) -> System.out.println(USD + " 달러 = " + (USD * 1400) + " 원"); 라고 정의한 동작이

 

interface에 있는 Convetible한개만 있기때문에, 람다식의 동작은 convert(인터페이스안에있는) 동작만 됨 ▽

- 인터페이스 Convetible

package chap_10.converter;

@FunctionalInterface    // 함수형 사용을 알려줌
public interface Convertible {
    void convert (int USD);
    // △ 추상 convert 메소드 (USD로 받겠다)
}

추상메소드 (convert) 가 두개부터는 어떤메소드와 람다식이 연결되는지 알수없어 에러 발생할수있음.

 

일반적으로 코드를 봤을때, 함수형인지 일반적인 인터페이스인지 알수없기때문에 실수할수있음

@FunctionalInterface
// 이 인터페이스는 함수형 인터페이스로 쓸거라는걸 알려주는 역활

 

 

 

- 클래스 converter

package chap_10.converter;

public class KRWConverter implements Convertible {
    // implement Convertible 을 alt + enter

    @Override
    public void convert(int USD) {
        // △ 추상 convert 메소드 (USD로 받겠다)

        System.out.println(USD + " 달러 = " + (USD * 1400) + " 원");
        // 1 달러 = 1400원
    }
}

추상이란 무엇일까 | Evans Library (evan-moon.github.io)

 

추상화가된 대상은, 대상의 본질 디테일한 특징이 배제되어, 대상 자체를 표현하는 특징이 강화됨

>> 결국 어떤 복잡한 대상의 핵심적인 특징만 남기고 나머지는 제거하여 단순화시킴

 

 

* 프로그래밍에서 추상이란?

 

- 왜 필요한가?

더 복잡하고 어려운것을 만들기위해.

복잡한 구현을 감추어 단순한 형태로 표현함으로써,내가 만든 모듈이나 부품, 혹은 제품을 사용하는 사용자가 근본적인 원리를 알지 못 하더라도 대상의 기능을 활용할 수 있도록 만들어주는 것

 

ex)

동사무소에가면 주민등록 할수있다 -> 행정처리 시스템이 분업화되어 추상화됨

자동차의 엑셀러레이터를 밟으면 차가 앞으로 전진 -> 흡기/압축/폭발/배기 과정을 다루는 ECU와 엔진의 로직이 추상화됨