💫 JAVA

✔️ static

✅ 정의

• static은 클래스에 속하는 정적 멤버
• 인스턴스 없이 클래스명.메소드로 호출 가능
• JVM이 클래스 파일을 메모리에 올릴 때 고정된 위치에 딱 한 번 생성되어 모든 인스턴스가 공유함.

---

↔️ 인스턴스 vs static

구분	인스턴스 멤버	static 멤버
소속	객체(인스턴스)에 속함	클래스 자체에 속함
접근 방법	객체참조.필드, 메소드()	클래스명.필드, 메소드()
메모리 위치	Heap 영역	Method Area 영역
생성 시점	객체 생성 시	클래스 로딩 시
사용 목적	각 객체마다 고유한 데이터	공통 데이터/기능 공유 목적

---

-memory-

Class Loader

JVM Memory

Method Area Heap JVM Language Stacks PC Registers Native Method Stacks

Execution Engine <-> Native Method <-> Native Method Libraries

---

class Person {
    public static void greet() {
        System.out.println("Hello from static method");
    }
    public void sayHello() {
        System.out.println("Hello from instance method");
    }
}
public class Main {
    public static void main(String[] args) {
        Person.greet();
        Person p = new Person();
        p.sayHello();
    }
}

---

❗사용 시 주의사항

• 과도한 static은 메모리 낭비 유발
• static 메소드에서는 인스턴스 변수에 접근 불가
• 객체 상태와 무관한 기능에만 사용해야 함

---

🔁 핵심 요약 정리

키워드	설명 요약
static	클래스에 소속되는 고정 멤버 (인스턴스 없이 접근 가능)
접근 방식	클래스명.메소드() 또는 클래스명.필드
장점	메모리 공유, 접근 속도 빠름, 공통 기능 처리에 적합
주의사항	인스턴스 변수에 접근할 수 없으며, 남용 시 메모리 부담

---

✔️ inner class

✅ 정의

• 클래스 안에 선언된 또 다른 클래스
• 논리적 그룹화, 캡슐화 강화 목적
• Outer Class의 멤버에 자유롭게 접근 가능

ℹ️ outer class 와의 관계

• Inner Class는 Outer Class의 private 멤버에도 접근 가능
• 마치 같은 클래스 내부처럼 작동. 논리적 단위. 동일 클래스 파일로 인식한다.
• inner Class는 1개의 Outer Class instance에 속할 수 있다.

🤔 Why Inner Class?

• 관련 있는 클래스를 논리적으로 묶어줌
• 외부 클래스 멤버를 자유롭게 사용할 수 있어 편리
• 캡슐화와 가독성 향상

---

class Car {
    String brand;
    public Car(String brand) {
        this.brand = brand;
    }
    class Engine {
        public void start() {
            System.out.println("The engine of " + brand + " is starting...");
        }
    }
    public void startEngine() {
        Engine engine = new Engine();
        engine.start();
    }
}
public class Main {
    public static void main(String[] args) {
        Car car = new Car("BMW");
        car.startEngine();
    }
}

---

✅ engine 재활용 가능 버전

class Car {
    String brand;
    Engine engine;
    public Car(String brand) {
        this.brand = brand;
        this.engine = new Engine();
    }
    class Engine {
        public void start() {
            System.out.println("The engine of " + brand + " is starting...");
        }
    }
    public void startEngine() {
        engine.start();
    }
}
public class Main {
    public static void main(String[] args) {
        Car car = new Car("BMW");
        car.startEngine();
    }
}

---

✅ inner class new 키워드로 생성

// 1. Outer instance 생성
        Main main = new Main();
        // 2. Inner instance 생성 (outer.new 사용)
        Main.Inner inner = main.new Inner();
        // 3. Inner 클래스 메서드 호출
        inner.showMessage();

---

✅ 강한 결합 없이 클래스 간 협력

class Button {
    interface OnClickListener {
        void onClick();
    }
    private OnClickListener listener;

    public void setOnclickListener(OnClickListener listener) {
        this.listener = listener;
    }
    public void click() {
        if (listener != null) {
            listener.onClick();
        }
    }
    // OnclickListener를 구현한 ClickHandler Innerclass
    private class ClickHandler implements OnClickListener {
        public void onClick() {
            System.out.println("Button is Clicked");
        }
    }
    public void simulateClick() {
        setOnclickListener(new ClickHandler());
        click();
    }
}
public class Main {
    public static void main(String[] args) {
        Button button = new Button();
        button.simulateClick();
    }
}

---

✅ 이너 클래스와 메모리

• Inner Class는 Outer 인스턴스와 함께 메모리에 존재
• Outer 객체가 GC될 때 Inner도 함께 정리됨

public class Outer {
    private String data = "Outer data";
    class Inner {
        void printData() {
            System.out.println(data);
        }
    }
    public Inner createInner() {
        return new Inner();
    }
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.createInner();
        inner.printData();
        outer = null; // outer 인스턴스가 null 이 되어도 Inner 인스턴스를 참조하고 있는 inner 는 사라지지 않는다.
        inner.printData();
        inner = null;
        System.gc();
    }
}

---

class Outer {
    static class StaticInner {
        void hello() {
            System.out.println("Hi!");
        }
    }
}
public class Main {
    public static void main(String[] args) {
        Outer.StaticInner inner = new Outer.StaticInner();
        inner.hello();
    }
}

Inner vs Static Nested Class

구분	Inner Class	Static Nested Class
Outer 인스턴스 필요	O	X
접근 가능 멤버	Outer의 모든 멤버	static 멤버만
사용 예시	멤버 도우미 클래스	유틸리티, 구조 분리
메모리 관리	Outer 객체와 함께	독립 객체로 관리

---

✔️ Anonymous Class

✅ 정의

• 이름이 없는 일회성 클래스
• 주로 인터페이스나 추상 클래스를 즉시 구현할 때 사용
• 재사용은 어렵지만 간단한 구현에 유용

✅ interface Greeting 작성

• 익명 클래스는 기반이 되는 인터페이스가 필요
• void greet() 메소드만 선언

✅ 익명 클래스 생성 방법

• new 인터페이스명() { 구현 } 형태로 정의
• 중괄호 내에서 메소드를 즉시 오버라이딩

interface Greeting {
    void greet();
}
class GClass implements Greeting {
    public void greet() {}
}
public class Main {
    public static void main(String[] args) {
    	// GClass 를 거치지 않고 바로 선언과 구현을 동시에 하는 anonymoust class Greeting
        Greeting greeting = new Greeting() {
            public void greet() {
                System.out.println("Hello World");
            }
        };
        greeting.greet();
    }
}

interface Calculator {
    int compute(int a, int b);
}
class CalculatorMachine implements Calculator {
    @Override
    public int compute(int a, int b) {
        return a * b;
    }
}
public class Main {
    public static void main(String[] args) {
        // 1. 간단하게 기능을 구현해서 바로 테스트 하려면 anonymous class를 사용하면 된다.
        Calculator multiply = new Calculator() {
            public int compute(int a, int b) {
                return a * b;
            }
        };
        Calculator add = new Calculator() {
            public int compute(int a, int b) {
                return a + b;
            }
        };
        // 숫자를 문자로 받아 합친 뒤 다시 숫자로 반환하는 connectNum 기능
        Calculator connectNum = new Calculator() {
            public int compute(int a, int b) {
                return Integer.parseInt("" + a + b);
            }
        };
        System.out.println(multiply.compute(3, 4)); //12
        System.out.println(add.compute(3, 4)); //7
        System.out.println(connectNum.compute(3, 4)); //34

        // 2. 만약 기능을 여러 번 사용하고 싶으면 class에 implement 해서 그 instance 를 가지고 실행시키는 것이 낫다.
        CalculatorMachine machine = new CalculatorMachine();
        System.out.println(machine.compute(1, 2)); //2
        System.out.println(machine.compute(10, 20)); //200
    }
}

---

람다식과 비교

• 자바 8부터는 익명 클래스보다 람다식을 더 자주 사용
• 익명 클래스는 여전히 복잡한 구현이나 상태가 있는 경우 유용

익명 클래스 vs 람다식

항목	익명 클래스	람다식
이름	없음	없음
구현 대상	인터페이스/추상 클래스	함수형 인터페이스
코드 길이	비교적 길다	간결하다
상태 보유	가능	제한적

---

💫 CS

✔️ CPU 동작원리

class CPU {
    public int register = 0; // register 장치
    public int[] memory = {4, 5, 6}; // memory
    int pc = 0;
    private static final int LOAD = 1;
    private static final int SAVE = 2;
    private static final int ADD = 3;
    private static final int SUB = 4;
    private static final int HALT = 5;
    // assembly
    private int[][] program = { // { operator , memory location }
            { LOAD, 0 },         // register = memory[0]
            { ADD, 1 },          // register = register + memory[1]
            { SAVE, 2 },         // memory[2] = register
            { HALT, 0 }          // stop program execution
    };
    public void executeProgram() {
        while(true) {
            int opcode = program[pc][0];  // {LOAD, ADD, SAVE, HALT}
            int operand = program[pc][1]; // {0, 1, 2, 0}
            switch (opcode) {
                case LOAD:
                    register = memory[operand];
                    System.out.println("MOV: Loading memory[" + operand + "] (" + memory[operand] + ") to Register.");
                    System.out.println("Register : " + register);
                    break;
                case SAVE:
                    memory[operand] = register;
                    System.out.println("MOV: Saving memory[" + operand + "] (" + memory[operand] + ") to Register.");
                    System.out.println("Register : " + register);
                    break;
                case ADD:
                    register += memory[operand];
                    System.out.println("MOV: Adding memory[" + operand + "] (" + memory[operand] + ") to Register.");
                    System.out.println("Register : " + register);
                    break;
                case SUB:
                    register -= memory[operand];
                    System.out.println("MOV: Subtracting memory[" + operand + "] (" + memory[operand] + ") from Register.");
                    System.out.println("Register : " + register);
                    break;
                case HALT:
                    System.out.println("MOV: Stopping program.");
                    return;
                default:
                    System.out.println("Unknown instruction. Halting... opcode : " + opcode);
                    return;
            }
            pc++;
        }
    }
}
public class Main {
    public static void main(String[] args) {
        CPU cpu = new CPU();
        cpu.executeProgram();
        System.out.println("Final memory state: memory[" + (cpu.pc-1) + "] = " + cpu.memory[cpu.pc-1]);
    }
}