안드로이드 앱 개발

<activity
    android:name=".MainActivity"
    android:exported="true"
    android:windowSoftInputMode="adjustResize">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_main)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->

            //시스템바의 insets
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())

            //소프트키보드의 insets
            val imeInsets = insets.getInsets(WindowInsetsCompat.Type.ime())

            //소프트키보드가 없다면( bottom 좌표가 0 ) 시스템바 사이즈 만큼만 아래(bottom) 영역을 주고 있다면 소프트키보드의 높이만큼 아래(bottom) 패딩 지정.
            if(imeInsets.bottom==0) v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            else v.setPadding(systemBars.left, systemBars.top, systemBars.right, imeInsets.bottom)

            insets
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //시스템바(status bar, navigation bar) 영역까지 액티비티의 영역을 확장(api35버전 부터 명시적 적용여부와 상관없이 강제로 적용)
        enableEdgeToEdge()

        //액티비티가 보여줄 레이아웃 뷰를 지정
        setContentView(R.layout.activity_main)

        //액티비티가 시스템바 영역까지 확대되면 시스템바에 의해 뷰들이 가려짐. 이에 최상위 뷰(R.id.main)를 찾아와서 시스템바 사이즈를 동적으로 얻어와 패딩을 적용.
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        //액티비티가 보여줄 레이아웃 뷰를 지정
        setContentView(R.layout.activity_main)

    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //시스템바(status bar, navigation bar) 영역까지 액티비티의 영역을 확장(api35버전 부터 명시적 적용여부와 상관없이 강제로 적용)
        enableEdgeToEdge()

        //액티비티가 보여줄 레이아웃 뷰를 지정
        setContentView(R.layout.activity_main)

    }
}

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        android:textSize="64sp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //시스템바(status bar, navigation bar) 영역까지 액티비티의 영역을 확장(api35버전 부터 명시적 적용여부와 상관없이 강제로 적용)
        enableEdgeToEdge()

        //액티비티가 보여줄 레이아웃 뷰를 지정
        setContentView(R.layout.activity_main)

        //액티비티가 시스템바 영역까지 확대되면 시스템바에 의해 뷰들이 가려짐. 이에 최상위 뷰(R.id.main)를 찾아와서 시스템바 사이즈를 동적으로 얻어와 패딩을 적용.
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }
    }
}

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">

    <Button
        android:id="@+id/btn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="button"/>

</LinearLayout>

class MainActivity : AppCompatActivity() {

    // 늦은 초기화로 버튼 참조하기
    lateinit var btn: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_main)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }

        //lateinit var 변수 초기화
        btn= findViewById(R.id.btn)
        
    }
}

//버튼 클릭이벤트 리스너 등록 3가지 방법 [ 익명객체 만들어 적용하는 3가지 방법 ]
//1. 기본적인 익명객체 문법
btn.setOnClickListener(object : View.OnClickListener{
    override fun onClick(v: View?) {
        //익명 클래스안에서 아웃터클래스(MainActivity)의 this를 호출할때 @Label 사용
        Toast.makeText(this@MainActivity, "clicked", Toast.LENGTH_SHORT).show()
    }
})

//2. 람다(Lambda)표기법 [ 익명객체의 추상메소드가 1개일때 사용가능한 기술 - 축약표현문법 : 추상메소드의 오버라이드 코드를 생략 -람다표기법 사용 ] {}는 익명클래스가 아니기에 this 가 MainActivity를 의미함.
btn.setOnClickListener( View.OnClickListener { v-> Toast.makeText(this, "SAM conversion clicked", Toast.LENGTH_SHORT).show() }  )

//2.1 파라미터가 1개일때는 파라미터도 생략가능
btn.setOnClickListener( View.OnClickListener { Toast.makeText(this, "SAM conversion clicked!", Toast.LENGTH_SHORT).show() }  )

//3. SAM 변환 - setOnClickListener()메소드가 어차피 다른 클래스는 사용이 불가능 하기에 OnClickListener 인터페이스이름 조차도 생략하여 더 축약형으로..
btn.setOnClickListener { v-> Toast.makeText(this, "완전 SAM 적용", Toast.LENGTH_SHORT).show() }

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">

    <EditText
        android:id="@+id/et"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="input text"
        android:inputType="text"/>
    <Button
        android:id="@+id/btn"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="button"/>
    <TextView
        android:id="@+id/tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:padding="8dp"
        android:text="RESULT"
        android:textColor="@color/black"/>

</LinearLayout>

class MainActivity : AppCompatActivity() {

    // 늦은 초기화로 버튼 참조하기
    lateinit var btn: Button

    //다른 방법으로 늦은 초기화
    val et: EditText by lazy { findViewById(R.id.et) }
    val tv by lazy { findViewById<TextView>(R.id.tv) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        .....

        //lateinit var 변수 초기화
        btn= findViewById(R.id.btn)
        
        .....
        
    }
}

//3.1 당연히 파라미터 생략가능 [ EditText의 글씨를 가져와서 TextView에 설정 - 코틀린의 getXXX(), setXXX()을 사용하지 않고 곧바로 property(멤버변수)를 제어하는 방식을 선호 ]
btn.setOnClickListener { tv.text= et.text.toString() }

//3.2 만약 파라미터를 생략했는데 {}안에서 파라미터 v를 사용하고 싶다면 특별한 키워드 it 사용
btn.setOnClickListener {
    when(it.id){
        //익명객체를 생략했기에 Context파라미터에 전달한 this가 자연스럽게 MainActivity가 되어 그냥 사용할 수 있음.
        R.id.btn-> Toast.makeText(this, "선택한 버튼의 ID 값 : " + it.id, Toast.LENGTH_SHORT).show()
    }
}

//1) LongClickListener
btn.setOnLongClickListener {
    Toast.makeText(this, "long click", Toast.LENGTH_SHORT).show()

    //return this //error - 여기서 return 을 하면 onCreate Method 의 return 으로 인식함.
    //SAM 변환에서는 return 키워드 사용하지 않음.
    true
    // return 키워드를 명시적으로 하고싶다면.. @Label을 통해 누구의 return 인지 명시..
    //return@setOnLongClickListener true   //리턴값이 있을때의 코드
}

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">

    ........

    <!-- SAM 연습용 복합버튼.   -->
    <CheckBox
        android:id="@+id/cb"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="checkbox"/>

</LinearLayout>

class MainActivity : AppCompatActivity() {

    ...

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        .....

        val cb: CheckBox = findViewById(R.id.cb)
        
    }
}

cb.setOnCheckedChangeListener( object : CompoundButton.OnCheckedChangeListener{
    override fun onCheckedChanged(buttonView: CompoundButton?, isChecked: Boolean) {
        Toast.makeText(this@MainActivity, "체크상태 : $isChecked", Toast.LENGTH_SHORT).show()
    }
})

//SAM conversion
//파라미터가 여러개면 생략할 수 없음 , 파라미터들의 변수명만 작성해도 되고. 자료형까지 명시해도 됨
cb.setOnCheckedChangeListener{ Toast.makeText(this, "aaa", Toast.LENGTH_SHORT).show() } //ERROR

cb.setOnCheckedChangeListener{ buttonView, isChecked:Boolean ->
    Toast.makeText(this, "체크상태 : $isChecked", Toast.LENGTH_SHORT).show()
}

.....

<RadioGroup
    android:id="@+id/rg"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <RadioButton
        android:id="@+id/rb_f"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="female"
        android:checked="true"/>
    <RadioButton
        android:id="@+id/rb_m"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="male"/>

</RadioGroup>

val rg: RadioGroup = findViewById(R.id.rg)

rg.setOnCheckedChangeListener(object : RadioGroup.OnCheckedChangeListener{
    override fun onCheckedChanged(group: RadioGroup?, checkedId: Int) {
        val rb: RadioButton = findViewById(checkedId)
        Toast.makeText(this@MainActivity, rb.text, Toast.LENGTH_SHORT).show()
    }
})

//SAM conversion
rg.setOnCheckedChangeListener { group, checkedId ->
    val rb: RadioButton = findViewById(checkedId)
    Toast.makeText(this, "선택 : ${rb.text}", Toast.LENGTH_SHORT).show()
}

et.addTextChangedListener( object : TextWatcher {
    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
        //자동으로 써진 TODO 를 지우거나 앞에 주석표시 없으면 이 영역이 실행될 때 에러 발생할 수 있음.
        //TODO("Not yet implemented")
    }

    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
        //TODO("Not yet implemented")
    }

    override fun afterTextChanged(s: Editable?) {
        //TODO("Not yet implemented")
    }
})

//위 처럼 추상메소드가 3개인 인터페이스는 원래 SAM이 안됨. 하지만, addTextChangedListener()에서는 3개중 마지막 추상메소드만 사용하는 인터페이스로 변경하여 SAM처리해줌
//즉,아래 SAM변환 메소드는 위 TextWatcher의 afterTextChanged() 추상메소드 임
et.addTextChangedListener{
    Toast.makeText(this,"글씨변경 : " + it.toString(),Toast.LENGTH_SHORT).show()
}

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">

    ......

    <Button
        android:id="@+id/btn2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="show AlertDialog"
        android:textAllCaps="false"/>

</LinearLayout>

class MainActivity : AppCompatActivity() {

    ...

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        .....

        findViewById<Button>(R.id.btn2).setOnClickListener {

            val builder= AlertDialog.Builder(this)
            builder.setTitle("Dialog")
            builder.setMessage("This is Alert Dialog")
            // 익명클래스로 클릭이벤트 처리
            builder.setPositiveButton("OK", object : DialogInterface.OnClickListener{
                override fun onClick(p0: DialogInterface?, p1: Int) {
                    Toast.makeText(this@MainActivity, "click ok", Toast.LENGTH_SHORT).show()
                }
            })
            // lambda 표현식으로 리스너처리
            builder.setNegativeButton("CANCEL",{po,p1->Toast.makeText(this, "click cancel", Toast.LENGTH_SHORT).show()})
            // SAM conversion 완성 - 위에서 ()도 생략했듯.. 여기서도. ()를 생략하고 {}만 작성하고자 하였으나 "CANCEL"처럼 다른 파라미터가 있으면 그 파라미터는 그대로 ()에 넣고.. {}만 밖으로 이동
            builder.setNeutralButton("OPTION"){po,p1-> Toast.makeText(this, "click option", Toast.LENGTH_SHORT).show()}
            builder.create().show()

        } 
        
    }//onCreate method
    
}//MainActivity class

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp"
    tools:context=".MainActivity">

    .....

    <Button
        android:id="@+id/btn3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="go to SecondActivity"
        android:textAllCaps="false"/>

</LinearLayout>

findViewById<Button>(R.id.btn3).setOnClickListener {
    //SecondActivity 를 실행하기 위한 인텐트 객체 생성
    val intent: Intent = Intent(this, SecondActivity::class.java)
    
}

class MainActivity : AppCompatActivity() {

    ...

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        .....

        findViewById<Button>(R.id.btn3).setOnClickListener {
            //SecondActivity 를 실행하기 위한 인텐트 객체 생성
            val intent: Intent = Intent(this, SecondActivity::class.java)
            
            //결과를 받아 돌아오는 ActivityResultLauncher 실행객체로 SecondActivity 실행!
            resultLauncher.launch(intent)    
        }
        
    }//onCreate method
    
    //결과를 받아 돌아오는 Activity Result Launcher 실행객체 -- 익명클래스로 ActivityResultCallback 콜백객체 처리
    val resultLauncher: ActivityResultLauncher<Intent> = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult(), object : ActivityResultCallback<ActivityResult> {
            override fun onActivityResult(result: ActivityResult) {
                TODO("Not yet implemented")
            }
        })
    
}//MainActivity class

// SAM 변환을 일부 사용하기
val resultLauncher2: ActivityResultLauncher<Intent> = registerForActivityResult(
    ActivityResultContracts.StartActivityForResult(), ActivityResultCallback {
        if(it?.resultCode== RESULT_OK){
            //.........
        }
    })

class MainActivity : AppCompatActivity() {

    ...

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        .....

        findViewById<Button>(R.id.btn3).setOnClickListener {
            //SecondActivity 를 실행하기 위한 인텐트 객체 생성
            val intent: Intent = Intent(this, SecondActivity::class.java)
            
            //결과를 받아 돌아오는 ActivityResultLauncher 실행객체로 SecondActivity 실행!
            //resultLauncher.launch(intent)   
            
            resultLauncher3.launch(intent)
        }
        
    }//onCreate method


    // SAM 변환 완성
    val resultLauncher3: ActivityResultLauncher<Intent> = registerForActivityResult(
        ActivityResultContracts.StartActivityForResult()){
        if(it?.resultCode== RESULT_OK){
            //.........
        }
    }
    
}//MainActivity class

//주 생성자 - 클래스명 옆에 constructor 키워드로 추가. 파라미터에 var or val 키워드를 추가하면 멤버변수 면서 매개변수가 됨.
//## RecyclerView.Adapter 상속 ##
class MyAdapter constructor(val context: Context, val items:MutableList<Item>) : RecyclerView.Adapter<MyAdapter.VH>(){

    .........

    //3] 아이템뷰에 Item 데이터 연결해주는 기능 : 현재 만들어야 할 position 번째 Item의 값을 뷰홀더의 멤버인 자식뷰들에 설정
    override fun onBindViewHolder(holder: VH, position: Int) {

        val item= items.get(position)  //현재 아이템뷰에 보여줄 Item 데이터 얻어오기

        holder.tvTitle.setText(item.title)  // 현재 아이템뷰의 제목을 보여주는 텍스트뷰에 [제목] 설정
        holder.tvMsg.text= item.msg         // 현재 아이템뷰의 메세지를 보여주는 텍스트뷰에 [메세지] 설정

        //holder.iv.setImageResource(item.img) // 현재 아이템뷰의 이미지를 보여주는 이미지뷰에 [도시 이미지] 설정
        // 이미지 로딩 라이브러리 Glide 로 이미지 설정
        Glide.with(context).load(item.img).into(holder.iv)
        
        //---------------------------------------------------------

        //SAM conversion 이용하여 이벤트처리
        holder.itemView.setOnClickListener{ v ->

            // ItemActivity 를 실행하기 위한 Intent 객체 생성
            val intent= Intent(context, ItemActivity::class.java)
            
            // 액티비티 전환할 때 Item 데이터 전달을 위해 Intent 에 Extra 데이터 추가
            intent.putExtra("title", item.title)
            intent.putExtra("msg", item.msg)
            intent.putExtra("img", item.img)
            
            // 위 인텐트 객체를 이용하여 ItemActivity 실행
            context.startActivity(intent)

        }
        
    }//onBindViewHolder method....

}//MyAdapter class..

class ItemActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_item)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }

        //넘어온 Intent 객체가 이미 이 액티비티의 property로 존재함
        val title= intent.getStringExtra("title")
        val msg= intent.getStringExtra("msg")
        val img= intent.getIntExtra("img", R.drawable.ic_launcher_foreground) //전달받은 이미지가 없다면 기본 앱아이콘 이미지 보여주기
        
    }//onCreate method..
    
}//ItemActivity class....

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context=".ItemActivity">
    
    <com.google.android.material.appbar.MaterialToolbar
        android:id="@+id/toolbar"
        android:layout_width="match_parent"
        android:layout_height="?attr/actionBarSize"
        android:background="@color/design_default_color_primary"
        app:title="아이템 제목"
        app:titleTextColor="@color/white"
        app:navigationIcon="@drawable/baseline_arrow_back_24"/>

    <ImageView
        android:id="@+id/iv"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:adjustViewBounds="true"
        android:contentDescription="city image"/>

    <TextView
        android:id="@+id/tv"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textColor="@color/black"
        android:padding="8dp"
        android:text="This is message."/>

</LinearLayout>

import android.os.Bundle
import android.widget.ImageView
import android.widget.TextView
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
import com.bumptech.glide.Glide
import com.google.android.material.appbar.MaterialToolbar

class ItemActivity : AppCompatActivity() {

    // 뷰들의 참조변수 3개 준비 - 참조변수의 참조값을 변경할 상황이 거의 없기에 val 키워드로 선언.
    // 초기값을 나중에 수행되도록 늦은 초기화 기법으로 by lazy 사용
    val toolbar: MaterialToolbar by lazy { findViewById(R.id.toolbar) }
    val iv: ImageView by lazy { findViewById(R.id.iv) }

    //tv변수를 만들때 명시적으로 자료형이 주어지지 않으면 대입되는 자료형의 값에 따라 추론처리되는데 findViewById()는 어떤 뷰 객체인지 추론이 불가하기에 <>제네릭으로 타입을 지정하면서 대입해줘야 함
    val tv by lazy { findViewById<TextView>(R.id.tv) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_item)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }

        //넘어온 Intent 객체가 이미 이 액티비티의 property로 존재함
        val title= intent.getStringExtra("title")
        val msg= intent.getStringExtra("msg")
        val img= intent.getIntExtra("img", R.drawable.ic_launcher_foreground) //전달받은 이미지가 없다면 기본 앱아이콘 이미지 보여주기

        // ---- Item 데이터(제목, 메세지, 도시 이미지)를 뷰들에 설정하기 -------------------

        // 툴바에 제목 title 표시
        toolbar.title= title

        // 텍스트뷰에 메세지 msg 표시
        tv.text= msg

        // 이미지뷰에 도시 이미지 img 표시 - 이미지 로드 라이브러리 Glide 사용
        Glide.with(this).load(img).into(iv)
        // ----------------------------------------------------------------------
        
        // 툴바(제목줄)에 뒤로가기 아이콘을 클릭했을 때 이전 화면(MainActivity)로 돌아가기. [ 뒤로가기 디스패처에게 뒤로가기 동작 실행 요청 ]
        toolbar.setNavigationOnClickListener { onBackPressedDispatcher.onBackPressed() }


    }//onCreate method..

}//ItemActivity class....

import android.content.Context
import android.content.Intent
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import androidx.core.app.ActivityOptionsCompat
import androidx.core.util.Pair
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide

//주 생성자 - 클래스명 옆에 constructor 키워드로 추가. 파라미터에 var or val 키워드를 추가하면 멤버변수 면서 매개변수가 됨.
//## RecyclerView.Adapter 상속 ##
class MyAdapter constructor(val context: Context, val items:MutableList<Item>) : RecyclerView.Adapter<MyAdapter.VH>(){

    .........

    //3] 아이템뷰에 Item 데이터 연결해주는 기능 : 현재 만들어야 할 position 번째 Item의 값을 뷰홀더의 멤버인 자식뷰들에 설정
    override fun onBindViewHolder(holder: VH, position: Int) {

        val item= items.get(position)  //현재 아이템뷰에 보여줄 Item 데이터 얻어오기

        holder.tvTitle.setText(item.title)  // 현재 아이템뷰의 제목을 보여주는 텍스트뷰에 [제목] 설정
        holder.tvMsg.text= item.msg         // 현재 아이템뷰의 메세지를 보여주는 텍스트뷰에 [메세지] 설정

        //holder.iv.setImageResource(item.img) // 현재 아이템뷰의 이미지를 보여주는 이미지뷰에 [도시 이미지] 설정
        // 이미지 로딩 라이브러리 Glide 로 이미지 설정
        Glide.with(context).load(item.img).into(holder.iv)

        //---------------------------------------------------------

        //SAM conversion 이용하여 이벤트처리
        holder.itemView.setOnClickListener{ v ->

            // ItemActivity 를 실행하기 위한 Intent 객체 생성
            val intent= Intent(context, ItemActivity::class.java)

            // 액티비티 전환할 때 Item 데이터 전달을 위해 Intent 에 Extra 데이터 추가
            intent.putExtra("title", item.title)
            intent.putExtra("msg", item.msg)
            intent.putExtra("img", item.img)

            // 위 인텐트 객체를 이용하여 ItemActivity 실행
            //context.startActivity(intent)

            //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
            //액티비티의 전환시에 뷰들에 연결 효과주기.. ActivityOptions - SceneTransition   [ Pair()객체 - 전화효과를 줄 뷰에게 별칭을 연결.. 실행될 액티비티에서 연결된 뷰도 같은 별칭을 주면 자동으로 전환효과 보여짐 ] - ex. 당근마켓앱에 구현되어 있음.
            val optionsCompat:ActivityOptionsCompat= ActivityOptionsCompat.makeSceneTransitionAnimation(context as MainActivity, Pair(holder.iv, "img")) //context를 Activity로 형변환 - 코틀린에서 클래스들의 형변환 연산자 as
            context.startActivity(intent, optionsCompat.toBundle())

        }

    }//onBindViewHolder method....

}//MyAdapter class..

class ItemActivity : AppCompatActivity() {

    // 뷰들의 참조변수 3개 준비 - 참조변수의 참조값을 변경할 상황이 거의 없기에 val 키워드로 선언.
    // 초기값을 나중에 수행되도록 늦은 초기화 기법으로 by lazy 사용
    val toolbar: MaterialToolbar by lazy { findViewById(R.id.toolbar) }
    val iv: ImageView by lazy { findViewById(R.id.iv) }

    //tv변수를 만들때 명시적으로 자료형이 주어지지 않으면 대입되는 자료형의 값에 따라 추론처리되는데 findViewById()는 어떤 뷰 객체인지 추론이 불가하기에 <>제네릭으로 타입을 지정하면서 대입해줘야 함
    val tv by lazy { findViewById<TextView>(R.id.tv) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContentView(R.layout.activity_item)
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }

        //넘어온 Intent 객체가 이미 이 액티비티의 property로 존재함
        val title= intent.getStringExtra("title")
        val msg= intent.getStringExtra("msg")
        val img= intent.getIntExtra("img", R.drawable.ic_launcher_foreground) //전달받은 이미지가 없다면 기본 앱아이콘 이미지 보여주기

        // ---- Item 데이터(제목, 메세지, 도시 이미지)를 뷰들에 설정하기 -------------------

        // 툴바에 제목 title 표시
        toolbar.title= title

        // 텍스트뷰에 메세지 msg 표시
        tv.text= msg

        // 이미지뷰에 도시 이미지 img 표시 - 이미지 로드 라이브러리 Glide 사용
        Glide.with(this).load(img).into(iv)
        // ----------------------------------------------------------------------

        // 툴바(제목줄)에 뒤로가기 아이콘을 클릭했을 때 이전 화면(MainActivity)로 돌아가기. [ 뒤로가기 디스패처에게 뒤로가기 동작 실행 요청 ]
        toolbar.setNavigationOnClickListener { onBackPressedDispatcher.onBackPressed() }
        
        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        
        //iv 이미지뷰에 전환효과 주기위에 별칭 부여 [ 이전 액티비티에서 ActivityOptions 에서 Pair()로 설정한 별칭과 같은 명칭
        iv.transitionName = "img"


    }//onCreate method..

}//ItemActivity class....

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/recycler"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</androidx.constraintlayout.widget.ConstraintLayout>

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()    //화면 전체를 사용하는 기능
        setContentView(R.layout.activity_main)
        
        //Navigation Bar 의 사이즈만큼 액티비티 패딩 설정.
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }
    }
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)        
        setContentView(R.layout.activity_main) //화면에 보여줄 뷰로 레이아웃 xml 파일 설정
        
    }//onCreate method...
}//MainActivity class.....

class MainActivity : AppCompatActivity() {

    // 뷰 참조변수들은 한번 뷰객체를 참조하면 다른 뷰객체로 바꾸어 참조하는 경우가 거의 없기에 var보다 val을 선호함
    // 이때, 초기화 안하면 에러 - 하지만 recycler의 객체 참조값을 지금 초기화 할 수 없음 [ onCreate() 에서 findViewById()를 해야 하기에..]
    // 그래서 늦은초기화 사용[ lateinit 은 var에만 사용할 수 있기에 by lazy 지연초기화 사용]
    val recycler: RecyclerView by lazy { findViewById(R.id.recycler) }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

    }//onCreate method...
}//MainActivity class.....

//데이터를 저장하는 용도의 클래스 ( 제목, 메세지, 이미지 파일 리소스 경로)
data class Item constructor(var title:String, var msg:String, var img:Int) //- 특별한 기능메소드를 작성할 필요없기에 보통은 {}도 생략함.

class MainActivity : AppCompatActivity() {

    // 리사이클러뷰 참조변수 - 늦은 초기화
    val recycler: RecyclerView by lazy { findViewById(R.id.recycler) }

    //대량의 데이터 property[속성:멤버변수]
    var items= mutableListOf<Item>() //Java의 ArrayList<Item>와 비슷하게 동작
    //var items= arrayListOf<Item>()  //이렇게 ArrayList 객체를 만들어도 됨

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

        //대량의 데이터들 추가 [테스트목적]
        items.add( Item("NEW YORK","Hello. Kotlin", R.drawable.newyork) )
        items.add( Item("PARIS","Nice to meet you", R.drawable.paris) )
        items.add( Item("SYDNEY","Have a good day", R.drawable.sydney) )
        items.add( Item("뉴욕","Do you have fun", R.drawable.newyork) )
        items.add( Item("파리","Nice to meet you", R.drawable.paris) )
        items.add( Item("시드니","Have a good day", R.drawable.sydney) )
        items.add( Item("new york","Do you have fun", R.drawable.newyork) )
        items.add( Item("paris","Nice to meet you", R.drawable.paris) )
        items.add( Item("sydney","Have a good day", R.drawable.sydney) )
        
    }
    
}

<?xml version="1.0" encoding="utf-8"?>
<com.google.android.material.card.MaterialCardView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="160dp"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    app:cardCornerRadius="8dp"
    app:cardElevation="4dp"
    android:layout_margin="12dp">

    <RelativeLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent">

        <ImageView
            android:id="@+id/iv"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:src="@drawable/newyork"
            android:scaleType="centerCrop"/>
        <TextView
            android:id="@+id/tv_title"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="TITLE"
            android:textStyle="bold"
            android:textSize="40sp"
            android:textColor="@color/white"
            android:layout_alignParentRight="true"
            android:layout_margin="16dp"/>
        <TextView
            android:id="@+id/tv_msg"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="This is message"
            android:textColor="@color/white"
            android:textStyle="bold"
            android:textSize="18sp"
            android:layout_alignParentRight="true"
            android:layout_alignParentBottom="true"
            android:layout_margin="16dp"/>

    </RelativeLayout>

</com.google.android.material.card.MaterialCardView>

import android.content.Context

//주 생성자 - 클래스명 옆에 constructor 키워드로 추가. 파라미터에 var or val 키워드를 추가하면 멤버변수 면서 매개변수가 됨.
class MyAdapter constructor(val context: Context, val items:MutableList<Item>){
}

import android.content.Context
import android.view.View
import android.widget.ImageView
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView

//주 생성자 - 클래스명 옆에 constructor 키워드로 추가. 파라미터에 var or val 키워드를 추가하면 멤버변수 면서 매개변수가 됨.
class MyAdapter constructor(val context: Context, val items:MutableList<Item>){

    //아이템뷰 1개의 자식뷰들을 참조하는 참조변수를 저장하는 뷰홀더 클래스 (이너클래스) - 아이템뷰를 생성자 파라미터로 받아서 사용
    inner class VH constructor(itemView: View) : RecyclerView.ViewHolder(itemView){
        // 아이템뷰의 자식뷰( 제목을 보여주는 텍스트뷰, 메세지를 보여주는 텍스트뷰, 이미지를 보여주는 이미지뷰 )
        // by lazy : 지연초기화를 이용하여 자식뷰들 참조
        val tvTitle: TextView by lazy { itemView.findViewById(R.id.tv_title) }
        val tvMsg: TextView by lazy { itemView.findViewById(R.id.tv_msg) }
        val iv: ImageView by lazy { itemView.findViewById(R.id.iv) }
    }
    
}

import android.content.Context
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView

//주 생성자 - 클래스명 옆에 constructor 키워드로 추가. 파라미터에 var or val 키워드를 추가하면 멤버변수 면서 매개변수가 됨. 
//## RecyclerView.Adapter 상속 ##
class MyAdapter constructor(val context: Context, val items:MutableList<Item>) : RecyclerView.Adapter<MyAdapter.VH>(){

    //아이템뷰 1개의 자식뷰들을 참조하는 참조변수를 저장하는 뷰홀더 클래스 (이너클래스) - 아이템뷰를 생성자 파라미터로 받아서 사용
    inner class VH constructor(itemView: View) : RecyclerView.ViewHolder(itemView){
        // 아이템뷰의 자식뷰( 제목을 보여주는 텍스트뷰, 메세지를 보여주는 텍스트뷰, 이미지를 보여주는 이미지뷰 )
        // by lazy : 지연초기화를 이용하여 자식뷰들 참조
        val tvTitle: TextView by lazy { itemView.findViewById(R.id.tv_title) }
        val tvMsg: TextView by lazy { itemView.findViewById(R.id.tv_msg) }
        val iv: ImageView by lazy { itemView.findViewById(R.id.iv) }
    }

    //반드시 구현해야 할 추상 메소드 3개. ------------------------------------------------------------------

    //1] 아이템뷰 생성 기능 : recycler_item.xml 레이아웃 모양의 아이템뷰 객체를 생성하여 뷰홀더에 전달하여 리턴하는 메소드
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
        TODO("Not yet implemented")
    }

    //2] 아답터가 만들 아이템뷰의 총 개수를 리턴하는 기능 : 대량의 데이터인 items 의 개수.
    override fun getItemCount(): Int {
        TODO("Not yet implemented")
    }

    //3] 아이템뷰에 Item 데이터 연결해주는 기능 : 현재 만들어야 할 position 번째 Item의 값을 뷰홀더의 멤버인 자식뷰들에 설정
    override fun onBindViewHolder(holder: VH, position: Int) {
        TODO("Not yet implemented")
    }

}

//1] 아이템뷰 생성 기능 : recycler_item.xml 레이아웃 모양의 아이템뷰 객체를 생성하여 뷰홀더에 전달하여 리턴하는 메소드
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
    val inflater= LayoutInflater.from(context)  //xml 레이아웃 파일 모양으로 뷰 객체를 생성해 주는 객체 소환
    val itemView= inflater.inflate(R.layout.recycler_item, parent, false) //아이템뷰 객체 생성
    val holder= VH(itemView) //아이템뷰의 자식뷰들을 참조해주는 뷰홀더 객체 생성
    return holder //뷰홀더 객체 리턴
}

//2] 아답터가 만들 아이템뷰의 총 개수를 리턴하는 기능 : 대량의 데이터인 items 의 개수.
override fun getItemCount(): Int {
    return items.size  //멤버변수인 대량의 Item 리스트의 총 개수 리턴.
}

//3] 아이템뷰에 Item 데이터 연결해주는 기능 : 현재 만들어야 할 position 번째 Item의 값을 뷰홀더의 멤버인 자식뷰들에 설정
override fun onBindViewHolder(holder: VH, position: Int) {
    
    val item= items.get(position)  //현재 아이템뷰에 보여줄 Item 데이터 얻어오기

    holder.tvTitle.setText(item.title)  // 현재 아이템뷰의 제목을 보여주는 텍스트뷰에 [제목] 설정
    holder.tvMsg.text= item.msg         // 현재 아이템뷰의 메세지를 보여주는 텍스트뷰에 [메세지] 설정

    holder.iv.setImageResource(item.img) // 현재 아이템뷰의 이미지를 보여주는 이미지뷰에 [도시 이미지] 설정
 
}

//3] 아이템뷰에 Item 데이터 연결해주는 기능 : 현재 만들어야 할 position 번째 Item의 값을 뷰홀더의 멤버인 자식뷰들에 설정
override fun onBindViewHolder(holder: VH, position: Int) {

    val item= items.get(position)  //현재 아이템뷰에 보여줄 Item 데이터 얻어오기

    holder.tvTitle.setText(item.title)  // 현재 아이템뷰의 제목을 보여주는 텍스트뷰에 [제목] 설정
    holder.tvMsg.text= item.msg         // 현재 아이템뷰의 메세지를 보여주는 텍스트뷰에 [메세지] 설정

    //holder.iv.setImageResource(item.img) // 현재 아이템뷰의 이미지를 보여주는 이미지뷰에 [도시 이미지] 설정
    // 이미지 로딩 라이브러리 Glide 로 이미지 설정
    Glide.with(context).load(item.img).into(holder.iv)
}

import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.TextView
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide

//주 생성자 - 클래스명 옆에 constructor 키워드로 추가. 파라미터에 var or val 키워드를 추가하면 멤버변수 면서 매개변수가 됨.
//## RecyclerView.Adapter 상속 ##
class MyAdapter constructor(val context: Context, val items:MutableList<Item>) : RecyclerView.Adapter<MyAdapter.VH>(){

    //아이템뷰 1개의 자식뷰들을 참조하는 참조변수를 저장하는 뷰홀더 클래스 (이너클래스) - 아이템뷰를 생성자 파라미터로 받아서 사용
    inner class VH constructor(itemView: View) : RecyclerView.ViewHolder(itemView){
        // 아이템뷰의 자식뷰( 제목을 보여주는 텍스트뷰, 메세지를 보여주는 텍스트뷰, 이미지를 보여주는 이미지뷰 )
        // by lazy : 지연초기화를 이용하여 자식뷰들 참조
        val tvTitle: TextView by lazy { itemView.findViewById(R.id.tv_title) }
        val tvMsg: TextView by lazy { itemView.findViewById(R.id.tv_msg) }
        val iv: ImageView by lazy { itemView.findViewById(R.id.iv) }
    }

    //반드시 구현해야 할 추상 메소드 3개. ------------------------------------------------------------------

    //1] 아이템뷰 생성 기능 : recycler_item.xml 레이아웃 모양의 아이템뷰 객체를 생성하여 뷰홀더에 전달하여 리턴하는 메소드
    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): VH {
        val inflater= LayoutInflater.from(context)  //xml 레이아웃 파일 모양으로 뷰 객체를 생성해 주는 객체 소환
        val itemView= inflater.inflate(R.layout.recycler_item, parent, false) //아이템뷰 객체 생성
        val holder= VH(itemView) //아이템뷰의 자식뷰들을 참조해주는 뷰홀더 객체 생성
        return holder //뷰홀더 객체 리턴
    }

    //2] 아답터가 만들 아이템뷰의 총 개수를 리턴하는 기능 : 대량의 데이터인 items 의 개수.
    override fun getItemCount(): Int {
        return items.size  //멤버변수인 대량의 Item 리스트의 총 개수 리턴.
    }

    //3] 아이템뷰에 Item 데이터 연결해주는 기능 : 현재 만들어야 할 position 번째 Item의 값을 뷰홀더의 멤버인 자식뷰들에 설정
    override fun onBindViewHolder(holder: VH, position: Int) {

        val item= items.get(position)  //현재 아이템뷰에 보여줄 Item 데이터 얻어오기

        holder.tvTitle.setText(item.title)  // 현재 아이템뷰의 제목을 보여주는 텍스트뷰에 [제목] 설정
        holder.tvMsg.text= item.msg         // 현재 아이템뷰의 메세지를 보여주는 텍스트뷰에 [메세지] 설정

        //holder.iv.setImageResource(item.img) // 현재 아이템뷰의 이미지를 보여주는 이미지뷰에 [도시 이미지] 설정
        // 이미지 로딩 라이브러리 Glide 로 이미지 설정
        Glide.with(context).load(item.img).into(holder.iv)
    }

}

class MainActivity : AppCompatActivity() {

    // 뷰 참조변수들은 한번 뷰객체를 참조하면 다른 뷰객체로 바꾸어 참조하는 경우가 거의 없기에 var보다 val을 선호함
    // 이때, 초기화 안하면 에러 - 하지만 recycler의 객체 참조값을 지금 초기화 할 수 없음 [ onCreate() 에서 findViewById()를 해야 하기에..]
    // 그래서 늦은초기화 사용[ lateinit 은 var에만 사용할 수 있기에 by lazy 지연초기화 사용]
    val recycler: RecyclerView by lazy { findViewById(R.id.recycler) }

    //대량의 데이터 property[속성:멤버변수]
    var items= mutableListOf<Item>() //Java의 ArrayList<Item>와 비슷하게 동작
    //var items= arrayListOf<Item>()  //이렇게 ArrayList 객체를 만들어도 됨

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

        //대량의 데이터들 추가 [테스트목적]
        items.add( Item("NEW YORK","Hello. Kotlin", R.drawable.newyork) )
        items.add( Item("PARIS","Nice to meet you", R.drawable.paris) )
        items.add( Item("SYDNEY","Have a good day", R.drawable.sydney) )
        items.add( Item("뉴욕","Do you have fun", R.drawable.newyork) )
        items.add( Item("파리","Nice to meet you", R.drawable.paris) )
        items.add( Item("시드니","Have a good day", R.drawable.sydney) )
        items.add( Item("new york","Do you have fun", R.drawable.newyork) )
        items.add( Item("paris","Nice to meet you", R.drawable.paris) )
        items.add( Item("sydney","Have a good day", R.drawable.sydney) )

        // ----------------------------------------------------------------------------
        
        //리사이클러뷰안에 이미 아답터 프로퍼티(멤버변수)가 있어서 아답터객체를 대입해 주면 됨
        recycler.adapter= MyAdapter(this, items)

    }//onCreate method...
}//MainActivity class.....

class MainActivity : AppCompatActivity() {

    // 뷰 참조변수들은 한번 뷰객체를 참조하면 다른 뷰객체로 바꾸어 참조하는 경우가 거의 없기에 var보다 val을 선호함
    // 이때, 초기화 안하면 에러 - 하지만 recycler의 객체 참조값을 지금 초기화 할 수 없음 [ onCreate() 에서 findViewById()를 해야 하기에..]
    // 그래서 늦은초기화 사용[ lateinit 은 var에만 사용할 수 있기에 by lazy 지연초기화 사용]
    val recycler: RecyclerView by lazy { findViewById(R.id.recycler) }

    //대량의 데이터 property[속성:멤버변수]
    var items= mutableListOf<Item>() //Java의 ArrayList<Item>와 비슷하게 동작
    //var items= arrayListOf<Item>()  //이렇게 ArrayList 객체를 만들어도 됨

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

        //대량의 데이터들 추가 [테스트목적]
        items.add( Item("NEW YORK","Hello. Kotlin", R.drawable.newyork) )
        items.add( Item("PARIS","Nice to meet you", R.drawable.paris) )
        items.add( Item("SYDNEY","Have a good day", R.drawable.sydney) )
        items.add( Item("뉴욕","Do you have fun", R.drawable.newyork) )
        items.add( Item("파리","Nice to meet you", R.drawable.paris) )
        items.add( Item("시드니","Have a good day", R.drawable.sydney) )
        items.add( Item("new york","Do you have fun", R.drawable.newyork) )
        items.add( Item("paris","Nice to meet you", R.drawable.paris) )
        items.add( Item("sydney","Have a good day", R.drawable.sydney) )

        // ----------------------------------------------------------------------------

        //리사이클러뷰안에 이미 아답터 프로퍼티(멤버변수)가 있어서 아답터객체를 대입해 주면 됨
        recycler.adapter= MyAdapter(this, items)

        //리사이클러뷰에 레이아웃매니저 붙이기
        recycler.layoutManager= LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false)

    }//onCreate method...
}//MainActivity class.....

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".IntroActivity">

    <!-- 익명클래스로 리스너 처리   -->
    <Button
        android:id="@+id/btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="go to Main"
        android:layout_centerInParent="true"/>

</RelativeLayout>

class IntroActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()    // 화면전체 사용 ON
        setContentView(R.layout.activity_intro)  // 액티비티가 보여줄 뷰를 설정
        
        //Edge-To-Edge 일때 하단 네비게시션바 사이즈 만큼 패딩 적용
        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }
    }
}

import android.os.Bundle
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat

class IntroActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_intro) //액티비티가 보여줄 뷰 설정
        
    }//onCreate method....
    
}//MainActivity class...

class IntroActivity : AppCompatActivity() {

    var btn:Button   //ERROR - 코틀린은 초기화 없이 멤버변수를 만들 수 없음.
    
    ....
    
 }

class IntroActivity : AppCompatActivity() {

    var btn:Button= findViewById(R.id.btn)    //초기화를 안하면 문법에러 라고 지금 여기서 find를 하면 에러.. 멤버변수가 만들어진 후 onCreate()가 호출되기에 아직 뷰가 만들어지지 않았음.
   
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_intro) //이때 xml 레이아웃파일의 뷰 객체들이 생성됨.
        
    }
}

class IntroActivity : AppCompatActivity() {

    var btn: Button?= null      //이렇게 시작은 null 값으로 지정 [nullable type]

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_intro)

        //btn 참조하기
        btn= findViewById(R.id.btn)
        
    }//onCreate method....
}//IntroActivity class........

class IntroActivity : AppCompatActivity() {

    var btn: Button?= null      //이렇게 시작은 null 값으로 지정 [nullable type]

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_intro)

        //btn 참조하기
        btn= findViewById(R.id.btn)
        
        //Button?타입이기에 null safe 연산자 ?. 사용
        btn?.setOnClickListener(object : View.OnClickListener{  //익명클래스 사용해보기
            override fun onClick(p0: View?) {
                
            }
        })
        
    }//onCreate method....
}//IntroActivity class........

class IntroActivity : AppCompatActivity() {

    var btn: Button?= null      //이렇게 시작은 null 값으로 지정 [nullable type]

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_intro)

        //btn 참조하기
        btn= findViewById(R.id.btn)
        
        //Button?타입이기에 null safe 연산자 ?. 사용
        btn?.setOnClickListener(object : View.OnClickListener{  //익명클래스 사용해보기
            override fun onClick(p0: View?) {
                //MainActivity로 전환
                val intent: Intent = Intent(this@IntroActivity, MainActivity::class.java)
                startActivity(intent)
                
            }
        })
        
    }//onCreate method....
}//IntroActivity class........

<?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:id="@+id/main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".IntroActivity">

    <!-- 익명클래스로 리스너 처리   -->
    <Button
        android:id="@+id/btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="go to Main"
        android:layout_centerInParent="true"/>


    <!-- (람다표현)으로 클릭이벤트 처리   -->
    <Button
        android:id="@+id/btn2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="16dp"
        android:layout_alignParentRight="true"
        android:text="EXIT"
        android:backgroundTint="#FFFF3300"/>

</RelativeLayout>

class IntroActivity : AppCompatActivity() {

    var btn: Button?= null      //이렇게 시작은 null 값으로 지정 [nullable type]

    //늦은 초기화 lateinit
    lateinit var btn2: Button
    
    ....
    
}//IntroActivity class.....

class IntroActivity : AppCompatActivity() {

    var btn: Button?= null      //이렇게 시작은 null 값으로 지정 [nullable type]

    //늦은 초기화 lateinit
    lateinit var btn2: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_intro)

        //btn 참조하기
        btn= findViewById(R.id.btn)
        //Button?타입이기에 null safe 연산자 ?. 사용
        btn?.setOnClickListener(object : View.OnClickListener{  //익명클래스 사용해보기
            override fun onClick(p0: View?) {
                val intent: Intent = Intent(this@IntroActivity, MainActivity::class.java)
                startActivity(intent)
            }
        })

        //btn2 참조하기 [lateinit - 늦은초기화 문법으로 ] 
        btn2= findViewById(R.id.btn2)  //이때 초기화 됨
        
    }//onCreate method...
    
}//IntroActivity class...

package com.kitesoft.kotlinrecyclerviewapp

import android.content.Intent
import android.os.Bundle
import android.view.View
import android.widget.Button
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat

class IntroActivity : AppCompatActivity() {

    var btn: Button?= null      //이렇게 시작은 null 값으로 지정 [nullable type]

    //늦은 초기화 lateinit
    lateinit var btn2: Button

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_intro)

        //btn 참조하기
        btn= findViewById(R.id.btn)
        //Button?타입이기에 null safe 연산자 ?. 사용
        btn?.setOnClickListener(object : View.OnClickListener{  //익명클래스 사용해보기
            override fun onClick(p0: View?) {
                val intent: Intent = Intent(this@IntroActivity, MainActivity::class.java)
                startActivity(intent)
            }
        })

        //btn2 참조하기 [lateinit - 늦은초기화 문법으로 ]
        btn2= findViewById(R.id.btn2)

        //리스너 설정을 람다 표기법을 이용하면 더 쉽게 코딩 가능. 단, 그 리스너 인터페이스의 추상메소드가 1개일 때[단일 추상 메소드 : SAM (Single Abstract Method]변환으로 구현 가능
        btn2.setOnClickListener {
            finish()   //액티비티 종료
        }
    }//onCreate Method...

}//MainActivity class...

//시작 함수
fun main(){


}//main 함수 종료..

// [이름, 이동기능]이 설계된 클래스. [ open class 가 아님. 더이상 상속 불가한 클래스 ]
class Robot{

    var name:String?= null

    fun move(){
        println("아장 아장 이동.")
    }

}//------------------------------

//시작 함수
fun main(){

    // Robot 객체 생성
    val robot= Robot()
    // 원래 있는 메소드 호출
    robot.move()
    
}//main 함수 종료..

// [이름, 이동 기능]이 설계된 클래스. [ open class 가 아님. 더이상 상속 불가한 클래스 ]
class Robot{

    var name:String?= null

    fun move(){
        println("아장 아장 이동.")
    }

}//------------------------------


//**출력**
아장 아장 이동.

// Robot 에게 attack(공격) 가능 추가 하기
// [상속을 통한 기능 추가 시도]
class MyRobot : Robot(){ //error -  final class Robot 은 상속 불가.

}

// [이름, 이동 기능]이 설계된 클래스. [ open class 가 아님. 더이상 상속 불가한 클래스 ]
class Robot{

    var name:String?= null

    fun move(){
        println("아장 아장 이동.")
    }

}//------------------------------


// Robot 에게 attack(공격) 가능 추가 하기

// [확장 함수 만들기]  -- 클래스명.함수명  으로 새로운 함수 제작
fun Robot.attack(){
    println("주먹 발사!!")
}

//시작 함수
fun main(){

    // Robot 객체 생성
    val robot= Robot()
    // 원래 있는 메소드 호출
    robot.move()

    // 원래 class 작성할 때는 없던 확장 함수 호출. -- 호출의 문법적 차이는 없음.
    robot.attack()

}//main 함수 종료..

// [이름, 이동 기능]이 설계된 클래스. [ open class 가 아님. 더이상 상속 불가한 클래스 ]
class Robot{

    var name:String?= null

    fun move(){
        println("아장 아장 이동.")
    }

}//------------------------------


// Robot 에게 attack(공격) 가능 추가 하기

// [확장 함수 만들기]  -- 클래스명.함수명  으로 새로운 함수 제작
fun Robot.attack(){
    println("주먹 발사!!")
}


//**출력**
아장 아장 이동.
주먹 발사!!

// [확장 함수 만들기2 - 멤버 변수 사용해 보기 (이름을 매개변수로 전달받아 멤버변수에 대입하기)]
fun Robot.fly(name: String){
    this.name= name
    println("${this.name} 난다~~ 난다~~~")
}

//시작 함수
fun main(){

    // Robot 객체 생성
    val robot= Robot()
    // 원래 있는 메소드 호출
    robot.move()

    // 원래 class 작성할 때는 없던 확장 함수 호출. -- 호출의 문법적 차이는 없음.
    robot.attack()

    // 파라미터 값 전달 및 멤버변수를 사용하는 확장함수 호출
    robot.fly("옵티머스 프라임")

}//main 함수 종료..

// [이름, 이동 기능]이 설계된 클래스. [ open class 가 아님. 더이상 상속 불가한 클래스 ]
class Robot{

    var name:String?= null

    fun move(){
        println("아장 아장 이동.")
    }

}//------------------------------


// Robot 에게 attack(공격) 가능 추가 하기

// [확장 함수 만들기]  -- 클래스명.함수명  으로 새로운 함수 제작
fun Robot.attack(){
    println("주먹 발사!!")
}

// [확장 함수 만들기2 - 멤버 변수 사용해 보기 (이름을 매개변수로 전달받아 멤버변수에 대입하기)]
fun Robot.fly(name: String){
    this.name= name
    println("${this.name} 난다~~ 난다~~~")
}

//**출력**
아장 아장 이동.
주먹 발사!!
옵티머스 프라임 난다~~ 난다~~~

//시작 함수
fun main(){

    // Kotlin APIs 로 제공되는 final class String 에 새로운 확장 함수 사용하기!
    "안녕하세요.".twicePrint()

}//main 함수 종료..

// String 클래스에 새로운 기능 추가!!
fun String.twicePrint(){
    println("$this $this")
}

//시작 함수
fun main(){

    // 제네릭 사용 클래스에 확장 함수 사용하기!
    val scores= listOf(90,88,75,68,95,100)
    val total= scores.total()
    println("성적 총합 : $total")    

}//main 함수 종료..

// 제네릭 타입에 확장함수 추가하기 - 정수값들을 가진 리스트의 총합을 구해서 리턴해주는 기능 추가!!
fun List<Int>.total():Int{
    var total:Int=0
    this.forEach { total += it }
    return total
}


//**출력***
성적 총합 : 516

// 같은 리스트여도 제네릭 타입이 다르면 확장함수 사용 불가
val scores2= listOf(60.5, 43.5, 66.7)
val total2= scores2.total() //error - 확장함수 안됨..

//시작함수
fun main(){


}//main 함수 종료...

//어떤 그룹의 크루원 정보 저장 클래스 
class Crew{
    
    //property [ 이름, 나이, 주소 ]
    var name:String?= null
    var age:Int?= null
    var address:String?= null

    //method - property 출력 기능
    fun show(){
        println("$name : $age , $address")
    }
}

//시작함수
fun main(){

    //Crew클래스 객체 생성 및 멤버 여러개를 사용해보기
    val crew= Crew()    
    crew.name="sam"
    crew.age= 20
    crew.address="seoul"
    crew.show()

}//main 함수 종료...

//어떤 그룹의 크루원 정보 저장 클래스 
class Crew{
    
    //property [ 이름, 나이, 주소 ]
    var name:String?= null
    var age:Int?= null
    var address:String?= null

    //method - property 출력 기능
    fun show(){
        println("$name : $age , $address")
    }
}

//**출력**
sam : 20 , seoul

//시작함수
fun main(){

    //Crew클래스 객체 생성 및 멤버 여러개를 사용해보기
    val crew= Crew()    
    crew.name="sam"
    crew.age= 20
    crew.address="seoul"
    crew.show()
    
    //스코프 함수로 멤버 여러개 사용해보기
    var crew2= Crew()
    crew2.apply {
        //이 apply{} 영역 안에서는 this가 crew2를 의미함. 또한 this는 생략이 가능함
        this.name= "robin"
        age= 25
        address="busan"
        show()
    }

}//main 함수 종료...

// 원래는 이런식으로 객체생성후 apply 라는 이름의 함수를 추가하는 것임( 일종의 확장함수 ) -- 이를 람다식처럼 줄여서 ()를 생략한 문법임
crew2.apply(){
}

//시작함수
fun main(){

    //Crew클래스 객체 생성 및 멤버 여러개를 사용해보기
    val crew= Crew()    
    crew.name="sam"
    crew.age= 20
    crew.address="seoul"
    crew.show()
    
    //스코프 함수로 멤버 여러개 사용해보기
    var crew2= Crew()
    crew2.apply {
        //이 apply{} 영역 안에서는 this가 crew2를 의미함. 또한 this는 생략이 가능함
        this.name= "robin"
        age= 25
        address="busan"
        show()
    }
    
    //영역안에서 it을 사용하는 스코프 함수
    val crew3= Crew()
    crew3.also {
        // also{} 영역 안에서는 it이 crew3을 의미함. it은 생략 불가
        it.name= "hong"
        it.age= 30
        it.address="paris"
        it.show()
    }

}//main 함수 종료...

// 1.1) apply - 본인객체를 return
val crew4:Crew= Crew()
val crew5:Crew= crew4.apply {
    name="kim"   //this. 키워드 생략 가능
    age= 40
    address="newyork"
    //별도의 리턴 명시가 없지만 무조건 return this 인것임
}
crew5.show()

// 1.2) run - 마지막 실행문이 return 값
val crew6:Crew= Crew()
val len= crew6.run {
    name="park"
    age= 45
    address="tokyo"
    name?.length //마지막 실행문이 리턴값  - 글자수 4 리턴됨
}
println("이름의 글자수 : $len")

//2.1) also - it 키워드를 사용하며 본인객체를 return
val crew7:Crew= Crew()
val crew8:Crew= crew7.also {
    it.name="lee"
    it.age= 50
    it.address="incheon"
    //별도의 리턴 명시가 없지만 무조건 return this 인것임
}
crew8.show()

//2.2) let - it 키워드를 사용하며 마지막 실행문이 return 값
val crew9:Crew= Crew()
val n:String?= crew9.let {
    it.name="choi"
    it.age=20
    it.address="LA"
    it.name?.uppercase()  //마지막 실행문의 결과가 리턴   -- 이름을 대문자로 변경한 결과값 "CHOI" 리턴됨
}
println("이름의 대문자 출력 : $n")

//** scope function 중 run과 비슷한 동작을 하는 with가 있음. 사용문법이 약간 다름.... **
val crew10:Crew= Crew()
with(crew10){      //범위 안에 객체를 파라미터로 전달받는 형태
    name="aaa"
    age=20
    address="HANOI"
    show()
    name?.lowercase()  //리턴값을 마지막 실행문의 결과
}

val builder:AlertDialog.Builder= AlertDialog.Builder(this)
builder.setTitle("aaa")
builder.setMessage("bbbb")
builder.setPositiveButton("OK", null)
builder.setNegativeButton("CANCEL", null)
val dialog=builder.create()
dialog.show()

val builder2:AlertDialog.Builder= AlertDialog.Builder(this)
val dialog2= builder2.run{
    setTitle("sss")
    setMessage("asdfasdfa")
    setPositiveButton("확인", null)
    setNegativeButton("취소", null)
    create()      // 빌더가 생성하는 dialog 객체가 리턴됨
}
dialog2.show()

var s1:String  = null //ERROR - non nullable 변수

var s2:String? = null //OK  - nullable 변수

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type

}

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type
    
    //non nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력하기
    println("글자수 : " + str1.length)    // OK :   . 연산자를 통해 String객체의 멤버 접근하여 사용

}

//**출력**
글자수 : 5

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type
    
    //non nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력하기
    println("글자수 : " + str1.length)    // OK :   . 연산자를 통해 String객체의 멤버 접근하여 사용
    
    //nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력시도하기
    println("글자수 : " + str2.length)  // ERROR :  String? 타입은 null 일 수도 있다는 것이기에 . 연산자가 언제나 안전하게 멤버를 가져올 수 있다고 확신할 수 없음 - 실제 null 이 아니어도 사용불가 [ 객체가 없을때 NullPointException 발생 ]

}

fun main(){

    //null 값을 저장할 수 없는 변수와 있는 변수.
    var str1:String = "Hello"   // non nullable type
    var str2:String? = "Nice"   // nullable type
    
    //non nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력하기
    println("글자수 : " + str1.length)    // OK :   . 연산자를 통해 String객체의 멤버 접근하여 사용
    
    //nullable 변수가 참조하는 문자열 객체의 글자수(길이) 출력시도하기
    //println("글자수 : " + str2.length)  // ERROR :  String? 타입은 null 일 수도 있다는 것이기에 . 연산자가 언제나 안전하게 멤버를 가져올 수 있다고 확신할 수 없음 - 실제 null 이 아니어도 사용불가 [ 객체가 없을때 NullPointException 발생 ]
    
    //해결방법 - null인지 확인하는 if문 코드 필요
    if(str2!=null) println("글자수 : " + str2.length) //if문이 참일때만 실행되는 영역이어서 String?도 사용가능함.

}

//**출력**
글자수 : 5
글자수 : 4

println("글자수 : " + str2?.length)  // null이 아니면 멤버에 접근, null이면 그냥 null 을 결과로 줌

//**출력**
글자수 : 4

str2= null;
println("글자수 : " + str2?.length)  // null 출력

//**출력**
글자수 : null

val len= if(str2!=null) str2.length else -1
println(len)

//**출력**
-1

val len2= str2?.length ?: -1   // ?: 연산자 뒤에 null일때 원하는 값을 지정
println(len2)

//**출력**
-1

var ss:String?= "Hello"
//println( ss.length )  //ERROR - String? 타입은 NPE 발생이 안되도록 문법적으로 못쓰도록 하고 있음
println( "글자수 : " + ss!!.length  )

//**출력**
글자수 : 5

//null참조객체
val sss:String?= null
println( "글자수 : " + sss!!.length  ) //Exception -- 실행 중 예외발생

//**출력**
Exception in thread "main" java.lang.NullPointerException

//시작 함수..
fun main(){

}// main() 함수 종료..

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}

fun main(){

    val mmm:MMM= MMM()

    //전혀 다른 타입 참조변수에 대입
    val zzz:ZZZ= mmm       //문법적으로 error - 타입이 전혀 다르므로.
    
}

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}

fun main(){

    val mmm:MMM= MMM()

    //전혀 다른 타입 참조변수에 대입
    //val zzz:ZZZ= mmm       //문법적으로 error - 타입이 전혀 다르므로.
    
    //억지로 as 연산자를 통해 형변환
    val zzz:ZZZ = mmm as ZZZ  //문법적으로는 error가 없지만 Class cast Exception 발생함!
    
}

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}

fun main(){

    val mmm:MMM= MMM()

    //전혀 다른 타입 참조변수에 대입
    //val zzz:ZZZ= mmm       //문법적으로 error - 타입이 전혀 다르므로.
    
    //억지로 as 연산자를 통해 형변환
    //val zzz:ZZZ = mmm as ZZZ  //문법적으로는 error가 없지만 Class cast Exception 발생함!
    
    //이때 혹시 잘못된 casting을 해도 예외로 인해 앱이 다운되지 않고 그냥 null을 리턴하는 안전한 캐스팅 연산자 as?
    val zzz:ZZZ? = mmm as? ZZZ?
    println(zzz) // null출력   - 객체가 실제로 캐스팅이 되었다면 [클래스명@해시코드] 가 출력됨
    
}

//4) 안전한 캐스팅 실습용 클래스들
class MMM{
    var a=10
}

class ZZZ{
    val a=20
}