반응형
// 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
반응형


HelloWorld 출력함수

public class Sec0101 {
    /**
     * Hello World 출력함수
     */
    public void exam01(){
        // 출력단축키 sout
        System.out.println("Hello World");
    }

    public void exam02(){
//        예제 1) x, y 정수 변수를 만들어서 덧셈결과를 화면에 출력하세요
        int x = 1;
        int y = 2;
        int result = x + y;
        System.out.println(result);
    }
}

변수

package chap02;

/**
 * packageName : chap02
 * fileName : Sec0201
 * author : GGG
 * date : 2023-09-18
 * description :
 * 요약 :
 *          변수          : 값을 저장할 수 있는 메모리 공간
 *          변수 사용 범위 : {} 안에서만 사용가능
 *                         만약에 {} 안에 {}가 있다면 변수는 안에 {} 도 사용가능함
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0201 {
    public void exam01(){
//        변수 선언
        int value = 20;

//        변수 연산
//        예제 2) 변수 value에 값을 10 더하는 연산을 한 후 화면에 출력하세요
        int result = value + 10;

        System.out.println(result);
    }

    public void exam02(){
//        예제 3) x=3, y=5가 있습니다.
//        x와 y 값을 바꾸어서 출력하세요
//        swap 코딩
        int x = 3;
        int y = 5;
//        swap 코딩
        int temp = x; // x의 값을 임시변수에 넣어둠
        x = y;        // x의 값이 overwrite 됨
        y = temp;     // 임시변수 값을 y에 넣음
//        출력
        System.out.println("x = " + x +" , y = " + y);
    }

    /**
     * 변수의 허용범위 예제
     */
    public void exam04(){
        int v1 = 15;
        if(v1 > 10){
            int v2;
            v2 = v1 - 10;
        }
//        int v3 = v1 + v2 + 5; // v2는 변수 사용불가라서 에러 발생
    }
}

기본자료형

package chap02;

/**
 * packageName : chap02
 * fileName : Sec0202
 * author : GGG
 * date : 2023-09-18
 * description : 기본 자료형(Type)
 * 요약 :
 *         정수 : byte(1), short(2), int(4, ***), long(8, **)
 *         char : 2byte 자료형, 문자 1개를 의미, 홑따옴표('')표시
 *         (저장시 유니코드(숫자)로 저장되고 출력시는 문자로 출력됨)
 *         String(***) : 쌍따옴표("")로 감싼 문자열을 의미
 *         실수 : float(4), double(8, ***)
 *         boolean : 참/거짓 자료형, true/false
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0202 {
    public void exam01(){
//        1bit : 최소 단위, 8bit = 1byte, 1024byte = 1KB
//        1024KB = 1MB, 1024MB = 1GB, 1024GB = 1TB, 1024TB = 1HB
//        2진수 표현 : 0b 를 붙이면 2진수(0, 1로 표현하는 수)
        int var1 = 0b1011; // 2진수(0b 붙이면 2진수)
        int var2 = 0206;   // 8진수(0 붙이면 8진수)
        int var3 = 365;    // 10진수
        int var4 = 0xB3;   // 16진수 (0x를 붙이면 16진수)

        System.out.println("var1 : " + var1);
        System.out.println("var2 : " + var2);
        System.out.println("var3 : " + var3);
        System.out.println("var4 : " + var4);

    }


    public void exam03(){
        long var1 = 10;     // 정수 8byte
        long var2 = 20L;    // L 붙이면 long 자료형

        System.out.println(var1);
        System.out.println(var2);
    }

    public void exam04(){
//        아스키코드
        char c1 = 'A';      // 문자를 직접 저장
        char c2 = 65;       // 십진수로 저장 => 'A'

        System.out.println(c1);
        System.out.println(c2);
    }

    public void exam05(){
        String name = "홍길동";
        String job = "프로그래머";

        System.out.println(name);
        System.out.println(job);

    }

    /**
     * 특수기호 : /n, /t, ", \(이스케이프문자)
     */
    public void exam06(){
        System.out.println("번호\t이름\t직업");                   // 탭 문자
        System.out.print("행 단위 출력\n");                       // 줄바꿈 문자
        System.out.println("우리는 \"개발자\" 입니다.");            // \" 사용
        System.out.println("봄\\여름\\가을\\겨울");                // \\ 사용
    }

    /**
     * 실수 : float(4), double(8, ***)
     */
     
    public void exam07(){
        float var2 = 3.14f;         // float 사용시 끝에 f 붙임
        double var3 = 3.14;         // double

        System.out.println(var2);
        System.out.println(var3);

//        e : 지수 표현식

        double var6 = 3e6;          // 3000000.0
        double var7 = 2e-3;         // 0.002

        System.out.println(var6);
        System.out.println(var7);
    }
}

형변환

package chap02;

/**
 * packageName : chap02
 * fileName : Sec0203
 * author : GGG
 * date : 2023-09-18
 * description : 자료형 변환
 * 요약 :
 *          자동 타입 변환 : 자동으로 자료형이 변환되는 것 : 작은(byte) 자료형 -> 큰 자료형
 *          강제 타입 변환 : 강제로 자료형 변환 : 사용법 : (자료형)변수명, 큰 자료형 -> 작은 자료형
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */

/**
 * 자동 형변환 예제
 */
public class Sec0203 {

    public void exam01(){
        byte byteValue = 10;    // 1byte 정수형
//        자동 자료형 변환
        int intValue = byteValue;
        System.out.println("intValue : " + intValue);

//        실수 자동 형변환
        float floatValue = 100.5F;
        double doubleValue = floatValue;
        System.out.println("doubleValue : " + doubleValue);
    }

    /**
     * 강제 형변환 예제
     * 참고) 아스키코드 변환 : char 변수 <- int 값 : 아스키코드 -> 문자로 변환
     *                      int 변수 <- char 값 : 아스키코드 변환 <- 문자
     */
    public void exam02(){
        int intValue = 44032;                // 4byte
//        char charValue = intValue;         // int 4byte, char 2byte 이므로 오류발생 강제형변환 필요
        char charValue = (char)intValue;     // 강제 형변환

//        TODO : char 자료형에 아스키 코드(숫자) 변환 : 아스키코드(숫자) -> 문자로 변환
        char alpha = 65;    // A
//        TODO : 정수형 자료형에 문자 -> 아스키코드로 변환
        int beta = 'A';     // 65


        System.out.println("charValue : " + charValue);

//        double(8) -> int(4) 강제 형변환
        double doubleValue = 3.14;
//        int intValue2 = doubleValue;      // 오류발생
        int intValue2 = (int)doubleValue;

        System.out.println("intValue : " + intValue2);
    }

    /**
     * 문자열 + 숫자 = 문자열
     */
    public void exam06(){
//        결합 연산
        String str1 = 10 + 2 + "8";     // 128
        System.out.println(str1);

        String str2 = 10 + "2" + 8;     // 1028
        System.out.println(str2);

        String str3 = "10" + (2 + 8);   // 1010
        System.out.println(str3);
    }

    /**
     *  문자열 -> int 자료형 변경 : Integer.parseInt("값");
     *  int -> 문자열 변경 :
     */
    public void exam07(){
        // 문자열 -> int 자료형으로 변경
        int value1 = Integer.parseInt("10");            // 문자열 -> 정수
        double value2 = Double.parseDouble("3.14");     // 문자열 -> 실수
        boolean value3 = Boolean.parseBoolean("true");  // 문자열 -> 참/거짓

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

        // int -> 문자열 자료형으로 변경
        String str1 = String.valueOf(10);           // 정수 -> 문자열로 변경 (속도 빠름)
        String str2 = "" + 10;                         // 빈문자열 + 정수 = 문자열
        String str3 = String.valueOf(3.14);         // 실수 -> 문자열
        String str4 = String.valueOf(true);         // 참/거짓 -> 문자열

        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
        System.out.println(str4);
    }
}

입출력함수 및 문자열 비교함수

package chap02;

import java.util.Scanner;

/**
 * packageName : chap02
 * fileName : Sec0204
 * author : GGG
 * date : 2023-09-18
 * description :
 * 요약 :
 *          System.out.println() : 화면에 출력하고 줄바꿈 함수
 *          System.out.print() : 화면에 출력하는 함수
 *          System.out.printf("%d %s %f", 정수변수, 문자열변수, 실수변수)
 *          Scanner : 콘솔 입력을 받기 위한 클래스(객체 정의)
 *                    한라인 입력 받기 함수      : .nextLine();
 *                    공백까지 입력 받기 함수    : .next();
 *                    참고) nextInt(), nextDouble() 등...
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0204 {

    public void exam05(){
//        입력받기 : System.in (키보드 입력)
        Scanner scanner = new Scanner(System.in);
        String inputData;   // 입력 문자열
        while(true){
            inputData = scanner.nextLine();     // 1 라인 입력받기
            System.out.println("입력된 문자열 :" + inputData);
//            TODO: 코드를 완성하세요 (입력된 문자열이 q가 들어오면 반복문 종료하게)
//            TODO: 자바에서 문자열 비교 equal 함수 사용
//                  문자열.equals("문자열2") : 같으면 true, 아니면 false
            if (inputData.equals("q")) {
                break;
            }
        }
        System.out.println("종료");

    }

}

연산자

package chap03;

import java.util.Scanner;

/**
 * packageName : chap03
 * fileName : Sec0301
 * author : GGG
 * date : 2023-09-18
 * description :
 * 요약 :
 *          산술 : +, -, *, /, %(나머지 연산자)
 *          부호 : +, -
 *          문자열 붙이기 : +
 *          대입연산자 : =, +=, -=, *=, /=, %=
 *          증감 : ++, --
 *          비교 : ==, !=, >, <, >=, <=,(1문자 비교, 숫자비교) instanaceof
 *          TODO : 문자열 비교 : 문자열.equals(문자열2)
 *          논리 : !, &, |,(비트연산자) &&(논리곱), ||(논리합)
 *          삼항 : (조건식)? A : B
 *          우선순위 필요하면 () 쓸 것
 *
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-18         GGG          최초 생성
 */
public class Sec0301 {
    public void exam01(){
        int x = -100;
        int result1 = +x;
        int result2 = -x;
        System.out.println("result1 : " + result1);
        System.out.println("result2 : " + result2);

    }

    public void exam03(){
        boolean play = true;
        System.out.println(play);
        play = !play;  // false
        System.out.println(play);
    }

    /**
     * 사칙연산 예제 : /(나눗셈) 조심
     */
    public void exam04(){
        int v1 = 5;
        int v2 = 2;

        int result = v1 + v2;
        System.out.println(result);
        System.out.println("---------------------------------");
        int result2 = v1 / v2;
        System.out.println(result2);    // 정수/정수 => 실수부분이 잘림
        System.out.println("---------------------------------");
        // TODO : 나눗셈 개선 코딩 : 강제 형변환 후 계산해야함
        double result3 = (double)v1 / (double)v2;
//        double result3 = (double)v1 / v2;     // 같은 결과
        System.out.println(result3);
    }

//    연습문제 : 정수 1개를 입력받아 그대로 출력하기
//    입력 : 5
    public void exam05(){
        Scanner sc = new Scanner(System.in);
        System.out.println(sc.next());
    }

//    연습문제2 : 문자 2개 입력받아 순서 바꿔 출력하기
    public void exam06(){
        Scanner sc = new Scanner(System.in);
        String strFirst = sc.next(); // 공백까지 입력받기
        String strSecond = sc.next(); // 공백까지 입력받기
        System.out.println(strSecond + " " + strFirst);
    }


    /**
     * char : 내부적으로 정수로 저장됨(유니코드 : 아스키코드 확장판(한글, 중국어 등을 표시))
     */
    public void exam07(){

        char c1 = 'A' + 1; // char(정수) : 'B' ('A' 아스키코드(65) 65 + 1 = 66)
        char c2 = 'A';
        System.out.println(c1);
        System.out.println(c2);
    }


    // 연습문제3 : char 이용하는 문제
    // 값이 'A' 로 주어져 있습니다. 'A' 대문자 이면 대문자이군요 라고 출력하고, 소문자이면 소문자이군요라고 출력, 숫자이면 숫자이군요 라고 출력

    public void exam08(){
        int charCode = 'A';
        if(charCode >= 65 && charCode <= 90) {
            System.out.println("대문자이군요");
        } else if (charCode >= 97 && charCode <= 122) {
            System.out.println("소문자이군요");

        } else if(charCode>=48 && charCode<=57) {
            System.out.println("숫자이군요");
        } else {
            System.out.println("다른 문자이군요");
        }
    }

    /**
     * 연습문제 : 정수 1개가 주어진다. 2와 3의 배수이면 2 또는 3의 배수이군요
     *          아니면, 2 또는 3의 배수가 아니군요
     */
    public void exam10(){
        int value = 6;

        if((value % 2 == 0) || (value % 3 == 0)){
            System.out.println("2 또는 3의 배수이군요");
        } else {
            System.out.println("2 또는 3의 배수가 아니군요");
        }
    }

}

if문과 switch문

package chap04;

/**
 * packageName : chap04
 * fileName : Sec0401
 * author : GGG
 * date : 2023-09-19
 * description : 조건문
 * 요약 :
 *          if문 - if(조건문1){실행문1} else if(조건문2){실행문2} else{실행문3};
 *          => 조건문1 true 실행문1 실행되고 조건문2 true 실행문2 실행되고 모두 아니면 실행문3 실행
 *          switch문 - switch(변수) { case 값1: 실행문1;break; case 값2: 실행문2;break;
 *                                     default: 실행문3;break;
 *          }
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0401 {
    /**
     * 예제 1 : 초기값이 90이상이면 점수가 90보다 큽니다.
     *                          등급은 A입니다. 출력
     *                90이하이면 점수가 90보다 작습니다.
     *                         등급은 B입니다. 출력
     */
    public void exam01(){
        int score = 93;     // 초기값
        if(score >= 90){
            System.out.println("점수가 90보다 큽니다.");
            System.out.println("등급은 A입니다.");
        } else {
            System.out.println("점수가 90보다 작습니다.");
            System.out.println("등급은 B입니다.");
        }
    }

    /**
     * 자바 랜덤 함수 소개하는 예제
     * 랜덤 함수 : Math.random() : 0 ~ 1 사이의 숫자(실수)를 내보내기(retrun)
     * 1 ~ 10 까지의 정수를 뽑기
     * 가공 :
     *      1 <= x < 11 의 정수 뽑기로 변환
     *      1) 0.0 <= Math.random() < 1.0
     *      2) 0.0 * 10 <=  Math.random() * 10 < 1.0 * 10                       // 10 곱하기
     *      3) (int)0.0 * 10 <=  (int)Math.random() * 10 < (int)1.0 * 10        // 강제 형변환 : 실수 -> 정수
     *         => 0 <= (int)Math.random() * 10 < 10
     *      4) 0 + 1 <= (int)Math.random() * 10 + 1 < 10 + 1
     *        => 1 <= (int)Math.random() * 10 + 1 < 11
     */

    public void exam04(){
        // 예제 : 주사위를 던져서 나오는 숫자를 화면에 출력하세요
        // 단, 1 ~ 6 까지의 랜덤하게 나오는 것
        int num = (int)(Math.random() * 6) + 1;      // 1 ~ 10 => 1 ~ 6
//        조건문
        if(num == 1){
            System.out.println("1번");
        } else if(num == 2){
            System.out.println("2번");
        } else if(num == 3){
            System.out.println("3번");
        } else if(num == 4){
            System.out.println("4번");
        } else if(num == 5){
            System.out.println("5번");
        } else {
            System.out.println("6번");
        }
    }

    /**
     * switch 문을 이용해서 코딩하기
     * 예제 : 부장이면 "700만원" 출력, 과장이면 "500만원" 출력
     *       그외 "300만원" 출력
     */

    public void exam08(){
        String position = "과장";

        switch (position){
            case "부장":
                System.out.println("700만원");
                break;
            case "과장":
                System.out.println("500만원");
                break;
            default:
                System.out.println("300만원");
        }
    }
}

반복문 for

package chap04;

/**
 * packageName : chap04
 * fileName : Sec0402
 * author : GGG
 * date : 2023-09-19
 * description : 반복문
 * 요약 :
 *          for문 : for(초기화식; 조건식; 증감식) {반복문;}
 *          => 조건식이 true 일때만 반복문이 실행됨
 *          while문 : 초기화식;
 *                    while(조건식) {
 *                        반복문;
 *                        증감식;
 *                    }
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0402 {

    /**
     * 예제1 : 1 ~ 10까지 숫자를 화면에 출력하세요
     */
    public void exam01() {
        // fori : for문 단축키
        for (int i = 1; i < 11; i++) {
            System.out.println(i);
        }
    }

    /**
     * 예제2 : 1 ~ 100 까지의 합
     */

    public void exam02() {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1~100 까지의 합 : " + sum);
    }

    /**
     * 예제 : 주사위 2 : 주사위를 던져서 나오는 숫자를 계속 화면에 출력하되 6이 나오면 반복문을 중단하고 빠져나오세요
     * 단, 빠져 나올때 프로그램 종료 라고 출력하세요
     */
    public void exam08() {

        while (true) {
            int num = (int) (Math.random() * 6) + 1;
            System.out.println(num);
            if (num == 6) {
                break;
            }
        }
        System.out.println("프로그램 종료");
    }

    /**
     * 예제 : 1 ~ 10 사이의 수 중에서 짝수만 출력하는 코드 : continue
     */
    public void exam09() {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 != 0) continue;
            System.out.println(i);
        }
    }

    /**
     * (참고) 새로나온 사용법 : 반복문의 라벨
     * 활용 : 중첩 for문에서 주로 사용
     */
    public void exam10() {
        Outter:
        for (char upper = 'A'; upper <= 'Z'; upper++) {
            for (char lower = 'a'; lower <= 'z'; lower++) {
                System.out.println(upper + "-" +lower);      // 화면 출력
//                g 가 나오면(안쪽/바깥쪽 모두) 반복문 중단
                if(lower == 'g'){
                    break Outter;       // 이중 중첩 반복문 탈출
                }
            }
        }
        System.out.println("프로그램 종료");
    }
}

참조자료형과 참조변수

package chap05;

/**
 * packageName : chap05
 * fileName : Sec0501
 * author : GGG
 * date : 2023-09-19
 * description : 참조 자료형과 참조 변수
 * 요약 :
 *          기본 자료형 : int(4), long(8), float(4), double, boolean 자료형
 *          => 스택 메모리 영역에 그대로 저장됨
 *          참조 자료형 : String(문자열), 배열, 객체
 *          => 힙 메모리 영역에 값이 저장되고 , 스택 메모리 영역에 주소값이 저장됨
 *          JVM(Java Virtual Machine) : 자바 가상 머신 : jdk(자바가상머신)
 *          역할 : linux / windows(운영체제) 모든 곳에서 실행할 수 있게 만드는 프로그램
 *          비교연산자(==) : 기본자료형에서는 값을 비교하고,
 *                         참조자료형에서는 주소값을 비교하게 됨
 *                         (스택 메모리 영역의 저장된 값을 비교함)
 *          null 포인트 에러(예외) : 프로그램을 강제 비정상 중단함
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0501 {
    /**
     * 비교연산자(==) 와 equals 함수 예제
     */
    public void stringEqualExam(){
//        참조 자료형
//        참조자료형 객체변수 = new 생성자함수();
//        메모리에 랜덤한 주소(방번호)값으로 생성됨
        String strVar1 = new String("신민철");
        String strVar2 = new String("신민철");

//        주소값(방번호)비교 : 개발자 입장에서는 의미 없음
        if(strVar1 == strVar2){
            System.out.println("두개의 주소가 같음");
        } else {
            System.out.println("두개의 주소가 다름");
        }
        
//        equals() 함수 사용 : 값을 비교하는 함수
        if(strVar1.equals(strVar2) == true){
            System.out.println("두개의 값이 같음");
        } else {
            System.out.println("두개의 값이 다름");
        }

//        null 포인터 예외(에러)
//        배열에서 null 에러
        int[] intArray = null;  // 없음(공간 없음)
        intArray[0] = 10;   // 0번지 방에 10번을 넣으니 null 에러가 발생

//        객체에서 null 에러
        String str = null;      // 권장코딩 : String str = "";  빈 문자열로 초기화
//        문자열의 길이를 가져오는 함수 : 문자열.length()
        System.out.println("총 문자 수는 : " + str.length());    // null 에러 발생
    }
}

배열

package chap05;

import java.util.Arrays;

/**
 * packageName : chap05
 * fileName : Sec0502
 * author : GGG
 * date : 2023-09-19
 * description : 배열
 * 요약 :
 *       배열 : 같은 자료형의 데이터를 연속된 공간에 나열하고 인덱스를 부여해 놓은 자료구조
 *       인덱스 : 배열 항목에 붙인 번호 , 0 ~ n 까지의 범위
 *       배열 선언(정의) : 자료형[] 변수;
 *       배열 생성 : 1) 자료형[] 변수 = {값1, ..., 값n};
 *                 2) 자료형[] 변수 = new 자료형[길이];
 *                 3) 자료형[] 변수 = new 자료형[길이] {값1, ... , 값n};
 *       배열 길이 : 배열의 값의 개수, 배열변수.lenght (읽기전용)
 *       다차원 배열 : 배열 안에 또 다른 배열이 있음
 *              자료형[][] 변수 = new 자료형[크기][크기];
 *              자료형[][] 변수 = {{값1...},{값1...}};
 *              => for문 코딩 (2개사용)
 *              => int[][] arr = {{1,2,3}, {4,5,6}}
 *              => 팁 ! : for(int i = 1; i<=2; i++){
 *                          for(int j = 1; j <=3; j++){
 *                       }
 *                      }
 *       향상된 for 문 : for(자료형 변수 : 배열) {} => 자동으로 인덱스 증가
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0502 {
    /**
     * 예제 : 학생 10명의 성적을 저장하고 평균값 구하기
     */
    public void getStudent(){
//        배열의 초기값
        int[] score = {83, 84, 85, 86, 87, 88, 89, 90, 91, 92};
        int sum = 0;    // 합계 변수
        for (int i = 0; i < score.length ; i++) {
            sum += score[i];        // 배열의 값 모두 더하기(누적합)
        }
//        평균구하기
        double avg = (double)sum / 10; // 평균
        System.out.println("sum = " + sum + " , avg = " + avg);
    }

    /**
     * 예제 2 : 배열에서 함수의 매개변수로 전달시 주의점
     */

    public void arrayFunc(){

        int[] scores = {84, 91, 88};

        int sum2 = add(scores);     // ok 가능
//        이렇게 하면 안됨
//        int sum3 = add({84, 91, 88});   // 에러 발생
//        참고)
        int sum4 = add(new int[]{84, 91, 88});  // 가능

        System.out.println(sum2);
        System.out.println(sum4);
    }


    // 더하기 함수 생성해서 호출해서 쓰기
    public int add(int[] scores) {
        int sum = 0;
        for (int i = 0; i < 3; i++) {
            sum += scores[i];
        }
        return sum;
    }

    /**
     * 배열의 2번째 정의 방법
     */

    public void arrayTwo(){
        int[] arr1 = new int[3];    // 배열의 정의(선언) : 빈방을 만들기(메모리에)
//        정수 : 기본값(0), 문자열 : null, 실수 : 0.0 등
//        배열의 3가지 방에 값넣기
        arr1[0] = 10;
        arr1[1] = 20;
        arr1[2] = 30;
//        배열 출력
        for (int i = 0; i < 3; i++) {
            System.out.println(arr1[i]);    // 배열 값 출력
        }

//        TODO: 배열의 안에 값을 간단히 확인하기
//        참고
//        사용법 : Arrays.toString(배열변수)
        System.out.println(Arrays.toString(arr1));
    }

    /**
     * 얇은 복사(shallow copy) vs 깊은 복사(depp copy)
     */
    public void copyArray(){
//        TODO: 얇은 복사
        int[] oldArray = {1, 2, 3};
        int[] copyArray = oldArray;     // 얇은 복사(주소값)을 복사
        int[] newArray = new int[3];    // 깊은 복사용 변수
//        스택방         |                        힙
//        oldArray      | 100       <------>    100 : {1, 2, 3}
//        copyArray     | 100
//        TODO : 얇은 복사 특징 : oldArray 값을 변경하면 copyArray 값도 같이 변경됨
//             : copyArray 값을 변경해도 원본인 oldArray 도 변경됨

//        위의 현상을 피하고자 깊은 복사를 함
//        TODO : 깊은 복사 : 반복문 이용
        for (int i = 0; i < newArray.length ; i++) {
            newArray[i] = oldArray[i];      // 깊은 복사(원본값 바뀌어도 복사본이 바뀌지 않음)
        }


    }

    /**
     * 향상된 for문 : for(자료형 변수 : 배열) {반복문};
     * 아래 점수 총합을 출력하세요
     */
    public void AdvancedExam(){
        int[] scores = {95, 71, 84};        // 국영수 점수 배열
        int sum = 0;
        for (int s : scores) {
            sum += s;
        }
        double avg = (double)sum / scores.length;
        System.out.println("점수의 총합 : " + sum + ", 점수의 평균 : " + avg);

    }
}

열거형

package chap05;

import java.util.Calendar;

/**
 * packageName : chap05
 * fileName : Sec0503
 * author : GGG
 * date : 2023-09-19
 * description :    열거형 사용
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Sec0503 {
    /**
     * 열거형 사용 예제
     */
    public void EnumWeek(){
        Week today = null;
//        달력 객체 : Calendar
        Calendar calendar = Calendar.getInstance(); // 객체 가져오기
        int week = calendar.get(Calendar.DAY_OF_WEEK);  // 현재 요일(1 ~ 7 숫자)
//        조건식
        switch (week){
            case 1:
                today = Week.SUNDAY; break;
            case 2:
                today = Week.MONDAY; break;
            case 3:
                today = Week.TUESDAY; break;
            case 4:
                today = Week.WEDNESDAY; break;
            case 5:
                today = Week.THURSDAY; break;
            case 6:
                today = Week.FRIDAY; break;
            case 7:
                today = Week.SATURDAY; break;
        }
        System.out.println("오늘 요일 :" + today);
    }
}
package chap05;

/**
 * packageName : chap05
 * fileName : Week
 * author : GGG
 * date : 2023-09-19
 * description : 열거형 클래스
 * 요약 :
 *      열거 자료형 : 몇 가지로 제한된 상수를 가지는 자료형
 *      사용법(정의) : enum 변수명 { 상수1, 상수2, ... 상수n }
 *      클래스 내에서 사용
 *          변수명.상수명 ex) Week.MONDAY
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public enum Week {
    //    월,화,수,목,금,토,일 정의(상수)
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}
package chap05;

import java.util.Arrays;

/**
 * packageName : chap05
 * fileName : Verify05
 * author : GGG
 * date : 2023-09-19
 * description :   배열 / 열거형 연습문제
 * 요약 :
 * <p>
 * ===========================================================
 * DATE            AUTHOR             NOTE
 * —————————————————————————————
 * 2023-09-19         GGG          최초 생성
 */
public class Verify05 {
    /**
     * 주어진 배열에서 최대값을 구해보세요
     */
    public void exam04() {
        int[] array = {1, 5, 3, 8, 2};
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max < array[i]) {
                max = array[i];
            }
        }
        System.out.println(max);
    }

    /**
     * 2) 중첩 for문을 이용해서 주어진 배열의 전체 항목의 합과 평균을 구해보세요.
     */
    public void exam05() {
        int[][] array = { { 95, 86 }, { 83, 92, 96 }, { 78, 83, 93, 87, 88 } };

        int sum = 0;
        int count = 0;

        for(int i = 0; i < array.length; i++){
            for(int j = 0; j < array[i].length; j++){
                sum += array[i][j];
                count += 1;
            }
        }
        double avg = (double) sum / count;



        System.out.println(sum);
        System.out.println(avg);
    }

}
반응형

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

생성자 함수  (0) 2023.09.20
클래스  (0) 2023.09.20
문자열 자료형  (1) 2023.09.08
[JAVA] 참조변수의 형변환  (0) 2023.08.11
[JAVA] 인터페이스(interface)  (0) 2023.08.11
반응형
    // String : 문자열 자료형
    // 0 ~ 다수의 문자들로 구성됨
    // ""로 둘러쌈
    // String은 참조 자료형임

    // 리터럴 방식
    String str1 = "Hello Java!";
    String str2 = "반갑습니다. 주녘의 블로그입니다.";

    // 빈 문자열도 가능
    String str3 = "";

    // 인스턴스 생성 방식
    String str4 = new String("안녕, 나는 주녘이야");

    String hi1 = "Hi";
    String hi2 = "Hi";
    String jv = "Java";

    // 리터럴끼리는 == 사용하여 비교가 가능함
    boolean bool1 = hi1 == hi2;  	// true
    boolean bool2 = hi1 == jv;		// false

    String hi3 = new String("Hi");
    String hi4 = new String("Hi");
    String hi5 = hi4;

    // 인스턴스와 비교하려면 == 이 아닌 .equals 메소드를 사용

    boolean bool3 = hi3 == hi4;		// false
    // 같은 Hi 인데 왜 false로 나올까?
    // hi3와 hi4 메모리의 다른 주소값으로 인스턴스가 생성되었기 때문!
    int result = System.identityHashCode(hi3);		// 2074407503
    int result2 = System.identityHashCode(hi4);		// 999966131

    boolean bool4 = hi1.equals(hi2);		// true
    boolean bool5 = hi1.equals(hi3);		// true
    boolean bool6 = hi1.equals(hi4);		// true
    boolean bool7 = hi1.equals(hi2);		// true
    boolean bool8 = hi4 == hi5;			// true
}

 

반응형

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

클래스  (0) 2023.09.20
[JAVA 다시보기] 자바기초  (1) 2023.09.19
[JAVA] 참조변수의 형변환  (0) 2023.08.11
[JAVA] 인터페이스(interface)  (0) 2023.08.11
[JAVA] String 클래스  (0) 2023.08.10
반응형

package ch01;

 

import java.util.Scanner;

 

public class Ex4_20 {

public static void main(String[] args) {

int menu = 0, num = 0;

Scanner sc = new Scanner(System.in);

 

// while문에 outer라는 이름을 붙임

outer: while (true) {

System.out.println("(1) square");

System.out.println("(2) square root");

System.out.println("(3) log");

System.out.print("원하는 메뉴(1~3)을 선택하세요, 종료는 0번");

 

String tmp = sc.nextLine(); // 입력값을 tmp에 저장

menu = Integer.parseInt(tmp); // 입력받은 문자열 tmp를 숫자로 변환

 

if (menu == 0) {

System.out.println("계산을 종료합니다.");

break; // 계산종료 for문 벗어남

} else if (!(1 <= menu && menu <= 3)) {

System.out.println("잘못입력하셨습니다.");

continue;

}

 

for (;;) {

System.out.print("계산할 값을 입력하세요(계산종료 0, 전체종료 99)>");

tmp = sc.nextLine();

num = Integer.parseInt(tmp);

 

if (num == 0)

 

break;

 

if (num == 99)

 

break outer;

 

switch (menu) {

case 1:

System.out.println("result=" + num * num);

break;

 

case 2:

System.out.println("result=" + Math.sqrt(num));

break;

 

case 3:

System.out.println("result=" + Math.log(num));

break;

}

} // for(;;)

 

} // end of while

} // end of main

} // end of class

 


메뉴를 선택하면 해당 연산을 반복적으로 수행할 수 있게 for문을 추가하였다.

반복문만 떼어놓고 보면 무한 반복문인 while문안에 또 다른 무한반복문인 for문이 중첩된 구조인 것을 알 수 있다.

while문은 메뉴를 반복해서 선택할 수 있게 해주고, for문은 선택된 메뉴의 작업을 반복해서 할 수 있게 한다.

 

outer:

while(true) { // 무한 반복문

           ...

          for(;;) { // 무한 반복문

           ...

          if(num==0) // 계산 종료 for문을 벗어남

              break;

          if(num==99) // 전체 종료 for문과 while 문 모두 벗어난다.

              break outer;

          ...

            } // for(;;)

    } // while

 

 

 

반응형

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

자료구조 연습문제 2  (0) 2023.09.26
자료구조 연습문제  (0) 2023.09.26
이름 붙은 반복문  (0) 2023.08.12
break문과 continue 문 예제  (0) 2023.08.12
[JAVA] 매개변수의 다형성 연습  (0) 2023.08.11
반응형

  • break문은 근접한 단 하나의 반복문만 벗어날 수 있다.
  • 여러 개의 반복문이 중첩된 경우 break문으로 중첩 반복문을 완전히 벗어날 수 없다.
  • 중첩 반복문 앞에 이름을 붙이고 break, continue 문에 이름을 지정하면 하나 이상의 반복문을 벗어날 수 있다.

package ch01;

 

public class Ex4_19 {

public static void main(String[] args) {

// 이름 붙은 반복문

 

// for문에 Loop1 이라는 이름을 붙임.

 

Loop1 : for(int i=2; i <= 9; i++) {

for(int j = 1; j <= 9; j++) {

if(j == 5) {

break Loop1;

// break;

// continue Loop1;

// continue;

 

} System.out.println(i + "*" + j + "=" + i * j);

} System.out.println(); // end of for i

} // end of Loop 1

}

}

 

위의 예제는 구구단을 출력하는 예제이다.

제일 바깥에 있는 for문에 Loop1 이라는 이름을 부여했다. 그리고 j가 5일때 break문을 수행하도록 했다.

반복문의 이름이 지정되지 않는 break문은 자신이 속한 하나의 반복문만 벗어날 수 있다.

이 처럼 반복문에 이름을 부여하고 break 문에 반복문 이름을 붙여주면 하나 이상의 반복문도 벗어날 수 있다.

j가 5일 때 Loop1을 벗어나도록 했으므로 2단의 4줄 까지 출력된다.

만일 반복문에 이름이 부여되지 않은 break문 이었다면 2단 부터 9단까지 모두 네 줄씩 출력되었을 것이다.

// 반복문에 이름을 부여하지 않은 break 문

2*1=2

2*2=4

2*3=6

2*4=8

 

3*1=3

3*2=6

3*3=9

3*4=12

 

4*1=4

4*2=8

4*3=12

4*4=16

 

5*1=5

5*2=10

5*3=15

5*4=20

 

6*1=6

6*2=12

6*3=18

6*4=24

 

7*1=7

7*2=14

7*3=21

7*4=28

 

8*1=8

8*2=16

8*3=24

8*4=32

 

9*1=9

9*2=18

9*3=27

9*4=36

 

 

// 반복문에 Loop1이라는 이름을 부여한 break 문

2*1=2

2*2=4

2*3=6

2*4=8

 

반응형
반응형

메뉴를 보여주고 선택하게 하는 예제입니다. 메뉴를 잘못선택한 경우 continue문으로 다시 메뉴를 보여주고

종료(0)을 선택한 경우 break문으로 반복을 벗어나 프로그램을 종료하도록 설계하였다.


package ch01;

import java.util.*;

public class Ex4_18 {

public static void main(String[] args) {

// break문과 continue 문 예제

 

int menu = 0;

int num = 0;

 

Scanner scanner = new Scanner(System.in);

 

while(true) {

System.out.println("(1) square");

System.out.println("(2) square root");

System.out.println("(3) log");

System.out.print("원하는 메뉴(1~3)을 선택하세요. (종료 : 0)>");

 

String tmp = scanner.nextLine(); // 화면에서 입력받은 내용을 tmp에 저장

menu = Integer.parseInt(tmp); // 입력받은 문자열(tmp)을 숫자로 변환

 

if(menu == 0) {

System.out.println("프로그램을 종료합니다.");

break;

} else if(!(1 <= menu && menu <=3)) { // menu의 선택 번호가 1보다 같거나 크고 3보다 작거나 같은게 아닌 번호

System.out.println("잘못 입력하였습니다. 종료는 0번");

continue;

}

 

System.out.println("선택하신 메뉴는 " + menu + "번 입니다.");

}

 

} // end of main

} // end of class

 

(1) square

(2) square root

(3) log

원하는 메뉴(1~3)을 선택하세요. (종료 : 0)>1

선택하신 메뉴는 1번 입니다.

-------------------------------------------------------------------------------------------------

(1) square

(2) square root

(3) log

원하는 메뉴(1~3)을 선택하세요. (종료 : 0)>2

선택하신 메뉴는 2번 입니다.

-------------------------------------------------------------------------------------------------

(1) square

(2) square root

(3) log

원하는 메뉴(1~3)을 선택하세요. (종료 : 0)>3

선택하신 메뉴는 3번 입니다.

-------------------------------------------------------------------------------------------------

(1) square

(2) square root

(3) log

원하는 메뉴(1~3)을 선택하세요. (종료 : 0)>4

잘못 입력하였습니다. 종료는 0번

-------------------------------------------------------------------------------------------------

(1) square

(2) square root

(3) log

원하는 메뉴(1~3)을 선택하세요. (종료 : 0)>0

프로그램을 종료합니다.

 

반응형

+ Recent posts