JAVA 🔥🔥 정리 및 오답노트 🔥🔥

기본 개념정리

• print 줄바꿈❌❌❌, println : 줄바꿈⭕⭕⭕!!!!

• 띄어쓰기 여부 확인!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

• 생성자

  생성자는 객체를 생성할 때 호출되는 특별한 메서드

• 상속 관계에 있을 때 생성자 호출

  자바에서 상속 관계에 있을 때 생성자를 호출하면, 자식 클래스의 생성자 실행에 앞서 부모 클래스의 생성자가 먼저 호출된다. super를 사용해 명시적으로 부모 클래스의 생성자를 지정할 수 있으며, 이 경우 지정된 부모 생성자가 실행된다. 명시적으로 부모 생성자를 호출하지 않으면, 묵시적으로 인자 없는 부모 클래스의 기본 생성자가 자동으로 호출된다.
  부모 클래스의 생성자가 실행을 마치고 나면, 자식 클래스의 생성자로 돌아와서 코드를 계속 실행한다.

• 오버 로딩

  같은 이름의 메서드를 매개변수의 개수 또는 타입에 따라 여러번 정의하는 것

  class Calculator {
      // add 메서드, 오버로딩을 사용하여 정의
      int add(int a, int b) {
          return a + b;
      }
  
      // 매개변수의 개수가 다른 add 메서드
      int add(int a, int b, int c) {
          return a + b + c;
      }    
    }
        
  Calculator calc = new Calculator();
  System.out.println(calc.add(5, 10));        // 15
  System.out.println(calc.add(5, 10, 15));   // 30

• 오버 라이딩

  상속 관계 에서 부모 클래스의 메서드를 자식 클래스가 재정의 하는 것. (메서드명, 매개변수의 타입과 개수, 반환 타입은 동일해야 함)

  class Animal {
    void sound() {
          System.out.println("동물 소리");
      }
  }
  
  class Dog extends Animal {
      // Animal 클래스의 sound 메서드 오버라이딩
      void sound() {
          System.out.println("멍멍");
      }
  }
  Animal dog = new Dog();
  dog.sound();  // 멍멍

• 하이딩

  상위 클래스의 static 메서드를 하위 클래스에서 같은 유형으로 다시 선언하는 것. 하이딩된 메서드는 메서드 호출이 클래스 타입에 따라 결정된다. (상속 관계에서만 발생하며 정적 메서드에 한정된 특성)

  class Base {
      static void display() {
          System.out.println("부모 클래스의 디스플레이 메서드");
      }
  }
  
  class Derived extends Base {
      // Base 클래스의 display 메서드 히딩
      static void display() {
          System.out.println("자식 클래스의 디스플레이 메서드");
      }
  }
  Base.display();      // 부모 클래스의 디스플레이 메서드
  Derived.display();   // 자식 클래스의 디스플레이 메서드

• 오버라이딩 vs 하이딩

  class A {
     static void f() { System.out.print("1 "); } // 부모 클래스의 정적 메서드
     void g() { System.out.print("2 "); } // 부모 클래스의 인스턴스 메서드
  }
  class B extends A {
     static void f() { System.out.print("3 "); } // 하이딩: A 클래스의 f() 메서드를 하이딩
     void g() { System.out.print("4 "); } // 오버라이딩: A 클래스의 g() 메서드를 오버라이딩
  }
  class C {
     public static void main(String[] args) {
         A a = new B();
         a.f(); // 하이딩된 메서드 호출, A의 f()가 호출됨
         a.g(); // 오버라이딩된 메서드 호출, B의 g()가 호출됨
     }
  }

• 추상 클래스 (abstract)

  // 추상 클래스 정의
  abstract class 동물 {
     abstract void 울다();  // 추상 메서드, 구현되지 않음
  
     // 추상 클래스 내에서도 일반 메서드 구현이 가능
     void 숨쉬다() {
         System.out.println("숨을 쉽니다.");
     }
  }
  // 추상 클래스를 상속받은 구체적인 클래스 정의
  class 개 extends 동물 {
     // 추상 메서드 '울다' 구현
     void 울다() {
         System.out.println("멍멍!");
     }
  }
  class 고양이 extends 동물 {
     // 추상 메서드 '울다' 구현
     void 울다() {
         System.out.println("야옹!");
     }
  }
  public class 추상클래스예제 {
     public static void main(String[] args) {
         개 개 = new 개();  // '개' 클래스의 인스턴스 생성
         개.울다();  // 구현된 메서드 호출
         개.숨쉬다();  // 상속받은 일반 메서드 호출
  
         고양이 고양이 = new 고양이();  // '고양이' 클래스의 인스턴스 생성
         고양이.울다();  // 구현된 메서드 호출
         고양이.숨쉬다();  // 상속받은 일반 메서드 호출
     }
  }

• 하나 이상의 추상 메서드(abstract method)를 포함하는 클래스로, 이 메서드들은 선언만 있고 구현이 없어서, 이를 상속받는 하위 클래스에서 반드시 구현해야 한다.
• 추상 클래스 자체로는 인스턴스를 생성할 수 없다

• 인터페이스

  • 모든 메서드가 기본적으로 추상 메서드인 형태 => 객체 생성 불가
  • 구현된 상태 없이 전부 시그니처(선언)만 있는 구조
  • implements와 함께 쓰인다! (extends 아니야!!!!!!)

실수 double, float

• Java에서는 유형을 지정하지 않고 십진수를 사용하면 기본적으로 double로 처리
  (명시적으로 float로 만들려면 24.8f와 같이 숫자 뒤에 f 또는 F를 추가해야 함)

  
  class Calculate {    
      public int cal(int a, int b) {
          return a - b; // a와 b의 차를 반환
      }
  
      // 두 실수(float)의 덧셈을 수행하는 메서드
      public float cal(float a, float b) {
          return a + b; // a와 b의 합을 반환
      }
  
      // 두 실수(double)의 덧셈을 수행하는 메서드
      public double cal(double a, double b) {
          return a + b; // a와 b의 합을 반환
      }
  
      // 세 정수의 덧셈을 수행하는 메서드
      public int cal(int a, int b, int c) {
          return a + b + c; // a, b, c의 합을 반환
      }
  }
  
  class Example {
      public static void main(String[] args) {
          Calculate a = new Calculate(); // 'Calculate' 클래스의 인스턴스 생성
  
          System.out.println(a.cal(31, 69, 25)); // 출력: 125
  
          // 실수(double) 덧셈 메소드 호출 및 결과 출력
          System.out.println(a.cal(24.8, 5.1)); // 출력: 29.9
      }
  }

사용된 기법

class Adder {
    // 오버로딩(Overloading): 같은 이름의 메서드를 매개변수의 유형과 개수를 다르게 해서 여러 개 정의
    public int add(int a, int b) { return a+b; } // 정수 덧셈
    public double add(double a, double b) { return a+b; } // 실수 덧셈
}

// Computer 클래스: Adder 클래스를 상속(Inheritance)받아 새로운 기능을 추가
class Computer extends Adder {
    // 캡슐화(Encapsulation) 및 정보 은닉(Information Hiding): 변수 x를 private로 선언하여 외부 접근 제한    
    private int x;

    // 오버로딩된 add 메서드: 매개변수가 세 개인 정수 덧셈
    public int cal(int a, int b, int c) {
        if (a == 1) return add(b, c); // 상속받은 Adder의 add 메서드 사용
        else return x;
    }
}

class Adder_Main {
    public static void main(String[] args) { 
        Computer c = new Computer();
        
        // 오버로딩된 메서드 호출: int 형식과 double 형식에 맞게 add 메서드가 호출됨
        System.out.println("100 + 200 = " + c.add(100, 200)); 
        System.out.println("5.7 + 9.8 = " + c.add(5.7, 9.8));
    }
}

변수의 유효범위

// 기본 클래스 X 정의
class X {
  int i;
  X() { i = 10; }  // 생성자에서 i를 10으로 초기화
  void print() { System.out.print(i+", "); }  // i값 출력
}

// X를 상속받는 클래스 Y 정의
class Y extends X {
  int i;  // 클래스 X와 동일한 이름의 i 변수를 가짐
  int j;
  Y() { 
      i = 15;  // Y의 i를 15로 초기화
      j = 20;  // Y의 j를 20으로 초기화
  }
  void print() { System.out.print(j+", "); }  // Y의 j값 출력
  void superprint() { super.print(); }  // X의 print() 호출
}

// Y를 상속받는 클래스 Z 정의
class Z extends Y {
  int k;
  Z() {
      super();  // 부모 클래스 Y의 생성자 호출
      k = 30;  // Z의 k를 30으로 초기화
  }
  void print() { System.out.print(k+", "); }  // Z의 k값 출력
  void test() {
      print();  // Z의 print() 호출
      superprint();  // Y의 print() 호출
      System.out.print(super.j+", ");  // Y의 j값 출력
      System.out.println(i);  // Z의 i값 출력 (여기서는 Y의 i가 출력됨)
  }
}

// 메인 클래스와 메인 메서드 정의
public class Main {
  public static void main(String[] args) {
      Z z = new Z();  // Z 클래스의 인스턴스 생성
      z.test();  // Z의 test() 메서드 호출
  }
}