Bin's의 개발블로그

[SQLD] 2026년 SQL 개발자 시험 - 도서 리뷰 (이기적 SQL개발자 이론서 + 기출문제)

Bin's. — Sun, 15 Feb 2026 18:34:06 +0900

클라이언트 개발을 하다 보면 서버와 DB에 대한 이해도가 필요해지는 시점이 옵니다.

예시로 복잡한 비지니스 로직을 처리하는 시점과 데이터 구조설계하는 등 다양한 상황에 필요하며,
특히 데이터를 효율적으로 쿼리하거나 구조를 이해하는데 있어 SQL 능력은 필수적이라고 생각합니다.

저는 작년에 지인이 SQLD 시험을 준비하길래 관심을 가지고 있다가

2026년 상반기 목표 중 하나로 SQLD(SQL 개발자)자격을 취득을 해보려 합니다.

SQLD 시험 일정은 https://www.dataq.or.kr/www/accept/schedule.do 에서 확인해 볼 수 있습니다.

Photo by https://www.dataq.or.kr/www/accept/schedule.do

올해 첫 시험이 3월 7일로 시간이 넉넉하진 않아서, 독학으로 빠르게 끝낼 수 있는 교재를 찾았습니다.

먼저 온라인으로 몇권 비교해보고 섹션별 이론을 확인하며 바로 기출문제를 풀 수 있는 이기적 출판의 SQLD로 선택했습니다.

교재를 선택할 때 가장 중요하게 본 기준 중 하나는 '러닝 커브를 줄여줄 수 있는가'였습니다.
독학으로 진행하다 보면 생소한 개념에서 막혀 시간을 허비하는 경우가 많은데,

이 책은 저자 직강 동영상 강의(이론 및 기출)를 무료로 제공하고 있어 막히는 구간을 빠르게 해소할 수 있었습니다.

https://cbt.youngjin.com/exam/index.php?no=73

특히나 CBT 온라인 문제집 서비스를 제공해서 언제든지 문제를 풀어볼 수 있다는 점도 매우 좋았습니다.
또한 QR코드를 제공해 원하는 기능에 바로 접속이 가능해 접근성도 나쁘지 않았습니다.

이기적 스터디 카페에서 도서 구매 인증 시 SQL 구문을 직접 연습할 수 있는 실습 문제와 데이터 파일을 제공해줍니다.
로컬 환경에서 직접 데이터를 조작해보며 익힐 수 있다는 점이 SQLD 자격증 독학에 최적화된 교재라고 생각합니다.

추가로 이기적 스터디 카페 및 오픈채팅방에서 질문을 하면 저자가 직접 답변해준다는 점도 메리트 있는거 같습니다.

자격증을 공부하며 중요한 인덱싱과 개념을을 공부하며 기출로 복기할 수 있다는점은 매우 만족한 점 이였습니다.

그리고 추가적으로 SQLD 자격증은 취득 후 2년이라는 유효기간이 존재하는데 1년 6개월 이후 별도의 '보수교육'을 들어
자격증을 영구전환해야한다는 팁도 있어 독자를 배려하는 느낌이 많이 나는 책입니다.

보수 교육

[https://www.dataq.or.kr/www/sub/a_iocon.do]

이 책의 가장 큰 장점 중 하나는 매번 달라지는 시험 출제 경향을 철저하게 분석하고,
이를 바탕으로 수험생이 기간별로 체계적인 학습 플랜을 세울 수 있도록 가이드라인을 제시해 준다는 점입니다.
독학을 하다 보면 진도 관리가 가장 어려운데, 책에 수록된 스터디 플래너를 활용하니 페이스 조절이 훨씬 수월했습니다.

특히 저처럼 단기간에 자격증 취득을 목표로 하는 수험생에게는 '선택과 집중'이 필수적입니다.

저는 책에서 제안하는 20일 완성 플랜을 따라 하루도 빠짐없이 이론 진도를 나가는 것을 1차 목표로 삼았습니다.

그리고 남은 시간에는 책에 수록된 기출 유형 문제와 실전 모의고사를 집중적으로 풀고,
틀린 부분은 오답 노트로 꼼꼼히 정리하며 빈틈을 메우는 방식으로 전략을 세웠습니다.

책의 구성은 비전공자나 DB 입문자도 쉽게 따라올 수 있도록 배려한 흔적이 보입니다.
복잡한 데이터베이스 개념을 줄글로만 설명하는 것이 아니라,
다양한 예시와 이미지로 시각화하여 비전공자도 쉽게 이해할 수 있도록 구성되어 있습니다.
덕분에 추상적인 개념을 직관적으로 파악하는 데 큰 도움이 됩니다.

또한, 이론만 읽고 넘어가면 내용을 금방 잊어버리기 마련인데,
이 책은 섹션별 이론을 확인하는 기출문제를 수록하여 학습한 내용을 즉시 복습할 수 있게 설계되었습니다.
이론 학습과 문제 풀이의 사이클이 짧아서, 개념을 제대로 이해했는지 점검하기가 수월합니다.

시험 준비의 핵심은 역시 양질의 문제를 풀어보는 것입니다. 이 책은 단순한 예상 문제가 아니라,
전문가가 직접 최신 출제경향을 분석해 복원한 기출 유형문제 5회분을 수록하고 있습니다.
실제 시험 난이도와 유사한 문제들을 풀어보며 최신 출제 패턴을 익히기에 적합합니다.

마지막 점검 단계에서는 시간을 재고 풀며 실제 시험처럼 실력을 점검할 수 있는 실전 모의고사 2회를 활용하면 됩니다.
실제 시험장이라 생각하고 시간을 배분해 보는 연습을 할 예정입니다.

만약 혼자 공부하는 게 느슨해질까 걱정된다면 제60회 SQLD 스터디에 참여하는 것도 좋은 방법입니다.
스터디 참여자에게는 특강 등 다양한 혜택을 제공한다고 하니, 강제성을 부여하고 확실한 동기부여를 얻기에 좋은 기회가 될 것 같습니다.

개발자에게 SQL 역량은 선택이 아닌 필수라고 생각합니다.
이번 기회에 자격증 취득은 물론, 실제 업무에서 쿼리 튜닝까지 고려할 수 있는 수준으로 DB 이해도를 높여보려 합니다.

특히 이 책은 CBT 온라인 문제집 서비스도 제공하고 있어,
출퇴근 시간 등 자투리 시간에 스마트폰으로 문제를 풀며 감을 잃지 않도록 도와줍니다.
저처럼 독학으로, 그리고 효율적으로 합격을 목표로 하는 분들에게 추천하고 싶습니다.

도서[https://vo.la/UCMCek]

2026 이기적 SQLD SQL 개발자 이론+기출문제 | 강태우 | 영진닷컴 - 예스24

본 도서는 SQL 개발자(SQLD) 시험 경향을 분석하여 수험생들이 혼자서도 학습할 수 있도록 한 완벽 대비서이다. 시행처인 데이터산업진흥원에서 공개한 최신 출제기준을 바탕으로 집필되었으며,

www.yes24.com

Kotlin - 문법 정리

Bin's. — Mon, 25 Feb 2019 21:11:08 +0900

코틀린(Kotlin) ?

구글 I/O 2017 에서 구글이 안드로이드 공식 언어로 코틀린을 채택.

코틀린 은 JetBrains 에서 만든 언어입니다.

IntelliJ , Android Studio 에서 코틀린을 완벽히 지원합니다.

장점

호환성 : JDK 6과 완벽호환 , 구형 안드로이드 기기에서도 완벽 실행, 안드로이드 빌드 시스템 완벽호환.

성능 : 자바만큼 빠르다, 람다로 실행되는 코드는 종종 자바보다 훨씬 바르게 동작.

상호 운용성 : 자바와 100% 상호 운용가능, 기존 모든 안드로이드 라이브러리 사용가능.

학습 곡선 : 자바를 하던 사람은 배우기 매우 쉽다, Android Studio 에서 자바 코드를 코틀린으로 자동 변환해주는 도구를 지원.

변수와 상수

var a: Int = 10 // var 변수명: 자료형 = 값
val b: Int = 20 // val 변수명: 자료형 = 값

코틀린에서 변수는 var, 상수는 val 로 선언합니다.

코틀린은 자료형을 지정하지 않아도 추론하는 형추론을 지원합니다

var c = 10.10 // var c: Double
var d = "Hello World!" // var d: String

출력

println("Hello World!")

자료형

정수	실수	문자	논리
Long : 64비트 정수	Double : 64비트 부동소수점	String : 문자열	Boolean
Int : 32비트 정수
Short : 16비트 정수	Float : 32비트 부동소수점	Char : 하나의 문자
Byte : 8비트 정수

자바와 달리 Char 형은 숫자형이아닙니다.

그리고 문자열의 리터럴은 큰따옴표 "", 한 문자는 ''로 자바와 동일합니다.

타입 캐스팅

var number = 1
var a = number.toLong() // .to자료형() 형태로 타입 캐스팅이 가능하다
var b = number.toShort()
var c = number.toByte()
var d = number.toDouble()
var e = number.toFloat()
var textNumber = "1"
var f = textNumber.toInt()

여러 줄의 문자열 표현

val str = """안녕하세요
코틀린 문법정리입니다.
trimIndent() = 들여쓰기 제거
""".trimIndent()

여러 줄에 걸쳐 문자열을 표현할 때는 큰따옴표 3개를 리터럴로 사용합니다.

문자열 비교

val str = "Hello"
if (str == "Hello"){
    println("안녕하세요")
}else{
    println("누구세요?")
}

문자열 비교는 == 를 사용합니다. 자바의 equals() 메서드와 대응합니다.

자바에서 == 오브젝트 비교시 사용합니다 , 코틀린은 === 를 사용.

문자열 템플릿

val str = "코틀린 "
println(str + "문법정리") // 자바에서 사용하던 방식
println("$str 문법정리") // 출력시 코틀린  문법정리
println("${str}문법정리}") // 출력시 코틀린 문법정리

복잡한 문자열 표현할 때 아주 편리합니다.

배열

val num : Array<Int> = arrayOf(1, 2, 3, 4, 5)
val num2 = arrayOf(1, 2, 3, 4, 5) // 자료형이 생략가능합니다
num[0] = 5
num2[0] = 0

코틀린에서 배열은 Array 라는 타입으로 별도로 지정해줍니다

타입은 <> 제네릭을 사용해서 지정해줍니다

배열의 인덱스에 접근하는 것은 대괄호 [] 안에 인덱스 값을 지정하는 것과 자바와 동일.

제어문

if

val a = 10
val b = 20

var max = a
if(a < b) max = b

실행할 문장이 한 줄이면 코드블럭을 생략할수 있습니다.

위에 코드를 좀 더 코틀린 식으로 바꾸면

if(a > b){ // ; 세미콜론을 제외한 자바와 완전히 동일한 코드
    max = a
}else{
    max = b
}

if (a > b) max = a else max = b

max = if (a > b) a else b // 코틀린 방식

변수에 if문을 넣을수도 있습니다.

when

val x = 1

when(x){
    1 -> println("x == 1")
    2, 3 -> ("x == 2 or x == 3") // 값 하나
    in 4..7 -> ("x == 4..7") // 여러 값은 .. 로 사용
    !in 8..10 -> ("!8..7") // in 연산자로 범위지정
    else -> {// 나머지
        print("x 는 1이나 2가 아님")
    }
}

자바에서 switch문과 매우 비슷해보일겁니다

맞습니다 코틀린에서는 switch문이 when 문 입니다.

val number = 1

val numStr = when (number % 2){
    0 -> "짝"
    1 -> "홀"
}

이런식으로 if 문과 같이 상수에 사용이 가능했습니다.

val number = 1

fun kotlinTest(num: Int) = when (num % 2) {
    0 -> "짝"
    else -> "홀"
}

println(kotlinTest(number))

이런식으로 함수의 반환값으로 사용할 수도 있습니다.

for

val numbers = arrayOf(1, 2, 3, 4, 5)

for (num in numbers){
    println(num)
}

코틀린의 for 문은 자바의 foreach 문과 흡사합니다.

이 코드를 해석하자면 1부터 5까지 담겨 있는 배열을

순회하면서 모든 인덱스 값을 출력하는 for 문의 예 입니다.

in 키워드를 이용하여 모든 요소를 num 변수로 가져옵니다

// 1 ~ 3 까지 출력
for (i in 1..3) {
    println(i)
}
// 0 ~ 10 까지 2씩 증가하며 출력
for (i in 0..10 step 2) {
    println(i)
}
// 10부터 0 까지 2씩 감소하며 출력
for (i in 10 downTo 0 step 2) {
    println(i)
}

step 키워드랑 downTo 를 이용한 for 문 예제입니다.

while

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

//do while
var count2 = 10
do {
    count2--
    println(count2) // 9; 8; 7; 6; 5; 4; 3; 2; 1; 0;
}while (count2 > 0)

자바와 완전히 동일합니다.

클래스(class)

클래스 선언

class Person{
    // 클래스 선언
}

val person = Person() // new 키워드 사용안함

클래스를 선언했고, 생성한 클래스를 인스턴스를 할때 new 키워드는 코틀린에서 사용하지 않습니다.

생성자

class Person {
    constructor(name: String){
        println(name)
    }
}

코틀린에서는 constructor 키워드로 생성자를 표현합니다.

이 키워드는 생략할수도있습니다.

class Person(name: String) {
    init {
        println(name)
    }
}

보조 생성자가 없을시 초기화 코드가 필요하다면 init 키워드 안에

작성한 코드는 클래스를 인스턴스화할 때 가장 먼저 초기화됩니다.

프로퍼티

class Person(var name: String)

val person = Person("코틀린")
person.name = "문법정리"
println(person.name)

자바에서는 클래스에서 속성을 사용하여 멤버에 직접 접근하기위해

게터(getter) / 세터(setter) 메서드 를 작성해줬는데요

코틀린에서는 보통 프로퍼티를 사용합니다.

접근 제한자

public ( 생략 가능 ) : 전체 공개, default 값 = 아무것도 안 쓰면 기본적으로 public.

private : 현재 파일 내부에서만 사용가능

internal : 같은 모듈 내에서만 사용가능

protected : 상속받은 클래스에서 사용가능

class A {
    val a = 1
    private val b = 2
    protected val c = 3
    internal val d = 4
}

자바와 달리 internal 이라는 접근 제한자가 존재합니다

프로젝트가 안드로이드 app 모듈뿐만아니라

스마트폰용, 시계용, TV용, Android Things 용

안드로이드 앱을 만든다면 모듈 4개를 생성합니다.

internal 은 이 모듈 간 접근을 제한하는 키워드 입니다.

상속

open class Animal(val name: String) {

}

class Dog(name: String) : Animal(name) {

}

코틀린에서 클래스 상속은 기본적으로 금지됩니다.

자바에서는 extends 사용한다면 코틀린에서 : 키워드로 대채합니다

여기서 상속을 하기위해서 open 이라는 키워드를 사용합니다.

또한 생성자가 존재한다면 위에 코드처럼 작성가능합니다.

내부 클래스

class OuterClass {
    var a = 10

    inner class OuterClass2 {
        fun kotlintest(){
            a = 20
        }
    }
}

클래스 안에 내부 클래스를 선언할시 inner 키워드를 사용합니다.

내부 클래스는 외부 클래스에 대한 참조를 가지고 있습니다.

추상 클래스

abstract class A { // 추상 클래스
    abstract fun func() // 추상 메서드
    fun func2(){

    }
}

class B : A(){ // 추상 클래스를 상속 받았을시 미구현 메서드를 구현해야함
    override fun func() { // 구현함
        println("코틀린 문법정리")

    }
}

val a = A() // 에러
val b = B() // OK

자바와 동일한 특성을 가지고 있고

abstract 키워드를 붙히고 class 를 적어줘야 오류가 나지않는다.

인터페이스

인터페이스는 미구현 메서드를 포함하고 구현된 메소드등 클래스에서 다중구현을 할때 사용합니다.

인터페이스 선언

interface Runnable{
    fun run()
    fun fastRun() = println("빨리 달린다")
}

인터페이스는 추상 클래스와 달리 다중 구현이 가능합니다.

인터페이스는 구현이 없는 메서드뿐만 아니라 구현된 메서드를 포함할 수 있습니다.

자바 8 의 default 메서드.

인터페이스 구현

class Human : Runnable{
    override fun run() {
        println("달린다")
    }
}

클래스를 상속받는거와 같이 : 키워드를 사용해 인터페이스를 구현해줍니다

상속과 인터페이스

open class Animal

interface Run {
    fun run()
    fun fastRun() = println("빨리 달린다")
}

interface Eat {
    fun eat()
}

class Dog : Animal(), Run, Eat {
    override fun run() {
        println("달린다")
    }

    override fun eat() {
        println("먹는다")
    }
}

val dog = Dog()
dog.run() // 달린다
dog.eat() // 먹는다

상속은 단하는의 클래스만 상속하고 인터페이스는 , 콤마 로 구분합니다.

데이터 클래스( Data Transfer Object )

// data class 클래스명(val 변수명 : 쟈료형..)
data class DTO(val dto: String)

코틀린은 getter / setter 를 구현할필요없이 DTO 를 간단히 구현가능하다.

null 가능성

코틀린에서는 null 가능성을 매우 중요시여깁니다.

기본적으로 객체를 불변으로 보고 null값을 허용하지 않습니다.

null 허용( ? )

val a: String // 에러 초기화를 해줘야합
val b: String = null // 에러 : 코틀린은 기본적으로 Null 을 허용하지 않음.
val c: String? = null //OK

코틀린에서 null 값을 허용하기위해 자료형 오른쪽에 ? 기호를 붙여주면

null 값을 허용하게 됩니다.

lateinit

lateinit var a: String
a = "Hello Kotlin"
println(a) // 출력값 : Hello Kotlin

코틀린에서 변수는 초기화를 해줘야합니다.

하지만 lateinit 키워드를 사용해 늦은 초기화를 할 수 있습니다.

lateinit 사용조건

var 변수에만 사용한다.

null 값으로 초기화할 수 없다.

초기화 전에는 변수를 사용할 수 없다.

Int, Long, Double, Float 에서 사용불가

lazy

val str: String by lazy {
    println("안녕")
    "Kotlin"
}

println(str) // 안녕; Kotlin
println(str) // Kotlin

var 에서 lateinit 을 사용해줬다면

val에서만 사용가능한 lazy 사용방법은

val 선언 뒤에 by lazy 와 블록을 작성해주면됩니다

마지막 줄에는 초기화할 값을 작성합니다.

null값이 아닐때( !! )

val name: String? = "코틀린"

val name2: String = name // 에러
val name3: String? = name // OK

val name4: String =name!!

변수 뒤에 !!를 추가하면 null 값이 아님을 보증하게되어

name 변수는 String? 타입입니다.

null 을 허용하죠 String 타입으로 변환하기위해서 !! 키워드를 붙여줘서

null 이 아니라는걸 보증해줍니다.

안전한 호출( ?. )

val str: String? = null

var upperCase = if (str != null) str else null //null
upperCase = str?.toUpperCase() // null

안전한 호출은 ?. 연산자를 사용합니다

?. 연산자를 사용하면 null 이 아닐경우에만 호출이 됩니다. 위 코드는 str 이 null 이고

upperCase 라는 변수에 str 이 null 아니면 str 을 대입 아니면 null 을반환합니다

마지막줄은 upperCase 라는 변수에 null 아니면 대문자로 변경하고 null값이면 null을 반환하는 코드입니다.

엘비스 연산자( ?: )

val str: String? = null

var upperCase = if (str != null) str else null
upperCase = str?.toUpperCase() ?: "null 값입니다 초기화 하시오"

안전한 호출 시 null이 아닌 기본값을 반환하고 싶을 때 엘비스 연산자를 함께 사용합니다.

str이 null이 아니면 대문자로 변경하고 null 값이면

뒤에 문자열을 출력합니다.

컬렉션

컬렉션은 개발에 유용한 자료구조를 뜻합니다.

리스트 ( List )

val timetable: List<String> = listOf("국어", "수학", "영어")

배열과 비슷하게 자료형의 데이터들을 순서대로 가지고 있는 자료구조입니다.

요소를 변경할 수 없는 읽기 전용 리스트는 listOf() 메서드로 작성.

val timetable = listOf("국어", "수학", "영어")

물론 코틀린은 형추론으로 자료형 생략이 가능합니다.

val timetable = mutableListOf("국어", "수학", "영어")

timetable.add("프로그래밍") // 프로그래밍을 맨 뒤에 추가

timetable.removeAt(0) // index 값이 0 인 국어를 삭제

timetable[0] = "코틀린" // index 값이 0 인 국어를 코틀린으로 변경

println(timetable) // [코틀린, 영어, 프로그래밍]
println(timetable[0]) // 코틀린

요소를 변경하는 리스트를 작성할 때는 mutableListOf() 메서드를 사용합니다.

여기서 자바의 리스트와 다른점은 index 값으로 접근할 수 있다는 겁니다.

맵 ( Map )

// 읽기 전용 맵
val map = mapOf("a" to 1, "b" to 2, "c" to 3)

// 변경 가능한 맵
val citiesMap = mutableMapOf("한국" to "서울", "일본" to "동경", "중국" to "북경")

citiesMap["한국"] = "서울특별시" // 요소에 덮어쓰기
citiesMap["미국"] = "워싱턴" // 요소 추가

맵 ( Map ) 은 키( key ) 와 값( value )의 쌍으로 이루어진 키가

중복될 수 없는 구조인 자료구조입니다.

리스트와 같이 읽기 전용과 요소를 변경할수 있는 Map 으로 만들수있습니다

mapOf() : 읽기 전용 맵

mutableMapOf() : 변경 가능한 맵

for ((k, v) in map){ // map 의 키 와 값을 탐색
    println("$k -> $v") //출력값 : a -> 1; b -> 2; c -> 3;
}

for 문을 이용하여 간단히 map 의 키 와 값을 탐색 할 수 있습니다.

집합

// 읽기 전용 집합
val languageSet = setOf("코틀린", "자바", "노드")
// 수정 가능 집합
val languageSet2 = mutableSetOf("코틀린", "자바", "노드")
languageSet2.add("파이썬")
languageSet2.remove("노드")

println(languageSet2.size) // 집합의 크기
println(languageSet2.contains("코틀린"))// 집합에 요소값이 존재하는지 : true

집합은 중복되지 않는 요소들로 구성된 자료구조입니다.

setOf() : 읽기 전용 집합

mutableSetOf() : 수정 가능 집합

람다식

코틀린은 자바 8 에서 지원하는 람다식을 지원합니다.

람다식은 함수를 표현하는 방법으로 익명 클래스, 함수를 간결하게 표현할수있습니다.

fun addOne(x: Int, y: Int): Int {
    return x + y
}

add() 메서드는 2개의 인수를 받아 더해주는 메서드입니다.

fun addTwo(x: Int, y: Int) = x + y

반환 자료형을 생략하고 블록 {} 을 생략하고 return 도 생략했습니다.

이렇게 람다식을 사용하게되면 코드가 간결해주는 장점이 있지만

디버깅이 어렵고 많이 쓰면 코드의 가독성이 떨어지게 된다는 단점이 있습니다.

var add = { x: Int, y: Int -> x + y }
println(add(3, 5)) // 출력 값: 8

또한 변수에 일반 함수처럼 사용할 수 있씁니다.

SAM 변환

자바로 작성된 메서드가 하나인 인터페이스를 구현할 때는 함수를 작성할수있습니다

바로 SAM ( Single Abstract Method) 변환이라고합니다

button.setOnLongClickListener(object : View.OnClickListener{
    override fun onClick(p0: View?) {
       // 클릭 이벤트 
    }
})

안드로이드에서 버튼에 클릭 이벤트 리스너를 구현하는 코드입니다.

여기서 SAM 변환을하면

button.setOnClickListener {
    // 클릭 이벤트
}

이런식으로 인수가 람다식인 경우는 람다식을 괄호 밖으로 뺄 수있고유일한 인수일 경운에는 괄호를 생략하고

자료형과 인수가 하나인 경우에는 이를 아예 생략하고 블록내에서 접근이 가능하게됩니다.

확장 함수

확장 함수 : 기존에 있던 클래스에 기능을 추가하는 함수.

fun Int.isEven() = this % 2 == 0

val a = 10
val b = 11

println(a.isEven()) // true
println(b.isEven()) // flase

Int class 에 . 을 찍고 함수 이름을 작성해줍니다

이 객체를 this 로 접근할 수 있습니다 또한 리시버 객체라고 부릅니다.

형 변환 ( as )

open class Animal

class Dog : Animal()

val dog = Dog()

val animal = dog as Animal

클래스 간에 형 변환을 하려면 as 키워드를 사용합니다

형 체크 ( is )

val str = "Hello"

if (str is String){ // str 이 String 형이라면
    println(str.toUpperCase())
}

is 키워드를 사용하여 형 체크를 합니다.

자바에서 instanceOf

고차 함수

고차 함수 : 함수의 인수로 함수를 전달하거나 함수를 반환할 수 있는 함수.

// 인수 : 숫자, 숫자, 하나의 숫자를 인수로 하는 반환값이 없는 함수
fun add(x: Int, y: Int, callback: (sum: Int) -> Unit) {
    callback(x + y)
}

add(5,3) { println(it)} // 8

add 함수는 x, y, callback 3개의 인수를 받고

callback 에 x + y 값을 전달합니다.

그리고 add() 함수에 5와 3을 인자로 넣어주면

callback 은 더한값을 반환해줍니다.

동반 객체 ( companion object )

class Fragment {
    companion object {
        fun newInstance() {
            println("생성됨")
        }
    }
}

val fragment = Fragment.newInstance()

프래그먼트는 팩토리 메서드를 정의하여 인스턴스를 생성해야 합니다.

팩토리 메서드 : 생성자가 아닌 메서드를 사용해 객체를 생성하는 코딩 패턴

코틀린은 자바의 static과 같은 정적인 메서드를 만들 수 있는 키워드를 제공않함,

대신 동반 객채( companion object ) 으로 구현합니다.

let() 함수

//fun <T, R> T.let(block (T) -> R): R
var str: String? = null
val result = str?.let{
    Integer.parseInt(it)
}

let() 함수는 블록에 자기 자신을 인수로 전달하고 수행된 결과를 반환합니다.

with() 함수

//fun <T, R> with(receiver: T, block T.() -> R): R
var str: String? = null

with(str){
    println(this?.toUpperCase())
}

with() 함수는 인수로 객체를 받고 블록에 리시버 객체로 전달합니댜.

apply() 함수

// fun <T> T.apply(block: T.() -> Unit): T
val result = car?.apply{
    car.setColor(Color.RED)
}

apply() 함수는 블록에 객체 자신이 리시버 객체로 전달되고 이 객체가 반환됩니다.

객체의 상태를 변회시키고 그 객체를 다시 반활할 때 주로사용합니다.

run() 함수

// fun <R> run(block: () -> R): R
val avg = run {
    val korean = 100
    val english = 80
    val math = 60
    (korean + english + math) / 3.0
}

run() 함수는 익명 함수처럼 사용하는 방법과,

객체에서 호출하는 방법을 모두 제공합니다.

익명 함수처럼 사용할 대는 블록의 결과를 반환합니다.

임시변수가 많을대 유용

// fun <T, R> T.run(block: T.() -> R): R
str?.run{
    println(toUpperCase())
}

객체를 블록의 리시버 객체로 전달하고 블록의 결과를 반환합니다

안전한 호출을 사용할 수 있어서 with() 합수보다는 더 유용

Retrofit - 학교급식 통신 (Retrofit2 + OkHttp3)

Bin's. — Sun, 27 Jan 2019 03:44:20 +0900

Retrofit - 학교 급식 통신

완성된 예제

먼저 Retrofit2 이란?

HTTP REST API 통신( Http 통신 라이브러리 )을 사용할때 쓰는 라이브러리 입니다.

한국문서

가장먼저 이 라이브러리를 사용하기전에

build.gradle (app) 에 추가해줘야합니다.

dependencies {
implementation 'com.squareup.retrofit2:retrofit:2.5.0'
implementation 'com.squareup.retrofit2:converter-gson:2.5.0'
implementation 'com.squareup.okhttp3:okhttp:3.12.0'

implementation 'com.squareup.okhttp3:logging-interceptor:3.4.2'

}

그리고 네트워크 (인터넷) 을 사용하기위해 manifests 에

  <uses-permission android:name="android.permission.INTERNET"/>

이 권환을 추가해주어야합니다.

자 준비가 끝났으면 이제 사용방법에대해 알아보도록 하겠습니다.

일단 Json 형태의 REST API 를 사용해야하는데요

저는 간단한 저희학교 급식 api 를 기준으로 설명해드리도록 하겠습니다.

이 날 저희학교 급식 API 입니다

1. 먼저 이 data 를 저장할 data 객체를 만들어 주겠습니다

beans.kt

data class lunch(val date:String,val menu:String,val day:String)

이렇게 코틀린을 쓰면 data 객체를 간단히 구현가능합니다

getter, setter 를 내부적으로 구현을해줍니다.

(String 형태로 내용을 받아오기때문에 데이터 타입은 String 형태로 받아줌)

먼저 날짜를 저장할 date 라는 변수,

그리고 우리가 원하는 메뉴를 저장할 menu 라는 변수,

그리고 오늘이 무슨요일인줄 알려주는 day 라는 변수를 만들어 주었습니다.

2. 이제 API 서비스를 만들어줄거입니다 (인터페이스 만들기).

Service.kt

interface UserService {
      @GET("받아올 API 의 URL")
      fun ApiService(): Call<lunch>
}

인터페이스를 선언해주고 @GET annotation 을추가하고

ApiService() 라는 함수에 받아올데이터 타입을

lunch (위에 만든 data 객체 이름) 데이터 타입으로 해줍니다.

3. Retrofit 초기화 해주기

MainActivity.kt

(일부분)

val retrofit = Retrofit.Builder()
        .baseUrl("적어줄 baseUrl ")
        .addConverterFactory(GsonConverterFactory.create())
        .client(createOkHttpClient())
        .build()

val service = retrofit.create(UserService::class.java)

이런식으로 Retrofit 을 초기화를 해주는데

간단히 baseUrl 을 적어서 초기화 해줍니다.

이렇게 초기화 해준뒤 Retrofit 을 생성해주는데요

그럼 이제 UserService 를 retrofit을 통해 생성을 해줍니다

그이후 service 를 통해 retrofit 을 사용하면됩니다.

그리고 대부분 서버는 json 으로 응답을 해주는데요

Retrofit 에서는 이러한 응답을 간단하게 변활할 수 있도록 Converter 를 지원해줍니다.

추가해줄수있는 방법은 바로

.addConverterFactory(GsonConverterFactory.create())

인데요

여기서 GsonConverterFactory.create() 를 추가해주는 이유는

통신이 완료된후 어떤 Converter 를 사용하여 데이터를 파싱할 것인지에 대한 설정을 해줘야해서 추가를 했습니다.

그리고 service 로 Retrofit 을 사용가능합니다.

Service.kt

interface UserService {
      @GET("받아올 API 의 URL")
      fun ApiService(): Call<launch>
}

그럼 이러한 인터페이스를 사용할수있습니다.

이제 Retrofit 과 인터페이스랑 연결을 해줬습니다

4. Retrofit 에서 응답받은 데이터 처리

MainActivity.kt

private fun setRetrofit(){

    val retrofit = Retrofit.Builder()
            .baseUrl("http://api.hansei.us/")
            .addConverterFactory(GsonConverterFactory.create())
            .client(createOkHttpClient())
            .build()

    val service = retrofit.create(UserService::class.java)

    val call:Call<launch> = service.ApiService()
    call.enqueue(object : Callback<launch>{
        override fun onFailure(call: Call<launch>, t: Throwable) {
            Toast.makeText(applicationContext,"실패",Toast.LENGTH_SHORT).show()
        }

        override fun onResponse(call: Call<launch>, response: Response<launch>) {
            if(response.body()!=null){
                Toast.makeText(applicationContext,"성공",Toast.LENGTH_SHORT).show()
                text1.text = response.body()!!.date + " 입니다"
                text2.text = response.body()!!.menu
                text3.text = response.body()!!.day + "요일 입니다."

            }
        }

    })

}

MainActivity.kt 의 일부분입니다

준비가 끝났으니 실제 HTTP 통신을 하고 결과를 받아보는코드입니다.

실질적으로 사용할 call 이라는 객체를 만들어줍니다.

enqueue() 메소드를 이용하여 요청을 처리해줍니다 그리고

해당 메소드에 Callback interface 를 구현해주면

Callback interface 는 onResponse 와 onFailure 를 구현을 해줘야합니다.

onResponse()

요청이 성공됬을경우의 처리

- 에외처리 가 포함된 코드

- 받아온 결과에 body() 부분이

null 이 아닐경우

성공이라는 Toast 메시지와

각각의 텍스트 뷰에 텍스트를

받아온값의 date ,

menu , day 를 설정해줍니다.

onFailure()

요청이 실패됬을경우의 처리

- 정말 실패했을경우

- Toast 메세지를 화면에

실패 출력.

자 이런식으로 처리가 되면 성공할경우 서버에서 가져온 급식정보를 원하는 Activity 에

TextView 에 설정이 됩니다.

간단히 통신을 성공했으면 이제

OkHTTP을 사용하여 Retrofit 의 로그를 확인해보자.

implementation 'com.squareup.okhttp3:okhttp:3.12.0'

implementation 'com.squareup.okhttp3:logging-interceptor:3.4.2'

사용을 위해 위에 2개의 dependencies 를 추가 해줬습니다.

그리고 간단히 예제 코드를 작성합니다.

private fun createOkHttpClient(): OkHttpClient {
    val builder = OkHttpClient.Builder()
    val interceptor = HttpLoggingInterceptor()
    interceptor.level = HttpLoggingInterceptor.Level.BODY
    builder.addInterceptor(interceptor)
    return builder.build()
}

그리고 아까 위부분에 정의한

val retrofit = Retrofit.Builder()
            .baseUrl("http://api.hansei.us/")
            .addConverterFactory(GsonConverterFactory.create())
            .client(createOkHttpClient())
            .build()

.client() 에

메소드를 추가해주면됩니다.

그리고 빌드를 해주신다면

이와 같이 통신이 됬는지 확인을 할수있습니다.

끝으로 Retrofit2 + OkHttp3 를 이용한 학교급식 통신을 해본 예제입니다.

굳

Android (일곱번째 수업 - Fragment와 TapLayout)

Bin's. — Thu, 4 Oct 2018 04:48:57 +0900

Fragment와 TapLayout

먼저 Fragment 란?

Android 3.0 (API 레벨 11) 에서 Fragment 가 소개 되었습니다.

Fragment는 보통 하나의 Activity안에 여러 UI를 구성할 때 이용할 수 있습니다.

TapLayou에 적용한 Fragment

이것처럼 Fragment를 사용해서 UI 를 쉽게 넘길수 있습니다.

즉 프래그먼트란

재사용 가능한 유저 인터페이스를 생성하기 위한 새로운 컴포넌트라고 볼 수 있습니다.

단 Fragment는 자신만의 레이아웃을 이용하여 화면에 UI 를 보여줄 수 있습니다

하지만 혼자 독자적으로 동작할 수 없으며,

Fragment 라이프 사이클은 자신이 포함된 Activity 라이프 사이클의 영향을 받습니다.

TabLayout 을 알아보자

Tab 은 상위 탐색 수단 및 앱 내의 컨텐츠를 그룹화 할 수단으로 흔히 사용되고 있습니다.

디자인 라이브러리의 TabLayout 은 고정 탭을 지원합니다.

많을 경우시 스크롤 이 지원됨.

TabLayout 에 Tab을 눌러 화면 전환

이렇게 Fragment를 전환할수있습니다

하지만 이번예제에선 ViewPager 를 사용해서 슬라이딩 해도

Fragment가 전환이됩니다.

예제설명 - TabLayout 을 이용한 Fragment 전환

먼저 TabLayout 을 MainActivity.xml 에 추가 해줍시다.

중요! Design Support Library 를 추가해줘야합니다.

하지만 안드로이드 3.2 버전이 정식 릴리즈가 되어

dependencies {
    implementation 'com.google.android.material:material:1.0.0'
}

meterial 를 dependencies 에 추가해주면 됩니다.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.google.android.material.tabs.TabLayout
        android:id="@+id/tab"
        android:layout_width="match_parent"
        android:layout_height="40dp"
        android:background="@android:color/white"
        >
    </com.google.android.material.tabs.TabLayout>
    <androidx.viewpager.widget.ViewPager
        android:layout_below="@+id/tab"
        android:id="@+id/viewPager"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        >
    </androidx.viewpager.widget.ViewPager>
</RelativeLayout>

여기서 Fragment 전환을 좀더 쉽게 하기위해서

VIewPager (슬라이딩으로 Fragment 변환) 를 추가 해줬습니다.

그리고 여기서 중요한점은 Fragment 의 View 를 띄어줄

ViewPager 가 TabLayout 밑에 있어야만 탭을 눌렀을시 작동이 됩니다.

자이제 Fragment 를 만드는 법을 알아봅시다.

app -> New -> Fragment -> Fragment (Blank)

이 방식으로 Fragment 를 추가해 주시면 됩니다.

사용할 Tab 에 대한 Fragment 를 만들때 저는 fragment_tab1.xml 을 만들었는데

Fragment 를 만드는 이름에 따라 달라집니다.

먼저 Fragment 의 xml 코드를 보자면

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".Tab1">

    <!-- TODO: Update blank fragment layout -->
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerVertical="true"
        android:layout_centerHorizontal="true"
        android:text="@string/Fragment1"
        android:textAppearance="@style/TextAppearance.AppCompat.Large"
        />
</RelativeLayout>

Fragment 의 xml 에는 Activity의 xml 과 같습니다.

Fragment 를 확인해주기 위해 TextView 를 사용해줬습니다

text 는 @string/Fragment1 를 참조했는데 내용을 보겠습니다.

string.xml

<string name="Fragment1">Fragment1</string>
<string name="Fragment2">Fragment2</string>
<string name="Fragment3">Fragment3</string>

이런식으로 각 Fragment 에 띄어줄 내용을 참조했습니다.

이제 Fragment 의 class 파일을 보면

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;


public class Tab1 extends Fragment {
    View view;
    public Tab1() {
        // Required empty public constructor
    }


    public static Tab1 newInstance() {
        Tab1 tab1 = new Tab1();
        return tab1;
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        view = inflater.inflate(R.layout.fragment_tab1, container, false);
        return view;
    }

}

Fragment 를 상속을 받습니다.

위에 형식대로 Fragment 를 만들게되면 다양한 메서드가

존재할거입니다 하지만 사용할 메서드만

남겨두고 지워주도록 합시다.

newInstance() 는

Class의 객체를 기초로 그 Class가 표시하고 있는

클래스의 객체를 만들 수 있습니다 = (인수 없는 생성자가 호출된다).

즉 위에 있는 Tab1() 생성자가 호출이됩니다.

그뒤에 Tab1 타입인 tab1 을 만들어줘 return 으로 반환을 해줍니다.

그리고 onCreateView 에는 Activity의 onCreate 와 비슷한데

Fragment 의 UI 가 화면에 그려지는 시점에 호출됩니다.

XML Layout을 inflate하여 Fragment를 위한 View를 생성하고

fragment_tab1 에 View를 Activity에게 리턴해야 합니다.

그리고 view 를 return 해줬다면 Fragment 를 성공적으로 만들었습니다.

이 예제에서는 총 3개의 Tab이 사용될것이 때문에 같은 방식으로 Fragment 를 3개 만들어줍시다.

이제 Fragment 를 위한 Adapter 를 만들어줍시다

import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentPagerAdapter;

public class FragmentAdapter extends FragmentPagerAdapter {

    public FragmentAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        switch (position){
            case 0:
                return Tab1.newInstance();
            case 1:
                return Tab2.newInstance();
            case 2:
                return Tab3.newInstance();
                default:
                    return null;
        }
    }
    @Override
    public int getCount() {
        return 3;
    }
}

이 코드를 간단히 설명하자면

Fragment 의 interface 를 전환 해주기 위해

2개의 메서드를 Override 해주는데요

먼저 getItem() 메서드를 보자면 매개변수론 position 을 받는데요

그밑에 switch 문을 사용해 return 해줄 Tab의 newInstance() 메서드를 호출해

해당 Tab 을 return 해줍니다

물론 index 값은 0 부터 시작하니 0, 1, 2 로 해주시면됩니다.

그리고 Tab이 더이상 없으면 default 로 null 를 return 해줍니다.

이제 getCount() 메서드는 간단합니다.

return 해줄 Tab의 갯수를 return 해주면 됩니다 .

즉 Item의 갯수를 return 해주면 됩니다 .

이제 TabLayout 을 사용하기 위해서

activity_main.xml 의 Class를 작성해줍시다.

MainActivity.java

import androidx.appcompat.app.AppCompatActivity;
import androidx.viewpager.widget.ViewPager;

import android.annotation.TargetApi;
import android.os.Build;
import android.os.Bundle;
import com.google.android.material.tabs.TabLayout;

import java.util.ArrayList;

public class MainActivity extends AppCompatActivity {

    private TabLayout tabLayout;
    private ArrayList <String> tabNames = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadTabName();
        setTabLayout();
        setViewPager();

    }

    @TargetApi(Build.VERSION_CODES.N)
    private void setTabLayout(){
        tabLayout = findViewById(R.id.tab);
        tabNames.stream().forEach(name ->tabLayout.addTab(tabLayout.newTab().setText(name)));
    }

    private void loadTabName(){
        tabNames.add("탭1");
        tabNames.add("탭2");
        tabNames.add("탭3");
    }

    private void setViewPager() {
        FragmentAdapter adapter = new FragmentAdapter(getSupportFragmentManager());
        ViewPager viewPager = findViewById(R.id.viewPager);
        viewPager.setAdapter(adapter);
        viewPager.addOnPageChangeListener(new TabLayout.TabLayoutOnPageChangeListener(tabLayout));
        tabLayout.setOnTabSelectedListener(new TabLayout.OnTabSelectedListener() {
            @Override
            public void onTabSelected(TabLayout.Tab tab) {
                viewPager.setCurrentItem(tab.getPosition());
            }
            @Override
            public void onTabUnselected(TabLayout.Tab tab) {

            }

            @Override
            public void onTabReselected(TabLayout.Tab tab) {

            }
        });
    }
}

마지막으로 이 코드를 보면

사용할 TabLayout 의 대한 객체랑 Tab 의 이름을 저장할 객체인 tabNames 를

ArrayList 객체로 만들어줬습니다.

이제 onCreate() 메서드의 내용을 보면

loadTabName() 메서드를 호출하는데

이 메서드 내용은 아까 만들어둔 tabNames 에 add() 메서드를 이용해

string 형태로 저장을 합니다.

저는 add 메서드를 이용해 Tab 의 이름을 차례대로 저장해줬습니다.

이제 다음 메서드인 setTabLayout() 메서드는

위에 이러한코드가있는데요

@TargetApi(Build.VERSION_CODES.N)

이코드는 Android 플랫폼 별 버전으로 빌드를 한다는 코드인데요

Build.VERSION_CODES.N 은

Api 레벨 24 인 안드로이드 7.0 Nougat 버젼으로 빌드한다는 코드입니다

이제 메서드 내용을 보면 tabLayout 의 객체에 tab 이란 id를 대입해주는데요.

tab 이란 id 를 가지고 있는 위젯은 위에 activity_man.xml 코드에

TabLayout 의 id 를 대입해줍니다.

그리고

tabNames.stream().forEach(name ->tabLayout.addTab(tabLayout.newTab().setText(name)));

이 코드는 tabName 을 tabLayout 에 setText() 이용해 Tab 의 이름을 설정해줍니다.

마지막으로 setViewPager() 메서드를 보자면

먼저 Adapter 객체를 만들어 줍니다.

그리고 ViewPager 의 객체를 만들어 ViewPager 의 id 를 대입해줍니다.

그리고 viewPager의 setAdapter() 메서드를 이용해 만들어준 Adapter 객체인 adapter 를 셋팅해줍니다.

그리고

addOnPageChangeListener()를 이용해

스크롤시 ViewPager 가 작동하도록 해주고

@Override
public void onTabSelected(TabLayout.Tab tab) {
            viewPager.setCurrentItem(tab.getPosition());
}

메서드를 이용해 탭을 눌렀을때 해당 Fragment 로 넘어가기위해

setCurrentItem() 메서드를 이용해 tab의 Position 을이용해

해당하는 Tab 을 누르면 viewPager 가 해당 Fragment 로 넘어가게 된다.!

이상으로 최종 완성된 예제의 모습이다

최종

굳 :)

ViewHolder - pattern (뷰홀더 패턴)

Bin's. — Tue, 18 Sep 2018 09:55:05 +0900

ViewHolder 란 ?

각 View들을 보관하는 Holder 객체.

RecyclerView & ListView 에서 사용되는 디자인패턴입니다.

RecyclerView 에서 만약 여러가지 data가 적을땐 동작이 잘 될것입니다.

하지만 data가 만약 많은 처리를 요구할때 동작에 영향이 지체됩니다.

그걸 개선하기위해 나온 디자인 패턴이있습니다

그 디자인 패턴이 바로 ViewHolder - pattern 입니다.

보통 ViewHodler 패턴은 RecyclerVIew 와 같이 쓰입니다.

그럼 ViewHolder - pattern 에대해 알아봅시다

ViewHolder - pattern

RecyclerView 에서 스크롤 할동안 findViewById() 를 자주호출 하게되면 성능이 저하되겠죠?

처리할 data가 증가할경우 호출해야하는 수 도 증가해서

성능도 저하되게 됩니다 ViewHolder - pattern 은 그런점을 보완해서

ViewHolder 객체는 layout 태그 필드 안에 각 View 를 저장하기 때문에

반복적으로 조회하지 않고 즉시 엑세스가 가능합니다!

즉 반복적으로 findViewById() 를 호출해주지않아도 사용가능하다는겁니다.

이제 사용 방법을 알아봅시다 ~

먼저 ViewHolder - pattern 을 사용해 RecyclerView 를 구현하기위해선

RecyclerView 의 Adapter에

꼭 구현해야하는 3가지 메서드가 있습니다.

1. onCreateViewHolder = ViewHolder 객체를 생성

2. onBindViewHolder = ViewHolder 에 data 를 넣는 작업 수행

3. getItemCount = data의 갯수를 반환 해준다

이렇게 3가지의 메서드를 꼭 구현해줘야합니다.

더 자세한 내용을 확인하고 싶으면 아래 사이트를 참고해주세요.

https://developer.android.com/training/improving-layouts/smooth-scrolling#ViewHolder

Android (여섯번째 수업 - RecyclerView)

Bin's. — Mon, 17 Sep 2018 10:07:08 +0900

RecyclerView

오늘은 RecyclerView 에 대해서 알아보자

먼저 RecyclerView 란?

Android 5.0 에서 처음 소개되었습니다.

Support-Library-v7 에 포함 되었습니다

RecyclerView 는 ListView 의 장/단점을 보완한 고급 위젯입니다.

그렇다면 이 위젯은 어떻게 사용할까요?

이 위젯 을 사용하기 위해서 dependencies 에 추가 해줘야합니다.

그리고 또한 appcompat 버전과 recyclerview의 버전이 같아야합니다.

먼저 RecyclerView 에 대해 간략히 보자면

이렇게 ListView 와 비슷합니다.

제목과 내용을 적어 제목을 눌르면 내용을 Toast로 출력해주는 예제입니다

망고를 눌렀을때 mango라는 토스트를 띄어줍니다.

이제 이 RecyclerView 를 사용하기 위해 먼저 Library를 추가 해줍니다.

이런식으로 말이죠.

dependencies {
    implementation 'com.android.support:recyclerview-v7:27.1.1'
}

이제 사용법에 대해 알아봅시다.

xml code 에는

main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/RecyclerView"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    </android.support.v7.widget.RecyclerView>

    <android.support.design.widget.FloatingActionButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>

이런식으로 추가를 해줬습니다.

RecyclerView와 추가하기위한 FloatingActionButton을 적어줬습니다.

RecyclerView 를 추가해줬으니 RecyclerView 에 띄어줄 iteml 을 만들어 줘야하는데요

Layout 폴더에 Layout resource file 을 추가 해줍니다

item_default_data.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="100dp">

    <TextView
        android:id="@+id/titleText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textColor="#000000"
        android:textAppearance="@style/Base.TextAppearance.AppCompat.Large"
        android:text="제목"
        android:layout_margin="10dp"/>
    <View
        android:layout_width="match_parent"
        android:layout_height="3dp"
        android:background="@android:color/darker_gray">
    </View>

</LinearLayout>

item 은 RecyclerView에 담을 하나 하나의 아이템들입니다.

이미지나 버튼등 개발자의 필요에따라 추가/수정 하면 됩니다.

저는 여기서 간단히 TextView 를 사용해 title 을 보여주는게 목적이기때문에

TextView를 사용해줬고 View 태그를 사용해줘서 line 구분을 해주었다.

이제 data를 담아줄 Data클래스를 만들어 줍시다.

Data.class

package com.example.qlsl7.test0816;

import java.io.Serializable;

public class Data implements Serializable {
    private String title;
    private String content;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    Data(String title, String content) {
        this.title = title;
        this.content = content;
    }
}

저는 제목과 내용을 사용 할 것 이니

Title과 content 의 getter/setter 만들어 줬습니다.

이 class 는 RecyclerView 에 출력될 값들입니다.

아까 간략히 본 RecyclerView 예제는

제목과 내용을 적어 제목을 눌르면 내용을 Toast로 출력해주는 예제입니다.

그러니 이제 만들어줘야하는건 내용을 적을곳을 만들어줍시다.

Write.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".WriteActivity"
    android:orientation="vertical"
    android:weightSum="360">

    <EditText
        android:id="@+id/titleEditText"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="40"
        android:hint="제목"
        android:layout_margin="10dp"/>
    <EditText
        android:id="@+id/contentEditText"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="300"
        android:layout_margin="10dp"
        android:hint="내용"
        android:lines="10"/>

    <android.support.design.widget.FloatingActionButton
        android:id="@+id/saveFab"
        android:src="@drawable/ic_save_black_24dp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginRight="30dp"
        android:layout_gravity="right"/>


</LinearLayout>

xml code를 간단히 설명하자면

Title 과 Content 를 적어줄

EditText를 만들어주고 이제 저장버튼을 대신해줄

FloatingActionButton 을 만들어 줍시다.

그럼 이제 이 java code 를 보자면

wirteActivity.class

import android.content.Intent;
import android.support.design.widget.FloatingActionButton;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;

public class WriteActivity extends AppCompatActivity {

    private EditText titleEditText;
    private EditText contentEditText;
    private FloatingActionButton saveFab;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_write);

        init();
        setListeners();

    }

    private void init(){

        titleEditText = findViewById(R.id.titleEditText);
        contentEditText = findViewById(R.id.contentEditText);
        saveFab = findViewById(R.id.saveFab);

    }

    private void setListeners(){
        saveFab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String title = titleEditText.getText().toString();
                String content = contentEditText.getText().toString();
                if(!title.equals("") && !content.equals("")){
                    Data data = new Data(titleEditText.getText().toString(), contentEditText.getText().toString());
                    Toast.makeText(getApplicationContext(), "성공적으로 작성하셨습니다.", Toast.LENGTH_SHORT).show();
                    Intent intent = new Intent();
                    intent.putExtra("data", data);
                    setResult(RESULT_OK,intent);
                    finish();

                }
            }
        });
    }
}

이 코드를 해석해보면

사용될 위젯의 id를 각각의 변수에 담아줍니다.

그리고 svaeFab = FloatingActionButton 을 눌렀을때

onClick 이벤트가 실행되면서

title 과 content 에 EditText에서 적은내용을 문자열로 저장을해줍니다.

그리고 if문 은 title 과 content 의 값이 있을때 실행되는데요

먼저 Data class의 객체를 만들어줘 titleEditText 내용, contentEditText의 내용

을 가져와 data 에 저장해줍니다.

그뒤에 Toast로 "성공적으로 작성하셨습니다." 라는 Toast를 띄어줍니다.

그뒤에 Intent 객체를 만들어주고

.putExtra() 로 "data" 라는 키로 data를 넘겨줍니다.

setResult(RESULT_OK,intent);
finish();

이코드로 종료를 시켜줍니다.

그럼 이제 적은 data를 RecyclerView에 뿌려줄 Adepter 를 만들어줍시다.

RecyclerAdapter.class

package com.example.qlsl7.test0816;

import android.content.Context;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v7.widget.RecyclerView;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import android.widget.Toast;

import java.util.List;

public class RecyclerAdapter extends RecyclerView.Adapter<RecyclerAdapter.ViewHolder> {

    private List<Data> dataList;
    private Context context;
    private int layout;
    private Data data;


    public RecyclerAdapter(@NonNull Context context, int resource, @NonNull List<Data> objects) {
        this.dataList = objects;
        this.context = context;
        this.layout = resource;
    }


    @NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View view = inflater.inflate(layout, null);
        return new ViewHolder(view);
    }

    @Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        data = dataList.get(position);


        holder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(context, data.getContent(), Toast.LENGTH_SHORT).show();
            }
        });
        holder.tiTextView.setText(data.getTitle());
    }

    @Override
    public int getItemCount() {
        return dataList.size();
    }

    class ViewHolder extends RecyclerView.ViewHolder{
        TextView tiTextView;
        ViewHolder(View itemView){
            super(itemView);
            tiTextView = itemView.findViewById(R.id.titleText);
        }

    }
}

먼저 ListView 와 RecyclerView 의 차이점 이라면

ListView 에서는 getView 형식으로 data를 뿌려줬다면.

RecyclerView 에서는 ViewHolder 라는 디자인 패턴을 이용해

View 객체를 ViewHolder 에 홀드 시키는 것입니다.

이러한 원리를 이용해 data를 RecyclerView 에 뿌려주는데요.

이 코드를 보면 각각의 타입의 변수를 선언해주고

    public RecyclerAdapter(@NonNull Context context, int resource, @NonNull List<Data> objects) {
        this.dataList = objects;
        this.context = context;
        this.layout = resource;
    }

생성자로 값을 받아옵니다

@NonNull
    @Override
    public ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        View view = inflater.inflate(layout, null);
        return new ViewHolder(view);
    }

이 코드는 RecyclerView 에 띄어줄 View 을 inflater 해주는 코드입니다

쉽게 설명하면 RecyclerView 에 사용될 ViewHoder 를 생성하는 코드입니다.

그리고

@Override
    public void onBindViewHolder(@NonNull ViewHolder holder, int position) {
        data = dataList.get(position);


        holder.itemView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(context, data.getContent(), Toast.LENGTH_SHORT).show();
            }
        });
        holder.tiTextView.setText(data.getTitle());
    }

이 코드는 매개변수로 holder 와 position 을 받고

data 변수에 dataList.get(position) 의 값을 대입해줍니다.

그리고 hoder 안에 있는 itemView 가 눌렸을경우에

onClick 이벤트가 실행되어

Toast 메세지를 띄어주는데요 내용은 context의 내용을 짧게 띄어줍니다.

쉽게 설명하자면 ViewHolder에 데이터를 넣는 작업을 수행을 하는 code 입니다.

그리고

class ViewHolder extends RecyclerView.ViewHolder{
        TextView tiTextView;
        ViewHolder(View itemView){
            super(itemView);
            tiTextView = itemView.findViewById(R.id.titleText);
        }

    }

Inner class를 만들어줍니다 이 class에 RecyclerView.ViewHolder를 상속해줍니다

그리고 TextView 변수를 만들어주고

생성자를 만들어줍니다 이 생성자의 매개변수는 View 타입의 itemView 입니다.

그리고 super() 메서드를 이용해 매개변수에 접근합니다

그리고 tiTextView 에 findViewById() 를 이용해

titleText의 id 를 넣어줍니다.

그리고

holder.tiTextView.setText(data.getTitle());

이제 이코드를 해석할수있는데요 이코드를 해석하자면

tiTextView에 data.class에 저장된 Title의 값을 반환해서 세팅을해줍니다.

@Override
    public int getItemCount() {
        return dataList.size();
    }

이 코드 는 사용하지않지만 오버라이드 해줘야하기때문에

dataList.size() = data 갯수를 반환만 시켜줍니다.

여기서 중요한점은 RecyclerView를 사용할때 ViewHolder라는 디자인패턴을 사용했습니다.

이제 정확히 ViewHolder 패턴에 대해 알아봅시다.

ViewHolder pattern 이란?

각 View 들을 보관하는 홀더 객체라고 볼수있습니다.

왜 이런 디자인 패턴이 등장했을까

바로 ListView 에서 살펴볼수있습니다.

RecyclerView 는 ListView 의 장/단점을 보완한 고급위젯이라고 위에서 설명했습니다.

ListView 에서는 스크롤을 할시 findViewById()를 호출을 해줍니다.

Adapter가 inflate된 View를 반환할때도 findViewById()를 호출해주기떄문에

리스트에 표시해야할 데이터가 많을경우 성능이 저하하는 그러한 단점을 보완하기 위해 나온게

ViewHolder 패턴입니다.

ViewHolder 객체는 findViewById 를 반복 호출을 않해도 RecyclerView 를 스크롤 했을시

즉시 사용 가능합니다.

자 이제 mainActivity의 code를 봅시다

mainActivity.class

        import android.content.Intent;
        import android.support.v7.app.AppCompatActivity;
        import android.os.Bundle;
        import android.support.v7.widget.LinearLayoutManager;
        import android.support.v7.widget.RecyclerView;
        import android.util.Log;
        import android.view.Menu;
        import android.view.MenuItem;

        import java.util.ArrayList;
        import java.util.List;

public class MainActivity extends AppCompatActivity {

    private List<Data> dataList;
    private RecyclerView recyclerView;
    private RecyclerAdapter recyclerAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
        setRecyclerView();
    }

    private void setRecyclerView(){
        LinearLayoutManager layoutManager = new LinearLayoutManager(getApplicationContext());
        recyclerView.setLayoutManager(layoutManager);
        recyclerAdapter = new RecyclerAdapter(getApplicationContext(), R.layout.item_default_data, dataList);
        recyclerView.setAdapter(recyclerAdapter);
    }

    private void init(){
        dataList = new ArrayList<>();
        recyclerView = findViewById(R.id.RecyclerView);

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()){
            case R.id.action:
                Intent intent = new Intent(this, WriteActivity.class);
                startActivityForResult(new Intent(this, WriteActivity.class), 3000);
                    return true;
                default:
                    return false;
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if(resultCode == RESULT_OK && requestCode == 3000){
            Log.d("asdf", "asdf");
            Data receiveData = (Data) data.getSerializableExtra("data");
            dataList.add(receiveData);
            setRecyclerView();
        }
    }
}

mainActivity 클래스파일을 설명하자면

일단 dataList 객체와 Recycler의 Adapter 와 View 변수를 만들어줍니다.

그리고 onCreate안에 호출해준 init()메서드와 RecyclerView를 위한 setRecyclerView()

메서드를 만들어줍니다.

먼저 setRecyclerView() 메소드를 보자면 LayoutManager 객체를 만들어줍니다.

제가 사용하는 xml 의 Layout은 LinearLayout 이여서 저는

LinearLayoutManager 객체를 만들어줬습니다.

그리고 지정된 레이아웃매니저를 RecyclerView에 Set 해줍니다

그뒤에 RecyclerAdapter에 itemlayout 을 셋팅해주고 recyclerView 에 adapter를 Set 해줍니다.

그리고 init 메소드를 보면

datalist를 ArrayList로 바꿔줍니다.

그리고 RecyclerView 의 id를 찾아와 recyclerView에 저장해줍니다

그리고 저는 WriteActivity.xml 로 가기위해 액션바 에 추가버튼을 만들어 줬는데요

일단 menu 의 xml 코드를 보자면

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item
        android:id="@+id/action"
        android:title="추가"
        app:showAsAction="always">
    </item>
</menu>

이런식으로 추가 버튼을 만들어주기 전에 menu를 만들어 id 와 title을 정해줬습니다

app:showAsAction 속성은 "always" 는 계속 Activity에 보입니다.

이제 onCreateOptionsMenu 를 오버라이드 해줍시다

매개변수는 menu 가 들어갈거고 화면에 띄어주기위해서 우리는

inflate 해줘서 xml 에 정의된 Resource 를 View 형태로 변환시켜줍니다.

그뒤에 onOptionsItemSelected 도 오버라이드 시켜줍시다.

switch 문을 이용해 id가 acton 인 menu 일때

Intent 객체를 만드는데 Intent 는 WriteActivity 로 인텐트를해줍니다.

그리고

startActivityForResult(new Intent(this, WriteActivity.class), 3000);

이 코드를 설명하자면 밑에 WriteActivity를 단순히 시작하는게 아니라 requestCode 를 확인하기 위해 3000이라는 상수를 지정해줬습니다.

@Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if(resultCode == RESULT_OK && requestCode == 3000){
            Log.d("asdf", "asdf");
            Data receiveData = (Data) data.getSerializableExtra("data");
            dataList.add(receiveData);
            setRecyclerView();
        }
    }

그리고 마지막으로 이코드를 설명하겠습니다

onActivityResult는 오버라이드 해줘야하는데요

이 코드를 해석하자면 WriteActivity의 data를 받는 메서드 이다.

처리된 결과 코드 resultCode 가 RESULT_OK 이거나 requestCode 가 3000 인 이유는 위에

requestCode를 확인하기 위해 3000 으로 지정해줬기때문입니다

그리고

 Data receiveData = (Data) data.getSerializableExtra("data");

이 코드로 아까 putExtra() 의 키값인 data로 넘겨준 data를 받는다.

그리고 dataList.add(receiveData); 로 data를 더해준다.

그리고 dataList에 .add() 메소드를 이용해 receiveData 에있는 data를 datalist에 더해줍니다

그리고 setRecyclerView(); 메서드를 실행시켜주게 됩니다.

이렇게되면 RecyclerView 가 정상작동하게 됩니다!

여기까지 ViewHolder 패턴을 이용한 RecyclerView 예제였습니다.

ㅠㅠ!

Android (다섯번째 수업 - Custom ListView 와 adapter pattern)

Bin's. — Sat, 25 Aug 2018 11:24:07 +0900

Custom ListView 와 adapter pattern

먼저 ListView 에 대해 알아보자.

보통의 ListView 를 생각하면

연락처 나 메시지 나 목록을 표시해야할때(SMS) 앱 등

필요한 위젯입니다.

Google play (구 버전)

하지만 ListView 는 선택 위젯입니다.

(일반 위젯이 아니다.)

안드로이드에서는 리스트뷰처럼 여러 개의 아이템 중에

하나를 선택할 수 있는 위젯들을 특별히 '선택 위젯'이라고 부름

선택위젯은 직접 데이터를 설정 할 수가 없습니다.

선택위젯에 데이터를 설정하기위해 사용하는게

Adapter pattern 이다.

우리는 이 Adapter 에서 만들어주는 getView() 메서드를 이용해 아이템을 표시해준다.

이해를 위한 예시

ListView 를 정의해보자면

Adapter를 사용해 데이터를 표시하는 View 입니다.

만든 CustomListView 예제를 살펴보자면

메모장처럼 제목 과 내용을 적고 저장 해주면

제목을 누르면 내용이 Toast로 띄어주는 그러한 예제이다.

먼저 Layout을 살펴보자.

일단 ListView 를 띄어줄 MainLayout 에는

간단히 ListView 만 추가해주면 된다

(나는 데이터를 잠깐 저장하기위한 FloatingActionButton 을 사용해줬다.)

MainActivity

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".MainActivity">

    <ListView
        android:id="@+id/listView"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
    </ListView>
    <android.support.design.widget.FloatingActionButton
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>

이런식으로 MainActivity에 추가 해주면된다.

하지만 우리는 리스트뷰에 표시할 아이템을 위해

item_Layout 을 만들어 줘야한다

item_default_data

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="100dp">

    <TextView
        android:id="@+id/titleText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textColor="#000000"
        android:textAppearance="@style/Base.TextAppearance.AppCompat.Large"
        android:text="제목"
        android:layout_margin="10dp"/>
    <View
        android:layout_width="match_parent"
        android:layout_height="3dp"
        android:background="@android:color/darker_gray">
    </View>

</LinearLayout>

이런식으로 우리가 보여줄 item 을위한

Layout이 구현됬으면 이제부터

ListAdapter 의 코드를 보자.

import android.content.Context;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.TextView;
import android.widget.Toast;

import java.util.List;

public class ListAdapter extends ArrayAdapter<Data> {

    private List<Data> dataList;
    private Context context;
    private int layout;


    public ListAdapter(@NonNull Context context, int resource, @NonNull List<Data> objects) {
        super(context, resource, objects);
        this.dataList = objects;
        this.context = context;
        this.layout = resource;
    }

    @NonNull
    @Override
    public View getView(final int position, @Nullable View convertView, @NonNull ViewGroup parent) {
        View view = convertView;
        if(view == null){
            LayoutInflater inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            view = inflater.inflate(layout, null);
        }

        TextView titleText = view.findViewById(R.id.titleText);

        Data data = dataList.get(position);


        view.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(context, dataList.get(position).getContent(), Toast.LENGTH_SHORT).show();
            }
        });
        titleText.setText(data.getTitle());



        return view;
    }

    public void setDataList(List<Data> dataList){
        this.dataList = dataList;
    }
}

이 Adapter를 통해 ListView 의

한 item 에 표시될 정보를 설정할수 있습니다.

먼저 생성자를 만들어준다.

그리고 여기서 살펴볼점은

1) LayoutInflater란?

xml 에 정의된 Resource(자원) 들을 View 형태로 변환시켜줍니다.

우리가 보통 Activity를 만들고 자바 코드안에

onCreate() 메서드에 기본으로 추가되는

setContentView(R.layout.activity_main); 와 같은 원리라고 생각하시면 됩니다.

2) ListView에 view 값이 Null 이라면?

ListView 에 아이템을 표시해줄 getView() 메서드를 보자면

view 값이 Null 이라면 view 가 없게 되닌까

View 가 없으니 inflater 해줘서 할당을 해줍니다.

xml에 정의된 레이아웃을 자바코드로 동적 할당해서 매칭시킨다고 보시면됩니다

그리고 view 의 아이템이 눌리게되면 onClick 이벤트가 실행되

Toast 를 띄어주게 되는데요 Toast 내용은 Content 인 즉 내용이 띄어지고

titleText.setText(data.getTitle());

즉 제목인 Title 을 ListView 에 텍스트로 띄어줍니다.

먼저 이렇게만 작성한다면 .

private List<Data> dataList;

이 코드에 Data 가 빨간밑줄 일 것 입니다.

우리는 저 Data class 를 만들어줘야합니다.

그래서 저는

import java.io.Serializable;

public class Data implements Serializable {
    private String title;
    private String content;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Data(String title, String content) {
        this.title = title;
        this.content = content;
    }
}

이런식으로 Data class를 만들어 줬는데요.

이 class 는 아이템에 출력될 데이터를 위한 클래스 입니다.

이렇게 Data를 위한 클래스, Adapter, item_default_data 까지 모두 완성해준다면

이제 상단 액션바에 Action(추가)인 menu xml 코드를 작성해주자

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto">
    <item
        android:id="@+id/action"
        android:title="추가"
        app:showAsAction="always">
    </item>
</menu>

이런식으로 작성하게 되면 액션바에 추가라는 이름이 적히는데요

app:showAsAction="always" 라는 속성은

항상 보이게 설정해줍니다

이 코드는 이예제의 WriteActivity 에 넘어가서 작성할수 있도록 버튼같은 역활을합니다.

이제 WriteActivity 를 봅시다.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".WriteActivity"
    android:orientation="vertical"
    android:weightSum="360">

    <EditText
        android:id="@+id/titleEditText"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="40"
        android:hint="제목"
        android:layout_margin="10dp"/>
    <EditText
        android:id="@+id/contentEditText"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="300"
        android:layout_margin="10dp"
        android:hint="내용"
        android:lines="10"/>

    <android.support.design.widget.FloatingActionButton
        android:id="@+id/saveFab"
        android:src="@drawable/ic_save_black_24dp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginRight="30dp"
        android:layout_gravity="right"/>


</LinearLayout>

간단하게

제목을 적을 EditText 와 내용을적을 EditText랑

데이터를 저장해줄 FloatingActionButton

이 구성되 있습니다.

이제 본격적으로

WriteActivity의 xml 코드를 보자면

import android.content.Intent;
import android.support.design.widget.FloatingActionButton;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;

public class WriteActivity extends AppCompatActivity {

    private EditText titleEditText;
    private EditText contentEditText;
    private FloatingActionButton saveFab;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_write);

        init();
        setListeners();

    }

    private void init(){

        titleEditText = findViewById(R.id.titleEditText);
        contentEditText = findViewById(R.id.contentEditText);
        saveFab = findViewById(R.id.saveFab);

    }

    private void setListeners(){
        saveFab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String title = titleEditText.getText().toString();
                String content = contentEditText.getText().toString();
                if(!title.equals("") && !content.equals("")){
                    Data data = new Data(titleEditText.getText().toString(), contentEditText.getText().toString());
                    Toast.makeText(getApplicationContext(), "성공적으로 작성하셨습니다.", Toast.LENGTH_SHORT).show();
                    Intent intent = new Intent();
                    intent.putExtra("data", data);
                    setResult(RESULT_OK,intent);
                    finish();

                }
            }
        });
    }
}

간단하게 해석하자면 각각의 EditText의 id를 찾아주고

saveFab은 FloatingActionButton의 id 이다.

saveFab을 눌르면 onClick 이벤트가 실행된다.

내용은 titleEditText 내용을 가져와String 형태로 title 에 담고

contentEditText의 내용도 가져와 String 형태로 Content에 담습니다.

if문 은 title 과 content 의 값이 있을때 실행되는데요

먼저 Data class의 객체를 만들어줘 titleEditText 내용, contentEditText의 내용

을 가져와 data 에 저장해줍니다.

그뒤에 Toast로 "성공적으로 작성하셨습니다." 라는 Toast를 띄어줍니다.

그뒤에 Intent 객체를 만들어주고

.putExtra() 로 "data" 라는 키로 data를 넘겨줍니다.

그리고

setResult(RESULT_OK,intent);
finish();

이코드로 Activity를 종료해줍니다.

이제 마지막으로 data값을 ListView 에 띄어주는 MainActivity.java code 를보자.

        import android.content.Intent;
        import android.support.v7.app.AppCompatActivity;
        import android.os.Bundle;
        import android.util.Log;
        import android.view.Menu;
        import android.view.MenuItem;
        import android.widget.ListView;

        import java.util.ArrayList;
        import java.util.List;

public class MainActivity extends AppCompatActivity {

    private List<Data> dataList;
    private ListView listView;
    private ListAdapter listAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
        setListView();
    }

    private void setListView(){
        listAdapter = new ListAdapter(getApplicationContext(), R.layout.item_default_data, dataList);
        listView.setAdapter(listAdapter);
    }

    private void init(){
        dataList = new ArrayList<>();
        listView = findViewById(R.id.listView);

    }

    public void changeData(Data data){
        dataList.add(data);
    }



    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()){
            case R.id.action:
                Intent intent = new Intent(this, WriteActivity.class);
                startActivityForResult(new Intent(this, WriteActivity.class), 3000);
                    return true;
                default:
                    return false;
        }
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if(resultCode == RESULT_OK && requestCode == 3000){
            Log.d("asdf", "asdf");
            Data receiveData = (Data) data.getSerializableExtra("data");
            dataList.add(receiveData);
            setListView();
        }
    }
}

먼저 onCreate 에 호출된 init(); 과 setListView(); 를 보면

init(); 은 dataList 에 변수에 arrayList 형식으로 데이터를 저장합니다.

그리고 listView 의 id 를 listView에 저장해줍니다.

그리고 setListView();를 보면

Adapter 의 객체를 만들어주는데 Layout은 아까 만들어준

item_default_data 을 사용해주고 내용은 datalist 입니다.

그리고 listView.setAdapter(listAdapter);

Adapter의 값을 정해주고

이제 다른 코드를 보자면

public void changeData(Data data){
        dataList.add(data);
    }

를 보면 매개변수는 data를 받아오고

dataList.add(data); 를 이용해 데이터를 더해준다.

그리고

@Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu, menu);
        return true;
    }

보게 되면 Inflater 를 이용해

xml 로 정의된 menu 를 실제 객체화를 해줍니다.

이 코드를 써준이유는

미리 xml 을 만들어준 뒤 java code 에서

inflater 을 활용해 바로 view 를 생성할 수있기 때문이다.

그리고

 @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()){
            case R.id.action:
                Intent intent = new Intent(this, WriteActivity.class);
                startActivityForResult(new Intent(this, WriteActivity.class), 3000);
                    return true;
                default:
                    return false;
        }
    }

이 코드를 보자

switch 문을 사용했다. 먼저 item 의 id 를 얻어

id 가 action 인 item 은 아까 추가해준

item_default_data 이 xml 이다.

item 의 id 가 action 이면 추가 버튼을 눌르게된다면 WriteActivity 로 intent 로 넘어가고

startActivityForResult() 를 이용해 WriteActivity 를 시작하고 그 Activity로부터 결과를 수신할 수도 있습니다.

값은 3000으로 지정해줬습니다.

만약 id 가 action 아니면 false를 return 해줍니다.

그리고 마지막으로

@Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        if(resultCode == RESULT_OK && requestCode == 3000){
            Log.d("asdf", "asdf");
            Data receiveData = (Data) data.getSerializableExtra("data");
            dataList.add(receiveData);
            setListView();
        }
    }
}

이 코드를 해석하자면 WriteActivity의 data를 받는 메서드 이다.

처리된 결과 코드 resultCode 가 RESULT_OK 이거나 requestCode 가 3000 인 이유는 위에

startActivityForResult(new Intent(this, WriteActivity.class), 3000);

이코드를 이용해 WriteActivity 를 시작하고 그 Activity로부터 결과를 수신 했습니다

Data receiveData = (Data) data.getSerializableExtra("data");

이 코드로 아까 putExtra() 의 키값인 data로 넘겨준 data를 받는다.

그리고 dataList.add(receiveData); 로 data를 더해준다.

그리고 마지막으로

setListView(); 를 이용해세

private void setListView(){
        listAdapter = new ListAdapter(getApplicationContext(), R.layout.item_default_data, dataList);
        listView.setAdapter(listAdapter);
    }

을 호출해 준다.

이렇게 되면 ListView가 띄어지는걸 볼수있다.

여기까지 adapter pattern 을 이용한 CustomListView 사용법 이였다.

굳!

Android (네번째 수업 - Glide , Ratingbar)

Bin's. — Tue, 14 Aug 2018 04:33:39 +0900

Android - Glide , Ratingbar

1. Glide

1. 2014년에 공개된 이미지 로딩 라이브러리이다.

2. ImageView 에 이미지 로딩때 사용되는 라이브러리이다.

3. 이미지 URL을 로드해서 보여줄수있다.

일단 Glide 도 하나의 라이브러리 이기때문에

먼저 다른 라이브러리들 처럼 Gradle 에 dependencies 에 등록해줍니다.

dependencies { 
    implementation 'com.github.bumptech.glide:glide:4.7.1'
}

자 이렇게 glide 를 추가해줬으면

이제 glide 를 어떻게 사용하는지에 대해 알아보도록 하자.

glide를 먼저 사용하기전에

load할 사진의

이미지주소 를 추가해줘야하는데

values폴더에 string.xml 파일안에

<string name="url">이미지주소 넣어주세요</string>

이렇게 load 할 url 을 추가 시켜줘야한다.

먼저 xml 코드를 보자

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <ImageView
        android:id="@+id/imageView"
        android:layout_width="320dp"
        android:layout_height="200dp"
        android:layout_marginBottom="8dp"
        android:layout_marginEnd="8dp"
        android:layout_marginStart="8dp"
        android:layout_marginTop="8dp"
        android:src="@android:color/darker_gray"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.0" />
 
</android.support.constraint.ConstraintLayout>

ConstraintLayout 을 사용했습니다.

먼저 이미지 를 로드할 <ImageView/> 을 만들어줍니다.

여기서 새로운점은 background 대신 src 속성을 줬다는겁니다.

이제 자바 코드를 봅시다.

Java code

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.ImageView;


import com.bumptech.glide.Glide;

public class MainActivity extends AppCompatActivity {

    private ImageView imageView;
    private String url;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
        loadImage();
    }

    private void init(){
        imageView = findViewById(R.id.imageView);
        url = getResources().getString(R.string.url);

    }
    private void loadImage(){
        Glide.with(this).load(url).into(imageView);
    }
}

이 코드를 해석해 보자면

ImageView 변수랑 url 변수를 만들어 준다.

그리고 imageView 의 id 찾아주는 , 그리고 url 을 url 변수안에 넣어주는

init메서드를 정의하고

이미지를 imageView에 띄어줄

loadImage 메서드를 정의해주는데

Glide.with(this).load(url).into(imageView);

이소스를 해석하자면

이클래스 안에 서 .load(url) 안 에들어가는

인자를 로드해오는데요

인자에 아까 정의해둔 url 을 불러온뒤

.into() 안에 인자는어디로 띄어줄가를 정하는겁니다.

그럼 결론적으로 아까 정의해둔 url이 이미지뷰에 로드 되는걸 볼수있는

그런 이미지 로딩 라이브러리가 glide 입니다.

2. Ratingbar

Ratingbar 는 별점을 줄때 많이 사용하는

위젯입니다.

먼저 사용법을 알아보자.

xml 코드

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <RatingBar
        android:id="@+id/ratingBar"
        android:layout_width="242dp"
        android:layout_height="wrap_content"
        android:layout_marginBottom="268dp"
        android:layout_marginTop="8dp"
        android:max="5"
        android:rating="0"
        android:stepSize="1"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="1.0" />


</android.support.constraint.ConstraintLayout>

ConstraintLayout를 사용한 xml 코드

먼저 구현하는 방법은 간단하다

<Ratingbar/> 의 xml 특성을 보자면

 android:max="5"
 android:rating="0"
 android:stepSize="1"

max // 레이팅의 최고 수치를 뜻합니다 (실제 값)

rating // 최초 시작지 즉 별의 시작지를 뜻합니다.

stepSize // 별의 움직임 단위를 뜻합니다.

좀더 알고싶다면

https://developer.android.com/reference/android/widget/RatingBar

에서 찾아 볼수 있습니다.

java 코드

private void setListeners(){
    ratingBar.setOnRatingBarChangeListener(new RatingBar.OnRatingBarChangeListener() {
        @Override
        public void onRatingChanged(RatingBar ratingBar, float rating, boolean fromUser) {
            Toast.makeText(getApplicationContext(), Float.toString(rating),Toast.LENGTH_SHORT).show();
        }
    });
}

이렇게 Ratingbar 사용법에 대해 알아봤다.

방학이끝나간다 끝나기전에 좀더 열심히 공부하자.

Android (세번째 수업 - 안드로이드 Design Support Library( Snackbar, AlertDialog ))

Bin's. — Thu, 9 Aug 2018 10:47:52 +0900

Android - Design Support Library

안드로이드 디자인 서포트 라이브러리

구글은 지난 Google I/O 2015 에서 머티리얼 디자인을 더욱

쉽게 적용할수 있는 'Android Design Support Library' 를 공개했습니다.

이번에 살펴볼 안드로이드 디자인 서포트 라이브러리 를 살펴보기전에

먼저 다른 라이브러리들 처럼 Gradle 에 dependencies 에 등록해줍니다

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:27.1.1'
    implementation 'com.android.support.constraint:constraint-layout:1.1.2'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
    implementation 'com.android.support:design:27.1.1'
}

소스를 보면 마지막줄처럼

 implementation 'com.android.support:design:27.1.1'

이소스를 추가 해주셔야합니다 버전은 위에 appcompat 버전 이랑 동일하게 해주세요.

1. Snackbar

Snackbar 는 Toast 랑 비슷하다.

Snackbar는 하단에 메세지를 출력해준니다

동작과 사용방법은 Toast랑 비슷하다 하지만 메세지와 함께 액션(Action) 을

포함한다는 점에 달라집니다.

그럼 사용법에 대해 알아보도록하자.

Snackbar.make(view, "스낵바 테스트", Snackbar.LENGTH_SHORT).show();

Toast 메시지와 비슷한점을 알수있다.

Snackbar는 3가지 인자를 받는데

첫번째 인자는 view , 두번째 인자는 Snackbar 에 띄어줄 문구를 적어준다

세번째 인자는 지속시간이다. (LENGTH_SHORT 는 약 2초이다 짧게 띄어줄때 사용.)

그리고 항상 뒤에 .show(); 메소드로 실행시켜주자 까먹지말자.

이코드로만은 아직 아쉬운점이있다.

왜냐하면 이렇게 그냥 띄어주기만하면 Toast랑 다른점은 그냥 하단에

Snackbar형식으로 띄어주는것 차이이다

이제 우리가 살펴볼건 Snackbar에 액션(Action) 을 추가해줄것이다.

button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Snackbar.make(view, "스낵바 테스트", Snackbar.LENGTH_SHORT)
                    .setAction("확인", new View.OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            textView.setText("스낵바 내용  확인됨");
                        }
                    }).show();
        }
    });
}

소스 코드를 해석해보자면

Snackbar에 인자를 주고

.setAction() 메서드를 사용해 액션(Action) 을 추가해줬다.

.setAction() 안에는

액션에 표시할 텍스트와 View.OnClickListener()

두개의 인자를 받습니다

사용자가 액션을 클릭했을때

수행할 코드는 onClick 이벤트에 정의합니다.

소스를 보면 textView.setText("스낵바 내용 확인됨");

액션을 클릭했을때 텍스트로 "스낵바 내용 확인됨"

이라고 textView가 뜹니다.

이런식으로 Snackbar 의사용법을 알아봤습니다.

2.AlertDialog

AlertDialog은 알림상자라고 볼수있다.

먼저 AlertDialog 도 Snackbar 처럼 Gradle 에 dependencies 에 등록해줍니다.

AlertDialog을 설명하자면

제목 하나, 최대 세 개의 버튼, 선택 가능한 품목 목록 또는 사용자 지정 레이아웃을 표시할 수 있는 대화상자입니다.

먼저 xml 코드를 보면

xml code

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:weightSum="360"
    tools:context=".MainActivity">

    <Space
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="150"/>
    <TextView
        android:id="@+id/textView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="50"
        android:textAppearance="@style/Base.TextAppearance.AppCompat.Large"
        android:text="tools"
        android:gravity="center"/>
    <Button
        android:id="@+id/button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:text="Press Me"/>


</LinearLayout>

Snackbar 도 같은 xml 코드

xml 코드를 간단하게 설명하자면

<Space/> 로 공백을 줬고

<TextView/> 은 그전에 Snackbar의 액션을 눌렀을때 <TextView/>가

바뀌는걸 볼수있다.

그리고 <Button/> 을 하나 만들어 줬다.

이제 AlertDialog 의 사용법에 대해 알아보자.

private void setDialog(){
    AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
    builder.setTitle("알림");
    builder.setMessage("정말로 종료하시겠습니까?");
    builder.setPositiveButton("확인", new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialog, int which) {
            finishAffinity();
        }
    });
    builder.setNegativeButton("취소", null);
    AlertDialog alertDialog = builder.create();
    alertDialog.show();
}

먼저 AlertDialog.Builder 클래스를 이용해 객체를 만들어준다음에

.setTitle() 의 인자로 타이틀 텍스트를 입력해주고

.setMessage() 의 인자로는 메세지 텍스트를 입력해준다.

여기서 살펴볼건 .setPositiveButton() 이다.

먼저 살펴보자면 "확인" 을 눌르면 onClick 이벤트의 finishAffinity(); 를 호출하게된다

finishAffinity(); 메서드를 설명하자면 어느 Activity 등

모든 부모 Activity를 닫을수 있다.

그러므로 "확인" 을누르게 되면 앱이 종료 된다.

그리고 "취소 를" 누르게 되면

알림창 객체를 생성하고 알림창을 띄우는데

내용은 null이다.

이런식으로 AlertDialog 의사용법에 대해 알아봤습니다

여기서 응용으로

public void onBackPressed(){
    setDialog();
}

이런식으로 onBackPressed() 는 뒤로가기 버튼을 눌렀을 경우 처리하는 함수이다.

뒤로가기 버튼을 이용해

AlertDialog 를 호출할수도 있다.

앞으로 열심히 해야겠다.

Android (두번째 수업 - 안드로이드 인텐트 / 인텐트 콜백(Intent Callback))

Bin's. — Fri, 27 Jul 2018 00:59:20 +0900

Android - Intent Callback

what is Intent?

인텐트는 뭘까?

먼저 Intent 를 알기전에

안드로이드 어플리케이션 구성하는 요소(컴포넌트)들을 알아보자.

1. Activity

2. Service

3. Broadcast Receiver

4. Content Provider

인텐트(Intent)란 이러한 어플리케이션 구성요소(컴포넌트) 간에

작업 수행을 위한 정보를 전달하는 역할을 한다.

우리는 보통 인텐트를 사용할땐 호출과 메시지 전달에 사용하는데

이번엔 Activity 간의 화면 전환 과 더불어

Intent Callback (data 주고받기) 를 해봤다.

먼저 activity_main 의 UI와 code 를 보자.

editText 에 입력할 내용을 입력하고 이동버튼을 눌르게되면

다음화면에 입력한값이출력된다.

xml code

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:weightSum="360"
    android:orientation="vertical"
    android:background="@android:color/white"
    tools:context=".MainActivity">

    <Space
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="150"
        />
    <TextView
        android:id="@+id/resultText"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="30"
        android:text="asdf"
        android:textColor="@color/colorAccent"
        android:textAppearance="@style/Base.TextAppearance.AppCompat.Large"
        android:gravity="center"
        android:layout_gravity="center_horizontal"
        android:visibility="gone"/>
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="50"
        android:layout_marginLeft="20dp"
        android:layout_marginRight="20dp"
        android:hint="전송할 값을 입력하세요"
        android:textColorHint="@android:color/white"
        android:textSize="20dp"
        android:layout_gravity="center_vertical|center_horizontal"/>
    <Button
        android:id="@+id/moveButton"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_marginLeft="30dp"
        android:layout_marginRight="30dp"
        android:layout_marginTop="100dp"
        android:background="@color/colorPrimaryDark"
        android:textColor="@android:color/white"
        android:text="이동"
        android:textSize="15dp"
        android:elevation="20dp"
        android:layout_weight="40"/>

</LinearLayout>

먼저 LinearLayout 을 사용했고선형 레이아웃으로 orientation을 vertical로 설정

그래서 수직으로 뷰가 구성된다. 그리고 weightSum 에 "360" 을 줬다.

<space> 로 공백을 "360"중의 "150" 만큼 준다.

<Textview> 를 하나만들어준다 먼저 이 Textview는 나중에 activity_second 에서 가져온 data를

보여주는 Textview 라고 보면된다."360"의 "30" 을 줬다.

그리고 android:layout_gravity="center_horizontal" 가로 중앙에 위치.

그리고 <EditText> "360" 중 "50" 만큼 줌.

그리고 이 EditText 은 전송할 값을 입력하는 EditText 이다.

android:hint="전송할 값을 입력하세요"

이렇게 hint를 사용하게 되면 글자를 입력하기전까진 보이지만 입력하면 보이지않는그러한 속성이다.

그리고 activity_second 으로 넘어가기위해 이동<Button> 하나를 만들어줬다.

자 이제 xml 코드 설명은 끝났다 이제 실질적 동작을하게 해주는 자바 소스를 보도록 하자.

Java code

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class MainActivity extends AppCompatActivity {

    private TextView resultText;
    private EditText editText;
    private Button moveButton;

    private  static final int REQUEST_CODE = 3000;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        init();
        setListeners();

    }

    private void init(){

        resultText = findViewById(R.id.resultText);
        editText = findViewById(R.id.editText);
        moveButton = findViewById(R.id.moveButton);

    }

    private void setListeners(){
        moveButton.setOnClickListener(v ->{
            Intent intent = new Intent(this, SecondActivity.class);
            intent.putExtra("value", editText.getText().toString());
            startActivityForResult(intent, REQUEST_CODE);
        });
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if(requestCode == REQUEST_CODE && resultCode == RESULT_OK){
                String value2 = data.getStringExtra("value2");
            resultText.setVisibility(View.VISIBLE);
            resultText.setText(value2);
        }
    }
}

자여기선 Lambda Expression Code 가 이용된 코드이다.

먼저 각각 버튼의 아이디를 찾아줄 private init 메소드를 정의해준다.

그리고 setListeners 메소드는 Lambda Expression Code 이다.

moveButton.setOnClickListener (v ->{ 실제 동작할 코드 })

이렇게 식별자없이 실행 가능한 함수표현식이다.

실제 동작할 코드는 인텐트로 화면을 SecondActivity로 넘기는데

putExtra() 를 사용하여 data를 넘겨준다.

putExtra() = data를 전송할때 사용한다

putExtra()는 putExtra(key, value)

이런형식으로 사용된다.

그리고 Activity를 수신하기위해서

startActivityForResult() 를호출합니다.

private  static final int REQUEST_CODE = 3000;

라는 코드를 써준이유는 startActivityForResult() 를호출를 하기위해서

정수 인자를 호출해야하기때문입니다.

그래서 REQUEST_CODE 에 정수 인자를 준 코드입니다.

그리고 밑에 @Override 된코드를 보면

뒤에 Second_Activity의 작업을 마치고 돌아오면, MainActivity 의 onActivityResult()를 호출합니다.

이 method는 세 가지 인수를 포함한다.

이코드는 인텐트에 대한 결과를 처리하는 방법

이라고 볼수있다.

if(requestCode == REQUEST_CODE && requestCode == REQUEST_CODE){
                String value2 = data.getStringExtra("value2");

이 코드를 보게되면

그리고 이코드는 value2 의 data를 받아와서 String 형태로 담는다.

resultText.setVisibility(View.VISIBLE);
 resultText.setText(value2);

value2의 내용을 보여주는 코드로 볼수있다.

setVisibility(View.VISIBLE)는

View를 숨기고, 감추고, 보여지게

해주는 코드이다

view.setVisibility(View.VISIBLE); // View를 보여 준다.
라고 이해하면 될것같다.

이제 두번째 화면의 UI를 보자

SecondActivity UI

첫번째 화면에서 입력한 값이 출력되있는걸 볼수있는 화면이다.

그리고 여기서 또 editText1에 또 내용을 입력한뒤 이동을

눌르게되면 첫번째 화면에 TextView에 두번째 화면에서

입력된 값이 출력되는 걸 볼수있다.

자이제 xml 코드를 보자.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:weightSum="360"
    android:orientation="vertical"
    android:background="@android:color/white"
    tools:context=".SecondActivity"
    >
    <Space
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="150"
        />
    <TextView
        android:id="@+id/resultText1"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="30"
        android:text="asdf"
        android:textColor="@color/colorAccent"
        android:textAppearance="@style/Base.TextAppearance.AppCompat.Large"
        android:gravity="center"
        android:layout_gravity="center_horizontal"
        android:visibility="visible"/>
    <EditText
        android:id="@+id/editText1"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="50"
        android:layout_marginLeft="20dp"
        android:layout_marginRight="20dp"
        android:hint="전송할 값을 입력하세요"
        android:textColorHint="@android:color/white"
        android:textSize="20dp"
        android:layout_gravity="center_vertical|center_horizontal"/>
    <Button
        android:id="@+id/finishButton"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_marginLeft="30dp"
        android:layout_marginRight="30dp"
        android:layout_marginTop="100dp"
        android:background="@color/colorPrimaryDark"
        android:textColor="@android:color/white"
        android:onClick="moveButton1"
        android:text="이동"
        android:textSize="15dp"
        android:elevation="20dp"
        android:layout_weight="40"/>
</LinearLayout>

이 xml 코드는 첫번째 xml 코드와 같은코드이다

하지만 각 위젯의 id 값은 다르게줬다.

Java code 를보자

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

public class SecondActivity extends AppCompatActivity {
    private TextView resultText1;
    private EditText editText1;
    private Button finishButton;
    private String value;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        init();
        setListeners();

    }
    private void init(){
        resultText1 = findViewById(R.id.resultText1);
        editText1 = findViewById(R.id.editText1);
        finishButton = findViewById(R.id.finishButton);
        value = getIntent().getStringExtra("value");
        resultText1.setText(value);
    }

    private void setListeners(){
        finishButton.setOnClickListener(v ->{
            Intent intent = new Intent();
            intent.putExtra("value2", editText1.getText().toString());
            setResult(RESULT_OK, intent);
            finish();
        });
    }
}

onCreate() 코드를 보면

init() 와 setListeners() 를 호출하는데

init()를 보면

각 위젯의 id를 찾는 코드가 보이고

value = getIntent().getStringExtra("value");
 resultText1.setText(value);

첫번째 화면에서 입력한 data를

getStringExtra()를 이용해 getStringExtra(key) 방식을 통해서 string을 받을수 있습니다.

그리고 받아온 data를

resultText1에 출력해줍니다

이 소스를 보면 두번째 화면에 첫번째 화면에 입력했던 값을 출력해주는

코드라는걸 알수있습니다.

그리고 setListeners()를 보면

이번에도 람다식(Lambda Expression Code)이 적용되었다.

여기선 value2의 data를 입력해주는 코드이다.

위에 첫번째 자바코드에서 value2의 data를 받아오는 코드가있을것이다.

그리고 두번째 화면에서 data 입력한뒤 finshButton을

누르게 되면 첫번째 화면으로 이동하게 되면서 입력한 data를

출력해주는 앱이다.

이앱은 Intent Callback 의 예제라고 볼수있다.

이번 수업에선 이해를 하려고 노력을 했다.

처음보는 방식의 코드도 있었고

새로운 지식도 많이 얻은 수업이었던것 같다.

좀 더 열심히 해야겠다.