목차

• 배운 내용 정리
  • Java
    • Java란?
    • JVM (Java Virtual Machine)
    • JDK (Java Development Kit)
  • Java 기본 문법
    • 자료형
    • 입출력
    • 조건문
    • 반복문
  • 객체 지향 프로그래밍
    • 접근 제어자 (Access Modifiers)
    • 클래스와 객체
    • OOP의 네 가지 원칙
  • 스트림 (Stream)
• 후기

배운 내용 정리

Java

Java란?

• 객체 지향 프로그래밍 (Object-Oriented Programming): Java는 객체 지향 언어로, 데이터를 객체로 관리하고 조작할 수 있다. 하지만 Java는 순수 객체 지향 언어로 간주되지는 않는다. 기본 데이터 타입(예: int, char 등)을 지원하기 때문.
• 플랫폼 독립성 ("Write Once, Run Anywhere"): Java로 작성된 프로그램은 어떤 운영체제에서도 실행될 수 있다. Java 프로그램이 바이트코드로 컴파일되고, 이 바이트코드가 JVM에 의해 해석되기 때문이다.
• C/C++과 유사한 문법: Java의 문법은 C와 C++의 영향을 받아 유사하지만, Java는 포인터와 같은 저수준 프로그래밍 기능을 제공하지 않는다.

JVM (Java Virtual Machine)

JDK (Java Development Kit)

Java 기본 문법

자료형

image.png

입출력

import java.util.Scanner; // java.util 패키지 내 존재
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("이름을 입력하시오: ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

조건문

int number = 10;
 
if (number > 0) {
    System.out.println("양수");
} else if (number < 0) {
    System.out.println("음수");
} else {
    System.out.println("zero");
}

char grade = 'B';
 
switch (grade) {
    case 'A':
        System.out.println("Excellent!");
        break;
    case 'B':
    case 'C':
        System.out.println("Well done");
        break;
    case 'D':
        System.out.println("You passed");
        break;
    case 'F':
        System.out.println("Better try again");
        break;
    default:
        System.out.println("Invalid grade");
}
 

반복문

// for
for (int i = 0; i < 5; i++) {
    System.out.println("Count: " + i);
}

// while
int count = 0;
while (count < 5) {
    System.out.println("Count: " + count);
    count++;
}

// do-while
int count = 0;
do {
    System.out.println("이거 한번은 출력 됩니다.");
} while (false);
 

객체 지향 프로그래밍

접근 제어자 (Access Modifiers)

클래스와 객체

class Member {
    String name;
    int generation; // 기수
 
    public Member(String name, int generation) {
        this.name = name;
        this.generation = generation;
    }
 
    public void eoheung() {
        System.out.println(name + ": 어흥 🦁");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Lion newMember1 = new Dog("12기 아기사자", 12);
        newMember1.eoheung();
    }
}

OOP의 네 가지 원칙

• 추상화(Abstraction):
  • 불필요한 세부 정보를 숨기고 중요한 정보를 강조하는 개념.
  • Java에서는 인터페이스와 추상 클래스가 추상화를 구현하는 데 사용된다.

  // 추상 클래스
  abstract class Animal {
      // 추상 메서드 (구현은 하위 클래스에서 제공)
      abstract void sound();
  }
   
  // 구체적인 하위 클래스
  class Dog extends Animal {
      @Override
      void sound() {
          System.out.println("Bark");
      }
  }
   
  public class Main {
      public static void main(String[] args) {
          Animal myDog = new Dog();
          myDog.sound(); // "Bark" 출력
      }
  }

• 캡슐화(Encapsulation):
  • 데이터와 그 데이터를 처리하는 코드를 하나의 단위로 묶고, 외부에서 접근을 제한하는 개념이다.
  • 클래스 내의 변수는 private로 선언되고, 변수에 접근하기 위한 메서드는 public으로 선언하여 데이터를 보호한다.

  class Person {
      // private 변수 (외부에서 직접 접근 불가)
      private String name;
   
      // public 메서드를 통해 데이터 접근
      public String getName() {
          return name;
      }
   
      public void setName(String name) {
          this.name = name;
      }
  }
   
  public class Main {
      public static void main(String[] args) {
          Person person = new Person();
          person.setName("Alice");
          System.out.println(person.getName()); // "Alice" 출력
      }
  }

• 상속(Inheritance):
  • 하나의 클래스가 다른 클래스의 속성과 메서드를 상속받는 기능이다.
  • 상속을 통해 코드 재사용성을 높일 수 있으며, 부모 클래스(슈퍼클래스)의 기능을 자식 클래스(서브클래스)가 확장할 수 있다.

  // 부모 클래스
  class Animal {
      void eat() {
          System.out.println("This animal eats food");
      }
  }
   
  // 자식 클래스
  class Dog extends Animal {
      void bark() {
          System.out.println("The dog barks");
      }
  }
   
  public class Main {
      public static void main(String[] args) {
          Dog myDog = new Dog();
          myDog.eat();  // "This animal eats food" 출력 (상속받은 메서드)
          myDog.bark(); // "The dog barks" 출력 (자식 클래스의 메서드)
      }
  }

• 다형성(Polymorphism):
  • 동일한 이름의 메서드가 서로 다른 형태로 동작할 수 있는 능력이다.
  • 오버로딩(Overloading): 같은 이름의 메서드가 다양한 매개변수 집합으로 정의되는 것.

    class Calculator {
        // 같은 이름의 메서드가 매개변수에 따라 다르게 동작
        int add(int a, int b) {
            return a + b;
        }
     
        int add(int a, int b, int c) {
            return a + b + c;
        }
    }
     
    public class Main {
        public static void main(String[] args) {
            Calculator calc = new Calculator();
            System.out.println(calc.add(2, 3));        // 5 출력
            System.out.println(calc.add(2, 3, 4));     // 9 출력
        }
    }

  • 오버라이딩(Overriding): 상속받은 메서드를 자식 클래스에서 재정의하는 것.

    // 부모 클래스
    class Animal {
        void sound() {
            System.out.println("Animal makes a sound");
        }
    }
     
    // 자식 클래스
    class Cat extends Animal {
        @Override
        void sound() {
            System.out.println("Meow");
        }
    }
     
    public class Main {
        public static void main(String[] args) {
            Animal myCat = new Cat();
            myCat.sound(); // "Meow" 출력 (Cat 클래스의 메서드로 오버라이딩됨)
        }
    }

스트림 (Stream)

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> result = new ArrayList<>();
 
for (int number : numbers) {
    if (number % 2 == 0) {
        result.add(number * 2);
    }
}
 
for (int number : result) {
    System.out.println(number);
}

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
 
numbers.stream()
       .filter(n -> n % 2 == 0)
       .map(n -> n * 2)
       .forEach(System.out::println);

후기