'전체 글'에 해당되는 글 384건
- 2019.07.18 Java - 제네릭스, Wildcard, 열거형, Thread
- 2019.07.17 Java - ArrayList, LinkedList, Stack, Queue, Iterator, ListIterator, Comparator, HashSet, TreeSet, HashMap, Set
- 2019.07.16 Java - Format, java.sql.date, StringTokenizer, Calendar, Class, Reflection
- 2019.07.15 Java - 자료구조(Collection), Random, Wrapper
- 2019.07.12 언어소개
- 2019.07.12 Java - 다형성, 상속, 예외
- 2019.07.11 CSS 코드의 재사용
- 2019.07.11 반응형 디자인
- 2019.07.11 Java - Switch, 다중for문, Break문, 반복문복합, Singleton, Prototype패턴, 인터페이스, String, StringBuffer
- 2019.07.10 Java - 다형성, equals, 정렬로직, 인터페이스, template 패턴
package Week02.day0718;
import java.sql.Date;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;
public class 실습8일차수정 {
public static void main(String[] args) {
/* 1. 개가 예방접종을 맞음. - .
* 2. 예방접종기록을 저장.(기록을 넣기 위해 클래스(arraylist에 넣음)를 만들어야함. -접종명, 접종날짜를 저장)
* - 체크로직1 : (단, 동일한 날짜에 같은 예방접종을 맞으면 안됨)
* - 체크로직2 : (예방접종간격이 존재 - 어긋나면 오류멘트 출력.)
* 3. 예방접종 이력 출력.
* --- 추가 실습-----
* addHandler - hashset
* getTotalHandlePeriod - 총 훈련기간을 day로 리턴
* addFamliy - 가족추가, hashmap에 넣음. 클래스로 만들어서 넣어도 됨.
*/
Dog d1 = new Dog("멍뭉이", 3, "셰퍼드");
Dog d2 = new Dog("냥냥이", 2, "진도견");
Dog d3 = new Dog("왈왈이", 1, "보더콜리");
try {
d1.shotInoculate("독감", Date.valueOf("2019-07-01"));
d2.shotInoculate("홍역", Date.valueOf("2019-07-01"));
d3.shotInoculate("광견병", Date.valueOf("2019-07-01"));
d3.shotInoculate("광견병", Date.valueOf("2019-07-01"));
} catch (Exception e) {
e.printStackTrace();
}
d1.printInoculateHistory();
d2.printInoculateHistory();
d3.printInoculateHistory();
d1.addHandler("홍길동", "2019-01-05", "2019-02-01");
d1.addHandler("홍길동", "2019-01-05", "2019-02-01");
d1.addHandler("김길동", "2019-05-09", "2019-05-30");
try {
System.out.println("Period:" + d1.getTotalHandlerPeriod());
} catch (Exception e) {
e.printStackTrace();
}
}
}
class Dog {
private String name; // 개이름
private int age; // 개나이
private String kind; //품종
private ArrayList inoculate = new ArrayList(); // 예방접종
private HashSet handler = new HashSet();
private HashMap family = new HashMap();
Dog(String name, int age, String kind) {
this.name = name;
this.age = age;
this.kind = kind;
}
public void shotInoculate(String name, Date date) throws Exception {
// 예방접종을 하다
// - inoculate 속성에 이름과 날자에 해당하는 예방접종 정보 저장
// - 동일한 날자에 같은 예방접종을 하면 안된다
// - 품종별 예방접종 가능 기간이 아니면 오류 발생
// “예방접종 가능 기간이 아닙니다”
// ** 예방접종간격:
// - 셰퍼드: 7일 이상
// - 진도견: 10일 이상
// - 보더콜리: 15일 이상
Inoculate in = new Inoculate(name, date);
// 같은 정보가 있는지 Check - contains 활용.
if (inoculate.contains(in)) {
throw new Exception("중복된 예방접종입니다");
}
// 품종별 예방접종 가능 기간이 아닌지 Check
Collections.sort(inoculate); // 정렬
Inoculate max = null;
if (inoculate.size() > 0) { //isEmpty 로 해도됨.
max = (Inoculate) inoculate.get(inoculate.size() - 1);
long day = 0;
if ("셰퍼드".equals(this.kind)) {
day = diffOfDate(max.getDate().toString(), date.toString());
if (day < 7)
throw new Exception("예방접종 가능기간이 아닙니다");
} else if ("진도견".equals(this.kind)) {
day = diffOfDate(max.getDate().toString(), date.toString());
if (day < 10)
throw new Exception("예방접종 가능기간이 아닙니다");
} else if ("보더콜리".equals(this.kind)) {
day = diffOfDate(max.getDate().toString(), date.toString());
if (day < 15)
throw new Exception("예방접종 가능기간이 아닙니다");
}
}
inoculate.add(in);
}
public void printInoculateHistory() {
// 예방접종 이력을 날자별 정렬하여 출력한다,
// 형식: ‘{0} - {1}’, {0}: 날자, {1}:예방접종명
// 날자는 xxxx.xx.xx Format으로 출력한다
Iterator it = inoculate.iterator();
while(it.hasNext()) {
String msg = "{0} - {1}";
Object[] arguments = {name, ((Inoculate)it.next()).getName()};
String result = MessageFormat.format(msg, arguments);
System.out.println(result);
}
}
public void addHandler(String name, String strDt, String endDt) { //set은 중복여부 체크할필요없음.
Handler h = new Handler(name, strDt, endDt); //HashSet 사용. equals와 hash코드를 적절히 재정의해줘야함.
handler.add(h); //equals를 반드시 재정의해줘야 중복저장안됨.
}
public int getTotalHandlerPeriod() throws Exception { //Handler의 훈련기간 리턴.
Iterator it = handler.iterator();
int sum = 0; //콜렉션에 변동사항이 있으면 안됨. 상식임.
while (it.hasNext()) {
Handler h = (Handler) it.next(); //여러 객체 불러올땐 ,담아놓고 호출해야함.
String strDt = h.getStrDt();
String endDt = h.getEndDt();
long lo = diffOfDate(strDt, endDt);
sum += lo;
}
return sum;
}
public long diffOfDate(String begin, String end) throws Exception {
System.out.println(begin + "~" + end);
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
java.util.Date beginDate = formatter.parse(begin);
java.util.Date endDate = formatter.parse(end);
long diff = endDate.getTime() - beginDate.getTime();
long diffDays = diff / (24 * 60 * 60 * 1000);
return diffDays;
}
}
class Handler {
private String name;
private String strDt;
private String endDt;
Handler(String name, String strDt, String endDt) {
this.name = name;
this.strDt = strDt;
this.endDt = endDt;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStrDt() {
return strDt;
}
public void setStrDt(String strDt) {
this.strDt = strDt;
}
public String getEndDt() {
return endDt;
}
public void setEndDt(String endDt) {
this.endDt = endDt;
}
public boolean equals(Object obj) {
String thisTmp = name + strDt + endDt;
String tmp = ((Handler) obj).getName() + ((Handler) obj).getStrDt() + ((Handler) obj).getEndDt();
System.out.println("equals 호출");
if (obj != null && obj instanceof Handler) { // obj가 Handler의 Instance이냐?
boolean b = thisTmp.equals(tmp);
System.out.println("비교:" + b);
return b; // 같이 같은지 비교
} else {
return false;
}
}
public int hashCode() { // HashCode 사용 - 중복 값을 빠르게 검색하고 Add시 어디에 집어 넣을지 결정합니다
return Objects.hash(name, strDt, endDt);
}
public String toString() {
// Card인스턴스의 kind와 number를 문자열로 반환한다.
return "name : " + name + ", startDt : " + strDt + ", endDt : " + endDt;
}
}
class Inoculate implements Comparable {
String name;
Date date;
Inoculate(String name, Date date) {
this.name = name;
this.date = date;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
public boolean equals(Object obj) {
if (obj != null && obj instanceof Inoculate) { // obj가 Inoculate의 Instance
return name.equals(((Inoculate) obj).name); // 같이 같은지 비교
} else {
return false;
}
}
@Override
public int compareTo(Object arg) { // compareTo 재정의.
Inoculate param = (Inoculate) arg;
return date.toString().compareTo(param.getDate().toString());
}
}
--------------------------------------------------------------------------
package Week02.day0718;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
class Student implements Comparable{
String name;
int score;
public String getName() {
return name;
}
public int getScore() {
return score;
}
public Student(String name, int score) {
this.name = name;
this.score = score;
}
public int compareTo(Object s) {
if(this.score < ((Student)s).getScore()) {
return -1;
} else if (this.score > ((Student)s).getScore()) {
return 1;
}
return 0;
}
}
public class ArrayListEx4 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Student("a", 5));
list.add(new Student("b", 10));
list.add(new Student("c", 1));
list.add(new Student("d", 52));
list.add(new Student("e", 23));
Collections.sort(list);
Iterator it = list.iterator();
while(it.hasNext()) {
System.out.println(((Student)it.next()).getScore()); // 1 5 10 23 52 출력
}
}
}
--------------------------------------------------------------------------
package Week02.day0718;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
class Student1{
int rollno;
String name, address;
public Student1(int rollno, String name, String address) {
this.rollno = rollno;
this.name = name;
this.address = address;
}
public String toString() {
return this.rollno + " " + this.name + " " + this.address;
}
}
class Sortbyroll implements Comparator<Student1>{
public int compare(Student1 a, Student1 b) {
return a.rollno - b.rollno;
}
}
public class ComparatorEx2 {
public static void main(String[] args) {
ArrayList<Student1> ar = new ArrayList<Student1>();
ar.add(new Student1(111, "bbbb", "london"));
ar.add(new Student1(131, "aaaa", "nyc"));
ar.add(new Student1(121, "cccc", "jaipur"));
System.out.println("Unsorted");
for(int i=0; i<ar.size(); i++)
System.out.println(ar.get(i));
Collections.sort(ar, new Sortbyroll());
for(int i=0; i<ar.size(); i++)
System.out.println(ar.get(i));
}
}
//출력값
/*Unsorted
111 bbbb london
131 aaaa nyc
121 cccc jaipur
111 bbbb london
121 cccc jaipur
131 aaaa nyc
*/
--------------------------------------------------------------------------
package Week02.day0718;
import java.util.ArrayList;
class Box<T>{
ArrayList<T> list = new ArrayList<T>();
void add(T item) { list.add(item);}
T get(int i) {return list.get(i);}
int size() {return list.size();}
public String toString() {return list.toString();}
}
class Fruit{
public String toString() {return "Fruit";}
}
class Apple extends Fruit{
public String toString() {return "Apple";}
}
class Grape extends Fruit{
public String toString() {return "Grape";}
}
class Toy{
public String toString() {return "Toy";}
}
public class FruitBoxEx1 {
//제네릭스.
public static void main(String[] args) {
Box<Fruit> fruitBox = new Box<Fruit>();
Box<Apple> appleBox = new Box<Apple>();
Box<Toy> toyBox = new Box<Toy>();
Box<Toy> toyBox2 = new Box<>(); //생성자에 타입생략가능 jdk1.7
//Box<Grape> grapeBox = new Box<Apple>(); // 에러. 타입 불일치. 생성시에는 타입이 일치해야 함.
fruitBox.add(new Fruit());
fruitBox.add(new Apple()); // OK. void add(Fruit item), Apple는 Fruit의 자식
appleBox.add(new Apple());
appleBox.add(new Apple());
//appleBox.add(new Toy()); //에러. Box<Apple>에는 Apple만 담을수 있음.
toyBox.add(new Toy());
//toyBox.add(new Apple()); //에러 . Box<Toy>에는 Apple만 담을수 있음.
System.out.println(fruitBox); // [Fruit, Apple]
System.out.println(appleBox); // [Apple, Apple]
System.out.println(toyBox); // [Toy]
} // main의 끝
}
--------------------------------------------------------------------------
package Week02.day0718;
import java.util.ArrayList;
class Fruit1 implements Eatable{
public String toString() {return "Fruit";}
}
class Apple1 extends Fruit1{public String toString() {return "Apple";}}
class Grape1 extends Fruit1{public String toString() {return "Grape";}}
class Toy1{public String toString() {return "Toy" ; }}
interface Eatable{}
public class FruitBoxEx2 {
public static void main(String[] args) {
FruitBox<Fruit1> fruitBox = new FruitBox<Fruit1>(); //Eatable의 자식
FruitBox<Apple1> appleBox = new FruitBox<Apple1>(); //Fruit의 자식
FruitBox<Grape1> grapeBox = new FruitBox<Grape1>(); //Fruit의 자식
// FruitBox<Grape> appleBox = new FruitBox<Apple>(); // 에러, 타입 불일치
// FruitBox<Toy> toyBox = new FruitBox<Toy>(); // 에러.
fruitBox.add(new Fruit1());
fruitBox.add(new Apple1());
fruitBox.add(new Grape1());
appleBox.add(new Apple1());
// appleBox.add(new Grape()); //에러. Grape는 Apple의 자손이 아님
grapeBox.add(new Grape1());
System.out.println("fruitBox-" + fruitBox); // fruitBox-[Fruit, Apple, Grape]
System.out.println("appleBox-" + appleBox); // appleBox-[Apple]
System.out.println("grapeBox-" + grapeBox); // grapeBox-[Grape]
}
}
class FruitBox<T extends Fruit1 & Eatable> extends Box1<T>{}
class Box1<T>{
ArrayList<T> list = new ArrayList<T>();
void add(T item) {list.add(item);}
T get(int i) {return list.get(i);}
int size() {return list.size();}
public String toString() {return list.toString();}
}
--------------------------------------------------------------------------
package Week02.day0718;
import java.util.ArrayList;
class Juice{
String name;
Juice(String name){this.name = name + "Juice";}
public String toString() {return name;}
}
class Juicer{ // Jucier는 Generic class 가 아니고 static 메소드에서 Generic 클래스 사용시
static Juice makeJuice(FruitBox1<? extends Fruit> box) {
String tmp = "";
for(Fruit f : box.getList())
tmp+=f+" ";
return new Juice(tmp);
}
}
public class FruitBoxEx3 {
public static void main(String[] args) {
//와일드카드
//<? extends T> : 와일드카드의 상한제한, T와 그 자손들만 가능
//<? super T> : 와일드 카드의 하한제한, T와 그 조상들만 가능
//<?> : 제한없음, 모든 타입이 가능
FruitBox1<Fruit> fruitBox = new FruitBox1<Fruit>();
FruitBox1<Apple> appleBox = new FruitBox1<Apple>();
fruitBox.add(new Apple());
fruitBox.add(new Grape());
appleBox.add(new Apple());
appleBox.add(new Apple());
System.out.println(Juicer.makeJuice(fruitBox)); // Apple Grape Juice
System.out.println(Juicer.makeJuice(appleBox)); // Apple Apple Juice
} // main
}
class FruitBox1<T extends Fruit> extends Box2<T>{}
class Box2<T>{
//class FruitBox<T extends Fruit>
ArrayList<T> list = new ArrayList<T>();
void add(T item) {list.add(item);}
T get(int i) {return list.get(i);}
ArrayList<T> getList(){return list;}
int size() {return list.size();}
public String toString() {return list.toString();}
}
--------------------------------------------------------------------------
package Week02.day0718;
enum Direction {EAST, SOUTH, WEST, NORTH}
public class EnumEx1 {
public static void main(String[] args) {
//열거형
//열거형 값을 할당하는 3가지 방법
Direction d1 = Direction.EAST;
Direction d2 = Direction.valueOf("WEST");
Direction d3 = Enum.valueOf(Direction.class, "EAST");
System.out.println("d1=" + d1); // d1=EAST
System.out.println("d2=" + d2); // d2=WEST
System.out.println("d3=" + d3); // d3=EAST
System.out.println("d1==d2 ? " + (d1==d2)); // false
System.out.println("d1==d3 ? " + (d1==d3)); // true
System.out.println("d1.equals(d3) ? " + d1.equals(d3)); // true
// System.out.println("d2> d3 ? " + (d1 > d3)); // 에러 , 비교구분 불가능
System.out.println("d1.compareTo(d3) ? " + (d1.compareTo(d3))); // 0
System.out.println("d1.compareTo(d2) ? " + (d1.compareTo(d2))); // -2
switch(d1){ // 변수값에 따라 아래 케이스 출력.
case EAST: //Direction.EAST라고 쓸수 없다.
System.out.println("The direction is EAST.");
break;
case SOUTH:
System.out.println("The direction is SOUTH.");
break;
case WEST:
System.out.println("The direction is WEST.");
break;
case NORTH:
System.out.println("The direction is NORTH.");
break;
default:
System.out.println("Invalid direction.");
//break;
}
Direction[] dArr = Direction.values();
for(Direction d : dArr) // for(Direction d : Direction.values())
System.out.printf("%s=%d%n", d.name(), d.ordinal());
/*EAST=0
SOUTH=1
WEST=2
NORTH=3
*/
}
}
--------------------------------------------------------------------------
/* Thread */
1. 하나의 프로그램을 프로세스라고 할때, Thread는 하나의 프로그램 내에서의 실행 단위
2. 호출 스택
- JVM에서 main()메소드를 호출
- main()에서 새로운 Thread를 시작
- JVM은 두 Thread가 종료될 때까지 새로운 Thread와 원래의 Main Thread 사이를 왔다 갔다 한다.
package Week02.day0718;
class ThreadSample extends Thread {// 3. Thread 클래스 상속 - 하위 클래스가 Thread 클래스의 run 메소드 재정의
int number;
ThreadSample(int n){
super(); number = n;
}
ThreadSample(String s, int n){
super(s); number = n;
}
public void run() {
int n = 3;
while(n<number) {
if(isPrimeNumber(n))
System.out.println(getName() + ": " + n + " is prime number");
n++;
try {
sleep(100);
}catch (InterruptedException e) {
}
}
}
public boolean isPrimeNumber(int n) {
int i;
for(i = 2; i<=(n/2); i++)
if((n%i)==0)
return (false);
return (true);
}
}
public class ThreadTest {
public static void main(String[] args) {
ThreadSample primeThread = new ThreadSample(30);
System.out.println("PrimeThread:"+primeThread);
primeThread.setName("PrimeThread");
System.out.println("PrimeThread:"+primeThread);
primeThread.start(); // thread시작시 알아서 run 메소드 호출
}
}
//출력값
//PrimeThread:Thread[Thread-0,5,main]
//PrimeThread:Thread[PrimeThread,5,main]
//PrimeThread: 3 is prime number
//PrimeThread: 5 is prime number
//PrimeThread: 7 is prime number
//PrimeThread: 11 is prime number
//PrimeThread: 13 is prime number
//PrimeThread: 17 is prime number
//PrimeThread: 19 is prime number
//PrimeThread: 23 is prime number
//PrimeThread: 29 is prime number
//..............
--------------------------------------------------------------------------
package Week02.day0718;
class PrimeThread implements Runnable{
int number;
String name;
PrimeThread(int n){
name = null ; number = n;
}
PrimeThread(String s, int n){
name = s; number = n;
}
public void run() {
int n = 3;
while(n<number) {
if(isPrimeNumber(n))
System.out.println(name + ": " + n + " is prime number");
n++;
try {
Thread.sleep(100); // 0.1초 thread일시정지후 실행대기 상태로
}catch (InterruptedException e) {
}
}
}
public boolean isPrimeNumber(int n) {
int i;
for(i = 2; i<=(n/2); i++)
if((n%i)==0)
return (false);
return (true);
}
}
/* Runnable Interface를 구현 */
1. Thread의 하위클래스를 만들지 않고서도 Thread로 수행될 클래스를 만들 수있는방법을 제공
public class RunnableTest {
public static void main(String[] args) {
//Runnable interface를 implements한 Class를 인자로 넣어서
//Thread생성
Thread primeThread = new Thread(new PrimeThread(30));
System.out.println("PrimeThread : " + primeThread);
primeThread.setName("PrimeThread");
System.out.println("PrimeThread : " + primeThread);
primeThread.start();
}
}
//출력값
//PrimeThread : Thread[Thread-0,5,main]
//PrimeThread : Thread[PrimeThread,5,main]
//null: 3 is prime number
//null: 5 is prime number
//null: 7 is prime number
//null: 11 is prime number
//null: 13 is prime number
//null: 17 is prime number
//null: 19 is prime number
//null: 23 is prime number
//null: 29 is prime number
//....................
/* Thread 환경에서 사용하는 함수 설명 */
1. public final int getPriority : 스레드의 우선순위를 얻는다
2. public final void setPriority(int newPriority) : 스레드의 우선순위를 주어진 값으로 설정
3. public final void suspend() : 스레드를 잠시 쉬게한다
4. public final void resume() : 다시 시작
5. void destory() : 스레드를 파괴
/* Thread 스케줄러 */
1. 스케줄러는 어떤 Thread가 실행되어야 하는지 얼마나 오랫동안 실행되어야 하는지 결정
2. 스케줄러는 사용자가 마음대로 제어할 수 없다.
3. sleep 메소드 : thread를 대기상태가 되도록 만듬
4. Thread 우선순위 결정 : 1 ~ 10 (숫자가 높을수록 우선순위 높다)'Java' 카테고리의 다른 글
| Java - Stream(byte, 문자) (0) | 2019.07.22 |
|---|---|
| Java - Thread(싱글, 다중(멀티), 스위칭), 동기화 (0) | 2019.07.19 |
| Java - ArrayList, LinkedList, Stack, Queue, Iterator, ListIterator, Comparator, HashSet, TreeSet, HashMap, Set (0) | 2019.07.17 |
| Java - Format, java.sql.date, StringTokenizer, Calendar, Class, Reflection (0) | 2019.07.16 |
| Java - 자료구조(Collection), Random, Wrapper (0) | 2019.07.15 |
Java - ArrayList, LinkedList, Stack, Queue, Iterator, ListIterator, Comparator, HashSet, TreeSet, HashMap, Set
| Java 2019. 7. 17. 18:40주요내용 :
package Week02.day0717;
import java.sql.Date;
import java.text.DecimalFormat;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
class Army{
private String name;
private int age;
private String grade;
private String strDt; //복무기간(시작~끝)
private String endDt;
private Date nextHoliday; // 다음휴가일
private Army[] sub = new Army[4]; // 부하병사들(sub)
private int bonus;
private int subCnt;
Army(String name, int age, String grade, String strDt, String endDt) {
this.name = name;
this.age = age;
this.grade = grade; // 계급
this.strDt = strDt;
this.endDt = endDt;
}
public int getOverTimePayByClass() { // class별야근수당 리턴 , 일병: 100,000, 상병: 200,000, 병장: 300,000
switch(grade) {
case "병장":
bonus+=300000;
break;
case "상병":
bonus+=200000;
break;
case "일병":
bonus+=100000;
break;
}
return bonus;
}
public void printSubOverTimePay(Army[] sub) {// 부하별야근수당을 출력한다. 형식: ‘{0} 의야근수당은 {1} 입니다’ 금액은 3자리마다,를 찍어 표시한다, message format 쓰기
DecimalFormat df = new DecimalFormat("#,###");
for(int i=0; i<sub.length; i++) {
String msg = "{0} {1} 의 야근수당은 {2} 원입니다.";
Object[] arguments = {sub[i].grade, sub[i].name, df.format(sub[i].getOverTimePayByClass())};
String result = MessageFormat.format(msg, arguments);
System.out.println(result);
}
}
public void getThisMMPeriod() throws ParseException { // 남은 복무기간. (끝날짜 - 현재날짜)
// return (today.getActualMaximum(Calendar.DATE) - today.get(Calendar.DATE)); // 이번달의 남은 근무기간을 리턴한다.
String endDt1 = endDt;
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
Calendar c1 = Calendar.getInstance();
String nowDt = sdf.format(c1.getTime());
java.util.Date nowDt1 = sdf.parse(nowDt);
java.util.Date endDt2 = sdf.parse(endDt);
long diff = endDt2.getTime() - nowDt1.getTime();
long diffDays = diff / (24 * 60 * 60 * 1000);
System.out.println(name + "님의 남은 복무기간은 = " + diffDays + "일 입니다.");
}
// public int getSubTotalPeriod() { // 부하들의총 근무기간을 리턴한다. 일수로 리턴. (현재날짜 - 첫날짜)
// int endDt2 = Integer.parseInt(endDt);
// int startDt1 = Integer.parseInt(strDt);
// int period = endDt2 - startDt1;
// return name + "님의 총 복무기간은 = " + period + "개월 입니다.";
// }
//
// public boolean checkSub(Army[] sub) { // 모두 본인의 부하인지 리턴한다. Army간 비교는 name/age/class가 동일하면 동일인이다
// //Army[] sub에 배열을 담아 파라미터로 던지면 부하인지 물어보는것. true, false로 리턴.
// //부하들 sub에 담는다.
// }
public void returnSub(Army[] sub) { // 부하들 목록을 리턴한다
System.out.println("======"+name+"님의 부하들======");
for(int i=0; i<sub.length; i++) {
System.out.println("이름 = " + sub[i].name +", 계급 = " + sub[i].grade);
}
}
public void printSub(Army[] sub) throws ParseException { // 부하들을 출력한다
for(int i=0; i<sub.length; i++) {
SimpleDateFormat origianl_format = new SimpleDateFormat("yyyymmdd");
SimpleDateFormat new_format = new SimpleDateFormat("yyyy-mm-dd");
java.util.Date Start_origianl_date = origianl_format.parse(sub[i].strDt);
String Start_new_date = new_format.format(Start_origianl_date);
java.util.Date End_origianl_date = origianl_format.parse(sub[i].endDt);
String End_new_date = new_format.format(End_origianl_date);
if(sub[i]!=null && sub[i] instanceof SpecialArmy)
System.out.println("우수병사 " + sub[i].grade + " " + sub[i].name + " " + Start_new_date + "~" + End_new_date);
else
System.out.println(sub[i].grade + " " + sub[i].name + " " + Start_new_date + "~" + End_new_date);
}
// 병장 홍길동 2019-01-01 ~ 2020-12-31
// 우수 상병 김길동 2018-01-01 ~ 2021-05-31
}
}
class SpecialArmy extends Army{ // 우수군인. 야근수당 bonus
private static int bonus; // 야근수당에 bonus가 추가된다
SpecialArmy(String name, int age, String grade, String strDt, String endDt, int bonus){
super(name, age, grade, strDt, endDt);
this.bonus = bonus;
}
public int getBonus() {
return bonus;
}
public void setBonus(int bonus) {
this.bonus = bonus;
}
}
public class 실습7일차 {
public static void main(String[] args) throws ParseException {
Army ar = new Army("이수원", 50, "중령", "19800101", "20200101");
Army[] sub = new Army[4];
sub[0] = new Army("홍길동", 24, "병장", "20190101", "20201231");
sub[1] = new Army("김형도", 23, "상병", "20110101", "20130101");
sub[2] = new Army("김병식", 22, "일병", "20120101", "20140101");
SpecialArmy as = new SpecialArmy("김길동", 20, "상병", "20180101", "20210531", 500000);
sub[3] = as;
ar.returnSub(sub);
ar.getOverTimePayByClass();
ar.printSubOverTimePay(sub);
ar.getThisMMPeriod();
ar.printSub(sub);
// ar.getSubTotalPeriod();
// ar.checkSub();
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListEx1 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList(10);
list1.add(new Integer(5));
list1.add(new Integer(4));
list1.add(new Integer(2));
list1.add(new Integer(0));
list1.add(new Integer(1));
list1.add(new Integer(3));
ArrayList list2 = new ArrayList(list1.subList(1, 4));
print(list1, list2);
//list1 : [5, 4, 2, 0, 1, 3]
//list2 : [4, 2, 0]
Collections.sort(list1); //list1과 list2를 정렬한다.
Collections.sort(list2); // Collections.sort(List l)
print(list1, list2);
// list1 : [0, 1, 2, 3, 4, 5]
// list2 : [0, 2, 4]
System.out.println("list1.containsAll(list2):" + list1.containsAll(list2)); // true
list2.add("B");
list2.add("C");
list2.add(3, "A");
print(list1, list2);
// list1 : [0, 1, 2, 3, 4, 5]
// list2 : [0, 2, 4, A, B, C]
list2.set(3, "AA");
print(list1, list2);
// list1 : [0, 1, 2, 3, 4, 5]
// list2 : [0, 2, 4, AA, B, C]
//list1에서 list2와 겹치는 부분만 남기고 나머지는 삭제한다.
System.out.println("list1.retainAll(list2): " + list1.retainAll(list2)); // true
print(list1, list2);
// list1 : [0, 2, 4]
// list2 : [0, 2, 4, AA, B, C]
//list2에서 list1에 포함된 객체들을 삭제한다.
for(int i=list2.size()-1; i>=0; i--) {
if(list1.contains(list2.get(i)))
list2.remove(i);
}
print(list1, list2);
// list1 : [0, 2, 4]
// list2 : [AA, B, C]
} // main의 끝
static void print(ArrayList list1, ArrayList list2) {
System.out.println("list1 : " + list1);
System.out.println("list2 : " + list2);
System.out.println();
}
} // class
--------------------------------------------------------------------------
package Week02.day0717;
import java.awt.List;
import java.util.ArrayList;
public class ArrayListEx2 {
public static void main(String[] args) {
final int LIMIT = 10; // 자르고자 하는 글자의 개수를 지정한다.
String source = "0123456789abcdefghijABCDEFGHIJ@#$%^&*()ZZZ";
int length = source.length();
ArrayList list = new ArrayList(length/LIMIT + 10); // 크기를 약간 여유 있게 잡는다.
for(int i=0; i<length; i+=LIMIT) {
if(i+LIMIT < length)
list.add(source.substring(i, i+LIMIT));
else
list.add(source.substring(i));
}
for(int i=0; i<list.size(); i++) {
System.out.println(list.get(i));
}
/*0123456789
abcdefghij
ABCDEFGHIJ
@#$%^&*()Z
ZZ
*/
}// main()
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListEx3 {
public static void main(String[] args) {
ArrayList a = new ArrayList();
Book3 b1 = new Book3("CC");
Book3 b2 = new Book3("AA");
Book3 b3 = new Book3("BB");
a.add(b1); a.add(b2); a.add(b3);
Collections.sort(a); //sort없이 출력하면 순서대로 찍힘. 그리고 compareTo를 쓰기때문에 오류남.
System.out.println(a); // [AA, BB, CC]
}
}
class Book3 implements Comparable{ // Comparable : 별도기준 x, Comparator : 별도기준O
private String title;
public Book3(String t) {title=t;}
public String getTitle() {return title;}
public String toString() {return title;}
public int compareTo(Object obj) { // compareTo 재정의.
Book3 book = (Book3)obj;
return title.compareTo(book.getTitle());
}
}
--------------------------------------------------------------------------
package Week02.day0717;
public class LinkedListEx1 {
public static void main(String[] args) {
//LinkedList 구조. 많이 사용됨. 다른 프로그래밍에서도 기초지식이 됨. 이해잘해놓을 것.
LinkedList list = new LinkedList();
System.out.println("(1) 공백 리스트에 노드 3개 삽입하기");
list.insertLastNode("월");
list.insertLastNode("수");
list.insertLastNode("일");
list.printList(); // [월 수 일]
System.out.println("(2) \"수\"노드 뒤에 \"금\" 노드 삽입하기");
ListNode pre = list.searchNode("수");
if(pre==null) {
System.out.println("검색 실패 >> 찾는 데이터가 없습니다.");
} else {
list.insertMiddleNode(pre, "금");
}
list.printList(); // [월 수 금 일]
System.out.println("(3) 리스트의 첫번째에 노드 추가하기");
list.insertFirstNode("토");
list.printList(); // [토 월 수 금 일]
System.out.println("(4) 리스트의 마지막 노드 삭제하기");
list.deleteLastNode();
list.printList(); // [토 월 수 금]
System.out.println("(5) 리스트의 중간 노드 \"수\" 삭제하기");
list.deleteMiddleNode("수");
list.printList(); // [토 월 금]
System.out.println("(6) 리스트의 첫번째 노드 삭제하기");
list.deleteFirstNode();
list.printList(); // [월 금]
System.out.println("(7) 리스트의 역순으로 출력하기");
list.reverseList();
list.printList(); // [금 월]
}
}
class ListNode{
String data;
ListNode next;
public ListNode() { // 정보를 가지고 있는애.
this.data = null;
this.next = null;
}
public ListNode(String data) {
this.data = data;
this.next = null;
}
public ListNode(String data, ListNode next) {
this.data = data;
this.next = next;
this.next = null;
}
public String getData() {
return this.data;
}
}
class LinkedList{
private ListNode head;
public LinkedList() { // 컨트롤 하는애. 시작점을 가지고 있고, 연결만 해줌.
this.head = null;
}
void insertLastNode(String str) {
ListNode node = new ListNode(str);
if(head == null) {
head = node;
} else {
ListNode current = head;
while(current.next != null) {
current = current.next;
}
current.next = node;
}
}
void insertMiddleNode(ListNode pre, String str) {
ListNode node = new ListNode(str);
if(head == null) {
head = node;
} else {
ListNode current = head;
while(current.next != pre) {
current = current.next;
}
current = current.next;
node.next = current.next;
current.next = node;
}
}
void insertFirstNode(String str) {
ListNode node = new ListNode(str);
if(head == null) {
head = node;
} else {
ListNode current = head;
node.next = current;
head = node;
}
}
void deleteLastNode() {
if(head == null) {
System.out.println("지울 노드가 존재하지 않습니다.");
} else {
ListNode prev = head;
ListNode current = head;
while(current.next != null) {
prev = current;
current = current.next;
}
prev.next = null;
}
}
void deleteMiddleNode(String str) {
ListNode node = new ListNode(str);
if(head == null) {
System.out.println("지울 노드가 존재하지 않습니다.");
} else {
ListNode prev = head;
ListNode current = head.next;
while(current.data != node.data) {
prev = current;
current = current.next;
}
prev.next = current.next;
}
}
void deleteFirstNode() {
if(head == null) {
System.out.println("지울 노드가 존재하지 않습니다.");
} else {
head = head.next;
}
}
ListNode searchNode(String str) {
ListNode node = new ListNode(str);
if(head == null) {
System.out.println("노드가 비어있습니다.");
return null;
} else {
ListNode current = head;
while(current.data != node.data) {
current = current.next;
}
return current;
}
}
void reverseList() {
ListNode next = head;
ListNode current = null;
ListNode prev = null;
while(next != null) {
prev = current;
current = next;
next = next.next;
current.next = prev;
}
head = current;
}
void printList() {
if(head == null) {
System.out.println("출력할 리스트가 존재하지 않습니다.");
} else {
ListNode current = head;
System.out.print("[");
while(current.next != null) {
System.out.print(current.data + " ");
current = current.next;
}
System.out.print(current.data);
System.out.print("]");
System.out.println();
}
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class StackQueueEx {
public static void main(String[] args) {
Stack st = new Stack();
Queue q = new LinkedList(); // Queue인터페이스의 구현체인 LinkedList를 사용
st.push("0");
st.push("1");
st.push("2");
q.offer("0");
q.offer("1");
q.offer("2");
System.out.println("=Stack=");
while(!st.empty()) { //empty : stack 이 콜렉션 나오기전 자료구조라 empty를 씀.
System.out.println(st.pop());
}
System.out.println("=Queue=");
while(!q.isEmpty()){ //isEmpty
System.out.println(q.poll());
}
}
//출력값.
/*=Stack=
2
1
0
=Queue=
0
1
2
*/
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorEx2 {
public static void main(String[] args) {
ArrayList original = new ArrayList(10);
ArrayList copy1 = new ArrayList(10);
ArrayList copy2 = new ArrayList(10); // 앞으로 과제할대 arraylist 써라.
for(int i=0; i<10; i++) {
original.add(i+"");
Iterator it = original.iterator();
while(it.hasNext()) //데이터가 있니?
copy1.add(it.next()); //데이터를 가져와라.
System.out.println("=Original에서 copy1로 복사(copy) = ");
System.out.println("original: " +original);
System.out.println("copy1:" + copy1);
System.out.println();
it = original.iterator(); //Iterator는 재사용이 안되므로, 다시 얻어와야 한다.
while(it.hasNext()) {
copy2.add(it.next());
it.remove();
}
System.out.println("=Original에서 copy2로 이동(move) = ");
System.out.println("origianl: " + original);
System.out.println("copy2: " + copy2);
System.out.println();
} //main
//출력값.
/*=Original에서 copy1로 복사(copy) =
original: [0]
copy1:[0]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0]
=Original에서 copy1로 복사(copy) =
original: [1]
copy1:[0, 1]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1]
=Original에서 copy1로 복사(copy) =
original: [2]
copy1:[0, 1, 2]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2]
=Original에서 copy1로 복사(copy) =
original: [3]
copy1:[0, 1, 2, 3]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2, 3]
=Original에서 copy1로 복사(copy) =
original: [4]
copy1:[0, 1, 2, 3, 4]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2, 3, 4]
=Original에서 copy1로 복사(copy) =
original: [5]
copy1:[0, 1, 2, 3, 4, 5]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2, 3, 4, 5]
=Original에서 copy1로 복사(copy) =
original: [6]
copy1:[0, 1, 2, 3, 4, 5, 6]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6]
=Original에서 copy1로 복사(copy) =
original: [7]
copy1:[0, 1, 2, 3, 4, 5, 6, 7]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6, 7]
=Original에서 copy1로 복사(copy) =
original: [8]
copy1:[0, 1, 2, 3, 4, 5, 6, 7, 8]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6, 7, 8]
=Original에서 copy1로 복사(copy) =
original: [9]
copy1:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
=Original에서 copy2로 이동(move) =
origianl: []
copy2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
*
*/
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.ArrayList;
import java.util.ListIterator;
public class ListIteratorEx1 {
public static void main(String[] args) {
ArrayList list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
list.add("4");
list.add("5");
ListIterator it = list.listIterator();
while(it.hasNext()) {
System.out.println(it.next()); // 순방향으로 진행하면서 읽어온다. 1 2 3 4 5
}
System.out.println();
while(it.hasPrevious()) {
System.out.println(it.previous()); // 역방향으로 진행하면서 읽어온다. 5 4 3 2 1
}
System.out.println();
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ArraysExTest {
public static void main(String[] args) {
//Arrays : 배열을 다루는데 유용한 메소드 정의
/*1. copyof(arr, 갯수) : 배열전체 복사
* copyOfRanghe(arr, sPos, ePos) : 배열부분복사, sPos<=x<ePos
*/
int[] arr = {0, 1, 2, 3, 4};
int[] arr2 = Arrays.copyOf(arr, arr.length); // 갯수만큼 복사
int[] arr3 = Arrays.copyOfRange(arr2, 2, 4); // 2,3
/*2. fill(arr, value) : value로 배열 채움
*/
int[] arr4 = new int[5];
Arrays.fill(arr4, 9); //9,9,9,9,9
/*3. sort(arr) : 정렬
* binarySearch(arr,value) : 지정요소 검색
* 정렬을 해야만 올바른 결과
*/
int[] arr5 = {3, 2, 0, 1, 4};
Arrays.sort(arr5); // 0,1,2,3,4
int idx = Arrays.binarySearch(arr5, 2);
System.out.println(idx); //2
/*4. equals(arr, arr2): 모든요소비교
* toString(): 모든요소출력, 1차원만
* deepToString(): 다차원배열 출력
*/
int[] arr6 = {0, 1, 2, 3, 4};
int[][] arr7 = {{11,12}, {21,22}};
System.out.println(Arrays.toString(arr6)); // [0, 1, 2, 3, 4]
System.out.println(Arrays.deepToString(arr7)); // [[11, 12], [21, 22]]
/*5. asList(Object... a)
* 배열을 List로 변환
*/
//변경만 가능하고 추가/삭제가 불가능한 List반환
List list = Arrays.asList(new Integer[] {1,2,3,4,5});
//추가/삭제 가능하게 하려면 아래처럼
List list2 = new ArrayList(Arrays.asList(1,2,3,4,5));
System.out.println(list); // [1, 2, 3, 4, 5]
System.out.println(list2); // [1, 2, 3, 4, 5]
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.Arrays;
import java.util.Comparator;
public class ComparatorEx {
public static void main(String[] args) {
String[] strArr = {"cat", "Dog", "lion", "tiger"};
Arrays.sort(strArr); //String의 Comparable구현에 의한 정렬
System.out.println("strArr=" + Arrays.toString(strArr)); // strArr=[Dog, cat, lion, tiger]
Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER); // 대소문자 구분안함
System.out.println("strArr=" + Arrays.toString(strArr)); // strArr=[cat, Dog, lion, tiger]
Arrays.sort(strArr, new Descending());
System.out.println("strArr=" + Arrays.toString(strArr)); // strArr=[tiger, lion, cat, Dog]
}
}
class Descending implements Comparator{
public int compare(Object o1, Object o2) {
if(o1 instanceof Comparable && o2 instanceof Comparable) {
Comparable c1 = (Comparable)o1;
Comparable c2 = (Comparable)o2;
return c1.compareTo(c2)*-1; // -1을 곱해서 기본 정렬방식의 역으로 변경한다.
// 또는 c2.compareTo(c1)와 같이 순서를 바꿔도 된다.
}
return -1;
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.HashSet;
import java.util.Set;
public class HashSetEx1 {
public static void main(String[] args) {
Object[] objArr = {"1", new Integer(1),"2", "2", "3", "3", "4", "4", "4"};
Set set = new HashSet();
for(int i=0; i<objArr.length; i++) {
set.add(objArr[i]); //HashSet에 objArr의 요소들을 저장한다.
}
// HashSet에 저장된 요소들을 출력한다.
System.out.println(set); // [1, 1, 2, 3, 4]
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.LinkedList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class HashSetLotto {
public static void main(String[] args) {
//로또번호 출력.
Set set = new HashSet();
for(int i=0; set.size()<6; i++) {
int num = (int)(Math.random()*45)+1;
set.add(new Integer(num));
}
List list = new LinkedList(set); // LinkedList(Collection c)
Collections.sort(list); // Collections.sort(List list)
System.out.println(list);
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.HashSet;
import java.util.Objects;
public class HashSetEx4 {
public static void main(String[] args) {
HashSet set = new HashSet();
set.add(new String("abc"));
set.add(new String("abc"));
set.add(new Person2("David", 10));
set.add(new Person2("David", 10));
System.out.println(set); // [David:10, abc]
}
}
//Equals와 hashCode를 하나라도 재정의하지 않으면 중복저장됨.
class Person2{
String name;
int age;
Person2(String name, int age){
this.name = name;
this.age = age;
}
public boolean equals(Object obj) { // ★★★ 없으면 중복저장됨.
if(obj instanceof Person2) {
Person2 tmp = (Person2)obj;
return name.equals(tmp.name) && age == tmp.age;
}
return false;
}
public int hashCode() {
return Objects.hash(name, age); // 속성값을 넣으면 유일한 hash값을 리턴. ★★★ 없으면 중복저장됨.
}
public String toString() {
return name + ":" + age;
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.Comparator;
import java.util.SortedSet;
import java.util.TreeSet;
public class TreeSetTest {
public static void main(String[] args) {
/*TreeSet원소는 반드시 Comparable이어야 한다.
* TreeSet사용하려면 집합에 들어가는 원소가 comparable을 구현하는 유형이어야 한다.
* Comparator를 인자로 받아 들이는 Treeset의 오버로드된 생성자를 사용
*/
new TreeSetTest().go();
}
public void go() {
//Comparable 이용
Book b1 = new Book("How Cats Work");
Book b2 = new Book("Remix your Body");
Book b3 = new Book("Finding Emo");
TreeSet tree = new TreeSet();
tree.add(b1);
tree.add(b2);
tree.add(b3);
//정렬되어 조회된다.
System.out.println("1 : " + tree); // 1 : [Finding Emo, How Cats Work, Remix your Body]
//Comparator이용
Book2 t1 = new Book2("How Cats Work");
Book2 t2 = new Book2("Remix your Body");
Book2 t3 = new Book2("Finding Emo");
TreeSet tree2 = new TreeSet(new BookCompare()); // Comparator를 설정.
tree2.add(t1);
tree2.add(t2);
tree2.add(t3);
//정렬되어 조회된다.
System.out.println("2 : "+ tree2); // 2 : [Finding Emo, How Cats Work, Remix your Body]
//첫번째 값 조회
System.out.println("3 : "+ tree2.first()); // 3 : Finding Emo
//마지막값 조회
System.out.println("4 : "+ tree2.last()); // 4 : Remix your Body
//삭제
System.out.println("5 : " + tree2.remove(new Book2("Finding Emo"))); // 5 : true
System.out.println("6 : " + tree2); // 6 : [How Cats Work, Remix your Body]
tree2.add(t3);
//인자보다 값이 작은 항목들의 집함
SortedSet ss = tree2.headSet(new Book2("Remix your Body"));
System.out.println("7 : " + ss); // 7 : [Finding Emo, How Cats Work]
//인자보다 값이 크거나 같은 항목들의 집합
SortedSet ss2 = tree2.tailSet(new Book2("Finding Emo"));
System.out.println("8 : " + ss2); // 8 : [Finding Emo, How Cats Work, Remix your Body]
// subSet(a,b) a이상 ~ b미만 인 집함
SortedSet ss3 = tree2.subSet(new Book2("Finding Emo"), new Book2("Remix your Body"));
System.out.println("9 : " + ss3); // 9 : [Finding Emo, How Cats Work]
TreeSet tree3 = (TreeSet) tree2.clone();
System.out.println("10 : " + tree3); // 10 : [Finding Emo, How Cats Work, Remix your Body]
}
}
class Book implements Comparable{
private String title;
public Book(String t) {
title = t;
}
public String getTitle() {
return title;
}
public String toString() {
return title;
}
public int compareTo(Object obj) {
Book book = (Book)obj;
return title.compareTo(book.getTitle());
}
}
class Book2{
private String title;
public Book2(String t) {
title = t;
}
public String getTitle() {
return title;
}
public String toString() {
return title;
}
}
//Comparator에 equals메소드도 존재하지만 재정의하라고 안뜨는건
//Object class에 equals메소드가 구현되어 있기 때문
class BookCompare implements Comparator{
public int compare(Object arg0, Object arg1) {
return ((Book2)arg0).getTitle().compareTo(((Book2)arg1).getTitle());
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapEx2 {
public static void main(String[] args) {
HashMap map = new HashMap();
map.put("김자바", new Integer(90));
map.put("김자바", new Integer(100));
map.put("이자바", new Integer(100));
map.put("강자바", new Integer(80));
map.put("안자바", new Integer(90));
Set set = map.entrySet(); //map entry타입의 콜렉션들을 set형태로 리턴.(set은 유일성을 만족)
Iterator it = set.iterator();
while(it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
System.out.println("이름 : " + e.getKey() +", 점수 : " + e.getValue()); //map에는 key와 value가 있다.(map의 기본속성)
/*이름 : 안자바, 점수 : 90
이름 : 김자바, 점수 : 100
이름 : 강자바, 점수 : 80
이름 : 이자바, 점수 : 100
*/
}
set = map.keySet(); // key만 리턴. 중복불가.
System.out.println("참가자 명단 : " + set); // 참가자 명단 : [안자바, 김자바, 강자바, 이자바]
Collection values = map.values(); // values만 리턴. 중복가능
it = values.iterator();
int total = 0;
while(it.hasNext()) {
Integer i = (Integer)it.next();
total+= i.intValue();
}
System.out.println("총점 : " + total); // 총점 : 370
System.out.println("평균 : " + (float)total/set.size()); // 평균 : 92.5
System.out.println("최고점수 : " + Collections.max(values)); // 최고점수 : 100
System.out.println("최저점수 : " + Collections.min(values)); // 최저점수 : 80
}
}
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class HashMapEx3 {
static HashMap phoneBook = new HashMap();
public static void main(String[] args) {
addPhoneNo("친구", "이자바", "010-111-1111");
addPhoneNo("친구", "김자바", "010-211-1111");
addPhoneNo("친구", "박자바", "010-311-1111");
addPhoneNo("회사", "김대리", "010-411-1111");
addPhoneNo("회사", "이대리", "010-511-1111");
addPhoneNo("회사", "박대리", "010-611-1111");
addPhoneNo("회사", "이과장", "010-711-1111");
addPhoneNo("세탁", "010-811-1111");
printList();
} // main
//그룹을 추가하는 메소드
static void addGroup(String groupName) {
if(!phoneBook.containsKey(groupName))
phoneBook.put(groupName, new HashMap()); // value에 hashmap을 넣음.
}
//그룹에 전화번호를 추가하는 메소드
static void addPhoneNo(String groupName, String name, String tel) {
addGroup(groupName);
HashMap group = (HashMap)phoneBook.get(groupName);
group.put(tel, name); //이름은 중복될수 있으니 전화번호를 key로 저장한다.
}
static void addPhoneNo(String name, String tel) {
addPhoneNo("기타", name, tel);
}
//전화번호부 전체를 출력하는 메소드
static void printList() {
Set set = phoneBook.entrySet();
Iterator it = set.iterator();
while(it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
Set subSet = ((HashMap)e.getValue()).entrySet();
Iterator subIt = subSet.iterator();
System.out.println(" * " + e.getKey()+ "[" + subSet.size()+"]");
while(subIt.hasNext()) {
Map.Entry subE = (Map.Entry)subIt.next();
String telNo = (String)subE.getKey();
String name = (String)subE.getValue();
System.out.println(name = " " + telNo);
}
System.out.println();
}
} //prinList()
} // class
//출력값
/* 기타[1]
010-811-1111
* 친구[3]
010-111-1111
010-211-1111
010-311-1111
* 회사[4]
010-611-1111
010-511-1111
010-711-1111
010-411-1111
*/
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
public class HashMapEx4 {
public static void main(String[] args) {
String[] data = {"A", "K", "A", "K", "D", "K", "A", "K", "K", "K", "Z", "D"};
HashMap map = new HashMap();
for(int i=0; i<data.length; i++) {
if(map.containsKey(data[i])) {
Integer value = (Integer)map.get(data[i]);
map.put(data[i], new Integer(value.intValue() + 1));
} else {
map.put(data[i], new Integer(1));
}
}
Iterator it = map.entrySet().iterator();
while(it.hasNext()) {
Map.Entry entry = (Map.Entry)it.next();
int value = ((Integer)entry.getValue()).intValue();
System.out.println(entry.getKey() + ": " + printBar('#', value) + " " + value);
}
}// main
public static String printBar(char ch, int value) {
char[] bar = new char[value];
for(int i=0; i<bar.length; i++) {
bar[i] = ch;
}
return new String(bar); //String(char[] chArr)
}
}
/*출력값
* A: ### 3
D: ## 2
Z: # 1
K: ###### 6
*/
--------------------------------------------------------------------------
package Week02.day0717;
import java.util.HashSet;
public class SetTest {
public static void main(String[] args) {
HashSet set1 = new HashSet();
set1.add("phone");
set1.add("banana");
System.out.println(set1.add("apple")); // true
System.out.println("set1: " + set1); // set1: [banana, apple, phone]
System.out.println("contains: " + set1.contains("apple")); // contains: true
//추가, 삭제
HashSet set2 = (HashSet)set1.clone();
set2.add("melon");
set2.remove("apple");
System.out.println("set2 : " + set2); // set2 : [banana, melon, phone]
//합집합, Collection Add, 중복되지 않게 set2의 내용을 result에 add시킨다.
HashSet result = (HashSet)set1.clone();
result.addAll(set2);
System.out.println("addAll : " + result); // addAll : [banana, apple, melon, phone]
// 교집합, result값들 중 set2에 있는 값만 남긴다.
result = (HashSet)set1.clone();
System.out.println("result : " + result); // result : [banana, apple, phone]
result.retainAll(set2);
System.out.println("retainsAll : " + result); // retainsAll : [banana, phone]
//차집합, result값들 중 set2에 있는 값을 제거한다.
result = (HashSet)set1.clone();
result.removeAll(set2);
System.out.println("removeAll : " + result); // removeAll : [apple]
}
}
'Java' 카테고리의 다른 글
| Java - Thread(싱글, 다중(멀티), 스위칭), 동기화 (0) | 2019.07.19 |
|---|---|
| Java - 제네릭스, Wildcard, 열거형, Thread (0) | 2019.07.18 |
| Java - Format, java.sql.date, StringTokenizer, Calendar, Class, Reflection (0) | 2019.07.16 |
| Java - 자료구조(Collection), Random, Wrapper (0) | 2019.07.15 |
| Java - 다형성, 상속, 예외 (0) | 2019.07.12 |
Java - Format, java.sql.date, StringTokenizer, Calendar, Class, Reflection
| Java 2019. 7. 16. 11:23
package Week02.day0716;
import java.util.Arrays;
abstract class Project{
private String name;
private String startDt;
private String endDt;
private String location;
private Developer[] dev; // 사이즈 초기값을 정해놓고 시작하는게 좋다.(실무에서도 보통 그러함)
private int count;
Project(String name, String startDt, String endDt, String location){ // 초기세팅 개발자 안 들어가있는 프로젝트
this.name = name;
this.startDt = startDt;
this.endDt = endDt;
this.location = location;
}
Project(String name, String startDt, String endDt, String location, Developer[] dev){ // 초기세팅 개발자 들어가있는 프로젝트
this.name = name;
this.startDt = startDt;
this.endDt = endDt;
this.location = location;
this.dev = dev;
}
public Project(String name, int period) {
// TODO Auto-generated constructor stub
}
public void process() { // 모든 Project는다음의 4가지 과정을 거치게 된다 plan(),join(), design(), develop()
plan();
design();
develop();
}
public void plan() { // “Project 준비” 출력
System.out.println("Project준비");
}
public void join(Developer[] d) { // Proejct에 개발자 Add(추가로 조인시키는 방법)
this.dev = d;
count++; // 예외처리해주는게 좋음.
}
public abstract void design(); // “설계작업수행” 출력
public abstract void develop(); // “개발작업수행” 출력
public int getPeriod() { // Project 기간 리턴
int endDt1 = Integer.parseInt(endDt);
int startDt1 = Integer.parseInt(startDt);
int period = endDt1 - startDt1;
return period;
}
public void getMMByDeveloper() { // Project에 참여한 개발자의 총 월간 개월수
int sum =0;
for(int i=0; i<dev.length; i++) {
sum+=dev[i].getPeriod();
}
System.out.println("Project에 참여한 개발자들의 총 월간 개월수는 = " + sum + "개월 입니다.");
// System.out.println("참여상황 = 개발자 : " + Arrays.toString(dev) + ", 총 개월수 : "+ (dev.length*(Integer.parseInt(endDt)-Integer.parseInt(startDt))));
// dev.length 대신 this.count 로 써도됨?
}
public void printDeveloper() {
for(int i=0; i<dev.length; i++) {
if(dev[i]!=null && dev[i] instanceof HighDeveloper)
System.out.println("고급개발자 " + dev[i].getName() + "/ 특기 " + ((HighDeveloper)dev[i]).getSpecialSkill()); // (HighDeveloper)로 변환한뒤 가져와야함.
else
System.out.println("일반개발자 " + dev[i].getName());
}
// System.out.println(dev[i] instanceof HighDeveloper? "고급개발자":"일반개발자");
// System.out.println(dev[i].getName());
// System.out.println(dev[i] instanceof HighDeveloper? "자바개발":" ");
}
}
class HrProject extends Project{
HrProject(String name, String startDt, String endDt, String location) {
super(name, startDt, endDt, location);
// TODO Auto-generated constructor stub
}
public void design() { // “HR 설계작업수행” 출력
System.out.println("HR 설계작업 수행");
}
public void develop() { // “HR 개발작업수행” 출력
System.out.println("HR 개발작업 수행");
}
}
class Developer{
private String name;
private int period;
public Developer(String name, int period) {
this.name = name;
this.period = period;
}
public String getName() {
return name;
}
public int getPeriod() {
return period;
}
public void setName(String name) {
this.name = name;
}
public void setPeriod(int period) {
this.period = period;
}
}
class HighDeveloper extends Developer{
private String specialSkill; // HighDeveloper만의 속성
HighDeveloper(String name, int period, String specialSkill){
super(name, period);
this.specialSkill = specialSkill;
}
String getSpecialSkill() {
return specialSkill;
}
void setSpecialSkill(String specialSkill) {
this.specialSkill = specialSkill;
}
}
public class 실습6일차 {
public static void main(String[] args) {
HrProject hr = new HrProject("사람인HR시스템구축", "20190716", "20190816", "서울");
Developer[] dev = new Developer[3];
dev[0] = new Developer("홍길동", 12);
dev[1] = new Developer("김길동", 24);
HighDeveloper dev2 = new HighDeveloper("김고급", 36, "java");
dev[2] = dev2;
hr.join(dev);
hr.process();
hr.getMMByDeveloper();
hr.printDeveloper();
}
}
--------------------------------------------------------------------------
package Week02.day0716;
import java.util.Arrays;
class CompanyMan{
private String name;
private int age;
private String[] hobby = new String[3]; //array가 있으면 count를 써라.
private Company nowCompany;
private Company[] hisCompany = new Company[3];
private int hobbyCnt;
private int hisCompanyCnt;
CompanyMan(String name, int age, Company nowCompany){
this.name = name;
this.age = age;
this.nowCompany = nowCompany;
}
public boolean setHobby(String hobby) { // 취미를 추가
int temp = hobbyCnt;
try {
this.hobby[this.hobbyCnt] = hobby;
hobbyCnt++;
} catch(Exception e) {
hobbyCnt = temp;
return false;
}
return true;
}
public boolean delHobby(String hobby) { // 취미를 삭제. 예외처리 사용할것. temp로 담았다가 실패하면 temp로 복귀.
int index = -1;
String[] temp = Arrays.copyOf(this.hobby, this.hobby.length);
try {
// 삭제할 취미가 있는 index구하기
for(int i=0; i<this.hobbyCnt; i++) {
if(this.hobby[i].equals(hobby)) {
index = i;
}
}
//삭제할 취미가 존재하지 않는 경우
if(index<0) {
return false;
}
//해당 index 제외하고 새로운 취미배열 만들기
for(int i=0; i<this.hobbyCnt; i++) {
if(i>=index) {
this.hobby[i] = this.hobby[i+1];
}
}
// 삭제대상 취미가 있는 경우 마지막 값 초기화
this.hobby[this.hobbyCnt-1]= null;
} catch(Exception e) {
this.hobby = temp;
return false;
}
this.hobbyCnt--;
return false;
}
public void setNowCompany(Company company) { // 현재 근무 회사등록. 현재근무회사가 변경되면 historyCompany에 이력을 추가
hisCompany[hisCompanyCnt] = this.nowCompany;
hisCompanyCnt++;
this.nowCompany = company;
}
public void printHobby() {
for(int i=0; i<this.hobbyCnt; i++) {
System.out.println(hobby[i]);
}
}
public void printHistoryCompany() {
for(int i=0; i<this.hisCompanyCnt; i++) {
System.out.println(hisCompany[i].getName());
}
}
}
class Company{
private String name;
private int period;
Company(String name, int period){
this.name = name;
this.period = period;
}
Company(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getPeriod() {
return period;
}
public void setPeriod(int period) {
this.period = period;
}
}
public class 실습6일차_2 {
public static void main(String[] args) {
CompanyMan cm = new CompanyMan("홍길동", 32, new Company("비트교육센터"));
cm.setHobby("바둑");
cm.setHobby("조깅");
cm.printHobby();
System.out.println("============================");
cm.delHobby("조깅");
cm.printHobby();
System.out.println("============================");
cm.setNowCompany(new Company("LG전자"));
cm.printHistoryCompany();
}
}
--------------------------------------------------------------------------
package Week02.day0716;
import java.util.StringTokenizer;
public class StringTokenizerTest {
public static void main(String[] args) {
StringTokenizer st = new StringTokenizer("This \t is a \n String");
while(st.hasMoreTokens())
System.out.println(st.nextToken());
System.out.println("==========================================");
//인자로 주어진 문자열을 :을 구분자로서 구분한다.
String str = "80::95::70";
StringTokenizer st2 = new StringTokenizer(str, ":", false);
int i = 0;
while(st2.hasMoreTokens()) {
System.out.println(i+":"+st2.nextToken());
i++;
}
System.out.println("==========================================");
//StringTokenizer 는 구분자끼리 붙어 있는 경우 위와 같이 구분을 하지 못하는 문제가 있다.
String[] result = str.split(":"); //배열은 오류가능성 내포. index로 접근하므로 split을 써야함.
for(int x = 0; x<result.length;x++) {
System.out.println(x+":"+result[x]);
}
System.out.println("==========================================");
//하지만 split도 마지막에 구분자가 있을 땐 이를 처리하지 못함-> 2개의 인자를 받는 split사용
String str2 = "81-2-010-1234-5678";
String[] arr2 = str2.split("-", 4);
for(int x=0; x<arr2.length; x++) {
System.out.println(x+":"+arr2[x]);
}
}
}
--------------------------------------------------------------------------
package Week02.day0716;
import java.text.ChoiceFormat;
import java.text.DecimalFormat;
import java.text.MessageFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class FormatTest {
public static void main(String[] args) {
// DecimlaFormat : 숫자 형식화
DecimalFormat df2 = new DecimalFormat("#,###,##");
System.out.println(df2.format(123456789.98)); // 1,23,45,67,90
DecimalFormat df3 = new DecimalFormat("#,###");
System.out.println(df2.format(123456789)); // 1,23,45,67,89
//SimpleDateFormat : 날짜 형식화
Date today = new Date();
SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss a");
System.out.println(sdf4.format(today)); // 2019-07-16 04:26:49 오후
//ChoiceFormat : 특정범위를 문자열로 변환
//# : 경계값 포함(작거나 같다), <은 경계값 미포함
String pattern = "60#D|70#|80<B|90#A"; //90은 A, 80은 C
int [] scores = {91, 90, 80, 88, 70, 52, 60};
ChoiceFormat form = new ChoiceFormat(pattern);
for(int i=0; i<scores.length; i++) {
System.out.println(scores[i] + "form.format(scores[i]))"); // 91form.format(scores[i]))
}
//MessageFormat - 많이 쓰임.
String msg = "Name: {0} \nTel: {1} \nAge: {2} \nBirthday:{3}";
Object[] arguments = {"이자바", "02-123-1234", "27", "07-09"};
String result = MessageFormat.format(msg, arguments);
System.out.println(result);
/*Name: 이자바
Tel: 02-123-1234
Age: 27
Birthday:07-09
*
*/
}
}
--------------------------------------------------------------------------
package Week02.day0716;
import java.sql.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class JavaSqlDateTest {
public static void main(String args[]) throws ParseException {
//java.util.Date : 오라클 날짜 타입과 연동불가
//java.sql.Date : 오라클 날짜타입과 연동가능 -> 대부분의 회사에서 많이 쓰임.
//String->java.sql.Daste 변환
String day = "2016-11-22"; //형식을 지켜야 함
java.sql.Date d = java.sql.Date.valueOf(day);
System.out.println(d); // 2016-11-22
//String -> java.sql.Timestamp 변환
String day2 = "2016-11-22 11:22:30.0"; // 형식을 지켜야 함.
java.sql.Timestamp t = java.sql.Timestamp.valueOf(day2);
System.out.println(t); // 2016-11-22 11:22:30.0
//String -> java.util.Date 변환
String day3 = "20161122"; // SimpleDateFormat 생성자에 전달되는 형식과 일치해야함
java.util.Date d2 = new java.text.SimpleDateFormat("yyyyMMdd").parse(day3);
System.out.println(d2); // Tue Nov 22 00:00:00 KST 2016
//java.util.Date -> java.sql.Date 변환
java.util.Date u = new java.util.Date();
java.sql.Date s = new java.sql.Date(u.getTime());
System.out.println(u); // Tue Jul 16 16:37:32 KST 2019
System.out.println(s); // 2019-07-16
}
public Date transformDate(String date) {
//날짜가 yyyymmdd 형식으로 입력되었을 경우 Date로 변경하는 메소드
SimpleDateFormat beforeFormat = new SimpleDateFormat("yyyymmdd");
//Date로 변경하기 위해서는 날짜 형식을 yyyy-mm-dd로 변경해야 한다,
SimpleDateFormat afterFormat = new SimpleDateFormat("yyyy-mm-dd");
java.util.Date tempDate = null;
try {
//현재 yyyymmdd로 된 날짜형식으로 java.util.Date객체를 만든다.
tempDate = beforeFormat.parse(date);
} catch (ParseException e) {
e.printStackTrace();
}
//java.util.Date를 yyyy-mm-dd 형식으로 변경하여 String로 반환한다.
String transDate = afterFormat.format(tempDate);
//반환된 String 값을 Date로 변경한다.
Date d3 = Date.valueOf(transDate);
System.out.println(d3);
return d3;
}
}
--------------------------------------------------------------------------
package Week02.day0716;
import java.util.Calendar;
public class CalendarEx4 {
public static void main(String[] args) {
Calendar date = Calendar.getInstance(); // Singleton(힙에 자신의 인스턴스는 1개만 존재하도록 해놓은 규칙.)
date.set(2005, 7, 31); // 2005년 8월 31일
System.out.println(toString(date)); // 2005년8월31일
System.out.println("= 1일 후 =");
date.add(Calendar.DATE, 1);
System.out.println(toString(date)); // 2005년9월1일
System.out.println("= 6달 전 =");
date.add(Calendar.MONTH, -6);
System.out.println(toString(date)); // 2005년3월1일
System.out.println("= 31일 후(roll) =");
date.roll(Calendar.DATE, 31);
System.out.println(toString(date)); // 2005년3월1일
System.out.println("= 31일 후(add) =");
date.add(Calendar.DATE, 31);
System.out.println(toString(date)); // 2005년4월1일
}
public static String toString(Calendar date) {
return date.get(Calendar.YEAR)+"년"+(date.get(Calendar.MONTH)+1)+"월" + date.get(Calendar.DATE) + "일";
}
}
--------------------------------------------------------------------------
package Week02.day0716;
import java.util.Calendar;
public class CalendarEx5 {
public static void main(String[] args) {
//기본적으로 현재날짜와 시간으로 설정된다.
Calendar today = Calendar.getInstance();
System.out.println("이 해의 년도 : " + today.get(Calendar.YEAR));
System.out.println("월(0~11, 0:1월)" + today.get(Calendar.MONTH)); // month는 0부터 시작
System.out.println("이 해의 몇 째 주 : " + today.get(Calendar.WEEK_OF_YEAR));
System.out.println("이 달의 몇 째 주 : " + today.get(Calendar.WEEK_OF_MONTH));
//DATE와 DAY_OF_MONTH는 같다.
System.out.println("이 달의 몇 일 : " + today.get(Calendar.DATE));
System.out.println("이 달의 몇 일 : " + today.get(Calendar.DAY_OF_MONTH));
System.out.println("이 해의 몇 일 : " + today.get(Calendar.DAY_OF_YEAR));
// 1:일요일, 2:월요일,... 7:토요일
System.out.println("요일(1~7, 1:일요일) : " + today.get(Calendar.DAY_OF_WEEK));
System.out.println("이 달의 몇 째 요일 : " + today.get(Calendar.DAY_OF_WEEK_IN_MONTH));
System.out.println("오전_오후(0:오전, 1:오후): " + today.get(Calendar.AM_PM));
System.out.println("시간(0~11) : " + today.get(Calendar.HOUR));
System.out.println("시간(0~23) : " + today.get(Calendar.HOUR_OF_DAY));
System.out.println("분(0~59) : " + today.get(Calendar.MINUTE));
System.out.println("초(0~59) : " + today.get(Calendar.SECOND));
System.out.println("1000분의 1초(0~999): " + today.get(Calendar.MILLISECOND));
//천분의 1초를 시간으로 표시하기 위해 3600000으로 나누었다.(1시간 = 60*60초)
System.out.println("TimeZone(-12~+12) : " + (today.get(Calendar.ZONE_OFFSET)/(60*60*1000)));
//이 달의 마지막 일을 찾는다.
System.out.println("이 달의 마지막 날 : " + today.getActualMaximum(Calendar.DATE));
}
}
--------------------------------------------------------------------------
package Week02.day0716;
import java.util.Calendar;
public class CalendarEx6 {
public static void main(String[] args) {
//실무에서 많이 쓰임.
//년월 가져올때 캘린더 쓰임.
if(args.length!=2) {
System.out.println("Usage : java CalendarEx6 2015 9");
return;
}
int year = Integer.parseInt(args[0]);
int month = Integer.parseInt(args[1]);
int START_DAY_OF_WEEK = 0;
int END_DAY = 0;
Calendar sDay = Calendar.getInstance(); // 시작일
Calendar eDay = Calendar.getInstance(); // 끝일
//월의 경우 0부터 11까지의 값을 가지므로 1을 빼주어야 한다.
//예를 들어, 2004년 11월 1일은 sDay.set(2004, 10, 1):과 같이 해줘야 한다.
sDay.set(year, month-1, 1);
eDay.set(year, month, 1);
//다음달의 첫날에서 하루를 빼면 현재달의 마지막 날이 된다.
//12월 1일에서 하루를 빼면 11월 30일이 된다.
eDay.add(Calendar.DATE, -1);
//첫번째 요일이 무슨 요일인지 알아낸다.
START_DAY_OF_WEEK = sDay.get(Calendar.DAY_OF_WEEK);
//eDay에 지정된 날짜를 얻어온다.
END_DAY = eDay.get(Calendar.DATE);
System.out.println(" " + args[0] + "년" + args[1] + "월");
System.out.println(" SU MO TU WE TH FR SA ");
//해당월의 1일이 어느 요일인지에 따라서 공백을 출력한다.
//만일 1일이 수요일이라면 공백을 세번 찍는다.(일요일부터 시작)
for(int i=1; i<START_DAY_OF_WEEK; i++) {
System.out.print(" ");
}
for(int i=1, n=START_DAY_OF_WEEK; i<=END_DAY; i++, n++) {
System.out.print((i<10)? " " +i : " " +i);
if(n%7==0) System.out.println();
}
}
}
--------------------------------------------------------------------------
/* class */
1. class의 정보를 가지고 있는 클래스
2. Class.forName("java.util.Vector").newInstance(); // ★★★==> Vector V = new Vector(); 같은 문장! 문법이므로 꼭 기억할 것
- newInstance() 를 호출하게 되면 java.util.Vector의 인스턴스를 생성한 다음 기본 생성자를 호출
하여 인스턴스를 초기화하고 인스턴스를 리턴한다.
3. class 객체 얻는 방법
- class obj = new Card().getClass();
- class obj = Card.class;
- class obj = class.forName("card");
package Week02.day0716;
class A{
public int i;
public A() {
System.out.println("A 생성자");
}
public void m() {
System.out.println("A.m()");
}
}
class B extends A{
public B() {
System.out.println("B 생성자");
}
public void m() {
System.out.println("B.m()");
}
public void m2() {
System.out.println("B.m2()");
}
}
public class ClassTest {
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
A a = new B(); // Class 클래스의 인스턴스는 자바상에서 Class들을 표현한다.
Class c1 = a.getClass(); //Object의 runtime상의 class를 반환한다.
System.out.println("class name:" + c1.getName());
System.out.println("super class name : " + c1.getSuperclass());
// 새로운 instance를 생성한다.
B b = (B)(c1.newInstance());
b.m2(); //B라는 이름의 클래스 객체를 반환, package까지 표현
Class c2 = Class.forName("data.B"); // B instance를 A가 가르키로 override된 B.m()을 호출
((A)c2.newInstance()).m();
System.out.println("abc".getClass().getName());
}
}
--------------------------------------------------------------------------
/* Reflection */
1. framework에서 쓰임
2. Runtime에 클래스를 전달받아서 임의의 Method를 실행하는 시스템이 있다고 가정할때
이때 전달되는 파라미터, return 되는 파라미터 모두 개발당시에는 알지못한다고 한다면
그 클래스에 대한 정보를 제공하는 API가 Reflection API이다.
package Week02.day0716;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectTest {
public String str;
public ReflectTest(String str) {
this.str = str;
System.out.println("REFLECT 생성자호출 : " + str);
}
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
Class c = Class.forName("data.ReflectTest");
System.out.println(c); // class 명 출력
Constructor[] ctor = c.getConstructors(); // 생성자를 얻는다.
for(int i=0; i<ctor.length; i++) {
System.out.println("생성자 : " + ctor[i].toString());
}
Method m[] = c.getMethods(); // 메소드를 얻는다.
for(int i=0; i<m.length; i++) {
System.out.println("메소드 : " + m[i].toString());
}
//메소드 호출하기
Class c2 = Class.forName("data.ReflectTest");
//String 하나를 매개변수로 가지는 파라미터를 형식을 만든다.
Class[] parameterTypes = new Class[] {String.class};
//String을 인자로 받는 생성자에 접근하는 정보를 얻는다.
Constructor constructor = c2.getConstructor(parameterTypes);
//객체 생성
Object obj = constructor.newInstance(new Object[] {"REFLECT"});
//String 하나를 매개변수로 가지는 파라미터를 형식을 만든다.
Class[] parameterTypes2 = new Class[] {String.class};
//String을 인자로 받는 메소드에 접근하는 정보를 얻는다.
Method method = c2.getMethod("test01", parameterTypes2);
Object[] parameters = new Object[] {"메소드호출"};
//메소드를 호출한다.
Object oResult = method.invoke(obj, parameters);
}
public void test01(String paramStr) {
System.out.println("test01 메소드호출 : " + paramStr);
}
public void test02() {
}
}
'Java' 카테고리의 다른 글
| Java - 제네릭스, Wildcard, 열거형, Thread (0) | 2019.07.18 |
|---|---|
| Java - ArrayList, LinkedList, Stack, Queue, Iterator, ListIterator, Comparator, HashSet, TreeSet, HashMap, Set (0) | 2019.07.17 |
| Java - 자료구조(Collection), Random, Wrapper (0) | 2019.07.15 |
| Java - 다형성, 상속, 예외 (0) | 2019.07.12 |
| Java - Switch, 다중for문, Break문, 반복문복합, Singleton, Prototype패턴, 인터페이스, String, StringBuffer (0) | 2019.07.11 |
package Week02.day0715;
class Programmer{
private int age;
private Project now;
private Project[] history; //name 하나 더 넣어도 됨.
private String sname;
private int count;
Programmer(int age, String sname, Project now, Project[] history) {
this.age = age;
this.now = now;
this.history = history;
this.sname = sname;
}
void joinProject(Project p) { // 현재 진행중인 project를 설정 now
this.now = p;
}
void addProjectHistory(Project p) throws Exception { //project 경력을 추가 hitory에 추가
this.history[5] = p;
if(count > 4) {
throw new Exception("Project Hisoty는 5개까지 추가가능합니다.");
}
}
void getNowProject() { // 현재 Project를 리턴한다.
System.out.println(sname + "님의 현재 진행중인 프로젝트는 : " + now.getName() + " 입니다.");
}
void printProjectHostory() { //Project 경력을 출력한다 (print로 출력.)
System.out.println(sname + "님의 현재 경력은 : ");
for(int i = 0; i<history.length; i++) {
System.out.println("프로젝트명 : " + history[i].getName() + ", 프로젝트기간 : " + history[i].getMonth() + "개월");
}
}
void getTotalHistory() { //모든 Project의 총 경력의 합을 리턴한다(x년 x월)
int sum=0;
for(int i = 0; i<history.length; i++) {
sum+=history[i].getMonth();
}
if(sum/12==0)
System.out.println(sname + "님의 총 경력기간은 : " + sum/12 + "년 0개월 입니다.");
else
System.out.println(sname + "님의 총 경력기간은 : " + sum/12 + "년 " + sum%12 + "개월 입니다.");
}
}
class Project{
private String name;
private int month;
private String company;
Project(String name, int month, String company){
this.name = name;
this.month = month;
this.company = company;
}
public Project() {
}
String getName() { //Project명 리턴
return name;
}
void setName(String name) { //Project명 설정
this.name = name;
}
int getMonth() { // Project 수행기간을 월로 리턴 // month를 sum해서 월로 리턴.
return month;
}
void setMonth(int month) { // Project 수행기간
this.month = month;
}
}
public class 실습5일차 {
public static void main(String[] args) throws Exception {
Project[] p = new Project[6];
p[0] = new Project("마케팅", 5, "마케팅컴퍼니");
p[1] = new Project("빅데이터", 3, "빅데이터컴퍼니");
p[2] = new Project("소셜커머스", 6, "소셜커머스컴퍼니");
p[3] = new Project("인공지능", 8, "인공지능컴퍼니");
p[4] = new Project("AI", 10, "AI컴퍼니");
Project p1 = new Project();
p1 = new Project("배민뽀개기", 24, "딜리버리히어로코리아");
Programmer pg = new Programmer(32, "박홍준", p1, p);
pg.getNowProject();
pg.joinProject(p1);
pg.addProjectHistory(p1);
pg.printProjectHostory();
pg.getTotalHistory();
}
}
--------------------------------------------------------------------------
package Week02.day0715;
interface Campus{
void meal();
void goToSchool();
void takeClass();
}
class Teacher implements Campus{
private int id;
private String name;
private String major;
Teacher(int id, String name, String major){
this.id = id;
this.name = name;
this.major = major;
}
@Override
public void meal() {
System.out.println(name + " 교수님이 밥을 먹는다.");
}
@Override
public void goToSchool() {
System.out.println(name + " 교수님이 출근한다.");
}
@Override
public void takeClass() {
System.out.println(name + " 교수님이 강의를 한다.");
}
public void print() {
System.out.println("이름 : " + name + ", 담당전공 : " + major + ", 사번 : " + id);
}
}
class UniversityStudent implements Campus{
private int id;
private String name;
private String major;
UniversityStudent(int id, String name, String major){
this.id = id;
this.name = name;
this.major = major;
}
@Override
public void meal() {
System.out.println(name + "가 밥을 먹는다.");
}
@Override
public void goToSchool() {
System.out.println(name + "가 학교를 간다.");
}
@Override
public void takeClass() {
System.out.println(name + "가 수업을 듣는다.");
}
public void doHomework() {
System.out.println(name + "가 과제를 한다.");
}
public void partTime() {
System.out.println(name + "가 알바를 한다.");
}
public void print() {
System.out.println("이름 : " + name + ", 학과 : " + major + ", 학번 : " + id);
}
}
public class CampusLife {
public static void main(String[] args) {
Teacher tc = new Teacher(123456, "홍길동", "컴퓨터공학");
System.out.println("=======교수의 생활========");
tc.meal();
tc.goToSchool();
tc.takeClass();
System.out.println("=======교수의 정보========");
tc.print();
System.out.println();
System.out.println("=======학생의 생활========");
UniversityStudent[] st = new UniversityStudent[3];
st[0] = new UniversityStudent(1234567, "홍자동", "경영학과");
st[1] = new UniversityStudent(2234567, "홍수동", "행정학과");
st[2] = new UniversityStudent(3234567, "홍영동", "식품영양학과");
st[0].meal();
st[1].goToSchool();
st[2].takeClass();
System.out.println("=======학생의 정보========");
st[0].print();
st[1].print();
st[2].print();
}
}
--------------------------------------------------------------------------
/* 자료구조 */
1. 여러 개의 원소를 한 묶음으로 묶어 줄 수 있는 객체
2. Collection Framework
- interface : 각 collection에 있어야하는 연산의 정의
- implements : 각 collection이 실제 어떤 자료구조를 이용하여 표현했는가에 따라 collection 의 종류가 달라짐
- Algorithm : 각 collection 마다 유용하게 사용할 수 있는 메소드
package Week02.day0715;
import java.util.Random;
public class RandomEx2 {
public static void main(String[] args) {
Random rand = new Random();
int[] number = new int[100];
int[] counter = new int[10];
for(int i = 0; i<number.length; i++) {
// System.out.println(number[i] = (int)(Math.random()*10));
// 0<=x<10 범위의 정수 x를 반환한다.
System.out.println(number[i] = rand.nextInt(10));
}
System.out.println();
for(int i=0; i<number.length; i++) {
counter[number[i]]++;
}
for(int i=0; i<counter.length; i++) {
System.out.println(i + "의 개수 : " + printGraph('#', counter[i]) + " " + counter[i]);
}
}
public static String printGraph(char ch, int value) {
char[] bar = new char[value];
for(int i=0; i<bar.length; i++) {
bar[i] = ch;
}
return new String(bar);
}
}
--------------------------------------------------------------------------
package Week02.day0715;
public class RandomEx4 {
final static int RECORD_NUM = 10; //생설할 레코드의 수를 정한다.
final static String TABLE_NAME = "TEST_TABLE";
final static String[] CODE1 = {"010", "011", "017", "018", "019"};
final static String[] CODE2 = {"남자", "여자"};
final static String[] CODE3 = {"10대", "20대", "30대", "40대","50대"};
public static void main(String[] args) {
for(int i =0; i<RECORD_NUM; i++) {
System.out.println("INSERT INTO " + TABLE_NAME
+ " VALUES("
+ " '" + getRandArr(CODE1) + "'"
+ ", " + getRandArr(CODE2) + "'"
+ ", " + getRandArr(CODE3) + "'"
+ ", " + getRand(100, 200) //100~200 사이의 값을 얻는다.
+ ");" );
}
}
public static String getRandArr(String[] arr) {
return arr[getRand(arr.length-1)]; //배열에 저장된 값 중 하나를 반환한다.
}
public static int getRand(int n) {
return getRand(0, n);
}
public static int getRand(int from, int to) { //100~200 사이의 값을 얻는 로직.
return (int)(Math.random()*(Math.abs(to-from)+1)) + Math.min(from, to);
}
}
--------------------------------------------------------------------------
package Week02.day0715;
public class RandomWrapperTest {
public static void main(String[] args) {
//Random메소드
//Math.random()도 내부적으로 Random클래스의 인스턴스 생성해서 사용
//아래의 두문장은 동일
//double randNum = Math.random();
//double randNum = new Random().nextDouble();
/* 1. Random()
* 현재시간을 seed값으로 이용하는 Random 생성
*
* 2. Random(long see)
* 매개변수 seed를 종자값으로 하는 Random 생성
*
* 3. boolean nextBoolean()
* boolean type의 난수 발생
*
* 4. void nextBytes(byte[] bytes)
* Bytes배열에 byte타입의 난수를 채워서 반환
*
* 5. double nextDouyble()
* double타입의 난수를 반환, 0.0<=x<1.0
*
* 6. float nextFloat()
* float타입의 난수를 반환, 0.0<=x<1.0
*
* 7. int nextInt()
* Boolean타입의 난수를 반환
*
* 8. int nextInt(int n)
* int타입의 난수를 반환
*
* 9.long nextLang()
* Lang타입의 난수를 반환
*
* 10. void setSeed(long seed)
* seed변경
*/
//Wrapper
//변수를 객체로 만들 필요가 있을때 사용.
//사용시기
// 1. 매개변수로 객체가 요구 될때.
// 2. 기본형 값이 아닌 객체로 저장해야 할 때.
// 3. 객체간의 비교가 필요할 때. 등등
/*1.문자열->기본형
* byte b = Byte.parseByte("100");
* short s = Short.parseShort("100");
* int i = Int.parseInt("100");
* long l = Long.parseLong("100");
* float f = Float.parseFloat("100");
* double d = Double.parseDouble("3.14");
*
* 2. 문자열 -> Wrapper Class
* Byte b = Byte.valueOf("100");
* Short s = Short.valueOf("100");
* Int i = Int.valueOf("100");
* Long l = Long.valueOf("100");
* Float f = Float.valueOf("100");
* Double d = Double.valueOf("3.14");
*/
Integer i = new Integer(100);
Integer i2 = new Integer(100);
System.out.println("i==i2 ? " + (i==i2)); // false
System.out.println("i.equals(i2) ? " + i.equals(i2)); //true
System.out.println("i.compareTo(i2)=" + i.compareTo(i2)); //0
System.out.println("i.toString()=" + i.toString()); //100
System.out.println("MAX_VALUE=" + Integer.MAX_VALUE); //2147483647
System.out.println("MIN_VALUE=" + Integer.MIN_VALUE); //-2147483648
System.out.println("SIZE=" + Integer.SIZE+" bits"); // 32
System.out.println("BYTES=" + Integer.BYTES + " bytes"); // 4
System.out.println("TYPE=" + Integer.TYPE); //int
int i3 = 10;
//기본형을 참조형으로 형변환(형변환 생략가능)
Integer intg = (Integer)i3; // Integer intg = Integer.valueOf(i3);
Object obj = (Object)i3; // Object obj = (Object)Integer.valueOf(i3);
Long lng = 100L; // Long lng = new Long(100L);
int i4 = intg + 10; //참조형과 기본형간의 연산 가능
long l = intg + lng; // 참조형 간의 덧셈도 가능
Integer intg2 = new Integer(20);
int i5 = (int)intg2; //참조형을 기본형으로 형변환도 가능(형변환 생략가능)
Integer intg3 = intg2 + i5;
System.out.println("i3 = " + i3); //10
System.out.println("intg = " + intg); //10
System.out.println("obj = " + obj); //10
System.out.println("lng = " + lng); //100
System.out.println("intg = " + intg); //10
System.out.println("intg + 10 = " + i4); // 20
System.out.println("intg + lng = " + l); // 110
System.out.println("intg2 = " + intg2); // 20
System.out.println("i5 =" + i5); // 20
System.out.println("intg2 + i5 = " + intg3); // 40
}
}
--------------------------------------------------------------------------
package Week02.day0715;
import java.util.Scanner;
class Add{
private int a, b;
public void setValue(int a, int b) {
this.a = a;
this.b = b;
}
public int calculate() {
return a+b;
}
}
class Mul{
private int a, b;
public void setValue(int a, int b) {
this.a = a;
this.b = b;
}
public int calculate() {
return a*b;
}
}
class Sub{
private int a, b;
public void setValue(int a, int b) {
this.a = a;
this.b = b;
}
public int calculate() {
return a-b;
}
}
class Div{
private int a, b;
public void setValue(int a, int b) {
this.a = a;
this.b = b;
}
public int calculate() {
return a/b;
}
}
public class 계산기예제 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("두 정수와 연산자를 입력하시오>>");
int a = sc.nextInt();
int b = sc.nextInt();
char operator = sc.next().charAt(0); //연산자를 문자로 변환
switch(operator) {
case '+':
Add add = new Add();
add.setValue(a, b);
System.out.println(add.calculate());
break;
case '-':
Sub sub = new Sub();
sub.setValue(a, b);
System.out.println(sub.calculate());
break;
case '*':
Mul mul = new Mul();
mul.setValue(a, b);
System.out.println(mul.calculate());
break;
case '/':
Div div = new Div();
div.setValue(a, b);
System.out.println(div.calculate());
break;
default:
System.out.println("잘못된 연산자입니다.");
}
}
}
--------------------------------------------------------------------------
package Week02.day0715;
public class 피라미드예제 {
public static void main(String[] args) {
new 피라미드예제();
}
public 피라미드예제() {
int max = 50;
for(int i = 0; i <max; i++) {
String print = "";
for(int j = max; j>0; j--) {
if(i>=j) {
print+="*";
} else {
print+=" ";
}
}
for(int j = 0; j<max; j++) {
if(i<=j) {
print+=" ";
} else {
print+="*";
}
}
System.out.println(print);
}
}
}
'Java' 카테고리의 다른 글
############### JavaScript란? ##################
웹브라우저를 프로그래밍적으로 제어하는 언어 (client side script)
############### JavaScript 의 탈웹브라우저 ##################
웹서버를 동작하게 하는 언어로써 사용 가능(Node.js, server side script)
Google Apps Script (구글 스프레드 시트)등과 같은 서비스에서도 사용 가능
이 강의에서 배우는 것은,
웹브라우저나 웹서버나 다른서비스등의 환경에 대해서가 아니라
그곳에서 공통적으로 쓰이는 자바스크립트 그 '언어' 자체를 배운다.
'언어' '환경'
'JavaScript' 카테고리의 다른 글
| 반복문 (0) | 2019.07.25 |
|---|---|
| 비교와 조건문 (0) | 2019.07.23 |
| 변수, 주석, 줄바꿈과 여백 (0) | 2019.07.23 |
| 숫자와 문자 (0) | 2019.07.22 |
| 실행방법과 실습환경 (0) | 2019.07.22 |
class Mother{
String name;
String job;
int age;
private Child[] childs;
public Mother(String name, int age) {
this.name = name;
this.age = age;
}
public Mother(String name, int age, String job, Child[] childs) {
this.name = name;
this.age = age;
this.job = job;
this.childs = childs;
}
void goToSchool(String name, Child[] childs) {
for(int i=0; i<=2; i++) {
System.out.println(name + "는 " + childs[i].name + "과 학교를 갔다");
}
}
void callChild(String name, Child[] childs) {
for(int i=0; i<=2; i++) {
System.out.println(name + "는 " + childs[i].name + "를 불렀다.");
}
}
void setChild(Child[] childs) { //get 뒤에는 얻어가고자 하는 속성을 넣음.
this.childs = childs; //주소값을 던진다.
}
}
class Child{
String name, hobby;
int age;
public Child(String name, int age) {
this.name = name;
this.age = age;
}
public Child(String name, int age, String hobby) {
this.name = name;
this.age = age;
this.hobby = hobby;
}
String goToSchool(String name) {
return name + "은 학교를 갔습니다";
}
void fight(Child c) {
System.out.println(c.name + "와(과) 싸웠습니다.");
}
}
public class 실습4일차 {
public static void main(String[] args) {
/*
•실습1: Mother에 대한 클래스
- 속성:(String)name, (int)age, (String)job, private(Child[])childs
- 생성자
Mother(String name, int age)
Mother(String name, int age, String job, Child[] childs)
- 메소드:
void goToSchool(): ‘아이들과 학교가다’ 출력
void callChild(): 아이들 수만큼 출력 =>‘아이이름’이지금 갑니다
void setChild(Child[] c): 아이를 설정
Mother의 goToSchool, setChild후 callChild 를 호출해 보기
• Child에 대한 클래스
- 속성:(String)name, (int)age, String hobby
- 생성자
Child(String name, int age)
Child(String name, int age, String hobby)
- 메소드:
void goToSchool(): ‘학교가다’ 출력
void fight(Child c): ‘아이이름’과 싸웠습니다 출력
---------------------------------------------------------
*/
Child[] c = new Child[3];
c[0] = new Child("홍길동", 11);
c[1] = new Child("임꺽정", 12);
c[2] = new Child("이순신", 13);
Mother mt = new Mother("영희", 35, "개발자", c);
mt.goToSchool("영희", c); // name + "는 " + childs[i].name + "과 학교를 갔다" 배열별로 출력
mt.setChild(c);
mt.callChild("영희", c); // name + "는 " + childs[i].name + "를 불렀다." 배열별로 출력
Child ch = new Child("홍길동", 11, "축구");
System.out.println(ch.goToSchool("영희")); // 영희은 학교를 갔습니다
ch.fight(ch); // 홍길동와(과) 싸웠습니다.
}
}
--------------------------------------------------------------------------
class Book{
int number;
String title;
String author;
public void getLateFee(int day) {
}
public Book(int number, String title, String author) {
this.number = number;
this.title = title;
this.author = author;
}
void getMethod() {
}
void setMethod() {
}
public boolean equals(Object obj) { //object에 대해서 재정의됨.
if(obj!=null && obj instanceof Book) { //obj가 Person2의 Instance , "obj가 널이 아니고 && obj가 person2의 인스턴스가 맞냐?"
return number ==((Book)obj).number; // "s1의 id와 파라미터로 넘어온 obj의 id가 같냐?" 값이 같은지 비교하는 equals? object?로 재정의됨. ()는 타입변환용임. Person2로 변환하지 않으면 id를 호출하지 못하므로.
} else {
return false;
}
}
}
class Animation extends Book{
public Animation(int number, String title, String author) {
super(number, title, author);
}
public void getLateFee(int day) {
System.out.println(day*300);
}
}
class Science extends Book{
public Science(int number, String title, String author) {
super(number, title, author);
}
public void getLateFee(int day) {
System.out.println(day*200);
}
}
public class 실습4일차2번 {
public static void main(String[] args) {
/*
l 실습 2
책을 대여해주는 업체를 위한 Book이라는 클래스를 작성한다
Book는 관리자번호(number), 제목(title), 저자(author)를필드로 가진다
Book클래스는 접근자(GetMethod)와 설정자(SetMethod)를 가진다.
"Object클래스의 equals() 메소드를 재정의 해서 관리자 번호가 동일하면 동일한 책으로 간주한다."
Book으로부터 상속받은 Animation,Science 클래스를 작성한다
이들 클래스는 연체된 날짜에 따라서 연체료를 계산하는 getLateFee()메소드를
재정의한다. 연체료는Animation은 300원/일,Science는 200원/일 이다
클래스 Book, Animation, Science를 작성하라
*/
Book bk = new Book(77, "죽은시인의 사회", "톰슐먼");
Book bk2 = new Book(77, "난쏘공", "조세희");
System.out.println(bk.equals(bk2)); //true
Animation ani = new Animation(3, "마음의 소리", "조석");
ani.getLateFee(3);
Science sci = new Science(3, "Java의 정석", "남궁성");
sci.getLateFee(3);
System.out.println(ani.equals(sci)); //true
System.out.println(ani.equals(bk)); //false
}
}
--------------------------------------------------------------------------
package Week01;
abstract class Calculator{
int left, right;
public void setOprands(int left, int right) {
this.left = left;
this.right = right;
}
int _sum(){
return this.left + this.right;
}
public abstract void sum();
public abstract void avg();
public void run() {
sum();
avg();
}
}
class CalculatorDecoPlus extends Calculator{
public void sum() {
System.out.println("+sum :"+_sum());
}
public void avg() {
System.out.println("+avg :"+(this.left+this.right)/2);
}
}
class CalculatorDecoMinus extends Calculator{
public void sum() {
System.out.println("-sum :" +_sum());
}
public void avg() {
System.out.println("-avg :" +(this.left+this.right)/2);
}
}
public class 다형성예제 {
public static void execute(Calculator cal) {
System.out.println("실행결과");
cal.run();
}
public static void main(String[] args) {
Calculator c1 = new CalculatorDecoPlus();
c1.setOprands(10, 20);
Calculator c2 = new CalculatorDecoMinus();
c2.setOprands(10, 20);
execute(c1);
execute(c2);
}
}
--------------------------------------------------------------------------
package Week01;
class Calculator1{
int left, right;
public void setOprands(int left, int right) {
this.left = left;
this.right = right;
}
public void sum() {
System.out.println(this.left + this.right);
}
public void avg() {
System.out.println((this.left + this.right)/2);
}
}
class SubstractionableCalculator extends Calculator1{
public void substract() {
System.out.println(this.left - this.right);
}
}
public class 상속예제 {
public static void main(String[] args) {
SubstractionableCalculator c1 = new SubstractionableCalculator();
c1.setOprands(10, 20);
c1.sum();
c1.avg();
c1.substract();
}
}
--------------------------------------------------------------------------
package Week01;
public class 클래스예제 {
public static void main(String[] args) {
Song s = new Song("Dancing Queen",
"ABBA",
"Arrival",
new String[] {"Benny Andersson", "Bjorn Ulvaeus", "프레디 머큐리", "윤종신"}, //String [] s = new String[]
// Song s = new Song[] 두줄을 한줄로 만든셈.
1977,
2);
s.show();
}
}
class Song{
private String title;
private String artist;
private String album;
private String[] composer;
private int year;
private int track;
Song(String title, String artist, String album, String[] composer, int year, int track){
this.title = title;
this.artist = artist;
this.album = album;
this.composer = composer;
this.year = year;
this.track = track;
}
public void show() {
System.out.println("노래 제목 : " + title);
System.out.println("가수 : " + artist);
System.out.println("앨범 : " + album);
System.out.println("작곡가 : ");
for(int i=0; i<composer.length; i++) {
System.out.println(composer[i]);
if(i+1 ==composer.length)
System.out.println();
else
System.out.println(",");
}
System.out.println("년도 : " + year);
System.out.println("트랙 번호 : " + track);
}
}
--------------------------------------
/* 예외 */
1. 예외처리 예약어
- throw : 예외강제발생, 메소드안에서 쓰임, 의도적으로 예외를 발생시킴
- throws : 예외전가, 메소드에 달아서 책임을 전가시킴, 다음으로 넘겨버리는 것
- try ~(예외발생지역)~ catch ~(예외발생시 처리할 내용)~ finally ~ (예외발생유무와 상관없이 처리할 내용)~
2. Checked Exception : 컴파일시 예외처리 강제(무조건 try ~ catch 해야함) -> 대부분 프로그램으로 해결불가능
- throwable, exception, IOException, InterruptException
3. UnChecked Exception : 컴파일시 예외처리 선택(try ~ catch 안해도 됨) -> 대부분 프로그램으로 해결가능
- Error, ClassCastException, RuntimeException, NullPointException
4. printStackTrace() : 예외발생 당시의 call stack에 있었던 메소드의 정보와 예외 메세지를 출력(디버깅시 유용)
-> 로그가 굉장히 길어짐(개발시 대부분 이거 사용)
5. getMessage() : 발생한 예외 클래스의 인스턴스에 저장된 메세지를 리턴
-> 간단 명료
package Week01;
public class 예외처리예제1 {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
try {
System.out.println(3);
System.out.println(0/0); //에러가 나서 catch블록으로 넘어감
System.out.println(4); //실행되지 않는다.
} catch (ArithmeticException ae) {
if(ae instanceof ArithmeticException) //ae 객체가 예외가 맞느냐?
System.out.println("true");
System.out.println("ArithmeticException");
} catch (Exception e) {
System.out.println("Exception");
} //try ~ catch 의 끝
System.out.println(6);
} //main 메소드의 끝
}
-------------------------------------------
package Week01;
public class 예외처리예제2 {
public static void main(String[] args) {
System.out.println(1);
System.out.println(2);
try {
System.out.println(3);
System.out.println(0/0); //예외발생!!
System.out.println(4); //실행되지 않는다.
} catch(ArithmeticException ae) {
ae.printStackTrace(); //예외메세지 전부를 출력
System.out.println("예외메시지 : " + ae.getMessage()); //간단명료 출력.
} //try~ catch의 끝
System.out.println(6);
} //main 메소드의 끝
}
--------------------------------------------------------------------------
package Week01;
public class 예외처리예제3 {
public static void main(String[] args) {
try{
Exception e = new Exception("고의로 발생시켰음.");
throw e; //예외를 발생시킴
//throw new Exception("고의로 발생시켰음.")
} catch(Exception e) {
System.out.println("에러 메세지 : " + e.getMessage());
e.printStackTrace();
}
System.out.println("프로그램이 정상 종료되었음.");
}
}
--------------------------------------------------------------------------
package Week01;
public class 예외처리예제4 {
public static void main(String[] args) {
//method1()은 static 메소드이므로 인스턴스 생성없이 직접 호출
예외처리예제4.method1();
System.out.println("method1()의 수행을 마치고 main메소드로 리턴.");
} //main 메소드의 끝
static void method1() {
try {
System.out.println("method1()이 호출되었습니다.");
return; //현재 실행 중인 메소드를 종료한다.
} catch(Exception e) {
e.printStackTrace();
} finally {
System.out.println("method1()의 finally블럭이 실행되었습니다.");
}
} // method1 메소드의 끝
}
--------------------------------------------------------------------------
package Week01.exception;
import java.io.PrintStream;
import java.io.PrintWriter;
class MyException extends Exception{
private String message;
private Throwable cause;
public MyException() {
super();
}
public MyException(String msg) {
super(msg);
message = msg;
}
public MyException(Throwable cause) {
super(cause);
this.cause = cause;
}
public MyException(String msg, Throwable cause) {
super(msg, cause);
message = msg;
this.cause = cause;
}
public void setCause(Throwable cause) {
this.cause = cause;
}
public Throwable getCause() {
return cause;
}
public void setMessage(String message) {
this.message = message;
}
public String getMessage() {
return message;
}
public void printStackTrace() {
System.out.println(":: ERROR 발생!! ::");
System.out.println("에러사유 = " + message);
System.out.println("관련 클래스= " + cause);
System.out.println(":: ERROR 출력끝!! ::");
super.printStackTrace(System.out);
}
public void printStackTrace(PrintStream out) {
super.printStackTrace(out);
}
public void printStackTrace(PrintWriter out) {
super.printStackTrace(out);
}
}
public class ExceptionTest {
public static void main(String[] args) throws Exception {
int x = 100;
int y = 0;
int tot = 0;
try {
tot = x / y;
} catch(ArithmeticException ae) {
MyException me = new MyException("나눗셈", ae);
//throw me;
me.printStackTrace();
}
System.out.println("tot = " + tot);
}
}
-----------------------------------------------------------
package Week01;
public class MathTest {
public static void main(String[] args) {
//Math 메소드
//Math내 모든 메소드는 static이고 2개의 상수가 존재
//public static final double E = 2.17...;
//public static final double PI = 3.1415...;
//1.static double abs(double a)
//float, int, long : 절대값 반환
int l = Math.abs(-10);
double d = Math.abs(-10.0);
System.out.println(l); // 10
System.out.println(d); // 10.0
//2. static double ceil(double a)
//주어진 값을 올림하여 반환한다.
double d2 = Math.ceil(10.1);
double d3 = Math.ceil(-10.1);
double d4 = Math.ceil(10.000015);
System.out.println(d2); // 11.0
System.out.println(d3); //-10.0
System.out.println(d4); // 11.0
//3. static double max(double a, double d)
//float, int, long
//주어진 두 값을 비교하여 큰 쪽을 반환
double d5 = Math.max(9.5, 9.50001);
int i = Math.max(0, -1);
System.out.println(d5); // 9.50001
System.out.println(i); // 0
//4. static double min(double a, double b)
//float, int, long
//주어진 두 값을 비교하여 작은쪽을 반환
double d6 = Math.min(9.5, 9.50001);
int i2 = Math.min(0, -1);
System.out.println(d6); // 9.5
System.out.println(i2); // -1
//5. static double random()
// 0.0 ~1.0 범위의 임의의 double 반환
double d7 = Math.random();
int i3 = (int)(Math.random()*10)+1;
System.out.println(d7); // 0.0<=d<1.0
System.out.println(i3); // 1<=i<=11
//6. static double rint(double a) -> 안쓰임..................
//주어진 double값과 가장 가까운 정수값을 double형으로 반환한다.
double d8 = Math.rint(5.5); //
double d9 = Math.rint(5.1);
double d10 = Math.rint(-5.5);
double d11 = Math.rint(-5.1);
System.out.println(d8); //6.0
System.out.println(d9); //5.0
System.out.println(d10); //-6.0
System.out.println(d11); //-5.0
//7. static long round(double a)
// static long round(float a)
// 소수점 첫째자리에서 반올림한 long값을 반환
long l2 = Math.round(5.5);
long l3 = Math.round(5.11);
long l4 = Math.round(-5.5);
long l5 = Math.round(-5.1);
double d12 = 90.7552;
double d13 = Math.round(d12*100)/100.0;
System.out.println(l2); // 6
System.out.println(l3); // 5
System.out.println(l4); // -5
System.out.println(l5); // -5
System.out.println(d13); // 90.76
}
}
--------------------------------------------------------------------------
package Week01;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Lotto {
public static void main(String[] args) {
Lotto lotto = new Lotto();
Scanner sc = new Scanner(System.in);
System.out.println("로또 번호 추출 개수 입력 : ");
int gameCnt = sc.nextInt();
for(int i = 1; i<=gameCnt; i++) {
System.out.println(i + "번째 로또번호 : " + lotto.lottoNumbers());
}
}
String lottoNumbers() {
List<Integer> lottoNum = new ArrayList<Integer>();
//List 안에 로또번호 추가
for(int i = 1; i<=45; i++) {
lottoNum.add(i);
}
//set안의 수를 무작위로 섞는다
Collections.shuffle(lottoNum);
int[] lottoNums = new int[6];
for(int i=0; i<6; i++) {
lottoNums[i] = lottoNum.get(i);
}
//정렬
Arrays.sort(lottoNums);
return Arrays.toString(lottoNums);
}
}
--------------------------------------------------------------------------
package Week01.poly2;
class Vet{ // 수의사
public void giveShot(Animal a) { // 주사를 놓는다.
a.makeNoise(); // 동물마다 다른 비명소리를 지른다.
}
}
class Animal{
// 각 동물은 이 메소드를 Overriding한다.
public void makeNoise() {}
}
class Dog extends Animal{
public void makeNoise() {
System.out.println("멍멍");
}
}
class Cat extends Animal{
public void makeNoise() {
System.out.println("야옹");
}
}
public class PetOwner {
public static void main(String[] args) {
Vet v = new Vet();
Dog d = new Dog(); // Animal의 하위 클래스
Cat c = new Cat(); // Animal의 하위 클래스
v.giveShot(d);
v.giveShot(c);
}
}
package Week01.poly2;
class Vet{ // 수의사
public void giveShot(Animal a) { // 주사를 놓는다.
a.makeNoise(); // 동물마다 다른 비명소리를 지른다.
}
}
class Animal{
// 각 동물은 이 메소드를 Overriding한다.
public void makeNoise() {}
}
class Dog extends Animal{
public void makeNoise() {
System.out.println("멍멍");
}
}
class Cat extends Animal{
public void makeNoise() {
System.out.println("야옹");
}
}
public class PetOwner {
public static void main(String[] args) {
Vet v = new Vet();
Dog d = new Dog(); // Animal의 하위 클래스
Cat c = new Cat(); // Animal의 하위 클래스
v.giveShot(d);
v.giveShot(c);
}
}
--------------------------------------------------------------------------
package Week01.poly1;
//다형성 p.64쪽
class Dog extends Animal{
static String dog;
public Dog(String dog) {
this.dog = dog;
}
}
class Cat extends Animal{
static String cat;
public Cat(String cat) {
this.cat = cat;
}
}
class Wolf extends Animal{
static String wolf;
public Wolf(String wolf) {
this.wolf = wolf;
}
}
public class Animal{
public static void main(String[] args) {
Animal[] animals = new Animal[3];
animals[0] = new Dog("진돗개");
animals[1] = new Cat("페르시안고양이");
animals[2] = new Wolf("울버린");
//각 객체별 재정의된 메소드가 실행된다.
for(int i = 0; i<animals.length; i++) {
animals[i].eat();
animals[i].roam();
}
}
private void roam() {
System.out.println(Dog.dog + "가 으르렁댑니다.");
}
private void eat() {
System.out.println(Cat.cat + "가 냠냠 먹습니다.");
}
}
'Java' 카테고리의 다른 글
지금까지 우리는 박스모델과 그리드를 통해 CSS 페이지를 보다 직관성있게 만들었습니다. 1.HTML 3.JavaScript 페이지 역시 같은 형태로 만드려면 CSS 페이지의 <style> 내의 코드들을 복사해주면 됩니다.
만일 적용해야하는 페이지가 수천개라면 어떨까요? 수천번 직접 복사하는건 비효율적이고 이를 간단하게 하기위해 다음과 같이 <link> 태그를 이용합니다.
1. style.css 라는 파일을 새로 만들고, <style> 태그 내의 내용들을 전부 복사해 넣습니다. (태그 자체는 복사x)
2. html 페이지 내의 <style> 태그를 이제 지워버리고, <link> 태그를 이용해 <link rel="stylesheet" href="style.css">를 대신 삽입합니다.
이 과정을 통해코 드의 양이 줄어 훨씬 직관적이 되며, 웹페이지를 수정해야 할때도 Style.css 파일만 수정하면 되기때문에 효율성이 폭발적으로 늘어납니다.
이렇게 코딩에서 중요한 중복의 제거를 통해 훨씬 효율적이고 수정이 파격적으로 쉬운 웹페이지를 만들수있습니다. CSS 수업 초기에 언급했던 '정보로써의 html' 의 가치또한 퇴색되지 않습니다.
캐시(Cache)
한번 페이지를 방문해서 Style.css 파일을 다운받았다면, 다음부터 방문할때 웹브라우저는 컴퓨터 내에 저장된 Style.css 파일을 불러와서 빠르게 훨씬 페이지를 읽고 네트워크 트래픽 또한 다시 사용하지 않습니다.
'HTML & CSS' 카테고리의 다른 글
| Margin vs. Padding (0) | 2020.01.21 |
|---|---|
| 구글 크롬 개발자 도구 (0) | 2019.07.31 |
| 반응형 디자인 (0) | 2019.07.11 |
| 박스모델 (0) | 2019.07.08 |
| HTML5 (0) | 2019.07.06 |
반응형 디자인(Responsive Web Design)
웹 개발자들은 모니터, 스마트폰, 미래의 가상현실과 같이 변화하고 발전하는 화면의 형태에 각각 최적화된 웹페이지를 만들고자 합니다. 이에 사용되는 기술이 미디어 쿼리입니다.
미디어 쿼리는 <style> 태그 내에 @media( ) 코드를 통해 적용할수 있습니다. 예로 화면크기가 800px 보다 작을 경우를 가정하려면 @media(max-width:800), 화면 크기가 1500px보다 클 때부터를 가정하려면 @media(min-width=1501) 과 같이 ( ) 안에 조건을 입력하는 방식입니다.
그 후 화면 크기에 따라 변화시키고 싶은 태그, 혹은 그리드는 <style> 태그 내에 있는 코드를 복사해 원하는대로 편집하면 간단합니다.
'HTML & CSS' 카테고리의 다른 글
| 구글 크롬 개발자 도구 (0) | 2019.07.31 |
|---|---|
| CSS 코드의 재사용 (0) | 2019.07.11 |
| 박스모델 (0) | 2019.07.08 |
| HTML5 (0) | 2019.07.06 |
| 외부문서삽입 - iframe (0) | 2019.07.05 |
Java - Switch, 다중for문, Break문, 반복문복합, Singleton, Prototype패턴, 인터페이스, String, StringBuffer
| Java 2019. 7. 11. 18:56
package Week01;
import java.util.Scanner;
//실습1]
class Father{ // 겟,셋메소드 -> 속성을 private으로 하기때문.
String name;
int age;
String job;
public Father(String name, int age, String job){ //생성자에서 초기화를 해야함.(정답은 없음)
this.name = name;
this.age = age;
this.job = job;
}
void goToWork(int time) {
System.out.println("직업이 " + job + "인 " + age + "세 " + name + "님이 " + time + "시에 출근하다.");
}
void goOffWork(int time) {
System.out.println("직업이 " + job + "인 " + age + "세 " + name + "님이 " + time + "시에 퇴근하다.");
}
}
//실습2]
class Member{
String name; //최상위 클래스에 변수선언해야 자식클래스에서 상속받고 , 재사용 및, 다시 선언안하게됨.
Member(String name) { //속성이 있으므로 무조건 생성자를 만든다.
this.name = name;
}
String getName() { //name은 부모에 있으므로 안써도 됨.
return name;
}
void setName(String name) {
this.name = name;
}
}
class SpecialMember extends Member{
public SpecialMember(String name) {
super(name);
}
}
//실습3]
class Parent {
String name;
int age;
Hobby h;
public void setAge(int age) {
this.age = age;
}
public void setHobby(Hobby h) {
this.h = h;
}
public String toString() {
return h.setHobby();
}
public boolean equals(Object obj) {
if (obj != null && obj instanceof Child) {
return name == ((Child) obj).name;
} else
return false;
}
}
public class Child extends Parent {
Child(String name) {
this.name = name;
}
}
public class 실습3일차 {
public static void main(String[] args) {
/*•실습1: Father에 대한 클래스
- 속성:(String)name, (int)age, (String)job
- 메소드:
void goToWork(int time): ‘출근하다’ 출력
void goOffWork(int time): ‘퇴근하다’ 출력
위 클래스를 사용하여 출근하다, 퇴근하다를 출력해 보기
*/
Father ft = new Father("홍길동", 35, "개발자");
ft.goToWork(9);
ft.goOffWork(18);
/*
•실습2: 다음 클래스 설계
SpecialMember, Member
SpecialMember m = new SpecialMember(“홍길동”);
Member s = m;
s.getName(); // 홍길동
*/
SpecialMember sm = new SpecialMember("홍길동"); //"홍길동"을 인자로 받는다.
Member s = sm; //SpecialMember는 Member를 상속받는다.
System.out.println(s.getName()); // 홍길동
/*
•실습3: 다음을 만족하는 클래스를 작성
Parent, Child, Hobby, Tennis, Piano
Child c = new Child(“홍길동”);
Parent p = c; //상속관계
c.setAge(30); //child로 놓을지, parent로 놓을지는 선택의 문제.
Tennis t = new Tennis();
Hobby b = t; //hobby가 tennis의 부모. 잘알면 실체화시킬수있는 클래스로 만든다. 잘모르면 추상클래스로 만든다.
c.setHobby(t); //parent는 테니스 hobby를 t로 받고있음.
Piano p = new Piano();
Hobby b2 = p;
c.setHobby(p);
Child c2 = new Child(“홍길동”);
System.out.println(c); // 피아노
System.out.println(c.equals(c2));// true
*/
Child c = new Child("홍길동");
Parent p = c;
c.setAge(30);
Tennis t = new Tennis();
Hobby b = t;
c.setHobby(t);
System.out.println(c);
Piano p2 = new Piano();
Hobby b2 = p2;
c.setHobby(p2);
Child c2 = new Child("홍길동");
System.out.println(c); // 피아노
System.out.println(c.equals(c2));// true
}
}
-----------------------------------------------------------------------------
package Week01;
import java.util.*;
public class Switch예제 {
public static void main(String[] args) {
char gender;
String regNo = "";
System.out.println("당신의 주민번호를 입력하세요.ex)011231-1111222");
Scanner sc = new Scanner(System.in);
regNo = sc.nextLine();
gender = regNo.charAt(7); //입력받은 번호의 8번째 문자를 gender에 저장. 인덱스처리는 0번째부터 시작함.
switch(gender) {
case '1':
case '3':
switch(gender) {
case'1':
System.out.println("당신은 2000년 이전에 출생한 남자입니다.");
break; //break는 {}속해있는 블록을 탈출하는 거임.
case'3':
System.out.println("당신은 2000년 이후에 출생한 남자입니다.");
}
break; //이 break문을 빼먹지 않도록 주의
case '2':
case '4':
switch(gender) {
case'2':
System.out.println("당신은 2000년 이전에 출생한 여자입니다.");
break;
case'4':
System.out.println("당신은 2000년 이후에 출생한 여자입니다.");
break;
}
break; //이 break문을 빼먹지 않도록 주의
default: //만족하는 case가 없는경우 default 출력.
System.out.println("유효하지 않는 주민등록번호입니다.");
}
} // main의 끝
}
--------------------------------------------------------------------------
package Week01;
public class 다중For문 {
public static void main(String[] args) {
for(int i = 1; i<=5; i++) { //이 안에서 int 선언해주는 것이 좋음. 밖에서 선언할경우 에러날수도 있다. {}블록범위를 잘 파악해라.
for(int j = 1; j<=10; j++) {
System.out.print("*");
}
System.out.println();
}
}//main의 끝
}
--------------------------------------------------------------------------
package Week01;
public class Break문예제 {
public static void main(String[] args) {
int sum = 0;
int i = 0;
while(true) {
if(sum>100) //실무시 break if 조건 바로 오른쪽에. 블록반드시 쓸것.
break;
++i;
sum+=i;
}// end of while
System.out.println("i=" + i); //14
System.out.println("sum=" + sum); //105
}
}
--------------------------------------------------------------------------
package Week01;
import java.util.Scanner;
public class 반복문복합예제 {
public static void main(String[] args) {
int menu = 0;
int num = 0;
Scanner sc = new Scanner(System.in);
outer: //반복문에 이름부여. 잘안쓰임. 많이쓰면 추적하기 어려워짐.
while(true) {
System.out.println("(1)sqaure");
System.out.println("(2)sqaure root");
System.out.println("(3)log");
System.out.print("원하는 메뉴(1~3)를 선택하세요.(종료:0)");
String tmp = sc.nextLine(); //화면에서 입력받은 내용을 tmp에 저장
menu = Integer.parseInt(tmp);
if(menu==0) {
System.out.println("프로그램을 종료합니다.");
break;
} else if (!(1<=menu && menu <=3)){ //! : boolean 반대로
System.out.println("메뉴를 잘못 선택하셨습니다. (종료는 0)");
continue;
}
for(;;) {
System.out.println("계산할 값을 입력하세요(계산종료0, 전체종료99)");
tmp = sc.nextLine(); //화면에서 입력받은 내용을 tmp에 저장
num = Integer.parseInt(tmp); //입력받은 문자열(tmp)을 숫자로 변환
if(num==0)
break; //계산종료, for문을 벗어난다
if(num==99)
break outer; //전체종료, for문과 while문을 모두 벗어난다. break할 대상을 지정함.
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(;;)
} //while의 끝
} // main의 끝
}
--------------------------------------------------------------------------
package Week01;
public class Singleton { //싱글톤 -> 많이 쓰임. 힙에 자신의 인스턴스는 1개만 존재하도록 해놓은 규칙.
private Singleton() {}
private static Singleton instance = null;
public static synchronized Singleton getInstance() { //
if(instance == null) {
instance = new Singleton(); //단 하나의 스레드만 들어와서 실행할 수 있음.
}
return instance;
}
}
--------------------------------------------------------------------------
package Week01;
import java.util.ArrayList;
import java.util.List;
//인스턴스에 대한 카피본을 만드는 소스
public class Prototype패턴 implements Cloneable {
private List<String> userList; //userList :자바에서 제공하는 라이브러리
public Prototype패턴() {
userList = new ArrayList();
}
public Prototype패턴(List list) {
this.userList = list;
}
public void loadData() {
userList.add("1");
userList.add("2");
userList.add("3");
userList.add("4");
}
public void print() {
System.out.println(userList);
}
public List<String> getUserList(){
return userList;
}
public Object clone() throws CloneNotSupportedException{
List<String> temp = new ArrayList();
for(String s : this.getUserList()) {
temp.add(s);
}
return new Prototype패턴(temp);
}
public static void main(String[] args) throws Exception{
Prototype패턴 orginUsers = new Prototype패턴();
orginUsers.loadData();
Prototype패턴 cloneUsers = (Prototype패턴)orginUsers.clone();
cloneUsers.print();
}
}
--------------------------------------------------------------------------
package Week01;
interface A3{
int x = 100;
public static class B3{
private int y;
public B3() {
this.y = 200;
}
public void disp() {
System.out.println("x = " + x); //A.x
System.out.println("y = " + y); //this.y
}
}
}
public class Interface01예제 {
public static void main(String[] args) {
A3.B3 bp = new A3.B3();
bp.disp(); // x = 100, y = 200 출력
}
}
--------------------------------------------------------------------------
package Week01;
interface MyInterface {
default void method1() {
System.out.println("method1() in MyInterface");
}
default void method2() {
System.out.println("method2() in MyInterface");
}
static void staticMethod() {
System.out.println("staticMethod() in MyInterface"); // 인터페이스.메소드명으로 호출 static이므로 출력
}
}
interface MyInterface2{
default void method1() {
System.out.println("method1() in MyInterface2");
}
static void staticMethod() {
System.out.println("staticMethod() in MyInterface2"); // 인터페이스.메소드명으로 호출 static이므로 출력
}
}
public class Interface02예제 {
public static void main(String[] args) {
Child c = new Child();
c.method1(); // method1() in Child 출력
c.method2(); // method2() in Parent 출력
MyInterface.staticMethod(); // staticMethod() in MyInterface 출력
MyInterface2.staticMethod(); // staticMethod() in MyInterface2 출력
}
}
class Child extends Parent implements MyInterface, MyInterface2{
public void method1() {
System.out.println("method1() in Child"); //오버라이딩
}
}
class Parent{
public void method2() {
System.out.println("method2() in Parent");
}
}
--------------------------------------------------------------------------
package Week01;
import java.util.Arrays;
public class StringTest {
public static void main(String[] args) {
//여기있는 메소드를 잘 활용해라. 메소드 만드는데 시간허비하지 말것.
//1.String(char[] value) 메소드
char[] c = {'H', 'e', 'l', 'l', 'o'};
String s = new String(c);
System.out.println(s); //Hello 출력
//2.String(StringBuffer buf) 메소드 : 루프안에서는 스프링버퍼를 써야함.
StringBuffer sb = new StringBuffer("Hello");
String s2 = new String(sb);
System.out.println(s2); //Hello 출력
//3. char charAt(int index) 메소드
String s3 = "Hello";
char c2 = s3.charAt(1); //index가 0부터 시작.
System.out.println(c2); // e출력
//4. int compareTo(String str) : 사전순으로 비교 -1/0/1 -> 습관적으로 1,2개씩 바꿔가면서 해보는게 나중에 큰차이!!!(오류잡는 방법)★★★
int l = "aaa".compareTo("aaa");
int m = "aaa".compareTo("aaa1");
int n = "aaa".compareTo("aa");
System.out.println(l); // 0출력
System.out.println(m); // -1출력
System.out.println(n); // 1출력
//5. String concat(String str) : 문자열 덧붙임
String s4 = "Hello";
String s5 = s4.concat(" World");
System.out.println(s5); // Hello World 출력
//6. boolean contains(CharSequence s) : 지정된 문자열이 포함되었는지 검사
String s6 = "abcdefg";
boolean b = s6.contains("bc");
System.out.println(b); // true
//7. boolean endsWith(String suffix) : 지정된 문자열로 끝나는지 검사
String file = "Hello.txt";
boolean b2 = file.endsWith("txt");
System.out.println(b2); //true
//8. int indexOf(int ch) : 문자(ch)가 존재하는 위치(0부터 시작). 많이쓰임★★★
String s7 = "Hello";
int idx1 = s7.indexOf('o');
System.out.println(idx1); //4 출력
//9. int indexOf(int ch, int pos) : 문자(ch)가 존재하는 위치를 pos부터 확인하여 index를 알려줌
String s8 = "Hello";
int idx2 = s8.indexOf('e',0); //1
int idx3 = s8.indexOf('e',2); //-1 (e가 기준점 l로부터 왼쪽 첫번째에 있으므로 -1임)
System.out.println(idx2);
System.out.println(idx3);
//10. int indexOf(String str) : 문자열이 존재하는 위치
String s9 = "ABCDEFG";
int idx4 = s9.indexOf("CD");
System.out.println(idx4); //2 출력
//11. int lastIndexOf(int ch) : 문자를 오른쪽 끝에서 찾아서 위치리턴
String s10 = "java.lang.Object";
int idx5 = s10.lastIndexOf('.');
System.out.println(idx5); //9출력. index 순서는 왼쪽부터
//12. String replace(char old, char nw) : old문자를 nw로 변경. 많이쓰임★★★
String s11 = "Hello";
String s12 = s11.replace('H', 'C');
System.out.println(s11); //Hello
System.out.println(s12); //Cello
//13. String replaceAll(Sting regex, String nw) : 전체변경
String sb2 = "AABBAABB";
String r = sb2.replaceAll("BB", "bb");
System.out.println(r); //AAbbAAbb
//14. String replaceFirst(String regex, String nw) : 일치하는 것중 첫번째 것만 변경
String sb3 = "AABBAABB";
String r2 = sb3.replaceFirst("BB", "bb");
System.out.println(r2); //AAbbAABB
//15. String[] split(String regex) : 분리자로 나누어 배열을 반환. 많이쓰임★★★
String animals = "dog,cat/bear";
String[] arr = animals.split(",|/"); //cf. | 멀티지정 구분자.
System.out.println(arr[2]); // bear
//16. String[] split(String argex, int limit) : 분리하되 문자열을 limit 수만큼 자른다.
String animals2 = "dog, cat, bear";
String[] arr2 = animals.split(",", 2); //arr[0] : dog, arr[1] : cat, bear
//17. boolean startWith(String prefix) : 주어진 문자열로 시작하는지 검사
String s13 = "java.lang.Object";
boolean b3 = s13.startsWith("java");
System.out.println(b3);//true
//18. String trim() : 문자열의 왼쪽, 오른쪽 끝에 있는 공백을 없앤 결과를 반환. 많이쓰임★★★. R trim, L trim
String s14 = " Hello World ";
String s15 = s14.trim();
System.out.println(s15); //Hello World
//19. static String valueOf(boolean b);
// boolean대신 -> char/int/long/float/double/Object 값들이 올수있고 : 지정된 값을 문자열로 반환
String b4 = String.valueOf(123456);
System.out.println(b4); //true
//20. static String join(CharSequence arg(), CharSequence... arg1). 많이쓰임★★★. 한줄로 만들어서 보냄.
String[] arr3 = {"A", "B", "C"};
String s16 = String.join("-", arr3);
System.out.println(s16); //A-B-C
}
}
--------------------------------------------------------------------------
package Week01;
public class StringBufferTest {
public static void main(String[] args) {
// StringBufferTest
//1. StringBuffer(String str)
StringBuffer sb = new StringBuffer("H1");
System.out.println(sb); //H1
//2. StringBufer append(boolean b)
//기본자료형 / char[]/ Object /String 문자열 뒤에 붙이기
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb2.append("abc")); //abcabc
//3. char charAt(int index)
StringBuffer sb3 = new StringBuffer("abc");
char c = sb3.charAt(2);
System.out.println(c); //c
//4. StringBuffer delete(int start, int end)
//start ~ end 사이의 문자를 제거
StringBuffer sb4 = new StringBuffer("0123456");
StringBuffer c2 = sb4.delete(0, 5); // 56 (0번째에서 5번째까지 삭제)
System.out.println(c2);
//5. StringBuffer deleteCharAt(int index)
//지정된 위치의 문자 제거
StringBuffer sb5 = new StringBuffer("0123456");
StringBuffer c3 = sb5.deleteCharAt(3); //3번째 문자 제거
System.out.println(c3); // 012456
//6. StringBuffer insert(int pos, boolean b)
// boolean대신 -> char/char[]/int/long/float/double/Object/String 값들이 올수있고 : 지정된 값을 문자열로 변환하여 pos에 추가
StringBuffer sb6 = new StringBuffer("0123456");
System.out.println(sb6.insert(4, ',')); // 0123,456
//7. StringBuffer replace(int start, int end, String str)
//지정된 범위의 문자열을 주어진 문자열로 바꾼다.
StringBuffer sb7 = new StringBuffer("0123456");
System.out.println(sb7.replace(3, 6, "AB")); //012AB6
//8. StringBuffer reverse()
// 문자열 순서를 거꾸로
StringBuffer sb8 = new StringBuffer("0123456");
System.out.println(sb8.reverse()); //6543210
//9. String substring(int start)
// String substring(int start, int end) // 범위에 해당하는 값 출력.
StringBuffer sb9 = new StringBuffer("0123456");
String str = sb9.substring(3);
System.out.println(str); //3456
String str2 = sb9.substring(3,5);
System.out.println(str2); //34
}
}
'Java' 카테고리의 다른 글
| Java - 자료구조(Collection), Random, Wrapper (0) | 2019.07.15 |
|---|---|
| Java - 다형성, 상속, 예외 (0) | 2019.07.12 |
| Java - 다형성, equals, 정렬로직, 인터페이스, template 패턴 (0) | 2019.07.10 |
| Java - 일반화, 추상화, 클래스(생성자, this, super, 접근제한자, static, final), is a/has a, 상속, object class, 연산자, state 패턴, 클래스 다이어그램, 재귀함수 (0) | 2019.07.09 |
| 기본 알고리즘 (0) | 2019.07.08 |
package Week01;
import java.util.Scanner;
//실습3]
interface AnimalType {
public String bark();
}
class Dog1 implements AnimalType {
@Override
public String bark() {
return "멍멍";
}
}
class Cat implements AnimalType {
@Override
public String bark() {
return "야옹";
}
}
public class 실습2일차 {
//실습2]
private int move;
private int arr[];
public 실습2일차(int move, int arr[]) {
this.move = move;
this.arr = arr;
ArrMove();
}
public void ArrMove() {
for (int y = 0; y < move; y++) {
int temp; //임시보관함 만듬
temp = arr[0]; //0번째 배열값을 임시보관함에 저장. 반복문 실행될 경우 0번째 값은 사라지기에.
for (int x = 1; x < arr.length; x++) {
arr[x - 1] = arr[x];
}
arr[arr.length - 1] = temp; // 임시보관함에 저장한 것을 마지막 배열에 투입.
}
}
public String toString() {
return arr[0] + " " + arr[1] + " " + arr[2] + " " + arr[3] + " " + arr[4] + " " + arr[5] + " " + arr[6] + " ";
}
//실습3]
private AnimalType type;
public void setType(AnimalType type) {
this.type = type;
}
public void bark() {
System.out.println(type.bark());
}
public static void main(String[] args) {
/*실습1 : 일반화, 추상화
* 1.Transformation(운송수단) : 교통통합시스템(기준, 전제)
* - 속성 : 이름, 평균속도, 승차가용인원, 배차간격, 첫차시간, 막차시간
* - 메소드 : 이동하다(추), 정차하다, 승객을 승차시킨다, 승객을 하차시킨다, 운행시간이 종료되다, 운행시간이 시작되다
* 2.Food : 배달(기준, 전제)
* - 속성 : 배달시간, 배달가능지역, 주문방법, 배달수단, 영업시간
* - 메소드 : 배달하다, 수거하다, 주문을 받다, 결제하다, 배달비를 따로 받는다
* 3.Transformation 추상화 : 운송가능지역, 운임요금, 운행시간
* 4.Food 추상화 : 칼로리, 가격대, 주로주문하는 연령대
*/
/*실습2 : 배열원소 이동
* 입력 : 1~10
* 출력 : [2,3,4,5,6,7,1]
* -메소드를 만들고, 호출해서 배열을 넣고, 스캔쓰지말고, 왼쪽씩 1칸씩 옮기는 개념.
* - 생성자로 받았으면 멤버로 넣는다.
* - 알고리즘보단 구조를 만드는게 더 중요함.
*/
Scanner input = new Scanner(System.in);
System.out.println("숫자를 입력하세요.");
int move = input.nextInt();
int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
실습2일차 am = new 실습2일차(move, arr);
System.out.println(am.toString());
/*실습3 : 동물짖기
* Animal class를 설계한다.
* 생성자로 AnimalType(부모클래스)을 파라미터로 받는다
* bark() 메소드를 통해 동물의 짖는 소리를 출력한다 : Dog는 멍멍, Cat은 야옹 (자식클래스, 오버라이딩)
* 현재 Dog와 Cat의 클래스만 존재하는데 향후 추가될 수 있다.
* -
*/
Cat cat = new Cat();
Dog1 dog = new Dog1();
실습2일차 pr = new 실습2일차();
pr.setType(cat);
pr.bark();
}
}
--------------------------------------------------------------------------
/*다형성*/
1. 여러개의 개별적인 클래스를 하나의 부모클래스 객체로 통합관리 -> 효율성을 높임
2. 자식 클래스의 instance를 부모class에 담았을때 접근 규정
- 부모 class가 가지고 있는 모든 멤버들에 접근
- 단 자식class에서 메소드 overriding 했다면 overriding 된 자식의 멤버에 접근
- 멤버 필드의 경우 부모 class의 멤버 필드에만 접근 가능
package Week01.polymor;
class A6{
public void aaa() {
System.out.println("aaa");
}
public void bbb() {
System.out.println("bbb");
}
}
class B6 extends A6{
public void bbb() {
System.out.println("bbb1");
}
public void ccc() {
System.out.println("ccc");
}
}
public class PolymorTest {
public static void main(String[] args) {
A6 ap = new B6(); // 다형적 표현 ap 는 b의 인스턴스를 가리킴
ap.aaa(); //A6클래스의 aaa()메소드 호출 ? aaa출력
ap.bbb(); //B6클래스의 bbb()메소드 호출 ? bbb1출력
// ap.ccc(); //접근 가능한 멤버는 Data type에 의해 결정, compile error 발생 ->A6클래스는 ccc메소드가 없다. 그러므로 에러. (자식만 가지고 있는 메소드는 가리킬수없다.)
}
}
--------------------------------------------------------------------------
package Week01;
class Car{
String color; //색상
String gearType; //변속기 종류 = auto(자동), manual(수동)
int door; // 문의 개수
Car(){
this("white", "auto", 4); //parameter 3개 넣음
}
Car(Car c){ //인스턴스의 복사를 위한 생성자.
color = c.color;
gearType = c.gearType;
door = c.door;
}
Car(String color, String gearType, int door){ //3개 받아서 초기화
this.color = color;
this.gearType = gearType;
this.door = door;
}
long id;
//Object의 equals를 Overriding
public boolean equals(Object obj) { //object에 대해서 재정의됨.
if(obj!=null && obj instanceof Car) { //obj가 Car의 Instance
//위 3가지 항목이 같은경우 true가 나오게 equals 정의하는 경우...
//return (this.color ==((Car)obj).color)
// && (this.gearType ==((Car)obj).gearType)
// && (this.door ==((Car)obj).door) ...
return id ==((Car)obj).id; // 값이 같은지 비교하는 equals? object?로 재정의됨.
} else {
return false;
}
}
Car(long id){
this.id = id;
}
}
public class CarTest3 {
public static void main(String[] args) {
Car c1 = new Car(); //인스턴스 생성
Car c2 = new Car(c1); // c1의 복사본 c2를 생성한다.
System.out.println(c1.door);
System.out.println(c2.door);
if(c1==c2) //다르다
System.out.println("c1과 c2는 같은 car입니다.");
else
System.out.println("c1과 c2는 다른 car입니다.");
if(c1.equals(c2)) //같다. 재정의되어 같다고 표시
System.out.println("c1과 c2는 같은 car입니다.");
else
System.out.println("c1과 c2는 다른 car입니다.");
}
}
//object 0 = c1; -> object o가 c1을 가리킨다는 뜻. 데이터범위는 가리키는 애를 통해 결정됨.
//다형성 - PolymorTest 와 연관된 샘플.
/*class Parent{
* public String name = 'k'
* public int age
* public void test1(){sysout aa}
*
* public String getName{
* this.name}
* }
*
* class Child extends Parent{
* public void test2(){sysout bb}
* public void test1(){sysout bb}
*
* public String name = 'm'
*
* public String getName(){
* return this.NAME;
* }
* }
*
* Child c = new Child();
* Parent p = c;
* c.test1(); -> 가능 aa
* c.test2(); -> 가능
* p.test1(); -> 가능 bb (자식 메소드 오버라이딩)
* p.test2(); -> 불가능 (가리키는 변수의 타입으로 결정.) Parent는 test2 메소드가 없음.
* c.name; -> m출력.
* p.name; -> k출력.
* c.getName; -> m출력.
* p.getName; -> m출력. (오버라이딩.) cf. 멤버변수는 오버라이딩x
*/
--------------------------------------------------------------------------
/* abstract */
1. 추상클래스 -> 자식을 통해 의미를 가지는 클래스
2. 인스턴스를 새로 만들 수는 없지만 그 유형의 객체를 저장하기 위한 배열 객체를 만드는 것은 가능.
3. 추상메서드
- 추상 메소드가 있는 클래스는 추상클래스여야 한다.
- 추상 메서드를 상속 받은 자식클래스가 "메소드를 재정의하지 않는다면" -> 자식클래스는 추상메소드를 재정의 하지 않아 추상클래스가 되기 때문에 객체를 생성시키지 못하게 된다.
package Week01;
//정렬로직
//자바에서 제공하는 api 이해하는데 도움됨.
public class SortTest {// ★★★★★ 활용도 높은 소스
public static void main(String[] args) {
String[] names = {"이인화", "한희원", "김성연", "심재후"};
Sorter s = new StringSorter();
s.doSort(names);
for(int i =0; i<names.length; i++) {
System.out.println(names[i]);
}
}
}
abstract class Sorter{
abstract boolean isCorrectOrder(Object o, Object o2); //object는 모든 클래스의 최상위. object가 매개변수로 온이유:모든 클래스를 다 가리키기 위해.
void doSort(Object[] list) {
for(int max=list.length-1;max>0;max--) {
for(int i=0; i<max; i++) {
if(!isCorrectOrder(list[i], list[i+1])) {
Object temp;
temp = list[i];
list[i]=list[i+1];
list[i+1]=temp;
}
}
}
}
}
class StringSorter extends Sorter{
boolean isCorrectOrder(Object o, Object o2) { //두값이 왔을때 첫번째 값이 크면 false
if(((String)o).compareTo((String)o2)<=0) { //o2가 더 크면
System.out.println(o+ "," + o2 + "TRUE, " + ((String)o).compareTo((String)o2));
return true;
} else {
System.out.println(o+ "," + o2 + "FALSE, " + ((String)o).compareTo((String)o2));
return false;
}
}
}
--------------------------------------------------------------------------
/* interface */
1. 다형성에 의한 클래스 제어
-> interface는 클래스가 어떤 역할을 할 수 있는지를 정의.
2. 형식 : 접근_제한자 interface 인터페이스명 extends 상위_인터페이스
3. 인터페이스 포함 멤버 - 필드
-> 무조건 public static final 멤버 필드
4. 인터페이스 포함 멤버 - 메소드
-> 무조건 public abstract 멤버 메서드(public abstact를 붙이지 않아도 error가 나지는 않는다)
-> 구현부가 없음
* 구현부 정의 가능한 예외 2가지
1) 디폴드 메소드 : 추상메소드가 아니다. 접근제한자는 항상 public 이고 생략할 수 있다.
2) static 메소드(jdk 1.8) : 접근제한자가 항상 public 이고 생략할 수 있다.
5. 인터페이스에 있는 메소드는 반드시 재정의해야함.
package Week01.iface;
interface interA1{
int w = 10;
static int x = 20;
final int y = 30;
public static final int z = 40;
}
public class InterfaceTest {
public static void main(String[] args) {
// interA1 ap = new interA1(); //interface는 instance를 생성할 수 없다
// interA1.w = 100; //interface의 필드는 public static final이므로 값을 변경할 수 없다.
System.out.println("w =" + interA1.w); //w = 10
System.out.println("x =" + interA1.x); //x = 20
System.out.println("y =" + interA1.y); //y = 30
System.out.println("z =" + interA1.z); //z = 40
}
}
--------------------------------------------------------------------------
package Week01.iface;
interface interA2{
void aaa();
public abstract void bbb(); //구현부가 없음.
}
class interB2 implements interA2{
//A2의 aaa가, public abstract이므로 public으로 지정해야함.
//자식은 부모보다 넓은 접근제한자를 가져야 한다.
public void aaa() {
System.out.println("aaa 메소드");
}
public void bbb() {
System.out.println("bbb 메소드");
}
}
public class InterfaceTest2 {
public static void main(String[] args) {
interB2 bp = new interB2();
bp.aaa();
bp.bbb();
}
}
--------------------------------------------------------------------------
package Week01.pattern;
//template 패턴
//카페인 제조과정
abstract class CaffeineReferage{ //공통된 제조과정 fix
final void prepareRecipe() {
this.boilWater();
this.brew();
this.pourInCup();
this.addcndiments();
}
abstract void brew(); // 구체적으로 정확히 모름. 재정의하게 보냄.
abstract void addcndiments();
void boilWater() {
System.out.println("물 끓이는 중");
}
void pourInCup() {
System.out.println("컵에 따르는 중");
}
}
class Coffee extends CaffeineReferage{
void brew() { //재정의
System.out.println("필터를 통해 커피를 우려내는 중");
}
void addcndiments() {
System.out.println("설탕과 우유를 추가하는 중");
}
}
class Tee extends CaffeineReferage {
void brew() {
System.out.println("차를 우려내는 중");
}
void addcndiments() {
System.out.println("레몬을 추가하는 중");
}
}'Java' 카테고리의 다른 글
| Java - 다형성, 상속, 예외 (0) | 2019.07.12 |
|---|---|
| Java - Switch, 다중for문, Break문, 반복문복합, Singleton, Prototype패턴, 인터페이스, String, StringBuffer (0) | 2019.07.11 |
| Java - 일반화, 추상화, 클래스(생성자, this, super, 접근제한자, static, final), is a/has a, 상속, object class, 연산자, state 패턴, 클래스 다이어그램, 재귀함수 (0) | 2019.07.09 |
| 기본 알고리즘 (0) | 2019.07.08 |
| Java - Overloading, 가변인자, 배열, 메소드 (0) | 2019.07.08 |
