반응형

프로그램 종료(System.exit( ))

package chap11.sec01.exam04;

/**
 * packageName : chap11.sec01.exam04
 * fileName : ExitApplication
 * author : GGG
 * date : 2023-09-26
 * description : System 클래스의 함수들 exit()
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class ExitApplication {
    public static void main(String[] args) {
        // TODO : 0 ~ 10까지 수 중에 값이 5일 때 프로그램을 강제 종료하세요
        for (int i = 0; i < 10; i++) {
            if(i == 5){
//                break;    // 반복문 종료
                System.exit(i); // 프로그램 강제 종료(kill), 밑에 코드가 실행안됨
            }
        }
        System.out.println("이 코드 실행?");     // 실행 안됨
    }
}

 

소요시간 체크함수 (.nanoTime())

package chap11.sec01.exam04;

/**
 * packageName : chap11.sec01.exam04
 * fileName : SystemTimeApplication
 * author : GGG
 * date : 2023-09-26
 * description : System 객체 : 소요시간 체크 함수 .nanoTime()
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class SystemTimeApplication {
    public static void main(String[] args) {
//        1) 처음 시간 체크 (컴퓨터 설정된 현재시간)
        long time = System.nanoTime(); // 1/10^9 시간
//        2) 실행
        int sum = 0;
        for (int i = 1; i <= 1000000; i++) {
            sum += i; //누적합
        }
//        3) 마지막 시간 체크
        long time2 = System.nanoTime(); // 1/10^9 시간
//        4) 마지막 시간 - 처음 시간 = 소요시간
        System.out.println("1~백만까지 합 : " + sum);
        System.out.println("소요시간(ns) : " + (time2 - time));
    }
}

-------------- 실행결과
1~백만까지 합 : 1784293664
소요시간(ns) : 2100200

 

Class 클래스

package chap11.sec01.exam05;

/**
 * packageName : chap11.sec01.exam05
 * fileName : CarApplication
 * author : GGG
 * date : 2023-09-26
 * description : Class 클래스 소개 : 클래스의 정보보기
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class CarApplication {
    public static void main(String[] args) {
        // TODO : Class => 자바에서 클래스의 정보(패키지명, 클래스명, 경로명 등)가 있는 객체
        //   java -> 컴파일(빌드) -> .class
        Class clazz = Car.class;

        // TODO : 정보 보기
        System.out.println(clazz.getPackage().getName());       // 패키지 정보보기
        System.out.println(clazz.getName());                    // 패키지 + 클래스명 정보가 출력(full 클래스명)
        System.out.println(clazz.getSimpleName());              // 패키지명 제외한 클래스명 정보보기
    }
}


------ 실행결과
chap11.sec01.exam05
chap11.sec01.exam05.Car
Car

 

ByteToString

byte 배열 -> 문자열(String)로 변환하기

package chap11.sec01.exam06;

/**
 * packageName : chap11.sec01.exam06
 * fileName : ByteToStringApplication
 * author : GGG
 * date : 2023-09-26
 * description :  byte 배열 -> 문자열(String)로 변환하기
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class ByteToStringApplication {
    public static void main(String[] args) {
        byte[] bytes = {72, 101, 108, 108, 111, 32, 74, 97, 118, 97};

        // TODO : byte 배열 -> 문자열 변환
        //  사용법 : new String(byte배열);
        String str1 = new String(bytes);
        System.out.println(str1);
        // TODO : 참고) 응용 : 사용법 : new String(byte배열, 인덱스번호, 문자열길이)
        String str2 = new String(bytes, 6, 4);
        System.out.println(str2);
        
    }
}

--------- 실행결과
Hello Java
Java

 

StringToByte

문자열 -> byte 배열로 변환

package chap11.sec01.exam08;

/**
 * packageName : chap11.sec01.exam08
 * fileName : StringToByteApplication
 * author : GGG
 * date : 2023-09-26
 * description : 문자열(String) => byte 배열 변환
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class StringToByteApplication {
    public static void main(String[] args) {
        String str = "안녕하세요";

        // TODO : 문자열 -> byte[] 변환
        //  사용법 : 문자열.getBytes() => byte[] 리턴
        byte[] bytes = str.getBytes();
        System.out.println("길이 : " + bytes.length);
    }

}

----- 실행결과
길이 : 15

 

String Char

charAt() 

문자열에서 어떤 인덱스 번호의 한 문자 조회하기

문자열.charAt(인덱스번호);
package chap11.sec01.exam07;

/**
 * packageName : chap11.sec01.exam07
 * fileName : StringCharApplication
 * author : GGG
 * date : 2023-09-26
 * description : 문자열에서 어떤 인덱스번호의 한문자 조회하기 : charAt(인덱스번호)
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class StringCharApplication {
    public static void main(String[] args) {
        // 주민번호
        String ssn = "123456-1234567";
        // TODO : 1문자 가져오기
        char gender = ssn.charAt(7);        // '1' 문자를 가져옴
        if(gender == '1' || gender == '3'){
            System.out.println("남자입니다.");
        } else if(gender == '2' || gender == '4'){
            System.out.println("여자입니다.");
        }
    }
}

-------- 실행결과
남자입니다.

 

String 클래스의 함수 : IndexOf()

package chap11.sec01.exam09;

/**
 * packageName : chap11.sec01.exam09
 * fileName : IndexOfApplication
 * author : GGG
 * date : 2023-09-26
 * description : String 클래스의 함수 : IndexOf()
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class IndexOfApplication {
    public static void main(String[] args) {
        String subject = "자바 프로그래밍";

        // TODO : 전달된 문자열이 시작되는 인덱스번호를 리턴 : indexOf(문자열)
        int location = subject.indexOf("프로그래밍");
        System.out.println(location);

        // TODO : (참고) 찾는 문자열이 없으면 : -1 리턴
        int location2 = subject.indexOf("파이썬");
        System.out.println(location2);        
    }
}
----------- 실행결과
3
-1

 

String 클래스의 함수 : length()

문자열 길이를 리턴하는 함수

package chap11.sec01.exam10;

/**
 * packageName : chap11.sec01.exam10
 * fileName : LengthApplication
 * author : GGG
 * date : 2023-09-26
 * description : String 클래스 함수 : 문자열 길이 리턴하는 함수 : length()
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class LengthApplication {
    public static void main(String[] args) {
        String ssn = "123456-1234567";
        // TODO : 문자열 길이 출력 : 문자열.length()
        System.out.println(ssn.length());
    }
}

---- 실행결과
14

 

String 클래스의 함수 : replace()

문자열 바꾸기 함수

package chap11.sec01.exam11;

/**
 * packageName : chap11.sec01.exam11
 * fileName : ReplaceApplication
 * author : GGG
 * date : 2023-09-26
 * description : String 클래스의 함수 : 문자열 바꾸기 함수 : replace()
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class ReplaceApplication {
    public static void main(String[] args) {
        // 자바 API : 자바의 유용한 함수 묶음
        String oldStr = "자바는 객체지향언어입니다. 자바는 풍부한 API도 지원합니다.";
        // TODO : 문자열 바꾸기 : 문자열.replace(이전문자, 바꿀문자);
        String newStr = oldStr.replace("자바","Java");
        System.out.println(newStr);
    }
}

--- 실행결과
Java는 객체지향언어입니다. Java는 풍부한 API도 지원합니다.

 

String 클래스의 함수 : substring()

문자열 자르기 함수

package chap11.sec01.exam12;

/**
 * packageName : chap11.sec01.exam12
 * fileName : SubStringApplication
 * author : GGG
 * date : 2023-09-26
 * description : String 클래스의 함수 : 문자열 자르기 함수 : substring()
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class SubStringApplication {
    public static void main(String[] args) {
        String ssn = "123456-1234567";

        // TODO : 문자열 자르기 : 문자열.substring(시작인덱스위치, 마지막인덱스위치)
        //        ( 시작인덱스위치 ~ 마지막인덱스위치 - 1 )
        String firstNum = ssn.substring(0, 6);
        System.out.println(firstNum);       // 주민번호 앞자리 숫자 출력

        // TODO 응용) 문자열.substring(시작인덱스번호);
        //           (시작인덱스위치 ~ 끝까지 잘림)
        String lastNum = ssn.substring(7);
        System.out.println(lastNum);        // 주민번호 뒷자리 숫자


    }

}


----- 실행결과
123456
1234567

 

String 클래스의 함수 : trim()

문자열의 앞 뒤 공백을 제거 후 문자열을 리턴하는 함수

package chap11.sec01.exam13;

/**
 * packageName : chap11.sec01.exam13
 * fileName : TrimApplication
 * author : GGG
 * date : 2023-09-26
 * description : String 클래스 함수 : 문자열 앞/뒤 공백 없애기 함수 : trim()
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class TrimApplication {
    public static void main(String[] args) {
        String tel = " 12345 ";     // 앞/뒤 공백이 있는 문자열
        // TODO : 앞/뒤 공백없애기 함수 : 문자열.trim();
        System.out.println(tel.trim());
    }
}

------- 실행결과
12345

 

Wrapper 클래스의  boxing/unboxing

 *          기본 자료형     : byte, short, int, long, float, double, char, boolean
 *          Wrapper 클래스 : 위의 자료형을 객체형으로 제공하는 클래스 
 *                                   Byte, Short, Integer, Long, Float, Double, Character, Boolean
 *          과거 코딩 :
 *          int -> Integer 변환 : API 함수를 사용해서 변환했음(Boxing)
 *          Integer -> int 변환 : (Unboxing)
 *          현대 코딩 :
 *          자동 변환 (함수 사용없이 자동변환됨)

 

public class BoxingApplication {
    public static void main(String[] args) {
        // TODO : 기본자료형 -> Wrapper 클래스로 변환
        //  과거 방식 : boxing
        Integer obj1 = new Integer(100);
        //  현대 방식
        Integer obj2 = 100;     // 자동 변환

        // TODO : Unboxing
        //  과거 방식
        int value1 = obj1.intValue();       // 원복 (함수호출)
        // 현대 방식
        int value2 = obj2;                  // 자동 변환

        System.out.println(value1);
        System.out.println(value2);


    }
}

-------- 출력결과
100
100

 

Math객체의 함수들

package chap11.sec01.exam15;

/**
 * packageName : chap11.sec01.exam20
 * fileName : MathApplication
 * author : ds
 * date : 2022-10-05
 * description : 수학함수들 . Math 객체의 함수들
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2022-10-05         ds          최초 생성
 */
public class MathApplication {
    public static void main(String[] args) {

        // TODO : 랜덤 함수 : 0 <= x < 1 값
        //  Math 클래스 : random() (정적(공유)함수 : 클래스명.함수명())
        double v11 = Math.random();
        System.out.println("v11=" + v11);
        // TODO : Math.abs(숫자); : 절대값 함수
        int v1 = Math.abs(-5);
        System.out.println("v1= " + v1);
        // TODO : Math.max(숫자1, 숫자2); 최대값 구하는 함수
        int v7 = Math.max(5,9);
        System.out.println("v7=" + v7);
        // TODO : Math.min(숫자1, 숫자2); 최소값 구하는 함수
        int v9 = Math.min(5,9);
        System.out.println("v9=" + v9);
        // TODO : Math.ceil(숫자); 소수점 올림 구하기(무조건 첫째자리에서 올림)
        double v3 = Math.ceil(5.3);
        System.out.println("v3=" + v3);
        // TODO : Math.floor(숫자); 소수점 버림 구하기(무조건 첫째자리에서 버림)
        double v5 = Math.floor(5.3);
        System.out.println("v5=" + v5);
        // TODO: Math.round(숫자); 반올림(무조건 첫째자리에서 반올림)
        double v14 = Math.round(5.3); // 5
        System.out.println("v14=" + v14);

        // TODO (참고) 응용 : 셋째자리에서 반올림하기
        //   1) 100을 곱하고 2) 반올림 구하고 3) 100 나누기
        double value = 12.3456;     // 셋째자리에서 반올림
        double temp = value * 100;  // 1)
        long temp2 = Math.round(temp);  // 2)
        double v16 = temp2/100.0; // 3)
        System.out.println("v16=" + v16);

    }
}

--- 결과
v11=0.7381840307023227
v1= 5
v7=9
v9=5
v3=6.0
v5=5.0
v14=5.0
v16=12.35

 

반응형

'Java > Java 이론' 카테고리의 다른 글

제네릭  (0) 2023.09.27
날짜 함수  (0) 2023.09.26
예외처리  (0) 2023.09.26
자료구조 - Stack / Queue  (0) 2023.09.26
객체의 동등비교  (1) 2023.09.25
반응형

Null Pointer Exception

package chap10.sec01.exam01;

/**
 * packageName : chap10.sec01.exam01
 * fileName : NullApplication
 * author : GGG
 * date : 2023-09-26
 * description : 예외처리(에러처리), null pointer exception(널 에러)
 * 요약 :
 *
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class NullApplication {
    public static void main(String[] args) {
//        TODO : null 발생시키는 코드
        String data = null;
        System.out.println(data.toString());        // null 에러 발생
    }

}

nullpointerexception 에러 발생

 

Out of Bound 에러

* description : 배열의 지정된 index 보다 큰 값을 조회할 때 발생하는 에러
*               Out of Bound 에러
*               예) 10개짜리인 배열 : 인덱스 번호 => 0 ~ 9
*               => 코딩에서 11인덱스를 조회하면 위의 에러가 발생
package chap10.sec01.exam02;

/**
 * packageName : chap10.sec01.exam02
 * fileName : OutOfBoundApplication
 * author : GGG
 * date : 2023-09-26
 * description : 배열의 지정된 index 보다 큰 값을 조회할 때 발생하는 에러
 *               Out of Bound 에러
 *               예) 10개짜리인 배열 : 인덱스 번호 => 0 ~ 9
 *               => 코딩에서 11인덱스를 조회하면 위의 에러가 발생
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class OutOfBoundApplication {
    public static void main(String[] args) {
//        TODO : Out of Bound 에러 발생시키는 코드
//         현재 main의 매개변수는 기본적으로 없음
        String data1 = args[0];
        String data2 = args[1];
        System.out.println(data1);
        System.out.println(data2);
    }
}
배열이 없는데 조회해서 에러가 발생함

 

NumberFormatException 에러

* description : Number Format 에러[예외](Exception) :
*                 문자열 -> 숫자로 변경하였는데 그 숫자 형태가 잘못되었을 경우 발생
package chap10.sec01.exam03;

/**
 * packageName : chap10.sec01.exam03
 * fileName : NumberFormatApplication
 * author : GGG
 * date : 2023-09-26
 * description : Number Format 에러[예외](Exception) :
 *                 문자열 -> 숫자로 변경하였는데 그 숫자 형태가 잘못되었을 경우 발생
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class NumberFormatApplication {
    public static void main(String[] args) {
//        TODO : 강제로 Number Format 에러 발생
        String data1 = "100";
        String data2 = "a100";
//        TODO : 문자열 -> 숫자로 변경 : Integer.parseInt()
        int value1 = Integer.parseInt(data1);
        int value2 = Integer.parseInt(data2);       // a100은 숫자 변환 안됨
        System.out.println(data1 + " " + data2);

    }
}

 

ClassCastException 에러

* description :  Class Cast 에러[예외](Exception)
*              => 클래스 형변환시 적절한 클래스를 안넣으면 에러 발생
package chap10.sec01.exam04;

/**
 * packageName : chap10.sec01.exam04
 * fileName : ClassCastApplication
 * author : GGG
 * date : 2023-09-26
 * description :  Class Cast 에러[예외](Exception)
 *              => 클래스 형변환시 적절한 클래스를 안넣으면 에러 발생
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class ClassCastApplication {
    public static void main(String[] args) {
//        강아지 객체 생성
        Dog dog = new Dog();
        changeDog(dog);     // 가능(매개변수의 다형성)
//        TODO : Class Cast 에러 발생 코드
//        고양이 객체 생성
        Cat cat = new Cat();
        changeDog(cat);     // 에러발생 => 고양이를 강아지로 강제 형변환 불가, 강아지 객체를 넣어야함

    }
//    공유 함수
    public static void changeDog(Animal animal){
//        강제 형변환 : Dog
        Dog dog = (Dog)animal;
    }
}

// 동물 클래스
class Animal{}
// 강아지
class Dog extends Animal{}
// 고양이
class Cat extends Animal{}

Exception in thread "main" java.lang.ClassCastException: class chap10.sec01.exam04.Cat cannot be cast to class chap10.sec01.exam04.Dog (chap10.sec01.exam04.Cat and chap10.sec01.exam04.Dog are in unnamed module of loader 'app')
at chap10.sec01.exam04.ClassCastApplication.changeDog(ClassCastApplication.java:31)
at chap10.sec01.exam04.ClassCastApplication.main(ClassCastApplication.java:25)

 

예외처리 - 에러처리를 하는 이유?

*        (참고) : 예외(개발자 에러) vs 시스템 에러(자바가상머신 에러)
*        에러처리를 왜 하는가? 에러(예외)가 발생하면 콘솔에 빨간줄의 에러코드가 나타남
*           => 사용자 입장에서 보기가 좋지 않음
*           => 목적) 에러처리를 이용해서 좀 더 품질 좋은 프로그램을 만들기 위함
*           (예) 에러발생 -> 관리자가 확인중입니다. 메시지 출력
try ~ catch 구문

try {
    <수행할 문장 1>;
    <수행할 문장 2>;
    ...
} catch(예외1) {
    <수행할 문장 A>;
    ...
} catch(예외2) {
    <수행할 문장 a>;
    ...
}

package chap10.sec02.exam01;

/**
 * packageName : chap10.sec02.exam01
 * fileName : TryCatchFinallyApplication
 * author : GGG
 * date : 2023-09-26
 * description : 일반 예외(에러) 처리
 * 요약 :
 *        (참고) : 예외(개발자 에러) vs 시스템 에러(자바가상머신 에러)
 *        에러처리를 왜 하는가? 에러(예외)가 발생하면 콘솔에 빨간줄의 에러코드가 나타남
 *           => 사용자 입장에서 보기가 좋지 않음
 *           => 목적) 에러처리를 이용해서 좀 더 품질 좋은 프로그램을 만들기 위함
 *           (예) 에러발생 -> 관리자가 확인중입니다. 메시지 출력
 *        
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class TryCatchFinallyApplication {
    public static void main(String[] args) {
//        TODO : 에러처리 : try ~ catch 구문
//         사용법 : try { 실행문; } catch(에러클래스 변수) {에러처리실행문;}
//          => (설명) try의 실행문이 실행될때 에러가 발생하면 catch 실행문이 실행됨
        try {
//            forName(클래스명) : 클래스명에 해당되는 자바클래스를 리턴
            Class clazz = Class.forName("String2");     // 에러 발생
        } catch (ClassNotFoundException e){
            System.out.println("클래스가 존재하지 않습니다.");
        }
    }
}

package chap10.sec02.exam02;

/**
 * packageName : chap10.sec02.exam02
 * fileName : TryCatch2Application
 * author : GGG
 * date : 2023-09-26
 * description : 예외처리(에러처리) 2
 * 요약 : try ~ catch 문은 여러 번 사용 가능
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class TryCatch2Application {
    public static void main(String[] args) {
//        TODO : Out of Bound 에러 발생시키는 코드
//         현재 main의 매개변수는 기본적으로 없음
//         try ~ catch() {}
        String data1 = null;
        String data2 = null;

        try{
            data1 = args[0];
            data2 = args[1];

            System.out.println(data1);      // 에러발생 -> catch로 이동함
            System.out.println(data2);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("실행 매개변수값이 없습니다.");
        }

//        TODO : 강제로 Number Format 에러 발생
//        TODO : 문자열 -> 숫자로 변경 : Integer.parseInt()
        try {
            int value1 = Integer.parseInt(data1);
            int value2 = Integer.parseInt(data2);       // a100은 숫자 변환 안됨
            System.out.println(data1 + " " + data2);

        } catch (NumberFormatException e){
            System.out.println("숫자로 변환할 수 없습니다.");
        } finally {
            System.out.println("다시 실행하세요");
        }

    }
}

어떤 예외가 발생하더라도 반드시 실행되어야 하는 부분이 있어야 한다면 finally를 사용한다.

finally 문은 try 문장 수행 중 예외 발생 여부에 상관없이 무조건 실행된다. 

 

Catch 2개 이상 있는 예외처리

package chap10.sec02.exam03;

/**
 * packageName : chap10.sec02.exam03
 * fileName : CatchByCatchApplication
 * author : GGG
 * date : 2023-09-26
 * description : Catch 2개 이상 있는 에러(예외) 처리
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class CatchByCatchApplication {
    public static void main(String[] args) {
        try {
//         TODO : Out of Bound 에러 발생시키는 코드
//         현재 main의 매개변수는 기본적으로 없음
            String data1 = args[0];
            String data2 = args[1];
            System.out.println(data1); // 에러 발생
            System.out.println(data2);

        } catch (ArrayIndexOutOfBoundsException e){
            System.out.println("실행 매개변수 값이 부족합니다.");
        } catch (NumberFormatException e){
            System.out.println("숫자로 변환할 수 없습니다.");
        } catch (Exception e) {
            // TODO : Exception 개발자 에러의 최고 조상 클래스 : 기본에러로 설정하면 거의 탐지됨.
            System.out.println("그외의 다른 에러가 발생했습니다.");
        }

    }
}

 

예외 던지기

예외가 발생할 수 있는 코드를 작성할 때 try - catch 블록으로 처리하는 것이 기본이지만, 경우에 따라서는 다른 곳에서 예외를 처리하도록 호출한 곳으로 예외를 떠넘길 수도 있다.

package chap10.sec02.exam04;

/**
 * packageName : chap10.sec02.exam04
 * fileName : ThrowsApplication
 * author : GGG
 * date : 2023-09-26
 * description : Throws, 예외(에러) 처리 떠넘기기
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class ThrowsApplication {
    public static void main(String[] args) {
        
        try {
            findClass();        // 공유함수 호출    
        } catch (Exception e){
            System.out.println("클래스가 존재하지 않습니다.");
        }
        
    }

    // 공유 함수
    // TODO : 리턴자료형 함수명() throws 에러클래스
    //   => 함수 내에서 에러처리 안하고 이 함수를 호출하는 쪽에 에러처리를 떠넘기기
    public static void findClass() throws ClassNotFoundException{
        // TODO : Class 객체 : 자바의 환경을 접근하는 자바 API 함수
        //   Class.forName("클래스명") : 해당 클래스를 리턴
        Class clazz = Class.forName("String2");
    }
}

 

반응형

'Java > Java 이론' 카테고리의 다른 글

날짜 함수  (0) 2023.09.26
JAVA API 함수  (0) 2023.09.26
자료구조 - Stack / Queue  (0) 2023.09.26
객체의 동등비교  (1) 2023.09.25
자료구조  (0) 2023.09.25
반응형

Stack

한 쪽 끝에서만 자료를 넣고 뺄 수 있는 LIFO(Last In First Out) 형식의 자료구조

package chap12.sec02.exam01;

import java.util.Stack;

/**
 * packageName : chap12.sec02.exam01
 * fileName : StackApplication
 * author : GGG
 * date : 2023-09-26
 * description : 스택(Stack)에 대한 소개 예제
 * 요약 :
 *         Stack(스택) : LIFO (Last In First Out)  -> 코딩 : Stack 클래스
 *         Queue(큐 : 인터페이스)  : FIFO (First in First out)  -> 코딩 : LinkedList 사용
 *
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class StackApplication {
    public static void main(String[] args) {

//        TODO : 스택 객체 정의
        Stack<Coin> coinStack = new Stack<>();
//        TODO : Coin 객체 추가 : .push(값)
        coinStack.push(new Coin(100));          // 100원  (1st)
        coinStack.push(new Coin(50));           // 50원
        coinStack.push(new Coin(500));          // 500원
        coinStack.push(new Coin(10));           // 10원   (last)     => 꺼낼때 먼저 나옴


//        TODO : Coin 객체 꺼내기 : .pop() (순차적으로 마지막 값을 꺼냄)
//         참고) 현재 마지막 값 조회하기 : .peek()
        while (coinStack.isEmpty() == false){
            Coin coin = coinStack.pop();        // 마지막 코인 꺼내기
            System.out.println("꺼낸 동전 : " + coin.getValue());
        }

        
    }
}

 

 

 

 

Queue

데이터를 일시적으로 쌓아두기 위한 형식, FIFO(First In First Out) 형식의 자료구조

package chap12.sec02.exam02;

import java.util.LinkedList;
import java.util.Queue;

/**
 * packageName : chap12.sec02.exam02
 * fileName : MessageApplication
 * author : GGG
 * date : 2023-09-26
 * description :    큐 소개 예제 : FIFO
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class MessageApplication {
    public static void main(String[] args) {
//        TODO: 큐(인터페이스) 객체 생성 - LinkedList 사용
        Queue<Message> messageQueue = new LinkedList<>();

//        TODO: 큐에 자료저장 : .offer(값) 또는 .add(값)
        messageQueue.offer(new Message("sendMail", "홍길동"));
        messageQueue.offer(new Message("sendSMS", "신용권"));
        messageQueue.offer(new Message("sendKakao", "홍두깨"));

//        TODO: 꺼내기 : .poll()
        while (messageQueue.isEmpty() == false){
            Message message = messageQueue.poll();      // 1st 꺼내기
            System.out.println(message.to);             // 보낼 사람 이름
            
        }


    }
}

반응형

'Java > Java 이론' 카테고리의 다른 글

JAVA API 함수  (0) 2023.09.26
예외처리  (0) 2023.09.26
객체의 동등비교  (1) 2023.09.25
자료구조  (0) 2023.09.25
MVC 디자인 패턴  (0) 2023.09.22
반응형

    // TODO: 연습문제) Map 자료구조에 값과 객체를 추가하고 아래와 같이 결과가 출력하도록
    //    실행 클래스를 코딩하세요
    //    힌트 : put(), get()
    //    입력 :  키         |    값
    //         currentPage      2
    //         totalNum         3
    //         dept             Dept{dno=10, dname='Sales', loc='부산'}
    //         sizePerPage      3
    //    결과 :
    //    2
    //    3
    //    Dept{dno=10, dname='Sales', loc='부산'}
    //    3

package chap12.sec01.verify.exam05;

/**
 * packageName : chap13.sec01.verify.exam01
 * fileName : Dept
 * author : kangtaegyung
 * date : 2023/04/05
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/05         kangtaegyung          최초 생성
 */
public class Dept {
    private int dno;
    private String dname;
    private String loc;

//    생성자
    public Dept(int dno, String dname, String loc) {
        this.dno = dno;
        this.dname = dname;
        this.loc = loc;
    }

//    getter
    public int getDno() {
        return dno;
    }

    public String getDname() {
        return dname;
    }

    public String getLoc() {
        return loc;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dno=" + dno +
                ", dname='" + dname + '\'' +
                ", loc='" + loc + '\'' +
                '}';
    }
}
package chap12.sec01.verify.exam05;

import java.util.HashMap;
import java.util.Map;

/**
 * packageName : chap12.sec01.verify.exam05
 * fileName : DeptApplication
 * author : GGG
 * date : 2023-09-26
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class DeptApplication {
    public static void main(String[] args) {

        Map<String, Object> map = new HashMap<>();
        map.put("currentPage", 2);
        map.put("totalNum", 3);
        map.put("dept", new Dept(10,"Sales", "부산"));
        map.put("sizePerPage", 3);

        System.out.println(map.get("currentPage"));
        System.out.println(map.get("totalNum"));
        System.out.println(map.get("dept"));
        System.out.println(map.get("sizePerPage"));


    }
}

// TODO: 연습문제) Map 자료구조에 값과 객체를 추가하고 아래와 같이 결과가 출력하도록
//    실행 클래스와 Qna 객체를 디자인(코딩)하세요
//    힌트 : put(), get()
//    입력 :  키         |    값
//         currentPage      1
//         totalNum         8
//         qna             Qna{qno=1, question='질문', questioner='질문자', answer='답변', answerer='답변자'}
//         sizePerPage      4
//    결과 :
//    1
//    8
//    Qna{qno=1, question='질문', questioner='질문자', answer='답변', answerer='답변자'}
//    4

package chap12.sec01.verify.exam06;

/**
 * packageName : chap13.sec01.verify.exam06
 * fileName : Qna
 * author : kangtaegyung
 * date : 2023/04/06
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/06         kangtaegyung          최초 생성
 */
public class Qna {
    private int qno;
    private String question;
    private String questioner;
    private String answer;
    private String answerer;

    public Qna(int qno, String question, String questioner, String answer, String answerer) {
        this.qno = qno;
        this.question = question;
        this.questioner = questioner;
        this.answer = answer;
        this.answerer = answerer;
    }

    public int getQno() {
        return qno;
    }

    public String getQuestion() {
        return question;
    }

    public String getQuestioner() {
        return questioner;
    }

    public String getAnswer() {
        return answer;
    }

    public String getAnswerer() {
        return answerer;
    }

    @Override
    public String toString() {
        return "Qna{" +
                "qno=" + qno +
                ", question='" + question + '\'' +
                ", questioner='" + questioner + '\'' +
                ", answer='" + answer + '\'' +
                ", answerer='" + answerer + '\'' +
                '}';
    }
}
package chap12.sec01.verify.exam06;

import java.util.HashMap;
import java.util.Map;


/**
 * packageName : chap12.sec01.verify.exam06
 * fileName : QnaApplication
 * author : GGG
 * date : 2023-09-26
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class QnaApplication {
    public static void main(String[] args) {
        Map<String, Object> map = new HashMap();

        map.put("currentPage", 1);
        map.put("totalNum", 8);
        map.put("qna", new Qna(1, "질문", "질문자", "답변", "답변자"));
        map.put("sizePerPage", 4);


        System.out.println(map.get("currentPage"));
        System.out.println(map.get("totalNum"));
        System.out.println(map.get("qna"));
        System.out.println(map.get("sizePerPage"));
    }
}

// TODO: 연습문제) 실행클래스는 결과는 아래와 같다.
//    Student 객체의 속성 및 중복을 제거하기 위해 재정의해야할 함수를 포함하여
//    Student 객체를 디자인(코딩)하세요
//    결과 :
//       1:홍길동
//       2:신용권

package chap12.sec01.verify.exam07;

import java.util.Objects;

/**
 * packageName : chap12.sec01.verify.exam07
 * fileName : Student
 * author : GGG
 * date : 2023-09-26
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class Student {

    private int studentNum;
    private String name;

    public Student() {
    }

    public Student(int studentNum, String name) {
        this.studentNum = studentNum;
        this.name = name;
    }

    public int getStudentNum() {
        return studentNum;
    }

    public String getName() {
        return name;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return studentNum == student.studentNum && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(studentNum, name);
    }


}
package chap12.sec01.verify.exam07;


import java.util.HashSet;
import java.util.Set;

/**
 * packageName : chap13.sec01.verify.exam08
 * fileName : HashSetApplicaton
 * author : kangtaegyung
 * date : 2022/10/03
 * description : HashSet에 Student 객체를 저장하려고 합니다.
 *      학번이 같으면 동일한 Student라고 가정하고 중복 저장이 되지 않도록 하고 싶습니다.
 *      Student 클래스에서 재정의해야 하는 hashCode()와 equals() 함수를 내용을 채워보세요.
 *      Student의 해시코드는 학번이라고 가정합니다.
 * 요약 : 자바 기본 자료구조 ( List, Set, Map )
 *      
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2022/10/03         kangtaegyung          최초 생성
 */
public class HashSetApplication {
    public static void main(String[] args) {
        Set<Student> set = new HashSet<Student>();

//        HashSet : 키가 중복되었을때 자동으로 중복을 제거해주는 자료구조
//        HashSet : 기존에 값이 있으면 안들어감
        set.add(new Student(1, "홍길동"));
        set.add(new Student(2, "신용권"));
        set.add(new Student(1, "홍길동"));

        for(Student student : set) {
            System.out.println(student.getStudentNum() + ":" + student.getName());
        }
    }
}
반응형

'Java > Java 연습문제' 카테고리의 다른 글

객체생성 연습문제  (0) 2023.10.04
자료구조 연습문제  (0) 2023.09.26
이름 붙은 반복문 심화예제  (0) 2023.08.12
이름 붙은 반복문  (0) 2023.08.12
break문과 continue 문 예제  (0) 2023.08.12
반응형
// TODO: 연습문제) 실행 클래스의 결과가 다음과 같도록 DeptDao 의 createDept() 함수에
//         List 의 자료를 추가하는 로직을 작성하세요.
//    결과 :
//      10 Sales       부산
//      20 Marketing   서울
//      30 Research    대전

package chap12.sec01.verify.exam01;

/**
 * packageName : chap13.sec01.verify.exam01
 * fileName : Dept
 * author : kangtaegyung
 * date : 2023/04/05
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/05         kangtaegyung          최초 생성
 */
public class Dept {
    private int dno;
    private String dname;
    private String loc;

//    생성자
    public Dept(int dno, String dname, String loc) {
        this.dno = dno;
        this.dname = dname;
        this.loc = loc;
    }

//    getter
    public int getDno() {
        return dno;
    }

    public String getDname() {
        return dname;
    }

    public String getLoc() {
        return loc;
    }

}
package chap12.sec01.verify.exam01;

import java.util.ArrayList;
import java.util.List;

/**
 * packageName : chap12.sec01.verify.exam01
 * fileName : DeptDao
 * author : GGG
 * date : 2023-09-25
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-25         GGG          최초 생성
 */

public class DeptDao {
    public List<Dept> createDept(){
        List<Dept> list = new ArrayList<>();
        list.add(new Dept(10,"sales","부산"));
        list.add(new Dept(20,"Marketing","서울"));
        list.add(new Dept(30,"Research","대전"));
        return list;
    }

}
package chap12.sec01.verify.exam01;

import java.util.List;

/**
 * packageName : chap13.sec01.verify.exam01
 * fileName : DeptApplication
 * author : kangtaegyung
 * date : 2023/04/05
 * description : 실행클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/05         kangtaegyung          최초 생성
 */
public class DeptApplication {
    public static void main(String[] args) {
        DeptDao deptDao = new DeptDao();
        List<Dept> deptList = deptDao.createDept(); // 자료 생성

        for(Dept dept : deptList) {
            System.out.println(dept.getDno() + " " + dept.getDname()
                    + " " + dept.getLoc());
        }
    }
}

// TODO: 연습문제) 실행 클래스의 결과가 다음과 같도록
//       Emp 모델을 디자인하고 EmpDao의 createDept()
//       List 의 자료를 추가하는 로직을 작성하세요.
//    결과 :
//        1 Scott 3000 500 10
//        2 Mark 3500 0 20
//        3 Smith 5000 1000 30

package chap12.sec01.verify.exam02;

/**
 * packageName : chap13.sec01.verify.exam02
 * fileName : Emp
 * author : kangtaegyung
 * date : 2023/04/05
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/05         kangtaegyung          최초 생성
 */
public class Emp {
    private int eno;
    private String ename;
    private int salary;
    private int comission;
    private int dno;

//    생성자
    public Emp(int eno, String ename, int salary, int comission, int dno) {
        this.eno = eno;
        this.ename = ename;
        this.salary = salary;
        this.comission = comission;
        this.dno = dno;
    }

//    Getter
    public int getEno() {
        return eno;
    }

    public String getEname() {
        return ename;
    }

    public int getSalary() {
        return salary;
    }

    public int getComission() {
        return comission;
    }

    public int getDno() {
        return dno;
    }
}
package chap12.sec01.verify.exam02;

import java.util.ArrayList;
import java.util.List;

/**
 * packageName : chap12.sec01.verify.exam02
 * fileName : EmpDao
 * author : GGG
 * date : 2023-09-25
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-25         GGG          최초 생성
 */
//        1 Scott 3000 500 10
//        2 Mark 3500 0 20
//        3 Smith 5000 1000 30
public class EmpDao {
    public List<Emp> createEmp(){
        List<Emp> list = new ArrayList<>();
        list.add(new Emp(1,"Scott",3000,500,10));
        list.add(new Emp(2,"Mark",3500,0,20));
        list.add(new Emp(3,"Smith",5000,1000,30));
        return list;
    }
}
package chap12.sec01.verify.exam02;

import java.util.List;

/**
 * packageName : chap13.sec01.verify.exam02
 * fileName : EmpApplication
 * author : kangtaegyung
 * date : 2023/04/05
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/05         kangtaegyung          최초 생성
 */
public class EmpApplication {
    public static void main(String[] args) {
        EmpDao empDao = new EmpDao();

        List<Emp> empList =  empDao.createEmp();

        //        List 배열 내용 출력
        for(Emp emp : empList) {
            System.out.println(emp.getEno() + " "
                          + emp.getEname() + " "
                          + emp.getSalary() + " "
                          + emp.getComission() + " "
                          + emp.getDno());
        }
    }
}

// TODO: 연습문제) 실행 클래스의 결과가 다음과 같도록
//       Faq 모델을 디자인하고 실행클래스 FaqApplication 에서
//      다음과 같은 결과가 나오도록 코딩하세요
//    결과 :
//        1 제목1 내용1
//        2 제목2 내용2
//        3 제목3 내용3

package chap12.sec01.verify.exam03;

/**
 * packageName : chap12.sec01.verify.exam03
 * fileName : Faq
 * author : GGG
 * date : 2023-09-26
 * description : Faq 모델 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class Faq {
//    TODO : 속성
    private int fid;
    private String subject;
    private String text;

//    TODO : 기본 생성자, 풀 속성 생성자
    public Faq() {
    }

    public Faq(int fid, String subject, String text) {
        this.fid = fid;
        this.subject = subject;
        this.text = text;
    }

//    TODO : getter
    public int getFid() {
        return fid;
    }

    public String getSubject() {
        return subject;
    }

    public String getText() {
        return text;
    }
}
package chap12.sec01.verify.exam03;


import java.util.ArrayList;
import java.util.List;

/**
 * packageName : chap13.sec01.verify.exam03
 * fileName : FaqDao
 * author : kangtaegyung
 * date : 2023/04/05
 * description : MVC 디자인 패턴
 * 요약 :
 *          M : Model               - 속성, 생성자, getter/setter 함수 (정보 저장용 클래스)
 *              DAO(DB 접속용 클래스) - CRUD(Create(insert) Read(select) Update(Update) Delete(Delete) 함수만 존재함
 *          V : View
 *          C : Controller
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/05         kangtaegyung          최초 생성
 */
public class FaqDao {
    public List<Faq> createFaq() {
//        내용 완성
//        ArrayList 사용, .add()
        List<Faq> list = new ArrayList<>();
        list.add(new Faq(1, "제목1", "내용1"));
        list.add(new Faq(2, "제목2", "내용2"));
        list.add(new Faq(3, "제목3", "내용3"));

        return list;
    }
}
package chap12.sec01.verify.exam03;


import java.util.List;

/**
 * packageName : chap13.sec01.verify.exam03
 * fileName : FaqApplication
 * author : kangtaegyung
 * date : 2023/04/05
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * -----------------------------------------------------------
 * 2023/04/05         kangtaegyung          최초 생성
 */

public class FaqApplication {
    public static void main(String[] args) {
        FaqDao faqDao = new FaqDao();

        List<Faq> faqList =  faqDao.createFaq();

        //        List 배열 내용 출력

        for(Faq faq : faqList) {
            System.out.println(faq.getFid() + " "
                    + faq.getSubject() + " "
                    + faq.getText());
        }
    }
}

// TODO: 연습문제) BoardDao 의 createBoard() 함수에는 List 자료구조를 이용해
//       아래의 값이 추가되어 있다. Board 객체와 실행클래스 BoardApplication 를 작성해서 아래 결과가 나오도록 코딩하세요
//    단, Board 객체의 속성명은 아래의 이름을 사용하고, createBoard() 함수를 이용해서 자료를 생성하세요.
//       title // 제목 속성
//       content // 내용 속성
//    결과 :
//      제목1-내용1
//      제목2-내용2
//      제목3-내용3

package chap12.sec01.verify.exam04;

/**
 * packageName : chap12.sec01.verify.exam04
 * fileName : Board
 * author : GGG
 * date : 2023-09-26
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class Board {
    private String title;
    private String content;

    public Board() {
    }

    public Board(String title, String content) {
        this.title = title;
        this.content = content;
    }

    public String getTitle() {
        return title;
    }

    public String getContent() {
        return content;
    }
}
package chap12.sec01.verify.exam04;

import java.util.ArrayList;
import java.util.List;

/**
 * packageName : chap12.sec01.verify.exam04
 * fileName : BoardDao
 * author : GGG
 * date : 2023-09-26
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-26         GGG          최초 생성
 */
public class BoardDao {

    public List<Board> createDept(){

        List<Board> list = new ArrayList<>();
        list.add(new Board("제목1", "내용1"));
        list.add(new Board("제목2", "내용2"));
        list.add(new Board("제목3", "내용3"));

        return list;
    }

}
package chap12.sec01.verify.exam04;

import java.util.List;

/**
 * packageName : chap13.sec01.verify.exam07
 * fileName : ListApplication
 * author : kangtaegyung
 * date : 2022/10/03
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2022/10/03         kangtaegyung          최초 생성
 */
public class BoardApplication {
    public static void main(String[] args) {
        BoardDao dao = new BoardDao();
//        List 배열 : Board 객체에 저장되어 있는 값이 들어감
        List<Board> list = dao.createDept();

//        List 배열 내용 출력
        for(Board board : list) {
            System.out.println(board.getTitle() + "-" + board.getContent());
        }
    }
}
반응형

'Java > Java 연습문제' 카테고리의 다른 글

객체생성 연습문제  (0) 2023.10.04
자료구조 연습문제 2  (0) 2023.09.26
이름 붙은 반복문 심화예제  (0) 2023.08.12
이름 붙은 반복문  (0) 2023.08.12
break문과 continue 문 예제  (0) 2023.08.12
반응형

.equals()

  • 두개의 객체가 같다라는 의미 ? => 속성이 같다는 의미로 해석
  • .equals() 함수 소스를 보면 두 개의 객체를 비교할 때 비교연산자(==)를 사용하여 비교를 함
  • == 연산자는 속성의 주소값(쉬운말로 방번호)을 비교를 함

String 객체에서 어떻게 비교를 해야할까?

.equals() 함수를 재정의하여 비교연산자(==) 대신 값을 비교하도록 재정의함

즉, 두 개의 객체를 비교할 때 속성을 비교할 수 있게 equals() 함수를 재정의하여 사용해야함!

 

JAVA 언어의 최고 조상 객체는 Object 객체이며 Object 객체의 메서드 종류는 .equals(), .hashCode(), .toString()등이 있음

 

JAVA에서 모든 객체(클래스)는 Object 를 상속받고 있음 (extends 라는 키워드는 생략)

 

예제1

public class Member {
//    TODO : 속성, 생성자함수, 메서드
//    속성
    public  String id;

//    생성자
    public Member(String id) {
        this.id = id;
    }

//    객체 동등 비교를 위해 .equals 함수 재정의 해야함 : alt + insert
//    TODO : 인텔리제이 자동코딩
//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (o == null || getClass() != o.getClass()) return false;
//        Member member = (Member) o;
//        return Objects.equals(id, member.id);       // 객체 속성 동등비교
//    }

//    TODO : 참고, 개발자 직접코딩
    @Override
    public boolean equals(Object o) {

//        1) 매개변수 o 객체가 Member 인가?
        if(o instanceof Member) {
//            강제 형변환
            Member member = (Member) o;
//        2) 속성의 값(id) 비교 같으면 true, 아니면 false
            if(this.id.equals(member.id)) {
                return true;
            }
        }
        return false;
    }

}

실행클래스

 

public class MemberApplication {
    public static void main(String[] args) {
//       Member 객체 2명 생성
        Member member = new Member("blue");
        Member member2 = new Member("blue");

//        객체 2명 비교
        if(member.equals(member2)){
            System.out.println("같습니다.");
        } else {
            System.out.println("다릅니다.");
        }


    }
}

결과

 

같습니다.

 

.hashCode()

*          해쉬코드(hashCode)? : 객체를 식별하는 유일한 정수값(번호 중복 없음)
*          1) 방번호(주소) : 메모리의 랜덤하고 유일한 방번호 만들때 사용
*          2) HashMap, HashSet 자료구조에서 내부적으로 해쉬코드를 사용함(객체들을 비교할때)
*          TODO => 기본 hashCode는 객체간 비교에서 오류를 일으키므로 재정의 해야함!
*            결론 ) .equals(), .hashCode() 재정의해야함 (추천 : 자동코딩 기능이용)

예제2

public class Member {
//    속성
    public String id;

//    생성자
    public Member(String id) {
        this.id = id;
    }

//    equals, hashCode 재정의
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Member member = (Member) o;
        return Objects.equals(id, member.id);
    }

    @Override
    public int hashCode() {
//        2개의 객체를 생성해서 비교시 id 속성의 해쉬코드가 2개 모두 같아짐
        return Objects.hash(id);    // 객체의 비교(속성을 비교)
    }
반응형

'Java > Java 이론' 카테고리의 다른 글

예외처리  (0) 2023.09.26
자료구조 - Stack / Queue  (0) 2023.09.26
자료구조  (0) 2023.09.25
MVC 디자인 패턴  (0) 2023.09.22
생성자  (0) 2023.09.20
반응형

ArrayList

package chap12.sec01.exam01;

import java.util.ArrayList;			// ArrayList를 사용하기 위한 유틸패키지 import
import java.util.List;				// List를 사용하기 위한 유틸패키지 import

/**
 * packageName : chap12.sec01.exam01
 * fileName : ArrayListApplication
 * author : GGG
 * date : 2023-09-25
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-25         GGG          최초 생성
 */
public class ArrayListApplication {
    public static void main(String[] args) {
//        객체 생성 : 리스트 : 다형성(자식에 따라 결과가 달라짐)
        List<String> list = new ArrayList<>();
//      TODO: 리스트에 추가하기
//        사용법 : 리스트객체변수.add(값); // 최소 0 인덱스 번호에 추가됨
        list.add("Java");                           // 1st(0: 인덱스 번호)
        list.add("JDBC");                           // 2nd
        list.add("Servlet/JSP");                    // 4th
        list.add(2, "Database");       // 3rd
        list.add("myBATIS");                        // 5th

//        결과출력
        System.out.println(list);

//        TODO : 향상된 배열의 크기 가져오기    (vs. 일반배열.length)
        int size = list.size();
//        결과 출력
        System.out.println("총 객체 수"+ size);
    }
}
// 결과
[Java, JDBC, Database, Servlet/JSP, myBATIS]
*          List : 인터페이스, 배열을 개선한 자료구조
*                배열(고정길이) vs 향상된 배열(크기 자동증가) : 기본 10개
*                부모인터페이스를 상속받은 자식클래스들
*                리스트 : 다형성(자식에 따라 결과가 달라짐)
*                ArrayList(*)     : 순차적으로 추가/삭제시 속도 빠름
*                                   중간에 추가/삭제시 속도 저하
*                LinkedList       : 중간에 추가/삭제시 속도 향상, 순차적일때 속도 저하
*                Vector           : 멀티 쓰레드 환경에서 사용하는 자료구조
//        TODO : 향상된 배열의 크기 가져오기    (vs. 일반배열.length)
//          사용법 : 객체변수.size();
        int size = list.size();
//        결과 출력
        System.out.println("총 객체 수 : "+ size);

총 객체 수 : 5

//        TODO : 저장된 데이터 가져오기
//         예제 1) 3번째 자료 가져오기
//         사용법 : 객체변수.get(인덱스 번호)
        String skill = list.get(2);     // 0 ~ n : 0부터 시작
//        결과출력
        System.out.println("3번째 자료 : " + skill);

3번째 자료 : Database

//        TODO : 반복문을 이용해서 자료 모두 출력하기
for (int i = 0; i < list.size(); i++) {
    String str = list.get(i);
    System.out.println(i + " : " + str);
}

0 : Java
1 : JDBC
2 : Database
3 : Servlet/JSP
4 : myBATIS

//        TODO : 자료 수정하기
//         사용법 : 객체변수.set(인덱스번호, 값);
list.set(0, "자바");
System.out.println("수정된 값 : " + list.get(0));

수정된 값 : 자바

//        TODO : 자료 삭제하기
//         사용법 :  객체변수.remove(인덱스번호)
//         사용법 :  객체변수.remove(값)
        list.remove(2);         // 2번 인덱스 위치의 값 삭제
        list.remove(2);
        list.remove("myBATIS");     // 값(myBATIS) 찾아서 삭제
        //        결과출력
        System.out.println(list);

[자바, JDBC]

//        TODO : 모든 자료 삭제하기
        list.clear();       // 모든 자료 삭제
//        결과출력
        System.out.println(list);

[]

 

Vector

*        Vector : 멀티쓰레드 환경에서 사용하는 자료구조, ArrayList 거의 유사
*                  (병렬처리 : 속도 향상(장점), 코딩 복잡도 증가(동기화 문제 등))
*          속도 : ArrayList > Vector

 

public class Board {
    String subject;     // 제목
    String content;     // 내용
    String writer;      // 작성자

//    매개변수 3개 생성자
    public Board(String subject, String content, String writer) {
        this.subject = subject;
        this.content = content;
        this.writer = writer;
    }

//    .equals(), .hashCode() 재정의
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Board board = (Board) o;
        return Objects.equals(subject, board.subject) && Objects.equals(content, board.content) && Objects.equals(writer, board.writer);
    }

    @Override
    public int hashCode() {
        return Objects.hash(subject, content, writer);
    }

//    TODO 편리성 증진 : 함수 재정의 toString() : 객체를 문자열로 변환하는 함수

    @Override
    public String toString() {
        return "["+ subject + "," + content + "," + writer +"]";
    }
public class BoardApplication {
    public static void main(String[] args) {
//        백터 객체 생성 : 다형성 이용
//        TODO : Vector의 부모 : List ( add(): [추가], get(): [조회), set(): [수정], remove(): [삭제] )
        List<Board> list = new Vector<>();
//        객체 추가
        list.add(new Board("제목1", "내용1", "글쓴이1"));
        list.add(new Board("제목2", "내용2", "글쓴이2"));
        list.add(new Board("제목3", "내용3", "글쓴이3"));
        list.add(new Board("제목4", "내용4", "글쓴이4"));
        list.add(new Board("제목5", "내용5", "글쓴이5"));

        System.out.println(list);   // 속성 : toString() : list에서 생략해도됨 (자동 실행)

//        삭제 2건
        list.remove(2);     // 2번 삭제 후 자동으로 자료가 당겨짐
        list.remove(3);
        System.out.println(list);

    }

실행결과

[[제목1,내용1,글쓴이1], [제목2,내용2,글쓴이2], [제목3,내용3,글쓴이3], [제목4,내용4,글쓴이4], [제목5,내용5,글쓴이5]]
[[제목1,내용1,글쓴이1], [제목2,내용2,글쓴이2], [제목4,내용4,글쓴이4]]

 

LinkedList

*    LinkedList  vs  ArrayList
*    구분       |  순차 추가/삭제      |  중간에 추가/삭제
*    ArrayList  |   빠름               | 느림
*    LinkedList |   느림               | 빠름
public class LinkedListApplication {
    public static void main(String[] args) {
//     TODO : 예제 1) 속도 비교 : ArrayList vs LinkedList
//        객체 생성 : 다형성을 이용
        List<String> list = new ArrayList<>();
        List<String> list2 = new LinkedList<>();

//       시간 변수 2개
        long startTime;
        long endTime;
//        TODO 1) 처음시간 : System 객체 : 시간을 재는 함수 : nanoTime()
        startTime = System.nanoTime();

//        TODO 2) 실행 : 반복문 ( 0 ~ 10000 까지 배열에 값을 추가 )
        for (int i = 0; i < 10000 ; i++) {
//            중간에 추가 : add(인덱스번호, 값)
            list.add(0, String.valueOf(i));     // 정수 -> 문자열 반환 추가

        }
//        TODO 3) 종료 시간 : System 객체 nanoTime()
        endTime = System.nanoTime();
        System.out.println("ArrayList 소요시간 : " + (endTime - startTime));

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

//        TODO 1) 처음시간 : System 객체 : 시간을 재는 함수 : nanoTime()
        startTime = System.nanoTime();

//        TODO 2) 실행 : 반복문 ( 0 ~ 10000 까지 배열에 값을 추가 )
        for (int i = 0; i < 10000 ; i++) {
//            중간에 추가 : add(인덱스번호, 값)
            list2.add(0, String.valueOf(i));     // 정수 -> 문자열 반환 추가

        }
//        TODO 3) 종료 시간 : System 객체 nanoTime()
        endTime = System.nanoTime();
        System.out.println("LinkedList 소요시간 : " + (endTime - startTime));
    }

Set

*      복습 : List : (ArrayList, LinkedList, Vector)
*            Set  : (HashSet, LinkedHashSet, TreeSet 등)
*      Set : 집합을 표현한 인터페이스, 자식클래스 (HashSet, LinkedHashSet, TreeSet 등)
*      특징 : 순서가 없음(인덱스번호가 없음), 중복이 허용되지 않음
*      vs List 특징(순서 있음(인덱스), 중복 허용됨)
public class HashSetApplication {
    public static void main(String[] args) {
//        객체 생성 : 다형성
        Set<String> set = new HashSet<>();

//      TODO : 자료 추가 / 사용법 : 객체변수.add(값)
        set.add("Java");
        set.add("JDBC");
        set.add("Servlet/JSP");
        set.add("Java");
        set.add("myBATIS");
        System.out.println(set);
//        set의 특징 : 중복을 허용하지 않음

//      TODO : 자료 크기 보기 / 사용법 : 객체변수.size();
        int size = set.size();
        System.out.println("총 객체수 : " + size);

//      TODO : 자료 삭제 / 사용법 : 객체변수.remove(값);
        set.remove("JDBC");
        System.out.println(set);

//      TODO 참고 : 모두 삭제 / 사용법 : 객체변수.clear()
        set.clear();
        System.out.println(set);
    }

HashSet 예제

package chap12.sec01.exam05;

import java.util.Objects;

/**
 * packageName : chap12.sec01.exam05
 * fileName : Member
 * author : GGG
 * date : 2023-09-25
 * description : 회원 객체
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-25         GGG          최초 생성
 */
public class Member {
    public String name; // 이름
    public int age;     // 나이

    public Member(String name, int age) {
        this.name = name;
        this.age = age;
    }

//    객체 비교

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Member member = (Member) o;
        return age == member.age && Objects.equals(name, member.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "[" + name + "," + age +"]";
    }
}
public class HashSetApplication {
    public static void main(String[] args) {
//        객체 생성 : 다형성
        Set<Member> set = new HashSet<>();
//        객체 추가
        set.add(new Member("홍길동", 30));
        set.add(new Member("홍길동", 30));
//        TODO : 중복 제거되었는지 확인(.hashCode() 재정의)
        System.out.println(set);
    }
}

Map

*      복습 : List(**) : (ArrayList(*), LinkedList, Vector), 향상된 배열
*            Set  : (HashSet, LinkedHashSet 등), 집합 구현
*            Map(**)  : (HashMap(*), HashTable 등) (키, 값 : 엔트리) 이루어진 자료구조
*             (vs List (인덱스번호, 값)
*            특징 : 키 - 유일한 값 (중복 금지), 값 - 중복 허용
public class HashMapApplication {
    public static void main(String[] args) {
//        객체 생성 : 다형성
//        TODO : Map<키_자료형, 값_자료형> map = new HashMap<>();
//         Object : 자바 최고 조상 객체
        Map<String, Object> map = new HashMap<>();

//        TODO : 자료 추가 : 객체변수.put(키, 값);
        map.put("no", 1);
        map.put("name", "홍길동");
        System.out.println(map);

//        TODO : 자료크기 : 객체변수.size()
        System.out.println("총 객체 수 : " + map.size());

//        TODO : 키로 값을 조회하기 : 객체변수.get("키이름") => 결과 : 값이 출력
        System.out.println(map.get("no"));
        System.out.println(map.get("name"));

//        TODO : 수정하기 : 객체변수.put(키, 값)
        map.put("no", 2);   // no=1->2 값 수정
        System.out.println("1 -> 2 : " + map.get("no"));

//        TODO : 삭제하기 : 객체변수.remove(키이름);
        map.remove("no");
        System.out.println("키 삭제 : " + map.get("no"));


    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

자료구조 - Stack / Queue  (0) 2023.09.26
객체의 동등비교  (1) 2023.09.25
MVC 디자인 패턴  (0) 2023.09.22
생성자  (0) 2023.09.20
생성자 함수  (0) 2023.09.20
반응형
package chap06.sec04.exam01;

/**
 * packageName : chap06.sec04.exam01
 * fileName : Calculator
 * author : GGG
 * date : 2023-09-20
 * description : 모델 클래스
 *              함수(멤버 메소드)
 * 요약 :
 *          MVC 디자인 패턴 : M(Model), V(View), C(Controller)
 *          TODO : <요약>
 *              함수형태 :
 *              접근제어자 리턴자료형 함수명(매개변수1...., 매개변수 n) {실행문 ;}
 *              ex) public void sample(int a, String b, double c) { }
 *              접근제어자 : public(공용), default(생략, package 내에서는 사용가능) 등...
 *              함수이름 명명법 : 낙타표기법(카멜표기법), 첫 글자는 소문자, 단어 + 단어는 대문자
 *              매개변수 : 함수 실행시 전달되는 데이터
 *              리턴자료형 : 함수가 실행된 이후 결과값을 내보내기 할 떄 사용
 *              리턴값이 없는 함수 형태 호출: 객체변수.함수()
 *              리턴값이 있는 함수 형태 호출: 자료형 변수명 = 객체변수.함수()
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Calculator {
//      TODO: 속성(필드), 생성자함수, 함수(메소드)
//    속성생략 : 사물이나 사람의 특징을 나타냄
//    생성자생략 :
//    TODO: 함수 : 사물이나 사람의 동작을(행동) 나타냄

    /**
     * 전원 켜는 함수 : 리턴값 없이 만들기 : void 예약어 사용
     * 사용법 : 접근제어자 리턴자료형 함수명(매개변수1, ... 매개변수 n){};
     * 접근제어자 : public(공용 *), private(개인 *), default(생략), protected
     */

    void powerOn(){
        System.out.println("전원을 켭니다.");
    }

    void powerOff(){
        System.out.println("전원을 끕니다.");
    }

    /**
     * 더하기 함수 : 리턴값이 있는 함수
     */
    int plus(int x, int y){
        int result = x + y;
        return result;      // 결과 내보내기의 자료형이(정수:int)
    }

    /**
     * 나누기 함수
     */
    double divide(int x, int y){
        double result = (double) x / y;
        return result;
    }

}
package chap06.sec04.exam01;

/**
 * packageName : chap06.sec04.exam01
 * fileName : CalculatorApplication
 * author : GGG
 * date : 2023-09-20
 * description :    실행 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class CalculatorApplication {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
//        TODO: 1) 전원을 on
        calculator.powerOn();

//        TODO: 2) 덧셈계산
//              리턴값이 있는 함수를 사용하는 전용 패턴(형태)
        int result = calculator.plus(5,6);
        System.out.println(result);

//        TODO: 예제 3) 계산기에 나눗셈 기능을 추가하려고 합니다.
//                      나눗셈을 추가하고 결과를 실행하세요

        double result2 = calculator.divide(10, 4);
        System.out.println(result2);

//        TODO : 예제 4) 추가 기능을 요청해서 추가했습니다.
//                      계산기를 끄는 기능을 추가해주세요.
        calculator.powerOff();
    }
}

 

package chap06.sec04.exam02;

/**
 * packageName : chap06.sec04.exam02
 * fileName : Computer
 * author : GGG
 * date : 2023-09-20
 * description :   컴퓨터모델 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Computer {
//    TODO: 속성, 생성자함수, 함수(메소드)
//    속성생략
//    생성자함수 생략
//    TODO: 함수
//          배열을 함수의 매개변수로 사용하면 장점이 있음
//          실행시에 함수의 매개변수로 1개를 넣을지, 2개를 넣을지 정해지지 않았을 때

    int sum1(int[] value) {
        int sum = 0;
//        매개변수 배열의 개수까지 모두 더하는 로직
        for (int i = 0; i < value.length; i++) {
            sum += value[i];     // 누적합
        }
        return sum;
    }

//    TODO: 기능추가 : 매개변수의 모든 값을 곱하는 함수를 만들어보세요

    int multi(int[] value) {
        int mul = 1;
        for (int i = 0; i < value.length; i++) {
            mul *= value[i];
        }
        return mul;
    }

    //    TODO: 자바의 새로운 기능 : ... 연산자
//          ...value : 매개변수의 각각의 변수를 배열로 만들어 줌
    int sum2(int... value) {
        int sum = 0;
//        매개변수 배열의 개수까지 모두 더하는 로직
        for (int i = 0; i < value.length; i++) {
            sum += value[i];     // 누적합
        }
        return sum;
    }

}
package chap06.sec04.exam02;

import java.util.ArrayList;
import java.util.List;

/**
 * packageName : chap06.sec04.exam02
 * fileName : ComputerApplication
 * author : GGG
 * date : 2023-09-20
 * description : 실행 클래스(main)
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class ComputerApplication {
    public static void main(String[] args) {
        Computer computer = new Computer();

//       배열정의
        int[] value1 = {1, 2, 3};
        int result1 = computer.sum1(value1);
        System.out.println("result1 : "+ result1);


        int[] value2 = {1, 2, 3, 4, 5};
        int result2 = computer.sum1(value2);
        System.out.println("result2 : "+ result2);

//      TODO: 곱하기 함수 실행
        int[] value3 = {1,2,3};
        int result3 = computer.multi(value3);
        System.out.println("result3 : " + result3); // 6

//      TODO: 새로운 ...연산자 사용하기
        int result4 = computer.sum2(1, 2, 3);
        System.out.println(result4);

        int result5 = computer.sum2(1, 2, 3, 4, 5);
        System.out.println(result5);

    }

}
package chap06.sec04.exam03;

/**
 * packageName : chap06.sec04.exam03
 * fileName : Car
 * author : GGG
 * date : 2023-09-20
 * description : 자동차 모델 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Car {
    // gas 체크해서 차가 출발을 합니다.
    //    gas 있으면 "출발합니다" 출력하고,
    //    .run() 실행 // gas--; 감소시킴 반복문 종료
    //    다시 gas > 0 인지 확인해서 "gas를 주입할 필요가 없습니다"
    //     아니면 "gas"를 주입하세요"
    //    결과 :
    //      gas가 있습니다.
    //      출발합니다.
    //      달립니다.(gas잔량:5)
    //      달립니다.(gas잔량:4)
    //      달립니다.(gas잔량:3)
    //      달립니다.(gas잔량:2)
    //      달립니다.(gas잔량:1)
    //      멈춥니다.(gas잔량:0)
    //      gas가 없습니다.
    //      gas를 주입하세요.

    int gas;    // 연료

//    속성에 값을 넣지 않고, 1) 생성자를 이용해서 값을 넣거나
//                       2) setter 함수를 이용해서 값을 수정하거나
//    사용법 : void set속성명(int 속성명){ this.속성명 = 속성명; }
//    역할 : 속성에 값을 저장, 수정하는 함수
//    자동화 기능 : alt + insert

    public void setGas(int gas) {
        this.gas = gas;
    }

    /**
     * gas가 남았는지 확인하는 함수
     */
    boolean isLeftGas(){
        if(gas == 0){
            System.out.println("gas가 없습니다.");
            return false;
        } else{
            System.out.println("gas가 있습니다.");
            return true;
        }
    }

    /**
     * 자동차를 달리게 하는 함수 : gas 가 1씩 감소함
     * 계속 달리다가 gas == 0 순간 중단
     */
    void run(){
        while (true){
            if( gas > 0){
                System.out.println("달립니다. (gas잔량 :" + gas + ")");
                gas = gas - 1;
            } else {
                System.out.println("멈춥니다. (gas잔량 :" + gas + ")");
                return; // break 동일한 효과(강제중단)
            }
        }
    }
}
package chap06.sec04.exam03;


/**
 * packageName : chap06.sec04.exam03
 * fileName : CarApplication
 * author : GGG
 * date : 2023-09-20
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class CarApplication {
    public static void main(String[] args) {
//        객체 생성
        Car car = new Car();

//        TODO: 1) 기름 넣기 : 5
        car.setGas(5);

//        TODO: 2) 남아있는 기름 확인 : true, 없으면 false
        boolean gasState = car.isLeftGas();

//        TODO: 3) 자동차 출발
        if (gasState){
            System.out.println("출발합니다.");
            car.run();  // 출발
        }

//        TODO: 4) 기름 확인
        if(car.isLeftGas() == true){
            System.out.println("gas 넣을 필요가 없습니다.");
        } else {
            System.out.println("gas를 주입하세요");
        }
    }
}
package chap06.sec04.exam04;

/**
 * packageName : chap06.sec04.exam04
 * fileName : Calculator
 * author : GGG
 * date : 2023-09-20
 * description : 계산기 모델 클래스 (덧셈, 평균)
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Calculator {
    // TODO : 속성, 생성자함수, 함수(메소드)
    // 속성생략
    // 생성자 생략

    // TODO: 함수 : 덧셈, 평균, 계산실행
    // 사용법 : 접근제한자 리턴자료형 함수명(매개변수....){}

    /**
     * 덧셈 함수
     * @param x
     * @param y
     * @return
     */
    int plus(int x, int y){
        int result = x + y;
        return result;
    }

    /**
     * 평균 구하는 함수
     * @param x
     * @param y
     * @return
     */
    double avg(int x, int y){
//        TODO : 자신의 클래스 내에서는 자유롭게 함수를 사용할 수 있음
        int sum = plus(x, y);   // 합계
        double result = (double) sum / 2;
        return result;
    }

    /**
     * 자신의 계산결과를 출력하는 함수
     */
    void println(String message){
        System.out.println("계산 결과 : " + message);
    }

    /**
     * 평균과 계산결과를 출력하는 실행 함수
     */
    void execute(){
        // 1) 평균 함수
        double result = avg(7, 10);
        println(result + "");
    }



}
package chap06.sec04.exam04;

/**
 * packageName : chap06.sec04.exam04
 * fileName : CalculatorApplication
 * author : GGG
 * date : 2023-09-20
 * description : 실행클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class CalculatorApplication {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        calculator.execute();   // 실행함수
    }
}
package chap06.sec04.exam05;

/**
 * packageName : chap06.sec04.exam05
 * fileName : Car
 * author : GGG
 * date : 2023-09-20
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Car {
    //    TODO: 속성, 생성자함수, 함수(메소드)
    int speed;   // 자동차 속도

    /**
     * 현재 속성의 값을 구하는 함수 : getter 함수
     * 사용법: 리턴자료형 get속성명(){ return 속성명; }
     */
//    자동화 기능 : alt + insert => getter 선택
    public int getSpeed() {
        return speed;
    }

    /**
     * 키를 돌립니다. 출력 함수
     */
    void keyTurnOn() {
//        결과 출력 : sout
        System.out.println("키를 돌립니다.");
    }

    /**
     * 달립니다. 5개 출력 + 속도 함수
     */
    void run() {
//        반복문 5번 실행 : 10씩 증가
        for (int i = 10; i <=50 ; i=i+10) {
//            속성 = 10씩 증가
            speed = i;
            System.out.println("달립니다.(시속:" + speed + "km/h)");
        }
    }
}
package chap06.sec04.exam05;

/**
 * packageName : chap06.sec04.exam05
 * fileName : CarApplication
 * author : GGG
 * date : 2023-09-20
 * description : 실행 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class CarApplication {
    public static void main(String[] args) {
        Car car = new Car();
        car.keyTurnOn(); // 키를 돌립니다. 출력
        car.run(); // 5개의 달립니다.
        int speed = car.getSpeed(); // 현재 속도 값을 리턴
        System.out.println("현재속도:" + speed + "km/h");



    }
}
package chap06.sec04.exam06;

/**
 * packageName : chap06.sec04.exam06
 * fileName : Calculator
 * author : GGG
 * date : 2023-09-20
 * description : 계산기 모델
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Calculator {
//    TODO: 속성, 생성자함수, 함수
    //함수
    /**
     * 정사각형 넓이 구하는 함수 : areaRectangle(10)
     * 사용법: 접근제한자 리턴자료형
     */
    double areaRectangle(double width) {
        return width * width;
    }

    /**
     * 직사각형 넓이 구하는 함수 : areaRectangle(10, 20)
     */
    double areaRectangle(double width, double height) {
        return width * height;
    }

}
package chap06.sec04.exam06;

/**
 * packageName : chap06.sec04.exam06
 * fileName : CalculatorApplication
 * author : GGG
 * date : 2023-09-20
 * description : 실행 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class CalculatorApplication {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();

//        함수의 오버로딩을 이용한 예제
//        정사각형의 넓이 구하기(한변의 길이(가로) * 한변의 길이(가로))
        double result1 = calculator.areaRectangle(10);

//        직사각형 넓이 구하기(가로 * 세로)
        double result2 = calculator.areaRectangle(10, 20);

//        결과 출력
        System.out.println("정사각형 넓이 :" + result1);
        System.out.println("직사각형 넓이 :" + result2);
    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

객체의 동등비교  (1) 2023.09.25
자료구조  (0) 2023.09.25
생성자  (0) 2023.09.20
생성자 함수  (0) 2023.09.20
클래스  (0) 2023.09.20
반응형
package chap06.sec03.exam02;

/**
 * packageName : chap06.sec03.exam02
 * fileName : Korean
 * author : GGG
 * date : 2023-09-20
 * description : 한국인 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Korean {
//    TODO: 속성, 생성자함수, 메소드
//    속성
    String name;        //  이름
    String ssn;         //  주민번호
//    생성자 함수
    Korean(){};

    Korean(String strName, String strSsn){
        name = strName;
        ssn = strSsn;
    };
}
package chap06.sec03.exam02;

/**
 * packageName : chap06.sec03.exam02
 * fileName : KoreanApplication
 * author : GGG
 * date : 2023-09-20
 * description : 실행 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class KoreanApplication {
    /**
     * 한국인 객체를 생성하고 매개변수 2개짜리 생성자를 이용해서 속성을 초기화하세요.
     * 초기화 한 결과를 출력하세요.
     * //        결과 :
     * //            k1.name : 박자바 (문자열)
     * //            k1.ssn : 011225-1234567 (문자열)
     * //            k2.name : 김자바
     * //            k2.ssn : 930525-0654321
     */
    public static void main(String[] args) {

        Korean k1 = new Korean("박자바", "011225-1234567");
        Korean k2 = new Korean("김자바", "930525-0654321");

        System.out.println("k1.name " + k1.name);
        System.out.println("k1.ssn " + k1.ssn);
        System.out.println("k2.name " + k2.name);
        System.out.println("k2.ssn " + k2.ssn);

    }
}

생성자 오버로딩

package chap06.sec03.exam03;

/**
 * packageName : chap06.sec03.exam03
 * fileName : Car
 * author : GGG
 * date : 2023-09-20
 * description :    생성자 오버로딩
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Car {
//    TODO: 객체의 3요소 = 속성, 생성자, 함수
//    속성
    String company = "현대자동차";     // 제조사
    String model;                    // 자동차 모델(SUV, 세단)
    String color;                    // 자동차 색깔
    int maxSpeed;                    // 최고속도

//    기본 생성자
    public Car(){};

//    매개변수 1개짜리 생성자
    public Car(String model){
//        TODO: this? : 객체 자기 자신을 의미하는 객체변수
//             객체의 사용 : 객체변수.속성명
        this.model = model;
    }

//    매개변수 2개짜리 생성자
    public Car(String model, String color ){
        this.model = model;
        this.color = color;
    }

//    매개변수 3개짜리 생성자
//    자동화 기능이용 : alt + insert => 생성자 속성 선택 후 확인
    public Car(String model, String color, int maxSpeed) {
        this.model = model;
        this.color = color;
        this.maxSpeed = maxSpeed;
    }
}
package chap06.sec03.exam03;

/**
 * packageName : chap06.sec03.exam03
 * fileName : CarApplication
 * author : GGG
 * date : 2023-09-20
 * description :    실행 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class CarApplication {
    public static void main(String[] args) {
//        객체 생성 : 모든 생성자 이용하기
        Car car1 = new Car();       // 기본 생성자
        Car car2 = new Car("자가용");      // 매개변수 1개
        Car car3 = new Car("자가용", "빨강");        // 매개변수 2개
        Car car4 = new Car("자가용","빨강",200);     // 매개변수 3개

//        결과출력
        System.out.println(car1.color);
        System.out.println(car1.company);
        System.out.println(car1.maxSpeed);
        System.out.println(car1.model);
        System.out.println("--------------------------------");
        System.out.println(car4.color);
        System.out.println(car4.company);
        System.out.println(car4.maxSpeed);
        System.out.println(car4.model);
    }
}

연습문제

/**
* Member 객체를 생성하고 싶습니다. 생성자에서 name 속성과 id 속성을
* 초기화 할 수 있도록 Member 클래스를 작성해 보세요.
*/
package chap06.sec03.verify.exam02;

/**
 * packageName : chap06.sec03.verify.exam02
 * fileName : Member
 * author : GGG
 * date : 2023-09-20
 * description : 회원 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Member {

    String name;
    String id;

    public Member(String name, String id) {
        this.name = name;
        this.id = id;
    }
}
package chap06.sec03.verify.exam02;

/**
 * packageName : chap06.sec03.verify.exam02
 * fileName : MemberApplication
 * author : GGG
 * date : 2023-09-20
 * description : 실행 클래스(main)
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class MemberApplication {
    /**
     * Member 객체를 생성하고 싶습니다. 생성자에서 name 속성과 id 속성을
     *        초기화 할 수 있도록 Member 클래스를 작성해 보세요.
     * @param args
     */
    public static void main(String[] args) {
        Member member = new Member("홍길동", "hong");

        System.out.println("name :" + member.name);
        System.out.println("id :" + member.id);
    }
}
아래 메인 함수을 참고하여 오류를 수정할 클래스를 생성해보세요
package chap06.sec03.verify.exam03;

/**
 * packageName : chap06.sec03.verify.exam03
 * fileName : BoardApplication
 * author : GGG
 * date : 2023-09-20
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class BoardApplication {
    public static void main(String[] args) {
        Board board = new Board("제목");
        Board board2 = new Board("제목", "내용");
        Board board3 = new Board("제목", "내용", "작가");

        System.out.println("title :" + board.title);

        System.out.println("title2 :" + board2.title);
        System.out.println("content2 :" + board2.content);

        System.out.println("title3 :" + board3.title);
        System.out.println("content3 :" + board3.content);
        System.out.println("content3 :" + board3.writer);
    }
}
package chap06.sec03.verify.exam03;

/**
 * packageName : chap06.sec03.verify.exam03
 * fileName : Board
 * author : GGG
 * date : 2023-09-20
 * description : 모델 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Board {

    String title;
    String content;
    String writer;

    public Board(String title) {
        this.title = title;
    }

    public Board(String title, String content) {
        this.title = title;
        this.content = content;
    }

    public Board(String title, String content, String writer) {
        this.title = title;
        this.content = content;
        this.writer = writer;
    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

자료구조  (0) 2023.09.25
MVC 디자인 패턴  (0) 2023.09.22
생성자 함수  (0) 2023.09.20
클래스  (0) 2023.09.20
[JAVA 다시보기] 자바기초  (1) 2023.09.19
반응형

기본생성자

클래스 선언(정의)시 컴파일러에 의해 자동으로 추가되는 생성자
// 기본 생성자 : 만들지 않아도 컴파일러가 자동으로 1개 생성함(생략가능)
// 1) 생성자함수 이름은 클래스명과 같음
// 2) 생성자함수는 여러개를 만들수 있음 : 생성자 오버로딩(Overloading)
// 사용법 : 클래스명(){};
package chap06.sec03.exam01;

/**
 * packageName : chap06.sec03.exam01
 * fileName : Car
 * author : GGG
 * date : 2023-09-20
 * description :    생성자 함수
 * 요약 :
 *           자바소스(.java) -> 컴파일러(컴파일) => (.class) -> 실행
 *          기본 생성자 : 생성자가 한개도 없을 경우 클래스 선언(정의)시 컴파일러에 의해 자동으로 추가되는 생성자
 *          (만약에 있을 경우(2nd 생성자 등) 자동 추가되지 않음)
 *          오버로딩 : 함수의 이름이 같은 경우라도 에러를 발생시키지 않고 정의하게 하는 기능
 *               (주로 함수의 이름이 같고, 매개변수 자료형, 개수, 순서가 다른 경우에 오버로딩이 됨)
 *
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Car {
//    TODO: 클래스의 3요소 = 속성(필드), 생성자함수, 함수(메소드)
    String col;         // 자동차 색깔
    int ccNum;          // 자동차 배기량
//    TODO: 생성자 함수
//    기본 생성자 : 만들지 않아도 컴파일러가 자동으로 1개 생성함(생략가능)
//    1) 생성자함수 이름은 클래스명과 같음
//    2) 생성자함수는 여러개를 만들수 있음 : 생성자 오버로딩(Overloading)
//    사용법 : 클래스명(){};
    Car(){};

//    TODO: 2nd 생성자 함수 : 개발자가 정의하기 나름(매개변수 있고 자유롭게 정의할 수 있음)
//        **) 생성자 오버로딩 : 같은 이름을 가진 함수를 여러 개 정의할 수 있게 하는 기능(객체지향 언어만 가능)
    Car(String color, int cc){
//        TODO: 생성자 함수의 역할 : 속성의 초기화(변수에 값을 처음 넣어두는 행위)를 담당
      col = color;
      ccNum = cc;
    };
}

생성자 오버로딩

같은 이름을 가진 함수를 여러 개 정의할 수 있게 하는 기능(객체지향 언어만 가능)
package chap06.sec03.exam01;

/**
 * packageName : chap06.sec03.exam01
 * fileName : CarApplication
 * author : GGG
 * date : 2023-09-20
 * description :
 * 요약 :
 *
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class CarApplication {
    public static void main(String[] args) {
//        객체 생성
//        사용법 : 클래스명 객체변수명 = new 생성자함수();
        Car car = new Car();                           // 기본 생성자 함수
//        2nd 생성자 함수 : Car(String color, int cc)
        Car car1 = new Car("검정", 3000);       // 오버로딩된 생성자 함수
        Car car2 = new Car("흰색", 2000);       // 오버로딩된 생성자 함수

//        결과출력 : 1st car1
        System.out.println(car1.ccNum);
        System.out.println(car1.col);
//        결과출력 : 2nd car2
        System.out.println(car2.ccNum);
        System.out.println(car2.col);
    }
}
반응형

'Java > Java 이론' 카테고리의 다른 글

MVC 디자인 패턴  (0) 2023.09.22
생성자  (0) 2023.09.20
클래스  (0) 2023.09.20
[JAVA 다시보기] 자바기초  (1) 2023.09.19
문자열 자료형  (1) 2023.09.08
반응형

클래스


* 클래스 : 객체의 구조를 정의하는 곳 (속성(필드, 멤버변수), 생성자, 함수(메서드))
* 객체(인스턴스) : 클래스로부터 생성되며 new 생성자함수() 이용해서 생성함
* new 연산자 : 객체 생성 연산자이며, 생성자함수를 호출하고, 힙 메모리 영역에 객체를 저장함
* 사용법 : 클래스 객체변수 = new 생성자함수();* 객체변수 : 힙 메모리 주소(방번호)가 저장됨
package chap06.sec02.exam01;

/**
 * packageName : chap06.sec02.exam01
 * fileName : Car
 * author : GGG
 * date : 2023-09-19
 * description :  자동차 클래스
 * 요약 :
 *      클래스         : 객체의 구조를 정의하는 곳 (속성(필드, 멤버변수), 생성자, 함수(메서드))
 *      객체(인스턴스)  : 클래스로부터 생성되며 new 생성자함수() 이용해서 생성함
 *      new 연산자     : 객체 생성 연산자이며, 생성자함수를 호출하고, 힙 메모리 영역에 객체를 저장함
 *      사용법         : 클래스 객체변수 = new 생성자함수();
 *      객체변수       : 힙 메모리 주소(방번호)가 저장됨
 *
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Car {
//    클래스의 3요소 : 속성, 생성자함수, 함수(메서드)
//    TODO: 속성(필드, 멤버변수)
    String compnay = "현대자동차";
    String model = "그랜저";
    String color = "검정";
    int maxSpeed = 350;
    int speed;      // 기본 초기화(0)
}
package chap06.sec02.exam01;

/**
 * packageName : chap06.sec02.exam01
 * fileName : CarApplication
 * author : GGG
 * date : 2023-09-19
 * description : 실행 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class CarApplication {
    public static void main(String[] args) {

//        객체 생성 : 클래스명 객체변수명 = new 생성자함수();
//        생성자 함수명 == 클래스명
        Car car = new Car();
//        TODO: 클래스의 속성 출력하기
//              사용법 : 객체변수명.속성명

        System.out.println("제작회사 : "+ car.compnay);
        System.out.println("모델명 : "+ car.model);
        System.out.println("색상 : "+ car.color);
        System.out.println("최고속도 : "+ car.maxSpeed);
        System.out.println("현재속도 : "+ car.speed);       // 기본값 출력


//        car 클래스 속성값 수정 수정
//        현재속도를 수정해보기 (car.speed)
        car.speed = 60;
//        결과출력
        System.out.println("수정된 현재속도 : "+ car.speed);

    }


}

자동 속성 초기화

속성을 선언만 하고 출력할 때 기본값이 무엇인지 알아봅시다.
package chap06.sec02.exam02;

/**
 * packageName : chap06.sec02.exam02
 * fileName : FieldInit
 * author : GGG
 * date : 2023-09-20
 * description :    자동 속성 초기화
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class FieldInit {
//    TODO: 클래스의 3요소 = 속성(필드), 생성자함수, 함수(메서드)
//    정수 : byte, short, int, long
    byte bField;
    short sField;
    int iField;
    long lField;

//    실수 : float, double
    float fField;
    double dField;

//    char / boolean
    char cField;
    boolean boField;

//    String / int[]
    String strField;
    int[] arrField;




}
package chap06.sec02.exam02;

/**
 * packageName : chap06.sec02.exam02
 * fileName : FiledApplication
 * author : GGG
 * date : 2023-09-20
 * description :
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class FiledApplication {
    public static void main(String[] args) {
//        TODO: 클래스명 명명법 :  첫글자 대문자 나머지 소문자, 단어사이는 대문자(파스칼표기법)
        FieldInit fieldInit = new FieldInit();

//        정수
        System.out.println("byte : " + fieldInit.bField);
        System.out.println("short : " + fieldInit.sField);
        System.out.println("int : " + fieldInit.iField);
        System.out.println("long : " + fieldInit.lField);
//        실수
        System.out.println("float : " + fieldInit.fField);
        System.out.println("double : " + fieldInit.dField);
//        char / boolean
        System.out.println("char : " + fieldInit.cField);
        System.out.println("boolean : " + fieldInit.boField);
//        String / int[]
        System.out.println("String : " + fieldInit.strField);
        System.out.println("int[] : " + fieldInit.arrField);


    }
}

[ 출력 결과 ]

 

연습문제

/**
* Member 객체를 생성하고 속성에 아래의 값으로 저장한 후 속성의 값을 출력하세요
* 결과 :
* 이름 : 최하얀
* id : 23
*/
package chap06.sec02.verify;

/**
 * packageName : chap06.sec02.verify
 * fileName : Member
 * author : GGG
 * date : 2023-09-20
 * description :    회원 정보 클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class Member {
    String name;        // 회원명
    String id;          // 회원 아이디
    String password;    // 회원 패스워드
    int age;            // 나이


}
package chap06.sec02.verify;

/**
 * packageName : chap06.sec02.verify
 * fileName : MemberApplication
 * author : GGG
 * date : 2023-09-20
 * description :    실행클래스
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-20         GGG          최초 생성
 */
public class MemberApplication {
    public static void main(String[] args) {
        /**
         * Member 객체를 생성하고 속성에 아래의 값으로 저장한 후 속성의 값을 출력하세요
         * 결과 :
         *      이름 : 최하얀
         *      id  : 23
         */
        Member member = new Member();
        member.name = "최하얀";
        member.id = "23";
        System.out.println("이름 : " + member.name);
        System.out.println("id : " + member.id);

    }
}

반응형

'Java > Java 이론' 카테고리의 다른 글

생성자  (0) 2023.09.20
생성자 함수  (0) 2023.09.20
[JAVA 다시보기] 자바기초  (1) 2023.09.19
문자열 자료형  (1) 2023.09.08
[JAVA] 참조변수의 형변환  (0) 2023.08.11
반응형

프로젝트 계획


프로젝트 관리

프로젝트 핵심 관리대상(3P)

  • 사람(People)
  • 문제(Problem)
  • 프로세스(Process)

PMBOK(Project Management Body of Knowledge)

  • PMI(Project Management Institute)에서 제작한 프로젝트 관리 프로세스 및 지식 체계

🔶 PMBOK 5단계 프로세스 그룹

  1. 1단계 : 프로젝트 착수
  2. 2단계 : 프로젝트 계획
  3. 3단계 : 프로젝트 실행
  4. 4단계 : 프로젝트 통제
  5. 5단계 : 프로젝트 종료

 

개발 비용 산정

하향식 산정 기법(전문가 기법/델파이 기법)

1) 전문가 기법

  • 조직 내 경험이 있는 전문가에게 비용 산정을 의뢰하여 산정하는 기법

2) 델파이 기법

  • 여러 전문가의 의견을 종합하여 판단하는 방법

 

상향식 산정 기법(LOC 기법 / 단계별 인원수 기법)

1) LOC(원시코드 라인 수) 기법

  • 각 기능의 원시 코드 라인 수의 비관치(가장 많은 라인수), 낙관치(가장 적은 라인수), 중간치(기대치, 평균 라인수)를 측정 후 예측치를 구하고, 이를 이용해 비용을 산정하는 방법

2) 단계별 인원수(M/M) 기법

  • SW 개발 생명주기 각 단계별로 적용시켜 모든 단계의 비용을 산정하는 기법

 

수학적 산정 기법

1) COCOMO 기법

  • 개발할 SW의 규모를 예측한 후 SW 종류에 따라 각 비용 산정 공식에 대입하여 비용을 산정하는 방법
  • 개발 유형
개발유형 설명
조직형(Organic Mode) 5만 라인 이하의 프로젝트
반분리형(Semidetached Mode) 30만 라인 이하의 프로젝트
내장형(Embedded Mode) 30만 라인 이상의 프로젝트

2) Putnam 기법

  • 시간에 따른 함수로 표현되는 Rayleigh-Norden 곡선의 노력 분포도를 기초로 한다
  • SLIM :  Rayleigh-Norden 곡선과 Putnam 예측 모형을 기초로 개발한 자동화 추정도구

3) 기능 점수 기법(FP, Function Point)

  • S/W가 가지는 기능의 개수를 기준으로, S/W의 규모를 측정하는 기법
  • ESTIMACS : FP모형을 기초로 개발된 자동화 추정도

출처 : IT위키

  • 비용 산정에 이용되는 요소

- 자료 입력(입력 양식)

- 정보 출력(출력 보고서)

- 명령어(사용자 질의수)

- 데이터 파일

- 필요한 외부 루틴과의 인터페이스

 

개발 일정 산정

작업순서

  1. 작업분해(Work Breakdown Structure)
  2. PERT/CPM 작성
  3. 임계경로 구함
  4. 간트 차트로 표현

WBS(Work Breakdown Structure)

  • 프로젝트 목표를 달성하기 위해 필요한 활동과 업무를 세분화하는 작업

PERT/CPM

  • 작업의 선/후행 관계를 고려, 전체작업의 완료시간을 결정(PERT), 추가비용 투입을 고려하여 전체작업 완료시간을 단축하는(CPM) 네트워크 분석 기법
  • 임계경로(Critical Path) : 프로젝트를 끝내기 위해 필요한 최소 소요시간

출처 : IT위키

간트차트(Gantt chart)

  • 일정 계획의 최종산출물
  • 프로젝트 일정관리를 위한 바(Bar) 형태의 도구

출처 : IT위키

 

요구사항 분석


현행 시스템 분석

플랫폼 기능분석 - 플랫폼의 유형

유형 설명
싱글 사이드 플랫폼
(Single-Side Platform)
제휴 관계를 통해 소비자와 공급자를 연결하는 형태
투 사이드 플랫폼
(Two-Side Platform)
두 그룹을 중개하고 모두에게 개방하는 형태
멀티 사이드 플랫폼
(Mulit-Side Platform)
다양한 이해관계 그룹을 연결하여 중개하는 형태

 

CPND(Contents Platform Network Device)

  • 콘텐츠를 플랫폼에 맞게 가공하고 네트워크를 통해 사용자의 단말기로 서비스가 이루어짐을 표현하는 무선 인터넷 서비스의 가치사슬

 

미들웨어 분석 - 개념

  • 양 쪽을 연결하여 데이터를 주고받을 수 있도록 중간에서 매개 역할을 하는 S/W

종류

1) 원격 프로시저 호출(RPC, Remote Procedure Call)

  • 클라이언트가 원격에서 동작하는 프로시저를 호출하는 시스템

2) 메시지 지향 미들웨어(MOM, Message Oriented Middleware)

  • 응용 S/W 간의 데이터 통신을 위한 S/W
  • 메시지 기반의 비동기형 메시지를 전달하는 방식의 미들웨어

3) ORB(Object Request Broker)

  • 객체지향 시스템에서 객체 및 서비스를 요청하고 전송할 수 있도록 지원하는 미들웨어

4) DB 접속 미들웨어

  • 애플리케이션 - DB서버를 연결해주는 미들웨어

5) TP모니터

  • 트랜잭션이 올바르개 처리되고 있는지 데이터를 감시하고 제어

6) 웹 애플리케이션 서버(WAS, Web Application Server)

  • 동적인 콘텐츠를 처리하기 위한 미들웨어

7) 엔터프라이즈 서비스 버스(ESB, Enterprise Service Bus)

  • 메시지 기반으로 느슨한 결합 형태의 표준 인터페이스 통신을 지원하는 미들웨어

 

요구공학

1) 요구공학 내용의 종류

(1) 기능적 요구사항

  • S/W를 구성하는 기능들이 무엇인지 정의한 것

(2) 비기능적 요구사항

  • 보안, 성능, 품질, 안정성 등 S/W 기능들에 대한 조건과 제약사항들이 무엇인지 정의한 것

(3) 요구사항 개발 프로세스(도출 - 분석 - 명세 - 확인)

 

1) 도출(Elicitation)

  • S/W가 해결해야 할 문제를 이해하고 요구사항이 어디에 있고, 어떻게 수집할 것인가를 확인

2) 분석(Analysis)

  • 요구사항들 간에 상충되는 문제를 해결

3) 명세(Specification)

1) 정형 명세 기법

- 수학, 논리학

2) 비정형 명세 기법

- 자연어, 그림 중심

 

4) 확인(Validation)

  • 이해 관계자들이 문서를 검토하고, 형상관리를 수행

 

(5) 요구사항 분석도구 - 분류

1. 상위 CASE

  • 생명주기 전반부에 사용, S/W의 계획과 요구분석, 설계단계를 지원

2. 하위 CASE

  • 생명주기 후반부에 사용, 코드의 작성과 테스트, 문서화하는 과정을 지원

3. 통합 CASE

  • S/W 생명주기에 포함되는 전체 과정을 지원

(5-1) HIPO(Hierarchy Input Process Output)

  • 하향식 S/W 개발을 위한 문서화 도구

🔶 종류

종류 설명
가시적 도표
(Visual Table of Content)
시스템의 전체 기능과 흐름을 보여주는 트리 구조
입력, 처리, 출력이 없음
총체적 도표
(Overview Diagram)
프로그램을 구성하는 기능을 기술한 것
입력, 처리, 출력에 대한 전반적인 정보 제공
세부적 도표
(Detail Diagram)
총체적 도표에 표시된 기능을 구성하는 기본 요소들을 상세히 기술하는 도표

 

반응형

+ Recent posts