// 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());
}
}
}
.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); // 객체의 비교(속성을 비교)
}
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);
}
* 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"));
}
}
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);
}
}
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;
}
}
클래스 선언(정의)시 컴파일러에 의해 자동으로 추가되는 생성자 // 기본 생성자 : 만들지 않아도 컴파일러가 자동으로 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);
}
}
* 클래스 : 객체의 구조를 정의하는 곳 (속성(필드, 멤버변수), 생성자, 함수(메서드)) * 객체(인스턴스) : 클래스로부터 생성되며 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;
}
/** * 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);
}
}
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);
}
}