data class Ticket(val companyName : String, val name : String, var dat : String, var seat : Int)

fun main() {
    val ticketA = Ticket("koreaAir", "nana", "2022-07-04",06)
}

toString(), hashCode(), equals(), copy() 컴파일러가 자동으로 생성해 준다.

companion

class Book private constructor (val id:Int, val name:String){
    companion object BookFactory : IdPro{
        override fun getId() : Int {
            return 33
        }
        val myBook = "New name"
        fun create() = Book(getId(),myBook)
    }
}

interface IdPro{
    fun getId() : Int
}

fun main() {
    var book = Book.create()
    println("${book.id} ${book.name}")

}

람다식은 우리가 마치 value처럼 다룰 수 있는 익명 함수이다.

1) 메소드의 파라미터로 넘겨줄 수 있다. 2) return 값으로 사용할 수 있다.

람다의 기본 정의

val lamdaName : Type = {argumentList -> codeBody}

람다 기본 문법

//기본 형식
val square : (Int) -> (Int) = {number -> number*number}
//자료형 선언 
val square = {number : Int -> number*number}
//에러
val square = {number -> number*number}

fun main() {
    println(square(12))
}

코틀린은 자동으로 자료형 추론이 가능하나, 한 쪽에는 무조건 써줘야 한다.

val namgeAge = {name : String, age:Int ->
"my name ${name} I'm ${age}"}

fun main() {
    println(namgeAge("gyoung",21))
}

람다는 무조건 맨 마지막 줄이 return된다.

//람다의 return
val calcul : (Int) -> String = {
    when(it){
        in 0..40 -> "fail"
        in 41..70 -> "pass"
        in 71..100 -> "perfect"
        else -> "Error!"
    }
}

여기서 else가 없다면 에러가 난다. 위에 람다식은 무조건 String을 반환해야 하기 때문에 0~100사이 값이 아닌 값을 넣게 되면 else문을 실행해 String을 반환해야 한다.

fun a(lamda : (Double) -> Boolean) : Boolean {
    return lamda(5.2343)
}

fun main() {  
    val lamda = {number : Double ->
    number == 4.123123
    }
    println(a(lamda))
    println(a({it>3.22})) // a {it>3.22}
}

이름이 없어도 함수 역할을 하는 익명 함수의 하나의 형태이다. 화살표 표기법을 사용하고 고차 함수에서 인자로 넘기거나 결과값으로 반환 등을 할 수 있다. < 사용 예시 > { 변수1 : 타입, 변수2 : 타입 -> 변수1 + 변수 2 }

(타입, 타입) -> 반환형 타입

//이름이 없는 함수 형태
{ x , y -> x + y }

//기본 람다식 구성
val sum : (Int, Int) -> Int = { x : Int, y : Int -> x + y }

//선언 자료형 생략
val sum = { x : Int, y : Int -> x + y }

//매개변수 자료형 생략
val sum : (Int, Int) -> Int = { x , y -> x + y }

//에러.. 자료형 추론 불가
val sum = { x , y -> x + y }

println(sum(3,5)) //8

선언 자료형과 매개변수 자료형 한 쪽이 선언이 되었다면 다른 한 쪽은 생략이 가능하다. x, y 가 람다식의 매개변수이고, x+y가 람다식의 처리 내용이다. 처리 내용이 여러 줄인 경우 마지막 표현식이 반환된다.

고차함수

고차함수는 함수를 인수로 취하거나 혹은 결과로 반환하는 함수를 고차함수라고 한다.

fun sum( a : Int, b : Int, p : (Int, Int) -> Int){
    println("$a, $b -> ${p(a, b)}")
}

//기본 호출
sum(2 , 4, {a : Int, b : Int -> a+b}) //2,4 -> 6

//람다 함수가 맨 마지막에 있다면 뺄 수 있다.
sum(5, 1) {a : Int, b : Int -> a+b} //5,1 -> 6

//고차 함수에 타입이 정의되어있는 경우 타입 생략 가능
sum(3,3) {a,b -> a+b} //3,3 -> 6

sum 함수는 a,b와 두 개의 Int 인자를 받아 하나의 Int 반환값을 내는 함수를 인자로 받아 이를 출력한다.

fun sum(a : Int, b : Int) = a+b

//main
sum(5,3,::sum)
println("$a, $b -> ${p(a, b)}") // 5,3 -> 8

람다함수가 아닌 일반함수를 인자로 넣으려면 일반 함수 앞에 ::를 붙여 사용한다.

fun sum(a : Int, p: (Int) -> Int){
    println($a -> ${p(a)}")
}

//main
Square(3) {it * it} //square 3 -> 9

고차함수의 인자가 하나인 경우 it을 사용해 간단하게 사용할 수 있다.

인터페이스

클래스와 인스턴스에 대한 개념부터 본다면 클래스는 객체가 갖는 속성이나 메서드를 하나의 캡슐로 만들어주는 역할을 한다. 클래스로부터 만들어진 인스턴스 객체가 기능을 실행하도록 하려면 그 객체의 메서드를 호출해야 한다. 객체를 사용할 때에는 다른 곳에서 해당 인스턴스 객체를 호출할 수 만 있다면 그 객체가 가진 모든 캡슐 안의 기능들(속성, 메서드)를 사용할 수 있다. 이 캡슐안의 기능들을 사용하기 위해, 캡슐에 접근하는 방법을 인터페이스라고 볼 수 있다.

추상클래스

추상클래스는 아직 구현되지 않고 선언만 된 추상메서드를 가지고 있는 클래스이다. 추상클래스는 메서드가 구현되지 않아서 이 클래스를 직접 객체로 만들 수 없다. 반드시 상속을 받는 자식 클래스가 있어야 한다. 추상클래스는 상속을 통해 생성될 자식 클래스에서 메서드 오버라이딩에 강제성을 부여하기 위해 사용된다.

용어

프로퍼티

class Person {
    var name: String = "Jordan"
    val age: Int = 20
}

위 코드에서 name, age를 프로퍼티라고 부른다. 변수처럼 보이지만 이미 접근자라고 부르는 getter/setter와 같은 함수가 내장되어 있기 때문에 프로퍼티라고 부른다

매개변수

fun sum(a : Int, b : Int)

a,b가 매개변수이다.

인자

sum(3,6)

3,6이 인자이다.

const

const는 함수나 어떤 클래스의 생성자에게도 결코 할달 될 수 없고 오직 문자열이나 기본 자료형으로 할당되어야 한다.때문에 const 로 선언을 하면 클래스의 프로퍼티나 지역변수로 할당 할 수 없게 된다. 일반적으로 companion object 안에 상수로 선언하게 된다.

상속

상속하는 클래스를 부모클래스(Super Class)라고 하고 상속을 받는 클래스를 자식클래스(Sub Class)라고 한다. 부모클래스를 상속받은 자식클래스는 부모의 변수나 메서드를 자기 것 처럼 사용할 수 있다.

open class Super{
    var superNum = 5;

    fun superMethod() { 
        println("Super Class Method $superNum")
    }
}

class Sub : Super {
    var subNum = 1;

    //부모클래스를 호출하는 생성자를 꼭 만들어 줘야함
    constructor() : super()

    fun subMethod() {
        println("Sub Class Method $subNum")
    }
}

부모클래스에는 open 키워드를 사용해줘야 한다. 자식클래스에서 부모클래스를 호출하는 생성자를 꼭 만들어줘야한다. 부모클래스를 호출하는 방법은 super() 메서드를 사용하면 된다.

DAO(Data Access Object)

repository package

1. 실제로 DB에 접근하는 객체이다.

DTO(Data Transfer Object)

dto package

1. 계층간 데이터 교환을 위한 객체이다.

-DB에서 데이터를 얻어 Service나 Controller등으로 보낼 때 사용하는 객체를 말한다. -> DB의 데이터가 Presentation Logic Tier로 넘어오게 될 때는 DTO의 모습으로 변해서 오고가는 것이다.

VO(Value Object)

DTO와 동일한 개념이지만 read only속성을 갖는다.

Entity Class

domain package 실제 DB의 테이블과 매칭될 클래스

1. @Entity, @Column, @Id 등을 이용한다.

List

list는 값을 바꿀 수 있는 가변형 mutableListOf()와 값을 바꿀 수 없는 불변형 listOf()로 나눠진다.

//가변형 list
val str : List<String> = mutableListOf("one", "two" ,"three" ,"four" ,"five")

//불변형 list
val num : List<Int> = listOf(1,2,3,4,5) 

요소에 접근하기

val str = listOf("one", "two" ,"three" ,"four" ,"five")

for(strNumber in str.indices)
    println("str[$strNumber] = ${str[strNumber]}")
//str[0] = one
//str[1] = two
//str[2] = three
//str[3] = four
//str[4] = five

가변형 list - arrayListOf()

//arrayList선언
val str : ArrayList<String> = arrayListOf("one", "two" ,"three" ,"four" ,"five")

str.add("six") //추가
str.remove("three") //삭제

printle(str)
//[one, two, four, five, six]

가변형 헬퍼 함수를 사용하면 요소를 추가/삭제할 수 있는 list를 선언할 수 있고 반환형은 자바의 ArrayList이다.

가변형 list - mutableListOf()

val str : mutableList<String> = mutableListOf("a","b","c","d")
str.add("e") //추가
str.removeAt(2) //두 번째 요소 삭제
srt[1] = "w" //1번 요소 변경
println(str)
//[a, w, d, e]

list 기본 함수

size() - 리스트의 사이즈(갯수)를 반환 get(index) - 해당 인덱스 요소를 가져옴 indexOf(Element) - 해당 요소의 인덱스 번호를 반환 contains(Element) - 해당 요소를 확인 후 있으면 true 없으면 false 반환 isEmpty() - 리스트가 비어있으면 true 아니면 false 반환

자바가 사용되고 있는 모든 용도에 적합하면서도 간결하고, 생산적이며 안전한 대체 언어를 제공 장점 간결하고 실용적 자바 코드와의 상호운용 대부분의 자바 프로젝트에서 코틀린 사용 가능(안드로이드, 서버 개발) 자바와 비슷한 성능 안전성(null체크, 타입 검사와 캐스트)

코틀린 기본 문법

변수 선언 방법

1.즉시 대입(타입 선언)

val a:Int = 1

2.즉시 대입(타입 체크)

val a = 1

3. 선언 후 초기화

   val a:Int 
   a = 1

   선언 후 나중에 초기화해야 할 때에는 타입을 static하게 정해놓고 사용해야 한다.

함수 선언 방법

1. 기본 함수 선언

   fun sum1(a : Int, b: Int) : Int// 리턴 타입 {
    return a+b //리턴 값
   }

2. 괄호, return type, return 생략

   fun sum2(a : Int, b: Int) = a+b

3. 아무 리턴값을 반환 하지 않는다는 표현은 :Unit 으로 함수 리턴타입을 붙일 수도 있고, 생략이 가능하다

   fun printSum(a: Int, b: Int): Unit {
    println("sum of $a and $b is ${a + b}")
   }
   

fun printSumNoUnit(a: Int, b: Int) { println("sum of $a and $b is ${a + b}") }

## 문자열 템플릿

fun string_template() { var a = 1 val s1 = "a is $a" println(s1) //a is 1

a = 2
val s2 = "${s1.replace("is", "was")}, but now is $a" 
println(s2) //a was 1, but now is 2

}

변수 a는 문자열안에서 $기호를 붙여 값을 대입하여 사용할 수 있다. 또한 ${} 안에서 문자열 s1는 자신의 인스턴스 메소드를 사용할 수 있다.

## 조건식
1. 기본 조건식

fun maxOf(a: Int, b: Int): Int { if (a > b) { return a } else { return b } }

2. return문 생략 조건식

fun maxf2(a: Int, b: Int) = if(a>b) a else b

if(a>b) return a
else return b

## null값과 null체크
엘비스 연산자 ?:

class Elvis{ var na : String? = null

fun elvis(){ var name1 : String = na ?: "NA" //na는 현재 null 이기 때문에 name1에는 NA가 들어간다. var name2 : String = na ?: return //na는 현재 null 이기 때문에 함수 자체를 return 시킨다. var name3 : String = na ?: throw NullPointerException() //na는 현재 null 이기 때문에 NullPointerException 예외가 발생한다.

```

var 변수 이름 : 변수 타입 = true ?: false

${str?.length ?: -1} str이 null이라면 -1 반환 아니라면 length 반환 if(str != null) str.length else -1 와 똑같은 문장이다

map()함수는 흔히 사용하는 for문과 비슷하다. 각 배열의 요소를 돌면서 인자로 전달된 함수를 사용하여 처리된 새로운 결과를 새로운 배열에 담다 반환하는 함수이다.

cosnt result = array.map((index) => index * 2);

array는 map()함수로 돌릴 배열 index는 map()함수로 돌린 배열의 요소값 result는 map()함수 내에서 처리된 값들을 배열로 저장

const array = [1,2,3,4,5];
cosnt result = array.map((index) => index * 2);
console.log(result); -> 2,4,6,8,10

1. 무조건 태그를 닫아줘야 한다. <div></div> 혹은 셀프 클로징 태그</input>를 사용한다.

2. 두개 이상의 엘리먼트는 무조건 하나의 엘리멘트로 감싸져있어야 한다. div 태그도 좋지만 <Fragment> 태그를 사용하면 불필요한 div태그를 줄일 수 있다.

3. JSX내부에서 자바스크립트 값을 사용할때에는 { } 로 감싸준다.

4. Let, const 는 scope가 블럭 단위로 되어있고, var는 함수 단위다. const - 한번 선언 후 고정적인 값 let - 유동적인 값

5. 조건부 렌더링

• { 조건 ? True : false }
• { 조건 && true }

6. 스타일 적용 -> 객체 형태로 적용 , 카멜케이스(ex. background-color -> backgroundColor)
7. JSX 내부 주석 { /* 주석 */ } 으로 감싸주기, 태그 내부에서도 //로 주석 처리 가능

Props / State

Props

부모 컴포넌트가 자식 컴포넌트에게 값을 전달해 줄 때 사용한다. 함수형 -> 초기 마운트 속도가 미세하게 빠름, 메모리 자원도 적게 사용함

State

컴포넌트 안에 있으면서, 내부에서 변경할 수 있다 -> setState() 사용[ 사용하지 않으면 리렌더링이 일어나지 않아서 값이 안바뀜!]

lifecycle

Mounting(컴포넌트가 브라우저에 나올 때)

Constructor 생성자 함수로 만든 컴포넌트가 브라우저에 나올 때 가장 먼저 실행되는 함수 초기 설정, 미리 작업해야하는 일이 있을 때 사용 getDerivedStateFromProps porps를 state에 동기화 해야할 때 Updating과정에서도 props가 바뀔 때 실행된다 Render DOM, 내부 태그 전달 값 등을 정의 ComponentDidMount 외부 라이브러리 같은 걸 가져와야할 때 사용 컴포넌트가 나타날 때 시간 주기? 이벤트 리스닝할 때

Updating(컴포넌트의 props/state가 바뀌었을 때)

getDerivedStateFromProps shouldComponentUpdate 최적화 할 때 부모가 렌더링 되면 자식도 렌더 함수가 실행되는데 이 때 자원 낭비를 막기 위해서 렌더를 막을 수 있다 true/false를 반환할 수 있다. -> 렌더를 막을 수 있다. Render getSnapshotBeforeUpdate 렌더링 후 결과가 브라우저에 반영되기 바로 직전에 호출 디자인적인 요소들, 사전에 가져와야 할 데이터들을 사용할 때 componentDidUpdate
컴포넌트가 업데이트 되었을 때 호출됨 state가 바뀌었을 때 과거 데이터와 새로운 데이터를 비교할 때 사용할 수 있다.

Unmounting(컴포넌트가 브라우저에서 사라질 때)

componentWillUnmount 컴포넌트가 사라지는 과정에서 호출 리스너를 삭제할 때 사용가능

Key는 고유 번호같은 느낌, 데이터를 추가/삭제할 때 효율적으로 사용 할 수 있음

<div v-if="data == 1">
내가 보여요
<div>

data가 1일때만 내가 보여요라는 문구가 보여진다.

비동기 처리 패턴 async현재 사용할 함수를 비동기로 처리하겠다는 선언자. await는 비동기로 순차 처리하기 위해서 수행할 API에 붙이는 선언자.

async testFunction() {
    const response = await axios.get('api/test')
    console.log(response)
}

렌더링이 일어날 때마다 항상 함수를 실행한다.

Computed

호출하는 부분을 감시하고 있다가 값이 변경되면 다시 계산하고 자동으로 캐싱해주는 '끝내주는 반응형'이다. computed에 정의하는 익명함수는 반드시 값을 리턴하도록 작성되야한다.

계산해야하는 목표 데이터를 정의 하는 ‘선언형’ 프로그래밍 방식. 저장된 결과(캐싱)를 반환하므로 종속 대상의 변경이 일어나기 전까지 호출 되지 않는다.

Method와 Computed 의 차이

computed는 data속성에 변화가 있을 때 자동으로 다시 연산을 한다.

computed에서 사용하고 있는 data속성인 message라는 프로퍼티가 변화가 있을때만 다시 연산을하고 한번 연산한 값을 캐싱 해놓았다가 필요한 부분에 다시 재 사용한다. 같은 페이지내에서 같은 연산을 여러번 반복해야 할 경우에 성능면에서 효율적으로 사용할 수 있다.

반면 methods는 캐싱이라는 개념이 없기 때문에 매번 재 렌더링된다. 캐싱 효과가 필요하다면 computed를 사용하고 캐싱이 필요없다면 methods를 사용하도록 하자.

1. template에서 호출시 ()를 적지 않아야 된다.
2. return 값이 반드시 존재해야한다.
3. 파라메터를 받을 수 없다.

Method를 사용해야 할 때.

1. 파라메터를 받아서 호출해야할 때 - data를 사용하지 않는다는 정책을 취한다면 computed로는 아예 불가능하다.
2. 함수 안에서 다른 값을 바꿔줘야할 때 - computed에서는 다른 값을 바꾸는건 정책위반이다. (불가능한건 아니다.) 이 경우 methods를 사용한다.

참고1 참고2

1xx(정보) *: 요청을 받았으며 프로세스를 계속 진행. *2xx(성공) *: 요청을 성공적으로 받았으며 인식 후 수용. *3xx(리다이렉션) *: 요청 완료를 위해 추가 작업 조치 필요. *4xx(클라이언트 오류) : 요청의 문법이 잘못되었거나 요청을 처리할 수 없습니다. *5xx(서버 오류) *: 서버가 명백히 유효한 요청에 대한 충족을 실패했습니다.

1XX : Information responses

상태 코드가 '1'로 시작하는 경우는 서버가 요청을 받았으며, 서버에 연결된 클라이언트는 작업을 계속 진행하라는 의미.

100 Countinue

진행중. 무시해도 무방함.

101 Switching Protocol

클라이언트가 보낸 Upgrade 요청 헤더에 대한 응답에 들어간다. 서버에서 프로토콜을 변경할 것임을 알려줍니다. 해당 코드는 Websocket 프로토콜 전환 시에 사용된다.

102 Processing(WebDAV)

서버가 요청을 수신하였으며 이를 처리하고 있지만, 아직 제대로 된 응답을 알려줄 수 없음.

2XX : Successful responses

200 OK

요청이 성공적.

201 Created

요청이 성공적. 그 결과로 새로운 리소스가 생성되었음. 일반적으로 POST요청 또는 일부 PUT요청 이후 따라온다.

202 Accepted

요청을 수신했지만 행동할 수 없음. 이것은 다른 프로세스에서 처리 또는 서버가 요청을 다루고 있거나 배치 프로세스를 하고 있는 경우를 위해 만들어졌다.

204 No Content

요청에 대해서 보내줄 수 있는 콘텐츠가 없지만, 헤더는 의미있을 수 있다.

4XX : Client error responses

400 Bad Request

잘못된 문법으로 인하여 서버가 요청하여 이해할 수 없음을 의미.

401 Unauthorized

'비인증(unauthenticated)'를 의미. 클라이언트는 요청한 응답을 받기 위해서는 반드시 스스로를 인증해야한다.

403 Forbidden

클라이언트는 콘텐츠에 접근할 권리를 가지고 있지 않다. 예를 들어, 그들은 미승인이어서 서버는 거절을 위한 적절한 응답을 보냅니다. 401과 다른 점은 서버가 클라이언트가 누구인지 알고 있다.

404 Not Found

서버는 요청받은 리소스를 찾을 수 없다.

405 Method Not Allowed

요청한 메소드는 서버에서 알고 있지만, 제거되었고 사용할 수 없다. 예를 들어, 어떤 API에서 리소스를 삭제하는 것을 금지할 수 있습니다. 필수적인 메소드인 GET과 HEAD는 제거될 수 없으며, 이 에러 코드를 리턴할 수 없습니다.

5XX : Server error reponses

500 Internal Server Error

웹 사이트 서버에 문제가 있음을 의미하지만 서버는 정확한 문제에 대해 더 구체적으로 설명할 수 없음.

참고 사이트

const formdata = new FormData();

formData.append('name','data.facilityItem.name');
formData.append('address','data.facilityItem.address');
formData.append('phoneNo','data.facilityItem.phoneNo');

append() 메소드로 key-value 값을 하나씩 추가해주면 된다. 참고 사이트

private 변수를 외부에서 접근하게 하려면 public 메서드를 제공한다. 값을 얻는 get() 메서드를 getter, 값을 지정하는 set() 메서드를 setter라고 한다. 외부 클래스에서 private 멤버 변수에 직접 접근할 수 없지만, public메서드인 setter를 활용하여 값을 대입할 수 있다.

get() method

저장된 멤버변수의 값을 불러올 때 사용하는 메소드이다. 매개변수 X, 반환 값 O ※get()메소드 반환값의 자료형과 멤버변수의 자료형이 같아야 한다.

set() method

데이터를 멤버변수에 저장하는 메소드이다. 매개변수 O, 반환 값 X ※외부에서 접근이 가능해야하기 때문에 public작성, 반환값이 없기 때문에 void로 작성한다.

외부로부터 데이터를 보호하고, 외부에는 불필요한, 내부적으로만 사용되는 부분을 감추기 위해서 사용한다.

public

접근 제한이 전혀 없다

protected

같은 패키지 내에서만 가능하다. 다른 패키지의 자손 클래스에서 접근이 가능하다(상속 시 가능)

default

같은 패키지 내에서만 접근이 가능하다.

private

같은 클래스 내에서만 접근이 가능하다.

접근 범위가 넓은 쪽에서 -> 좁은 쪽으로 나열한다면 public -> protected -> (default) -> private

-일반 클래스와 abstract 클래스 상속에 사용된다.

-부모의 메소드를 그대로 사용할 수 있고, 오버라이딩 할 필요 없이 부모에 구현 돼 있는 것을 직접 사용 가능하다.(상속)

-클래스 한 개만 상속 받을 수 있다. -자신 클래스의 부모 클래스의 기능을 사용한다.

implements

-interface 상속에 사용된다

-부모의 메소드를 반드시 오버라이딩(재정의)해야한다.

-여러개 사용이 가능하다. -implements한 클래스는 implemens의 내용을 다 사용해야 한다.

상속 조건

class -> class = extends interface -> interface = extends class -> interface = implements interface -> class = implements(X)

참고 자바 extends, implements 차이

어노테이션은 엘리먼트(Element)라는 것을 멤버로 가질 수 있다. Element는 타입과 이름으로 구성되며 디폴트값을 가질 수 있다. Element의 이름 뒤에는 메서드를 작성하는 것처럼 뒤에 ()를 꼭 붙여야 한다.

@Entity(tableName = "vehicles")

기본 Element는 value이며 해당 값은 @어노테이션(값)으로 바로 사용 가능하다.

@Transactional

@Transactional이 적용되는 메소드를 하나의 트랜잭션으로 묶어주는 역할이다.

2개 이상의 쿼리를 하나의 커넥션으로 묶어 DB에 전송하고, 이 과정에서 에러가 발생할 경우 자동으로 모든 과정을 Rollback합니다.

클래스 위에 @Transactional이 붙어있으면, 클래스에 속한 모든 메소드에 각각 @Transactional이 적용된다.

-특정 리소스의 표시를 요청한다. GET을 사용하는 요청은 오직 데이터를 받기만 한다. -GET을 사용할 때는 서버에 어떠한 수정도 있으면 안된다.(수정이 없기 때문에 GET Method = safe Methods라고 할 수 있다).

POST

-특정 리소스에 엔티티를 제출할 때 사용한다. -새로운 리소스를 생성하거나 독립적인 명령(Controller)를 실행할 때 사용한다. -정상적으로 생성된 경우 201(Create) HTTP응답 코드를 리턴한다.

PUT

-현재 존재하는 리소스의 전체적인 업데이트를 하는 경우에 사용한다.(만약, 리소스가 존재하지 않는다면 POST의 생성로직으로 새로 만들어도 되며 그렇지 않아도 된다.) -정상적으로 Update되었다면 200(OK) HTTP응답 코드를 리턴한다.

DELETE

-리소스를 삭제하는데 사용된다. 성공적으로 리소스를 삭제했다면, 응답 상태를 body에 담고 있다가 200(OK)으로, 그렇지 않을 경우 202(Accepted)또는 204(No Content)로 응답한다. 그리고 해당 리소스가 없다면 404(Not Found)로 응답해야 합니다.

PATCH

-부분 리소스의 업데이트의 경우 사용한다. -PUT의 경우는 전체적인 업데이트, PATCH의 경우 부분적인 업데이트이다. ※PHP, 톰캣,Django등등 많은 곳에서 지원하지 않는다.

조건

1.메서드 이름이 같아야 한다 2.매개변수의 개수 또는 타입이 달라야 한다.

서로 다른 이름으로 만들지 않아도 되어서 사용하는 쪽에서 부담이 적다.

Overriding

조건

1.자손 클래스에서 오버라이딩하는 메서드는 조상 클래스의 메서드와 이름이 같아야 한다. 2.자손 클래스에서 오버라이딩하는 메서드는 조상 클래스의 매개변수가 같아야 한다. 3.자손 클래스에서 오버라이딩하는 메서드는 조상 클래스의 메서드와 반환 타입이 같아야 한다.

차이점

오버라이딩 - 기존에 없는 새로운 메서드를 추가하는 것 오버로딩 - 조상으로부터 상속받은 메서드의 내용을 변경하는 것

class Parent{
    void parentMethod() {}
}
class Child extends Parent{
    void parentMethod() {} //오버라이딩
    void parentMethod(int i) {}  //오버로딩
}