Java - 객체를 접근하는 권한 / Access Modifier / Package란? / 클래스 접근하는 방법

Java

Java - 객체를 접근하는 권한 / Access Modifier / Package란? / 클래스 접근하는 방법

wy-family 2024. 11. 29. 14:47

Java에서 Access Modifier는 클래스, 변수, 메서드, 또는 생성자에 대한 접근 수준을 제어하는 데 사용됩니다. 이를 통해 **캡슐화(encapsulation)**를 구현하고, 프로그램의 보안성과 안정성을 강화할 수 있습니다. Java는 네 가지 주요 접근 제어자를 제공합니다: public, protected, default(명시하지 않을 경우), 그리고 private. 이를 각 접근 수준에 따라 정리하고, 보호와 보안적 측면도 함께 설명하겠습니다.

1. Access Modifier의 종류와 특징


Modifier	같은 클래스	같은 패키지	다른 패키지의 서브클래스	다른 패키지
public	O	O	O	O
protected	O	O	O	X
default	O	O	X	X
private	O	X	X	X

1.1 public

특징: 어디서든 접근 가능. 제한이 없습니다.
예시:

public class MyClass {
    public int number = 10;
    public void display() {
        System.out.println("Public method");
    }
}

이 필드나 메서드는 다른 클래스와 패키지에서도 직접 접근 가능합니다.

보안적 측면:
- 데이터를 완전히 노출시키기 때문에 민감한 정보를 public으로 선언하면 보안 위협이 될 수 있습니다.
- 단, 외부에서 꼭 접근해야 하는 인터페이스나 API는 public으로 설정하여 의도적으로 노출합니다.

1.2 protected

특징: 같은 패키지 내의 클래스 또는 다른 패키지의 서브클래스에서만 접근 가능.
예시:

public class MyClass {
    protected int number = 20;
    protected void display() {
        System.out.println("Protected method");
    }
}

이 필드나 메서드는 다른 패키지의 일반 클래스에서는 접근할 수 없지만, 상속받은 서브클래스에서는 접근 가능합니다.

보안적 측면:
- 데이터의 접근 범위를 패키지와 서브클래스로 한정하여 외부의 불필요한 접근을 차단합니다.
- 서브클래스가 부모 클래스의 기능을 재사용 및 확장할 수 있도록 허용하면서도 완전한 공개를 방지합니다.

1.3 default (패키지-프라이빗)

특징: 접근 제어자를 명시하지 않을 때 적용되며, 같은 패키지 내에서만 접근 가능.
예시:

class MyClass { // default 접근 수준
    int number = 30; // default 접근 수준
    void display() {
        System.out.println("Default method");
    }
}

같은 패키지에 속한 다른 클래스에서만 이 필드나 메서드에 접근할 수 있습니다.

보안적 측면:
- 패키지를 논리적 모듈로 사용하여, 외부에서 접근할 필요가 없는 기능을 감춥니다.
- 패키지 외부에 불필요한 정보를 노출시키지 않음으로써 프로그램을 더 안전하게 설계합니다.

1.4 private

특징: 같은 클래스 내에서만 접근 가능. 외부 클래스는 물론이고 서브클래스에서도 접근할 수 없습니다.
예시:

public class MyClass {
    private int number = 40;
    private void display() {
        System.out.println("Private method");
    }
}

위 예제에서는 number와 display는 MyClass 외부에서는 사용할 수 없습니다.

보안적 측면:
- 캡슐화의 핵심: 외부에서 객체의 상태를 직접 수정하지 못하도록 보호합니다.
- 데이터 무결성을 유지하며, 의도된 방식으로만 데이터를 수정하도록 합니다(예: getter와 setter 사용).

2. 보호와 보안적 측면

Access Modifier는 다음과 같은 이유로 보호와 보안을 강화합니다.

2.1 데이터 은닉(Data Hiding)

민감한 데이터(예: 사용자 정보, 비밀번호)는 private으로 선언하여 외부 접근을 제한합니다.
외부 코드가 객체의 상태를 임의로 변경하지 못하도록 하고, 데이터 무결성을 유지합니다.

2.2 모듈화(Modularity)

default와 protected를 사용하여 관련 있는 클래스들만 데이터를 공유하도록 함으로써, 패키지를 하나의 독립적 모듈로 보호합니다.
프로그램의 특정 부분이 변경되더라도 다른 부분에 영향을 최소화합니다.

2.3 최소 공개 원칙(Minimum Exposure Principle)

필드와 메서드를 필요 이상으로 공개하지 않음으로써, 공격 지점을 줄이고 코드를 더 안전하게 만듭니다.
public은 꼭 필요한 부분에만 사용하며, 나머지는 private 또는 protected로 선언하는 것이 권장됩니다.

3. 실습 예제: Access Modifier와 캡슐화

class Account {
    // Private 데이터 필드: 민감한 정보는 외부에 노출되지 않음
    private String accountNumber;
    private double balance;

    // Public 생성자: 외부에서 객체 생성 가능
    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    // Public 메서드: 안전한 접근을 위한 인터페이스 제공
    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    // Private 메서드: 내부 로직 구현 (외부에 노출되지 않음)
    private void applyInterest() {
        balance *= 1.02;
    }

    // Public 메서드: 내부 로직을 안전하게 호출
    public void updateBalance() {
        applyInterest(); // private 메서드 호출
    }
}

보안적 장점:
- accountNumber와 balance는 private으로 보호되어 외부에서 직접 수정 불가능.
- 메서드를 통해서만 데이터를 읽고 수정할 수 있으므로, 논리적 제약을 추가하거나 데이터 유효성을 검증 가능.

4. 권장사항

모든 필드는 기본적으로 private으로 선언하고, 필요에 따라 getter와 setter를 제공합니다.
패키지 구조를 통해 연관된 클래스를 그룹화하고, default와 protected를 적절히 활용합니다.
외부에 공개해야 하는 API만 public으로 선언합니다.
불필요한 노출을 최소화하여 보안성을 강화합니다.

Access Modifier는 잘 활용하면 코드의 안정성과 보안성을 크게 향상시킬 수 있는 중요한 도구입니다. 😃

**protected**의 동작에 대해 정확히 이해하는 것이 중요합니다.

동일한 패키지 내에서는 상속 여부와 관계없이 접근 가능합니다.
다른 패키지에서는 서브클래스(자식 클래스)일 때만 접근 가능합니다.

protected 접근 범위 상세 설명

1. 동일한 패키지의 클래스

protected는 동일한 패키지 내의 모든 클래스에서 접근 가능합니다.
이 경우, 상속 여부는 상관없습니다. 동일 패키지 내에 있다면 protected 멤버에 자유롭게 접근할 수 있습니다.

2. 다른 패키지의 서브클래스

다른 패키지에서는 서브클래스에서만 접근이 가능합니다.
또한, 서브클래스 내에서 접근하려면 해당 멤버를 상속받은 객체를 통해 접근해야 하며, 상속받은 클래스 외부에서는 접근할 수 없습니다.

예제 코드로 이해하기

동일한 패키지 내에서 protected 접근

// File: PackageA/Parent.java
package PackageA;

public class Parent {
    protected String protectedField = "Protected Field";

    protected void protectedMethod() {
        System.out.println("Protected Method in Parent");
    }
}

// File: PackageA/NonChild.java
package PackageA;

public class NonChild {
    public void accessProtected() {
        Parent parent = new Parent();
        System.out.println(parent.protectedField); // 접근 가능
        parent.protectedMethod(); // 접근 가능
    }
}

// 실행
public class Main {
    public static void main(String[] args) {
        NonChild nonChild = new NonChild();
        nonChild.accessProtected(); // 정상 작동
    }
}

결과: 동일한 패키지에 속한 NonChild 클래스는 Parent의 protected 멤버에 접근 가능합니다.

다른 패키지의 서브클래스에서 protected 접근

// File: PackageA/Parent.java
package PackageA;

public class Parent {
    protected String protectedField = "Protected Field";

    protected void protectedMethod() {
        System.out.println("Protected Method in Parent");
    }
}

// File: PackageB/Child.java
package PackageB;
import PackageA.Parent;

public class Child extends Parent {
    public void accessProtected() {
        System.out.println(protectedField); // 접근 가능
        protectedMethod(); // 접근 가능
    }
}

// 실행
public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.accessProtected(); // 정상 작동
    }
}

결과: 다른 패키지에서 Parent를 상속받은 Child 클래스는 protected 멤버에 접근 가능합니다.

다른 패키지에서 상속받지 않은 경우

// File: PackageB/NonChild.java
package PackageB;
import PackageA.Parent;

public class NonChild {
    public void accessProtected() {
        Parent parent = new Parent();
        // System.out.println(parent.protectedField); // 오류: 접근 불가
        // parent.protectedMethod(); // 오류: 접근 불가
    }
}

결과: 다른 패키지에서 상속받지 않은 클래스는 protected 멤버에 접근할 수 없습니다.

요약

동일한 패키지 내에서는 상속 여부와 관계없이 접근 가능:
- protected는 default와 동일하게 작동하며, 같은 패키지의 모든 클래스에서 접근 가능합니다.
다른 패키지에서는 상속받은 서브클래스만 접근 가능:
- 단, 서브클래스 외부에서 부모 클래스 객체를 통해 직접 접근은 불가능합니다.
protected는 상속을 통해 자식 클래스에서 부모 클래스의 중요한 메서드나 데이터를 사용할 수 있게 하면서도, 외부에서는 접근을 제한하는 설계에 유용합니다.

Access Modifier의 동작을 명확히 이해하려면, 각각의 경우를 현실 세계 사례에 비유하고 코드 예시를 통해 설명하는 것이 효과적입니다. 아래에서는 public, protected, default, private 각각에 대한 사례와 예제를 다룹니다.

1. public: 모든 곳에서 접근 가능

사례: 공공 도서관

공공 도서관의 문은 누구나 들어갈 수 있도록 열려 있습니다. 외부 사람도, 내부 직원도 접근 가능합니다.
프로그램에서는 public 멤버는 어떤 클래스나 패키지에서도 접근 가능한 상태를 의미합니다.

코드 예제:

package library;

public class PublicLibrary {
    public String libraryName = "Central Library";

    public void openDoor() {
        System.out.println("Door is open for everyone!");
    }
}

// 다른 패키지에서도 접근 가능
package visitor;

import library.PublicLibrary;

public class Visitor {
    public static void main(String[] args) {
        PublicLibrary library = new PublicLibrary();
        System.out.println(library.libraryName); // 접근 가능
        library.openDoor(); // 접근 가능
    }
}

2. protected: 같은 패키지 또는 상속 관계에서만 접근 가능

사례: 가족 상속

부모가 가진 재산은 **가족(같은 패키지)**이나 **자식(상속 관계)**만 접근할 수 있습니다. 외부인은 접근할 수 없습니다.

코드 예제:

package family;

public class Parent {
    protected String familySecret = "This is a family secret";

    protected void shareSecret() {
        System.out.println("Sharing the family secret.");
    }
}

// 동일 패키지
package family;

public class Sibling {
    public void accessSecret() {
        Parent parent = new Parent();
        System.out.println(parent.familySecret); // 접근 가능
        parent.shareSecret(); // 접근 가능
    }
}

// 상속 관계
package inheritance;

import family.Parent;

public class Child extends Parent {
    public void revealSecret() {
        System.out.println(familySecret); // 접근 가능 (상속)
        shareSecret(); // 접근 가능 (상속)
    }
}

// 외부에서의 접근
package outsider;

import family.Parent;

public class Stranger {
    public void tryAccess() {
        Parent parent = new Parent();
        // System.out.println(parent.familySecret); // 오류: 접근 불가
        // parent.shareSecret(); // 오류: 접근 불가
    }
}

3. default (패키지-프라이빗): 같은 패키지에서만 접근 가능

사례: 사내 비공개 프로젝트

회사 내부에서는 특정 프로젝트에 접근할 수 있지만, 외부 사람(다른 패키지)에게는 비공개입니다.

코드 예제:

package company;

class InternalProject {
    String projectName = "Top Secret Project";

    void accessProject() {
        System.out.println("Accessing the internal project.");
    }
}

// 동일 패키지
package company;

public class Employee {
    public void viewProject() {
        InternalProject project = new InternalProject();
        System.out.println(project.projectName); // 접근 가능
        project.accessProject(); // 접근 가능
    }
}

// 다른 패키지
package competitor;

import company.InternalProject;

public class Hacker {
    public void stealProject() {
        // InternalProject project = new InternalProject(); // 오류: 접근 불가
        // System.out.println(project.projectName); // 오류: 접근 불가
        // project.accessProject(); // 오류: 접근 불가
    }
}

4. private: 같은 클래스 내에서만 접근 가능

사례: 비밀번호 보호

은행 계좌 비밀번호는 오직 계좌 소유자만 알 수 있으며, 외부에서 접근할 수 없습니다.

코드 예제:

package banking;

public class BankAccount {
    private String accountPassword = "password123";

    public void setPassword(String newPassword) {
        this.accountPassword = newPassword;
    }

    public void showPassword() {
        System.out.println("Your password is: " + accountPassword);
    }
}

// 외부 클래스
package banking;

public class Customer {
    public void tryAccess() {
        BankAccount account = new BankAccount();
        // System.out.println(account.accountPassword); // 오류: 접근 불가
        account.setPassword("newPassword123"); // 접근 가능 (간접적으로 설정)
        account.showPassword(); // 간접적으로 비밀번호 확인
    }
}

Access Modifier의 접근 사례 요약

Modifier사례접근 가능한 대상비유

public	공공 도서관	모든 클래스, 모든 패키지	누구나 접근 가능
protected	가족 상속	같은 패키지 또는 다른 패키지의 서브클래스	가족과 자식만 접근 가능
default	사내 비공개 프로젝트	같은 패키지	회사 내부에서만 접근 가능
private	비밀번호 보호	같은 클래스	계좌 소유자만 접근 가능

적용 시 유의사항

private:
- 필드와 메서드를 기본적으로 private으로 선언하여 캡슐화를 유지하세요.
- 외부에 꼭 필요한 정보만 getter와 setter로 공개합니다.
protected:
- 상속 구조에서 부모 클래스의 중요한 기능을 자식 클래스에만 공유하고 싶을 때 사용합니다.
- 동일 패키지에서도 접근이 가능하므로 패키지 구조 설계에 주의가 필요합니다.
default:
- 패키지 내에서만 사용해야 하는 경우 적합합니다.
- API를 설계할 때 외부에 불필요하게 노출하지 않도록 조심하세요.
public:
- 외부에서 반드시 접근이 필요한 API나 메서드에만 사용합니다.
- 모든 클래스에 공개되어야 하므로, 잘못 사용하면 보안 문제가 생길 수 있습니다.

마무리

Access Modifier는 클래스 멤버(필드, 메서드)의 접근을 제어함으로써 캡슐화와 보안을 구현하는 데 핵심적인 역할을 합니다. 각 제어자의 사용 사례와 비유를 통해 더 명확히 이해하고, 코드 설계 시 적절히 활용해 보세요!

근데 private은 같은 클래스에 있어야 접근가능하다고 했는데, 너가 공유해준 예시 코드 (계좌 소유주만 접근 가능하다고 한 예시) 를 확인해보면, 다른 클래스에서 접근이 가능하다는거면, private 하지 않은거 아닌가? 나에게는 추가 설명이 필요해 보여.

좋은 관찰입니다! private에 대한 동작을 좀 더 명확히 설명해드릴게요. 제가 공유한 은행 계좌 예제에서 private로 선언된 멤버에 다른 클래스가 직접 접근할 수 없음을 강조하려 했습니다. 하지만 코드에서 private 멤버가 간접적으로 접근되는 부분이 혼란을 줄 수 있습니다. 이를 정확히 이해하기 위해, private의 동작과 직접 접근과 간접 접근의 차이를 명확히 설명드리겠습니다.

1. private의 본질

private로 선언된 멤버는 동일한 클래스 내에서만 직접 접근할 수 있습니다.
다른 클래스에서는 직접 접근이 불가능하며, 같은 클래스 내에서 정의된 메서드를 통해서만 간접적으로 접근할 수 있습니다.

2. 문제의 코드 다시 확인

코드:

package banking;

public class BankAccount {
    private String accountPassword = "password123"; // private 멤버

    // 같은 클래스 내의 public 메서드로 간접 접근을 허용
    public void setPassword(String newPassword) {
        this.accountPassword = newPassword; // private 필드 수정 가능
    }

    public void showPassword() {
        System.out.println("Your password is: " + accountPassword); // private 필드 읽기 가능
    }
}

// 다른 클래스
package banking;

public class Customer {
    public void tryAccess() {
        BankAccount account = new BankAccount();
        // System.out.println(account.accountPassword); // 오류: 직접 접근 불가
        account.setPassword("newPassword123"); // 간접 접근 (public 메서드 사용)
        account.showPassword(); // 간접 접근 (public 메서드 사용)
    }
}

설명:

Customer 클래스에서 accountPassword에 직접 접근하려고 하면 컴파일 에러가 발생합니다:

System.out.println(account.accountPassword); // 오류: private 접근 불가

하지만 setPassword와 showPassword 메서드는 BankAccount 클래스 내부에서 accountPassword에 접근할 수 있는 public 메서드입니다.
- 따라서 외부 클래스(Customer)는 이 public 메서드를 통해 간접적으로 private 멤버에 접근합니다.
간접 접근의 의의:
- 이 방식은 데이터를 캡슐화하면서도 외부에서 필요한 작업(예: 비밀번호 변경 또는 보기)을 허용합니다.
- 예를 들어, setPassword 메서드에서 비밀번호가 특정 조건을 만족하는지 검사할 수 있습니다.

3. 직접 접근과 간접 접근의 차이


접근 유형	설명	코드 예시
직접 접근	외부 클래스에서 private 멤버를 직접 읽거나 수정하려는 경우.	account.accountPassword = "newPass"; (불가)
간접 접근	외부 클래스에서 public 메서드를 통해 private 멤버를 수정하거나 읽는 경우.	account.setPassword("newPass"); (가능)

4. 왜 private 멤버에 간접 접근을 허용하는가?

데이터 무결성 보장:
- private 필드에 직접 접근을 차단하고, setter나 getter 메서드에 유효성 검사를 추가할 수 있습니다.
- 예를 들어, 비밀번호를 설정할 때 최소 길이를 검증합니다:

public void setPassword(String newPassword) {
    if (newPassword.length() >= 8) {
        this.accountPassword = newPassword;
    } else {
        System.out.println("Password must be at least 8 characters long.");
    }
}

캡슐화 유지:
- 외부 클래스는 내부 구현에 의존하지 않고 public 메서드로 작업을 처리합니다.
- 내부 필드가 수정되더라도 public 인터페이스는 유지되므로, 코드의 안정성을 높입니다.
보안성 강화:
- 민감한 데이터(예: 비밀번호)는 외부에서 직접 접근할 수 없도록 보호합니다.
- 대신, 데이터 접근과 관련된 논리를 클래스 내부에 숨깁니다.

5. private와 캡슐화의 진정한 의미

현실 세계 사례:

은행 계좌에서 비밀번호(private)는 은행 내부 시스템에서만 관리합니다.
고객은 비밀번호를 변경하거나 확인할 때 은행의 **서비스 창구(public 메서드)**를 통해서만 작업을 요청할 수 있습니다.

코드로 구현:

package banking;

public class BankAccount {
    private String accountPassword = "password123"; // 비밀번호는 숨겨짐

    // 비밀번호 확인 서비스
    public void verifyPassword(String inputPassword) {
        if (this.accountPassword.equals(inputPassword)) {
            System.out.println("Access granted.");
        } else {
            System.out.println("Access denied.");
        }
    }

    // 비밀번호 변경 서비스
    public void setPassword(String newPassword) {
        if (newPassword.length() >= 8) {
            this.accountPassword = newPassword;
            System.out.println("Password updated successfully.");
        } else {
            System.out.println("Password must be at least 8 characters long.");
        }
    }
}

// 고객
package banking;

public class Customer {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();

        // 직접 비밀번호 접근 시도: 불가능
        // System.out.println(account.accountPassword); // 컴파일 오류 발생

        // 비밀번호 확인 및 변경: 간접 접근
        account.verifyPassword("password123"); // Access granted.
        account.setPassword("newPass"); // Password must be at least 8 characters long.
        account.setPassword("securePassword123"); // Password updated successfully.
    }
}

6. 요약

private는 클래스 외부에서 직접 접근을 완전히 차단합니다.
외부 클래스는 private 멤버에 접근하려면 해당 클래스 내부의 **public 메서드(간접 접근)**를 통해야 합니다.
이는 캡슐화를 구현하고, 데이터를 보호하며, 유효성 검증 등을 추가하여 프로그램의 안전성과 안정성을 높입니다.

Java에서 **패키지(package)**는 클래스를 그룹화하고 조직화하기 위한 메커니즘입니다. 패키지는 관련된 클래스와 인터페이스를 논리적으로 묶어서 관리하며, 대규모 애플리케이션에서 코드의 가독성과 재사용성을 높이는 데 중요한 역할을 합니다. 또한, 패키지는 클래스와 인터페이스에 대한 이름 충돌 방지와 접근 제어를 제공합니다.

1. 패키지의 주요 개념

1.1 패키지란?

패키지는 클래스와 인터페이스의 논리적 그룹입니다.
파일 시스템에서는 디렉토리 구조로 표현됩니다.
패키지는 두 가지 유형으로 나뉩니다:
- 빌트인 패키지(Built-in Packages): Java가 기본적으로 제공하는 패키지(e.g., java.util, java.io).
- 사용자 정의 패키지(User-defined Packages): 개발자가 필요에 따라 생성한 패키지.

2. 패키지의 이점

클래스 및 인터페이스의 조직화:
- 관련 있는 클래스와 인터페이스를 묶어서 관리할 수 있습니다.
- 예: 은행 애플리케이션에서 accounts와 transactions 패키지를 분리.
클래스 이름 충돌 방지:
- 동일한 이름의 클래스를 다른 패키지에 정의할 수 있어 충돌을 방지합니다.
- 예: com.bank.Customer와 com.shop.Customer는 서로 다른 클래스.
접근 제어:
- protected나 default 접근 제어자를 사용하여 패키지 내의 클래스들 간에 멤버를 공유하고, 외부로는 제한할 수 있습니다.
재사용성:
- 한 번 정의된 패키지는 다른 프로젝트에서 재사용할 수 있습니다.
유지보수성:
- 모듈화를 통해 코드 유지보수가 용이합니다.

3. 패키지의 사용법

3.1 패키지 선언

패키지는 소스 파일의 첫 번째 줄에 선언됩니다.
키워드 package를 사용하여 선언합니다.
예:

package mypackage;

public class MyClass {
    public void display() {
        System.out.println("Hello from MyClass in mypackage.");
    }
}

3.2 패키지 포함(import)

다른 패키지의 클래스를 사용하려면 import 키워드를 사용합니다.
예:

import mypackage.MyClass;

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.display();
    }
}

3.3 패키지 없이 클래스 사용

import 없이 패키지 경로를 포함한 클래스 이름을 사용하여 참조할 수도 있습니다.
예:

public class Main {
    public static void main(String[] args) {
        mypackage.MyClass obj = new mypackage.MyClass();
        obj.display();
    }
}

3.4 특정 클래스만 포함:

import package_name.class_name;를 사용하여 특정 클래스만 가져옵니다.

3.5 패키지 전체 포함:

import package_name.*;를 사용하여 패키지의 모든 클래스를 포함합니다.
예:

import java.util.*; // java.util 패키지의 모든 클래스 포함

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        System.out.println(list);
    }
}

4. 패키지 구조와 컴파일

4.1 패키지 디렉토리 구조

패키지는 파일 시스템에서 디렉토리 구조로 표현됩니다.
예:
- 패키지 이름이 com.example.project라면, 파일 경로는 다음과 같습니다:

com/
    example/
        project/
            MyClass.java

4.2 컴파일과 실행

컴파일:
- 소스 파일을 패키지에 맞는 디렉토리에 배치하고 컴파일합니다.
- 예: javac -d . MyClass.java
  - -d 옵션은 컴파일된 파일을 적절한 디렉토리로 배치합니다.
실행:
- 패키지 경로를 포함한 클래스 이름을 사용합니다.
- 예:

java com.example.project.MyClass

5. Java의 빌트인 패키지 예제

5.1 java.util 패키지

컬렉션 클래스(e.g., ArrayList, HashMap)와 유틸리티 클래스(e.g., Random, Date)를 포함합니다.
예:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Packages");
        System.out.println(list);
    }
}

5.2 java.io 패키지

파일 읽기/쓰기, 입출력 스트림 처리를 제공합니다.
예:

import java.io.File;

public class Main {
    public static void main(String[] args) {
        File file = new File("example.txt");
        System.out.println("File exists: " + file.exists());
    }
}

6. 사용자 정의 패키지 예제

6.1 패키지 생성

// File: mypackage/MyClass.java
package mypackage;

public class MyClass {
    public void greet() {
        System.out.println("Hello from MyClass in mypackage!");
    }
}

6.2 패키지 사용

// File: Main.java
import mypackage.MyClass;

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.greet();
    }
}

디렉토리 구조

mypackage/
    MyClass.java
Main.java

컴파일 및 실행

javac -d . mypackage/MyClass.java
javac -d . Main.java
java Main

7. 이름 충돌 방지 사례

문제: 동일한 이름의 클래스가 두 패키지에 존재

package animals;

public class Dog {
    public void speak() {
        System.out.println("Woof!");
    }
}

package pets;

public class Dog {
    public void speak() {
        System.out.println("Bark!");
    }
}

해결:

패키지 경로를 명시적으로 사용합니다.

import animals.Dog;

public class Main {
    public static void main(String[] args) {
        Dog animalDog = new animals.Dog();
        animalDog.speak(); // Woof!

        pets.Dog petDog = new pets.Dog();
        petDog.speak(); // Bark!
    }
}

8. 패키지와 접근 제어자

제어자동일 패키지다른 패키지

public	O	O
protected	O	상속 관계에서만 O
default	O	X
private	X	X

마무리

Java 패키지는 클래스와 인터페이스를 논리적으로 묶고, 이름 충돌 방지와 코드 조직화에 핵심적인 역할을 합니다. 빌트인 패키지와 사용자 정의 패키지를 활용하여 유지보수성과 재사용성을 높일 수 있습니다.

'Java' 카테고리의 다른 글

Java - Static과 JVM 메모리 모델 / class, object, instance의 상호관계 (0)	2024.12.02
Java - Constructor 생성자 메서드 / 클래스 모델 DTO, VO, DAO, Utility (0)	2024.12.01
Java - Method / static 정적/ parameter passing 매개변수 전달기법 / method overloading 메서드 중복정의 / (4)	2024.11.28
Java - if, swich-case, for, while, break, continue (0)	2024.11.26
Java - 연산자 (증가 연산자/ 감소 연산자/ 삼항 연산자) (0)	2024.11.25

현재글Java - 객체를 접근하는 권한 / Access Modifier / Package란? / 클래스 접근하는 방법

wy_family

wy-family 님의 블로그 입니다.

restful, Rest, 데브옵스, java, spring, restapi, 티스토리챌린지, 진로고민, cd, GitLab, PostgreSQL, Django, aws, 자바, KDT, 서버배포, restfulapi, 스마트팩토리, chatbot, it학습, 오블완, CICD, Python, 백엔드, CI, Pipeline, 웹개발, Docker, 진로계획, SpringBoot,

Today :
Yesterday :

« 2024/12 »
일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28
29	30	31