13Day - (정적 내부클래스) OuterTwo & OuterTwoApp / OuterThree & OuterThreeApp / (익명 클래스)Anonymous & AnonymousApp / (패키지) SubjectApp / SubjectApp & JavaSubject & OracleSubject & JavaSubject // (입출력) CalcAgeApp // (접근제..

첼로그 2023. 4. 13. 22:28

임포트

https://hjjungdev.tistory.com/102

인텔리J(IntelliJ) 임포트(Import) / Eclipse Ctrl + Shift + O in IntelliJ IDEA

1. 문제상황 Eclipse에서 CTRL + SHIFT + O "Organize Imports"를 눌러 패키지를 자동으로 가져옵니다. IntelliJ IDEA의 경우 CTRL + ALT + O "Optimize Imports" 를 누르면 사용되지 않은 가져 오기가 제거되고 패키지는

hjjungdev.tistory.com

package nested;

OuterTwo

public class OuterTwo {
    private  int outerNum;

    public OuterTwo(int outerNum) {
        super();
        this.outerNum = outerNum;
    }

    public int getOuterNum() {
        return outerNum;
    }

    public void setOuterNum(int outerNum) {
        this.outerNum = outerNum;
    }

    public void outerDisplay() {
        System.out.println("outerNum = " + outerNum);

//        // 외부클래스는 정적 내부클래스로 객체를 생성하여 접근제한자에 상관없이 정적 내부클래스 필드 또는 메소드 참조 가능
//        InnerTwo innerTwo = new InnerTwo(200);
////        System.out.println("innerNum = " + innerNum); // 에러떠서 △만듦
//        System.out.println("innerNum = " + innerTwo.innerNum); // 에러떠서 △만듦
//        innerTwo.innerDisplay();

        // 외부클래스에서는 정적 내부클래스를 사용하여 정적필드 또는 정적메소드 접근 가능

    }


    // 정적 내부클래스 (Static InnerClass) - static 제한자를 사용하여 클래스 선언
    // > 정적 내부클래스에서는 static을 제한자를 사용하여 필드 또는 메소드 선언 가능

    public static class InnerTwo {
        private int innerNum;
        private static int staticNum = 300;

        public InnerTwo() {
            // TODO Auto-generated constructor stub
        }

        public InnerTwo(int innerNum) {
            super();
            this.innerNum = innerNum;
        }

        public int getInnerNum() {
            return innerNum;
        }

        public void setInnerNum(int innerNum) {
            this.innerNum = innerNum;
        }

        public static int getStaticNum() {
            return staticNum;
        }

        public static void setStaticNum(int staticNum) {
            InnerTwo.staticNum = staticNum;
        }

        public void innerDisplay() {
            System.out.println("innerNum = "+innerNum);
            System.out.println("staticNum = "+staticNum);

            //정적 내부클래스에서는 외부클래스의 필드 또는 메소드 참조 불가능
            // > 외부클래스의 정적필드 또는 정적메소드는 참조 가능
            // System.out.println("outerNum = "+outerNum);
            // outerDisplay();
        }
    }
}

OuterTwoApp

import nested.OuterTwo.InnerTwo;
public class OuterTwoApp {

    public static void main(String[] args) {
        OuterTwo outerTwo = new OuterTwo(100);

        outerTwo.outerDisplay();
        System.out.println("---------------------------------------------");
        
        // 정적 내부클래스의 생성자를 직접 호출하여 객체 생성 가능
        InnerTwo innerTwo = new InnerTwo(200); // (설정해주고)임포터시켜줌 >> 그래야 에러 안남
        innerTwo.innerDisplay(); //

        System.out.println("---------------------------------------------");
    }
}


outerNum = 100
---------------------------------------------
innerNum = 200
staticNum = 300
---------------------------------------------

package nested;

OuterThree

public class OuterThree {
    private int outerNum;

    public OuterThree() {
        // TODO Auto-generated constructor stub
    }

    public OuterThree(int outerNum) {
        super();
        this.outerNum = outerNum;
    }

    public int getOuterNum() {
        return outerNum;
    }

    public void setOuterNum(int outerNum) {
        this.outerNum = outerNum;
    }

    public void outerDisplay() {
        System.out.println("outerNum = "+outerNum);

        // 외부클래스에서는 지역클래스 사용 불가능
        // InnerThree innerThree=new InnerThree();
    }

    public void local() {
        // 지역클래스(LocalClass) : 메소드 내부에 선언된 클래스 - 메소드가 종료되면 자동 소멸
        // > 지역클래스에는 final 또는 abstract 제한자만 사용하여 선언 가능
        // > 접근제한자 및 static 제한자를 사용하여 지역클래스를 선언할 경우 에러 발생
        // > 비동기식 처리를 위한 스레드 객체를 생성하기 위해 사용
        class InnerThree {
            int innerNum;

            void innerDisplay() {
                System.out.println("innerNum = "+innerNum);
            }
        }

        // 지역클래스가 선언된 메소드에서만 객체를 생성하여 필드 또는 메소드 참조 가능
        InnerThree innerThree = new InnerThree();
        innerThree.innerNum = 200;
        innerThree.innerDisplay();
    }
}

OuterThreeApp

public class OuterThreeApp {
    public static void main(String[] args) {
        OuterThree outerThree = new OuterThree(100);

        outerThree.outerDisplay();
        outerThree.local();

    }
}


outerNum = 100
innerNum = 200

package nested;

(익명 클래스) Anonymous

public interface Anonymous {
    void display();
}

AnonymousApp

public class AnonymousApp {
    public static void main(String[] args) {
        // 인터페이스를 사용하여 참조변수는 생성가능하지만 객체 생성 불가능
        // > 인터페이스는 클래스가 상속받기 위한 자료형
        // > 인터페이스를 상속받은 자식클래스는 인터페이스에 선언된 모든 추상 메소드를 반드시 오버라이드 선언
        // > 인터페이스를 상속받은 자식클래스로 객체를 생성하여 인터페이스로 생성된 참조변수에 저장 가능

        // Anonymous anonymous = new Anonymous(); // 오류

        // 인터페이스를 상속받은 이름이 없는 자식클래스를 선언하고 인터페이스의 메소드를
        // 오버라이드 선언하여 객체 생성 가능 - 익명의 내부클래스 (지역클래스)
        // 익명의 내부클래스 (Anonymous InnerClass) 인터페이스 또는 추상클래스를 상속받은 이름이 없는 자식클래스
        // > 익명의 내부클래스는 상속받은 인터페이스 또는 추상클래스의 모든 추상메소드를 오버라이드 선언
        Anonymous anonymous = new Anonymous() {
            @Override
            public void display() {

            }
        };

    }
}

(패키지)

// 패키지 - 같은 목적의 자료형을 명확하게 구분하여 그룹화 하기 위해 사용
// Java 참조형 - 클래스, 인터페이스, 열거형
// Java 자료형을 보다 쉽게 관리하기 위해 패키지 사용
// > 패키지의 이름은 도메인을 역방향으로 나열하고 그룹명을 지정하여 작성하는 것을 권장

// 도메인 - 인터넷에서 개인 또는 그룹이 사용하기 위한 네트워크 식별자
// ex) itwill.xyz : 도메인 >> xyz.itwill.board

// 패키지에 작성된 소스파일의 처음 위치에는 소스파일이 작성된 패키지를 반드시 명확하게 작성
// 형식) package 패키지경로;
// > Java 자료형이 어떤 패키지에서 선언된 자료형인지를 명확하게 구분하여 사용

// import 키워드 : 다른 패키지에 작성된 Java 자료형을 명확히 표현하여 접근하기 위한 키워드
// 형식) import 패키지경로.자료형; >> 자료형 대신 *(전체) 사용 가능
// > package 키워드로 작성된 명령 하단에 선언하며 자료형 위에 선언
// 이클립스에서는 다른 패키지에 작성된 자료형을 사용할 경우 import 명령을 자동 완성하는 기능
// 제공 - [Ctrl]+[Space] => 같은 이름의 자료형이 여러개인 경우 선택
// > [Ctrl]+[Shift]+[O] >> import 명령을 정리하는 단축키 : 불필요한 자료형에 대한 import
// 설정을 제거하거나 필요한 자료형에 대한 import 설정을 추가하는 기능 제공

package xyz.itwill.app;

SubjectApp

import xyz.itwill.subject.OracleSubject;
import xyz.itwill.subject.JavaSubject;

// 자료형의 이름이 같은 경우 import 처리 불가능
// import xyz.uniwill.subject.JavaSubject;

public class SubjectApp {
    public static void main(String[] args) {
        // 같은 패키지에 작성된 클래스는 패키지 경로 표현 없이 클래스 접근 가능
        // > 형식) 클래스명
        // 다른 패키지에 작성된 클래스는 반드시 패키지 경로를 표현해야만 클래스 접근 가능
        // > 형식) 패키지경로.클래스명
        // xyz.itwill.subject.OracleSubject subject1=new xyz.itwill.subject.OracleSubject();

        // 다른 패키지에 작성된 클래스를 import 처리한 경우 패키지 경로 표현없이 클래스 접근 가능
        OracleSubject subject1 = new OracleSubject();
        subject1.display();

        JavaSubject subject2 = new JavaSubject();
        subject2.display();

        //import 설정이 불가능 자료형은 패키지 경로를 반드시 표현해야만 접근 가능
        xyz.uniwill.subject.JavaSubject subject3 = new xyz.uniwill.subject.JavaSubject();
        subject3.display();
    }
}

아이티윌 학원의 Oracle 과정입니다.
아이티윌 학원의 Java 과정입니다.
유니윌 학원의 Java 과정입니다.

package xyz.itwill.subject;

JavaSubject

public class JavaSubject {
    public void display() {
        System.out.println("아이티윌 학원의 Java 과정입니다.");
    }
}

package xyz.itwill.subject;

OracleSubject

public class OracleSubject {
    public void display() {
        System.out.println("아이티윌 학원의 Oracle 과정입니다.");
    }
}

package xyz.uniwill.subject;

JavaSubject

public class JavaSubject {
    public void display() {
        System.out.println("유니윌 학원의 Java 과정입니다.");
    }
}

package xyz.itwill.app;

(입출력)

CalcAgeApp

// 키보드로 이름과 태어난 년도를 입력받아 나이를 계산하여 이름과 나이를 출력하는 프로그램 작성
// ex) 이름 입력 >> 홍길동
// 태어난 년도 >> 2000
// [결과] 홍길동님의 나이는 24살 입니다.

import java.util.Date;
import java.util.Scanner;

// 키보드로 이름과 태어난 년도를 입력받아 나이를 계산하여 이름과 나이를 출력하는 프로그램 작성
// ex) 이름 입력 >> 홍길동
// 태어난 년도 >> 2000
// [결과] 홍길동님의 나이는 24살 입니다.
public class CalcAgeApp {
    public static void main(String[] args) {
        // Scanner 클래스로 객체를 생성하여 참조변수에 저장 ▽
        Scanner scanner = new Scanner(System.in);


        // 키보드를 이용하여 사용자로부터 이름과 태어난 년도를 입력받아 변수에 저장
        System.out.print("이름 입력 >> ");
        String name = scanner.nextLine();

        System.out.print("태어난 년도 >> ");

        int birthYear = scanner.nextInt();
        // java.util.Date 클래스로 객체를 생성하여 참조변수에 저장
        // > Date 클래스 : 날짜와 시간을 저장하기 위한 클래스
        // > Date 클래스의 기본 생성자를 사용하여 객체를 생성하면 시스템(OS)의 현재 날짜와
        //시간이 저장된 Date 객체 생성
        Date now = new Date();

        // Date.getYear() : Date 객체에 저장된 날짜와 시간에서 년도를 정수값으로 반환하는 메소드
        // > 1900년을 기준으로 1년에 1씩 증가된 정수값으로 반환
        // > @Deprecated 어노테이션이 적용된 메소드
        // @Deprecated 어노테이션 : 메소드 사용을 권장하지 않도록 설정하는 어노테이션
        // > @Deprecated 어노테이션이 적용된 메소드를 호출할 경우 경고 발생
        // @SuppressWarnings 어노테이션 : 경고 메세지를 제거하는 어노테이션
        // > value 속성을 사용하여 경고 관련 속성값을 설정
        // > value 속성외에 다른 속성이 없는 경우 속성값만 설정 가능
        // @SuppressWarnings(value = "deprecation")
        
        @SuppressWarnings("deprecation")
        int currentYear = now.getYear() + 1900;

        // 현재 년도와 태어난 년도를 이용하여 나이 계산
        // int age = 2023 - birthYear + 1;
        int age = currentYear-birthYear + 1;


        // 결과 출력
        System.out.println("[결과] " + name + "님의 나이는 " + age + "살 입니다.");

        scanner.close();
    }
}


이름 입력 >> 정대만
태어난 년도 >> 1990
[결과] 정대만님의 나이는 34살 입니다.

(접근제한자)

package xyz.itwill.access;

PrivateMember

// 접근제한자 (Access Modifier) - 클래스,필드, 메소드에 대한 접근 설정을 제한하기 위한 키워드
// > private, package(default), protected, public


// private - 클래스 내부에서만 접근 가능하며 클래스 외부에서는 접근 불가능
public class PrivateMember {
    private int num;
@SuppressWarnings("unused")
    private  void  display() {
        System.out.println("num = " + num);
    }
}

package xyz.itwill.access;

PrivateMemberUse

public class PrivateMemberUse {
    public void run() {
        @SuppressWarnings("unused")
        PrivateMember member = new PrivateMember();

        // private 접근제한자로 설정된 필드와 메소드에 접근할 경우 에러 발생
        // member.num=100;
        // member.display();
    }
}

// public - 모든 패키지의 클래스에서 접근가능하도록 설정

// public 접근 제한자를 사용하여 클래스 선언 - public 클래스
// > public 클래스로 설정된 클래스는 모든 패키지의 클래스에서 접근 가능
// > public 클래스로 설정되지않은 클래스는 다른 패키지의 클래스에서 접근 불가능
// > 하나의 소스파일에는 public class를 하나만 설정 가능

package xyz.itwill.access;

PublicMember

public class PublicMember { // public 에선 class 에서, 다른곳으로 끌어와서 사용가능
    public int num;

    public void display() {
        System.out.println("num = " + num);
    }
}

package xyz.itwill.access;

PublicMemberUse

public class PublicMemberUse {
    public void run() {
        PublicMember member = new PublicMember();

        member.num = 100;
        member.display();
    }
}

package xyz.itwill.other;

PublicMemberOtherUse

import xyz.itwill.access.PublicMember; // PublicMember에 public빠지면 임포트안됨
public class PublicMemberOtherUse {
    public void run() {
        PublicMember member = new PublicMember();

        member.num=100;
        member.display();
    }
}

//protected 접근 제한자 : 같은 패키지의 클래스에서 접근 가능하도록 설정
// => 다른 패키지의 클래스에서 접근 불가능
// => 다른 패키지의 클래스에서 protected 접근 제한자의 필드 또는 메소드의 클래스를 상속을
// 받은 경우 접근 가능

package xyz.itwill.access;

ProtectedMember

public class ProtectedMember {
    protected int num;

    protected void display() {
        System.out.println("num = "+num);
    }
}

package xyz.itwill.access;

ProtectedMemberUse

public class ProtectedMemberUse {
    public void run() {
        ProtectedMember member=new ProtectedMember();

        member.num=100;
        member.display();
    }
}

package xyz.itwill.other;

ProtectedMemberOtherUse

import xyz.itwill.access.ProtectedMember;

public class ProtectedMemberOtherUse {
    public void run() {
        @SuppressWarnings("unused")
        ProtectedMember member = new ProtectedMember();

        //member.num=100;
        //member.display();
    }
}

package xyz.itwill.other;

ProtextedMemberOtherInheritanceUse

import xyz.itwill.access.ProtectedMember;

public class ProtextedMemberOtherInheritanceUse extends ProtectedMember {
    public void run() {
        num = 100;
        display();
    }
}

package xyz.itwill.access;

PackageMember

//  Package 접근제한자
public class PackageMember {
    int num;
    void display() {
        System.out.println("num = " + num);
    }
}

package xyz.itwill.access;

PackageMemberUse

public class PackageMemberUse {
    public void run() {
        PackageMember member = new PackageMember();

        member.num = 100;
        member.display();
    }
}

package xyz.itwill.other;

PackageMemberOtherInheritanceUse

import xyz.itwill.access.PackageMember;

public class PackageMemberOtherInheritanceUse extends PackageMember {
    public void run() {
        // num=100;
        // dispaly();
    }
}

package xyz.itwill.other;

PackageMemberOtherUse

import xyz.itwill.access.PackageMember;

public class PackageMemberOtherUse {
    public void run() {
        @SuppressWarnings("unused")
        PackageMember member=new PackageMember();

        //member.num=100;
        //member.display();
    }
}

package xyz.itwill.subject;

JavaSubject

public class JavaSubject {
    public void display() {
        System.out.println("아이티윌 학원의 Java 과정입니다.");
    }
}

package xyz.itwill.subject;

OracleSubject

public class OracleSubject {
    public void display() {
        System.out.println("아이티윌 학원의 Oracle 과정입니다.");
    }
}

package xyz.uniwill.subject;

JavaSubject

public class JavaSubject {
    public void display() {
        System.out.println("유니윌 학원의 Java 과정입니다.");
    }
}

package xyz.itwill.app;

SubjectApp

import xyz.itwill.subject.OracleSubject;
import xyz.itwill.subject.JavaSubject;

// 자료형의 이름이 같은 경우 import 처리 불가능
// import xyz.uniwill.subject.JavaSubject;

public class SubjectApp {
    public static void main(String[] args) {
        // 같은 패키지에 작성된 클래스는 패키지 경로 표현 없이 클래스 접근 가능
        // > 형식) 클래스명
        // 다른 패키지에 작성된 클래스는 반드시 패키지 경로를 표현해야만 클래스 접근 가능
        // > 형식) 패키지경로.클래스명
        // xyz.itwill.subject.OracleSubject subject1=new xyz.itwill.subject.OracleSubject();

        // 다른 패키지에 작성된 클래스를 import 처리한 경우 패키지 경로 표현없이 클래스 접근 가능
        OracleSubject subject1 = new OracleSubject();
        subject1.display();

        JavaSubject subject2 = new JavaSubject();
        subject2.display();

        //import 설정이 불가능 자료형은 패키지 경로를 반드시 표현해야만 접근 가능
        xyz.uniwill.subject.JavaSubject subject3 = new xyz.uniwill.subject.JavaSubject();
        subject3.display();
    }
}


아이티윌 학원의 Oracle 과정입니다.
아이티윌 학원의 Java 과정입니다.
유니윌 학원의 Java 과정입니다.

(예외처리)

try catch

// 예외 - 사용자에 의해 프로그램이 잘못 실행되거나 프로그램이 잘못 개발되어 실행될 경우
// 발생되는 프로그램 오류

// > 프로그램 실행시 예외가 발생되면 예외가 발샌된 지점에서 프로그램에 깅제 종료
// > 예외가 발생되어 프로그램에 강제로 종료되는 것을 방지하거나 프로그램이 강제로 종료된
// 이유를 알기위해 예외 처리(ExceptionHandle) 필드

// Java에서는 예외를 처리하기 위해 다양한 예외클래스를 제공
// 예외클래스 (ExceptionHandle) - 예외 관련 정보를 저장하기 위한 클래스
// > Exception 클래스를 상속받아 작성된 자식클래스
// > 프로그램 실행시 예외가 발새오디면 예외클래스로 객체를 생성하여 제공

// Throwable 클래스 - 프로그램에서 발생되는 모든 오류정보를 저장하기 위한 부모 클래스
// > 자식클래스 : Error , Exceoption 클래스

// 예외 종류
// 1. 일반 예외 : 프로그램 실행시 예외가 발생될 가능성이 높아 컴파일시 예외 처리를 하지않은 에러 발생
// 2. 실행 예외 : 프로그램 실행시 예외가 발생될 가능성이 낮아 예외처리를 하지않아도 컴파일시
// > RuntimeException 클래스를 상속받은 클래스로 예외처리
// > 실행 예외는 예외처리를 하지않은 경우 JVM이 자동으로 예외 처리하여 예외 메시지 제공

// 예외 처리방법 - try ~ catch 구문사용
// 형식 ) try {
// 예외가 발생될 수 있는 명령;
// ...
// } catch(예외클래스 참조변수) {
// 예외가 발생될수 있는 명령;
// ...
// } finally {
// 예외 발생과 상관없이 무조건 실행될 명령;
// ...
// }

// > try 키워드로 생성된 블럭의 명령을 실행할 때 예외가 발생될 경우 JVM이 해당 예외에 대한 예외 클래스로 객체 생성
// > try 키워드로 생성된 블럭에서 발생된 예외 관련 객체를 catch 키워드로 설정된 블럭으로 전달하여
// 참조변수에 저장 - 참조변수에 저장된 옝하 관련 객체의 메소드를 호출하여 예외 처리
// > try 키워드로 생성된 블럭에서 예외가 발생되면 프로그램이 종료되지 않고, catch 키워드의 블록으로
// 프로그램의 흐름(스레드)이 이동하여 예외처리 명령 실행
// > catch키워드로 블럭을 여러개 작성 가능 - 다양한 예외를 구분하여 예외처리 가능
// finally 키워드의 블럭에는 예외 발생과 상관없이 무조건 실행될 명령 작성 - 생략 가능
// > 사용 자원에 대한 제거 명령 실행

ExceptionHandleApp

package xyz.itwill.exception;

public class ExceptionHandleApp {
    public static void main(String[] args) {


//        int[] array = {10,20,30,40,50}; //배열사용하는이유? 일괄처리
//
//        try {
//            // 배열요소의 첨자가 사용범위를 벗어난 경우 ArrayIndexOutOfBoundsException 발생
//            for (int i = 0; i < array.length; i++) { // for (int i = 0; i <= array.length; i++) 하면 이퀄발생(오류)
//                System.out.println("array[" + i + "] = " + array[i]); // 예외 발생
//            }
//            System.out.println("[에러] 프로그램에 예기치 못한 오류가 발생되었습니다.");
//
//
//        System.out.println("---------------------------------------------");
//        System.out.println("[메세지] 프로그램이 정상적으로 실행 되었습니다.");



        System.out.println("00000000000000000000000-------------------000000000000000000000000000000");




        int[] array = {10,20,30,40,50}; //배열사용하는이유? 일괄처리

        try {
            // 배열요소의 첨자가 사용범위를 벗어난 경우 ArrayIndexOutOfBoundsException 발생
            for (int i = 0; i < array.length; i++) { // for (int i = 0; i <= array.length; i++) 하면 이퀄발생(오류)
                System.out.println("array[" + i + "] = " + array[i]); // 예외 발생
            }
            System.out.println("[메세지] 프로그램이 정상적으로 실행 되었습니다.");
            // try에서 예외가 발생되면 catch에서 잡음

        } catch (ArrayIndexOutOfBoundsException e) { // 예외객체를 전달받아 참조변수에 저장
            // 프로그램 사용자에게 예외 관련 메시지 출력 => 선택

            // 프로그램 개발자에게 예외 관련 메세지를 기록하여 제공 - 에러 로그 > 필스
            // > 참조변수에 저장된 예외 관련 객체의 메소드를 호출하여 작성
            // Throwable.getMessage() - 예외객체에 저장된 예외 메세지를 반환하는 메소드
            System.out.println("[예외]" + e.getMessage());

            // Throwable.printStackTrace() : 예외가 발생된 경로를 역추적하여 발생된 정보를 제공받아 출력하는 메소드
            e.printStackTrace();
        } finally {
            System.out.println("[메세지] 예외 발행과 상관없이 무조건 실행될 명령");
        }
    }
}

array[0] = 10
array[1] = 20
array[2] = 30
array[3] = 40
array[4] = 50
[메세지] 프로그램이 정상적으로 실행 되었습니다.
[메세지] 예외 발행과 상관없이 무조건 실행될 명령