[JAVA] OOP의 개념과 특징

buckshot·2024년 4월 25일

JAVA

목록 보기
2/18
post-thumbnail

OOP

OOP(Object Oriented Programming), 객체지향프로그래밍이은 소프트웨어를 모듈화하거 유지 보수하기 용이하도록 설계하는 프로그래밍 패러다임 중 하나이다. 해당 패러다임은 객체와 그 객체들간의 상호작용을 모델링하여 프로그램을 구성한다.

여기서 객체는 데이터와 그 데이터를 처리하는 메소드를 같이 포괄한 개념적인 개체를 말 한다.

자바는 객체 지향 프로그해밍의 핵심 원칙인 캡슐화(Encapsulation), 상속(Inheritance), 다형성(Polymorphism), 추상화(Abstraction)을 지원한다.

OOP의 4가지 특성

  • 캡슐화(Encapsulation)

    캡슐화란 하나의 객체에 대하여 그 객체가 특정한 목적을 위한 필요한 변수나 메소드를 하나로 묶는 것을 말한다.
    객체는 목정을 잘 수행할 수 있도록 사용할 변수와 메소드를 관련성이 있도록 설계를 해야한다.

    정보 은닉

    캡슐화의 중요한 부분은 정보은닉에 있다고 한다.

    이는 외부에서 객체 내부의 상태를 직접적으로 접근하지 않고 메소드를 통해 접근하도록 해야 한다. 이렇게 메소드를 통해 접근 하도록 하여 객체 내부 상세구현을 숨기고, 외부에서는 객체의 인터페이스만을 이용하여 상호작용을 하게 만들어 정보 은닉을 한다.

public class Circle {
    private double radius;

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

    // 반지름 설정 메서드
    public void setRadius(double radius) {
        if (radius > 0) {
            this.radius = radius;
        }
    }

    // 원의 넓이 계산 메서드
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        // 반지름 직접 접근은 제한되어 있음
        // circle.radius = -1; // 컴파일 에러
        // 반지름 설정은 메서드를 통해 이루어짐
        circle.setRadius(10);
        System.out.println("원의 넓이: " + circle.calculateArea());
    }
}

public class Circle {
    private double radius;

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

    // 반지름 설정 메서드
    public void setRadius(double radius) {
        if (radius > 0) {
            this.radius = radius;
        }
    }

    // 원의 넓이 계산 메서드
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle(5);
        // 반지름 직접 접근은 제한되어 있음
        // circle.radius = -1; // 컴파일 에러
        // 반지름 설정은 메서드를 통해 이루어짐
        circle.setRadius(10);
        System.out.println("원의 넓이: " + circle.calculateArea());
    }
}

  • 추상화 (Abstraction)

    추상화는 목적과 관련이 없는 부분을 제거하여 필요한 부분만 표현하기 위한 개념

    추상 클래스

    추상 클래스는 하나 이상의 추상 메소드를 내포한 클래스다.
    추상 메소드는 메소드의 선언부만 존재하고 추가적인 구현은 필요가 없다. 그렇기에 구현부는 해당 추상 클래스 하위 클래스에서 구현을 해야 한다. 또한 추상 클래스는 내부에 객체를 직접 생성할 수 없으며, 하위 클래스에서 상속을 받아서 구현을 해야한다.

	    	abstract class Shape {
	    	abstract void draw(); // 추상 메서드
		}

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

		class Rectangle extends Shape {
	    	void draw() {
	     	   System.out.println("사각형을 그립니다.");
	    	}
		}

		class Main {
    		public static void main(String[] args) {
        		Shape circle = new Circle();
        		circle.draw(); // "원을 그립니다." 출력

        		Shape rectangle = new Rectangle();
        		rectangle.draw();
   		}
	}

인터페이스

인터페이스는 추상 메소드와 상수를 정의하는데 사용이 된다.
클래스가 인터페이스를 구현하면 인터페이스에 선언되 메소드를 모두 구현을 해야 한다
추가적으로 인터페이스는 클래스와 달리 다중 상속을 지원하기 위해 사용될 수 있다.

interface Drawable {
    void draw(); // 추상 메서드
}

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

class Rectangle implements Drawable {
    public void draw() {
        System.out.println("사각형을 그립니다.");
    }
}

class Main {
    public static void main(String[] args) {
        Drawable circle = new Circle();
        circle.draw(); // "원을 그립니다." 출력

        Drawable rectangle = new Rectangle();
        rectangle.draw(); // "사각형을 그립니다." 출력
    }
}

  • 다형성

    다형성은 같은 이름의 메소드나 연산자가 서로 다른 동작을 하도록 하는 기능이다. 이는 보통 오버로딩과 오버라이딩을 통해서 구현이 된다.

이를 통해 코드의 재사용성을 높이고, 코드양의 감소가 되어 유지보수가 용이하도록 한다.

  • 재사용성 : 동일한 메소드나 인터페이스를 여러 클래스에서 재사용이 가능하기 때문이다. 예를 들어 동일한 인터페이스를 구현할 때, 클라이언트 코드에서 이들을 구현한 실체 객체의 타입을 몰라도 인터페이스의 메소드를 호출할 수 있다.
  • 유연성과 확장성 : 다형성을 이용하면 코드의 유연성과 확장성을 높일 수 있는데 이는 새로운 클래스를 추가하거나 기존 클ㄹ래스를 수정하지 않고도 클라이언트 코드를 변경할 수 있기 때문이다.
  • 코드의 간결성 : 복잡한 조건문이나 스위치문을 피할 수 있다. 대신에 다형성을 이용하여 각 객체의 타입에 따라 동작을 다르게 할 수 있다. 이렇게 되면 코드가 좀 더 간결해지고 가독성이 올라간다.

Overriding & Overloading

  • Overriding
    부모 클래스에서 상속받은 자식 클래스에서 부모 클래스에서 만들어진 메소드를 자식 클래스에서 재정의 하여 사용하는 것
  • Overloading
    같은 이름의 메소드를 사용하지만 매개변수의 타입, 수가 다르게 선언하여 사용하는 것
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    // 세 정수를 더하는 메서드 (오버로딩)
    public 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("5 + 3 = " + calc.add(5, 3));
        System.out.println("5 + 3 + 2 = " + calc.add(5, 3, 2));
    }
}

  • 상속성

    상속은 이미 존재하는 클래스(슈퍼 클래스)의 특성을 그대로 이어받아 새로운 클래스(서브 클래스)를 정의하는 것이다.

    기존 클래스의 기능을 갖고와 재사용할 수 있으면서도 동시에 새롭게 만든 클래스에 새로운 기능을 추가할 수 있게 만들어준다.

    상속이 꼭 필요한가?

    상속이 필요한 이유는 코드의 중복을 없애기 위함이다.
    코드의 중복이 많아지면 같은 코드를 또 작성을 해야하고 나중에 유지보수에도 많이 비용이 들어가게 될 경우가 있다.
    OOP에서는 상속을 통해 코드의 중복 문제를 일부 해결을 할 수 있다.
    상속관계를 맺으면 자식 객체를 생성할 때 부모 클래스의 속성들을 자동으로 물려 받기 때문에 자식 클래스에서 또 재정의할 필요가 없다.

public class Animal {
    public void makeSound() {
        System.out.println("동물이 소리를 낸다.");
    }
}

// Animal 클래스를 상속받는 Dog 클래스
public class Dog extends Animal {
    public void makeSound() {
        System.out.println("강아지가 짖는다.");
    }
}

// Animal 클래스를 상속받는 Cat 클래스
public class Cat extends Animal {
    public void makeSound() {
        System.out.println("고양이가 야옹야옹 소리를 낸다.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.makeSound(); // "강아지가 짖는다." 출력
        animal2.makeSound(); // "고양이가 야옹야옹 소리를 낸다." 출력
    }
}

OOP의 장단점

  • 장점

    • 높은 코드의 재사용성 : 다형성이 있고, 캡슐화를 통해 모듈화가 가능
    • 생산성 향상 : 캡슐화로 객체의 독립성이 높아진다.
    • 자연적 모델링 가능
    • 유지 보수의 우수성

  • 단점

    • 개발 속도가 다소 늦어짐 : 모델링 과정에서 시간이 오래걸리기 때문
    • 절차 지향에 비래, 실행 속도가 느림
    • 객체가 많아짐에 따라 용량이 비대해진다.

profile
buckshot
let's go insane
이전 포스트

문자열 배열 길이로 정렬

다음 포스트

[JAVA] 객체지향 개발 SOLID

0개의 댓글