객체지향 프로그래밍 이란?

date

Oct 12, 2023

slug

what-is-object-oriented

author

status

Public

tags

Java

객체지향

summary

객체지향 프로그래밍에 대해 알아보고, 객체지향적으로 프로그램을 작성해봅시다

type

Post

thumbnail

category

☕ Java

updatedAt

Nov 1, 2023 12:00 PM

자바 개발자라면, 객체지향을 자기 만의 언어로 표현할 줄 알아야 한다.

객체지향 프로그래밍과 클래스 단위 프로그래밍

객체지향 프로그래밍은 클래스 단위로 프로그래밍 하는 것을 말해!

객체지향 프로그래밍은 클래스가 아닌 객체 중심적으로 프로그래밍 해야해!

객체 vs 클래스

public class Person {
	private String name;
  private int age;
  private double height;
  private double weight;

	public void introduce() {
		System.out.println("제 이름은 " + this.name + " 입니다.");
  }
}

public class Person {
	private String name;
  private int age;
  private double height;
  private double weight;

	public void introduce() {
		System.out.println("제 이름은 " + this.name + " 입니다.");
  }

	public Person(String name, int age, double height, double weight) {
		this.name = name;
		this.age = age;
		this.height = height;
		this.weight = weight;
	}

public static void main(String[] args) {
	Person stoneHee = new Person("stoneHee", 25, 180.0, 60.0);
	stoneHee.introduce();
}

// 출력: "제 이름은 stoneHee 입니다."

클래스(Class) 란

• 객체를 생성하기 위한 틀, 규칙

• 변수와 메서드의 집합

객체(Object) 란

• 소프트웨어 안에 구현될 대상

• 클래스의 틀, 규칙대로 생성된 실체 (클래스에 의해 생성)

객체 지향의 특징

1. 추상화(Abstraction)

public abstract class Car {
	public abstract void drive();
	public abstract void brake();
}

public class Sedan extends Car {
	@Override
	public void drive() {
		System.out.println("세단을 운전합니다");
	}

	@Override
	public void brake() {
		System.out.println("세단이 정지합니다");
	}
}

public class SportsCar extends Car {
	@Override
	public void drive() {
		System.out.println("스포츠카를 운전합니다");
	}

	@Override
	public void brake() {
		System.out.println("스포츠카가 정지합니다");
	}
}

2. 캡슐화(Encapsulation)

public class BankAccount {
	private double balance;
	
	public BankAccount(double initialBalance) {
		if (initialBalance < 0) {
			throw new IllegalArgumentException("잔액은 0보다 적을 수 없습니다");
		}
		this.balance = initialBalance;
	}

	public void deposit(double amount) {
		if (amount <= 0) {
			throw new IllegalArgumentException("입금액은 0보다 커야 합니다");
		}
		balance += amount;
	}

	public void withdraw(double amount) {
		if (amount <= 0 || amount > balance) {
			throw new IllegalArgumentException("출금액은 0보다 커야 하며 잔액보다 작아야 합니다");
		}
		balance -= amount;
	}

	public double getBalance() {
		return balance;
	}
}

3. 상속(Inheritance)

class Animal {
	String name;
	
	public void setName(String name) {
		this.name = name;
	}

	public void sound() {
		System.out.println("동물이 소리를 냅니다");
	}
}

class Dog extends Animal {
	public void wagTail() {
		System.out.println(name + "이(가) 꼬리를 흔듭니다");
	}

	@Override
	public void sound() {
		System.out.println(name + "이(가) 멍멍 짖습니다");
	}
}

class Cat extends Animal {
	public void purr() {
		System.out.println(name + "이(가) 웁니다");
	}

	@Override
	public void sound() {
		System.out.println(name + "이(가) 야옹 웁니다");
	}
}

public class TestInheritance {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setName("바둑이");
        dog.sound(); // "바둑이가 멍멍 소리를 냅니다." 출력
        dog.wagTail(); // "바둑이가 꼬리를 흔듭니다." 출력

        Cat cat = new Cat();
        cat.setName("나비");
        cat.sound(); // "나비가 야옹 소리를 냅니다." 출력
        cat.purr(); // "나비가 웁니다." 출력
    }
}

4. 다형성(Polymorphism)

interface Shape {
	void draw();
}

class Circle implements Shape {
	@Override
	public void draw() {
		System.out.println("원을 그립니다");
	}
}

class Rectangle implements Shape {
	@Override
	public void draw() {
		Ststem.out.println("사각형을 그립니다");
	}
}

class Triangle implements Shape {
	@Override
	public void draw() {
		System.out.println("삼각형을 그립니다");
	}
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();
        Shape triangle = new Triangle();

        drawShape(circle);       // "원을 그립니다." 출력
        drawShape(rectangle);    // "사각형을 그립니다." 출력
        drawShape(triangle);     // "삼각형을 그립니다." 출력
    }

    public static void drawShape(Shape shape) {
        shape.draw();
    }
}

결론

좋은 객체 지향 설계의 5가지 원칙(SOLID)

1. SRP: 단일 책임 원칙 (Single Responsibility Principle)

public class OrderProcessor {
	public void processOrder(Order order) {
		/** 
			주문 처리 로직
		**/
		saveOrderToDatabase(order);
		sendConfirmationEmail(order);
	}
	
	private void saveOrderToDatabase(Order order) {
		/** 
			DB에 주문 정보 저장 로직
		**/
	}

	private void sendConfirmationEmail(Order order) {
		/**
			고객에게 주문 확인 이메일 보내는 로직
		**/
	}
}

public class OrderProcessor {
	private final OrderSaver orderSaver;
	private final EmailSender emailSender;

	public OrderProcessor(OrderSaver orderSaver, EmailSEnder emailSender) {
		this.orderSaver = orderSaver;
		this.emailSender = emailSender;
	}

	public void processOrder(Order order) {
		/**
			주문 처리 로직
		**/
		orderSaver.saverOrder(order);
		emailSender.sendConfirmationEmail(order);
	}
}

public class OrderSaver {
	public void saveOrder(order order) {
		/** 
			DB에 주문 정보 저장 로직
		**/
	}
}

public class EmailSender {
	public void sendConfirmationEmail(Order order) {
		/**
			고객에게 주문 확인 이메일 보내는 로직
		**/
	}
}

2. OCP: 개방-폐쇄 원칙 (Open/Closed Principle)

// Step 1: 인터페이스 정의
interface Shape {
    double area();
}

// Step 2: 구체적인 클래스 구현
class Rectangle implements Shape {
    double width;
    double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double area() {
        return width * height;
    }
}

class Circle implements Shape {
    double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

// Step 3: AreaCalculator 클래스는 Shape 타입의 리스트를 받아 그 총 넓이를 계산
class AreaCalculator {
    public double calculateTotalArea(List<Shape> shapes) {
        double total = 0;
        for (Shape shape : shapes) {
            total += shape.area();
        }
        return total;
    }
}

// Step 4: 새 도형 추가
class Triangle implements Shape {
    double base;
    double height;

    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }

    @Override
    public double area() {
        return 0.5 * base * height;
    }
}

3. LSP: 리스코프 치환 원칙 (Liskov Substitution Principle)

class Bird {
    void fly() {
        System.out.println("새가 날다");
    }
}

class Sparrow extends Bird {
    @Override
    void fly() {
        System.out.println("참새가 날다");
    }
}

class Penguin extends Bird {
    @Override
    void fly() {
        throw new UnsupportedOperationException("펭귄은 날 수 없습니다");
    }
}

interface FlyingBird {
    void fly();
}

class Sparrow implements FlyingBird {
    @Override
    public void fly() {
        System.out.println("참새가 날다");
    }
}

class Penguin {
    void swim() {
        System.out.println("펭귄이 수영하다");
    }
}

4. ISP: 인터페이스 분리 원칙 (Interface Segregation Principle)

interface Worker {
    void work();
    void eat();
}

class Developer implements Worker {
    @Override
    public void work() {
        System.out.println("개발자가 일을 합니다.");
    }

    @Override
    public void eat() {
        System.out.println("개발자가 밥을 먹습니다.");
    }
}

class Robot implements Worker {
    @Override
    public void work() {
        System.out.println("로봇이 일을 합니다.");
    }

    @Override
    public void eat() {
        // 로봇은 먹을 필요가 없음
        throw new UnsupportedOperationException();
    }
}

interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Developer implements Workable, Eatable {
    @Override
    public void work() {
        System.out.println("개발자가 일을 합니다.");
    }

    @Override
    public void eat() {
        System.out.println("개발자가 밥을 먹습니다.");
    }
}

class Robot implements Workable {
    @Override
    public void work() {
        System.out.println("로봇이 일을 합니다.");
    }
}

5. DIP: 의존관계 역전 원칙 (Dependency Inversion Principle)

class LightBulb {
    public void turnOn() {
        System.out.println("불이 켜졌습니다.");
    }

    public void turnOff() {
        System.out.println("불이 꺼졌습니다.");
    }
}

class Switch {
    private LightBulb bulb;

    public Switch(LightBulb bulb) {
        this.bulb = bulb;
    }

    public void operate() {
        // ... 로직 ...
        bulb.turnOn();
        // ... 로직 ...
    }
}

interface SwitchableDevice {
    void turnOn();
    void turnOff();
}

class LightBulb implements SwitchableDevice {
    @Override
    public void turnOn() {
        System.out.println("불이 켜졌습니다.");
    }

    @Override
    public void turnOff() {
        System.out.println("불이 꺼졌습니다.");
    }
}

class Switch {
    private SwitchableDevice device;

    public Switch(SwitchableDevice device) {
        this.device = device;
    }

    public void operate() {
        // ... 로직 ...
        device.turnOn();
        // ... 로직 ...
    }
}

결론