wrapping_not.log

Kotlin 예외처리

Tue, 04 Apr 2023 10:53:47 GMT

코틀린의 예외 처리는 자바와 접근방법이 아주 비슷하다. 함수는 정상 종료, 즉 어떤 값을 반환하거나 비정상적으로 오류가 발생한 경우 예외를 던질 수 있다. 예외가 발생한 경우에는 함수를 호출한 쪽에서 예외를 잡아내거나 (catch) 잡아내지 않는 경우 함수 호출 스택의 위로 예외가 전달 될 수 있다.

예외 던지기

오류 조건을 신호로 보내려면 자바와 마찬가지로 throw 식에 예외 객체를 사용해야 한다. 문자열이 잘못된 경우 어떤 폴백(fallback) 값을 돌려주는 대신 오류를 발생시키도록 바꿔야한다.

fun parseIntNumber(s: String): Int{
    var num = 0

    if(s.length !in 1..31) throw NumberFormatException("Not a number: $s")

    for(c in s) {
        if(c !in '0'..'1') throw NumberFormatException("Not a number: $s")
        num = num*2 + (c - '0')
    }
    return num
}

자바와 달리 코틀린은 클래스 인스턴스를 생성(위는 예외) 할 때 new 같은 구문을 사용하지 않는다. NumberFormatException처럼 생성자 호출도 일반 함수 호출과 똑같이 생겼다.

예외를 던지면 생기는 일

프로그램은 예외를 잡아내는 핸들러를 찾는다. 예외와 일치하는 예외 핸들러가 있다면, 예외 핸들러가 예외를 처리한다.
현재 함수 내부에서 핸들러를 찾을 수 없으면 함수 실행이 종료되고 함수가 스택에서 제거(pop)된다. 그리고 호출한 쪽의 문맥 안에서 예외 핸들러 검색을 수행한다. 이런경우 예외 호출자에게 전파 했다고 한다.
프로그램 진입점에 이를 때까지 예외를 잡아내지 못하면 현재 스레드가 종료된다.

→ 코틀린의 예외 처리 단계는 기본적으로 자바와 같다.

코틀린에서 break나 continue와 같이 throws 식에도 Nothing 타입식이다.

fun sayHello(name: String){
    val message = 
        if(name.isNotEmpty()) "Hello $name"
        else throw IllegalArgumentException("Empty name")

    println(message)
}

try 문으로 예외 처리

코트린에서도 예외를 처리 할 때는 기본적으로 자바와 똑같은 문법인 try문을 사용한다.

import java.lang.NumberFormatException

fun readInt(default: Int): Int {
    try{
        return redLine()!!.toInt()
    } catch (e: NumberFormatException){
        return defualt
    }
}

예외가 발생 할 수 있는 코드를 try문으로 감싼다. try문에는 최소한 하나 이상 적절한 탑입의 예외를 잡아내는 catch블록이 있어야 한다.
처리할 예외는 파라미터로 표현된다. catch 블록의 내부에서는 이 파라미터를 마음대로 쓸수 있다.
catch 블록은 선언된 순서대로 예외타입을 검사하기 때문에 어떤 타입을 처리할 수 있는 catch 블록을 그 타입 상위 타입을 처리할 수 있는 catch블록 보다 앞에 작성해야 한다. 그렇지 않으면 상위 타입을 잡아내는 핸들러가 하위 타입인 예외도 모두 잡아내버린다.
코틀린에는 검사 예외와 비검사 예외를 구분하지 않는다.

사이드프로젝트 6일차

Sat, 01 Apr 2023 01:30:31 GMT

네비게이션 드로어 이어주기

override fun onOptionsItemSelected(item: MenuItem): Boolean {
        isclick = false
        val id = item.itemId
        if (id == R.id.menu_item1) {
        } else if (id == R.id.menu_item2) {
            Log.d("실행", "ㅇㅇ")
            if (Build.VERSION.SDK_INT >= 28) {
                startForegroundService(intent)
                Log.v("asdf", "startService!")
            }
        }
        when (item.itemId) {
            android.R.id.home -> {
                if (classes == "8") {
                    navi_icon!!.setImageResource(R.drawable.uni_1color)
                } else if (classes == "7") {
                    navi_icon!!.setImageResource(R.drawable.uni_2color)
                } else if (classes == "6") {
                    navi_icon!!.setImageResource(R.drawable.uni_3color)
                } else if (classes == "5") {
                    navi_icon!!.setImageResource(R.drawable.uni_4color)
                } else if (classes == "4") {
                    navi_icon!!.setImageResource(R.drawable.uni_5color)
                } else if (classes == "3") {
                    navi_icon!!.setImageResource(R.drawable.uni_6color)
                } else if (classes == "2") {
                    navi_icon!!.setImageResource(R.drawable.uni_7color)
                } else if (classes == "1") {
                    navi_icon!!.setImageResource(R.drawable.uni_8color)
                }
                drawerLayout.openDrawer(GravityCompat.START)
                return true
            }
        }
        return super.onOptionsItemSelected(item)
    }

리소스 코드

›

결과물

액티비티_1

Fri, 31 Mar 2023 08:51:43 GMT

안드로이드 액티비티

안드로이드 액티비티는 사용자 인터페이스 화면을 나타내는 하나의 창입니다. 즉, 사용자가 앱에서 보는 화면이 바로 액티비티입니다.

안드로이드에서 다수의 액티비티를 갖는 앱을 만들 수 있습니다. 이 때 각각의 액티비티는 서로 독립적이며, 하나의 앱 내에서도 서로 다른 동작을 수행할 수 있습니다.

컨텍스트

컨텍스트는 액티비티, 서비스등의 컴포넌트와 스피너, 리사이클러뷰와 같은 화면 요소를 사용하기 위해서 필요합니다.

컨텍스트는 시스템을 사용하기 위한 정보(프로퍼티)와 도구(메서드)가 담겨있는 클래스 입니다.

대부분의 컨텍스트는 컴포넌트 실행시 함께 생성되고, 그다음에 메서드를 호출 해서 각각의 도구를 사용할 수 있습니다.

액티비티는 컨텍스트를 상속받아 구현됩니다.

컨텍스트를 상속받은 컴포넌트들은 코드상에서 baseContext를 호출하는 것만드로 안드로이드의 기본 기능을 사용할 수 있습니다.

컨텍스트의 종류

애플리케이션 컨텍스트
- 어플리케이션과 곤련된 핵심 기능을담고 있는 클래스 입니다. 앱을 통틀어서 하나의 인스턴스만 생성됩니다. 액티비티나 서비스 같은 컴포넌트에서 applicationContext를 직접 호출해서 사용할 수 있는데 호출 하는 지점과 관계없이 모두 동일한 컨텍스트가 호출됩니다.
베이스 컨텍스트
- 안드로이드 4대 메이저 컴포넌트인 액티비티, 서비스, 컨텐트 프로바이더, 브로드캐스트리시버의 기반 클래스 입니다. 각각의 컴포넌트에서 baseContext 또는 this로 컨텍스트를 사용할 수 있고 컴포넌트 개수 만큼 컨텍스트도 함께 생성되기 때문에 호출되는 지점에 따라 서로 다른 컨텍스트가 호출 됩니다.

컴포넌트	컨텍스트 기능
애플리케이션	애플리케이션과 관련된 핵심 기능을 담고 있는 클래스로, 앱 전체에서 하나의 인스턴스만 생성됩니다.
액티비티	UI를 관리하는 클래스로, 앱에서 사용자가 볼 수 있는 화면을 담당합니다. 사용자 인터페이스를 구성하고, 사용자 입력에 응답하며, 여러 개의 액티비티를 조합하여 앱의 전체적인 UI를 구성합니다.
서비스	백그라운드에서 실행되는 컴포넌트로, 앱이 화면에서 나가도 계속 실행할 수 있습니다. 다른 컴포넌트와 연결하여 백그라운드 작업을 수행하거나, 원격 프로세스와 통신하기 위한 수단으로 사용됩니다.
컨텐트 프로바이더	앱 데이터를 관리하고 다른 앱에 데이터를 제공하는 인터페이스를 제공하는 컴포넌트입니다. 앱의 데이터베이스나 파일 시스템의 내용을 다른 앱에 제공할 수 있습니다.
브로드캐스트 리시버	시스템이나 다른 앱에서 발생한 이벤트를 수신하는 컴포넌트입니다. 예를 들어, 전화가 왔을 때 브로드캐스트 리시버를 등록하여 이벤트를 처리할 수 있습니다.

인텐트

안드로이드에서 인텐트(Intent)는 컴포넌트간의 통신을 위한 메시지 객체입니다. 인텐트를 사용하면 다른 앱의 컴포넌트를 실행하거나, 자신의 컴포넌트를 실행할 때 추가적인 정보를 전달할 수 있습니다. 인텐트는 명시적 인텐트와 암시적 인텐트로 나눌 수 있습니다. 명시적 인텐트는 실행할 컴포넌트를 직접 지정하는 방식이며, 암시적 인텐트는 실행할 컴포넌트를 액션(action)과 데이터(data)를 이용하여 시스템에 요청하는 방식입니다.

자료구조와 알고리즘 복잡도 분석

Fri, 31 Mar 2023 04:56:59 GMT

시간 복잡도

시간 복잡도(Time Complexity)는 알고리즘 실행 속도의 측정치입니다. 보통 연산 횟수를 계산합니다. 이 연산 횟수는 입력의 크기에 따라 달라지기 때문에 입력 크기(n)를 기준으로 표기합니다.

Big O 표기법

Big O 표기법은 알고리즘의 수행 시간을 나타내는 표기법 중 하나입니다. 알고리즘의 최악 시간 복잡도를 나타냅니다. 여기서 최악 시간 복잡도란, 입력값 n에 대해 알고리즘이 가장 오래 걸리는 경우의 연산 횟수를 의미합니다. Big O 표기법은 입력값 n이 무한대로 커질 때, 알고리즘의 실행 시간이 어떤 함수 f(n)보다 빠르게 증가하지 않는다는 것을 나타냅니다.

자료구조와 알고리즘 복잡도 예시

배열(Array)

접근 시간: O(1)
검색 시간: O(n)
삽입 시간: O(n)
삭제 시간: O(n)

연결 리스트(Linked List)

접근 시간: O(n)
검색 시간: O(n)
삽입 시간: O(1)
삭제 시간: O(1)

이진 탐색 트리(Binary Search Tree)

접근 시간: O(log n)
검색 시간: O(log n)
삽입 시간: O(log n)
삭제 시간: O(log n).

해시 테이블(Hash Table)

접근 시간: O(1)
검색 시간: O(1)
삽입 시간: O(1)
삭제 시간: O(1)

정렬 알고리즘(Sorting Algorithm)

// 샘플 코드: 정렬 알고리즘 시간 복잡도 측정하기
fun main() {
    val n = 1000000
    val lst = (0 until n).toList()

    val startTime = System.currentTimeMillis()

    // 접근 연산
    val x = lst[0]

    // 검색 연산
    val y = n - 1 in lst

    // 삽입 연산
    val newList = lst.toMutableList()
    newList.add(n)

    // 삭제 연산
    newList.removeAt(newList.lastIndex)

    // 선택 정렬
    selectionSort(lst)

    // 삽입 정렬
    insertionSort(lst)

    // 버블 정렬
    bubbleSort(lst)

    // 합병 정렬
    mergeSort(lst)

    // 퀵 정렬
    quickSort(lst)

    // 힙 정렬
    heapSort(lst)

    val endTime = System.currentTimeMillis()

    println("모든 연산에 걸린 시간: ${endTime - startTime} ms")
}

// 선택 정렬
fun selectionSort(lst: List): List {
    val result = lst.toMutableList()
    for (i in result.indices) {
        var minIndex = i
        for (j in i + 1 until result.size) {
            if (result[j] < result[minIndex]) {
                minIndex = j
            }
        }
        val temp = result[i]
        result[i] = result[minIndex]
        result[minIndex] = temp
    }
    return result
}

// 삽입 정렬
fun insertionSort(lst: List): List {
    val result = lst.toMutableList()
    for (i in 1 until result.size) {
        val key = result[i]
        var j = i - 1
        while (j >= 0 && result[j] > key) {
            result[j + 1] = result[j]
            j -= 1
        }
        result[j + 1] = key
    }
    return result
}

// 버블 정렬
fun bubbleSort(lst: List): List {
    val result = lst.toMutableList()
    for (i in 0 until result.size - 1) {
        for (j in 0 until result.size - i - 1) {
            if (result[j] > result[j + 1]) {
                val temp = result[j]
                result[j] = result[j + 1]
                result[j + 1] = temp
            }
        }
    }
    return result
}

// 합병 정렬
fun mergeSort(lst: List): List {
    if (lst.size <= 1) {
        return lst
    }
    val middle = lst.size / 2
    val left = lst.subList(0, middle)
    val right = lst.subList(middle, lst.size)
    return merge(mergeSort(left), mergeSort(right))
}

fun merge(left: List, right: List): List {
    val result = mutableListOf()
    var i = 0
    var j = 0
    while (i < left.size && j < right.size) {
        if (left[i] < right[j]) {
            result.add(left[i])
            i++
        } else {
            result.add(right[j])
            j++
        }
    }
    result.addAll(left.subList(i, left.size))
    result.addAll(right.subList(j, right.size))
    return result
}

// 퀵 정렬
fun quickSort(lst: List): List {
    if (lst.size <= 1) {
        return lst
    }
    val pivot = lst[lst.size / 2]
    val equal = lst.filter { it == pivot }
    val less = lst.filter { it < pivot }
    val greater = lst.filter { it > pivot }
    return quickSort(less) + equal + quickSort(greater)
}

// 힙 정렬
fun heapSort(lst: List): List {
    val result = lst.toMutableList()
    for (i in result.size / 2 - 1 downTo 0) {
        heapify(result, result.size, i)
    }
    for (i in result.size - 1 downTo 1) {
        val temp = result[0]
        result[0] = result[i]
        result[i] = temp
        heapify(result, i, 0)
    }
    return result
}

fun heapify(lst: MutableList, n: Int, i: Int) {
    var largest = i
    val l = 2 * i + 1
    val r = 2 * i + 2
    if (l < n && lst[l] > lst[largest]) {
        largest = l
    }
    if (r < n && lst[r] > lst[largest]) {
        largest = r
    }
    if (largest != i) {
        val swap = lst[i]
        lst[i] = lst[largest]
        lst[largest] = swap
        heapify(lst, n, largest)
    }
}

위 코드는 Kotlin을 사용하여 서로 다른 정렬 알고리즘의 시간 복잡도를 측정하는 예시입니다. 코드는 리스트의 접근, 검색, 삽입, 삭제 연산의 시간, 그리고 선택 정렬, 삽입 정렬, 버블 정렬, 합병 정렬, 퀵 정렬, 힙 정렬의 시간 복잡도를 측정합니다.

각 정렬 알고리즘의 시간 복잡도는 다음과 같습니다:

선택 정렬: O(n^2)
삽입 정렬: O(n^2)
버블 정렬: O(n^2)
합병 정렬: O(n log n)
퀵 정렬: O(n log n)
힙 정렬: O(n log n)

같은 문제에 대해 적절한 알고리즘을 사용하면 더 나은 성능과 효율성을 얻을 수 있습니다. 따라서 알고리즘을 설계할 때 시간 복잡도 분석을 고려하는 것이 중요합니다.

아래는 파이썬의 리스트를 예시로, 리스트의 길이에 따른 연산 시간을 측정하는 코드입니다.

import time

n = 1000000
lst = [i for i in range(n)]

start = time.time()

# Access operation
x = lst[0]

# Search operation
y = n - 1 in lst

# Insert operation
lst.append(n)

# Delete operation
del lst[-1]

end = time.time()

print("Elapsed time for list operations: ", end - start)

이 코드는 리스트를 사용하는 연산 중 접근, 검색, 삽입, 삭제 연산의 시간을 측정합니다. 리스트의 길이(n)를 바꿔가며 시간을 측정하여, 각각의 연산이 얼마나 오래 걸리는지를 확인할 수 있습니다.

결론

알고리즘의 시간 복잡도를 분석하여 최적의 알고리즘을 선택하면, 더 효율적으로 문제를 해결할 수 있습니다. 따라서 알고리즘을 설계할 때, 시간 복잡도 분석을 고려하여야 합니다.

AWS ssh Key Permission 오류

Sun, 26 Mar 2023 03:21:16 GMT

AWS 서버 접속시 오류 발생

Permission 0644 for 'ssh/woogies.pem' are too open. 오류가 발생 되었다.
이 오류는 Permission에 대한 내용으로 구글에 검색 해보니 해결 방법은 간단 했다.

해결 코드

chmod 600 ssh/woogies.pem 를 터미널에 입력하고 재 접속 해보니

정상적으로 접속이 되었다.
역시 오류해결은 구글신에게 물어보면 된다.

사이드 프로젝트 5일차

Sun, 26 Mar 2023 03:19:49 GMT

화면처럼 꾸미기

아래는 코드입니다.
디자이너가 아니기 때문에 여러 홈페이지를 통해서 디자인을 참고 했습니다.

결과물!

![](https://velog.velcdn.com/images/wrapping_not/post/0a7d53f3-97a0-42d8-877e-58b91e2a5ae5/image.png "height="100")

화면 기능 구현을 위해 연결하기

코드

package com.example.seenablow

import android.content.Intent
import android.os.Build
import android.os.Bundle
import android.util.Log
import android.view.MenuItem
import android.view.View
import android.widget.*
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.appcompat.widget.Toolbar
import androidx.cardview.widget.CardView
import androidx.core.view.GravityCompat
import androidx.drawerlayout.widget.DrawerLayout
import com.google.android.material.navigation.NavigationView

class MainActivity : AppCompatActivity() {
    var card_nov: CardView? = null
    var card_poem: CardView? = null
    var card_news: CardView? = null
    var card_column: CardView? = null
    private var toolbar: Toolbar? = null
    private var drawerLayout: DrawerLayout? = null
    private var navigationView: NavigationView? = null
    var navi_textview: TextView? = null
    var navi_textview2: TextView? = null
    var username: String? = null
    var age: String? = null
    var gender: String? = null
    var classes: String? = null
    //var intent: Intent? = null
    //
    var isclick = false
    var navi_icon: ImageView? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //해당 액티비티를 잠금화면에 띄워줌
        setContentView(R.layout.activity_main)
        card_nov = findViewById(R.id.card_nov)
        card_poem = findViewById(R.id.card_poem)
        card_news = findViewById(R.id.card_news)
        card_column = findViewById(R.id.card_column)
        drawerLayout = findViewById(R.id.drawer_layout)
        intent = getIntent()
        navigationView = findViewById(R.id.naviView) as NavigationView
        navigationView!!.setNavigationItemSelectedListener { item: MenuItem ->
            onOptionsItemSelected(
                item
            )
        }
        val nav_header_view = navigationView!!.getHeaderView(0)
        navi_textview = nav_header_view.findViewById(R.id.user_name) as TextView
        val nav_header_view2 = navigationView!!.getHeaderView(0)
        navi_textview2 = nav_header_view2.findViewById(R.id.userinfo) as TextView
        val nav_header_view3 = navigationView!!.getHeaderView(0)
        navi_icon = nav_header_view3.findViewById(R.id.navi_icon) as ImageView
        toolbar = findViewById(R.id.toolbar)
        setSupportActionBar(toolbar)
        //액션바 객체
        val actionBar = supportActionBar
        actionBar!!.setDisplayHomeAsUpEnabled(true)
        supportActionBar!!.setDisplayShowTitleEnabled(false)

        //뒤로가기 버튼 이미지 적용
        actionBar.setHomeAsUpIndicator(R.drawable.ic_menu)
        val sharedPreferences = getSharedPreferences("username", MODE_PRIVATE)
        username = sharedPreferences.getString("username", "")
        age = sharedPreferences.getString("age", "")
        gender = sharedPreferences.getString("gender", "")
        classes = sharedPreferences.getString("class", "")

    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        isclick = false
        val id = item.itemId
        if (id == R.id.menu_item1) {
        } else if (id == R.id.menu_item2) {
            Log.d("실행", "ㅇㅇ")
            if (Build.VERSION.SDK_INT >= 28) {
                startForegroundService(intent)
                Log.v("asdf", "startService!")
            }
        }
        when (item.itemId) {
            android.R.id.home -> {
                if (classes == "8") {
                    navi_icon!!.setImageResource(R.drawable.uni_1color)
                } else if (classes == "7") {
                    navi_icon!!.setImageResource(R.drawable.uni_2color)
                } else if (classes == "6") {
                    navi_icon!!.setImageResource(R.drawable.uni_3color)
                } else if (classes == "5") {
                    navi_icon!!.setImageResource(R.drawable.uni_4color)
                } else if (classes == "4") {
                    navi_icon!!.setImageResource(R.drawable.uni_5color)
                } else if (classes == "3") {
                    navi_icon!!.setImageResource(R.drawable.uni_6color)
                } else if (classes == "2") {
                    navi_icon!!.setImageResource(R.drawable.uni_7color)
                } else if (classes == "1") {
                    navi_icon!!.setImageResource(R.drawable.uni_8color)
                }
                navi_textview!!.text = username
                navi_textview2!!.text = "$age 세 $gender"
                drawerLayout!!.openDrawer(GravityCompat.START)
                return true
            }
        }
        return super.onOptionsItemSelected(item)
    }

    override fun onBackPressed() {
        val alert_ex = AlertDialog.Builder(this)
        alert_ex.setMessage("정말로 종료하시겠습니까?")
        alert_ex.setNegativeButton("취소") { dialog, which -> }
        alert_ex.setPositiveButton("종료") { dialog, which -> finishAffinity() }
        alert_ex.setTitle("Good Bye!")
        val alert = alert_ex.create()
        alert.show()
    }
}

사이드프로젝트 4일차

Fri, 24 Mar 2023 05:10:51 GMT

Django를 AWS서버를 이용한 배포

개발 환경

mac os(13.0 Ventura)
Python 3.9
Django 4.1.5
Pycham 22.11.ver

Login을 위해 DB 생성과 연결할 서버를 생성

DB 생성 (adminuser_DB 테이블 생성)

Django 서버를 생성해서 로그인 API를 만든다. (Django Ver 4.1)

장고를 임포트 하여 첫 시작 페이지를 만듬

python manage.py startapp Login 구문을 사용해서 Login app 생성

setting.py 에서 DB를 셋팅 해주고 migration을 통해 설정을저장 한다.

의도치 않은 오류 발생

위의 포트가 이미 사용중이라는 오류가 발생했다.

이유는 제대로 앱이 꺼지지 않아서 그럴수있다. (ctrl + z를 사용하면 서버가 죽는게 아닌 멈춘다. 제대로 죽이려면 ctrl + c를 사용해서 서버를 죽이면 된다.)

이럴 경우 port 8000과 관련된 모든 프로세스를 죽이고 다시 실행시키면 된다.

터미널에서 "sudo lsof -t -i tcp:8000 | xargs kill -9"를 입력하면 된다.

혹은 python manage.py runserver 0.0.0.0:9000 이런식으로 포트를 지정해주면 된다.

포트 연결 성공

AWS서버에 django 웹 배포하기

서버에서도 똑같은 패키지를 사용할수 있도록 pip3 freeze >> requirements.txt 명령어를 입력한다.

인증키의 경로를 잘 선택하거나 잘 잡아야 할거 같다. 그후 아래 명령어를 입력하면

(venv) (base) weng-weng@MacBook-Pro ssh % $ ssh -i ssh/woogies.pem ubuntu@ec2-ec2-13-124-208-83.ap-northeast-2.compute.amazonaws.com

이 화면에서 Yes라고 하면

성공적으로 접속이 되었다!

준비는 끝났고 로그인 API를 띄워서 APP의 Retrofit 통신을 확인작업을 하면되겠다.

Git에 올리기

깃 설정을 하고 커밋과 푸쉬를 해주면 깃에 서버를 사용할수 있는 코드가 올라가게 된다!

https://github.com/WrappingorNot/Django_server

이제 AWS서버를 어떤 형태든지 쓸수 있게 되었다!

AWS서버에 접속 해서 git 코드를 Clone 해주었다.

서버에서 git clone한 프로젝트의 필요한 패키지를 전부 다운받았다,.

그리고 runserver 8080 포트로 열었다.

그전에 서버에서 접속이 될수 있도록 인바운드 규칙에 추가하자.

위 주소는 서버를 통한 Django를 배포한것이다.

그러나 위처럼 오류가 발생되었다. setting의 ALLOWED_HOST의 설정이 안되었기 때문에

아래처럼 로컬 장고에서 설정을 하고 git push를 해준다.

다시 접속 하게끔 python3 manage.py runserver 0:8080입력하면

성공!!!

가상 환경시 경로가 잘되어있는지 확인하자

uwsgi --http :8080 --home /home/ubuntu/myvenv/ --chdir /srv/Django_server/mysite/ -w mysite.wsgi

Django DisallowedHost 오류

Fri, 24 Mar 2023 01:40:22 GMT

장고 오류

3일차에 만들어놓은 장고 서버가 오늘 날짜로 들어가 보니 아래같은 오류가 발생하였다.
- 구글에 검색해보니 ‘0.0.0.0’을 허용을 해야한다는 것이였다.

해결하기

setting 파일에 들어가서 ALLOW_HOSTS를 찾은 다음

로컬로도 접속 할 수 있도록 허용 해주었다.

결과

해결 완료~!

사이드 프로젝트 3일차

Wed, 22 Mar 2023 11:36:53 GMT

회원가입 화면 만들기

XML 코드!
아래는 코드의 결과!
- 아래는 액티비티 코드! (각자의 기능 구현은 서버를 구성하고 연결해줄 예정이다)

AWS서버 구성

개발환경

mac os (13.0 Ventura)
AWS EC2 로 서버 생성

AWS - EC2 기본 사용법

위의 영상을 참고 하여 생성

목표

Django 를 서버에 띄우기
Android App을 통해 서버 접속할 수 있게 한다.

AWS

간단한 설명 그림

사용하려는 이유

확장성이 좋다
탄력성이 좋다
높은 접근성
장애 허용성

인스턴스 생성

인스턴스 시작버튼을 눌러서 생성한다.

Server 선택

20.04 버전 우분투 사용

인스턴스 유형은 t2.micro

Amazon Linux 와 Ubuntu의 차이점

아마존은 돈만 낸다면 어떤 지원이든 편하게 받을수 있다
Ubuntu는 많은 개발자들이 전세계에 있기 때문에 Stack overflow나 여러 개발 커뮤니티에서 도움을 얻을수 있다

→ Ubuntu를 선택하게 되었다.

인스턴스는 1개로 정했다. ₩(인스턴스란 클라우딩 컴퓨터이며, 갯수를 늘리면 컴퓨터의 갯수도 늘어난다.)

인스턴스 생성 완료

인스턴스 생성이 완료 되었다.

중요!

키페어를 생성 했다면 키페어 파일이 다운로드 된다.

나중에 이 파일을 잃어버리게 되면 다시는 인스턴스에 접속 할수 없게 되니 잃어버리지 않도록 하자.

연결 하기

연결 버튼을 누른다.

연결 성공

이 화면에서 인스턴스들을 운용, 사용할수 있다.
사용하고 있는 컴퓨터에서 사용하려면 SSH 클라이언트 기능을 사용하면 된다.

누구나 접속 할수 있도록 설정하기

sudo apt update 명령어를 이용하여 최신버전으로 업데이트 시켜준다

sudo apt install apache2 를 통해 apache를 설치하면 내게 주어진 웹서버 주소를 통해 누구나 내가 만든 서버로 접속 할 수 있게 된다.
이제 나에게 주어진 IP주소를 입력하면 접속 할수 있다.

접속방법

바로 접속은 안된다. → 방화벽 설정을 끝내야 사용가능 (웹에서 사용하는 80번 포트를 안열었기 때문)

인바운드 규칙
- 최소한으로 열어야 한다
아웃바운드 규칙
- 전체 가 열려있어야 한다.

인바운드 규칙을 추가하고, HTTP로 설정한다음 0.0.0.0/0 까지 지정해주면 어떤 IP든지 접속할수 있도록 하게 된다.

다시 한번더 접속하게 되면 아래처럼 나오게 된다.

접속성공

가격

1년동안은 프리티어로 무료로 사용가능 하다.

무료 클라우드 컴퓨팅 서비스 - AWS 프리 티어

이 페이지에서 1년이 지난후에 구매해야 한다. 서비스를 지속적으로 사용하려면 구매 필수…

프래그먼트 다루기

Wed, 22 Mar 2023 11:12:05 GMT

안드로이드에서 프래그먼트(Fragment)란 액티비티(Activity) 내에서 화면 UI 일부를 나타내는 작은 조각입니다. 프래그먼트는 액티비티와 비슷한 생명주기를 가지며, 액티비티 내에서 여러 개의 프래그먼트를 조합하여 화면을 구성할 수 있습니다.

프래그먼트는 서로 다른 크기의 화면을 가진 기기에서 하나의 액티비티로 서로 다른 레이아웃을 구성할 수 있도록 설계되었습니다.
목록 프래그먼트와 상세 프래그먼트가 있을 때 태블릿 같은 큰화면에서는 두 프래그먼트를 한 화면에 표시하고 스마트폰 처럼 작은 화면에서는 먼저 목록 프래그먼트만 표시한 후에 목록을 클릭 하면 상세 가 나타나는 구조 입니다.
뷰가 하나만 필요 할 때는 프래그먼트를 사용하지 않습니다.

프래그먼트 생명주기

프래그먼트의 생명주기는 다음과 같습니다.

onAttach() : 프래그먼트가 액티비티에 붙을 때 호출됩니다.
onCreate() : 프래그먼트가 생성될 때 호출됩니다.
onCreateView() : 프래그먼트의 UI를 그리기 위해 호출됩니다.
onActivityCreated() : 프래그먼트가 액티비티와 연결되었을 때 호출됩니다.
onStart() : 프래그먼트가 화면에 표시될 때 호출됩니다.
onResume() : 프래그먼트가 화면에 표시된 후 호출됩니다.
onPause() : 프래그먼트가 일시적으로 화면에서 사라질 때 호출됩니다.
onStop() : 프래그먼트가 화면에서 완전히 사라질 때 호출됩니다.
onDestroyView() : 프래그먼트의 UI가 제거될 때 호출됩니다.
onDestroy() : 프래그먼트가 제거될 때 호출됩니다.
onDetach() : 프래그먼트가 액티비티에서 분리될 때 호출됩니다.

결론

프래그먼트는 안드로이드에서 화면을 구성하는 중요한 요소 중 하나입니다. 액티비티와 비슷한 생명주기를 가지며, 액티비티 내에서 여러 개의 프래그먼트를 조합하여 다양한 UI를 구성할 수 있습니다.

프래그먼트 만들기

onCreateView() 메서드는 리사이클러뷰의 onCreateViewHolder() 메서드 처럼 동작합니다. → 액티비티가 프래그먼트를 요청하면 onCreateView() 메서드를 통해 뷰를 만들어 보여줍니다.
inflate() 메서드는 리사이클러뷰 처럼 동일하게 동작합니다.
BlankFragment를 생성하고 아래와 같이 코드를 작성 합니다.

class ListFragment : Fragment() {



    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // Inflate the layout for this fragment
        return inflater.inflate(R.layout.fragment_list, container, false)
    }

}

inflater: 레이아웃 파일을 로드하기위한 인플레이터를 기본으로 제공합니다.
container: 프래그먼트 레이아웃이 배치되는 부모 레이아웃(액티비티 레이아웃 입니다)
savedInstanceState: 상태값을 저장하기 위한 보조 도구, 액티비티의 onCreate와 동일하게 동작합니다.

프래그먼트에서 액티비티의 레이아웃을 inflate 하기 위해서는 onCreateView() 메서드에서 LayoutInflater를 사용합니다. 액티비티와 연결된 레이아웃을 inflate 하려면 container 매개변수에 액티비티의 레이아웃을 전달하면 됩니다.

또한, 프래그먼트에서 버튼과 텍스트뷰를 사용하기 위해서는 inflate된 레이아웃의 View 객체를 먼저 가져와야 합니다. 이후 findViewById()를 사용하여 버튼과 텍스트뷰를 찾아와서 사용할 수 있습니다.

아래는 액티비티와 연결된 레이아웃에 텍스트뷰와 버튼을 띄우는 샘플 코드입니다.

class ExampleFragment : Fragment() {

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        // Inflate the layout for this fragment
        val view = inflater.inflate(R.layout.fragment_example, container, false)

        // TextView와 Button을 찾아온다
        val textView = view.findViewById(R.id.textview)
        val button = view.findViewById

위 코드에서 R.layout.fragment_example은 액티비티와 연결된 레이아웃 파일의 이름입니다. 이를 적절하게 수정해야 합니다.

컨테이너: 목록 만들기

Wed, 22 Mar 2023 08:44:19 GMT

ListView 사용하기

ListView는 안드로이드에서 가장 많이 사용되는 목록 뷰 중 하나입니다. ListView를 사용하면 단순한 목록부터 복잡한 목록까지 쉽게 구현할 수 있습니다.

1. XML 레이아웃에 ListView 추가하기

ListView를 사용하려면 먼저 XML 레이아웃 파일에 ListView를 추가해야 합니다. 예를 들어, activity_main.xml 파일에 ListView를 추가하려면 다음과 같이 작성합니다.

2. 데이터 소스 생성하기

ListView에 표시할 데이터를 생성합니다. 이 예제에서는 문자열 배열을 사용합니다.

val items = arrayOf("Apple", "Banana", "Orange", "Grapes")

3. 어댑터 생성하기

ListView의 데이터를 관리하는 어댑터를 생성합니다. ArrayAdapter를 사용하면 간단하게 문자열 배열을 ListView에 표시할 수 있습니다.

ArrayAdapter adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, items);

4. ListView에 어댑터 설정하기

ListView에 어댑터를 설정합니다.

ListView listView = (ListView) findViewById(R.id.list_view);
listView.setAdapter(adapter);

RecyclerView 사용하기

RecyclerView는 안드로이드에서 최근에 등장한 목록 뷰입니다. ListView보다 더 유연하고 성능도 좋습니다.

1. XML 레이아웃에 RecyclerView 추가하기

RecyclerView를 사용하려면 먼저 XML 레이아웃 파일에 RecyclerView를 추가해야 합니다. 예를 들어, activity_main.xml 파일에 RecyclerView를 추가하려면 다음과 같이 작성합니다.

2. 데이터 소스 생성하기

ListView와 마찬가지로 RecyclerView에 표시할 데이터를 생성합니다. 이 예제에서는 문자열 배열을 사용합니다.

String[] items = new String[] {"Apple", "Banana", "Orange", "Grapes"};

3. 어댑터 생성하기

RecyclerView의 데이터를 관리하는 어댑터를 생성합니다. RecyclerView.Adapter를 상속받는 어댑터를 만듭니다.

public class MyAdapter extends RecyclerView.Adapter {

    private String[] items;

    public MyAdapter(String[] items) {
        this.items = items;
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(android.R.layout.simple_list_item_1, parent, false);
        return new ViewHolder(view);
    }

    @Override
    public void onBindViewHolder(ViewHolder holder, int position) {
        holder.textView.setText(items[position]);
    }

    @Override
    public int getItemCount() {
        return items.length;
    }

    public static class ViewHolder extends RecyclerView.ViewHolder {
        TextView textView;

        public ViewHolder(View itemView) {
            super(itemView);
            textView = (TextView) itemView.findViewById(android.R.id.text1);
        }
    }
}

4. RecyclerView에 어댑터 설정하기

RecyclerView에 어댑터를 설정합니다.

RecyclerView recyclerView = (RecyclerView) findViewById(R.id.recycler_view);
recyclerView.setLayoutManager(new LinearLayoutManager(this));
recyclerView.setAdapter(new MyAdapter(items));

이렇게 ListView와 RecyclerView를 사용하여 안드로이드에서 목록을 만들 수 있습니다.

안드로이드 컨테이너: 스피너 만들기

1. XML 레이아웃에 Spinner 추가하기

Spinner를 사용하려면 먼저 XML 레이아웃 파일에 Spinner를 추가해야 합니다. 예를 들어, activity_main.xml 파일에 Spinner를 추가하려면 다음과 같이 작성합니다.

2. 데이터 소스 생성하기

Spinner에 표시할 데이터를 생성합니다. 이 예제에서는 문자열 배열을 사용합니다.

// 데이터 소스 생성하기
val items = arrayOf("Apple", "Banana", "Orange", "Grapes")

3. 어댑터 생성하기

Spinner의 데이터를 관리하는 어댑터를 생성합니다. ArrayAdapter를 사용하면 간단하게 문자열 배열을 Spinner에 표시할 수 있습니다.

// 어댑터 생성하기
val adapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, items)
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)

4. Spinner에 어댑터 설정하기

Spinner에 어댑터를 설정합니다.


// Spinner에 어댑터 설정하기
val spinner = findViewById(R.id.spinner)
spinner.adapter = adapter

이렇게 Spinner를 사용하여 안드로이드에서 선택할 수 있는 목록을 만들 수 있습니다.

생명 주기 콜백의 이해

Wed, 22 Mar 2023 08:19:52 GMT

액티비티는 인스턴스 생성과 동시에 생성과 관련된 생명 주기 메서드가 순차적으로 호출됩니다.
finish() 메서드나 뒤로가기로 액티비티를 종료하면 소멸과 관련된 생명주기 메서드가 순차적으로 호출됩니다.

액티비티 생명 주기

onCreate(): 액티비티가 생성될 때 호출됩니다. 여기서 액티비티 초기화를 수행합니다.
onStart(): 액티비티가 사용자에게 보여지기 전에 호출됩니다.
onResume(): 액티비티가 포그라운드에 위치하고 있을 때 호출됩니다. 이 시점에서 애니메이션 및 오디오 재생과 같은 리소스를 할당하는 것이 좋습니다.
onPause(): 액티비티가 일시 중지되었을 때 호출됩니다. 포그라운드에 위치하지 않지만 화면에 여전히 보이는 경우도 있습니다.
onStop(): 액티비티가 더 이상 사용자에게 표시되지 않을 때 호출됩니다.
onDestroy(): 액티비티가 소멸될 때 호출됩니다. 리소스 해제 및 전체적인 정리를 수행합니다.

프레그먼트 생명 주기

onAttach(): 프래그먼트가 액티비티에 붙을 때 호출됩니다.
onCreate(): 프래그먼트가 생성될 때 호출됩니다. 여기서 초기화를 수행합니다.
onCreateView(): 뷰를 생성하고 반환합니다. 여기서 UI 구성 요소를 초기화합니다.
onActivityCreated(): 액티비티에서 프래그먼트의 onCreate() 메서드 호출이 완료된 후에 호출됩니다.
onStart(): 프래그먼트가 사용자에게 보여지기 전에 호출됩니다.
onResume(): 프래그먼트가 포그라운드에 위치하고 있을 때 호출됩니다. 이 시점에서 애니메이션 및 오디오 재생과 같은 리소스를 할당하는 것이 좋습니다.
onPause(): 프래그먼트가 일시 중지되었을 때 호출됩니다. 포그라운드에 위치하지 않지만 화면에 여전히 보이는 경우도 있습니다.
onStop(): 프래그먼트가 더 이상 사용자에게 표시되지 않을 때 호출됩니다.
onDestroyView(): 프래그먼트의 UI가 제거됩니다. 여기서 뷰와 관련된 리소스를 해제합니다.
onDestroy(): 프래그먼트가 소멸될 때 호출됩니다. 리소스 해제 및 전체적인 정리를 수행합니다.
onDetach(): 프래그먼트가 액티비티에서 분리될 때 호출됩니다.

액티비티 백스택

백스택은 액티비티 또는 화면 컴포넌트를 담는 안드로이드의 저장 공간입니다.
새로운 액티비티가 시작되면 이전 액티비티는 백스택에 저장됩니다. 이전 액티비티는 사용자가 뒤로가기 버튼을 누르거나 finish() 메서드를 호출하여 종료될 수 있습니다. 사용자가 뒤로가기 버튼을 누르면 백스택에서 가장 최근에 저장된 액티비티가 화면에 표시됩니다. 이것은 액티비티를 백그라운드에서 실행하고 다시 포그라운드로 가져오는 데 사용됩니다.

태스크와 프로세스

태스크(Task)는 어플에서 실행되는 프로세스를 관리하는 작업 단위입니다.
안드로이드에서 태스크는 다른 프로세스의 액티비티를 담을 수 있습니다.
안드로이드는 서로 다른 어플리케이션의 액티비티를 공유 할 수 있는데 카메라와 갤러리 액티비티를 예로 들수 있습니다. 카메라 기능을 간단한 코드로 호출해서 사용하명 실제로능 카메라 앱의 독자적인 프로세스가 실행되고 카메라 액티비티 또한 카메라 앱의 프로세스에 의해 처리됩니다.
인텐트를 통해 카메라앱에 전달하는 코드를 구현하면 다음과 같습니다.

fun openCamera() {
    val intent - Intent(MediaStore.ACTION_IMAGE_CAPTURE)
    activityResult.launch(intent)
}

카메라를 사용하기 위한 인텐트를 시스템으로 전달하면 카메라 액티비티가 다른 앱이 있기 때문에 프로세스를 새로 생성합니다.

→ 호출된 카메라 액티비티가 새로운 프로세스를 통해 동작하지만 하나의 작업 단위인 태스크로 묶입니다. 결국 하나의 앱처럼 동일한 태스크로 묶이고 백스택에 쌓이게 됩니다.

같은 태스크의 백스택에 쌓이기 때문에 뒤로가기 버튼을 누르면 같은 앱의 액티비티 처럼 백스택에서 제거되고 , 홈버튼을 누르면 마치 하나의 태스크 전체가 백그라운드로 이동합니다.

액티비티 태스크 관리하기

액티비티 태스크는 두 가지 방법으로 관리할 수 있습니다. 먼저는 매니패스트의 설정으로 관리하는 방법입니다.

태그 안의 속성으로 사용할 수 있습니다.

⇒

launchMode: 액티비티의 launchMode 속성을 이용하여 태스크 관리를 할 수 있습니다. launchMode에는 standard, singleTop, singleTask, singleInstance가 있으며, 각각 다른 태스크 관리 방식을 가집니다.
Intent Flag: Intent Flag를 이용하여 태스크 관리를 할 수 있습니다. FLAG_ACTIVITY_NEW_TASK, FLAG_ACTIVITY_CLEAR_TOP, FLAG_ACTIVITY_SINGLE_TOP 등이 있으며, 각각 다른 태스크 관리 방식을 가집니다.
TaskAffinity: TaskAffinity 속성을 이용하여 액티비티가 속할 태스크를 지정할 수 있습니다. TaskAffinity 속성을 이용하여 액티비티가 속한 태스크의 관리를 세부적으로 조정할 수 있습니다.

태스크 관리를 잘 이용하면 앱의 사용자 경험을 개선할 수 있습니다.

사이드 프로젝트 2일차

Tue, 21 Mar 2023 13:19:59 GMT

로그인 화면 제작하기!

XML 코드

액티비티와 연결 하기!

viewBinding을 사용해서 각 텍스트뷰의 명들과 버튼을 바인딩 시켰습니다.
뷰바인딩을 쓰면 나중에 코드유지 보수하기 쉽도록 하기 위함입니다.
디자인은 잘 못하지만 깔끔하게 만들어 보았습니다.

결과물

다음에 할일

목록 화면 만들기
데이터 크롤링 하기

사이드 프로젝트(Based on Tinder) 1일차

Mon, 20 Mar 2023 13:16:04 GMT

틴더처럼 카드뷰를 통해 앱을 한번 만들어 보려고 한다.
카드뷰를 활용해서 데이터를 띄우기
원하는 데이터 Retrofit을 통해 전달 받기
문맹률 줄이기

카드뷰를 먼저 만들기 위한 작업 진행

아래 블로그를 참고해서 밑작업을 시작 했다.

[안드로이드] Activity에서 RecylerView + CardView 연결하기 (Kotlin)

class MainActivity : AppCompatActivity() {
    //databinding
    private lateinit var binding: ActivityMainBinding

    //CardView를 담을 리사이클러 뷰를 lateinit으로 미리 선언해줍니다.
    private lateinit var reCyclerView: RecyclerView
    private lateinit var viewAdapter: RecyclerView.Adapter<*>
    private lateinit var viewManager: RecyclerView.LayoutManager

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        // 1. LinearLayout으로 쌓기위해 초기화
        viewManager = LinearLayoutManager(this, RecyclerView.HORIZONTAL,true )
        // 2. 미리 만들 어댑처를 초기화 한다.
        viewAdapter = MyAdapter()

        // 3. 만들어놓은 리사이클러뷰에 어댑터를 붙이기!
        reCyclerView =binding.recycleView.apply{
// use this setting to improve performance if you know that changes
            // in content do not change the layout size of the RecyclerView
            setHasFixedSize(true)
            // use a linear layout manager
layoutManager= viewManager
            // specify an viewAdapter (see also next example)
adapter= viewAdapter
    }

}
    // 액티비티가 파괴될 때..
    override fun onDestroy() {
        // onDestroy 에서 binding class 인스턴스 참조를 정리해주어야 한다.

        super.onDestroy()
    }

findviewbyID 보다 ViewBinding을 시켜서 보다 쉽고 간결하게 코드를 써보았다.
여기엔 안썼지만 어댑터도 필요하고, 레이아웃도 짜야 한다.

코드의 결과물
조금더 꾸며서 발전 시켜봐야 겠다.

다음 할일

회원가입 화면 구성
간단한 심리검사 페이지 구성(리사이클러 뷰를 통해 만들것)
전체 화면 구성 (프래그먼트를 사용할 예정)
DB 구성 및 AWS서버 구성

스코프 함수

Mon, 20 Mar 2023 08:50:34 GMT

코틀린에서는 스코프 함수라는 특별한 함수가 제공됩니다. 스코프 함수는 객체의 속성에 접근하거나 메서드를 호출하는 등의 작업을 보다 간결하게 처리할 수 있는 기능을 제공합니다.

코드를 축약해서 표현할 수 있도록 도와주는 함수, 영역 함수라고도 합니다.
함수처럼 사용은 아하며, run, let처럼 괄호 없이 일종의 키워드로 사용할 수 있습니다.
Safe Call남용을 막아주는 역할도 하기 때문에 많이 사용하는 요소 입니다.

스코프 함수에는 다음과 같은 종류가 있습니다.

1. let

let 함수는 null이 아닌 객체에 대해서만 수행되며, 객체를 파라미터로 받습니다. 람다식 내에서는 해당 객체를 it 키워드로 참조할 수 있습니다. 반환값은 람다식의 마지막 구문의 결과값입니다.

val name: String? = "John Doe"
name?.let {
    println(it.length) // name이 null이 아닐 때만 실행
}

2. also

also 함수는 객체를 파라미터로 받고, 람다식 내에서 해당 객체를 it 키워드로 참조할 수 있습니다. 반환값은 해당 객체 자체입니다.

val list = mutableListOf()
list.also {
    println("List has been created.")
}.add("apple")

3. apply

apply 함수는 객체를 파라미터로 받고, 람다식 내에서 해당 객체를 this 키워드로 참조할 수 있습니다. 반환값은 해당 객체 자체입니다.

val person = Person("John Doe").apply {
    age = 30
    gender = "Male"
}

4. run

run 함수는 let 함수와 유사하지만, 해당 객체를 this 키워드로 참조할 수 있습니다. 반환값은 람다식의 마지막 구문의 결과값입니다.

val result = "John Doe".run {
    println(length)
    length
}

5. with

with 함수는 객체를 파라미터로 받고, 람다식 내에서 해당 객체를 this 키워드로 참조할 수 있습니다. 반환값은 람다식의 마지막 구문의 결과값입니다.

val person = Person("John Doe")
with(person) {
    age = 30
    gender = "Male"
}

지연 초기화

Mon, 20 Mar 2023 08:38:43 GMT

코틀린 지연 초기화

코틀린에서는 변수를 선언할 때 즉시 초기화를 해야 하는데, 때로는 초기화를 뒤로 미루고 싶은 경우가 있습니다. 이때 사용하는 것이 지연 초기화입니다.

lateint

lateinit은 'late initialization'의 약자로, 변수를 선언할 때 초기화하지 않고, 추후에 초기화하는 기능입니다.

lateinit 키워드를 사용하여 변수를 선언할 때 초기화를 하지 않아도 되는 장점이 있습니다. 이는 예를 들어, 객체의 생성자에서 초기화할 수 없는 경우에도 사용할 수 있습니다.

lateinit var name: String

fun initializeName() {
    name = "John"
}

위 코드에서는 lateinit으로 선언된 name 변수를 선언할 때 초기화하지 않았습니다. 대신, 추후 initializeName() 함수를 호출하여 name 변수를 초기화합니다.

Nullable로 선언하는 방법

일반적인 선언방식입니다. 처음에는 null을 입력해두고, 클래스의 다른 메서드 영역에서 값을 입력 합니다.

class Person{
    var name: String? = null
    init{
        name = "Lionel"
    }
    fun process() {
        name?.plus("Messi")
        print("이름의 길이 = ${name?.legth}")
        print("이름의 첫 글자 = ${name?.substring(0,1}")
    }
}

lateinit 특징

변수를 선언할 때 즉시 초기화하지 않아도 됨
추후 초기화 가능
nullable로 선언하지 않음

lazy

lazy는 변수를 최초로 사용할 때에만 초기화하는 기능입니다. 이를 통해 불필요한 초기화를 하지 않고 성능을 높일 수 있습니다.

val name: String by lazy {
    println("초기화")
    "John"
}

fun main() {
    println(name)
    println(name)
}

위 코드에서는 name 변수를 선언할 때 lazy 키워드를 사용하여 초기화를 뒤로 미루었습니다. 따라서, name 변수를 최초로 사용할 때에만 초기화가 수행됩니다.

이를 통해, 성능이 더 중요한 상황에서 lazy를 사용하여 불필요한 초기화를 줄일 수 있습니다.

Lazy특징

선언 시에 초기화 코드를 함께 작성하기 때문에 따로 초기화 할 필요 없습니다.
lazy로 선언된 변수가 최초 호출되는 시점에 by lazy{} 안에 넣은 값으로 초기화 됩니다. 클래스가 초기화 되더라도 바로 초기화 되지 않고 호출되는 순간 초기화 됩니다.
최초 호출 되는 시점에 초기화 되기 때문에 초기화 리소스가 너무 크면 전체 처리속도에 영향을 미칠수 있으니 복잡한 코드 같은 경우엔 미리 초기화 하는것이 좋습니다.

Null Safety

Mon, 20 Mar 2023 07:51:32 GMT

Null safety란 코틀린에서 null 값을 다룰 때 발생하는 오류를 줄이고 안정적인 코드를 작성하기 위한 기능입니다.

코틀린에서는 기본적으로 null 값을 허용하지 않으며, null 값을 다루기 위해서는 nullable 타입을 사용해야 합니다. nullable 타입은 해당 변수에 null 값을 할당할 수 있도록 해줍니다.

하지만 nullable 타입을 사용할 경우, null 값을 처리하지 않고 그대로 사용하면 NullPointerException이 발생할 수 있습니다. 이를 방지하기 위해 코틀린에서는 안전한 호출(Safe call) 연산자인 ?.와 엘비스 연산자(?:)를 제공합니다.

?. 연산자는 해당 변수가 null이 아닐 때만 호출하고, null일 경우 null을 반환합니다. 엘비스 연산자(?:)는 해당 변수가 null일 경우 대체값을 반환합니다.

또한 코틀린에서는 null 체크를 강제하는 Non-null 타입을 제공합니다. 이를 사용하면 해당 변수에 null 값을 할당할 수 없어 NullPointerException을 방지할 수 있습니다.

이러한 null safety 기능을 적절히 활용하면 안정적이고 오류가 적은 코드를 작성할 수 있습니다.

변수에 null 허용

var nullable: String? //타입 다음에 물음표를 붙여 null 값을 입력할 수 있다.
nullable = null

var notNullable = String
notNullable = null //일반 변수엔 Null을 입력할 수 없습니다.

함수 파라미터에 null 허용

fun printLength(str: String?) {
    println(str?.length ?: "null")
}

fun main() {
    val str: String? = null
    printLength(str)
}

위 코드는 printLength 함수를 정의하고, main 함수에서 printLength 함수를 호출하는 코드입니다.

printLength 함수는 nullable한 String 타입의 매개변수 str을 받아 해당 문자열의 길이를 출력합니다. 이 때, str?.length와 같이 안전한 호출 연산자 ?.를 사용하여 str이 null일 경우 null을 반환하도록 합니다. 또한, ?: 연산자를 사용하여 str?.length가 null일 경우 대체값인 "null"을 반환하도록 합니다.

main 함수에서는 nullable한 String 타입의 변수 str을 null로 초기화하고, printLength 함수를 호출합니다. 이 때, printLength 함수에서 안전한 호출 연산자와 엘비스 연산자를 사용하여 str이 null일 경우 "null"을 출력합니다.

함수의 리턴 타입에 null 허용

함수의 리턴타입에 물음표를 붙여서 null 허용 여부를 설정 할 수 있습니다.

fun nullReturn(): String?{
        reutn null
    }

안전한 호출 연산자 ?. & 엘비스 연산자 (?:)

안전한 호출 연산자인 ?.은 해당 변수가 null이 아닐 때만 호출하고, null일 경우 null을 반환합니다. 또한, 엘비스 연산자(?:)는 해당 변수가 null일 경우 대체값을 반환합니다.

var nullable: String? //타입 다음에 물음표를 붙여 null 값을 입력할 수 있다.
nullable = null

var notNullable = String
notNullable = null //일반 변수엔 Null을 입력할 수 없습니다.

fun printLength(str: String?) {
    println(str?.length ?: "null")
}

fun nullReturn(): String?{
    return null
}

위 코드는 nullable한 String 타입의 변수 nullable을 선언하고, null 값을 할당하는 코드입니다. 또한, 일반적인 String 타입의 변수 notNullable은 null 값을 할당할 수 없습니다.

nullReturn 함수는 nullable한 String 타입의 값을 리턴하며, 이를 통해 null 값을 리턴할 수 있음을 보여줍니다.

코틀린 설계 도구 (패키지, 추상화, 인터페이스, 제네릭)

Mon, 20 Mar 2023 07:13:08 GMT

객체지향 프로그래밍은 구현(실제 로직을 갖는 코딩)과 설계(껍데기만 있는 코딩)으로 구분할 수 있습니다.

패키지

컴퓨터 언어에서 패키지 사용의 목적이 설계라고 볼수 있습니다. 패키지는 클래스와 소스 파일을 관리 하기 위한 디렉토리 구조의 저장 공간 입니다.

코틀린에서 패키지는 물리적인 디렉토리 구조로 표현됩니다. 패키지 이름은 소문자로 작성되며, 점(.)으로 구분됩니다. 패키지 내에는 클래스, 함수, 프로퍼티 등이 포함될 수 있습니다. 패키지를 선언할 때는 package 키워드를 사용합니다.

예를 들어, org.example.myproject 패키지 내에 MyClass라는 클래스를 선언하려면 다음과 같이 작성합니다.

package org.example.myproject

class MyClass {
  // ...
}

패키지를 지정하지 않으면 기본 패키지가 사용됩니다.

추상화

추상화는 객체 지향 프로그래밍에서 중요한 개념 중 하나입니다. 추상화는 객체의 공통적인 특징을 뽑아내어 인터페이스나 추상 클래스 등으로 정의하는 것을 말합니다. 추상화를 통해 객체들 사이의 공통점을 찾는 것이 가능하며, 이를 바탕으로 코드의 유지보수성이나 재사용성을 높일 수 있습니다.

코틀린에서 추상화는 인터페이스나 추상 클래스를 사용하여 구현됩니다. 인터페이스는 객체의 동작 방식을 정의하는 일종의 계약서 역할을 하며, 추상 클래스는 추상 메서드와 구현된 메서드를 모두 포함할 수 있는 클래스입니다. 추상 클래스를 사용하면 공통적인 로직을 구현하고, 상속받은 클래스에서 필요한 부분만 구현할 수 있습니다.

쉽게 설명하면 클래스 설계 과정에서 구현해야 하는 메서드의 이름만 명시 하고 구현은 나중에 하는것을 이야기 합니다.
Activity클래스가 상속 받는 클래스중 Context클래스는 abstract로 설계되어있습니다.

예를 들어, 다음은 추상 클래스와 인터페이스를 사용하여 추상화를 구현한 코드입니다.

// 추상 클래스
abstract class Animal {
    abstract fun makeSound()
    fun eat() {
        println("먹는다")
    }
}

// 인터페이스
interface Flyable {
    fun fly()
}

// 구현 클래스
class Dog: Animal() {
    override fun makeSound() {
        println("멍멍")
    }
}

class Bird: Animal(), Flyable {
    override fun makeSound() {
        println("짹짹")
    }

    override fun fly() {
        println("날다")
    }
}

추상화 주의 할 점

과도한 추상화는 코드의 복잡도를 증가시킬 수 있습니다. 따라서 필요 이상으로 추상화를 사용하지 않도록 주의해야 합니다.
추상화된 개념을 명확히 정의하고 문서화해야 합니다. 이를 통해 추상화된 개념에 대한 이해도를 높이고, 코드의 가독성을 향상시킬 수 있습니다.
추상화된 개념은 실제로 사용되는 곳에서 검증되어야 합니다. 따라서 코드를 작성하기 전에 프로토타입을 만들어 테스트하는 것이 좋습니다.
추상 클래스는 독립적으로 인스턴스와 할 수 없기 때문에 구현 단계가 고려되지 않는다면 잘못된 설계가 될 수 있습니다.

인터페이스

인터페이스는 객체 지향 프로그래밍에서 중요한 개념 중 하나로, 클래스나 객체가 어떤 메서드를 구현해야 하는지를 정의하는 일종의 계약서 역할을 합니다. 인터페이스는 클래스와 마찬가지로 추상적인 개념이기 때문에 직접 인스턴스화할 수 없습니다. 하지만 인터페이스를 구현하는 클래스를 만들고 해당 클래스를 인스턴스화하여 사용할 수 있습니다.

코틀린에서 인터페이스는 interface 키워드를 사용하여 정의됩니다. 인터페이스 내에서는 메서드 또는 프로퍼티를 선언할 수 있으며, 기본적으로 추상 메서드로 선언됩니다. 인터페이스 내에서 구현된 메서드는 없지만, 디폴트 구현을 제공할 수도 있습니다.

예를 들어, 다음은 Runnable 인터페이스를 구현하는 클래스의 예시 코드입니다.

interface Runnable {
    fun run()
}

class MyRunnable : Runnable {
    override fun run() {
        println("Hello, World!")
    }
}

val thread = Thread(MyRunnable())
thread.start()

이 예시 코드에서 MyRunnable 클래스는 Runnable 인터페이스를 구현합니다. Runnable 인터페이스는 run 메서드를 선언하고 있으며, MyRunnable 클래스에서는 run 메서드를 구현합니다. thread.start() 메서드를 호출하면, MyRunnable 클래스의 run 메서드가 실행됩니다.

추상화와 인터페이스의 차이점

개념 클래스 중에 실행 코드가 한 줄이라도 있으면 추상화, 코드없이 메서드 이름만 나열되어 있으면 인터페이스 입니다.

접근제한자

코틀린에서 정의되는 클래스, 인터페이스, 메서트, 프로퍼티는 모두 접근 제한자를 가질 수 있습니다.

함수형 언어라는 특성으로 기존 객체지향에서 접근 제한자의 기준으로 삼았던 패키지 대신에 모듈 개념이 도입되었습니다. internal 접근 제한자로 모듈 간에 접근을 제한할 수 있습니다.

접근 제한자의 종류

접근 제한자	대상	설명
public	클래스, 인터페이스, 메서드, 프로퍼티	어디서든지 접근 가능(기본적용)
internal	모듈 내부	같은 모듈 내에서만 접근 가능
protected	클래스 내부, 하위 클래스	클래스 내부와 하위 클래스에서만 접근 가능
private	클래스 내부	같은 클래스 내부에서만 접근 가능
- public: 어디서든지 접근 가능합니다. 아무런 접근 제한자가 지정되지 않으면 기본값으로 public이 지정됩니다.

class Example {
    public var name: String = "John"
}

internal: 같은 모듈 내에서만 접근 가능합니다.

internal class Example {
    internal fun printHello() {
        println("Hello")
    }
}

protected: 클래스 내부와 하위 클래스에서만 접근 가능합니다.

open class Example {
    protected var name: String = "John"
}

class SubExample : Example() {
    fun printName() {
        println(name)
    }
}

private: 같은 클래스 내부에서만 접근 가능합니다.

class Example {
    private var name: String = "John"
    fun printName() {
        println(name)
    }
}

제네릭

제네릭은 입력되는 값의 타입을 자유롭게 사용하기 위한 설계도구입니다.

제네릭(Generic)은 입력되는 값의 타입을 자유롭게 사용하기 위한 설계도구입니다. 제네릭을 사용하면 클래스나 함수의 타입을 일반화할 수 있습니다. 이를 통해 클래스나 함수를 만들 때 타입에 대한 제약이 없어지므로, 코드의 재사용성이 높아집니다.

제네릭을 사용하는 방법은 다음과 같습니다.

class ClassName {
    var variable: T
}

위의 예시에서 T는 제네릭 타입 매개변수입니다. T는 어떤 타입이든 될 수 있습니다. ClassName 클래스를 사용할 때, T 대신 구체적인 타입을 지정해줘야 합니다.

val obj = ClassName()
obj.variable = "Hello, World!"

위의 예시에서 obj 변수는 ClassName 클래스의 인스턴스입니다. ClassName 클래스는 제네릭 클래스이므로, obj 변수 선언에서 제네릭 타입 매개변수 T를 String으로 지정해줍니다. 따라서 obj 변수의 variable 프로퍼티는 String 타입이 됩니다.

제네릭을 사용하는 가장 일반적인 예시 중 하나는 컬렉션입니다. 다음은 List 인터페이스를 구현하는 ArrayList 클래스에서 제네릭을 사용한 예시입니다.

val list: ArrayList = ArrayList()
list.add("Hello")
list.add("Kotlin")
println(list)

위의 예시에서 list 변수는 ArrayList 클래스의 인스턴스입니다. ArrayList 클래스는 List 인터페이스를 구현하고 있으며, 제네릭 타입 매개변수로 String을 사용하고 있습니다. 따라서 list 변수는 String 타입을 요소로 갖는 리스트입니다. list.add() 메서드를 사용하여 요소를 추가할 수 있으며, println(list)를 호출하여 리스트의 내용을 출력할 수 있습니다.

제네릭을 사용하면 타입에 대한 제약이 없어지므로 코드의 재사용성이 높아집니다. 또한, 컴파일 시점에 타입 검사가 이루어지므로, 런타임에 발생할 수 있는 오류를 방지할 수 있습니다.

함수에서 제네릭 사용하기
```
 fun  List.slice(indices: IntRange): List {
     // ...
 }
```
이 경우, 함수 이름 앞에 를 작성하면 제네릭 함수를 선언할 수 있습니다. 여기서 T는 함수가 인수로 받는 타입을 나타냅니다.
클래스에서 제네릭 사용하기
```
 class Box(t: T) {
     var value = t
 }
```
이 경우, 클래스 이름 뒤에 를 작성하면 제네릭 클래스를 선언할 수 있습니다. 여기서 T는 클래스가 인스턴스화될 때 사용되는 타입을 나타냅니다.
인터페이스에서 제네릭 사용하기
```
 interface List {
     // ...
 }
```
이 경우, 인터페이스 이름 뒤에 를 작성하면 제네릭 인터페이스를 선언할 수 있습니다. 여기서 T는 인터페이스가 구현될 때 사용되는 타입을 나타냅니다.

오버라이드와 익스텐션

Mon, 20 Mar 2023 06:08:32 GMT

오버라이드

코틀린에서 클래스 상속은 자바와 비슷한 방식으로 동작합니다. 자식 클래스는 부모 클래스의 메소드를 오버라이드할 수 있습니다. 이는 부모 클래스에 정의된 메소드를 자식 클래스에서 새로운 구현으로 대체하는 것을 의미합니다.

코틀린에서는 override 키워드를 사용하여 메소드를 오버라이드할 수 있습니다. 오버라이드된 메소드는 부모 클래스의 메소드와 이름, 매개변수, 반환 유형이 동일해야 합니다. 그러나 자식 클래스에서는 메소드 구현을 변경할 수 있습니다.

다음은 Animal 클래스를 상속받아 Cat 클래스에서 makeSound() 메소드를 오버라이드하는 예시 코드입니다.

open class Animal {
    open fun makeSound() {
        println("The animal makes a sound")
    }
}

class Cat : Animal() {
    override fun makeSound() {
        println("Meow")
    }
}

이 예시에서 Animal 클래스의 makeSound() 메소드는 open 키워드로 선언되었기 때문에, Cat 클래스에서 이를 오버라이드할 수 있습니다. Cat 클래스에서 오버라이드된 makeSound() 메소드는 "Meow"를 출력합니다.

오버라이드 주의 할 점

부모 클래스의 메소드를 오버라이드할 때는 이름, 매개변수, 반환 유형이 모두 일치해야 합니다.
자식 클래스에서 오버라이드된 메소드는 부모 클래스의 메소드를 대체합니다.
하지만, 자식 클래스에서는 오버라이드된 메소드를 확장할 수 있습니다. 이때 super 키워드를 사용하여 부모 클래스의 메소드를 호출할 수 있습니다.
자식 클래스에서 open 키워드를 사용하여 오버라이드할 수 있는 메소드를 선언해야 합니다. 만약 부모 클래스에서 메소드가 final로 선언되어 있다면, 오버라이드할 수 없습니다.

익스텐션

코틀린에서는 또한 익스텐션(Extension)이라는 기능이 있습니다. 익스텐션은 이미 존재하는 클래스에 새로운 기능을 추가합니다. 이를 통해 기존 클래스의 코드를 수정하지 않고도 새로운 기능을 추가할 수 있습니다.

익스텐션을 사용하려면 클래스 이름 뒤에 점(.)을 붙이고, 새로운 메소드 이름을 정의합니다. 이를 활용하여 기존 클래스에 새로운 메소드를 추가할 수 있습니다. 새로운 메소드는 클래스 내부의 다른 메소드와 같은 방식으로 작동합니다.

코틀린의 오버라이드와 익스텐션은 각각 클래스 상속과 클래스 확장을 위한 강력한 기능입니다. 코드의 재사용성을 높이고, 새로운 기능을 추가하거나 기존 기능을 수정할 수 있는 유연성을 제공합니다.

다음은 String 클래스에 addExclamation() 메소드를 추가하는 익스텐션 예시 코드입니다.

fun String.addExclamation(): String {
    return "$this!"
}

이 예시에서 String 클래스에 addExclamation() 메소드를 추가하고 있습니다. addExclamation() 메소드는 문자열 뒤에 느낌표를 추가하여 반환합니다. 이제 String 클래스의 인스턴스에서 addExclamation() 메소드를 호출할 수 있습니다.

val greeting = "Hello"
println(greeting.addExclamation()) // 출력: "Hello!"

위 예시에서 addExclamation() 메소드를 사용하여 "Hello!"를 출력합니다.

익스텐션 주의 할 점

익스텐션은 클래스의 기능을 수정하는 것이 아니라 기존 클래스에 새로운 함수를 추가하는 것입니다.
익스텐션에서는 클래스의 프로퍼티에 접근할 수 없습니다.
익스텐션 함수를 호출할 때, 클래스 내부의 멤버 함수와 같은 이름의 함수가 있다면, 멤버 함수가 호출됩니다.
익스텐션 함수는 클래스 내부의 private 멤버에 접근할 수 없습니다.
뷰- 액티비티를 연결해 뷰를 바로 쓸수 있다는 장점이 있지만 안드로이드 스튜디오 4.1 버전 이후 부터는 추천을 안하고 있습니다. 뷰를 바로 사용하고 싶다면, DataBinding을 이용하는것이 좋습니다.

오브젝트

Mon, 20 Mar 2023 05:59:39 GMT

오브젝트란?

오브젝트는 클래스의 인스턴스를 만들어 내지 않고, 고유한 인스턴스를 바로 생성하는 것이 가능한 싱글톤 패턴의 구현 방법 중 하나입니다. 코틀린에서는 object 키워드를 사용하여 오브젝트를 생성할 수 있습니다. 이를 사용하면 인스턴스를 생성하기 위한 보일러플레이트 코드를 줄일 수 있으며, 코드의 가독성과 유지보수성을 향상시킬 수 있습니다.

자바에서는 static과 같은 역활
예시 코드

object Pig{
    var name: String = "Pinky"
        fun printName(){
            Log.d("class", "Pig의 이름은 ${name}입니다.")
        }
}

오브젝트 코드 블록 안의 프로퍼티와 베서드는 클래스명에 도트 연산자를 붙여서 생성자 없이 직접 호출 가능합니다.
주의 할 점은 클래스명을 그대로 사용하기 때문에 호출하는 클래스명의 첫글자가 대문자 입니다.
object는 클래스와 다르게 앱 전체에 1개만 생성됩니다.

컴패니언 오브젝트

컴패니언 오브젝트는 클래스 내부에 선언되는 오브젝트로, 클래스의 인스턴스와는 별개로 생성되며 해당 클래스와 관련된 유틸리티 메서드나 프로퍼티를 담을 수 있습니다. 컴패니언 오브젝트를 선언하면 해당 클래스의 이름으로 접근할 수 있는 "정적" 멤버 변수나 메서드를 선언할 수 있습니다. 코틀린에서는 companion object 키워드를 사용하여 컴패니언 오브젝트를 생성할 수 있습니다.

컴패니언 오브젝트의 멤버 변수와 메서드는 클래스명을 사용하여 직접 호출할 수 있습니다.
컴패니언 오브젝트 내부에서 선언된 멤버 변수와 메서드는 private으로 선언되어 있는 멤버 변수와 메서드를 사용할 수 있습니다.
컴패니언 오브젝트는 클래스와 마찬가지로 생성자를 가질 수 있습니다.
클래스 내부에는 하나의 컴패니언 오브젝트만 선언할 수 있습니다.
예시 코드

class MyClass {
    companion object {
        *val myProperty = "Hello, World!"
        fun myMethod() {
            println("This is a companion object method.")
        }*
    }
}

MyClass.*myProperty = "Hi"*
MyClass.*myMethod() -> "This is a companion object method."*

위 코드에서 MyClass.myProperty와 MyClass.myMethod()를 이용하여 컴패니언 오브젝트의 멤버에 접근할 수 있습니다.