🚀 객체지향 세계로

📚 객체란?

• 실제로 존재하는것을 뜻 함
• 덧셈, 뺄셈 등 눈에 보이지 않은 것들도 무형의 객체임!
• c파란딱지 클래스 준비되어 있다면 클래스를 기준으로 여러 객체들을 만들어 낼수 있음!( 나만알아들을듯..)
  

사진처럼 Person.classr 객체 파일이 있다면 클래스는 객체를 만들기위한 설계도임!

1️⃣ Person.classr 클래스 파일

public class Person() { 
		...
}

2️⃣ new 키워드로 객체 생성, 이과정을 인스턴스화라고 표현함

public class Main {

		public static void main(String[] args) {
				Person personA = new Person(); // ✅ 첫번째 객체 생성 
				Person personB = new Person(); // ✅ 두번째 객체 생성
		}
}

📙 클래스 / 설계도 구조

• 클래스구조는 속성,생성자,기능 부분으로 나누어짐 (속,생,기)

class 클래스 {

		// 1. 속성  나이 이름 주소 
		
		// 2. 생성자
		
		// 3. 기능
}

✔️ 속성

• 속성은 특징을 작성하는 곳
• 당연히 객체를 생성해야 속성에 접근할수있겠지~?ㅎㅎ
• 사람을 속성으로 들면 나이,이름,주소 계산기로 예를들면 현재값, 이전값, 연산자 등 해당함
• 프로퍼티(property), 필드(field)라고 칭한다함..
  

public class Main {

		public static void main(String[] args) {
		
				// 1. 객체 생성
				Person personA = new Person(); 
				Person personB = new Person(); 
				
				//  ✅ 객체를 통해 접근 personA 의 name
				System.out.println(personA.name);

				// ✅ 객체를 통해 접근 personB 의 name
				System.out.println(personB.name);
		}
}

✔️생성자

• 객체를 만들때 사용한다
• 객체를 어떻게 만들지 정의해놓는것(조립설명서 느낌이라보면뎅)
• 생성자가 없으면 클래스를 객체화를 시킬수 없음(조립불가/팥없는 단팥빵느낌이라봄)
• 사실 클래스를 생성하면 기번 생성자는 자동으로 추가되는거거등 메롱😝

이름 나이만을 가지고있는 객체를 만단다면 아래 객체 생성하면댐 (address 제외임 이건 물어봐야겠다)

1️⃣ 클래스 객체 생성

public class Person {
		String name;
		int age;
		String address;
		
		Person() {} // ❌ 기본생성자 제거!!!
		
		Person(String name, int age) { // ✅ 새로운 생성자(조립설명서)
				this.name = name;
				this.age = age;
		}
}

2️⃣ Main 이전코드 에러발생
⚠️ this 키워드는 객체 자신을 가리키는 키워드 즉 현재 실행중인 객체를 의미함.

public class Main {

		public static void main(String[] args) {
				Person personA = new Person(); // ❌ 에러발생
				Person personB = new Person(); // ❌ 에러발생
		}
}

3️⃣ 나 박지연 당황노노 Main(tring name, int age)값 슥 넣어주기

public class Main {

public static void main(String[] args) {
Person personA = new Person("gygim", 10); // ✅ 조립설명서 준수
Person personB = new Person("Steve", 5);  // ✅ 조립설명서 준수
		}
}

✔️ 기능(매서드)

• 상상하는 모든것을 구현할수있다. (야!너두꿈을 펼칠수이쒀!)
  → 자기소개, 더하기, 걷기 기능 등
• 매서드를 활용하는것이 객체의 기능을 활용하는것이라 볼수있움
• 클래스와 관련된 기능을 작성하는게 좋음 어처구니 불가야

1️⃣ 클래스 객체생성

class Person {
		...
		
		// ✅ 사람의 소개 기능
		void introduce() {
				System.out.println("안녕하세요.");
				System.out.println("나의 이름은 " + this.name + "입니다.");
				System.out.println("나이는 " + this.age + "입니다.");
		}
		
		// ✅ 사람의 더하기 기능
		int sum(int a, int b) {
				int result = a + b;
				return result;
		}
}

2️⃣ Main

public class Main {

		public static void main(String[] args) {
				Person personA = new Person("gygim", 10);
				personA.introduce(); // ✅ personA 객체 introduce() 호출
				
				Person personB = new Person("Steve", 5);
		}
}

⚠️ 클래스와 객체 예시 코드

📌 Person 클래스 (설계도)
class Person {
    // 속성 
    String name;
    int age;

    // 생성자 
    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 기능 (메서드)
    void introduce() {
        System.out.println("\n안녕하세요.");
        System.out.println("나의 이름은 " + this.name + "입니다.");
        System.out.println("나이는 " + this.age + "살입니다.");
    }

    //  두 수를 더하는 기능 (메서드)
    int sum(int a, int b) {
        return a + b;
    }
}

 🚀 프로그램 실행을 위한 Main 클래스
public class Main {
    public static void main(String[] args) {
        // 첫 번째 사람 생성
        Person personA = new Person("gygim", 10);
        personA.introduce();  // 자기소개 출력

        //  두 번째 사람 생성
        Person personB = new Person("Steve", 5);
        personB.introduce();  // 자기소개 출력

        // 객체를 이용해 더하기 기능 사용
        int result = personA.sum(3, 4);
       System.out.println("\n3 + 4의 결과는 " + result + "입니다.");
    }
}

📒 게터와세터(패트와매트)

• 게터는 클래스의 속성을 가져올때 사용되는 기능
• 즉 클래스의 속성(필드)을 외부에서 읽을 수 있도록 하는 메서드
• 보통 get필드명() 형태로 정의하며, 해당 속성 값을 반환(return)해야함
• 고냥 getName(), getAge(), getAddress() 처럼 클래스에 추가하면 게터가 왕성

💡 게터는 왜 사용해야하지?

1️⃣ 객체의 필드를 private으로 보호(캡슐화) → 직접 접근 방지! 🚫
2️⃣ 필드 값을 가져올 때 추가 로직을 넣을 수 있음 (데이터 변환, 검증 등)
3️⃣ 클래스 내부 구현을 변경해도 외부 코드를 수정할 필요 없음

String name = person.getName();
int age = person.getAge();
String address = person.getAddress();

📌 게터 매서드 추가하기

1️⃣ 클래스 객체파일에 추가
class Person {
    private String name;
    private int age;
    private String address;

    // 생성자
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    // 게터 (Getter) 매서드
    public String getName() { 
        return name; 
    }
    
    public int getAge() { 
        return age; 
    }
    
    public String getAddress() { 
        return address; 
    }
}

2️⃣ Main 게터 호출
public class Main {
    public static void main(String[] args) {
        // 👤 Person 객체 생성
        Person person = new Person("gygim", 25, "Seoul");

        // 📢 게터 호출하여 속성 가져오기
        String name = person.getName();
        int age = person.getAge();
        String address = person.getAddress();

        // 🖨 출력
        System.out.println("이름: " + name);
        System.out.println("나이: " + age);
        System.out.println("주소: " + address);
    }
}

• 세터는 객체의 속성을 외부에서 설정할수있게 해주는기능
• 보통 set필드명(값) 형태로 정의, 해당 속성 값을 변경하는 역할을함
• 주의! getName()이 아니라 setName()이 되어야함
• 올바른 네이밍은 setName(), setAge(), setAddress()
• Getter와 함께 사용하면 캡슐화를 유지하면서 속성을 관리할 수 있다함

💡세터를 사용해야하는이유?

1️⃣ 객체의 속성을 private으로 보호 (캡슐화)
→ 직접 수정 방지, 메서드를 통해 변경 가능 🚫
2️⃣ 변경할 때 추가 로직을 넣을 수 있음
→ 값이 유효한지 확인 가능!
3️⃣ 객체 내부 구현이 바뀌어도 외부 코드 수정 필요 없음
→ 유지보수가 쉬워짐!

📌 예제 (나이가 0보다 작으면 변경 불가)

    if (age < 0) {
        System.out.println("나이는 0이 될 수 없습니다!");
    } else {
        this.age = age;
    }
}

📌 세터매서드추가하기

1️⃣ 클래스 객체파일에 추가
class Person {
    private String name;
    private int age;
    private String address;

    // 생성자
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter (게터): 속성 값을 가져오기
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getAddress() { return address; }

    //  Setter (세터): 속성 값을 변경하기
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}
2️⃣ Main 에서 세터 사용하기
public class Main {
    public static void main(String[] args) {
        //  객체 생성
        Person personA = new Person("gygim", 20);
        Person personB = new Person("Steve", 15);

        // 세터 () 메서드를 사용하여 주소 변경
        personA.setAddress("서울");
        personB.setAddress("미국");

        //  값 출력
        System.out.println(personA.getName() + "의 주소: " + personA.getAddress());
        System.out.println(personB.getName() + "의 주소: " + personB.getAddress());
    }
}


gygim의 주소: 서울
Steve의 주소: 미국

📚 JAM 메모리구조

• Method Area (도서관 비유)

  • 프로그램시작시 정보가 저장됨
  • 클래스 정보(.class 파일) 가 올라가는 곳
  • 래스의 메서드 정보, static 변수 등이 저장
  • 모든 객체가 공유하는 공용공간
  • 프로그램 실행 시점에 한번만 저장됨

• Stack Area(접시 쌓기 비유)

  • 가장위에있는 접시부터 꺼내는것 처럼 비슷한 구조
  • 선입후출구조, 먼저 들어온것이 가장 늦게 나간다는 뜻임
  • 메서드가 호출될 때마다 새로운 접시한장(스택프레임)이 쌓임
  • 가장 위의 접시(최근 호출된 메서드)가 먼저 실행
  • 메서드가 시작되면 추가되고 메서드가 종료되면 사라지는 구조
  • 특정 메서드가 실행되면 해당 메서드의 정보와 변수가 Stack 에 저장되고 메서드 실행이 끝나면 그 메모리는 자동으로 제거 됨

  

• Heap Area(풍선 비유)
  • new 키워드로 생성된 객체는 Heap 영역에 저장됨
  • 객체의 실제 데이터 저장, 데이터 주소는 stack 영역에 저장됨
  • stack은 메서드 실행 중에만 필요한 데이터(지역 변수, 메서드 호출)를 저장하는 메모리 영역임!!
    

📌 래퍼클래스

• 기본자료형 을 객체로 감싸는 클래스

💡 왜사용할까?알아볼까나

• 기본형(int, double 등)은 그냥 숫자일 뿐, 기능이 없다!
  → int 자체로는 아무 기능도 못 하지만, Integer는 숫자를 변환하거나 비교하는 기능을 제공함
• 기본형은 리스트(List)에 못 넣는다!
  → List는 안 되지만, List는 가능! 그래서 기본형을 객체(Integer)로 감싸야 함
• null 값을 저장할 수 있다!
  → int num = null; ❌ 오류 발생! 저것은 숫자거덩
  → Integer num = null; ✅ 가능!왜냐 객체니까썁가능
• 자바가 자동으로 변환해 준다!
  → Integer num = 10; (int가 자동으로 Integer로 변환됨)
  → int value = num; (Integer가 자동으로 int로 변환됨)
  = 즉 본형을 객체처럼 다룰 수 있게 해 주는 게 레퍼클라스, 토달지마 지연아👍

자료형	래퍼클래스	종류	범위	바이트	비트
boolean	Boolean	논리형	true 또는 false	1	8
char	Character	문자형	0 ~ 65535 (유니코드 값)	2	16
byte	Byte	정수형	-128 ~ 127	1	8
short	Short	정수형	-32,768 ~ 32,767	2	16
int	Integer	정수형	-2,147,483,648 ~ 2,147,483,647	4	32
long	Long	정수형	-9,233,372,036,854,775,808 ~ 9,233,372,036,854,775,807	8	64
float	Float	실수형	약 소수점 6~7자리까지	4	32
double	Double	실수형	약 소수점 15~17자리까지	8	64

📌 래퍼클라스 예시

1️⃣ 클래스 객체파일
class CustomInteger {
		// 속성
  int value; 
  // 생성자
  CustomInteger(int value) {
      this.value = value;
  }
		// 기능
  // 값을 가져오는 메서드
  int getValue() {
      return value;
  }

  // 값을 설정하는 메서드
  void setValue(int value) {
      this.value = value;
  }

  // toString() 오버라이딩 (값을 출력할 수 있도록)
  @Override
  public String toString() {
      return String.valueOf(value);
  }
}
1️⃣ 메인 파일
public class Main {
  public static void main(String[] args) {
      CustomInteger num1 = new CustomInteger(100);
      System.out.println(num1); // 100
      System.out.println(num1.getValue()); // 100

      num1.setValue(200);
      System.out.println(num1); // 200
  }
}

📌 참조형

• 변수에 객체가 담기면 변수를 참조형 변수라고 말함

• 참조형 변수는 데이터가 저장된 메모리 주소를 가리키는데 Heap 메모리가 된다

• 객체데이터는 JAM 메모리구조 풍선에 비유했던 Heap 영역에 저장되어있기 때문임

• 객체, 배열등이 참조형에 속함

💡객체일경우

Person personA = new Person("Steve");  ✅ 객체가  담긴 personA 는 참조형 변수
Syetem.out.println(personA.name);
System.out.println(personA); // ✅ 출력하면 @123 메모리의 주소값이 출력됨

💡배열일경우

int[] arr = {1, 2, 3, 4}; // ✅ 배열이 담긴 arr 는 참조형 변수
System.out.println(arr); // ✅ 출력하면 @123 메모리의 주소값 출력 

1️⃣ 클래스 객체파일
class CustomInteger {
		// 속성
  int value; 
  // 생성자
  CustomInteger(int value) {
      this.value = value;
  }
		// 기능
  // 값을 가져오는 메서드
  int getValue() {
      return value;
  }

  // 값을 설정하는 메서드
  void setValue(int value) {
      this.value = value;
  }

  // toString() 오버라이딩 (값을 출력할 수 있도록)
  @Override
  public String toString() {
      return String.valueOf(value);
  }
}
1️⃣ 메인 파일
public class Main {
  public static void main(String[] args) {
      CustomInteger num1 = new CustomInteger(100);
      System.out.println(num1); // 100
      System.out.println(num1.getValue()); // 100

      num1.setValue(200);
      System.out.println(num1); // 200
  }
}

전체 흐름 
1️⃣ CustomInteger(100) → 처음에 100 저장
2️⃣ System.out.println(num1); → 100 출력됨
3️⃣ num1.setValue(200); → 값이 100 → 200으로 변경됨
4️⃣ System.out.println(num1); → 200 출력됨 ✅ 왜 뇌지진와 ㅠ 진정해 지연아 

✅ 기본형과 레퍼형 속도 확인 🏎️💨

• 기본형(int)은 그냥 숫자! → 연산이 바로바로 진행됨
• 래퍼 클래스(Integer)는 숫자를 감싼 '포장지' 같은 존재
• 래퍼클래스는 연산할 때마다 포장을 벗기고(언박싱) 다시 감싸야(오토박싱) 하기 때문에 느림!
• ⏳ 반복문처럼 많은 연산이 필요한 경우 기본형을 쓰는 게 유리함!
• 하지만! 객체처럼 사용해야 한다면 Integer도 필요할 때가 있음 🎁

비교 항목	기본형 (int)	래퍼 클래스 (Integer)
메모리 사용량	적게 차지함 int a = 10;	많이 차지함 (객체로 감싸야 해서) Integer b = 10;
연산 속도	빠름 int sum = a + 5;	느림 (포장을 벗기고 다시 씌우는 과정 필요) Integer sum = b + 5;
배열/리스트 저장	배열에 저장 가능 int[] arr = {1, 2, 3};	리스트, 맵에 저장 가능 List<Integer> list = new ArrayList<>();
null 저장 가능 여부	불가능	가능 (값이 없을 때 null 사용 가능) Integer c = null;
언제 사용하면 좋을까?	단순한 계산, 빠른 연산이 필요할 때 int result = a * 2;	리스트나 맵에 저장할 때, 객체처럼 다뤄야 할 때 Map<String, Integer> scores = new HashMap<>();

📌 궁금증 대마왕의 예제

int 연산 시간: 30ms  
Integer 연산 시간: 300ms  (10배 이상 느림)  
public class PerformanceTest {
  public static void main(String[] args) {
      int iterations = 10_000_000; // 1천만 번 반복

      ☑️ 기본형 int 연산
      long start1 = System.nanoTime();
      int sum1 = 0;
      for (int i = 0; i < iterations; i++) {
          sum1 += i;  //  더하기
      }
      long end1 = System.nanoTime();
      System.out.println("int 연산 시간: " + (end1 - start1) + " ns");

      ☑️ 래퍼 클래스 Integer 연산
      long start2 = System.nanoTime();
      Integer sum2 = 0;
      for (int i = 0; i < iterations; i++) {
          sum2 += i;  // 언박싱 & 오토박싱 발생
      }
      long end2 = System.nanoTime();
      System.out.println("Integer 연산 시간: " + (end2 - start2) + " ns");
  }
}

📚 static 클래스 공유

• static 키워드는 객체를 생성하지 않고도 사용할 수 있는 변수와 메서드를 정의할 때 사용됨
• 모든 객체가 같은 값을 공유 → 공용 데이터 관리에 적합
• 클래스 이름으로 직접 접근 가능 → 클래스명.변수명 or 클래스명.메서드명()
• Method Area(메서드 영역)에 저장되며 한 번만 생성됨
  
  

  구분	static 변수 (클래스 변수)	인스턴스 변수
  소속	클래스 자체	개별 객체
  생성 시점	클래스가 로드될 때 딱 한 번	객체가 생성될 때마다
  메모리 영역	Method Area(메서드 영역)	Heap 영역
  공유 여부	✅ 모든 객체가 공유	❌ 객체별로 독립적
  접근 방식	클래스명.변수명	객체명.변수명

⚠️ static 변수 vs 인스턴스 변수의 접근 방식 차이

• 변수가 어디에 속해 있고, 어떻게 접근할 수 있는지 이해를 해야해 지연아
• 학교 반에 학생, 넌 학생이고! 난 성생이양! >@<

변수 종류	설명	예시
static 변수 (클래스 변수)	모든 학생(객체)이 함께 공유하는 값	"학교 이름" 같은 거! 모든 반(객체)에서 같은 학교를 다님.
인스턴스 변수 (객체 변수)	각 학생(객체)이 개별적으로 가지는 값	"학생 이름" 같은 거! 각 학생(객체)마다 다른 이름을 가짐.

class School {
static String schoolName = "코딩 고등학교"; // 모든 학생이 공유하는 static 변수
String studentName; // 각 학생마다 다른 인스턴스 변수 

 \
School(String name) {    // 생성자 (학생 이름 설정)
      this.studentName = name;
  }
}

📔 Static 활용 (변수,메서드)

📌 static 변수(클래스 변수)

클래스가 로드될 때 한 번만 생성되고, 모든 객체가 공유함

static int count = 0;  //  모든 객체가 공유하는 변수
public Counter() {
        count++; // 생성될 때마다 count 증가
    }
}
public class Main {
    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
 System.out.println(Counter.count); // ⭐️ 출력: 3 
                                    (모든 객체가 같은 변수 공유)
    }
}

📌 static 메서드(클래스 메서드)

객체 없이 호출할 수 있고, 인스턴스 변수는 사용할 수 없음

class MathUtils {
static int add(int a, int b) {
      return a + b;
  }
}
public class Main {
  public static void main(String[] args) {
      int result = MathUtils.add(10, 20); // ✅ 클래스명.메서드명() 호출
      System.out.println(result); // 출력: 30
  }
}```

📕 인스턴스 멤버 (객체 생성 후 사용 가능!)

• 객체를 만들 때 생성되는 변수와 메서드

• 클래스만으로는 접근할 수 없음! (new 키워드로 객체 생성 필수)

• 각 객체마다 개별적으로 값을 가짐 (공유 안됨)

• Heap 영역에 저장됨 (객체가 사라지면 같이 삭제됨)

  

📌 인스턴스 예제

class Student {
  String name;         // 인스턴스 변수

  void introduce() {    // 인스턴스 메서드
      System.out.println("안녕하세요! 저는 " + name + "입니다.");
  }
}
public class Main {
  public static void main(String[] args) {
      Student student1 = new Student();   //
      student1.name = "지연";
      student1.introduce(); // 출력: 안녕하세요! 저는 지연입니다.

      Student student2 = new Student(); 
      student2.name = "민수";
      student2.introduce(); // 출력: 안녕하세요! 저는 민수입니다.
  }
}

✅확인하기
void introduce() // void → 반환값이 없음 (단순히 실행만 함) , introduce() → 이 메서드 이름 (자기소개하는 기능)
System.out.println("안녕하세요! 저는 " + name + "입니다."); //→ name에 저장된 값과 함께 출력
Student student1 = new Student() //객채생성

🧹 static 정리

구분	인스턴스 변수	클래스 변수 (static)	인스턴스 메서드	클래스 메서드 (static)
생성 시점	객체가 생성될 때	클래스가 로드될 때	객체가 생성될 때	클래스가 로드될 때
메모리 위치	Heap (객체별 저장)	Method Area (공유)	Heap	Method Area (공유)
공유 여부	❌ 객체마다 독립적	✅ 모든 객체가 공유	❌ 객체별로 실행	✅ 객체 없이 실행 가능
접근 방법	객체명.변수명	클래스명.변수명	객체명.메서드명()	클래스명.메서드명()
인스턴스 변수 사용	✅ 가능	❌ 불가능	✅ 가능	❌ 불가능

---

📑 상수와 불변객체_ final

📕 상수

• 상수는 변하지 않고 일정한 값을 갖는수
• Java에서 상수는 대문자로 표현하는 것이 관례임
• 프로그램 실행중에 절대 변경되서는 안되기 때문에 static final 키워드를 사용해 선언함
• static 키워드로 선언된 변수는 프로그램 시작 시 한 번만 초기화되며, 모든 인스턴스에서 같은 값을 공유

📌 대표적인선언예시

1. static final을 사용하여 상수를 선언
2. 변수명을 대문자로 작성하고, 여러 단어는 _(언더스코어)로 구분
3. PI, MAX_USER처럼 변하지 않는 중요한 값을 저장할 때 사용됨

  class Constants {
    static final double PI = 3.141592;  // ✅ 원주율 상수
    static final int MAX_USER = 100;   // ✅ 최대 사용자 수
}public class Main {
    public static void main(String[] args) {
        // ✅ 객체 생성 없이 클래스명.상수명으로 직접 접근 가능
        System.out.println("원주율: " + Constants.PI);
        System.out.println("최대 사용자 수: " + Constants.MAX_USER);
    }
}
출력 결과
원주율: 3.141592  
최대 사용자 수: 100   

📌 상수활용예시

class Messages {
  static final String WELCOME = "환영합니다!";
  static final String ERROR = "오류가 발생했습니다.";
}

public class Main {
  public static void main(String[] args) {
      System.out.println(Messages.WELCOME); // ✅ "환영합니다!" 출력
      System.out.println(Messages.ERROR);   // ✅ "오류가 발생했습니다." 출력

✔ 클래스가 두 개 있지만, Messages는 실행용이 아니라 상수 저장용
✔ Main 클래스에서 Messages의 상수를 불러와서 사용 🚀
  }
}

---

📘 불변객체

• 내부 상태를 변경할 수 없는 객체
• final 키워드를 사용하여 필드(속성)를 수정할 수 없도록 설정
• setter 메서드 없이 설계하여 변경을 방지
• 변경이 필요하면 새로운 객체를 생성해야 함
• 대표적인 불변객체 String, Integer, Double 등 래퍼 클래스

public final class Circle {  
    final static double PI = 3.14159; // ✅ 1️⃣ 클래스가 로드될 때 저장됨
    final double radius; // ✅ 3️⃣ 객체가 생성될 때 값이 설정됨

    Circle(double radius) {  
        this.radius = radius;  // ✅ 4️⃣ 생성자 실행 -> radius 값이 고정됨
    }
}

// ✅ 2️⃣ main 실행 (객체 생성 시작!)
public class Main {
    public static void main(String[] args) {
        Circle circle1 = new Circle(10.0); // ✅ 5️⃣ 반지름 10짜리 원 생성!
        Circle circle2 = new Circle(5.0);  // ✅ 6️⃣ 반지름 5짜리 원 생성!
    }
}
    }
}
  PI (static final)
→ 클래스가 처음 로드될 때 저장되고, 모든 객체가 공유!
radius (final)
→ 객체마다 개별 저장되고, 생성자에서 한 번만 설정 가능!

---

📙 인테페이스란?

모든 설계에는 표준이 필요하다!
인터페이스는 클래스가 반드시 따라야 할 규칙(표준)을 정의하는 역할함!

💡 인터페이스를 사용하는 이유 ?

• 개발자마다 다른 방식으로 메서드를 만든다면 일관성이 깨짐!
• 인터페이스를 활용하면 최소한의 규격을 정할 수 있음!
• 세부 구현은 각 클래스에서 자유롭게 확장 가능!
• 유지보수와 확장성이 뛰어난 코드 작성 가능!

🏢 인터페이스를 회사 규칙으로생각 해 보자!

개념	예시	설명
인터페이스	회사의 규칙서 📜	"출근 시간은 9시!" "이메일 도메인은 @company.com!"
클래스	직원 🧑‍💻	개발자는 코딩(), 디자이너는 디자인()을 해야 함!

📌 인터페이스 예제

class Employee {  
  void work() {
      System.out.println("직원이 일을 합니다!");
  }
}

class Developer extends Employee {
  @Override
  void work() {
      System.out.println("👨‍💻 개발자가 코딩을 합니다!");
  }
}

class Designer extends Employee {
  @Override
  void work() {
      System.out.println("🎨 디자이너가 디자인을 합니다!");
  }
}

public class Main {
  public static void main(String[] args) {
      Developer dev = new Developer();
      dev.work(); // 출력: 👨‍💻 개발자가 코딩을 합니다!

      Designer des = new Designer();
      des.work(); // ✅ 출력: 🎨 디자이너가 디자인을 합니다!
  }

📚 인터페이스기능

✅ 인터페이스 다형성 적용

(여러 구현체를 동일한 타입으로 다룰 수 있음!)

• 인터페이스 타입으로 객체를 다루면, 유연한 코드를 작성할 수 있음!

• 객체의 실제 타입(구현체)에 따라 다르게 동작(다형성)함.

• 유지보수성과 확장성이 좋아짐!

  📌 다중구현 예시(Main,Dog,Cat class 3개)

// 1️⃣ 인터페이스 정의 -Animal 인터페이스를 통해 Dog, Cat을 동일한 타입으로 다룰 수 있음
interface Animal {  
    void sound();  // 동물 소리를 내는 메서드
}
// 2️⃣ 인터페이스 구현 클래스 (구현체)
class Dog implements Animal {
    @Override
    public void sound() {
        System.out.println("🐶 멍멍!");
    }
}  //3️⃣ 인터페이스 구현 클래스 (구현체)
class Cat implements Animal {
    @Override
    public void sound() {
        System.out.println("🐱 야옹!");
    }
}
public class Main {
    public static void main(String[] args) {
        // 4️⃣ 다형성을 활용하여 인터페이스 타입으로 객체를 다룸!
        Animal myPet1 = new Dog();
        Animal myPet2 = new Cat();
  
        myPet1.sound(); // 출력: 🐶 멍멍!
        myPet2.sound(); // 출력: 🐱 야옹!
    }
}

✅ 인터페이스 다중구현

• implements 키워드를 사용하여 하나의 클래스가 여러 인터페이스를 구현할 수 있음.
• 한 개의 클래스가 여러 인터페이스를 구현한 경우 다중 구현 이라고 함(Animal, Flyable)
• 서로 관련 없는 기능을 조합하여 유연하고 확장성 있는 설계 가능!

자바에서는 extends를 이용한 클래스 다중 상속은 불가능하지만,
implements를 활용하면 여러 개의 인터페이스를 동시에 다중 구현 할 수 있다.

📌 다중구현예제

// ✅ 동물 인터페이스
interface Animal {
  void sound(); // 동물은 소리를 낸다
}
// ✅ 날 수 있는 인터페이스
interface Flyable {
  void fly(); // 날 수 있다
}

// ✅ 박쥐 클래스: Animal, Flyable 두 인터페이스를 구현 (다중 구현)
class Bat implements Animal, Flyable {
  @Override
  public void sound() {
      System.out.println("박쥐가 초음파를 냅니다!");
  }

  @Override
  public void fly() {
      System.out.println("박쥐가 날아갑니다!");
  }
}

public class Main {
  public static void main(String[] args) {
      Bat bat = new Bat(); //  박쥐 객체 생성

      bat.sound(); // 출력: 박쥐가 초음파를 냅니다!
      bat.fly();   // 출력: 박쥐가 날아갑니다!
  }
}

📌 Bird 객체가 가질 수 있는 기능

기능	설명	인터페이스	예제 메서드
날기	하늘을 날 수 있음	Flyable	void fly();
소리 내기	지저귐 (짹짹~)	Soundable	void sound();
걷기	땅에서 걸어 다님	Walkable	void walk();
먹기	먹이를 먹을 수 있음	Eatable	void eat();

💊 캡슐화_접근제어자

• 객체의 정보를 외부에서 직접 접근하지 못하도록 보호하는 개념임
• 마치 캡슐처럼 감싸서 내부를 보호하고, 외부에서 불필요한 접근을 차단하는 것

✅ 데이터 보호: 중요한 데이터가 외부에서 임의로 변경되는 것을 방지
✅ 유지보수용이: 객체 내부 로직이 변경되더라도 외부에 영향을 주지 않음
✅ 일관성 유지: 무분별한 데이터 수정 방지

public class Person {      // ✅ 외부에서 접근 불가 

  public String name;    // ✅ 외부에서 접근 불가 
  private String secret; // ❌ 외부에서 접근 불가 
  
  public Person() {}    // ✅ 외부에서 접근 불가 

  public void methodA() {}  // ✅ 외부에서 접근 가능
  private void methodB() {} // ❌ 외부에서 접근 불가

Person person = new Person(); // ✅ 접근가능 생성자가 public
person.name;                  // ✅ 접근가능 변수가 public
person.secret;                // ❌ 접근불가능 변수가 private
person.methodA();             // ✅ 접근가능 메서드가 public
person.methodB();             // ❌ 접근불가능 메서드가 private

접근제어자	클래스 내부	같은 패키지	자식 클래스	전체 접근
private	✅ 가능	❌ 불가능	❌ 불가능	❌ 불가능
default	✅ 가능	✅ 가능	❌ 불가능	❌ 불가능
protected	✅ 가능	✅ 가능	✅ 가능	❌ 불가능
public	✅ 가능	✅ 가능	✅ 가능	✅ 가능

📌 무분별한 세터

• Setter는 꼭 필요한 경우에만 한다!
• 값을 변경할 때는 유효성 검사를 추가한다!
• 불변 객체가 필요한 경우 final을 사용하여 값 변경을 막는다!
  💡 무조건 Setter를 만들지 말고, 객체의 안정성을 고려해서 설계하기

  ❌ Setter를 사용하면 안 되는 경우	✅ 해결 방법
  불변 객체를 만들 때	final 키워드를 사용하여 값 변경을 막음
  객체가 생성될 때 반드시 필요한 값이 있을 때	생성자를 통해 값 설정 & 이후 변경 불가
  값이 변경되면 프로그램 흐름이 달라질 때	유효성 검사를 포함한 메서드(deposit() 등) 사용

📌 세터 활용 예시

public class BankAccount {
  private int balance; // 계좌 잔액

  public BankAccount(int balance) { // 초기 잔액 설정
      this.balance = balance;
  }

  public int getBalance() {
      return balance;
  }

  // ✅ 예제: 입금 메서드 (유효성 검사 추가)
  public void deposit(int amount) {
      if (amount > 0) {
          balance += amount;
      }
  }

  // ❌ 잘못된 Setter (잔액을 마음대로 변경할 수 있음 → 제거!)
  // public void setBalance(int balance) {
  //     this.balance = balance;
  // }
}

📌 게터 활용 예시

public class Person { 
  private String secret;
   public String getSecret() {
		    return this.secret; // ✅ 객체의 secret 속성 반환
  }
}
public class Main {
  public static void main(String[] args) {
		    Person p1 = new Person();
		    p1.secret; // ❌ 직접 접근 불가능
		    String newSecret = p1.getSecret(); // ✅ 게터를 활용해 접근가능
  }
}

📒 캡슐 + 게터와세터 활용

• 객체의 데이터를 외부에서 막 변경하지 못하게 보호하기 위해!
• 직접 값을 바꾸면 실수할 수도 있으니까, Setter에서 "유효성 검사" 를 할 수 있음!
  = 즉 데이터 보호 + 조절임!!
  ✔️ Getter (getX()) → 변수를 읽는 함수
  ✔️ Setter (setX()) → 변수를 변경하는 함수

  📌 예시: "냉장고에서 우유 꺼내기"
  Getter = 우유가 얼마나 남았는지 보기
  Setter = 우유를 새로 사서 채우기

기능	Getter (getX())	Setter (setX())
역할	변수를 읽을 때 사용	변수를 변경할 때 사용
접근	외부에서 읽기 가능	외부에서 변경 가능
유효성 검사	없음	추가 가능 (잘못된 값 거부 가능)
활용 예시	getName(), getAge()	setName(), setAge()

1️⃣ 📌 Getter & Setter 데이터접근 예제

class Person {
    private String name;  // ✅ private → 직접 접근 ❌

    // ✅ Getter (값 읽기)
    public String getName() {
        return name;
    }

    // ✅ Setter (값 변경)
    public void setName(String newName) {
        this.name = newName;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();

        person.setName("지연");  // 이름 설정 (Setter 사용)
        System.out.println("이름: " + person.getName()); // 출력: 이름: 지연
    }
}

  
✔️ Getter (getName()) 을 사용해 name 값을 읽을 수 있음
✔️ Setter (setName()) 을 사용해 name 값을 변경할 수 있음

2️⃣ Setter에서 유효성 검사(잘못된 값 방지하기위함)
❌ 나이를 음수로 설정할 수 없도록 보호하기!❌

class Person {
    private int age;

    // ✅ Getter (나이 조회)
    public int getAge() {
        return age;
    }

    // ✅ Setter (나이 변경)
    public void setAge(int newAge) {
        if (newAge >= 0) {  // 🔴 0 이상만 가능하도록 설정
            this.age = newAge;
        } else {
            System.out.println("❌ 나이는 0 이상이어야 합니다!");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();

        person.setAge(25);  // ✅ 정상적인 값 입력
        System.out.println("나이: " + person.getAge()); // 출력: 나이: 25

        person.setAge(-5);  // ❌ 잘못된 값 입력 → 경고 메시지 출력
    }
}
✅ 출력값
나이: 25
나이는 0 이상이어야 합니다!  //❌ 세터에서 값이 이상하면 거부하도록 설정 가능!

3️⃣ Getter만 제공할경우 (읽기전용변수/보기만하셈-_-)
✔️ 한 번 정해지면 변경할 수 없는 데이터는 Setter 없이 Getter만 제공!

class User {
    private final String id;  // ✅ ID는 변경 불가능

    public User(String id) {  // ✅ 생성자로 ID 설정
        this.id = id;
    }

    // ✅ Getter만 제공 (Setter 없음)
    public String getId() {
        return id;
    }
}

public class Main {
    public static void main(String[] args) {
        User user = new User("user123");
        System.out.println("사용자 ID: " + user.getId()); // 출력: 사용자 ID: user123

        // ❌ user.setId("newID");  → 컴파일 에러 발생!
    }
}
  
✅ 출력값

사용자 ID: user123

---

📒 상속 (부모,자식클래스)

• 클래스간 관계를 부모/상위, 자식/하위, 로 바라보는 개념
• 상속에서는 재사용성, 확장 이 가능함🌟 중요키워드
  → 물려받은 속성과 기능은 자식 클래스에서 재사용할 수도,확장할수도있음
• extends 키워드를 사용해서 상속관계를 구현함
• 객체지향의 중요한 개념 추상화, 다형성을 구현하는 데 활용됨

공통된 기능이나 속성을 자식 클래스들에게 제공하고 싶을 때 사용함
부모 클래스에서 재사용할 수 있는 멤버 변수나 메서드를 정의
자식 클래스들이 상속받아 재사용하는 방식으로 기억하면하기. 오키지연?
= 중복을 줄이고 변경사항을 부모클래스만 수정하면 자식 클래스에도 자동으로 적용되므로 유지보수가 쉬워질수있다함

📌 상속 예시_문자열

// 1️⃣ 부모 클래스
public class Parent { 
  public String familyName = "스파르탄";
  public int honor = 10;

  public void introduceFamily() {
      System.out.println("우리 " + this.familyName + " 가문은 대대로 명성을 이어온...");
  }
}
// 2️⃣ 자식 클래스 (상속)
class Child extends Parent { // ✅ extends 키워드 활용
}

3️⃣  Main 클래스 (실행 클래스)
public class Main {
  public static void main(String[] args) {
        // 자식 클래스 객체 생성
      Child child = new Child(); // Child 생성자 호출
      System.out.println(child.honor); // ✅ 부모 속성 사용
      child.introduceFamily(); // ✅ 부모 메서드 사용
  }
}
✅ 출력값
부모 클래스 생성자 호출!
자식 클래스 생성자 호출!
우리 가문의 이름은 김
원래 가문의 이름은 스파르탄

✔️ extends  자식 클래스에서 부모 클래스를 상속받을 때 사용
✔️ super() 자식 클래스의 생성자에서 부모 클래스의 생성자를 호출( 생략 가능하지만 명시적으로 호출하면 부모가 먼저 실행된다함/참고)
✔️ this 자식 클래스 자신의 변수를 참조할 때 사용, 자신을 가르킴
✔️ super 부모 클래스의 변수를 참조할 때 사용

📌 상속 예시_문자열

1️⃣ 부모 클래스  
class Parent {
    // 부모 클래스에서 문자열 변수 정의
    String familyName = "스파르탄";  // 문자열 변수
    int age = 50;  //  숫자 변수 정의
  
    boolean isActive = true;  // 부모 클래스에서 불린 변수
} 
class Parent {
    String familyName = "스파르탄";  // 부모 클래스의 변수
    int age = 50;  // 부모 클래스의 변수
}
2️⃣ 자식 클래스 (상속)
class Child extends Parent {  // 부모 클래스 상속
    public void showInfo() {
        // 자식 클래스에서 부모 클래스의 변수 사용
        System.out.println("우리 가문의 이름은 " + familyName);  // 부모 클래스의 familyName 사용
        System.out.println("부모의 나이는 " + age);  // 부모 클래스의 age 사용
    }
}
3️⃣  Main 클래스 (실행 클래스)
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.showInfo();  // 자식 클래스에서 부모 클래스의 변수 출력
    }
}
  
✅ 출력 값
부모의 나이는 50

🔖 부모 메서드 변수 참조(super,this)

핵심 💫
this는 자식 클래스의 멤버를, super는 부모 클래스의 멤버를 명확하게 참조할 때 사용하자! 알았어? 박지ㅇㅕㄴ!???

1️⃣ this 키워드

• this. 자식 클래스의 객체킴
• 자식 클래스에서 자식클래스의 변수나 메서드를 사용할 때 사용

 class Child {
    String name = "자식";  // ✅ 자식 클래스의 변수
    public void printName() {
        System.out.println("자식 클래스에서 호출: " + this.name);  // ✅ this. 자식 클래스 변수 ⭐️
    }
}

2️⃣ super 키워드

• super는 부모 클래스를 가리킴
• 자식 클래스에서 부모 클래스의 변수나 메서드를 사용할 때 사용하기

class Parent {
    String name = "부모";  // ✅ 부모 클래스의 변수
}

class Child extends Parent {
    String name = "자식";  // ✅ 자식 클래스의 변수
    
    public void printName() {
        System.out.println("부모 클래스에서 호출: " + super.name);  // ✅ super. 부모 클래스 변수 ⭐️
    }
}

🔖 클래스 생성자 호출 (super(),this())

핵심 💫
super()는 부모 클래스의 생성자를 호출, this()는 자식 클래스 내에서 다른 생성자를 호출할 때 사용함

1️⃣ this() 키워드

• this()는 자식 클래스 내에서 다른 생성자를 호출할때 사용
  📋...이해 안 됐음.. 더 찾아봄..
  • this()를 사용해서 자식 클래스 내에서 다른 생성자를 호출할수있다임 다시..순서를 차근차근 생각해보자.지연 이럴수도 있어 괜찮아!
  1. 자식 클래스Child 에는 2개의 생성자가있어.
     1.1 Child() this("기본이름")를 사용하는 자식 클래스 기본 생성자 호출하는 녀석
     1.2 Child(String name)문자열 출력하는녀석 오키 이건 아까부터 알았어.
  2. Main 클래스에서 new Child() 객체를 생성하는거야!!이제 불러!
     2.1 Child child = new Child(); (클래스명/객체명 = new 클래스명;)

 //부모클래스 
class Child {
    Child() {
        this("기본 이름");  // ✅ this() 다른 생성자 호출 ⭐️
        System.out.println("자식 클래스 기본 생성자 호출");
    }
   Child(String name) {
        System.out.println(name + "으로 자식 클래스 생성");
    }
}
 //메인 실행클래스
  public class Main {
    public static void main(String[] args) {
        Child child = new Child();  // 첫 번째 생성자가 호출되면서 두 번째 생성자 호출
    }
}

2️⃣ super() 키워드

• super()는 부모 클래스의 생성자를 호출할 때 사용
• 자식 클래스에서 부모 클래스의 생성자가 필요하면 super()를 명시적으로 해야함!

  //부모클래스
class Parent {
    Parent() {
        System.out.println("부모 클래스 생성자");
    }
}
//메인실행클래스
class Child extends Parent {
    Child() {
        super();  // ✅ 부모 클래스 생성자 호출 ⭐️
        System.out.println("자식 클래스 생성자");
    }
}

---

📣 상속 기능 확장

• 부모클래스의 기능을 유지하면서 자식클래스에서 기능을 확장수있음(개끌?)
• 자식클래스에서 새로운 메서드를 추가하거나 부모클래스의 메서드를 수정할수있음
• 자식클래스는 부모클래스의 멤버(변수, 메서드)를 그대로 사용할 수 있고 필요시 새로운 기능을 추가할수있음
  ❌너 박지연 매서드 정의할대 카멜표기저거잊지마라getUserInfo() 알지?

  // 1️⃣ Parent 클래스 (부모 클래스)
class Parent {
    String name = "부모";  // ✅부모 클래스의 변수
}
// 2️⃣Child 클래스 (자식 클래스)
class Child extends Parent {
    String name = "자식";  // ✅ 자식 클래스의 변수
  
  public void printName() { ✅  printName() 매서드 정의
        System.out.println("부모의 이름: " + super.name);  // 부모 클래스의  변수
        System.out.println("자식의 이름: " + this.name);  // 자식 클래스의 변수
    }
}
// 3️⃣ Main 클래스 (실행 클래스)
public class Main {
    public static void main(String[] args) {
        Child child = new Child();  // ✅ 자식 클래스 객체 생성
        child.printName();  // ✅ printName 메서드 호출
    }
}

📖 재정의 오버라이딩

• 오버라이딩은 자식 클래스에서 부모 클래스의 메서드를 새롭게 정의하는것!
• 부모 클래스에서 정의된 메서드를 자식 클래스에서 다르게 구현할 수 있음

💡 부모 클래스에서 정의된 메서드를 자식 클래스에서 다르게 구현하는것
1. @Override 어노테이션을 사용하면 부모 클래스에 메서드가 없으면 컴파일러가 알려주기 때문에 실수를 방지할 수 있다.
2. 메서드 이름, 매개변수, 반환 타입은 부모 클래스의 메서드와 완전히 동일해야함

📌 오버라이딩 예시

 // 부모 클래스
class Animal {
    void makeSound() {
        System.out.println("동물이 소리를 낸다.");
    }
}
// 자식 클래스 Dog
class Dog extends Animal {
    @Override  // 부모 클래스의 메서드를 오버라이딩
    void makeSound() {
        System.out.println("멍멍!");
    }
}
// 자식 클래스 Cat
class Cat extends Animal {
    @Override  // 부모 클래스의 메서드를 오버라이딩
    void makeSound() {
        System.out.println("야옹!");
    }
}
//메인 실행 클래스
public class Main {
    public static void main(String[] args) {
        // Animal 타입 변수로 객체 생성
        Animal myDog = new Dog();  // Dog 객체
        Animal myCat = new Cat();  // Cat 객체
              
        myDog.makeSound();  // "멍멍!" 
        myCat.makeSound();  // "야옹!"  
 ✅ 출력 값   
  "멍멍!"
  "야옹!"
  }
}

📙 추상클래스

• 객체를 생성할 수 없는 클래스로 설계도 역할을 함
• 자식 클래스에게 반드시 구현해야 할 메서드를 강제로 지정하고 싶을 때 사용함
• abstract 키워드를 사용하여 추상 메서드를 정의할수있음
• 🙅‍♀️추상클래스로 객체를 생성할순없음
• 추상 메서드는 자식 클래스에서 구현해야함

  💡추상 메서드는 선언만 하고 구현부 {}는 작성하지않는다!
  void makeSound(); ← 여기까지만 입력하는 느낌

// 1️⃣ 추상 클래스
abstract class Animal {
    // 추상 메서드 (자식 클래스에서 구현해야 함)
    abstract void makeSound();
}
// 2️⃣ 자식 클래스
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("멍멍!");
    }
}
3️⃣ Main 클래스 (실행 클래스)
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound();  // "멍멍!" 출력
    }
}

📌 🎯 추상 클래스 vs 인터페이스 비교 표

같은것같지만 다른,,넘,,

특성	추상 클래스 (Abstract Class)	인터페이스 (Interface)
인스턴스 변수	O (멤버 변수 선언 가능)	X (멤버 변수 선언 불가능)
메서드 구현	O (일반 메서드 + 추상 메서드)	X (기본적으로 모든 메서드는 추상 메서드)
다중 상속	X (하나만 상속 가능)	O (여러 개 구현 가능)
사용 목적	계층 구조 표현 (공통 속성, 기능 재사용)	공통된 기능을 정의 (표준 제공)
생성자 사용	O (생성자 선언 가능)	X (생성자 선언 불가능)
키워드	abstract 키워드 사용	interface 키워드 사용
접근 제어자	O (public, protected, private 사용 가능)	X (모든 메서드는 기본적으로 public)

✔️ 추상 클래스는 부모-자식 관계를 만들고 공통 속성과 기능을 물려주기 위해 사용

✔️ 인터페이스는 다중 구현이 가능하며 여러 클래스에서 동일한 기능을 강제할 때 사용

---

📘 추상화 (Abstraction)

• 추상화란 불필요한 정보를 제거하고 본질적인 특징만 남기는 것을 의미함
• 객체지향 프로그래밍에서는 추상화의 계층적 특징을 활용하여 유지보수성이 좋은 프로그램을 만들 수 있음
• 인터페이스 상속과 클래스 상속을 활용하여 추상 계층을 표현할 수 있음
• 추상화의 특징은 다형성에서 더욱 강력하게 활용됨

✔️ 추상화의 핵심 개념

개념	설명
추상화(Abstraction)	불필요한 세부 구현을 숨기고 핵심적인 부분만 노출하는 개념
추상 클래스(Abstract Class)	abstract 키워드를 사용하여 공통 기능을 정의하고, 일부 메서드를 자식 클래스에서 구현하도록 강제하는 클래스
인터페이스(Interface)	모든 메서드가 추상 메서드로만 이루어진 구조. 여러 클래스를 표준화하기 위해 사용
추상화 계층	클래스 또는 인터페이스를 사용하여 상위 개념에서 하위 개념을 설계하는 계층 구조

📌 추상화 계층 표현 예시

• 인터페이스 상속을 활용한 추상 계층 표현 (interface)
  • 인터페이스를 사용하여 규칙을 정의하고 여러 클래스가 구현할 수 있도록 함

// 1️⃣ 인터페이스 정의 (설계)
interface Animal {
    void makeSound();  // ✅ 추상 메서드 interface 활용 구현 강제
}

// 2️⃣ 인터페이스 구현 (각 클래스마다 동물 다르게 구현)
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("멍멍! 🐶");
    }
}
class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("야옹! 🐱");
    }
}

// 3️⃣ Main 클래스 (실행 클래스)
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();  
        Animal myCat = new Cat();

        myDog.makeSound();
        myCat.makeSound(); 
    }
}
 ✅ 출력 값   
멍멍! 🐶
야옹! 🐱

📌 클래스상속 추상 계층 표현 예시

• 추상 클래스를 사용하여 공통 기능을 정의, 자식 클래스가 구체적인 기능을 구현하도록!

// 1️⃣ 추상 클래스 정의 (설계)
  //각 차량마다 다르게 구현해야 할 추상 메서드
abstract class Vehicle {
    abstract void move(); // ✅ 추상 메서드 (구현 강제)

    void stop() {  // ✅ 공통 기능 제공 메서드
        System.out.println(" 차량이 멈췄습니다.");
    }
}

// 2️⃣ 추상 클래스 상속 (각 차량마다 다르게 구현)
class Car extends Vehicle {
    @Override
    void move() {
        System.out.println("🚗 자동차가 도로를 달립니다.");
    }
}

class Airplane extends Vehicle {
    @Override
    void move() {
        System.out.println("✈️ 비행기가 하늘을 납니다.");
    }
}
// 3️⃣ Main 클래스 (실행 클래스)
public class Main {
    public static void main(String[] args) {
        Vehicle myCar = new Car();
        Vehicle myPlane = new Airplane();

        myCar.move(); // 출력: 🚗 자동차가 도로를 달립니다.
        myPlane.move(); // 출력: ✈️ 비행기가 하늘을 납니다.

        myCar.stop();  // 출력: 차량이 멈췄습니다.
    }
}
  
✅ 추상 클래스를 활용하면 Vehicle이라는 공통 기능(stop)은 유지하면서
✅ move() 메서드는 각 클래스에서 다르게 구현할 수 있음을 알수있다!
  = 즉 공통기능 구현!

💡 추상 클래스 vs 인터페이스 차이점

• 추상화는 불필요한 정보를 숨기고 중요한 요소만 노출하는 것
• 인터페이스는 표준을 정의하고, 여러 클래스가 동일한 규칙을 따르도록 강제
• 추상 클래스는 공통 기능을 제공하면서 일부 기능은 자식 클래스에서 구현하도록 강제 할수있음
• 상황에 따라 추상 클래스와 인터페이스를 적절히 활용하여 유지보수성을 높이기

비교 항목	추상 클래스	인터페이스
선언키워드	abstract class	interface
메서드 구성	일반 메서드 + 추상 메서드 가능	모든 메서드가 추상 메서드
변수 구성	일반 변수 선언 가능	모든 변수는 public static final (상수)
상속 방식	extends 키워드를 사용해 1개만 상속 가능	implements를 사용해 다중 구현 가능
사용 목적	공통 기능을 제공하면서 일부 기능을 강제	표준(규격)을 정의하여 여러 클래스에서 구현

📔 객체의 다형성

• 하나의 타입으로 여러 객체를 다룰 수 있는 기술임
• 부모 클래스의 타입 사용하여 자식 클래스 객체를 처리

  // 1️⃣ 인터페이스 정의 (설계)
interface Animal {  ✅  interface 활용 구현 강제
    void makeSound();  // 동물마다 소리를 냄
    void exist();      // 동물이 존재한다
}
// 2️⃣ 인터페이스 구현 (각 클래스마다 동물 다르게 구현)
  // Dog 클래스
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("멍멍!");
    }
    @Override
    public void exist() {
        System.out.println("나는 개입니다.");
    }
}
// Cat 클래스
class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("야옹!");
    }
    @Override
    public void exist() {
        System.out.println("나는 고양이입니다.");
    }
}
  3️⃣ Main 클래스 (실행 클래스)
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  // ✅ 객체 생성!
        animal.makeSound(); 
        animal.exist();      

        animal = new Cat();  // ✅ 재 할당 
        animal.makeSound();  
        animal.exist();    
  ✅ 출력 값 
  멍멍!
  나는 개입니다.
  야옹!
  나는 고양이입니다.
  
  ✔️ Animal animal = new Dog();로 Dog 객체를 할당한 후 
     animal = new Cat();로 재할당한거임 그래서 소문자임

📚 형변환(업/다운)

📘 업 캐스팅 (자식 → 부모)

• 자식 클래스 객체를 부모 클래스 타입으로 변환하는 과정
• 자식 클래스는 부모 클래스의 모든 속성과 메서드를 상속받기 때문에 자식 객체를 부모 타입으로 자동으로 변환할수있음
  ⭐️ 안전하고 명시적인 캐스팅 없이 이루어짐

📌 업캐스팅 예시

 1️⃣ 인터페이스 정의 (설계)
interface Animal {   ✅  interface 활용 구현 강제
    void makeSound();  // Animal 인터페이스
}
  
2️⃣ 인터페이스 구현
class Dog implements Animal {  
    @Override
    public void makeSound() {
        System.out.println("멍멍!");
    }
    public void fetch() {
        System.out.println("공을 물어옵니다.");
    }
}
3️⃣ Main 클래스 (실행 클래스)  
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog(); // ✅ 자동 형 변환

        // 1. Dog 객체를 Animal 타입으로 업캐스팅
        Animal animal = dog;  
        animal.makeSound();  //  ✅ Animal 타입에서 정의된 메서드만 사용 가능
  
        // animal.fetch();  //  ❌ 오류! Animal 타입에서는 fetch()를 알지 못함
    }
}

    }
}

📙 다운 캐스팅(부모 → 자식)

• 부모 클래스를 자식 클래스의 객체로 변환하려면 ⭐️ 명시적인 캐스팅이 필요함
• 잘못된 다운 캐스팅을 시도하면 에러가 발생할 수 있기 때문에 타입 확인이 중요함
• 다운캐스팅에는 instanceof는 인스턴스인지 확인해주는 역할을함
• if , else로 유형을 확인하자!

1️⃣ 인터페이스 정의 (설계)
  class Animal {
    void makeSound() {
        System.out.println("소리");
    }
}
2️⃣ 인터페이스 구현
// Dog 클래스
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("멍멍!");
    }
    void wagTail() {
        System.out.println("꼬리를 흔든다.");
    }
}
// Cat 클래스
class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("야옹!");
    }
    
    void scratch() {
        System.out.println("긁는다.");
    }
}
3️⃣ Main 클래스 (실행 클래스)  
public class Main {
    public static void main(String[] args) {
        // ✅ Animal 타입으로 Dog 객체를 생성
        Animal animal = new Dog(); 
        
        // ✅ 만약 생성한게 Dog 객체라면 wagTail()을 호출
        if (animal instanceof Dog) { 
            Dog dog = (Dog) animal;  // animal을 Dog 타입으로 바꿔줌
            dog.wagTail();  // "꼬리를 흔든다." 출력
        } 
        // ✅ 만약 animal이 Cat 객체라면 scratch()을 호출
        else if (animal instanceof Cat) { 
            Cat cat = (Cat) animal;  // animal을 Cat 타입으로 바꿔줌
            cat.scratch();  // "긁는다." 출력
        } 
        //✅  만약 Dog도 아니고 Cat도 아니라면 예상하지 못한 타입일 경우 출력
        else {
            System.out.println("알 수 없는 동물입니다.");
        }
        
        // animal 객체  호출
        animal.makeSound(); 
    }
}
 ✅ 출력 값 
꼬리를 흔든다.
멍멍!