✏️ Lecture 1 ~

정나영·2022년 10월 11일

Java

📁 자바 프로그램의 기본 구조

🧷 메소드

함수를 자바에서는 메소드로 지칭
클래스 바깥에서 작성할 수 없음
메소드 개수 제한이 없음

🧷 main() 메소드

자바 프로그램은 메인 메소드부터 실행 시작
public static void 로 선언
String[] args 로 실행 인자 전달 받음

🧷 변수 선언

변수란 프로그램 실행동안 데이터를 저장하는 공간
지역변수: 메소드 내에 선언되어 사용되는 변수
변수는 메소드 내에서만 사용, 메소드 실행이 끝나면 소멸

📁 식별자

: 클래스, 변수, 상수, 메소드 등에 붙이는 이름

특수문자, 공백 또는 탭은 식별자로 사용 불가, '_','$'는 사용 가능
유니코드 문자, 한글 사용 가능
자바의 키워드는 식별자로 사용 불가
식별자의 첫번째 문자로 숫자 사용 불가
'_', '$'는 첫번째 문자로 사용할 수 있으나 일반적으로 사용x
불린 리터럴(true,false)과 널 리터럴(null)은 식별자로 사용불가
길이 제한 없음
대소문자 구분

📁 자바의 데이터 타입

🧷 기본 타입

boolean (1byte)
char (2byte)
byte (1byte)
short (2byte)
int (4byte)
long (8byte)
float (4byte)
double (8byte)

🧷 레퍼런스 타입
:1개 (용도는 3가지)

배열(array)에 대한 레퍼런스
클래스(class)에 대한 레퍼런스
인터페이스(interface)에 대한 레퍼런스

=> 레퍼런스란 포인터와 비슷한 개념

📁 자바에서 키 입력

🧷 System.in

키보드로부터 직접 읽는 자바의 표준 입력 스트림
키 값을 바이트로 리턴

🧷 Scanner 클래스

System.in 에게 키를 읽게 하고, 읽은 바이트를 문자, 정수, 실수, 불린, 문자열 등 다양한 타입으로 변환하여 리턴

import java.util.Scanner; //import문 필요
...
Scanner a = new Scanner(System.in); //Scanner 객체 생성

📁 연산자 우선순위

🧷 같은 순위의 연산자

왼쪽에서 오른쪽으로 처리
예외) 오른쪽에서 왼쪽으로
- 대입 연산자 ++,--

🧷 괄호는 최우선순위

괄호가 다시 괄호를 포함하는 경우에는 가장 안쪽의 괄호부터 먼저 처리

📁 산술 연산

📁 증감 연산

🧷 ++, --

📁 대입 연산

: 연산의 오른쪽 결과는 왼쪽 변수에 대입

int a=1, b=3;
a = b; //a=b=3
a += b; //a = a+b =3+3=6, b=3

📁 비교 연산과 논리 연산

🧷 비교 연산
: 두 피연산자를 비교하여 true 또는 false의 논리 값을 내는 연산

🧷 논리 연산
: 논리 값으로 NOT, OR, AND 논리 연산. 논리 값을 내는 연산

🧷 두 연산의 복합 사례

//나이가 20대인 경우
(age>=20) && (age<30)

//문자가 대문자인 경우
(c>='A') && (c<='Z')

//(x,y)가 (0,0)과 (50,50)의 사각형 내에 있음
(x>=0) && (y>=0) && (x<=50) && (y<=50)

//오류!
//20 <= age < 30

📁 조건 연산자

Condition ? opr2 : opr3

세 개의 피연산자로 구성된 삼항 연산자
- condition이 true이면 연산 결과는 opr2, false이면 opr3
if - else 를 간결하게 표현 가능

int s;
if(x>y)
	s = 1;
else
	s = -1;
🟰

int s = (x>y)?1:-1;

📖 조건문 (if)

📁 단순 if문

if의 괄호 안에 조건식 (논리형 변수나 조건 연산)
실행 문장이 단일 문장일 경우 {} 생략 가능

if (조건식) {
	..실행 문장.. //조건식이 참인 경우
}

📁 조건문 if - else

🧷 if-else 문

if (조건식) {
	..실행 문장1..
}
else {
	..실행 문장2..
}

조건식이 true면 실행문장1 실행 후 if-else문 벗어남
조건식이 false면 실행문장2 실행 후 if-else문 벗어남

🧷 다중 if-else 문

if (조건식1) {
	실행문장1;
}
else if (조건식2) {
	실행문장2;
}
else if (조건식m) {
	...
}
else {
	실행문장n; 
}

📁 switch문

🧷 switch문은 식과 case문의 값과 비교

case의 비교 값과 일치하면 해당 case의 실행문장 수행
break를 만나면 switch문을 벗어남
case의 비교 값과 일치하는 것이 없으면 default문 실행
default 문은 생략 가능

switch (식) {
	case 값1:
    	실행문장1;
        break;
    case 값2:
    	실행문장2;
        break;
    ...
    case 값m:
    	실행문장m;
        break;
    default:
    	실행문장n;
}

🧷 switch 문 내의 break 문

break문 만나면 switch문 벗어남
case문에 bread문이 없다면, 다음 case문 실행 계속
break를 만날 때까지 계속 내려가면서 실행

🧷 case 문의 값

문자, 정수, 문자열 리터럴만 허용
실수 리터럴 허용 x

오류!
switch(a) {
	case a: //변수 사용 안됨
    case a > 3: //수식 안됨
    case a == 1: //수식 안됨
}

📖 반복문 (for, while)

🧷 자바 반복문의 종류

for문
while문
do while문

🧷 for문의 구성

for(초기문; 조건식; 반복 후 작업) {
	.. 작업문 ..
}

🧷 for문의 특이한 형태

for (초기작업; true; 반복후작업) { //반복조건이 true이면 무한 반복
}

for (초기작업; ;반복후작업) { //반복조건이 비어있으면 true로 간주, 무한 반복
}

//초기 작업과 반복후작업은 ','로 분리하여 여러 문장 나열 가능
for(i=0; i<10; i++,System.out.println(i){
..
}

//for문 내 변수 선언 가능
for(int i=0; i<10; i++) { //변수 i는 for문 내에서만 사용 가능
}

🧷 while문의 구성

while (조건식) {
	..작업문..
}

🧷 do-while문의 구성

do {
	..작업문..
} whlie (조건식);

🧷 continue문

반복문을 빠져 나가지 않으면서 다음 반복으로 진행

🧷 break문

반복문 하나를 완전히 빠져나갈 때 사용
하나의 반복문만 벗어남
중첩 반복의 경우 안쪽 반복문의 break 문의 실행되면 안쪽 반복문만 벗어남

📖 배열 (array)

인덱스와 인덱스에 대응하는 데이터들로 이루어진 자료구조
- 배열을 이용하면 한번에 많은 메모리 공간 할당 가능
같은 타입의 데이터들이 순차적으로 저장
- 인덱스를 이용하여 원소 데이터 접근
- 반복문을 이용하여 처리하기에 적합
배열 인덱스
- 0부터 시작
- 인덱스는 배열의 시작 위치에서부터 데이터가 있는 상대 위치

🧷 일차원 배열 만들기

배열 선언

int intArray[];
char charArray[];

int[] intArray;
char[] charArray;

배열 생성

intArray = new int[10];
charArray = new char[20];

//선언과 동시에 생성
int intArray[] = new int[10];
char charArray[] = new char[20];

선언과 함께 초기화

int intArray[] = {0,1,2,3,4,5,6,7,8,9};
//초기화된 값의 개수만큼의 배열 생성

잘못된 배열 선언

int intArray[10]; //배열 선언 시 크기를 지정하면 안돼!

🧷 배열 인덱스와 원소 접근

배열 원소 접근
- 배열 변수명과 [] 사이에 원소의 인덱스를 적어 접근
- 배열의 인덱스는 0부터 시작
- 배열이 마지막 항목의 인덱스는 (배열크기 -1)

int intArray[] = new int[5]; //원소가 5개인 배열 생성
intArray[0] = 5;
intArray[3] = 6;
int n = intArrayp[3]; //원소 3의 값을 읽어 n에 저장 (n=6)

인덱스 범위

n = intArray[-2]; //오류! 인덱스로 음수 사용 불가
n = intArray[5]; //오류! 5는 인덱스 범위를 넘었음 (0~4)

반드시 배열 생성 후 접근

int intArray[]; //배열 선언
intArray[] = 8; //오류! 생성되지 않은 배열 사용

🧷 레퍼런스 치환과 배열 공유

하나의 배열을 다수의 레퍼런스가 참조 가능

int intArray[] = new int[5];
int myArray[] = intArray; //레퍼런스 치환. myArray는 intArray와 동일한 배열 참조

🧷 배열의 크기, length 필드

배열은 객체로 관리
배열 객체 내에 length 필드는 배열의 크기를 나타냄

int intArray[];
intArray = new int[5];

int size = intArray.length; //size = 5

🧷 배열과 for-each문

for (변수 : 배열레퍼런스) {
	.. 반복작업문 ..
}

int n[] = {1,2,3,4,5};
int sum = 0;
for (int k : n) {
	sum += k;
}
🟰
for(int i=0; i<n.length; i++) {
	sum += n[i];
}

String names[] = {"사과", "배", "바나나", "체리", "딸기", "포도"};
for (String s : name) {
	System.out.print(s+ " ");
}

>> 사과 배 바나나 체리 딸기 포도

enum Week {월, 화, 수, 목, 금, 토, 일}
for (Week day: Week.values())
	System.out.print(day+ "요일 ");
    
>> 월요일 화요일 수요일 목요일 금요일 토요일 일요일

🧷 2차원 배열

배열 선언

int intArray[][];
char charArray[][];
double doubleArray[][];

int [][] intArray;
char [][] charArray;
double [][] doubleArray;

배열 생성

intArray = new int[2][5];
charArray = new char[5][5];
doubleArray = new double[5][2];

배열 선언, 생성, 초기화

int intArray[][] = { {0,1,2}, {3,4,5}, {6,7,8} };
char charArray[][] = { {'a','b','c'} {'d','e','f'} };
double doubleArray[][] = { {0.01,0.02}, {0.03,0.04} };

🧷 비정방형 배열
: 각 행의 열의 개수가 다른 배열

🧷 비정방형 배열의 length

int i[][];
i = new int[4][];

i[0] = new int[1];
i[1] = new int[2];
i[2] = new int[3];
i[3] = new int[4];

i.length -> 2차원 배열의 행의 개수로서 4
i[n].length는 n번째 행의 열의 개수
- i[0].length -> 0번째 행의 열의 개수로서 1
- i[1].length -> 1번째 행의 열의 개수로서 2
- i[2].length -> 2번째 행의 열의 개수로서 3
- i[3].length -> 3번째 행의 열의 개수로서 4

🧷 배열 리턴 과정

🧷 main() 메소드

main()은 자바 응용프로그램의 실행 시작 메소드
main()의 원형
- 반드시 static
- 반드시 public
- 반드시 void
- 반드시 매개 변수 타입은 문자열 배열

📖 예외 처리

🧷 컴파일 오류

문법에 맞지 않게 작성된 코드
컴파일 할 때 발견

🧷 예외 (Exception)

오동작이나 결과에 악영향을 미칠 수 있는 실행 중 발생한 오류
- 정수를 0으로 나누는 경우
- 배열보다 큰 인덱스로 배열의 원소에 접근하는 경우
- 존재하지 않는 파일을 읽으려고 하는 경우
- 정수 입력을 기다리는 코드가 실행되고 있을 때, 문자가 입력되는 경우

🧷 예외 처리, try-catch-finally 문

try {
	예외가 발생할 가능성이 있는 실행문
}
catch (처리할 예외 타입 선언){
	예외 처리문
}
finally {
	예외 발생 여부와 상관없이 무조건 실행되는 문장
}
//finally 블록은 생략 가능

🧷 자주 발생하는 예외

📖 클래스 & 객체

🧷 객체 지향 특성 : 캡슐화

객체를 캡슐로 싸서 내부를 볼 수 없게 하는 것
객체의 본질적인 특성
- 외부의 접근으로부터 객체 보호

🧷 클래스(class) : 객체 모양을 선언한 틀 (캡슐화)

메소드(멤버 함수)와 필드(멤버 변수)는 모두 클래스 내에 구현
객체의 속성(state)과 행동(behavior) 포함

🧷 객체

클래스의 모양대로 생성된 실체(instance)
객체 내 데이터에 대한 보호, 외부 접근 제한
- 객체 외부에서는 비공개 멤버 (필드, 메소드) 에 직접 접근할 수 없음
- 객체 외부에서는 공개된 메소드를 통해 비공개 멤버 접근

🧷 상속

상위 클래스의 속성이 하위 클래스에 물려짐
하위 클래스가 상위 클래스의 속성을 모두 가지는 관계
자식 클래스가 부모 클래스의 속성 물려받고, 기능 확장
- 부모 클래스 : 슈퍼 클래스
- 자식 클래스 : 서브 클래스. 슈퍼 클래스를 재사용하고 새로운 특성 추가

💡 참고
: 자바는 클래스 다중 상속 없음. 인터페이스 다중 상속 허용

🧷 다형성

같은 이름의 메소드가 클래스나 객체에 따라 다르게 동작하도록 구현
다형성 사례
- 메소드 오버로딩 : 같은 이름이지만 다르게 작동하는 여러 메소드
- 메소드 오버라이딩 : 슈퍼클래스의 메소드를 서브 클래스마다 다르게 구현

🧷 클래스 선언

class 키워드로 선언
클래스는 { 로 시작하여 }로 닫으며 안에 모든 필드와 메소드 구현
class Name은 Name 이름의 클래스 선언
클래스 접근 권한, public
- 다른 클래스들에서 Name 클래스를 사용하거나 접근할 수 있음을 선언

🧷 필드와 메소드

필드 : 객체 내에 값을 저장하는 멤버 변수
메소드 : 함수이며 객체의 행동을 구현

🧷 필드의 접근 지정자, public

필드나 메소드 앞에 붙어 다른 클래스의 접근 허용을 표시
public 접근 지정자 : 다른 모든 클래스의 접근 허용

🧷 생성자

클래스의 이름과 동일한 특별한 메소드
객체가 생성될 때 자동으로 한 번 호출되는 메소드

🧷 객체 생성

반드시 new 키워드를 이용하여 생성
new는 객체의 생성자 호출

🧷 객체 생성 과정

객체에 대한 레퍼런스 변수 선언
객체 생성
- 클래스 타입 크기의 메모리 할당
- 객체 내 생성자 코드 실행

🧷 객체의 멤버 접근

객체의 멤버에 접근할 때는 레퍼런스 변수 뒤에 점(.) 연산자를 붙임

객체 레퍼런스.멤버

ex) pizza.radius = 10;

🧷 객체 생성과 접근

🧷 생성자 개념
: 객체가 생성될 때 초기화를 위해 실행되는 메소드

🧷 생성자 특징
1) 생성자는 메소드
2) 생성자 이름은 클래스 이름과 반드시 동일

public class Circle {
	public Circle(int r, String n) { ... } //생성자
}

3) 생성자 여러 개 작성 가능 (오버로딩)

public class Circle {
	public Circle() { ... } //매개 변수 없는 생성자
    public Circle(int r, String n) { ... } //2개의 매개 변수를 가진 생성자
}

4) 생성자는 new를 통해 객체를 생성할 때, 객체당 한번 호출

Circle pizza = new Circle(10, "자바피자"); //생성자 Circle(int r, String n) 호출
Circle donut = new Circle(); //생성자 Circle() 호출

5) 생성자는 리턴 타입을 지정할 수 없음

public Circle() { ... } //리턴 타입 선언하지 않음

//리턴 값이 없다고 해서, void를 리턴 타입으로 지정하면 안됨!
public void Circle() {...} //오류!

6) 생성자의 목적은 객체 초기화

Circle pizza = new Circle(10, "자바피자"); //생성자 Circle(int r, String n) 호출

7) 생성자는 객체가 생성될 때 반드시 호출
- 하나 이상 선언되어야 함!
: 생성자를 작성하지 않았으면 컴파일러가 자동으로 기본 생성자 삽입

🧷 기본 생성자
: 매개 변수 없고 아무 작업 없이 단순 리턴하는 생성자 (=디폴트 생성자)

class Circle {
	public Circle() { } //기본 생성자
}

기본 생성자가 자동으로 생성되는 경우
: 클래스에 생성자가 하나도 선언되지 않은 경우, 컴파일러에 의해 자동으로 삽입
❗️ 생성자가 없는 클래스는 있을 수 없다 ❗️ -> 객체가 생성될 때 반드시 생성자가 실행되기 때문

public class Circle {
	int radius;
    void set(int r) { radius = r; }
    double getArea() { return 3.14 * radius * radius; }
    
    //public Circle() { } //컴파일러에 의해 자동 삽입된 기본 생성자
    
    public static void main(String[] args) {
    	Circle pizza = new Circle();
        pizza.set(3);
    ]
}

기본 생성자가 자동으로 생성되지 않은 경우
- 개발자가 클래스에 생성자를 하나라도 작성한 경우
-> 컴파일 오류 !

🧷 this 레퍼런스

객체 자신에 대한 레퍼런스
컴파일러에 의해 자동 관리
this.멤버 형태로 사용

public class Circle {
	int radius;
    public Circle(int r) {this.radius = r;}
    public int getRadius() {return radius;}
}

🧷 this 레퍼런스의 필요성

객체의 멤버 변수와 메소드 변수의 이름이 같은 경우
다른 메소드 호출 시 객체 자신의 레퍼런스를 전달할 때
메소드가 객체 자신의 레퍼런스를 반환할 때

🧷 this()로 다른 생성자 호출

클래스 내의 다른 생성자 호출
생성자 내에서만 사용 가능
반드시 생성자 코드의 제일 처음에 수행

💡 this 와 this()는 다름
- this : 객체 자신에 대한 레퍼런스. 메소드에서 사용 (static 메소드에서는 x)
- this() : 생성자가 다른 생성자 호출

🧷 객체 치환

객체의 치환은 객체가 복사되는 것이 아니라 레퍼런스가 복사

🧷 객체 배열
: 객체에 대한 레퍼런스를 원소로 갖는 배열

Circle[] c; //Circle 배열에 대한 레퍼런스 변수 c 선언
c = new Circlr[5]; //레퍼런스 변수 생성

for (int i=0; i<c.length; i++) {
	c[i] = new Circle(i); //배열의 각 원소 객체 생성
}

📁 메소드 활용

🧷 메소드 형식

메소드
- 클래스의 멤버 함수, C/C++의 함수와 동일
- 자바의 모든 메소드는 반드시 클래스 안에 있어야함 (캡슐화 원칙)
메소드 구성 형식
- 접근 지정자 : public, private, protected, 디폴트 (접근 지정자 생략된 경우)
- 리턴 타입 : 메소드가 반환하는 값의 데이터 타입

🧷 인자 전달

자바의 인자 전달 방식

경우 1. 기본 타입의 값 전달 : 값이 복사되어 전달
메소드의 매개변수가 변경되어도 호출한 실인자 값은 변경되지 않음
(매개변수가 byte, int, double 등 기본 타입의 값일 때)
경우 2. 객체 혹은 배열 전달
- 객체나 배열의 레퍼런스만 전달
- 객체 혹은 배열이 통째로 복사되어 전달되는 것이 아님
- 메소드의 매개변수와 호출한 실인자 객체나 배열 공유

🧷 메소드의 배열 리턴

배열의 레퍼런스 리턴
메소드의 리턴 타입
- 메소드의 리턴 타입과 리턴 받는 배열 타입과 일치
- 리턴 타입에 배열의 크기를 지정하지 않음

🧷 메소드 오버로딩

이름이 같은 메소드 작성
- 매개변수의 개수나 타입이 서로 다르고
- 이름이 동일한 메소드들
리턴 타입은 오버로딩과 관련 없음

class MethodOverloading {
	public int getSum(int i, int j) {
    	return i+j;
    }
    public int getSum(int i, int j, int k) {
    	return i+j+k;
    }
}

🧷 오버로딩된 메소드 호출

public class MethodSample {
    public int getSum(int i, int j) {
        return i+j;
    }
    public int getSum(int i, int j, int k) {
        return i+j+k;
    }
    public double getSum(double i, double j) {
        return i+j;
    }

    public static void main(String[] args) {
        MethodSample a = new MethodSample();

        int i = a.getSum(1,2);
        int j = a.getSum(1,2,3);
        double k =a.getSum(1.1,1.2);

        System.out.println(i);
        System.out.println(j);
        System.out.println(k);
    }
}

📁 접근 지정자

🧷 패키지
: 관련 있는 클래스 파일을 저장하는 디렉토리

🧷 접근 지정자
: 클래스나 멤버들을 다른 클래스에서 접근해도 되는지의 여부를 선언하는 지시어

private, protected, public, 접근 지정자 생략(디폴트 접근 지정)

🧷 클래스 접근 지정

다른 클래스에서 사용하도록 허용할 지 지정
public 클래스
- 다른 모든 클래스에게 접근 허용
디폴트 클래스 (접근 지정자 생략)
- 같은 패키지 내의 클래스에게만 접근 허용

🧷 멤버 접근 지정

public 멤버
- 패키지에 관계 없이 모든 클래스에게 접근 허용
private 멤버
- 동일 클래스 내에만 접근 허용
- 상속 받은 서브 클래스에서 접근 불가
protected 멤버
- 같은 패키지 내의 모든 클래스에게 접근 허용
- 상속 받은 서브 클래스는 다른 패키지에 있어도 접근 가능
디폴트(default) 멤버
- 같은 패키지 내의 다른 클래스에게 접근 허용

📁 static 멤버

🧷 non-static 멤버와 static 멤버

🧷 static 멤버의 생성과 활용 1 : 객체.static 멤버

class Ex {
    public int n;
    public void g() {
        m = 20;
    }
    public void h() {
        m = 30;
    }
    public static int m;
    public static void f() {
        m = 5;
    }
}

public class StaticSample {
    public static void main(String[] args) {
        Ex s1,s2;
        s1 = new Ex();
        s1.n = 5;
        s1.g();
        s1.m = 50;

        s2 = new Ex();
        s2.n = 8;
        s2.h();
        s2.f();
        System.out.println(s1.m);
    }   
}

>> 5

static 멤버의 생성
- static 멤버가 생성되는 시점은 Ex가 사용되기 시작하는 시점

Ex s1,s2; //static 멤버 m, f()는 이미 존재, 사용 가능

//Ex 객체 생성
s1 = new Ex(); 
s2 = new Ex();

static 멤버 접근
- static 멤버도 멤버이기 때문에 non-static 멤버와 사용 방법 동일

객체.static필드
객체.static메소드

s1.m = 50;
s2.f();

static 멤버의 공유
- 위 예제에서 객체 s1과 s2는 static 멤버 m과 f()를 공유

🧷 static 멤버의 생성 및 활용 2 : 클래스명.static 멤버

public class StaticEx {
    public static void main(String[] args) {
        Ex.m = 10;

        Ex s1 = new Ex();
        System.out.println(s1.m);
        s1.f();
        Ex.f();
    }
}

🧷 static 메소드의 제약 조건
1) static 메소드는 static 멤버만 접근 가능
- non-static 멤버 접근할 수 없음
- non-static 멤버는 static 멤버 사용 가능

class StaticMethod {
	int n;
    void f1(int x) {n=x;} //정상
    void f2(int x) {m=x;} //정상
    
    static int m;
    staic void s2(int x) {n=x;} //오류! static 메소드는 non-static 필드 사용 불가
    static void s2(inr x) {f1(3);} //오류! static 메소드는 non-static 메소드 사용 불가
    
   static void s3(int x) {m=x;} //정상. static 메소드는 static 필드 사용 가능
   static void s4(int x) {s3(3);} //정상. static 메소드는 static 메소드 호출 가능
}

2) static 메소드는 this 사용 불가
- static 메소드는 객체 없이도 존재하기 때문에, this 사용 불가

class StaticAndThis {
	int n;
    static int m;
    void f1(int x) {this.n = x;}
    void f2(int x) {this.m = x;}
    static void s1(int x) {this.n = x;} //오류!
    static void s2(int x) {this.m = x;} //오류!
}

📁 final

🧷 final 클래스, 메소드, 필드

final 클래스 -클래스 상속 불가
final 메소드 - 오버라이딩 불가
final 필드
- 상수 필드는 선언 시에 초기값 지정
- 상수 필드는 실행 중에 값 변경 불가

📖 클래스 상속, 재사용

🧷 객체 지향의 상속

부모클래스에 만들어진 필드, 메소드를 자식클래스가 물려받음
동일한 특성을 재정의할 필요가 없어 자식클래스 간결해짐

🧷 상속의 특징

클래스의 다중 상속 지원하지 않음
상속 횟수 무제한
상속의 최상위 클래스는 java.lang.Object 클래스
- 모든 클래스는 java.lang.Object 를 상속받음

🧷 상속과 접근 지정자

자바의 접근 지정자 4가지
-public, protected, 디폴트, private
슈퍼 클래스의 private 멤버
- 슈퍼 클래스의 private 멤버는 다른 모든 클래스에 접근 불허
- 클래스 내의 멤버들에게만 접근 허용
슈퍼 클래스의 디폴트 멤버
- 슈퍼 클래스의 디폴트 멤버는 같은 패키지 내 모든 클래스에 접근 허용
슈퍼 클래스의 public 멤버
- 슈퍼 클래스의 public 멤버는 다른 모든 클래스에 접근 허용
슈퍼 클래스의 protected 멤버
- 같은 패키지 내 모든 클래스에 접근 허용
- 다른 패키지에 있어도 서브 클래스는 슈퍼 클래스의 protected 멤버 접근 가능

🧷 **서브 클래스 / 슈퍼 클래스의 생성자 호출 및 실행

new 에 의해 서브 클래스의 객체가 생성될 때
- 슈퍼 클래스 생성자와 서브 클래스 생성자 모두 실행됨
[호출 순서]
- 서브 클래스의 생성자가 먼저 호출, 서브 클래스의 생성자는 실행 전 슈퍼 클래스 생성자 호출
[실행 순서]
- 슈퍼 클래스의 생성자가 먼저 실행된 후 서브 클래스의 생성자 실행

정나영

이전 포스트

✏️ 10/11 ~ 10/13 강의

다음 포스트

✏️ 10/18 강의 필기

2개의 댓글

조윤환

2022년 10월 12일

정리가 깔끔하네요 ㅎㅎ 잘 보고가요 :)

1개의 답글