https://school.programmers.co.kr/learn/courses/30/lessons/12915

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

문자열들을 주어진 기준에 따라 분류하는 문제.

 

String[]을 각 String의 n번째 문자 기준으로 정렬하고, n번째문자가 같은경우 사전순으로 정렬해야한다.

 

정렬이 일어나는 과정에는 반드시 두 요소를 비교할 수 있는 기준이 있어야한다. 따라서 내가 정의한 클래스의 인스턴스들 간의 크기를 비교해줄 수 있게하려면 Comparable 인터페이스를 implement하여, 그 안의 compareTo 메서드를 Override 해주어야한다.

비교하고싶은 객체가 o 라고하자.

o1.compareTo(o2)는 o1이 작을때(왼쪽에있을때) 음수를, o1이 클 때 (오른쪽에있을때) 양수를 리턴해야한다.

String에는 이것이 구현되어있다.

하지만 String을 다른 기준으로 비교하고싶다고 해서 String.compareTo()를 Override할 순 없다. final이기때문에

따라서 이럴 경우 Arrays.sort()나 Collections.sort()에 내가 만든 Comparator를 전달하여 정렬할 수 있다.

cmp를 살펴보면, 먼저 문제에 정의된대로 n번째 인덱스의 character를 비교하고 있다. character는 기본형 변수로 빼기 연산이 가능하고, o1ch가 o2ch보다 앞에와야하면 음수가, 뒤에와야하면 양수가 return된다.

o1ch와 o2ch가 같을 경우, 사전 기준으로 비교해야하기 때문에 String의 compareTo를 사용하여 int를 반환하게 하였다.

 

이 문제에 정의된 방법 상으로 s1이 s2보다 좌측에 와야하면 음수, 우측에 와야하면 양수를 리턴하는 comparator를 전달하여 정렬하였다.

Comparator<type>의 타입은 기본형일 수 없다. 래퍼클래스 이용할것

 

계속 함수나 클래스, 메서드 까먹어서 적는 cheat sheet. 새로운거 배울때마다 업데이트하기 !

<Java>

=== === 내부 : 클래스명

-----  ----- 내부 : 메소드

 

===========내장배열========== 

int[] intArr = {1,2,3,4}

char[] charArr = {'a', 'b', 'c', 'd'}

------------intArr.length() ------------- : 배열의 길이 반환

 

===========Arrays==========   : java.util.Arrays;

List<String // Integer 등등> new_arr = Arrays.asList(String[] // int[] // char[] 등등)

 

------------ Arrays.asList(String[] // Integer[] 등등) ------------- : List<타입> 형태로 반환해줌 :

------------ Arrays.toString() ------------- : 출력할 때 사용 ==> [elem1, elem2, elem3] 의 형식으로 나옴

------------ Arrays.deepToString() -------------  ==> 2차원 배열 출력할 때 사용

------------ Arrays.sort(배열) ------------- : 배열을 정렬해줌. 두번째 파라미터로 Collections.reverseOrder() 넣으면 오름차순

------------ Arrays.copyOfRange(배열, s_index, e_index) ------------- : 배열의 일부를 배열로 copy

------------ Arrays.stream() 시리즈 -------------  ★★★★★슈퍼유용★★★★★

 

 

===========ArrayList========== : java.util.ArrayList

 

------------ ArrayList<래퍼타입>.contains(elem) ------------- : true,false 반환

------------ ArrayList<래퍼타입>.toString() ------------- : 출력할 때 사용

 

 

===========String==========

------------ String.valueOf(char[]); -------------  : char array를 String으로 바꿔줌

------------ String.toBinaryString(num); ------------- : BinaryString으로 바꿔줌

 

===========Integer==========

------------ Integer.toString(int); -------------  : int를 String으로 바꿔줌. Long에도 똑같이 있음

 

===========StringBuilder==========

StringBuilder sb = new StringBuilder();

-----------------sb.append(chr)----------------

-----------------sb.reverse()--------------------

-----------------sb.toString()--------------------

 

===========Collections==========

-----------------Collections.min(List, 등등)----------------

 

 

===========Set========== 

Set<래퍼타입> setName = HashSet<>();

 

 

===========Map==========  : 생성자가 없어 new HashMap으로 생성

-----------------myMap.containsKey()----------------

-----------------myMap.containsValue()----------------

-----------------myMap.getOrDefault()---------------- : key가 있으면 value를, 없으면 defalut파라미터를 리턴

-----------------myMap.entrySet()---------------- : Set<Map.Entry<K, V>>를 반환. 이건 iterate 가능

 

 

 

 

 

=================기타문법=================

Collection 객체들의 toArray()의 파라미터에는 new Integer[0]과 같이 전환하려는 Array의 타입을 넣어줘야함.

길이가 0인 것을 전달하는 이유는, 기존 Collection객체의 사이즈와 전달하는 파라미터 Array의 length중 큰 것으로

반환이 되기 때문. 기존객체의 사이즈에 맞게 리턴받으려면  0으로 해줘야함

 

두 BinaryString 비교 시, 기존 integer를 먼저 |나 &로 비트연산 해주고, toBinaryString하면 됨. 비트연산은 integer에 적용해도 비트로 계산해줌.

 

개발을 하다보면, "예상치 못한" 상황을 많이 마주하게 된다. 대표적인 경우가 오류, 예외

 

오류(error) : 일반적으로 회복이 불가능한 문제. 주로 시스템 레벨에서, 주로 환경적인 이유로 발생

                    코드의 문제로 발생하는 경우도 있지만, 일단 발생하는 경우 일반적으로 회복이 불가. (종료되기때문)

                    에러 발생 시 어떠한 에러로 프로그램이 종료되었는지를 확인하고 대응 (logging 처리)

 

예외(Exception) :  일반적으로 회복이 가능한 문제

                               회복이 가능하다는 전제는, 그 예외가 발생할 수 있다는 것을 인지하고 대응했을 것

                               현실적으로 코드레벨에서 할 수 있는 문제상황에 대한 대응은 "예외처리"에 속함

                               ==> 예외처리를 자세하게 할 수록 완성도 높은 구현 가능

                               ==> 습관을 잘 들여놓는게 중요하다!!

 

<예외(Exception)의 종류>

1. 컴파일 에러(예외) : 컴파일 단계에서 발생하는 오류 (.java ==> .class)

-    대부분의 경우 코드 작성 단계에서 프로그래밍 언어의 규칙을 지키지 않았기 때문에 발생(클래스명, 접근가능여부 등)

-    해결방법 : 문법에 맞게 코드 수정

 

2. 런타임 에러(예외) : 주로 처리하게 될 에러(예외)로서, 컴파일은 잘 되었지만 프로그램이 실행도중 발생하는 에러

-    Checked Exception : 확인된 예외로서, 컴파일시점에 check하는 예외. 이것에 대한 처리를 하지 않으면 컴파일 에러

-    Unchecked Exception : 런타임 시점에 확인되는 에러로서, 예외처리가 반드시 필요하지 않음

 

<예외 발생과 try-catch, finally 문>

1. 예외를 어떻게 정의할 것인지 : 클래스를 만들어서 한다. extends Exception

2. 예외가 발생할 수 있음을 어떻게 알릴지 : 예외가 발생할 수 있는 logic에 flag를 달아놓는다 ?

3. 사용자는 예외가 발생할 수 있음을 알고 예외를 핸들링하는지

==> 이 흐름에서 나오는 것들이 try, catch, finally, throw 같은 키워드

 

예시)

<예외 클래스 만들기>

- Exception 클래스를 상속받아 만든다.

class ourException extends Exception(){

    public ourException(){

        super("출력할 메세지?")                                   

    }

}

 

<예외가 발생할 수 있는 메소드에 선언부에 flag(표시)>

- 메소드를 선언할 때 뒤에 throws ourException을 붙이고, 내용부분에서 exception을 정의하고, 예외클래스 생성, throw

public void dangerousMethod() throws ourException

    if(확인할조건){

        throw new ourException                 ==>  throw를 만나면 return을 만난것처럼 종료된다.

        }

    else{

            원래내용....

        }

}

 

<예외발생하는 메소드 사용 시 try-catch-finally 사용>

....코드 중...

 

try{

    // 예외처리가 되어있는 메소드를 "시도" 해보는 부분

    ourClass.dangerousMethod();

}catch( ourException e ){

    System.out.println(e.getMessage());          //  ourException e는 Exception을 상속받았기때문에 getMessage를 사용가능

                                                                       //  message는 ourException의 생성자에서 super로 넘겨줬다.

} finally {

    예외가 발생하든 발생하지 않든, 실행될 로직;

    // 예외가 발생하면 핸들링 후 실행, 발생안하면 그냥 실행.

}

 

===> 만약 throws로 처리가 되어있는 메소드를 쓸 때, try-catch문을 사용 안해주면 컴파일 오류가 난다.

 

<Exception 클래스 구조>

수많은 에러에 대한 것을 추상화하고, 객체로 만들어 주는 것은 어려운 일이다.

위에 나온 에러 대응 프로세스는 언어 설계 차원에서의 대응 프로세스이기도 하기 때문에, 이 문제들을 추상화 해서 객체로 만들어주는 것은 자바 언어에서 지원해준다. 따라서, 현실에서 마주하는 개념이나 이슈들을 객체지향 프로그래밍으로 어떻게 구현하는지에 대한 좋은 예시로서 공부할 수 있다.

 

==Java의 Throwable Class==

-시작은 모든 객체의 원형인 Object 클래스.

- Throwable Class는 "문제 상황"을 뜻하는 클래스 --> 자식으로 Error와 Exception 클래스가 있다.

- Error와 Exception 클래스는 각각 IOerror 클래스, RuntimeException 클래스와 같이 구분되어 처리된다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

          

일론머스크의 공약대로 트위터 추천알고리즘의 코드가 공개되었다.

https://github.com/twitter/the-algorithm

 

 

ml부분 : https://github.com/twitter/the-algorithm-ml

 

GitHub - twitter/the-algorithm-ml: Source code for Twitter's Recommendation Algorithm

Source code for Twitter's Recommendation Algorithm - GitHub - twitter/the-algorithm-ml: Source code for Twitter's Recommendation Algorithm

github.com

 

시간될 때 코드 구경해보자

'공부 > 잡다' 카테고리의 다른 글

웹 동작 간략개괄  (0) 2023.04.14
IntelliJ 디버거 활용 - Exception 조건설정  (0) 2023.04.10
Open-AI ChatGPT plugin  (0) 2023.04.06
ajax async // 웹관련 몇가지  (0) 2023.04.01
Git Bash  (0) 2023.03.23

https://openai.com/blog/chatgpt-plugins

<override>

부모로부터 상속받은 메서드의 내용을 재정의하는 것

1. 선언부가 부모 클래스의 메서드와 일치해야 함

2. 접근 제어자를 부모 클래스의 메서드보다 좁은 범위로 변경할 수 없음.

3. 예외는 부모 클래스의 메서드보다 많이 선언할 수 없다.

 

★override할 함수 위에 @Override 라고 써준다 (annotation)

이유 : 자바가 override 되고 있는지 체크해줌 (?)

 

<super>

super와 super()

 

super : this와 비슷하게 부모클래스의 멤버를 참조할 수 있는 키워드. 그냥 부모를 가리킨다고 보면 된다.

super() : super가 부모 클래스의 이름이니까, super()는 부모클래스의 생성자를 호출함.

             ==>자식클래스는 생성될 때, 부모클래스들이 같이 생성되면서 하나로 합쳐지게 되기 때문에, 자식클래스의 생성                     자에서는 부모클래스의 생성자가 첫줄에 호출되어야함. 만약 안써주면 컴파일러가 부모의 기본생성자 추가

 

<다형성>

부모타입 변수 = 자식타입객체; 는 자동으로 부모타입으로 변환이 일어난다.

                       ==>    Map<String> strMap = new HashMap<>()   자식클래스의 생성자로 부모클래스를 생성

                       ==> 자식은 부모의 모든 멤버를 가지고있기 때문으로  생각하기

 

Hobby hobby = new Hobby(Sports sport1) 이런식으로 Hobby의 생성자가 Sports 타입을 받아야한다고 할때,

이 대신 Sports를 상속받은 Sportsclimbing을 넣어주면 이것이 부모클래스로 자동 형변환이 일어나면서 Hobby를 생성할 수 있는 것이 다형성이다. 이 때, 자식클래스에서 override한 내용을 가지고 가서 형변환이 일어나기 때문에 결국 들어가는 자식 인스턴스의 속성에 따라 부모클래스의 내용이 바뀌므로, Hobby의 내용이 다양해질 수 있다.

 

=> 다형성 기능으로 인해서 클래스 객체의 원래 클래스명을 체크할 필요가 있을 수 있다. 이때 사용하는 것이

      instance of

 대상객체 instance of 클래스이름   ===> boolean을 return해줌. (자기부터 부모클래스들은 다 true를 return)

 

 

 

<생성자>

Constructor. 객체가 생성(new)될 때 호출되며, 객체를 초기화하는 역할을 하며, 부가적인 역할도 함.

모든 클래스는 반드시 생성자가 있어야함 (안만들어주면 컴파일러가 기본생성자로 만들어줌)

컴파일러에 의해 생성되는 기본 생성자는 해당 클래스의 접근제어자를 따라간다.

생성자도 오버로딩 가능

 

<this>

자기 자신(인스턴스)를 가리키는 변수.

왜 ? 생성자에서 생성할 때, 클래스에서 정한 변수명과 파라미터로 정한 변수명이 겹칠 경우가 있음

public ClimbingGym(String name){

    this.name = name

}

이런식으로 this 써준다. 생성자에서 필드변수를 가리키는 경우에는 this.변수명 으로 써주는게 국룰

 

오버로딩에서도 많이 활용된다.

this는 Car를 가리키므로  this()는 즉  Car()와 같다. Car 클래스의 생성자를 호출하는 것.

 

<제어자>

제어자는 클래스, 변수, 메서드의 선언부에 사용되어 부가적인 의미를 부여함

접근 제어자 : public // protected // default // private

그 외 제어자 : static // final // abstract

 

public : 접근 제한이 전혀 없음

protected : 같은 패키지 내에서 + 다른패키지의 자손클래스에서 접근 가능

default : 같은 패키지 내에서만 접근 가능

private : 같은 클래스 내에서만 접근 가능

 

클래스에 사용 가능한 접근제어자 : public // default

메서드 & 멤버변수에 사용 가능 : public // protected // default // private

 

메서드에 static과 abstract를 동시에 사용 불가

클래스에 abstract와 final을 동시에 사용 불가

abstract메서드의 접근 제어자가 private일 수 없다

메서드에 private과 final을 같이 사용할 필요는 없다

 

 

접근제어자는 객체의 무결성 즉, 변경이 없는 상태를 유지하기 위해 사용한다.

외부에서 필드에 접근하는 것을 막기 위해 필드에 private, default 등의 접근 제어자를 사용할 수 있다.

 

==>제어자때문에 나오는 개념이 ★★★★★Getter // Setter★★★★★

 

<Getter & Setter>

★ getter와 setter는 직접적인 값의 조회와 세팅을 방지하기 위해 사용됨 !!

보통 하나의 필드마다 getter와 setter가 존재함 getColor(), setColor() 와 같이 camelCase로 선언하는게 국룰

 

예를들어, double type으로 선언한 age필드에 누가 person.age = "27살" 이런식으로 값을 직접 바꾸게되면 안되기때문에 setAge() 같은 public한 setter 메소드를 사용해 값을 변경하도록 하고, 그 안에 특정한 로직을 담게된다.

 

외부에서 객체의 private한 필드를 읽을 필요가 있을 때 Getter 메서드를 사용. Getter를 이용해 내부 로직을 숨기면서, 내보내야 하는 정보만 내보낼 수 있다.

 

<상속>

부모클래스를 상속받은 자식클래스는 부모클래스의 필드나 메서드를 사용할 수 있다.

상속을 사용하면 코드의 중복이 제거되고, 재사용성이 크게 증가하여 생산성과 유지보수성에 매우 유리해진다.

상속 keyword : extends

public class 자식클래스 extends 부모클래스 { }

 

-부모클래스에 새로운 필드와 메서드가 추가되면 자식클래스는 이를 상속받아 사용할 수 있다.

-자식클래스에 새로운 필드와 메서드가 추가되어도 부모클래스는 어떠한 영향도 받지 않는다.

-따라서 자식 클래스의 멤버 개수는 부모클래스보다 항상 같거나 많다.

 

★Java는 다중상속을 허용하지 않음 : 클래스간의 관게가 복잡해지기 때문

★부모 클래스에 final인 멤버가 있으면 상속 불가 : 변경 불가하기 때문에 override할 수 없기때문

overload : 클래스 내에 같은 이름의 메소드를 여러가지로 정의  // override : 부모클래스의 메서드를 재정의

 

<추상 클래스>

-미완성된 설계도. 부모는 완성시키지 않은 method를 가지고 있고, 자식은 이를 상속받아서 완성시킴

- abstract 키워드를 class 앞에 넣어줘서 사용

eg) public abstract class 추상클래스명;                 ==> {}가 없고, 세미콜론으로 선언만 함

 

1. 추상 클래스는 추상 메서드를 포함할 수 있다 (없어도 선언 가능하긴함)

2. 추상 클래스는 자식 클래스에 상속되어서 자식 클래스에 의해서만 완성될 수 있음

3. 추상 클래스는 여러개 자식클래스 중에서 공통적인 필드나 메서드를 추출해서 만들 수 있다.

 

부모클래스를 자식들이 가져다 쓴다는 느낌보다, 자식클래스들의 공통된 특징을 묶어주는 느낌이 강하다(추상화)

상속받은 클래스에서 추상 클래스의 추상 메서드는 반드시 오버라이딩 되어야 한다(인터페이스와 다른 점)

 

<Interface>

두 객체를 연결해주는 다리.

- 상속관계가 없는 다른 클래스들이 서로 동일한 메서드를 구현해야할 때 인터페이스는 구현 클래스들의 동일한 사용 방법과 행위를 보장해줄 수 있다.

 

예를들어, 멀티 리모컨 인터페이스를 통해 삼성티비 객체, LG티비 객체의 채널을 변경할 수 있음

 

interface 키워드로 선언하며,   public interface 인터페이스명{ }    과 같은 형태가 됨. public // default 접근자 지정 가능

 

1. 인터페이스의 모든 멤버 변수는 public static final  : *생략가능 -생략시 컴파일러가 자동으로 추가

2. 인터페이스의 모든 메서드는 public abstract : *생략가능-생략시 컴파일러가 자동 추가(static, default 메서드 제외)

3. 생략되는 제어자는 컴파일러가 자동으로 추가해줌

 

- 인터페이스는 추상 클래스와 마찬가지로 직접 인스턴스를 생성할 수 없어, 클래스에 구현되어 생성된다.

 

public class 클래스명 implements 인터페이스명{

    @Override

    public 리턴타입 메서드이름(매개변수 ...{

            //실행문

        }

}

 

- 인터페이스의 추상 메서드는 구현될 때 반드시 오버라이딩 되어야 함. (안하면 컴파일 시 오류 발생)

- 인터페이스의 추상 메서드를 일부만 구현해야 한다면, 해당 클래스를 추상 클래스로 변경해주면 된다

    ==> implements 받는 클래스를 추상클래스로 선언한 뒤, 이것을 필요한 클래스에 상속해서 override

- 인터페이스 간의 상속이 가능하다. 인터페이스간의 상속은 extends 키워드를 사용하며, 다중상속 가능

 

===========Interface의 default, static 메서드=============

--------------interface의 디폴트 메서드----------------

-디폴트 메서드는 추상 메서드의 기본적인 구현을 제공하는 메서드.

-default 역시 접근 제어자가 public이며, 생략 가능

-추상 메서드가 아니기때문에 인터페이스의 구현체들에서 필수로 재정의할 필요는 없다.

 

--------------interface의 static 메서드----------------

-static 메서드의 경우, interface에 바로 접근 가능.

-이유 : static 메서드는 compile 단계에서 생성되기 때문에 구현체를 선언하지 안하도 쓸 수 있다.

 

<인터페이스의 다형성>

A가 interface, B는 interface를 implement받은 객체라고 할 때,

A a1 = new B(); 를 하면 B라는 구현체가 A로 형변환 일어나게 된다.

C는 구현체 B를 상속받은 객체라고 할 때,

A a2 = new C(); 를 하면 C가 A로 형변환됨.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

<객체지향>

Java는 대표적인 객체지향 언어. 객체빼면 시체

객체 = Object. 속성행위로 구성이 되어있다. 속성 = field // 행위 = method

객체지향 언어에서의 소프트웨어는 객체들의 조립. 객체들의 상호작용을 고려해야함.

상호작용 = 매개변수(parameter)를 넘겨주어 메서드를 호출시킨다.

객체 관계 : 사용 관계 // 포함 관계 // 상속 관계

 

클래스에서 자주 나오는 개념 : 캡슐화 // 상속 // 다형성 // 추상화

1.캡슐화(encapsulation) - 속성과 메서드를 하나로 묶어 객체로 만든 후, 내부 구현 내용은 외부에서 알 수 없게 감추는 것

    ==> 보안상의 이유, 외부에서 메서드를 잘못 사용하여 객체가 변하지 않게. Java에서는 접근 제어자를 써서 구현

 

2. 상속(inheritance) : 부모 객체가 가지고 있는 필드와 메서드를 자식 객체에 물려준다.

    ==> 그대로 쓸지, 가공해서 쓸건지(override) 결정해서 사용. 코드 중복이 줄어들며, 부모와 자식간의 일관성 유지 가능

 

3. 다형성 : 객체가 연산(메소드)를 수행할 때, 하나의 행위에 대해 각 객체의 속성(특성)에 따라 여러가지로 재구성되는 것

 

4. 추상화 : 객체에서 공통된 부분들을 모아 상위 개념으로 새롭게 선언하는 것.

==> eg) 여러 종류의 자동차들이 공통으로 가진 가속, 브레이크, 속도와 같은 것들을 모아서 새롭게 선언

 

=======클래스를 토대로 생성된 객체(Object)를 해당 클래스의 인스턴스라고 부른다.=============

- 동일한 클래스로 여러가지 인스턴스를 만들 수 있다.

- 클래스는 설계도, 객체는 만들어진 제품이라고 볼 수 있음

 

<클래스>

생성 방법 :

1. 만들고자 하는 클래스를 선언

2. 객체가 가지고 있어야할 속성(필드)를 정의

3. 객체를 생성하는 방식을 정의(생성자) - 생성자는 클래스 이름과 동일한 이름을 가진 메서드 형태

4. 객체가 가지고있어야 할 method를 정의

 

생성자가 아무 역할(파라미터를 받거나, 로직을 수행)을 하지 않으면 기본 생성자라고 하고, 생략 가능

 

객체 생성 방법

new를 통해 ClimbingGym이라는 클래스를 인스턴스화 했고, 생성자에 넣어놓은 출력

가 실행됨.  생성된 인스턴스를 그대로 프린트해보면, 주소값이 출력된다. 참조형 변수라는 뜻. 따라서,

아래와같이 ClimbingGym 객체로 이루어진 리스트도 선언 가능하다.

객체의 필드에는, 생성된 후 변하지 않는 부분과 변하는 부분이 있다. 이를 다루기 위해 set과 get을 공부하게 될것

또한, 그 값이 또다른 객체인 필드도 있다.

Athlete객체를 만들고,

ClimbingGym 클래스에 소속 선수들을 Athlete 인스턴스로 저장할 수 있는 Array 필드를 생성,

addAthlete 메서드를 추가해준 후 Athlete를 넣어주면 작동하는 것을 볼 수 있다.

 

===============Class, 객체 관련 잡다===================

-클래스의 필드를 선언하고 초기화하지 않으면, 각 변수 type에 맞는 default 값으로 할당됨

-클래스의 필드에 외부에서 접근할 땐 Class.필드 와 같이 .을 찍어서 접근한다.

-클래스의 내부에서 필드에 접근할 때는 변수명을 바로 써서 접근 가능

-메서드는 꼭 return값이 있어야 하는건 아니다

-메서드의 파라미터는 가변길이로 선언 가능 void addAthlete(Athlete... athletes) ==> addAthlete(jay1, jay2, jay3...)

 

<클래스의 멤버>

member = field + method

클래스의 멤버는 선언하는 방법에 따라서 인스턴스 멤버 // 클래스 멤버

                           =>static 등

인스턴스 멤버 : 인스턴스 필드 + 인스턴스 메서드

클래스 멤버 : 클래스 필드 + 클래스 메서드

==> 인스턴스 멤버는 객체 생성 후 사용할 수 있고, 클래스 메서드는 객체 생성 없이도 사용할 수 있다.

==> 이유 : 객체가 인스턴스화 될 때마다 모든 메서드가 생성된다고 생각하면 메모리낭비가 심할 것을 알 수 있다.

                 따라서 메서드는 메서드 영역에 두고서 모든 인스턴스들이 공유해서 사용함. 대신, 객체를 인스턴스화                                 해야 사용할 수 있는것.

                 클래스 메서드의 경우, Java의 클래스 로더에 의해 메서드영역에 저장되기 때문에 객체생성 없이 사용O

                 이러한 메서드를 만들어주는 것이 static 이다. 고정된 영역을 가지기 때문이라고 생각하면 될듯

==>일반적으로 인스턴스마다 모두 가지고 있을 필요 없는 공용데이터를 저장하는 필드는 클래스 멤버로 선언

                                                                                                                            ->eg) static String name = "재형";

==>인스턴스 필드를 사용하지 않고 실행되는 메서드는 static을 붙여주어 클래스 메서드로 선언

==>클래스멤버는 클래스이름.멤버  와 같이 클래스이름으로 접근하는 것이 좋다. 약속 !

 

<메서드>

-------------메서드 오버로딩------------

같은 이름의 메서드로 여러가지 기능을 구현 : 매개변수의 타입 또는 개수, 순서가 다르면 동일한 이름으로 정의 가능

대표적인 예시가, println() : 들어오는 매개변수의 type에 따라 다른 방법으로 출력해야 하기 때문. println의 정의 보면 앎

장점 : 같은 기능에 대해 메서드 이름을 절약할 수 있으며, 혼선을 방지 가능

 

--------------기본형 & 참조형 매개변수-----------

매개변수의 타입이 기본형일때는, 값이 복사되어서 넘어가기때문에 원본값 변경X

매개변수의 타입이 참조형일때는, 주소값을 넘겨주기 때문에 메서드 내에서 원본값 변경 가능

 

 

 

 

+ Recent posts