theo-no.log

Network - OSI 7계층(1.Physical layer)

Sun, 27 Aug 2023 15:21:23 GMT

물리 계층(Physical layer)

전기적 신호가 나가는 물리적인 장비
- 네트워크 통신은 복잡한 정보를 주고 받지만 실제로는 0과 1만 사용되며, 이것을 '잘' 주고받을 수 있으면 된다. 0과 1은 흔히 비트(bit) 라고 불린다.
이 계층에서는 단지 데이터를 전달할뿐 아래와 같은 요소들은 신경쓰지 않는다.
- 데이터가 무엇인지
- 어떤 에러가 있는지
- 어떻게 전송하는 것이 효과적인지
단지 데이터를 전기적인 신호로 변환해서 주고받는 기능만 있을 뿐이다.
- 디지털 신호(0과 1)을 아날로그 신호로, 아날로그 신호를 디지털 신호로 변경
  - 랜 카드가 데이터를 0과 1로 바꿔준다.

                             [출처 : https://jhnyang.tistory.com]

전송 단위

비트

전송 매체

유선
- 트위스트 페어 케이블
  - 한 쌍의 케이블이 꼬여있는 케이블, 일반적으로 랜 선
  - UTP 케이블과 STP 케이블이 있다.
- 광 케이블
무선
- 라디오파
- 마이크로파
- 적외선
리피터
- 전송과정 중에 신호가 약해진 신호를 다시 정상화하는 장비이다.
- 다른 장비들에서 리피터의 역할을 하기 때문에 이제는 따로 사용되지 않는다.
허브
- 여러 개의 포트를 가지고 있어, 여러 대의 컴퓨터끼리 송수신할 수 있도록 해주는 장비이다.
- 허브는 리피터의 역할도 한다.
- 허브는 들어오는 데이터를 연결되어 있는 모든 컴퓨터로 전송한다는 문제점이 있다.
- 이러한 문제점 때문에 허브는 현재 사용되고 있지 않다.
- 허브를 대체한 네트워크 장비는 MAC 주소를 통해 특정한 컴퓨터에 데이터를 전송할 수 있는 스위치이다.

프로그래밍 패러다임 - 선언형 프로그래밍과 함수형 프로그래밍

Mon, 21 Aug 2023 13:17:36 GMT

선언형 프로그래밍

선언형 프로그래밍이란

선언형 프로그래밍은 어떤 방법(How)으로 동작하는지 나타내기 보다 무엇(What)을 하는지를 중점으로 하는 방법이다.

//코드1(명령형)
function addOne (arr) {
    let results = [];
    for(let i=0; i


먼저 코드 1을 보면,
addOne이라는 함수는 arr 배열을 파라미터로 받고 나서 result라는 새로운 배열을 선언한 뒤, 배열 arr의 원소들에 1을 더 해서 result 배열에 push한 다음 그 값을 리턴하는 함수이다.
이렇게 어떻게(How) 동작하는지 확실하게 알 수 있다. 근데 그러면 당연히 이렇게 하지 선언형은 어떤 걸 말하는거지? 궁금점이 생길 것이다.
//코드2(선언형)
function addOne (arr) {
    return arr.map((i) => i+1);
}
코드 2를 보면,
단순히 javaScript의 내장형 함수로 바꿔 쓴게 선언형 프로그래밍이라고 생각이 들 수 있다.
하지만 여기서 중요한 건 내장형 함수로 바꾸면서 추사화가 되었다는 것이다.
즉, 선언형 프로그래밍에서 가장 중요한 점은 명령형 프로그래밍의 추상화라는 것이다.
위 코드를 보면 결국 어떤(What) 일이 일어나는지를 보여주지 어떻게(How) 원하는 결과를 만들어내느지는 중요하지 않다.


선언형 프로그래밍의 분류



함수형 언어

수학적 함수를 조합하여 문제를 해결하는 언어

알려진 값을 함수에 적용하는 것을 기반으로 한다.


side effect가 발생하지 않도록 함수를 짜야 한다.

side effect : 함수의 실행 결과가 함수 밖의 상항에 영향을 끼치거나, 함수 밖의 상황이 함수의 실행결과에 영향을 미치는 것
side effect가 없으려면 입력받은 파라미터 외의 전역변수 등을 참조하지 않아야 하며 수정해서도 안된다. 또, return 값이 있어야 하며 함수를 이용하는 이유는 오직 이 return 값을 받기 위해서이다.


재귀 호출이 자주 이용된다.

병렬 처리에 유리하다.

종류 : LISP
  





논리형 언어

기호 논리학에 기반을 둔 언어로, 논리 문장을 이용하여 프로그램을 표현하고 계산한다.

반복문이나 선택문을 사용하지 않는다.

비절차적 언어이다.

종류 : PROLOG





선언형 프로그래밍 종류


HTML


웹 브라우저의 표준 문서인 하이퍼텍스트 문서를 만들기 위해 사용하는 언어

특별한 데이터 타입이 없고 변수 사용이 없다.

호환성이 좋고 사용이 편리하다.


LIS

함수형 프로그래밍 언어, 수학 표기법을 나타내기 위한 목적
특이하게 전위 표기법을 사용
인공지능 분야에 사용되는 언어

PROLOG

대표적인 논리형 언어로, Object(객체)간의 Relation을 표기하는 데 집중하는 언어
인공지능 분야에서 논리적인 추론이라 리스트 처리에 사용된다.

XML

기존 HTML의 단점을 보완하여 웹에서 구조화된 다양한 문서들을 상호 교환할 수 있도록 설계된 언어
HTML에 사용자가 새로운 태그를 정의할 수 있고, 이를 표현하는 방식이 독립적이다.

HASKELL

함수형 프로그래밍 언어의 한 종류로, 코드가 간결하고 에러가 날 확률이 낮다.

SQL 

관계형 데이터베이스 관리 시스템의 데이터를 관리하기 위해 설계된 특수 목적의 프로그래밍 언어

### 선언형 프로그래밍의 장점



가독성과 재사용성이 좋고, 작동 순서를 구체적으로 작성하지 않아서 오류가 적다.
프로그램 동작을 변경하지 않고도 관련 값을 대체할 수 있다.
해당 언어에서 문제가 발생해도 다른 것에 영향을 주지 않는다.(참조 투명성)



함수형 프로그래밍



함수형 프로그래밍이란



함수형 프로그래밍은 선언형 프로그래밍의 일종으로 프로그램이 상태의 변화 없이 데이터 처리를 수학적 함수 계산으로 취급하고자 하는 패러다임이다.
순수 함수의 조합으로 프로그래밍하며 최종 Output이 발생할 수 있도록 순수 함수들을 엮어서 호출한다. 문이 아닌 식이나 선언으로 수행되는 선언형 프로그래밍 패러다임을 따르고 있다.


함수형 프로그래밍의 특징



순수 함수

동일한 입력에는 항상 같은 값을 반환한다.

함수의 출력(return)은 오로지 그 함수에 입력된 값(input)에만 의존한다.

함수의 실행은 프로그램의 실행에 영향을 미치지 않아야 한다.Self-contained되어야 한다. 즉, side effect가 없다.Side effect가 없다는 의미는 오로지 출력(return) 만 수행한다는 의미이다.





불변성

Input의 Immutability을 유지해야 순수함수의 순수성 유지가 의미가 있다.

구조체를 Input에 넣었을 때와 클래스를 Input에 넣었을 때 불변성을 유지시키는 구조가 다르다. 구조체는 deep copy이기 때문에 함수 내에서 변경이 불가능하기 때문에 Input의 불변성을 고민하지 않아도 된다. 하지만 클래스는 swallow copy이기 때문에 함수 내에서 속성 변경이 가능하다. 이는 함수가 상태를 변경할 수 있는 여지를 주게 되므로 주의해야 한다.





참조의 투명성

함수의 순수성, 전달인자의 불변성을 유지하면 다음과 같은 참조의 투명성을 기대할 수 있다.

자기 충족적이다(self-contained). 함수 외부에 의존하는 코드가 없고, 함수 사용자 입장에서는 유효한 매개변수만 전달하면 된다.

결정론적이다 (deterministic). 동일한 매개변수에 대해서는 항상 동일한 결과가 나온다.

예외 (Exception) 를 던지지 않는다. out of memory error 혹은 stack overflow error 는 발생할 수 있지만, 이러한 에러들은 버그로 취급되며, 함수의 사용자가 다룰 수 있는 것은 아니다.

다른 코드가 예기치 않게 실패하는 조건을 만들지 않는다. 예를 들어, 참조 투명성을 가진 함수는 매개 변수의 값을 변경하거나 함수 외부의 데이터를 변경하지 않는다.

데이터베이스, 파일 시스템, 네트워크 등의 외부 기기로 인해 동작이 멈추지 (hang) 않는다.






Avoid

함수형 프로그래밍에서 가장 피해야 하는 지점이다.

공유상태 피하기 (Avoid shared state)

상태변화 피하기 (Avoid mutating state)

부작용 피하기 (Avoid side effects)






함수형 프로그래밍의 활용



함수의 합성

원하는 Output을 위해 둘 이상의 재사용 가능한 순수 함수를 조합하는 과정을 말한다.

함수형 프로그램은 여러 작은 순수 함수들로 이루어져있기 때문에 이 함수들을 연쇄적으로 또는 병렬로 호출해서 더 큰 함수를 만드는 과정으로 전체 프로그램을 구축한다. 그리고 이 과정에서 함수를 엮기 때문에 고차원함수(Higher-Order Functions)를 활용해야 한다.

고차원 함수는 함수를 인자로 받고 또 결과로 반환하는 함수를 이야기한다.


이 때문에 함수형 프로그래밍에서 함수는 일급객체여야 한다.

일급객체

전달인자(argument)로 전달할 수 있다.

동적 프로퍼티 할당이 가능하다. 컴파일 단계가 아니라 런타임시에도 할당이 가능하다는 뜻이다.

변수나 데이터 구조(자료구조) 안에 담을 수 있다

반환 값으로 사용할 수 있다.

할당할 때 사용된 이름과 관계없이 고유한 객체로 구별할 수 있다.





swift에서는 filter, map, flatMap, reduce 등의 기능을 사용할 수 있다.





Function Decoration

순수함수를 재사용하다보면, 이미 만들어진 순수함수를 그대로 적용하기보다 일부 개선하거나, 조금 다른 방향으로 수정해야 하는 상황이 발생할 수 있다. 이 때 function decoration을 적용한다.




Partial Application & Curring

순수 함수를 조합하다보면, 인자의 수가 서로 맞지 않는 순수함수를 엮어야 하는 상황이 있을 수 있다.
  이 상황을 Arity(the number of arguments taken by a function) Mismatch라 한다.

Arity Mismatch는 왜 일어날까?
  순수함수 중에는 2개 이상의 인자를 필요로 하는 함수가 있을 수 있음
  이 순수함수는 2개 이상의 순수함수에서 실행된 출력값을 받아와야 함
  하지만 함수는 무조건 1개의 return 값만 나옴
  이렇게 인자의 수가 서로 맞지 않는 상황을 Arity Mismatch라 한다.

Partial Application & Curring으로 Arity Mismatch을 해결
  Partial Application : 인자를 부분적으로 먼저 엮어준다.
  Curring : 인자를 하나씩만 받는 함수의 체인으로 만드는 방법이다.


// Partial Application
func add(_ a: Int, _ b: Int) -> (Int) -> Int {
    return { c in
        return a + b + c
    }
}
var addTenFive = add(10, 5)//10과 5를 미리 합쳐준다!
print(addTenFive(5)) // 미리 10과 5가 합쳐줬기 때문에 20이 나온다.

//Curring
func before(_ a: String) -> ((String)->String) {
  return { b in
      return a + b;
  }
}
var word = before("이렇게");
var finalWord = word("붙어요!");
print(finalWord); //이렇게붙어요!



함수형 프로그래밍의 장점

여러 가지 연산 처리 작업이 동시에 일어나는 프로그램을 만들기 쉽다.
멀티 코어 혹은 여러 개 연산 프로세서를 사용하는 시스템에서 효율적인 프로그램을 만들기 쉽다.
상태변화에 따른 부작용에서 자유로워지기 때문에 순수하게 기능 구현에 초점을 맞추어 설계할 수 있다.




함수형 프로그래밍의 단점

순수함수를 구현하기 위해 코드의 가독성이 좋지 않을 수 있다.
재귀적 코드 스타일은 무한루프에 빠질 수 있다.
순수함수를 쓰는건 쉬울 수 있지만, 그것들을 조합하는 것은 쉽지 않다.



Desgin Pattern - Iterator(이터레이터) 패턴
Thu, 17 Aug 2023 13:34:30 GMT
Iterator 패턴
반복자(Iterator) 패턴은 일련의 데이터 집합에 대하여 순차적인 접근(순회)을 지원하는 패턴이다.
데이터 집합이란 객체들을 그룹으로 묶어 자료의 구조를 취하는 컬렉션을 말한다. 대표적인 컬렉션으로 한번쯤은 들어본 리스트나 트리, 그래프, 테이블 ..등이 있다.
                           [요소를 다양한 방법으로 저장하는 컬렉션]

                            [출처 : https://inpa.tistory.com/]
보통 배열이나 리스트 같은 경우 순서가 연속적인 데이터 집합이기 때문에 간단한 for문을 통해 순회할수 있다. 그러나 해시, 트리와 같은 컬렉션은 데이터 저장 순서가 정해지지 않고 적재되기 때문에, 각 요소들을 어떤 기준으로 접근해야 할지 애매해진다.
예를들어 아래와 같이 트리 구조가 있다면 어떤 상황에선 깊이(세로)를 우선으로 순회 해야 할 수도 있고, 너비(가로)를 우선으로 순회할수도 있기 때문이다.
                           [어떤 기준으로 순회할지 컬렉션마다 다를수 있다]

                               [출처 : https://inpa.tistory.com/]
이처럼 복잡하게 얽혀있는 자료 컬렉션들을 순회하는 알고리즘 전략을 정의하는 것을 이터레이터 패턴이라고 한다.
컬렉션 객체 안에 들어있는 모든 원소들에 대한 접근 방식이 공통화 되어 있다면 어떤 종류의 컬렉션에서도 이터레이터만 뽑아내면 여러 전략으로 순회가 가능해 보다 다형적인 코드를 설계할 수 있게 된다.

                             [출처 : https://inpa.tistory.com/]

💡 자바의 컬렉션 프레임워크(JCF)에서 각종 컬렉션을 무리없이 순회할수 있는 것도 내부에 미리 이터레이터 패턴이 적용되어 있기 때문이다.






Iterator 패턴 구조

                             [출처 : https://inpa.tistory.com/]

Aggregate (인터페이스)
ConcreateIterator 객체를 반환하는 인터페이스를 제공한다.
iterator() : ConcreateIterator 객체를 만드는 팩토리 메서드


ConcreateAggregate (클래스)
여러 요소들이 이루어져 있는 데이터 집합체


Iterator (인터페이스)
집합체 내의 요소들을 순서대로 검색하기 위한 인터페이스를 제공한다.
hasNext() : 순회할 다음 요소가 있는지 확인 (true / false)
next() : 요소를 반환하고 다음 요소를 반환할 준비를 하기 위해 커서를 이동시킴


ConcreateIterator (클래스)
반복자 객체
ConcreateAggregate가 구현한 메서드로부터 생성되며, ConcreateAggregate 의 컬렉션을 참조하여 순회한다.
어떤 전략으로 순회할지에 대한 로직을 구체화 한다.






Iterator 패턴 흐름
클래스 구성
// 집합체 객체 (컬렉션)
interface Aggregate {
    Iterator iterator();
}
class ConcreteAggregate implements Aggregate {
    Object[] arr; // 데이터 집합 (컬렉션)
    int index = 0;

    public ConcreteAggregate(int size) {
        this.arr = new Object[size];
    }

    public void add(Object o) {
        if(index < arr.length) {
            arr[index] = o;
            index++;
        }
    }

    // 내부 컬렉션을 인자로 넣어 이터레이터 구현체를 클라이언트에 반환
    @Override
    public Iterator iterator() {
        return new ConcreteIterator(arr);
    }
}
// 반복체 객체
interface Iterator {
    boolean hasNext();
    Object next();
}
class ConcreteIterator implements Iterator {
    Object[] arr;
    private int nextIndex = 0; // 커서 (for문의 i 변수 역할)

    // 생성자로 순회할 컬렉션을 받아 필드에 참조 시킴
    public ConcreteIterator(Object[] arr) {
        this.arr = arr;
    }

    // 순회할 다음 요소가 있는지 true / false
    @Override
    public boolean hasNext() {
        return nextIndex < arr.length;
    }

    // 다음 요소를 반환하고 커서를 증가시켜 다음 요소를 바라보도록 한다.
    @Override
    public Object next() {
        return arr[nextIndex++];
    }
}
클래스 흐름
public static void main(String[] args) {
    // 1. 집합체 생성
    ConcreteAggregate aggregate = new ConcreteAggregate(5);
    aggregate.add(1);
    aggregate.add(2);
    aggregate.add(3);
    aggregate.add(4);
    aggregate.add(5);

    // 2. 집합체에서 이터레이터 객체 반환
    Iterator iter = aggregate.iterator();

    // 3. 이터레이터 내부 커서를 통해 순회
    while(iter.hasNext()) {
        System.out.printf("%s → ", iter.next());
    }
}
/*출력결과
1 -> 2 -> 3 -> 4 -> 5 ->
*/
  


예시
이터레이터로 순회 전략을 나누기
클라이언트 요구사항은 다음과 같다. 게시판에 글을 올릴건데, 게시글을 최근글, 작성순으로 정렬해서 나열 할 수 있게 해달라고 한다. 즉, 두가지 정렬 전략을 구현해야 되는 것이다.
클린하지 않은 문제의 코드 ❌
다음은 게시글(Post)과 게시판(Borad)를 표현한 인스턴스이다.
게시글에는 게시글 제목 title과 게시글 발행 날짜 필드가 있다. (코드 간략화를 위해 게시글 내용은 생략하였다)
// 게시글
class Post {
    String title; // 게시글 제목
    LocalDate date; // 게시글 발행일

    public Post(String title, LocalDate date) {
        this.title = title;
        this.date = date;
    }
}
// 게시판
class Board {
    // 게시글을 리스트 집합 객체로 저장 관리
    List posts = new ArrayList<>();

    public void addPost(String title, LocalDate date) {
        this.posts.add(new Post(title, date));
    }

    public List getPosts() {
        return posts;
    }
}
public static void main(String[] args) {
    // 1. 게시판 생성
    Board board = new Board();

    // 2. 게시판에 게시글을 포스팅
    board.addPost("디자인 패턴 강의 리뷰", LocalDate.of(2020, 8, 30));
    board.addPost("게임 하실분", LocalDate.of(2020, 2, 6));
    board.addPost("이거 어떻게 하나요?", LocalDate.of(2020, 6, 1));
    board.addPost("이거 어떻게 하나요?", LocalDate.of(2021, 12, 22));

    List posts = board.getPosts();

    // 3. 게시글 발행 순서대로 조회하기
    for (int i = 0; i < posts.size(); i++) {
        Post post = posts.get(i);
        System.out.println(post.title + " / " + post.date);
    }

    // 4. 게시글 날짜별로 조회하기
    Collections.sort(posts, (p1, p2) -> p1.date.compareTo(p2.date)); // 집합체를 날짜별로 정렬
    for (int i = 0; i < posts.size(); i++) {
        Post post = posts.get(i);
        System.out.println(post.title + " / " + post.date);
    }
}
/*출력결과
디자인 패턴 강의 리뷰 / 2020-08-30
게임 하실분 / 2020-02-06
이거 어떻게 하나요? / 2020-06-01
이거 어떻게 하나요? / 2021-12-22

게임 하실분 / 2020-02-06
이거 어떻게 하나요? / 2020-06-01
디자인 패턴 강의 리뷰 / 2020-08-30
이거 어떻게 하나요? / 2021-12-22
*/
일반적으로 for문을 돌려 집합체의 요소들을 순회하였다. 그러나 이러한 구성 방식은 Board에 들어간 Post를 순회할 때, Board가 어떠한 구조로 이루어져 있는지를 클라이언트에 노출된다. 따라서 이를 보다 객체 지향적으로 구성하기 위해 이터레이터 패턴을 적용해보자.
이터레이터 패턴을 적용한 코드 ✔️
위에서 이터레이터 인터페이스를 직접 만들어 썼지만, 자바에선 이미 이터레이터 인터페이스를 지원한다. 자바의 내부 이터레이터를 재활용해서 메서드 위임을 통해 코드를 간단하게 구현할 수도 있다.
순회 전략으로는 리스트 저장 순서대로 조회와 날짜 순서대로 조회 두가지가 존재한다. 따라서 이에 대한 이터레이터 클래스 역시 두가지 생성해주면 된다.

ListPostIterator : 저장 순서 이터레이터
DatePostIterator : 날짜 순서 이터레이터

그리고 ListPostIterator 와 DatePostIterator 객체를 반환하는 팩토리 메서드를 Board 클래스에 추가만 해주면 완성 된다.

// 저장 순서 이터레이터
class ListPostIterator implements Iterator {
    private Iterator itr;

    public ListPostIterator(List posts) {
        this.itr = posts.iterator();
    }

    @Override
    public boolean hasNext() {
        return this.itr.hasNext(); // 자바 내부 이터레이터에 위임해 버림
    }

    @Override
    public Post next() {
        return this.itr.next(); // 자바 내부 이터레이터에 위임해 버림
    }
}
// 날짜 순서 이터레이터
class DatePostIterator implements Iterator {
    private Iterator itr;

    public DatePostIterator(List posts) {
        // 최신 글 목록이 먼저 오도록 정렬
        Collections.sort(posts, (p1, p2) -> p1.date.compareTo(p2.date));
        this.itr = posts.iterator();
    }

    @Override
    public boolean hasNext() {
        return this.itr.hasNext(); // 자바 내부 이터레이터에 위임해 버림
    }

    @Override
    public Post next() {
        return this.itr.next(); // 자바 내부 이터레이터에 위임해 버림
    }
}
// 게시판
class Board {
    // 게시글을 리스트 집합 객체로 저장 관리
    List posts = new ArrayList<>();

    public void addPost(String title, LocalDate date) {
        this.posts.add(new Post(title, date));
    }

    public List getPosts() {
        return posts;
    }

    // ListPostIterator 이터레이터 객체 반환
    public Iterator getListPostIterator() {
        return new ListPostIterator(posts);
    }

    // DatePostIterator 이터레이터 객체 반환
    public Iterator getDatePostIterator() {
        return new DatePostIterator(posts);
    }
}
public static void main(String[] args) {
    // 1. 게시판 생성
    Board board = new Board();

    // 2. 게시판에 게시글을 포스팅
    board.addPost("디자인 패턴 강의 리뷰", LocalDate.of(2020, 8, 30));
    board.addPost("게임 하실분", LocalDate.of(2020, 2, 6));
    board.addPost("이거 어떻게 하나요?", LocalDate.of(2020, 6, 1));
    board.addPost("이거 어떻게 하나요?", LocalDate.of(2021, 12, 22));

    // 게시글 발행 순서대로 조회하기
    print(board.getListPostIterator());

    // 게시글 날짜별로 조회하기
    print(board.getDatePostIterator());
}

public static void print(Iterator iterator) {
    Iterator itr = iterator;
    while(itr.hasNext()) {
        Post post = itr.next();
        System.out.println(post.title + " / " + post.date);
    }
}
/*출력결과
디자인 패턴 강의 리뷰 / 2020-08-30
게임 하실분 / 2020-02-06
이거 어떻게 하나요? / 2020-06-01
이거 어떻게 하나요? / 2021-12-22

게임 하실분 / 2020-02-06
이거 어떻게 하나요? / 2020-06-01
디자인 패턴 강의 리뷰 / 2020-08-30
이거 어떻게 하나요? / 2021-12-22
*/
이제 클라이언트는 게시글을 순회할 때 Board 내부가 어떤 집합체로 구현(Array, List, Tree, Queue ..등) 되어 있는지 알 수 없게 감추고 전혀 신경 쓸 필요가 없게 되었다. 그리고 순회 전략을 각 객체로 나눔으로써 때에 따라 적절한 이터레이터 객체만 받으면 똑같은 이터레이터 순회 코드로 다양한 순회 전략을 구사할 수 있게 되었다.
집합체 구현에 상관 없이 순회를 표현 ✔️
Iterator를 사용하는 또다른 이유는 이터레이터를 사용함으로써 집합체 구현과 분리할 수 있기 때문이다.
Iterator itr = iterator;
while(itr.hasNext()) {
    Post post = itr.next();
    System.out.println(post.title + " / " + post.date);
}
이터레이터 객체를 반환하면 컬렉션을 순회할때 hasNext() 와 next() 라는 Iterator의 메소드만을 이용하기 때문에, 집합체인 Board의 내부 구성을 감출수 있게 된다. 즉, 위의 while문은 Board의 구현에 의존하지 않는 것이다.
이 말은 만일 추후에 Board의 집합체를 수정하더라도 Board 클래스가 올바른 Iterator만을 반환해 준다면 클라이언트의 코드(위의 while 루프)는 변경하지 않아도 되게 된다.
  


Iterator 패턴 특징
Iterator 패턴 사용 시기

컬렉션에 상관없이 객체 접근 순회 방식을 통일하고자 할 때
컬렉션을 순회하는 다양한 방법을 지원하고 싶을 때
컬렉션의 복잡한 내부 구조를 클라이언트로 부터 숨기고 싶은 경우 (편의 + 보안)
데이터 저장 컬렉션 종류가 변경 가능성이 있을 때
클라이언트가 집합 객체 내부 표현 방식을 알고 있다면, 표현 방식이 달라지면 클라이언트 코드도 변경되어야 하는 문제가 생긴다.



Iterator 패턴 장점

일관된 이터레이터 인터페이스를 사용해 여러 형태의 컬렉션에 대해 동일한 순회 방법을 제공한다.
컬렉션의 내부 구조 및 순회 방식을 알지 않아도 된다.
이터레이터 패턴은 별도의 이터레이터 객체를 반환 받아 이를 이용해 순회하기 때문에, 집합체의 내부 구조를 노출하지 않고 순회 할 수 있다.


집합체의 구현과 접근하는 처리 부분을 반복자 객체로 분리해 결합도Visit Website를 줄 일 수 있다.
Client에서 iterator로 접근하기 때문에 ConcreteAggregate 내에 수정 사항이 생겨도 iterator에 문제가 없다면 문제가 발생하지 않는다.


순회 알고리즘을 별도의 반복자 객체에 추출하여 각 클래스의 책임을 분리하여 단일 책임 원칙(SRP)Visit Website를 준수한다.
데이터 저장 컬렉션 종류가 변경되어도 클라이언트 구현 코드는 손상되지 않아 수정에는 닫혀 있어 개방 폐쇄 원칙(OCP)Visit Website를 준수한다.

Iterator 패턴 단점

클래스가 늘어나고 복잡도가 증가한다.
만일 앱이 간단한 컬렉션에서만 작동하는 경우 패턴을 적용하는 것은 복잡도만 증가할 수 있다.
이터레이터 객체를 만드는 것이 유용한 상황인지 판단할 필요가 있다.


구현 방법에 따라 캡슐화를 위배할 수 있다.




실무에서의 Iterator 패턴
Java - java.util.Enumeration

Iterator가 만들어지기 전 java 1.0부터 있었던 API
과거의 클래스로서, 현재는 안쓰고 Iterator로 기능이 대체 되었다.
java 9 에서는 Enumeration Iterator로 변환해주는 코드가 추가되었다. asIterator()




Iterator
Enumeration



요소를 반복하는 데 사용되는 일반 커서이며 모든 컬렉션 클래스에 적용할 수 있다.
Vector와 같은 레거시 클래스에만 적용할 수 있으므로 일반 커서가 아니다. 컬렉션 클래스에 대한 읽기 권한만 있다.


반복 메서드 : hasNext(), next()
반복 메서드 : hasMoreElements(), nextElement()


반복자를 사용하여 컬렉션의 요소를 제거할 수 있다.
읽기 권한만 있기 때문에 열거를 사용하여 컬렉션의 요소를 제거할 수 없다.


public static void main(String[] args) {
    Vector rollno = new Vector<>();
    rollno.add(1);
    rollno.add(2);
    rollno.add(3);
    rollno.add(4);
    rollno.add(5);

    Enumeration classNine = rollno.elements();

    // hasMoreElements(), nextElement() 로 순회
    while (classNine.hasMoreElements()) {
        System.out.println(classNine.nextElement());
    }
}
Java - java.util.Iterator

hasNext() : 순회할 요소가 있는지 확인
next() : 현재 커서의 요소를 출력하고 다음으로 커서를 이동
remove() : Iterator에서 next()로 받았던 해당 엘리먼트를 삭제.
모든 이터레이터에서 다 지원하는 것은 아니다. UnsupportedOperationException()을 던지는 경우가 많다.
보통 이 기능은 동시에 다발적으로 같은 명령을 수행해도 안전한 컬렉션에서 제공한다.


forEachRemaining() : 함수형 인터페이스를 통해 순회 코드를 심플화 해준다.

public static void main(String[] args) {
    Set aggregate = new TreeSet<>(List.of(1,2,3,4,5));

    // hasNext(), next(), remove()
    Iterator itr = aggregate.iterator();
    while(itr.hasNext()) {
        System.out.printf("%d 삭제", itr.next());
        itr.remove();
    }

    System.out.println(aggregate); // []
}
public static void main(String[] args) {
    Set aggregate = new TreeSet<>(List.of(1,2,3,4,5));

    // 이터레이터의 while 문 코드를 for문으로 축약할 수 도 있다.
    for (Iterator i = aggregate.iterator(); i.hasNext();) {
        System.out.println(i.next());
    }

    // forEachRemaining()
    aggregate.iterator().forEachRemaining(System.out::println);
}
Java - Java StAX(Streaming API for XML)

XML 파일 포맷을 읽거나 만들때 사용하는 자바 라이브러리
콘솔 기반의 API, 이터레이터 기반의 API를 제공한다.
이터레이터 기반의 API
xml의 Element마다 이벤트가 지나가면서 캡쳐하며 그 영역을 표현하는 XMLEvent라는 인스턴스가 새로 만들고 이를 이용하는 방식이다. (XmlEventReader, XmlEventWriter)


콘솔 기반의 API
하나의 인스턴스가 Element를 지나가면서 직접 안의 내용들을 변경하는 방식이다. 그래서 메모리는 이터레이터 기반보다 효율적이지만 재사용, 변경 측면에서는 좋지 않아 이터레이터 기반의 API를 사용하는 것이 권장된다.




비슷한 SAX(Simple API for XML)도 있지만, SAX는 XML을 읽기만 가능하다.



    
    
    

public static void main(String[] args) throws FileNotFoundException, XMLStreamException {

    // 1. XMLEventReader 객체를 만드는 팩토리 객체를 얻는다.
    XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();

    // 2. XMLEventReader 객체를 만든다.
    XMLEventReader reader = xmlInputFactory.createXMLEventReader(new FileInputStream("book.xml"));

    // 3. 이터레이터 순회한다.
    while(reader.hasNext()) {
        //  엘리먼트를 캡쳐하여 그 영역을 표현하는 XMLEvent 인스턴스를 생성
        XMLEvent nextEvent = reader.nextEvent();

        // 엘리먼트에 자식 엘리먼트가 있을 경우
        if(nextEvent.isStartElement()) {
            StartElement startElement = nextEvent.asStartElement(); // 
            QName name = startElement.getName();
            if(name.getLocalPart().equals("book")) {
                // 엘리먼트의 속성을 얻는다. 
                Attribute title = startElement.getAttributeByName(new QName("title"));
                System.out.println(title.getValue());
            }
        }
    }
}
/*출력결과
오징어 게임
숨바꼭질
우리집에 왜 왔니
*/
Spring Framework  - CompositeIterator

기존의 Interator에 add 기능만 하나 추가한 것
add() : 여러 Iterator들을 조합(Composite)해서 사용할 수 있다.

public class IteratorInSpring {

    public static void main(String[] args) {
        CompositeIterator iterator;
    }
}



Desgin Pattern - Proxy(프록시) 패턴
Tue, 15 Aug 2023 14:00:02 GMT
Proxy Pattern
프록시 패턴(Proxy Pattern)은 대상 원본 객체를 대리하여 대신 처리하게 함으로써 로직의 흐름을 제어하는 행동 패턴이다.
프록시(Proxy)의 사전적인 의미는 '대리인'이라는 뜻이다. 즉, 누군가에게 어떤 일을 대신 시키는 것을 의미하는데, 이를 객체 지향 프로그래밍에 접목해보면 클라이언트가 대상 객체를 직접 쓰는게 아니라 중간에 프록시(대리인)을 거쳐서 쓰는 코드 패턴이라고 보면 된다. 
따라서 대상 객체(Subject)의 메소드를 직접 실행하는 것이 아닌, 대상 객체에 접근하기 전에 프록시(Proxy) 객체의 메서드를 접근한 후 추가적인 로직을 처리한뒤 접근하게 된다.
이때 프로시는 흐름제어만 할 뿐 결과값을 조작하거나 변경시키면 안된다!

                               [출처 : https://inpa.tistory.com/]
그냥 객체를 이용하면 되는데 이렇게 번거롭게 중계 대리자를 통해 이용하는 방식을 취하지?
그 이유는 대상 클래스가 민감한 정보를 가지고 있거나 인스턴스화 하기에 무겁거나 추가 기능을 가미하고 싶은데, 원본 객체를 수정할수 없는 상황일 때를 극복하기 위해서 이다. 
이로 인해 다음과 같은 효과를 누릴수 있다고 보면 된다.

보안(Sequrity)
프록시는 클라이언트가 작업을 수행할 수 있는 권한이 있는지 확인하고 검사 결과가 긍정적인 경우에만 요청을 대상으로 전달한다.


캐싱(Caching)
프록시가 내부 캐시를 유지하여 데이터가 캐시에 아직 존재하지 않는 경우에만 대상에서 작업이 실행되도록 한다.


데이터 유효성 검사(Data validation)
프록시가 입력을 대상으로 전달하기 전에 유효성을 검사한다.


지연 초기화(Lazy initialization)
대상의 생성 비용이 비싸다면 프록시는 그것을 필요로 할때까지 연기할 수 있다.


로깅(Logging)
프록시는 메소드 호출과 상대 매개 변수를 인터셉트하고 이를 기록한다.


원격 객체(Remote objects)
프록시는 원격 위치에 있는 객체를 가져와서 로컬처럼 보이게 할 수 있다.






Proxy 패턴의 구조

                           [출처 : https://inpa.tistory.com/]

Subject : Proxy와 RealSubject를 하나로 묶는 인터페이스 (다형성)
대상 객체와 프록시 역할을 동일하게 하는 추상 메소드(operation( )) 를 정의한다.
인터페이스가 있기 때문에 클라이언트는 Proxy 역할과 RealSubject 역할의 차이를 의식할 필요가 없다.


RealSubject : 원본 대상 객체
Proxy : 대상 객체(RealSubject)를 중계할 대리자 역할
프록시는 대상 객체를 합성(composition)한다.
프록시는 대상 객체와 같은 이름의 메서드를 호출하며, 별도의 로직을 수행 할수 있다 (인터페이스 구현 메소드)
프록시는 흐름제어만 할 뿐 결과값을 조작하거나 변경시키면 안 된다.


Client : Subject 인터페이스를 이용하여 프록시 객체를 생성해 이용.
클라이언트는 프록시를 중간에 두고 프록시를 통해서 RealSubject와 데이터를 주고 받는다.







Proxy 패턴의 종류



기본형 프록시(Normal Proxy)
interface ISubject {
    void action();
}
class RealSubject implements ISubject {
    public void action() {
        System.out.println("원본 객체 액션 !!");
    }
}
class Proxy implements ISubject {
    private RealSubject subject; // 대상 객체를 composition

    Proxy(RealSubject subject) {
        this.subject = subject;
    }

    public void action() {
        subject.action(); // 위임
        /* do something */
        System.out.println("프록시 객체 액션 !!");
    }
}
class Client {
    public static void main(String[] args) {
        ISubject sub = new Proxy(new RealSubject());
        sub.action();
    }
}
/*출력 결과
원본 객체 액션 !!
프록시 객체 액션 !!
*/



가상 프록시(Virtual Proxy)

지연 초기화 방식에 사용
서비스가 시작될 때 객체를 생성하는 대신에 객체 초기화가 실제로 필요한 시점에 초기화될 수 있도록 지연 가능


가끔 필요하지만 항상 메모리에 적재되어 있는 무거운 서비스 객체가 있는 경우
실체 객체의 생성에 많은 자원이 소모되지만 사용 빈도는 낮을 때 사용



//Interface와 RealSubject는 생략
class Proxy implements ISubject {
    private RealSubject subject; // 대상 객체를 composition

    Proxy() {
    }

    public void action() {
            // 프록시 객체는 실제 요청(action(메소드 호출)이 들어 왔을 때 실제 객체를 생성한다.
        if(subject == null){
            subject = new RealSubject();
        }
        subject.action(); // 위임
        /* do something */
        System.out.println("프록시 객체 액션 !!");
    }
}
class Client {
    public static void main(String[] args) {
        ISubject sub = new Proxy();
        sub.action();
    }
}




보호 프록시(Protection Proxy)

프록시가 대상 객체에 대한 자원으로의 Access 제어(접근 권한)
특정 Client만 서비스 객체를 사용할 수 있도록 하는 경우 사용
프록시 객체를 통해 클라이언트의 자격 증명이 기준과 일치하는 경우에만 서비스 객체에 요청을 전달할 수 있게 한다.



//Interface와 RealSubject는 생략
class Proxy implements ISubject {
    private RealSubject subject; // 대상 객체를 composition
    boolean access; // 접근 권한

    Proxy(RealSubject subject, boolean access) {
        this.subject = subject;
        this.access = access;
    }

    public void action() {
        if(access) {
            subject.action(); // 위임
            /* do something */
            System.out.println("프록시 객체 액션 !!");
        }
    }
}
class Client {
    public static void main(String[] args) {
        ISubject sub = new Proxy(new RealSubject(), false);
        sub.action();
    }
}




로깅 프록시(Logging Proxy)

대상 객체에 대한 로깅을 추가하려는 경우
프록시는 서비스 메서드를 실행하기(전달하기) 전에 로깅을 하는 기능을 추가하는 경우 사용



//Interface와 RealSubject는 생략
class Proxy implements ISubject {
    private RealSubject subject; // 대상 객체를 composition

    Proxy(RealSubject subject {
        this.subject = subject;
    }

    public void action() {
        System.out.println("로깅..................");

        subject.action(); // 위임
        /* do something */
        System.out.println("프록시 객체 액션 !!");

        System.out.println("로깅..................");
    }
}
class Client {
    public static void main(String[] args) {
        ISubject sub = new Proxy(new RealSubject());
        sub.action();
    }
}




원격 프록시(Remote Proxy)

프록시 클래스는 로컬에 있고, 대상 객체는 원격 서버에 존재하는 경우
프록시 객체는 네트워크를 통해 클라이언트의 요청을 전달하여 네트워크와 관련된 불필요한 작업들을 처리하고 결과값만 반환
클라이언트 입장에선 프록시를 통해 객체를 이용하는 것이니 원격이든 로컬이든 신경 쓸 필요가 없으며, 프록시는 진짜 객체와 통신을 대리하게 된다.




                             [출처 : https://blogshine.tistory.com/17]

💡 프록시를 스터브라고도 부르며, 프록시로부터 전달된 명령을 이해하고 적합한 메소드를 호출해주는 역할을 하는 보조객체를 스켈레톤이라 한다.





캐싱 프록시(Caching Proxy)

데이터가 큰 경우 캐싱하여 재사용을 유도
클라이어트 요청의 결과를 캐시하고 이 캐시의 수명 주기를 관리


HTTP Proxy
HTTP Proxy는 웹서버와 브라우저 사이에서 웹 페이지의 캐싱을 실행하는 소프트웨어이다.
웹 브라우저가 어떤 웹 페이지를 표시할 때 직접 웹 서버에서 그 페이지를 가져오는 것이 아니고, HTTP Proxy가 캐쉬해서 어떤 페이지를 대신해서 취득한다. 만일 최신 정보가 필요하거나 페이지의 유효기간이 지났을 때 웹 서버에 웹 페이지를 가지러 간다.
이를 패턴으로 따져보면, 웹 브라우저가 Client 역할, HTTP Proxy가 Proxy 역할, 그리고 웹 서버가 RealSubcjet 역할을 한다고 보면 된다.




                         [출처 : http/blog.naver.com/hai0416]



Proxy 패턴의 특징



프록시 패턴 사용 시기

접근을 제어하거가 기능을 추가하고 싶은데, 기존의 특정 객체를 수정할 수 없는 상황일때
초기화 지연, 접근 제어, 로깅, 캐싱 등, 기존 객체 동작에 수정 없이 추가하고 싶을 때




프록시 패턴 장점

개방 폐쇄 원칙(OCP)Visit Website 준수
기존 대상 객체의 코드를 변경하지 않고 새로운 기능을 추가할 수 있다.


단일 책임 원칙(SRP)Visit Website 준수
대상 객체는 자신의 기능에만 집중 하고, 그 이외 부가 기능을 제공하는 역할을 프록시 객체에 위임하여 다중 책임을 회피 할 수 있다.


원래 하려던 기능을 수행하며 그외의 부가적인 작업(로깅, 인증, 네트워크 통신 등)을 수행하는데 유용하다
클라이언트는 객체를 신경쓰지 않고, 서비스 객체를 제어하거나 생명 주기를 관리할 수 있다.
사용자 입장에서는 프록시 객체나 실제 객체나 사용법은 유사하므로 사용성에 문제 되지 않는다.




프록시 패턴 단점

많은 프록시 클래스를 도입해야 하므로 코드의 복잡도가 증가한다.
예를들어 여러 클래스에 로깅 기능을 가미 시키고 싶다면, 동일한 코드를 적용함에도 각각의 클래스에 해당되는 프록시 클래스를 만들어서 적용해야 되기 때문에 코드량이 많아지고 중복이 발생 된다.
자바에서는 리플렉션에서 제공하는 동적 프록시(Dynamic Proxy) 기법을 이용해서 해결할 수 있다. (후술)


프록시 클래스 자체에 들어가는 자원이 많다면 서비스로부터의 응답이 늦어질 수 있다.




실무에서의 프록시 패턴



Java - Dynamic Proxy
개발자가 직접 디자인 패턴으로서 프록시 패턴을 구현해도 되지만, 자바 JDK에서는 별도로 프록시 객체 구현 기능을 지원한다. 이를 동적 프록시(Dynamic Proxy) 기법이라고 불리운다.
동적 프록시는 개발자가 직접 일일히 프록시 객체를 생성하는 것이 아닌, 애플리케이션 실행 도중 java.lang.reflect.Proxy 패키지에서 제공해주는 API를 이용하여 동적으로 프록시 인스턴스를 만들어 등록하는 방법으로서, 자바의 Reflection APIVisit Website 기법을 응용한 연장선의 개념이다. 그래서 별도의 프록시 클래스 정의없이 런타임으로 프록시 객체를 동적으로 생성해 이용할 수 있다는 장점이 있다.
// 대상 객체와 프록시를 묶는 인터페이스
interface Animal {
    void eat();
}
// 프록시를 적용할 타겟 객체
class Tiger implements Animal{
    @Override
    public void eat() {
        System.out.println("호랑이가 음식을 먹습니다.");
    }
}
public class Client {
    public static void main(String[] arguments) {

        // newProxyInstance() 메서드로 동적으로 프록시 객체를 생성할 수 있다.
        Animal tigerProxy = (Animal) Proxy.newProxyInstance(
                Animal.class.getClassLoader(), // 대상 객체의 인터페이스의 클래스로더
                new Class[]{Animal.class}, // 대상 객체의 인터페이스
                new InvocationHandler() { // 프록시 핸들러
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object target = new Tiger();

                        System.out.println("----eat 메서드 호출 전----");

                        Object result = method.invoke(target, args); // 타겟 메서드 호출

                        System.out.println("----eat 메서드 호출 후----");

                        return result;
                    }
                }
        );
        tigerProxy.eat();
    }
}
/*출력결과
----eat 메서드 호출 전----
호랑이가 음식을 먹습니다.
----eat 메서드 호출 후----
*/



Spring Framework - 스프링 AOP
스프링 프레임워크에서는 내부적으로 프록시 기술을 정말 많이 사용하고 있다. (AOP, JPA 등)
스프링에서는 Bean을 등록할 때 SingletonVisit Website을 유지하기 위해 Dynamic Proxy 기법을 이용해 프록시 객체를 Bean으로 등록한다. 또한 Bean으로 등록하려는 기본적으로 객체가 Interface를 하나라도 구현하고 있으면 JDK를 이용하고 Interface를 구현하고 있지 않으면 내장된 CGLIB 라이브러리를 이용한다.
@Service
public class GameService {
    public void startDame() {
        System.out.println("이 자리에 오신 여러분을 진심으로 환영합니다.");
    }
}
@Aspect
@Comonent
public class PerfAspect {
    @Around("bean(gameService)")
    public void timestamp(ProceedingJoinPoint point) throws Throwable {
        System.out.println("프록시 실행 1");

        point.proceed(); // 대상 객체의 원본 메서드를 실행

        System.out.println("프록시 실행 2");
    }
}



JavaScript - Proxy / Reflect 객체
자바에서도 Proxy 객체를 별도로 지원하듯이, 자바스크립트 진영에서도 독립적인 Proxy 객체가 존재한다.
자바스크립트에서의 Proxy 객체의 역할은 대상 객체을 감싸서(wrapping), 속성 조회, 할당, 열거 및 함수 호출 등 여러 기본 동작을 가로채(trap) 특별한 다른 동작을 가미시키는 대리자 역할을 한다. 대상 객체는 Object, Array 등 자바스크립트의 모든 자료형이 대상이 될 수 있다.
let obj = {
    name: '홍길동',
    print: function () {
        console.log(`My Name is ${this.name}`);
    },
};

// print 함수를 프록시로 감싸기
obj.print = new Proxy(obj.print, {
    apply(target, thisArg, args) {
        console.log('메서드 실행할 때 중간에 가로채어 로직 시행');

        console.log('target: ', target); // 대상 함수
        console.log('thisArg: ', thisArg); // this의 값
        console.log('args: ', args); // 매개변수 목록 (배열)

        console.log('이름 바꿔 버리기 ~');
        thisArg.name = '임꺽정';

        Reflect.apply(target, thisArg, args); // 대상 원본 함수 실행
    },
});

obj.print();
/*출력결과
메서드 실행할 때 중간에 가로채어 로직 시행
target : [Function: print]
thisArg: { name: '홍길동', print: [Function: print] }
args: []
이름 바꿔 버리기 ~
My Name is 임꺽정
*/



Android(안드로이드) 5. 안드로이드 Component - Service
Thu, 15 Jun 2023 08:33:51 GMT
Service




일반적으로 화면 없이 동작하는 프로그램으로 Background 서비스

사용자와 상호작용 할 수 없음

액티비티의 생명주기에 종속되어 있지 않다. (각자 안드로이드 컴포넌트라서)

별도의 스레드에서 동작하지 않고 호스팅 프로세스의 메인 스레드에서 작동

bindService는 연결할 때와 해제할 때만 백그라운드 스레드에서 처리되고 onServiceConnected와 onServiceDisconnected는 메인 쓰레드에서 호출


액티비티가 비활성화 되면 액티비티보다 우선순위가 높음

8버전 이후로는 백그라운드에서 장시간 동작시 시스템에서 강제 종료

회피하려면 APP의 작동을 Notification 영역에 표시하는 Foreground 서비스가 되어야 함


startService 또는 bindService로 실행시킬 수 있음



startService





동작 방식

앱 내의 액티비티 같은 컴포넌트가 호출했을 때 실행

백그라운드에서 한 가지 일을 하며, 결과를 호출했던 컴포넌트에게 보내지 않음

예 - 다운로드, 파일 업로드





생명 주기


회색 부분 - 액티비티에서 호출

초록색 부분은 서비스 시작되고 순서대로 호출

시작되면 onCreate( ) → onStrartCommand( )

중지되면 onDestory( )



onCreate( )

서비스가 최초 초기화 될 때 호출


onStartCommand( )

서비스를 다른 컴포넌트가 호출했을 때 수행

이 메서드를 통해 서비스가 백그라운드에서 동작

리턴 값

START_NOT_STICKY - 서비스가 시스템에 의해 종료될 때 PendingIntent가 따로 있지 않다면 다시 생성하지 않음
START_STICKY(default) - 시스템에 의해 종료되어도 다시 생성(마지막 인텐트는 전해주지 않음)
START_REDELEVER_INTENT - 마지막 인텐트까지 모두 유지하며 다시 생성




onDestroy

서비스가 소멸될 때 호출

stopService( )나 stopSelf( )가 호출되면 서비스가 동작을 멈추고 시스템이 onDestroy 함







bindService



동작 방식

startService와 다르게 자신을 호출했던 컴포넌트와 인터랙션을 주고 받을 수 있음

처리한 결과를 주고 받을 수 있음

서로 다른 프로세스 상에 있어도 처리 가능

a 앱이 있고 b 앱이 있으면 프로세스도 다르고 VirtualMachine도 다르다. 이때, 서로 데이터를 주고 받으려면 프로세스 간 통신을 해야 한다.

startService( )와 달리 하나 이상의 클라이언트 컴포넌트 간의 통신을 구현 가능





생명 주기


bindService( )로 실행

onCreat( ) → onBind( )가 호출되면서 Running 상태가 됨

이때 Binder를 반환해준다.

액티비티 쪽에서onServiceConnected 함수에서 Binder를 받아서 사용



unbindService( )를 호출하면 onUnbind( ) → onDestroy( ) 순서로 호출됨

액티비티의 onStart( )에서 bindService( ) 해주고 onStop( )에서 unbindService( ) 호출





bindServcie 구현 방법

Local

Binder 클래스의 서브 클래스 생성해서 구현

onBind 함수에서 서비스의 IBinder 객체 반환



Remote

Messenger와 Handler 사용

안드로이드 프레임워크에서 정형화로 제공하는 것

Handler 상속한 클래스 구현해서 현재 스레드에 할당된 looper 객체를 만들고 onBind에서 걔의 binder를 액티비티로 건네준다. 이때 Messenger의 객체를 통해서 주고 받는다.

액티비티는 Bundle에 키 값의 데이터를 넣고 Message 객체에 값을 세팅해서 반환 받은 service.send 함수를 통해 메시지를 전달

Handler 상속할 때 handleMessage 메서드 오버라이딩 하면서 메시지를 수신했을 때 처리할 동작 구현



AIDL 사용

Handler 방식은 순차적으로 Task를 처리하여 멀티 쓰레드가 안되지만 AIDL을 사용하면 멀티 쓰레드 지원 가능

AIDL 파일 생성

인터페이스 구현

Android SDK는 AIDL 파일 기반으로 java 언어로 인터페이스 생성해 줌

해당 인터페이스는 Binder를 상속

AIDL 인터페이스 메서드를 구현해주는 Stub이라는 내부 추상 클래스가 있는데 이를 확장하고 메서드 구현해야 함



Activity에서 서비스 바인딩

Service를 구현하고 onBind( )를 오버라이딩하여 Stub 추상 클래스를 상속받은 클래스의 객체 생성하여 반환

Activity에서 구현한 서비스 바인딩











Foreground Service

활성화된 액티비티와 동급의 우선순위를 가짐

상태바에 알림을 표시해야 함 - Notification

알림콘텐츠 설정 및 알람의 탭 작업 설정 - NotificationBuilder, PendingIntent 사용

채널 만들기 및 중요도 설정

알림 표시



API 28 이상 부터는 Manifest에 android.permission.FOREGROUND_SERVICE 명시해줘야 함

액티비티에서 startService로 호출하고 해당 서비스에서 onStartCommand에서 startForeground 호출하면 foreground service 시작





Notification

화면을 사용하지 않고 사용자에게 알림 기능을 제공

Channel을 생성

getSystemService를 통해 Manager 획득한 후 channel 등록


Notification 생성 후 NotificationManager를 통해 전송

PendingIntent, builder, icon, title 등을 세팅






정렬
Thu, 15 Jun 2023 08:23:01 GMT
정렬
Arrays.sort()

int, char와 같은 primitive type 배열 정렬 지원 (예외로 String도 지원)

해당 함수는 dual pivot quicksort 정렬 알고리즘을 활용. (primitive type일때)

일반 quickSort는 O(n^2) 복잡도를 지님
→ 이러한 퀵소트 속도를 보안하여 만든 것이 dual pivot quicksort.

dual pivot quick sort = 삽입 정렬 + 퀵 정렬

사용법


**오름차순**
import java.util.Arrays;

public class Sort {
    public static void main(String[] args)  {    
        int[] array = {58, 32, 64, 12, 15, 99};

        Arrays.sort(array);
    }
}
**일부 오름차순**
import java.util.Arrays;

public class Sort {
    public static void main(String[] args)  {    
        Integer[] array = {58, 32, 64, 12, 15, 99};

        Arrays.sort(array, 1, 4);
    }
}
내림차순 정렬

내림차순 정렬은 Collections 내에 있는 reverseOrder()을 활용
primitive type 배열: wrapper 클래스로 변경해서 사용
primitive type boxing 하는법

int[] arr = {4, 3, 6, 1, 2};
Integer[] arr2 = Arrays.stream(arr).boxed().toArray(Integer[]::new); //방법1
Arrays.sort(arr2, Collections.reverseOrder());

arr = Arrays.stream(arr).boxed().sorted(Collections.reverseOrder()).mapToInt(Integer::intValue).toArray(); //방법2

object type 배열: sort 내에 Collections.reverseOrder()을 바로 사용
사용법

**내림차순**
import java.util.Arrays;
import java.util.Collections;

public class Sort {
    public static void main(String[] args)  {    
        Integer[] array = {58, 32, 64, 12, 15, 99};

        Arrays.sort(array, Collections.reverseOrder());
    }
}
**일부 내림차순**
import java.util.Arrays;
import java.util.Collections;

public class Sort {
    public static void main(String[] args)  {    
        Intege array = {58, 32, 64, 12, 15, 99};

        Arrays.sort(array, 1, 4, Collections.reverseOrder());
    }
}
Object 배열 & N차원 배열 정렬

object 정렬 → timSort

tim sort = 삽입정렬 + merge sort

Comparator 인터페이스로 int compare(T t1, T t2)를 구현
  List sList = new ArrayList<>();

  Comparator cp = new Comparator<>() {
      @Override
      public int compare(Student s1, Student s2) {
          return s2.age - s1.age;
      }
  };

  Collections.sort(sList, cp);

t1, t2 순서로 정렬 ⇒ return 음수
t1 == t2 ⇒ return 0
t2, t1 순서로 정렬 ⇒ return 양수



Lambda를 활용한 정렬

comparator 객체는 method 1개인 함수형 인터페이스를 구현 ⇒ lambda 함수로 대체 가능
간결한 코드
예시: 문자열 length 길이에 따른 정렬

Arrays.sort(months,
            (String a, String b) -> a.length() - b.length());
→ 아래 코드: 더 깔끔한 방식
Arrays.sort(months, Comparator.comparingInt(String::length));
Stream으로 정렬

Stream 클래스의 sorted() method도 Comparator 객체를 인자로 받아 정렬함
기존 객체의 순서를 변경하지 않고, 새롭게 정렬된 객체를 생성할 때 사용

List sortedPlayers = players.stream()
        .sorted((a, b) -> b.getScore() - a.getScore())
        .collect(Collectors.toList());



Android(안드로이드) 4. 안드로이드 Component - Activity
Mon, 15 May 2023 07:24:26 GMT
Activity



생성

모든 액티비티는 Manifest 파일에 선언되어야 함

시작 액티비티는  태그 안에

action은 android:name=”android.intent.action.MAIN”

category에는 android:name=”android.intent.category.LAUNCHER”를 추가해야 한다.



AppCompatActivity( ) 상속해서 클래스 생성 → onCreate( ) 메서드 오버라이딩





생명 주기

onCreate( )

액티비티가 생성될 때 호출

UI 초기화에 사용 (주로 View를 만드는 작업을 수행)



onStart( )

액티비티가 사용자에게 표시되기 직전에 호출

onStop( )과 짝

액티비티가 실행되는 중에만 어떤 작업을 하고 싶으면 onStrart( )에서 실행되게 하고 onStop( )에서 중단되게 하면 된다.

onStart( )는 focus가 없는 상태

최초에 만들어 졌을 때 불린건지, background에서 있다가 와서 불린건지 구분이 필요

최초에 만들어지면 초기화 같은 과정이 필요하기 때문에




onResume( )

액티비티가 사용자와 상호작용하기 바로 직전에 호출됨

onResume( )은 focus가 있는 상태

onResume( ) 안에 함수들이 다 호출되고 나면 어플리케이션이 Activity Running 상태가 됨

이 시점에 현재 액티비티가 액티비티 스택의 최상위에 있다.

onPause( )와 짝



onPause( )

액티비티가 비활성화 되었을 때 호출

onResume( )과 짝

onPause( ) 호출될 때 View나 데이터를 Shared Preference를 통해 저장하고 나중에 onResume( ) 호출될 때 불러올 수 있다.



onStop( )

액티비티가 더 이상 사용자자에게 보여지지 않을 때 호출

이후에 onRestart( )를 거쳐서 onStart( )가 호출되면서 어플리케이션을 다시 호출할 수 있다.

액티비티가 완전히 소멸된 것은 아니다 화면에서 내려왔을 뿐



onRestart( )

onStop( )이 호출되었다가 액티비티가 화면에 다시 보여질 때 onRestart( )를 거쳐서 onStart( )가 호출된다.


onDestory( )

액티비티가 완전히 종료, 즉 어플리케이션을 완전히 종료했을 때 호출

어플리케이션을 다시 실행시키면 onCreate( ) 부터 다시 시작

finish( ) 메서드가 호출되거나 시스템 메모리 확보를 위해 액티비티 제거할 때 사용

메인 액티비티는 뒤로가기 해서 홈 화면으로 가도 작업 관리자에서 지우지 않는 이상 onDestory( ) 호출 안됨



액티비티 전환 시 lifeCycle

기존 액티비티의 onPause() 메서드가 호출됩니다. 이때, 액티비티는 더 이상 화면에 보이지 않고, 사용자와의 상호작용이 불가능해집니다.(focus 잃음)

바뀔 액티비티의 onCreate() 메서드가 호출됩니다. 이때, 액티비티가 생성되고 레이아웃을 구성하게 됩니다.

바뀔 액티비티의 onStart() 메서드가 호출됩니다. 이때, 액티비티가 화면에 보이기 시작합니다.

바뀔 액티비티의 onResume() 메서드가 호출됩니다. 이때, 액티비티가 사용자와 상호작용할 수 있는 상태가 되며, 애니메이션 등의 효과가 표시됩니다. (focus 획득)

만약 바뀐 액티비티가 이전에 생성된 액티비티와 서로 다른 태스크에 속하게 된다면, 이전 액티비티는 onStop() 메서드를 호출합니다. 이때, 액티비티는 더 이상 화면에 보이지 않게 됩니다.



화면 회전 시 life Cycle

화면 회전하면 기존 화면이 Destory 되었다가 rotation된 화면을 재생성한다.

기존 화면 destory : onPause( ) → onSaveInstanceState( ) → onStop( ) → on Destory( )

회전 화면 생성 : onCreate( ) → onStart( ) → onRestoreInstanceState( ) → onResume( )

finish( )나 뒤로가기로 종료하면 onSaveInstanceState( )는 호출되지 않음







Intent

어플리케이션 구성요소 4가지 간에 작업 수행을 위한 정보를 전달




명시적 인텐트

실행하고자 하는 컴포넌트 이름과 클래스 명이 명시적으로 작성되어 호출할 대상을 확실히 알 수 있는 경우 사용
  val Intent = Intent(this, NextActivity::class.java)
  startActivity(intent)






암시적 인텐트

인텐트의 액션과 데이터를 저장하긴 했지만 호출할 대상이 달라질 수 있는 경우에 사용

특정 컴포넌트를 지정하지 않고, 원하는 작업 의도만 담고 컴포넌트를 실행할 수 있음

액션과 데이터만 주고 어떤 컴포넌트를 사용할 지는 명시하지 않음

시스템이 해당 의도를 적절히 처리할 수 있는 컴포넌트를 찾아 해당 작업을 처리

action, data, category만 비교한다.

나머지 putExtra로 넣어준 건 시스템이 알 수 없어서 비교하지 않음



이때 처리할 수 있는 컴포넌트가 여러 개라면 chooser가 나옴








Intent 구성 요소

Action

수행할 액션 이름 (ex - ACTION_DIAL)


Data

수행할 데이터의 URI


Category

수행할 액션에 대한 추가적인 정보


Type

수행할 인텐트 데이터의 명시적인 타입(MIME 타입) - video/mpeg


Component name

대상 컴포넌트의 완전한 클래스 이름


Extras

인텐트를 다루는 컴포넌트에 추가적으로 전달할 한 쌍의 키와 값


Flag

동작 방식 결정 → 뒤로가기 시에 어떻게 이동할 지(history에 남길지)






Intent의 브로드캐스트 액션

브로드캐스트 리시버가 받을 수 있는 Action
registReceiver(BroadcastRecceiver, IntentFilter) 메소드의 IntentFilter에 정의하거나 Mainfest의 태그 안에 정의할 수 있음




Intent Filter

특정 인텐트를 받을지 말지를 정의하는 역할을 수행 이를 통해 컴포넌트의 특징이 정해짐
Intent Filter를 구성하는 요소는 인텐트 구성 요소와 동일




startActivity / requestActivity.launch

startActivity
단방향으로 실행 → 결과 돌려받지 못함


Launcher
결과를 다시 돌려 받을 수 있음







Android Permission
  


권한 종류

Install time permissions

앱에서 설치 권한을 선언하면 설치할 때 권한 부여

플레이 스토어에 명시되어 있는 권한



Runtime Permissions

실행시 획득해야 하는 권한

나머지는 선언만 하면 되지만 얘는 코드상으로 구현해야 함



Special Permissions

플랫폼과 OEM만이 정의할 수 있는 권한






순서

Manifest에 선언

앱에 권한이 부여되어 있는지 확인

사용하려는 권한을 이미 부여 받았다면 다시 요청하지 않음

checkSelfPermission( ) 메서드를 사용하여 이미 권한이 있는지 확인 가능

PERMISSION_GRANTED or PERMISSION_DENIED를 반환 받음




권한 요청

requestPermissions 메소드를 호출하면서 필요한 권한을 명시

요청하려는 권한이 한 개 이상이면 String 배열로 넘겨줄 수 있음



응답 처리

응답

사용자가 권한 요청에 응답하면 콜백 메서드인 onRequestPermissionsResult( )가 호출되고 여기서 결과 작업 진행


거부

사용자가 권한 요청을 거부하면 앱이 비정상 종료될 수 있음

dialog 띄워서 설정 화면으로 안내하는 것이 적절










Activity Task
  


Task

관련된 실행 액티비티들을 순서대로 묶어 관리하는 것

서로 다른 패키지의 액티비티가 실행되더라도 하나의 실행 흐름(Task) 안에 있게 됨




구조

Task는 스택의 형태로 구성 → 실행되는 액티비티들이 쌓이는 구조


뒤로가기 누르면 top 액티비티가 없어지고 다음 액티비티가 top이 됨


맨 마지막 root 액티비티가 없어지면 Task 완전 종료



Task 전환

홈 화면에서 새로운 앱을 실행시키면 새로운 Task 생성


최근 실행 앱 목록(작업 관리자)이 Task의 목록으로 top 액티비티들이 표시됨


앱 목록에서 원하는 Task 선택 시 해당 Task 동작





Task 제어의 필요성

반복되는 액티비티 또는 중복 실행 방지

액티비티 실행 모드와 Flag로 제어




Activity 실행 모드



Activity 실행 모드 종류

standard

기본 값으로 task 내에 중복된 액티비티 허용


singleTop

task 내에 top 액티비티와 동일한 액티비티를 실행하면 쌓지 않고 기존 top 액티비티 재사용

intent flag로 설정 가능 → Intent.FLAG_ACTIVITY_SINGLE_TOP

기존 lifeCycle로는 처음 호출된건지, 다시 호출된건지 확인할 방법이 없다.

onPause( )와 onResume( )이 반복되서 실행될 것이다.

onNewIntent 함수 필요(onPause → onNewIntent → onResume)





singleTask

위치와 상관없이 중복된 액티비티를 쌓지 않는다.

기존의 있는 액티비티까지 위에 있는 액티비티들 제거해서 이동

다른 Task에서 호출해도 무조건 자신의 Task로 오게 만들 수 있음

외부에서 호출하게 하려면 exported = true 설정 필요




singleInstance

중복을 허용하지 않을 뿐 아니라 혼자서 별도의 task 구성

task 내에는 오직 singleInstance로 설정된 액티비티 하나만 존재



설정 방법

Manifest에 등록 → 등록 시에 동장 방식 결정

intent의 Flag 이용 → 런타임 시에 동작 방식 결정





Task 내 Activity 정리 및 변경

액티비티 속성과 intent의 flag를 이용해 task 내의 특정 액티비티 제거 및 변경

액티비티 속성 → Manifest 파일에 설정

액티비티가 실행될 때마다 기본적으로 적용


flag 속성 → Intent 생성 후 설정

Manifest 파일에 선언된 액티비티의 속성을 재정의








noHistory / FLAG_ACTIVITY_NO_HISTORY

해당 액티비티는 Task 스택에 쌓이지 않는다.

다음 액티비티에도 뒤로가기 해도 얘는 없다 그 전의 액티비티로 이동


Manifest 설정 → android:noHistory=”true”

flag 설정 → intent.flags = Intent.FLAG_ACTIVITY_NO_HISTORY



FLAG_ACTIVITY_CLEAR_TASK

FLAG_ACTIVITY_NEW_TASK와 같이 사용되며 Task 내에서 다른 액티비티를 모두 삭제

intent.flags = intent.FLAG_ACTIVITY_CLEAR_TASK or intent.FLAG_ACTIVITY_NEW_TASK


예시
  예를 들어, Task A가 있다고 가정하겠습니다. Task A에는 액티비티 A, 액티비티 B, 액티비티 C가 있습니다. 이때, 액티비티 C에서 FLAG_ACTIVITY_CLEAR_TASK와 FLAG_ACTIVITY_NEW_TASK 플래그를 사용하여 액티비티 D를 시작하면, Task B가 새로 생성되고 액티비티 D가 Task B에 포함됩니다. 그리고 이전 Task A의 모든 액티비티(A, B, C)는 삭제됩니다.
  FLAG_ACTIVITY_CLEAR_TASK 플래그를 사용하는 경우는 대개 로그아웃 기능을 구현할 때 사용됩니다. 로그아웃 기능을 구현할 때, 앱에서 사용자의 인증 토큰 등을 삭제하고 로그인 화면으로 이동해야 합니다. 이때, FLAG_ACTIVITY_CLEAR_TASK와 FLAG_ACTIVITY_NEW_TASK 플래그를 사용하여, 이전의 액티비티 스택을 모두 삭제하고 로그인 화면부터 새로운 Task를 시작합니다.





FLAG_ACTIVITY_CLEAR_TOP

기존에 있던 액티비티 제거(상위 포함)하고 새로운 액티비티 생성

flag 설정 → intent.flags = intent.FLAG_ACTIVITY_CLEAR_TOP

FLAG_ACTIVITY_SINGLE_TOP과 조합하여 기존 액티비티 재활용

액티비티 실행모드 singleTask과 동일해짐

intent.flags = intent.FLAG_ACTIVITY_CLEAR_TOP or intent.FLAG_ACTIVITY_SINGLE_TOP

해당 액티비티가 noHistory가 아닌지 확인해보고 실행







Kotlin(코틀린) 심화문법 2. 고차 함수, 코틀린 표준 함수, Generic
Thu, 13 Apr 2023 13:32:25 GMT
고차 함수



정의

매개 변수나 함수의 반환 값으로 함수가 사용되는 함수

코틀린에서는 람다나 함수 참조를 사용해 함수를 변수에 넘길 수도 있고 그 자체가 값이 되기도 함





예시 1

다른 함수를 인자로 사용하거나 함수를 결과값으로 반환하는 함수

private fun highOrderFunction(sum: (Int, Int) -> Int, a: Int, b: Int): Int = sum(a, b)

fun main() {
    println(highOrderFunction({ x, y -> x + y }, 20, 30))
}
<--출력 결과-->
50

highOrderFunction

파라미터(Int, Int) → Int인 함수(sum)와 Int, Int 총 3개를 받는 함수

함수의 body에서는 전달받은 함수 sum을 실행하며 두 개의 변수 a, b를 넘겨줌







예시 2

일반 함수를 인자나 반환 값으로 사용하는 함수

private fun sum(a: Int, b: Int): Int = a + b
private fun sumFunction(): Int = sum(40, 2)

fun main(){
    println($sumFunction()
}
<--출력 결과-->
42



예시 3

람다식을 인자나 반환 값으로 사용하는 고차 함수

val multiply = {x: Int, y: Int -> x*y}

println(${multiply(8,8)})
<--출력 결과-->
64



예시 4

변환 자료형이 아예 없거나 매개변수가 하나만 있을 때의 람다식 함수

val helloWorld: () -> {println("Hello World!")}
val outSelfSum: (Int) -> Int = {a -> a+a}
helloWorld()
println(ourSelfSum(10))
<--출력 결과-->
Hello World!
20



예시 5

람다식 안에 람다식을 넣는 람다식 함수

val nestedLambda: () -> () -> Unit = {{print("nested")}}



예시 6

인자와 반환 값이 없는 람다식 함수

val print: () -> Unit = {print("print")}
val print2 = {println("print")}
print()
print2()
<--출력 결과-->
print
print



예시 7

파라미터 1개의 람다식인 경우는 괄호 밖으로 빼서 표현 가능

fun main() {
    callFunction({println("hello")} )

    callFunction(){
        println("hello")
    }
    callFunction {
        println("hello")
    }
}

private fun callFunction( call:() -> Unit )  = call()
<--출력 결과-->
hello
hello
hello



예시 8

파라미터가 1개 이상인 람다식의 경우, 람다식을 제일 뒤로 이동해서 괄호 밖으로 빼서 표현 가능

제일 처음 살펴 본 highOrderFunction의 경우처럼 여러 개의 파라미터를 받는 경우, 람다식을 제일 마직막으로 이동시키면 메서드 밖으로 이동 가능


private fun highOrderFunction(a: Int, b: Int, sum: (Int, Int) -> Int): Int = sum(a, b)

fun main() {
    println(highOrderFunction(20, 30, {x, y -> x + y}))

    var result = highOrderFunction(20, 30){
            x, y -> x + y
    }

    println(result)
}
<--출력 결과-->
50
50



코틀린 표준 함수



표준 함수

코틀린에서 유틸리티성으로 제공하며 람다를 인자로 받아 동작하는 함수

확장함수의 형태로 모든 객체에서 호출 가능

객체를 초기화 할 때 실행할 코드가 있는 경우 등에서 자주 사용됨

java에서 객체의 내용을 참조하려면 object를 reference에 변수에 저장한 후 변수에 ‘ . ‘으로 접근했으나 코틀린에서는 표준함수를 사용하여 바로 접근 가능

let( ), apply( ), run( ), with( ), also( )
  


let( )

let( )을 호출하는 객체의 람다식 안에 파라미터로 넘김

‘it’을 통해 호출 객체에 접근

{ } 의 결과값을 반환

제일 마지막 줄을 return



fun main() {
    letTest()
}

fun letTest() {
    var arr = arrayOf(1, 2, 3)
    // let은 젤 마지막 줄이 리턴
    var result = arr.let {
        println("${it[1] + it[2]}")
        it[1] + it[2]
    } //let 람다식 계산 결과를 리턴

    println(result)

    //let 람다식에서 계산한 arr[1] + arr[2] 를 반환하고 arr[0]을 더해서 출력
    val result2 = arr.let { it[1] + it[2] }.plus(arr[0])
    println("더하기 결과: $result2")
}
<--출력 결과-->
5
5
더하기 결과: 6



also( )

also( )를 호출하는 객체의 람다식 안에 파라미터로 넘김
‘it’을 통해 호출 객체에 접근
호출 객체 자체를 반환
받은 객체의 값을 바꿔서 그 객체 자체를 return



fun main() {
    alsoTest()
}

fun alsoTest(){
        var student = Student("Park",11)

            // also는 return x
            var student2 = student.also {
        it.age = 15
        it.name = "kim"
    }

    println(student) //Student(name=kim, age=15)
    println(student2) //Student(name=kim, age=15)
}



apply( )

apply( )를 호출하는 객체의 람다식 안에 파라미터로 넘김
‘this’를 통해 호출 객체에 접근
this는 생략 가능
호출 객체 자체를 반환
받은 객체의 값을 바꿔서 그 객체 자체를 return



data class Student2(var name : String, var age : Int)
fun main() {
    applyTest()
}
fun applyTest() {
    var student = Student2("Park", 11)

    var student2 = student.apply {
        age = 15 //this 생략
        name = "kim" //this 생략
    }
    println(student) //Student2(name=kim, age=15)
    println(student2) //Student2(name=kim, age=15)
}



run( )

호출 객체를 파라미터로 넘기는 방식과 객체 없이 사용하는 방식 모두 가능

{ }의 결과값을 반환

제일 마지막 줄을 return



fun main() {
    runTest()
}
fun runTest() {
    var a = 10
    var b = 15

    //객체없이 run 단독 사용
    var result = run {
        var c = a + b
        println(c) //25
        c
    }//더하기 작업 수행 후 결과 c 반환

    //객체에 run 사용.
    result = result.run {
        plus(5)
    }
    println(result) //30
}



with( )

인자로 받는 객체를 블럭의 파라미터로 전달

run( ) 함수와 기능은 거의 동일

Safe Call 지원하지 않음 → 종종 let과 함께 사용됨

with은 ‘ . ‘ 없이 ( )로 인자를 받는다.

변수?. 뒤에 함수가 나오면 변수가 null일 때 뒤에 함수를 실행하지 않아서 safe call이 가능한데 with은 위와 같이 호출하지 않기 때문에 Safe Call을 하지 못한다.
  var newName = people?.let{
          with(it){
                  age = 20
                  name
          }
  }




data class People(var name : String, var age : Int)

fun main() {
    withTest()
}
fun withTest(){
    var people = People("Park", 15)

    var newAge = with(people){
        age = 20
        age
    }

    println(newAge) //20

}




Generic



정의

클래스나 함수를 정의할 때 타입을 정하지 않고 포괄적으로 받아 들일 수 있는 상태로 선언

타입 매개 변수를 (< >)를 클래스나 인터페이스 이름 뒤에 붙이면 제네릭하게 만들 수 있음


class Box(t: T){
        var value = t
}



예시 1

제네릭 클래스 / 인터페이스 정의

// kotlin
class Car2 {
}

// 항목을 담거나 뺄 수 있는 제네릭 인터페이스 Container 정의
interface Container {
    fun put(item: T)
    fun take(index: Int) : T
}

// 자동차(Car)를 담거나 뺄 수 있는 클래스 Garage 정의
class Garage : Container {
    private val items:MutableList = arrayListOf();
    override fun put(item: Car2) {
        items.add(item)
    }

    override fun take(index:Int): Car2 {
        return items.get(index)
    }
}



예시 2

제네릭을 통한 Todo list 작성

data class ToDo(val title: String,
                val content: String,
                var idx: Int = todoIdx++,
                var completed: Boolean = false)

interface ToDoContainer {
        companion object Todo{
                var todoIdx = 1
        }
    fun addNewItem(item: T)
    fun markCompleted(idx: Int)
}



예시 3

제네릭을 통한 Todo list 작성

ToDoContainer에 제네릭을 사용하고 매개변수로 Todo 클래스를 대입

filter 함수는 조건에 알맞은 리스트를 반환




class ToDoContainerImpl : ToDoContainer {
    var todoItems: MutableList = arrayListOf()
    override fun addNewItem(item: ToDo) {
        println("addNewItem : $item")
        todoItems.add(item)
    }
    override fun markCompleted(idx: Int) {
        todoItems.filter { it.idx == idx }[0].let {
            it.completed = true
            println("$idx is marked as completed")
            println("$it")
        }
    }
}



예시 4

제네릭을 통한 Todo list 작성

아이템을 추가하고 완료한 일을 체크하는 메서드 markCompleted의 인자로 1을 넣고 호출



fun main(){
    var todayTodoList = ToDoContainerImpl()
    todayTodoList.addNewItem(ToDo("자바공부", "자바 기본은 마스터 했음."))
    todayTodoList.addNewItem(ToDo("코틀린공부", "코틀린 공부를 시작하자!!!!"))
    todayTodoList.markCompleted(1)
}
<--출력 결과-->
addNewItem : ToDo(title=자바공부, content=자바 기본은 마스터 했음., idx=1, completed=false)
addNewItem : ToDo(title=코틀린공부, content=코틀린 공부를 시작하자!!!!, idx=2, completed=false)
1 is marked as completed
ToDo(title=자바공부, content=자바 기본은 마스터 했음., idx=1, completed=true)



in / out

타입 매개변수의 업 혹은 다운 캐스팅을 할 수 있도록 지원되는 키워드

out : B_{을 B에 대입할 수 있도록 지원}

in : C을 C_{에 대입할 수 있도록 지원}


: A<*>은 타입 인수가 무엇이든 상관 없이 대입할 수 있도록 지원





class A
class B
class C

fun main() {
    //T 로 선언된 경우
    val a: A = A() // 양쪽 자료형 일치해야 함.

    //out T 로 선언된 경우
    val b1: B = B(); // 양쪽 자료형 일치 -> OK
    val b2: B = B(); // 왼쪽이 Super 면 -> OK
//    val b3: B = B(); // 왼쪽이 Sub 면 -> 컴파일 오류

    //in T 로 선언된 경우
    val c1: C = C() // 양쪽 자료형 일치 -> OK
    val c2: C = C() // 오른쪽이 Super면 -> OK
//    val c3: C = C() // 오른쪽이 Sub 면 -> 컴파일 오류

    /* <*> 은 상관없이 대응 */
    val star1: A<*> = A()
    val star2: A<*> = A()
    val star3: A<*> = A()
}



Android(안드로이드) 3. 안드로이드 UI 기본
Tue, 11 Apr 2023 12:29:41 GMT
UI 기본 구조



Activity

사용자 화면을 제공하는 컴포넌트




View

화면에 보이는 대부분의 요소들은 View의 하위 클래스

액티비티 자체는 앱의 실행 단위인 컴포넌트

액티비티에 버튼, 문자열, 이미지 등을 출력해줘야 화면에 보임






View의 계층 구조

ViewGroup

뷰 그룹은 레이아웃 및 뷰 컨테이너의 기본 클래스


ViewGroup 종류

뷰 컨테이너

ViewPager
유저가 페이지를 좌우로 넘길 수 있는 레이아웃 관리자 클래스


Toolbar
특정 화면에서 가능한 행동들을 제시하는 뷰
보통 안드로이드에서는 상단에 위치




기본 Layout 클래스

LinearLayout(선형으로 배치)
RelativeLayout(상대 위치로 배치)
FrameLayout(겹쳐서 배치)
GridLayout(표 형태로 배치)
ConstraintLayout(계층 구조로 배치)








View의 대표적인 서브 클래스들

Button

일반적으로 생각하는 버튼 모양의 뷰

주로 클릭 시 호출되는 setOnClickListener를 이용하여 사용



EditText

텍스트를 수정하면 입력할 수 있는 뷰


CheckBox

선택하거나 취소할 수 있는 특정 유형의 두 가지 상태를 가지고 있는 버튼


RadioButton

여러가지 동일한 형태의 선택할 수 있는 버튼 중 하나를 고르는 버튼


ImageView

이미지 파일을 화면에 보여줄 수 있는 뷰


이 외에도 많은 View가 있고 각 View들은 공통 속성을 가짐

Color, Dimensions Positioning

Focus

Interactive

Visible

다른 View와 관계를 가질 수 있음







레이아웃 편집기

안드로이드에는 View를 편하게 다룰 수 있는 레이아웃 편집기가 존재



Palette 

레이아웃으로 드래그해서 사용할 수 있는 다양한 뷰 및 뷰 그룹을 포함


Component Tree

레이아웃에서 구성요소의 계층 구조를 보여줌


툴바

편집기에서 레이아웃 모양을 구성하고


디자인 편집기

디자인 뷰나 청사진 뷰 또는 두 뷰 모두에서 레이아웃을 수정


Attributes

선택한 뷰의 속성을 제어할 수 있는 영역


뷰 모드

레이아웃을 코드 모드, 디자인 모드, 분할 모드 중 하나로 표시
분할 모드는 코드 모드와 디자인 모드 동시에 보여줌


확대/축소 및 화면 이동 제어

편집기 내에서 미리보기의 크기와 위치를 제어






Android Resource

리소스
  


- 레이아웃의 코드에서 변하지 않는 데이터 분리

- 문자열, 치수, 이미지, 메뉴 텍스트, 색, 스타일
- drawable
    - 이미지, 이미지와 관련된 XML, 그림을 표현한 XML
- layout
    - 화면 UI를 정의한 레이아웃 XML
- values
    - 문자열, 색상, 크기 등 여러 가지 값
- menu
    - 액티비티의 메뉴를 구성하기 위한 XML
- mipmap
    - 앱 아이콘 이미지
    

안드로이드 치수

dpi(Dots per Inch)

1인치(2.54cm)에 들어 있는 픽셀의 수(안드로이드에서는 dpi 160이 기본)

ldpi : 120dpi
mdpi : 160dpi (기본)
hdpi : 240dpi
xhdpi : 320dpi
xxhdpi : 480dpi
xxxhdpi : 640dpi




dp 또는 dip(Density-independent Pixels)

픽셀에 독립적인 단위이면서 어떤 화면의 크기에서도 동일한 크기를 나타낼 수 있음

스크린의 픽셀과 dp가 160인 경우에는 1dp는 1pixel과 같으나 dpi가 240인 경우에는 1dp는 1.5pixel

dp = pixel / (density / 160)




sp(Scale-independent Pixels)

dp의 비슷한 부분이 있으나 사용자가 선택한 글꼴 크기에 의해 크기가 조절됨


pt

1/72 inch 기반의 물리적 화면 사이즈, 인쇄에서 쓰이던 크기, 안드로이드에서는 잘 사용하지 않음


px(Pixels)

스크린의 실제 픽셀 단위를 사용하고 실제 크기나 밀도와 관계 없음


mm(Millimeters)

화면의 물리적 사이즈 기반으로 millimeter를 사용


in(Inches)

화면의 물리적 사이즈 기반으로 inch를 사용


보통 글꼴 크기만 sp를 사용하고 나머지는 모두 dp를 사용





Android(안드로이드) 2. 안드로이드 파일 구조
Mon, 10 Apr 2023 07:31:46 GMT
디렉터리 파일 구조



AndroidManifest.xml

앱의 메인 환경 파일이다.




    
        
            
                

                
            
        
    



manifest

태그를 통해 이 문서가 manifest에 관련된 문서라는 것을 시스템이 알 수 있음

‘xmlns:android’는 android라는 네임스페이스를 선언

http://schemas.android.com/apk/res/android


‘package’의 경우 해당 어플리케이션이 속한 패키지 이름을 지정



application

애플리케이션의 정보 정의

android:allowBack

백업 및 복구 기능을 사용할 것인가 여부(기본값 : true)


android:icon

어플리케이션 전체를 위한 아이콘과 각각의 컴포넌트를 위한 아이콘


android:label

어플리케이션을 나타내는 사용자가 읽을 수 있는 라벨
간단히 말해 어플 이름


android:roundIcon

적응형 아이콘 적용


android:supportsRtl

어플리케이션의 RTL(Right-To-Left) 지원 여부
RTL : 오른쪽에서 왼쪽으로 글씨를 읽는 경우 지원


android:theme

어플리케이션 안의 모든 기능들의 기본 테마 정의


activity 태그

어플리케이션의 시각적 사용자 인터페이스 요소인 액티비티 선언
모든 액티비티는 manifest의 activity 태그에 등록해야 함


android:name

액티비티의 클래스명 설정


android:exported

이 액티비티가 외부에서 실행될 수 있는지 없는지 설정
외부에서 호출할 수 있으면 true
MainActivity는 런처에서 실행해야 하므로 항상 true




intent-filter 태그

수신할 intent를 지정한다.
action 태그
수신할 action명을 지정. 런처에서 클릭하는 아래 action의 Intent가 생성
android.intent.action.MAIN


런처에서 클릭하면 첫 액티비티로 해당 액티비티를 시작
action 태그는 하나만 존재 가능


category 태그
액션과 함께 수신할 Intent의 특징을 나타내는 항목
android.intent.category.LAUNCHER
이 액티비티가 최초 액티비티, 시스템의 애플리케이션 시작 관리자 목록으로 게재
category 태그는 여러 개 존재 가능


런처에서 클릭하면 해당 액티비티를 실행한다는 뜻







    
MainActivity.kt
package com.ex1

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

AppCompatActivity를 상속 받아 사용

AppCompatActivity는 Activity의 서브 클래스


onCreate( )

액티비티가 실행될 때 시스템이 호출하는 함수

setContentView( ) 함수를 통해 화면을 출력

R.layout.activity_main을 매개변수로 지정하였으므로 res/layout/activity_main.xml을 사용하여 화면을 구성








activity_main.xml



    



ConstraintLayout

루트 요소인 ConstraintLayout은 자식 요소들의 위치를 상대적으로 배치

여기서는 자식인 TextView의 배치를 담당

추후 Layout에서 상세히 설명



TextView

문구를 화면에 표시하는 view

View 객체를 상속 받음

여기서는 Hello world!를 출력







Gradle

안드로이드 빌드 자동화 시스템

bulid.gralde 파일을 통해 여러가지 환경 설정

프로젝트를 위한 build.gradle과 모듈을 위한 build.gradle 존재

안드로이드 스튜디오 plugin과 Gradle은 항상 버전을 맞춰줘야 함

gradle-wrapper.properties에서 Gradle 버전 확인

project structure에서 plugin 정보 확인

안드로이드 공식 홈페이지에 plugin과 gradle 버전 매칭 정보 확인

프로젝트 수준의 Gradle
  plugins {
      id 'com.android.application' version '7.4.2' apply false
      id 'com.android.library' version '7.4.2' apply false
      id 'org.jetbrains.kotlin.android' version '1.8.0' apply false
  }

모든 모듈을 위한 최상위 설정을 목적

plugins

gradle이 build할 때 사용할 plugin 선언
kotlin 버전 지정
모듈 gradle 파일에서 버전 없이 이름만으로 사용. 대부분 application으로 생성하지만 library도 가능





모듈 수준의 Gradle
  plugins {
      id 'com.android.application'
      id 'org.jetbrains.kotlin.android'
  }

  android {
      namespace 'com.ex1'
      compileSdk 33

      defaultConfig {
          applicationId "com.ex1"
          minSdk 24
          targetSdk 33
          versionCode 1
          versionName "1.0"

          testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
      }

      buildTypes {
          release {
              minifyEnabled false
              proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
          }
      }
      compileOptions {
          sourceCompatibility JavaVersion.VERSION_1_8
          targetCompatibility JavaVersion.VERSION_1_8
      }
      kotlinOptions {
          jvmTarget = '1.8'
      }
  }
  dependencies {

      implementation 'androidx.core:core-ktx:1.7.0'
      implementation 'androidx.appcompat:appcompat:1.6.1'
      implementation 'com.google.android.material:material:1.8.0'
      implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
      testImplementation 'junit:junit:4.13.2'
      androidTestImplementation 'androidx.test.ext:junit:1.1.5'
      androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
  }

모듈에 대한 특성 정의

파일을 수정하면 Sync Now를 이용해 프로젝트에 반영해야 함







Kotlin(코틀린) 심화문법 1. 추상 클래스/인터페이스/data 클래스/object 클래스/enum 클래스/sealed 클래스/inner 클래스
Wed, 05 Apr 2023 10:50:46 GMT
추상 클래스와 인터페이스



abstract class

상속 받을 클래스에서 구현해야 할 프로퍼티 및 메서드를 기술한 클래스

abstract 키워드와 함께 선언하며 추상 클래스는 객체 생성 불가

상속을 주기 위해서는 open 키워드를 선언해야 하는데 abstract class는 open이 기본적으로 적용됨

java와 달리 추상 프로퍼티를 가질 수 있음

반드시 하위 클래스에서 재정의하여 초기화 해야 함


예제 코드
  // 추상 클래스, 주 생성자에는 비추상 프로퍼티 선언의 매개변수 3개가 있음
  abstract class Vehicle(val name: String, val color: String, val weight: Double) {
      // 추상 프로퍼티 (반드시 하위 클래스에서 재정의해 초기화해야 함) -> 자바와 차이점
      abstract var maxSpeed: Double
      // 일반 프로퍼티 (초기 값인 상태를 저장할 수 있음)
      var year = "2018"
      // 추상 메서드 (반드시 하위 클래스에서 구현해야 함)
      abstract fun start()
      abstract fun stop()
      // 일반 메서드
      fun displaySpecs() {
          println("Name: $name, Color: $color, Weight: $weight, Year: $year, Max Speed: $maxSpeed") }
  }
  class Car(name: String, color: String, weight: Double, override var maxSpeed: Double) : Vehicle(name, color, weight) {
      override fun start() {
          println("Car Started") // 코드의 구현
      }
      override fun stop() {
          println("Car Stopped") // 코드의 구현
      }
  }
  class Motorcycle(name: String, color: String, weight: Double, override var maxSpeed: Double) : Vehicle(name, color, weight) {
      override fun start() {
          println("Bike Started") // 코드의 구현
      }
      override fun stop() {
          println("Bike Stopped") // 코드의 구현
      }
  }
  fun main() {
      val car = Car("SuperMatiz", "yellow", 1110.0, 270.0)
      val motor = Motorcycle("DreamBike", "red", 173.0, 100.0)
      car.year = "2013"
      car.displaySpecs()
      car.start()
      motor.displaySpecs()
      motor.start()
  }
  





interface

자바와 동일하게 구현부가 없는 method + default method의 집합

default 키워드는 따로 없음


상속을 주기 위해 만들어진 클래스로 별도의 open 키워드는 필요 없음

상속 받는 interface에서 동일한 function이 있다면 반드시 구현해야 함

예제 코드
  interface Clickable {
      fun click()
      fun showOff(){
          println("Clickable.showOff")
      }
  }
  interface Focusable{
      fun showOff(){
          println("Focusable.showOff")
      }
  }
  class Button : Clickable, Focusable {
      override fun click() {
          println("Button.click")
      }
      //showOff는 두 슈퍼에 모두 존재하므로, 동일하게 애매함을 없애기 위해서 반드시 선언.
      //super에 선언된 fun을 호출할때는 super.showOff()
      //java에서는 Clickable.super.showOff();
      override fun showOff() {
          println("Button.showOff")
      }
  }

  fun main() {
      var button = Button()
      button.click()
      button.showOff()
  }
  




data class



특징

data class 키워드로 선언해서 사용

변수나 상수를 선언할 수 있음 (구분은 쉼표( , ) 로)

프로퍼티를 일반 클래스 내의 프로퍼티를 기준으로 생성자가 만들어짐

DTO(Data Transfer Object)를 다룰 때 유용

자바와 다르게 getter, setter 만들 필요가 없고 초기화도 필요 없이 선언하기만 하면 끝





일반 클래스 vs data class

일반 클래스와 달리 소괄호로 프로퍼티를 선언하면 끝

자동으로 파라미터 생성자, toString( ), equals( ), hashCoode 등 제공

{ } 열어서 function 추가도 가능

예시 코드
  //일반 클래스
  class Person20(var name: String) {
      private var type: String = ""
      private var age: Int = 0

      constructor(name: String, type: String, age: Int) : this(name) {
          this.type = type
          this.age = age
      }

      fun myMbTi() {
          println("my name is $name and type is $type")
      }
  }
  //data clas
  data class PersonData(val name: String, val type: String, var num: Int, var own: Boolean)

  fun main(args: Array) {

      val person20 = Person20("김싸피", "ENFP", 23)
      person20.myMbTi()

      val person = PersonData("김싸피", "ENFP", 23, true)
      println(person)

      if (person.own)
          println("my name is  ${person.name}")
      else
          println("i'm not human being")

  }
  




object class



특징

object 키워드로 선언

class 키워드 위치에 object 키워드 선언 → 싱글톤 클래스가 됨


생성자를 갖지 않음

생성자가 private로 선언되므로 가질 수 없음 → 싱글톤


어느 클래스, 함수에서든 별도의 객체화 과정 없이 접근 가능

프로그램이 실행되는 동안 저장된 데이터는 손실되지 않고, 프로그램이 종료되면 소멸

위 특징 덕분에 안드로이드에서는 액티비티, 프래그먼트 구분하지 않고 데이터 전달 가능

anonymous nested class를 생성할 때 사용

익명 객체 = 재사용 없는 객체 = 일회성 객체


예제 코드
  object PersonObject {
      var name: String = ""
      var type: String = ""
      var age: Int = 0

      fun myType() {
          println("my name is $name and type is $type age is $age")
      }
  }

  fun main() {
      val name = "samsung"
      val type = "ENFP"
      val age = 23

      PersonObject.name = name
      PersonObject.type = type
      PersonObject.age = age
      PersonObject.myType()
      println("${PersonObject.name} and ${PersonObject.type} and ${PersonObject.age}")
  }
  




enum class



특징

java와 동일한 열거형

[클래스 이름.name] 으로 이름 값 접근 가능

[클래스 이름.ordinal] 으로 해당 값이 몇 번째에 기록되어 있는지 순서 값 접근 가능

인자가 있는 열거형 클래스인 경우 열거 값들을 표현하는 방식을 다채롭게 할 수 있음





인자 없는 열거형 클래스

별도의 인자가 없는 가장 기본적인 형태의 열거형 클래스
  enum class ExHandsome {
      EX, LOVE, PEACE
  }

  fun main() {
      val exEnum: ExHandsome = ExHandsome.LOVE
      println("${exEnum.name} ... ${exEnum.ordinal}")

      val exEnum2: Array = ExHandsome.values()

      for (i in exEnum2.indices) {
          println(exEnum2[i].name)
      }

  }
  





인자 있는 열거형 클래스
enum class Human(val age: Int) {
    KIM(25), CHOI(21)
}

fun main() {
    val human: Human = Human.KIM
    println("${human.name}, ${human.age}, ${human.ordinal}")

}



sealed class



특징

부모 클래스의 상속을 받는 자식 클래스의 종류를 제한하는 클래스

sealed class에 정의된 하위 클래스 외의 다른 하위 클래스는 존재하지 않는다는 것을 컴파일러에게 알려줌

sealed class 키워드를 선언해서 사용

sealed class도 추상 클래스로 객체 생성 불가

sealed class와 그 하위 클래스는 동일한 파일에 정의되어야 함.

하위 클래스는 class, data class, object class로 정의 가능

예시 코드
  sealed class Color {
      object Red : Color()
      object Green : Color()
      object Blue : Color()
  }
  fun main() {
      val color: Color = Color.Red

          val font = when (color) {
          is Color.Red -> "Noto Sans"
          is Color.Green -> "Open Sans"
          is Color.Blue -> "sans-serif"
          // No error!
      }
      println("결정된 font는 : $font")

          val font2 = when (color) {
          is Color.Red -> "Noto Sans"
          is Color.Green -> "Open Sans"
          is Color.Blue -> "sans-serif"
      }
      println("결정된 font는 : $font")
  }
  






sealed class  vs  enum

공통점

둘 다 타입을 제한할 때 사용


차이점

enum은 하나의 객체만 생성 가능

sealed class는 여러 개의 객체 생성 가능



예시 코드
  sealed class Expr

  data class Const(val number: Double) : Expr()
  data class Sum(val e1: Expr, val e2: Expr) : Expr()
  object NotANumber : Expr()

  fun eval(expr: Expr): Double = when (expr) {
      is Const -> {
          expr.number
      }
      is Sum -> {
          eval(expr.e1) + eval(expr.e2)
      }
      is NotANumber -> {
          Double.NaN
      }
  }

  fun main() {
      val num1 = Const(10.0)
      val num2 = Const(20.0)
      val sum = Sum(num1, num2)
      val result = eval(sum)
      println("result : $result")  //30.0

  }
  




inner class



특징

자바에서는 클래스 안에 클래스를 정의하면 자동으로 내부 클래스가 되었지만 코틀린에서는 클래스 안에 클래스 선언하면 그냥 중첩 클래스가 됨

내부 클래스로 만드려면 inner 키워드로 선언해야 함

내부 클래스는 기본적으로 외부 클래스를 참조 할 수 있지만, 중첩 클래스는 선언이 클래스 내부에 있을 뿐 외부 클래스의 member에 접근 불가





Nested class  vs Inner class
// nested class중첩 클래스
classOuter {
private valbar: Int = 1

classNested {
// nested class는 외부 클래스 멤버 참조 불가 (자바에선 가능했다.)
        //그냥 안에 있는 클래스 정도라 생각해라
// fun foo() = bar
funfoo() = 2
    }
}

// inner class내부 클래스
classOuterInner {
private valbar: Int = 1

inner classInner {
funfoo() = bar
//        fun foo() = this@OuterInner.bar
}
}

funmain() {

valdemo = Outer.Nested().foo()
valdemo2 = OuterInner().Inner().foo()
println(demo)// 2
println(demo2)// 1
}



가시성 지시자

가시성 지시자(Visibility modifiers)를 통해서 외부 접근 범위를 정할 수 있음

private

외부에서 접근 불가


protected

상속 관계에 있을 때만 외부에서 접근 가능


internal

같은 모듈 내에서 접근 가능


public

어디서든 접근 가능(기본값)








Android(안드로이드) 1. 안드로이드 구조
Tue, 04 Apr 2023 14:47:50 GMT
안드로이드 플랫폼 구조



안드로이드 플랫폼 아키텍처


Linux Kernel

보안, 메모리 관리, 프로세스 관리, 파일 시스템 관리, 파워 관리, 네트워크 스택, 하드웨어 드라이버 등 하드웨어를 지원


HAL

Hardware Abstraction Layer(하드웨어 추상화 계층)

상위 수준의 Java API 프레임워크에 기기 하드웨어 기능을 노출하는 표준 인터페이스를 제공

HAL은 여러 라이브러릴 모듈로 구성되어 있으며, 카메라 또는 블루투스 모듈과 같은 특정 유형의 하드웨어 구성 요소를 위한 인터페이스를 구현

프레임워크 API가 기기 하드웨어에 엑세스하기 위해 호출을 수행하면 Android 시스템이 해당 하드웨어 구성 요소에 대한 라이브러리 모듈을 로드





Native C / C++ Libraries

안드로이드 프레임워크에서 필요한 C와 C++ 라이브러리를 제공


Android Runtime

코어 라이브러리 지원, Dalvik | ART Virtual Machine으로 안드로이드 애플리케이션 실행환경을 제공


Java API Framework

안드로이드 어플리케이션 개발 시 필요한 API를 제공


System Apps

Email 클라이언트, SMS 프로그램, 달력, 지도, 브라우저 등의 코어 어플리케이션을 제공






App Components

컴포넌트란

컴포넌트는 앱 내에서의 독립적인 실행 단위(구성 단위)

컴포넌트 여러 개를 조합하여 하나의 앱을 만듦

일반 클래스와 달리 생명주기를 안드로이드 시스템이 관리

독립적인 실행 단위라는 말은 직접 코드로 결합해서 실행하는 것이 아니라 컴포넌트 간에 Intent라는 특정 클래스를 매개로 하여 결합하지 않은 상태로 실행하는 구조



Main 함수 같은 애플리케이션의 진입 지점이 따로 없음

런처의 아이콘을 클릭해서 실행하면, 최초 시작인 경우 메인 화면이 보이게 됨
알림을 눌러서 진입하면, 이때는 해당 알림이 원하는 화면이 보이게 됨




컴포넌트 종류

Acitivity
UI를 구성하기 위한 컴포넌트


Service
UI 없이 백그라운드에서 수행하는 컴포넌트


Broadcast Receiver
이벤트로 수행되는 컴포넌트(방송을 수신하는 컴포넌트)


Content Provider
어플리케이션 간 데이터를 공유하기 위한 컴포넌트


이 4가지 컴포넌트는 서로 연관성이 하나도 없고 완전히 별개로 동작한다.






DVM, ART



DVM(Dalvik Virtual Machine)

초기 안드로이드 런타임 시 사용됨

Android 2.2 이후 JIT 컴파일러로 처음 적용됨

JIT는 Just In Time으로 자주 사용되는 부분에 대해 미리 컴파일해 기계어로 해석해놓음으로써 성능을 향상시키고 실행시에 인터프리팅을 시작함



ART(Android Run Time)

AOT 컴파일러 사용

AOT는 Ahead On Time으로 설치 시점에 이미 컴파일을 완료하여 기계어로 해석을 끝내고 실행 시에는 해석 과정 없이 곧바로 기계어로 실행


Android 4.4(API 19)에서 처음으로 등장, 도입

이때는, DVM과 선택적 사용


Android 5.5(API 21) 이후 기본 런타임으로 지정

Android 7.0 이후로는 AOT+JIT

미리 기계어로 컴파일 해놓고 실행시에는 기계어를 실행






Kotlin(코틀린) 기본문법 6. Inheritance(상속) / Polymorphism(다형성) / Delegation(위임)
Sun, 02 Apr 2023 12:35:47 GMT
Inheritance(상속)



Inheritance

모든 클래스는 Any의 하위 클래스이며, 기본적으로 상속 줄 수 없는 final class로 만들어짐

java와 반대로 기본이 final class로 선언(상속 불가)

파생 클래스를 허용하려면 open 키워드를 사용하여 상속 가능한 상태로 선언해야 함


extends 키워드 대신 콜론( : ) 사용
  open class 부모 클래스 명{ //open으로 선언하여 파생 가능
  }
  class 자식 클래스 명: 부모 클래스 명( ){ //부모 클래스 상속, open 키워드 업음 -> 파생 불가
  }

java는 메소드만 오버라이딩 가능하지만 코틀린은 프로퍼티도 가능





상속 예제
open class Human(var name: String = "홍길동", var age: Int){ //주생성자
    fun play() = println("name : $name")
    fun sing(vol: Int) = println("Sing age : $age")
}
//주생성자를 사용하는 상속
class Woman(name: String, age: Int): Human(name, age){
    fun singHitone() = println("Happy song!")
}
//부생성자를 사용하는 상속
class Man: Human{
    val race: String
    constructor(name: String, age: Int, race: String): super(name, age){
        this.race = race
    }
}
fun main() {
    var woman = Woman("사임당",20)
    var man = Man("이순신",20,"아시아")
}
super, this

super

상위 클래스의 메서드, 프로퍼티, 생성자를 사용하는 키워드

super.메서드명 / super.프로퍼티명 / super( )



this

현재 클래스의 메서드, 프로퍼티, 생성자를 사용하는 키워드
this.메서드명 / this.프로퍼티명 / this( )








Polymorphism(다형성)



Polymorphism

Type Polymorphism

타입추론으로도 사용 가능


Method Polymorphism

오버라이딩

상속 받아서 선언부는 동일하나 구현부는 다르게 바꿔 재설계 가능


오버로딩

함수 명은 동일하나 인자를 다르게 하여 여러 경우를 처리






오버라이딩

method는 기본적으로 final method로 오버라이딩을 금지

open 키워드를 사용하여 오버라이딩 허용
  open class Human(){
      fun play(){} //최종 method로 오버라이딩 불가
      open fun sing(){} //open mehtod로 오버라이딩 가능
      open fun sing2(){}
  }
  open class Animal: Human(){
      override fun sing() = println("override sing") //super 클래스 그대로 재정의하여 이 또한 open method
      final override fun sing2() = println("override sing2 final") //final method로 오버라이딩 불가
  }
  open class Animal2: Animal(){
      override fun sing() = println("override sing one more") //이 또한 마찬가지로 open method
  }

런타임 시 만들어진 Object에서 최종적으로 오버라이딩된 메서드가 호출됨
  open class Human(){
      fun play() = println("Human play") //최종 method로 오버라이딩 불가
      open fun sing() = println("Human sing") //open mehtod로 오버라이딩 가능
      open fun sing2() = println("Human sing2")
  }
  open class Animal: Human(){
      override fun sing() = println("Animal sing") //super 클래스 그대로 재정의하여 이 또한 open method
      final override fun sing2() = println("Animal sing2") //final method로 오버라이딩 불가
  }
  open class Animal2: Animal(){
      override fun sing() = println("Animal2 sing") //이 또한 마찬가지로 open method
  }
  fun main() {
      var animal = Animal2()
      animal.play()
      animal.sing()
      animal.sing2()
  }

  <---실행 결과--->
  Human play
  Animal2 sing
  Animal sing2
  




Property와 초기화



Property

자바에서 필드

단순한 변수 선언만 가지기 때문에 접근을 위한 메서드를 따로 만들어야 함

setter, getter를 개발자가 생성




코틀린의 프로퍼티

변수 선언과 기본적인 접근 메서드를 모두 가지고 있음

setter, getter는 개발자가 할 필요 없이 내부적으로 생성하게 됨




접근 메서드는 생략(내부적으로 생성)
  class User(id: Int, name: String, age: Int){
      val id: Int = id // val로 선언 -> 읽기 전용 
      var name: String = name // var로 선언 -> 변경 가능
      var age: Int = age
  }

간략화하면 아래와 같고, getter / setter가 기본적으로 동작
  class User(val id: Int, var name: String, var age: Int){ }
  fun main() {
      val user = User(1,"길동",30)
      user.age = 25
      println("${user.name}의 나이 = ${user.age}")
  }

  <---실행 결과--->
  길동의 나이 = 25


setter, getter 직접 지정

값에 대한 validation(확인) 가능

기본적인 getter, setter를 대신해 지정 가능

불변형인 val은 getter만 설정 가능

filed 변수를 활용하여 기존 값과 새로운 값 비교 가능

filed는 원래 값을 가지는 가상의 변수

class User(id: Int, name: String, age: Int){
  val id: Int = id
      get() = field
  var name: String = name
      get() = field
      set(value){
          field = value
      }
  var age: Int = age
      get() = field
      set(value){
          println("현재값 : $field")
          if(value<0 || value>150) println("다시 확인 바람")
          else field = value
      }
}




지연 초기화

지연 초기화가 필요한 이유

변수나 객체의 값은 생성 시 반드시 초기화가 필요함

클래스 내에서 선언한 후 객체의 정보가 나중에 나타나는 경우 초기화 할 수 있는 방법이 필요함

지연 초기화를 위해 lateinit과 lazy 키워드 사용







lateinit을 통한 지연 초기화

의존성이 있는 초기화나 unit 테스트를 위한 코드 작성 시 프로퍼티 지연 초기화가 필요

예) Car 클래스의 초기화 부분에 Engine 클래스와 의존성을 가지는 경우, Engine 객체가 생성되지 않으면 완전하게 초기화 될 수 없음


클래스를 선언할 때 프로퍼티 선언은 null을 허용하지 않음

선언하려면 ? 형으로 선언하고 null 할당

lateinit 키워드를 사용하면 굳이 바로 할당하지 않아도 됨



var로 선언된 프로퍼티만 가능

프로퍼티에 대한 getter, setter 사용 불가
  class Person{
      lateinit var name: String
      fun test(){
          if(! ::name.isInitialized) { //초기화 여부 판단
              println("not initailized")
          }else{
              println("initialized")
          }

      }
  }
  fun main() {
      val gildong = Person()
      gildong.test()
      gildong.name = "gildong"
      gildong.test()
  }

  <---실행 결과--->
  not initailized
  initialized


lazy를 통한 지연 초기화

호출 시점에 by lazy{…} 부분의 초기화를 진행

불변의 변수 선언인 val에서만 사용 가능(읽기 전용)

val이므로 값을 다시 변경 불가
  class Lazy{
      init{println("init block")}
      val subject by lazy{
          println("lazy initialized")
          "lazy test"//lazy 반환 값
      }
      fun flow(){
          println("not initialized")
          println("subject inital : $subject")
          println("subject initialized : $subject")
      }
  }
  fun main() {
      val test = Lazy()
      test.flow()
  }

  <---실행 결과--->
  init block
  not initialized
  lazy initialized
  subject inital : lazy test
  subject initialized : lazy test

by lazy로 선언된 code block을 수행하는 것이므로, multi thread 동작 시 고려 필요

3가지 모드 지정 가능

SYNCHRONIZED

lock을 사용해 단일 스레드만이 사용하는 것을 보장(기본값)


PUBLICATION

여러 군데서 호출될 수 있으나 처음 초기화된 후 반환 값 사용


NONE

lock을 사용하지 않기 때문에 빠르지만 다중 스레드 접근 가능
값의 일관성을 보장할 수 없음








Delegation(위임)



Delegation

위탁자 → 수탁자 형태로 어떤 일의 책임 및 처리를 다른 클래스 또는 메서드에게 넘긴다는 의미

한 객체가 기능 일부를 다른 객체로 넘겨주어 첫 번째 객체 대신 수행하도록 하는 일

다른 클래스의 기능을 그대로 사용하면 상속 대신 위임

위임을 활용하면 한 객체의 변경이 다른 객체에 미치는 영향이 적어짐





By를 이용한 클래스 위임

Interface 타입의 위임만 가능

하나의 클래스가 다른 클래스에 위임하도록 선언하고 위임된 클래스가 가지는 멤버를 참조 없이 호출

코틀린 라이브러리는 대부분 open되어 있지 않아 상속이나 직접 확장이 어려움

위임을 통해 상속과 비슷하게 확장 가능


다른 클래스의 멤버를 사용하도록 위임
  interface Animal{
      fun eat() = println("Animal.eat()")
  }
  class Cat: Animal{}
  val cat = Cat()
  class Robot: Animal by cat
  fun main() {
      var robot = Robot()
      robot.eat()
      println(robot::class.java)
  }

  <---실행 결과--->
  Animal.eat()
  class com.android.example.kotlinproject.Robot


observable( ) 함수를 통한 위임

프로퍼티를 표준 위임 함수인 observable( )로 위임 가능

콜백처럼 프로퍼티의 내용이 변경될 때 수행한 작업을 정의할 수 있음
  class Observable{
      var name: String by Delegates.observable("처음"){
          property, oldValue, newValue -> println("$oldValue -> $newValue")
      }
  }
  fun main() {
      var ob = Observable()
      ob.name = "두 번째"
      ob.name = "세 번째"
  }

  <---실행 결과--->
  처음 -> 두 번째
  두 번째 -> 세 번째




vetoable( ) 함수를 통한 위임

프로퍼티를 표준 위임 함수인 vetoable( )로 위임 가능

observable( )과 거의 동일하지만 조건에 맞지 않으면 새로운 값 할당을 거부할 수 있음

observable( )은 단순히 바뀌는 것을 지켜보는 것이고, vetoable( )은 바뀔 때 할당할 지 결정할 수 있음


true를 반환하면 새로운 값 할당, false를 반환하면 할당 거부
  class Vetoable{
      var age: Int by Delegates.vetoable(22){
          property, oldValue, newValue ->
          println("property : ${property.name}, $oldValue -> $newValue, result : ${oldValue>newValue}")
          oldValue>newValue
      }
  }
  fun main() {
      var ve = Vetoable()
      ve.age = 20
      println(ve.age)
      ve.age = 25
      println(ve.age)
  }

  <---실행 결과--->
  property : age, 22 -> 20, result : true
  20
  property : age, 20 -> 25, result : false
  20
  







companion object



정적 변수와 컴페니언 객체

코틀린은 static 키워드가 없음

대신 companion object로 사용
class Person{
  var id: Int = 0
  var name: String = "hong"
  companion object{ //고정된 static 내부 클래스처럼 정의
      var language: String = "Ko"
      fun work() = println("work()...")
  }
}
fun main() {
  println(Person.language)
  Person.language = "En"
  println(Person.language)
  Person.work()
}

<---실행 결과--->
Ko
En
work()...







Kotlin(코틀린) 기본문법 5. 클래스와 객체
Sun, 02 Apr 2023 11:21:44 GMT
클래스와 객체



OOP (Object - Oriented Programming)

객체 지향 프로그래밍

절차적 프로그래밍의 한계를 극복하고자 나온 한 가지의 방법론

객체 간 상호작용으로서 표현하는 프로그래밍

객체의 관계를 표현하고 이를 통해 확장과 재사용이 용이

자바, 코틀린에서는 OOP를 지원





객체지향 용어

클래스(Class)

대상들을 분류하고 특징(속성)과 동작(함수)을 작성한 것


추상화

목표로 하는 것에 대해 필요한 만큼 속성과 동작을 정의하는 과정


객체지향 개념의 동의어들

코틀린에서 사용하는 용어 그 밖에 용어

프로퍼티(Property) / 속성(Attribute) / 변수(Variable) / 필드(Field) / 데이터(Data)
메서드(Method) / 함수(Function) / 동작(Operation) / 행동(Begivior)
객체(Object) / 인스턴스(Instance)


자바에서 사용하는 필드는 코틀린에서 프로퍼티라 불림







클래스 선언

빈 형태의 선언
  class Computer{ //내용이 비어있는 클래스 선언
  }

클래스 내에 프로퍼티와 메서드가 정의된 경우
  class Bird{
      //프로퍼티 저으이
      //메서드 정의
  }
  




클래스와 객체

Computer 클래스 만들기
  class Computer{ //클래스 정의
      //프로퍼티(속성)
      var name: String = "myComputer"
      var part: Int = 2
      var color: String = "blue"

      //메소드(함수)
      fun play() = println("computer part : $part")
      fun playGame(vol: Int) = println("game vol: $vol")
  }
  fun main() {
      val computer = Computer() //생성자를 통한 객체 생성
      computer.color = "blue" //객체의 프로퍼티에 값 할당
      println("compter.color : ${computer.color}") //객체의 멤버 프로퍼티 읽기
      computer.play() //객체의 멤버 메서드 사용
      computer.playGame(3)
  }

  <---실행 결과--->
  compter.color : blue
  computer part : 2
  game vol: 3
  




인스턴스

Computer 클래스는 틀일 뿐 실제 메모리에서 실행되고 있는 것이 아님

Heap 메모리에 올라간 객체를 인스턴스라고 함

java에서는 new 키워드로 객체를 생성하지만, 코틀린은 별도의 키워드가 없음

  val computer = Computer() // 클래스 생성자를 통한 객체의 생성
  




생성자

클래스를 통해 객체가 만들어질 때 기본적으로 호출되는 함수

객체 생성 시 필요한 값을 인자로 설정 가능

생성자를 위해 특별한 함수인 constructor( )를 정의
  class 클래스명 constructor(필요한 매개변수들...){ //주 생성자 위치
      ...
      constructor(필요한 매개변수들...){ //부 생성자의 위치
          //프로퍼티의 초기화
      }
  }
  




주 생성자(Primary Constructor)

클래스명과 함께 기술되며 보통의 경우 constructor 키워드를 생략 가능
  class MyDate(var year: Int, var month: Int, var day: Int){ //주생성자
      override fun toString(): String {
          return "MyDate(year=$year, month=$month, day=$day)"
      }
  }
  fun main() {
      var mydate = MyDate(2002,2,2)
      println(mydate)
  }

  <---실행 결과--->
  MyDate(year=2002, month=2, day=2)
  




부 생성자(Secondary Constructor)

클래스 본문에 기술되며 하나 이상의 부 생성자를 정의할 수 있음
  class MyDate(var year: Int){ //주생성자
      var month: Int = 0
      var day: Int = 0
      constructor(year: Int, month: Int): this(year){
          this.month = month
      }
      constructor(year: Int, month: Int, day: Int): this(year, month){
          this.day = day
      }
      override fun toString(): String {
          return "MyDate(year=$year, month=$month, day=$day)"
      }
  }
  fun main() {
      var mydate1 = MyDate(2002)
      println(mydate1)
      var mydate2 = MyDate(2002,2)
      println(mydate2)
      var mydate3 = MyDate(2002,2,2)
      println(mydate3)
  }

  <---실행 결과--->
  MyDate(year=2002, month=0, day=0)
  MyDate(year=2002, month=2, day=0)
  MyDate(year=2002, month=2, day=2)
  





초기화 Block : init block

객체 생성 시 제일 먼저 호출되는 구문
  class MyDate(year: Int){ //주생성자
      var year: Int = 0
      var month: Int = 0
      var day: Int = 0
      init{
          println("init 호출")
          this.year = year
      }
      constructor(year: Int, month: Int): this(year){ //부생성자
          println("부생성자 호출")
          this.month = month
      }
      override fun toString(): String {
          return "MyDate(year=$year, month=$month, day=$day)"
      }
  }
  fun main() {
      var mydate1 = MyDate(2002)
      println(mydate1)
      var mydate2 = MyDate(2002,2)
      println(mydate2)
  }

  <---실행 결과--->
  init 호출
  MyDate(year=2002, month=0, day=0)
  init 호출
  부생성자 호출
  MyDate(year=2002, month=2, day=0)
  




default value 설정

생성자의 선언부에 값을 assign하여 값을 입력받지 않으면 default value로 사용
  class MyDate(var year: Int = 2002, var month: Int, var day: Int){ //주생성자
      override fun toString(): String {
          return "MyDate(year=$year, month=$month, day=$day)"
      }
  }
  fun main() {
      var mydate1 = MyDate(2002,3,3)
      println(mydate1)
      var mydate2 = MyDate(month = 2, day = 2) //default 이외의 값은 '변수명 = 값' 형태로 선언
      println(mydate2)
  }

  <---실행 결과--->
  MyDate(year=2002, month=3, day=3)
  MyDate(year=2002, month=2, day=2)

default value 선언할 때 var year = 2002로 해도 int로 유추 가능하다고 생각하여 타입 명시를 빼면 안됨!!

외부에서 들어오는 값이기 때문에 어떤 값이 들어올 지 몰라 타입을 명시해줘야 함






Kotlin(코틀린) 기본문법 4. 함수
Thu, 30 Mar 2023 12:47:44 GMT
함수



일반 함수

일반 함수 선언과 간략화 표현
  fun 함수이름([변수이름 : 자료형, ... ]): 리턴 타입{
          표현식,,,
          return 반환값
  }
  //일반함수 add
  fun add(x1: Int, x2: Int):Int{
          return x1+x2
  }
  //brace 생략하고 = 으로 assign
  fun add1(x1: Int, x2: Int):Int = x1+x2

  //return type 생략, 추론 가능
  fun add2(x1:Int, x2: Int) = x1+x2
  





람다

람다 표현식
람다 함수는 프로그래밍 언어에서 익명 함수를 뜻함
람다의 형태
람다는 fun과 함수 이름을 명시하지 않고 축약형으로 선언


{매개변수 → 함수 내용}



람다 규칙
람다 함수는 항상 { }으로 감싸서 표현
{ } 안에 ‘→ ‘표시가 있으며 ‘→’ 왼쪽은 매개변수, 오른쪽은 함수 내용
매개변수 타입을 선언해야 하며 추론할 수 있을 때는 생략 가능
함수의 반환 값은 함수 내용의 마지막 표현식
매개변수가 하나인 경우 생략 가능
무조건 it으로 통일


코드의 마지막 줄은 return type으로 추론






일반함수 vs 람다함수

일반함수
  //일반함수
  fun sum(x1: Int, x2: Int): Int{
          return x1+ x2
  }

람다함수 : 표현식이 한 줄일 때 - 예) {x,y→x+y}
  //람다함수
  val add = {x1: Int, x2: Int -> x1+x2}

  fun main(){
          val result = add(10, 20)
          println(result) //30
  }
  




람다식의 구성

표현식이 2줄 이상일 때
  //람다식이 어려 줄일 때는 마지막 라인이 리턴
  val sumw: (Int, Int) -> Int = {x1: Int, x2: Int ->
          println(x1+x2)
          x1+x2 //이 줄(마지막 줄) 리턴
  }

자료형의 생략
  val multi: (Int, Int) → Int = {x: Int, y: Int → x*y} // 생략되지 않은 전체 표현
  val multi = {x: Int, y: Int -> x*y} // 선언 자료형 생략
  val multi: (Int, Int) -> Int = {x,y -> x*y} // 람다식 매개변수 자료형의 생략
  val multi: {x,y -> x*y} // 에러!! 추론 불가!

반환 자료형이 없거나 매개변수가 하나 있을 때
  val greet: () -> Unit = {println("Hello World!")}
  val square: (Int) -> Int = {x -> x*x}

람다식 안에 람다식이 있는 경우
  val nestedLambda: () -> () -> Unit = {{println("nested")}}

선언부의 자료형 생략
  val greet2 = {println("Hello World!")} //추론가능
  val sqare2 = {x: Int -> x*x} //선언부분 생략하면 x의 자료형을 명시해야 함
  val nestedLambda = {{println("nested")}} //추론가능





Kotlin(코틀린) 기본문법 3. 조건문과 분기
Wed, 29 Mar 2023 15:41:07 GMT
조건문과 분기



IF

형식
  if (조건){
      실행
  }else if (조건2){
        실행
  }else{
          실행
  }

실행할 문장이 한 줄이면 블록을 생략 가능.


자바와 달리 if문이 값 반환 가능.
  var a = 3
  var b = 5
  val e = if(a



when

자바에서의 switch문에 대응


값이 하나인 경우 콤마나 in 연산자로 값의 범위를 자유롭게 지정하고 싶을 때 사용

코드를 작성할 때 블록으로 코드를 감쌀 수도 있고, 안 할 수도 있음
val x = 1

when(x){
  1 -> println("x=1")
  2,3 -> println("x=2 or x=3")
  in 4..7 -> println("4<=x<=7")
  else -> println("else")
}

else문은 반드시! 있어야 한다.




if 문처럼 사용

num % 2를 계산 → 짝인지 홀인지 결정 → 그 값을 num2에 할당

0, 1만 처리하면 될 것 같지만, 전체 조건을 처리하기 위해 else문 꼭 필요
val num = 10
val num2 = when (num%2){
  0 -> println("짝수")
  else -> println("홀수")
}



조건식 반환
  fun main() {
      doWhen(1) // 정수 1
      doWhen("hello") // world
      doWhen(100L) // Long type
      doWhen('x') // String type이 아님
  }
  fun doWhen(a:Any){
      var result = when (a){
          1 -> "정수 1"
          "hello" -> "world"
          is Long -> "Long type"
          !is String -> "String type이 아님"
          else -> "else"
      }
  }


for

in 연산자를 통해서 배열을 순회 할 수 있음


.. , downTo, step, until : 증가 범위, 증감 간격 조절
  fun main() {
      val num = arrayOf(1,2,3,4)
      for(n in num){
          println(n) // 1; 2; 3; 4;
      }
      for(i in 1..4){ // .. 키워드
          println(i) // 1; 2; 3; 4;
      }
      for(i in 0..10 step 2){
          println(i) // 0; 2; 4; 6; 8; 10;
      }
      for(i in 10 downTo 0 step 2){
          println(i) // 10; 8; 6; 4; 2; 0;
      }
  }

step은 일정한 간격으로 증가

일정 간격 감소는 downTo와 step을 함께 써야 하기 때문에 for i in 10..0 step 2 는 작동하지 않음 → 감소할 때는 무조건 downTo 함께 써라!



forEach
  val num = arrayOf(1,2,3,4)
  num.forEach { println(it) } //1; 2; 3; 4;

  num.forEachIndexed { index, value ->
      println("$index : $value") // 0 : 1; 1 : 2; 2 : 3; 3 : 4;
  }


while & do while

주어진 조건이 참일 때 반복

do while은 우선 do 구문들을 실행하고 나서, while 문 조건이 참이면 실행

var x = 5
while (x>0){
    x--
    print(x) // 4; 3; 2; 1; 0;
}

var y = 5
do{
    y--
    print(y) // 4; 3; 2; 1; 0;
}while (y>0)
break & continue

break

반복문을 즉시 탈출


conitnue

아래 명령의 실행을 중단하고 다시 위로 올라가 반복문의 다음을 실행
var i = 0
while(i<10){
  i++
  if(i==7) break
  if(i%2==0) continue
  println(i) // 1; 3; 5;
}




label

레이블이 붙여진 곳으로 이동 가능 (레이블은 특정 반복문에 붙인 이름)

중첩된 반복문에서 원하는 반복문을 탈출하고 싶을 때 사용

out@
for(i in 1..5){
    for(j in 1..5){
        println("$i : $j")
        if(i+j >= 5) break@out
    } 
}
println("end")
// 1 : 1; 1 : 2; 1 : 3; 1 : 4; 1: 5; end;
삼항 연산자가 없는 코틀린

코틀린은 삼항 연산자가 없음

if-else가 표현식이기 때문

if와 else가 특정 값을 반환 할 수 있기 때문(when문도 동일)

따라서 삼항 연산자가 필요 없음
var a = 10
var b = 5
var max = if(a>b) a else b // 10









Kotlin(코틀린) 기본문법 2. 연산자, Null
Tue, 28 Mar 2023 16:02:47 GMT
연산자



기본 연산자

종류

산술, 대입, 증가, 감소, 비교, 논리 연산자 등



산술 연산자

사칙연산에 사용되는 사칙연산자와 나머지 연산자를 산술 연산자
‘+’ : 덧셈, ‘ - ‘ : 뺄셈, ‘ * ’ : 곱셈, ‘ / ‘ : 나눗셈, ‘ % ‘ : 나머지



대입 연산자

대입 연산자는 변수에 값을 할당하는 연산자를 말함
대입 연산자는 이항 연산자 중 우선 순위가 가장 낮으므로 모든 연산이 끝난 이후 마지막에 동작



증감 연산자

증감 연산자는 항이 단항임

++, - -
  var num1 = 10
  var num2 = 10
  val result1 = ++num1 // num1 증가 후 대입
  println(result1) // 11
  val result2 = num2++ // 대입 후 num2 증가
  println(result2) // 10





비교 연산자
'>', '<', '>=', '<=', 등의 연산
==, ===, ! ==, ! ===
== : 두 개 항의 값이 같으면 true, 다르면 false
! = : 두 개 항의 값이 다르면 true, 같으면 false
=== : 두 개 항의 참조가 같으면 true, 다르면 false
! == : 두 개 항의 참조가 다르면 true, 같으면 false





논리 연산자
&&, ||, !
&& : 논리곱으로 두 항이 모두 true일 때 true, 아니멸 false
|| : 논리합으로 두 항 중 하나의 항만 true여도 true, 둘 다 false면 false
! : 부정 단항 연산자로 true를 false로, false를 true로 바꿈








Null & Null Safe



Null

코틀린의 변수 선언은 원래 null을 허용하지 않음
  var str:String = "Hello Kotlin"
  str = null // 오류 발생

null 가능한 선언 → ‘?’ 키워드 사용
  var str:String? = "Hello Kotlin"
  str = null // null 허용

NPE(NullPointerException)

사용할 수 없는 null인 변수에 접근하면서 발생하는 예외







Safe-call & Non Null

safe-call

변수 뒤에 ‘?’를 붙혀 호출

값이 null일 경우 null이 입력됨
fun main() {
  val x:String? = null
  println(strLenSafe(x)) // null
  println(strLenSafe("abc")) // 3
}
fun strLenSafe(s:String?): Int?{ //반환이 null로 될 수 있기 때문에 '?' 사용
  return s?.length
}



엘비스 연산자

null인 경우 default를 주고 싶을 때 ‘ ?: ’ 키워드 사용
fun main() {
  val x:String? = null
  println(getStr(x)) // Unknown
  println(getStr("abc")) // abc
}
fun getStr(str:String?): String{
  return str ?: "Unknown"
}



Non-null

변수 뒤에 ‘!!’으로 표시(Not null 단정 기호)

프로퍼티나 변수에 붙이면 null이 아니라고 강제로 선언

null이 들어올 경우 NPE 발생
  fun main() {
      ignoreNulls(null)
  }
  fun ignoreNulls(s:String?){
      val notNull:String = s!! //!!키워드 때문에 그냥 String으로 선언 가능
      println(notNull.length)
  }
  









Kotlin(코틀린) 기본문법 1. 변수와 자료형
Tue, 28 Mar 2023 15:02:51 GMT
코틀린



특징

Intelllij IDEA(Android Strudio의 모체)로 유명한 JetBrains에서 개발하고 보급
Google IO 2017에서 Android 공식 언어로 추가 발표
변수는 Nullable(널 값 사용 가능)과 NotNull로 나뉘는데 변수 선언 시 ‘?’를 붙여 Nullable로 만들 수 있음

장점

자료형에 대한 오류를 미리 잡을 수 있음
컴파일러가 타입을 검증


아예 없는 것은 아니지만 java에 비해 Nullpointer Exception에서 자유로움
데이터형 선언 시 Null 가능한 형식과 불가능한 형식 지원
자바와 완벽하게 상호호환
java와 비교했을 때 코드가 간결하고 효율적인 프로그래밍이 가능
함수형 프로그래밍과 객체 지향 프로그래밍이 모두 가능
세미클론은 생략 가능




변수와 자료형



변수

val (value) - 불변형(immutable)
var (variable) - 가변형(mutable)
변수명
규칙 - java와 동일
변수 이름은 1242abc와 같이 숫자로 시작불가
변수 이름에는 when, val와 같이 코틀린에서 사용되는 키워드는 사용할 수 없음
변수 이름은 의미 있는 단어를 사용하여 만드는 것이 좋음
여러 단어로 변수명을 지을 때는 카멜 표기법 사용을 권장
클래스, 인터페이스 등은 파스칼 케이스를 사용 - java와 동일


변수 선언 예
val userName = “hong” (O) → 자료형을 추론하여 String으로 결정
var username (X) → 자료형을 지정하지 않은 변수는 사용할 수 없음
val init: Int (O) → 먼저 선언하고 나중에 사용 전에 초기화 할 수 있음
val number = 10 (O) → 자료형을 추론하여 Int형으로 추론








자료형


코틀린의 기본 자료형은 모두 객체

자바보다 엄격한 타입체크
Double에 Int가 들어갈 수 없음 (.toDouble( )와 같은 메소드를 이용해서 명시적으로 형변환을 시켜야 함)





숫자형 : Byte/Short/Int/Long, Float/Double
  val a = 5.toByte() // Byte
  val b = 65.toChar() // Char
  val c = 10.toShort() // Short
  val d = 10 // 정수 기본 자료형 Int
  val e = 10L // Long

  val f = 10.0f // Float
  val g = 10.0 // 실수 기본 자료형 double

문자형 : String/Char

코틀린은 유니코드(Unicode)를 사용
  var ch = '\uAC00'
  print(ch) // 가

String은 문자열 (double quotation), char는 글자 하나(single quotation)

여러 줄 문자열 표현은 큰 따음표 세 개로 감싸 줌
  val str = """
      Ssafy 여러분
      모두 화이팅!
  """.trimIndent()



문자열 비교

문자열이 같은지 비교할 때는 ==
오브젝트가 같은지 비교할 때는 ===



문자열 템플릿

‘+’ : 문자열 붙이기
  val str1 = "안녕"
  val str2 = "하세요"
  println(str1+str2) // 안녕하세요

$변수명 혹은 ${변수명} : 문자열 중간에 변수가 들어가야 할 경우
  val a = 20
  println("저는 $a 살 입니다.") //저는 20 살 입니다.
  println("저는 ${a}살 입니다.") // 저는 20살 입니다.



타입 별명 붙이기 - typealias

만약 타입의 이름이 너무 길거나 복잡한 경우, ‘typealias 별명 = 타입’ 과 같이 적어주면 그 타입에 새로운 이름을 부여해 줄 수 있음
  typealias Num = Int
  fun main() {
      val num: Num = 10
      println(num) // 10
  }

alias 유효 범위는 접근지정자 - 코틀린에서 default는 public
당연히 import하면 된다.







배열

arrayOf( )

배열의 생성과 초기화를 함께 수행 (컴파일러가 자료형 유추 가능하면 이를 생략)

배열의 요소에 접근하려면 [ ] 대괄호를 사용
fun main() {
  val num : Array = arrayOf(1,2,3,4)
  val num2 = arrayOf(5,'a',"hi!",8)
  println(num[0]) // 1
  println(num2[1]) // a
  println(num2[2]) // hi!
}

num처럼 선언하면 Int형이 아닌 값들을 넣으면 오류가 발생한다.

num2처럼 선언하면 어떤 값을 넣어도 오류가 나지 않는다.







코틀린의 자료형 변환




기존 java 자료형
기본형(Primitive data type)
가공되지 않은 순수한 자료형으로 프로그래밍 언어에 내장
int, long, float, double 등


참조형(Reference type)
동적 공간에 데이터를 둔 다음 이것을 참조하는 자료형
Int, Long, Float, Double 등





코틀린의 모든 데이터는 참조형.
컴파일 후 내부적으로 primitive type으로 동작
primitive type인 byte/short/int 등은 직접 사용할 수 없음





서로 다른 자료형은 변환 과정을 거친 후 비교
val a :Int = 1 // 정수형 변수 a 선언 후 1을 할당
val b :Double = a // 자료형 불일치 오류
val c :Int = 1.12 // 자료형 불일치 오류



변환 메서드 이용
val b :Double = a.toDouble( ) // 변환 메서드 사용



표현식에서 자료형의 자동 변환
val result = 1L + 3 // Long + Int → Long
큰 바이트형으로 전환된다.





변환 메서드 종류
toByte : Byte
toLong : Long
toShort : Short
toFloat : Float
toInt : Int
toDouble : Double
toChar : Char






스마트 캐스트




구체적으로 명시되지 않은 자료형을 자동 변환해줌

값에 따라 자료형 결정

Number - 숫자를 지정하기 위한 특수 자료형으로 스마트 캐스팅 됨
var test1:Number = 6.2 // Double로 스마트 캐스팅 됨
println(test1.javaClass) // class.java.lang.Double
test1 = 12
println(test1.javaClass) // class.java.lang.Integer
test1 = 12L
println(test1.javaClass) // class.java.lang.Long
test1 += 12.0f
println(test1.javaClass) // class.java.lang.Float





Is 키워드를 사용한 검사

변수 is 자료형
val number = 256
if(number is Int){ //num이 Int형일 때
  print(number)
}else if(number !is Int){ // number이 Int형이 아닐 때
  print("Not a Int")
}

java에서는 instanceof를 하더라도 명시적으로 타입 캐스팅을 해야 하지만, 코틀린에서는 타입 체크와 동시에 자동으로 해줌







묵시적 변환




Any

자료형이 정해지지 않은 경우

모든 클래스의 뿌리(Java의 java.lang.Object)

Ex) Int나 String은 Any 형의 자식 클래스

Any는 언제든 필요한 자료형을 자동 변환(스마트 캐스트)
var a:Any = 1
println(a.javaClass) // class.java.lang.Integer
a = 2L
println(a.javaClass) // class.java.lang.Long









자료구조_스택(Stack) / 큐(Queue)_JAVA
Tue, 28 Mar 2023 08:46:49 GMT
스택(Stack)이란?
데이터를 임시 저장할 때 사용하는 자료구조
후입선출(FILO) 방식
어떤 문제에서 스택을 써야할까?

➡️ **기호 짝 맞추기**

괄호의 짝이 맞는지 확인하는 문제


➡️ **히스토그램, 주가 스팬, 트리 순회, 하노이의 타워와 같은 알고리즘**





➡️ **백트래킹이 필요한 문제**

만약 길이 효율적이지 않다면 다시 이전 상태로 돌아와 다른 길로 가기 위해 이전 상태가 저장되어 있는 스택을 사용
ex) 체스, 미로찾기, Knight-Tour 문제, N-Queen 문제

스택 관련 코드

[기본]
  public class Main {

      public static void main(String[] args) {

          Stack stack = new Stack();

          // 데이터 추가
          stack.push("0");
          stack.push("1");
          stack.push("2");
          stack.push("3");
          stack.push("4");
          stack.push("5");

          // 가장 상위(마지막에 추가된 원소)값 리턴
          stack.peek();

          // 데이터 위치 검색 - 가장 상위 위치 1 기준으로 +1씩 증가 
          stack.search("4"); // 출력: 2

          // 크기
          stack.size();

          // 데이터 꺼내기(삭제) - 최상위부터 꺼냄  
          stack.pop(); // 출력:5

          // 비어있는지 검사 - true|false
          stack.empty(); 

                  // 출력 - 1
                  Iterator iter = stack.iterator();
                  while(iter.hasNext()) {
                      System.out.println(iter.next());
                  }

                  // 출력 - 2
                  stack.stream().forEach(S -> System.out.println(S));

                  // 출력 -3
                  stack.forEach(System.out::println);
      }




}
```
큐(Queue)란?
데이터를 임시 저장할 때 사용하는 자료구조
선입선출(FIFO) 방식
큐의 종류
🔄 순환 큐
front와 rear가 연결되어 계속 순환하는 큐
인덱스를 원형으로 돌려서 7이 0으로 가도록 %연산을 통해 구현

🥇 우선순위 큐
우선순위가 가장 높은 데이터를 가장 먼저 삭제하는 자료구조
보통의 큐와 같이 구현하면 데이터를 삽입하기 힘들다는 단점이 있어 주로 힙 자료구조를 사용해 구현

큐 관련 코드

큐의 주요 메서드



[기본]
public class Main {

  public static void main(String[] args) {

      Queue queue = new LinkedList<>(); //int형 queue 선언

      // 데이터 추가  add | offer
      queue.add(1);    
      queue.add(2);   
      queue.offer(3);
      queue.offer(2);
      queue.offer(4);

  // 가장 상위(가장 먼저 추가된 원소)값 리턴 element | peek
      queue.element();
      queue.peek();

      // 큐 데이터 삭제 remove | poll
      queue.remove(); // 가장 먼저 들어온 값 삭제
      queue.remove(2); // 동일한 값 중 가장 먼저 들어온 값 하나를 삭제 
      queue.poll(); 
      //queue.poll(2); // 원하는 값 삭제 불가능 

      // 큐 초기화 
      //queue.clear();

      // 출력 - 1
      Iterator iter = queue.iterator();
      while(iter.hasNext()) {
          System.out.println(iter.next());
      }
      // 출력 - 2
      queue.stream().forEach(S -> System.out.println(S));

      // 출력 - 3
      queue.forEach(System.out::println);

  }




}
```



자료구조_해시(Hash)_JAVA
Fri, 24 Mar 2023 06:41:59 GMT
해시란?
key : value의 값을 가지는 하나의 자료구조
예) 전화번호부 ⇒ 검색창에 이름을 입력하면 전화번호 결과가 나옴
무언가를 찾기 위한 검색어 (이름) = key
그 검색어로 나온 결과 (전화번호) = value
해시가 왜 필요한가?
배열로는 오직 정수로만 접근이 가능함
int[] phonebook = new int[5];
phonebook[0];
친구의 이름을 알더라도 이름을 기반으로 전화번호를 찾을 수 없음
String name = "hyunwoo";
phonebook[name] // error
그렇기 때문에 해시가 없던 시절 유일하게 할 수 있었던 방법은 0부터 끝까지 하나하나 열어보며 찾는 친구가 맞는지 확인하는 방법뿐이었음
for (int i = 0; i < n; i++) {
    // phonebookName[i] == name?
}
해시는 배열과 달리 String 타입이나 다른 어떤 데이터형을 기반으로 자료구조를 접근하고 데이터를 관리할 수 있도록 해줌

⚠️ **코딩테스트에서 중요한 점**

해시는 모든 데이터 타입으로 접근이 가능함
get / put / getOrDefault 함수 꼭 기억할 것



getOrDefault함수!
  public String solution(String[] participant, String[] completion) {
          String answer = "";
          HashMap hm = new HashMap<>();
          for(String player : participant){
              hm.put(player,hm.getOrDefault(player,0)+1);
          }
          //for(int i=0;i


위의 코드에서 주석된 부분처럼 키가 있는지 확인하고 없으면 초기값으로 넣고 있으면 1 더하는 코드를 한 줄로 간단하게 작성할 수 있다.



어떤 문제에서 해시를 써야할까?

➡️ **String을 기반으로 정보를 기록하고 관리해야 될 때**



String을 기준으로 정보를 기록하고 관리하려면 단순 배열을 쓸 수 없으니 Hash를 활용하자

Hash 관련 코드

[기본]
                  // 선언 
          HashMap<타입 ,타입> hm = new HashMap<>();

                  // 카피 -  타입이 모두 같아야 함.
                  HashMap<타입, 타입> hm2 = new HashMap<>(hm);

                  // 크기 지정
                  HashMap<타입, 타입> hm3 = new HashMap<>(크기);
  package codingtest;

  import java.awt.print.Printable;
  import java.util.*;
  import java.util.Scanner;

  import org.omg.CORBA.PolicyListHelper;

  public class Main {

      public static void main(String[] args) {

          Map hm = new HashMap<>();

          // 데이터 추가 
          hm.put("data1", 1);
          hm.put("data2", 2);
          hm.put("data3", 3);
          hm.put("data4", 4);
          hm.put("data5", 3);
          hm.put("data6", 6);

          // 데이터 삭제 - key
          hm.remove("data1");

          // 데이터 삭제 - values 
          // (**동일한 값이 존재하는 경우 가장 늦게 들어온 오직 한 개의 요소만 삭제**)
  //        hm.values().remove(3);   
          // 결과 : {data6=6, data4=4, data3=3, data2=2}




        // 데이터 삭제 - values - 한 번에 여러 요소 삭제 
        // value가 2,3인 모든 데이터를 삭제한다. 
    // hm.values().removeAll(Arrays.asList(2,3));

        // 크기 
            hm.size();

        // 모든 내용 삭제 
       // hm.clear();

        // 데이터 변경 
        hm.replace("data2", 10);
        hm.replace("data6", 6, 12); // 키의 값이 일치해야 값 변경 가능 

        // 데이터 추출 
        hm.get("data2"); // 키로 값 추출 

        // 키 존재 유무 확인 true|false
        hm.containsKey("data6");  // 키 기준
        hm.containsValue(12); // 값 기준





    }


}
```

[정렬]
  public class Main {

      public static void main(String[] args) {
          Map hm = new HashMap<>();

          Map map = new HashMap<>();
          map.put("Nepal", "Kathmandu");
          map.put("United States", "Washington");
          map.put("India", "New Delhi");
          map.put("England", "London");
          map.put("Australia", "Canberra");

          List valueList = new ArrayList<>(map.values());
          valueList.sort(String::compareTo); // 알파벳 순으로 정렬 

          for (String value : valueList) {
              System.out.println("Value: " + value);
          }

      }

  }

  /*
  Value: Canberra
  Value: Kathmandu
  Value: London
  Value: New Delhi
  Value: Washington
  */
  public class Main {

      public static void main(String[] args) {

          Map hm = new HashMap<>();
          hm.put("data1", 5);
          hm.put("data2", 6);
          hm.put("data3", 4);
          hm.put("data4", 4);
          hm.put("data5", 7);
          hm.put("data6", 1);

          List valueList = new ArrayList<>(hm.values());
          valueList.sort(Integer::compareTo);

          for (int value : valueList) {
              System.out.println("Value: " + value);
          }
      }
  }

  /*
  Value: 1
  Value: 4
  Value: 4
  Value: 5
  Value: 6
  Value: 7
  */

HashSet
  package codingtest;

  import java.awt.print.Printable;
  import java.util.*;
  import java.util.Scanner;

  import org.omg.CORBA.PolicyListHelper;

  public class Main {

      public static void main(String[] args) {

          // HashSet 선언
          HashSet setTest = new HashSet<>();

          // 데이터 삽입
          setTest.add(10);
          setTest.add(20);
          setTest.add(30);
          setTest.add(40);
          setTest.add(50);

          // 중복을 허용하지 않음
          setTest.add(10);
          setTest.add(20);
          setTest.add(30);

          System.out.println(setTest); // [50, 20, 40, 10, 30]

          // remove Element
          setTest.remove(40);

          // Element 존재 확인
          System.out.println(setTest.contains(10)); // true

          // isEmpty()
          System.out.println(setTest.isEmpty()); // false

          // size()
          System.out.println(setTest.size()); // 4

          // get iterator()
          Iterator setIter = setTest.iterator();
          while (setIter.hasNext()) {
              System.out.println(setIter.next());
          }

          // Removes all of the elements from this set.
          setTest.clear();







    }


}
```

Iterator	Enumeration
요소를 반복하는 데 사용되는 일반 커서이며 모든 컬렉션 클래스에 적용할 수 있다.	Vector와 같은 레거시 클래스에만 적용할 수 있으므로 일반 커서가 아니다. 컬렉션 클래스에 대한 읽기 권한만 있다.
반복 메서드 : hasNext(), next()	반복 메서드 : hasMoreElements(), nextElement()
반복자를 사용하여 컬렉션의 요소를 제거할 수 있다.	읽기 권한만 있기 때문에 열거를 사용하여 컬렉션의 요소를 제거할 수 없다.