반응형
명령법(표기법)
/*
Pascal 표기법 : 대문자시작 + 2개이상 단어조합시 매단어 첫글자 대문자
(클래스명)
Camel 표기법 : 소문자시작 + 2개이상 단어조합시 매단어 첫글자 대문자
(변수명/메소드명)
int myAge;
Snake 표기법 : 소(대)문자 + 2개이상의 단어조합시 _ 연결
(변수명/메소드명/상수)
int my_age;
헝거리언 표기법 : 변수앞에 변수 성질나타낸다
int nAge;
int nCount;
boolean bOk = true;
▶ 데이터베이스에 따라서 변수 표기 방법이 다르기 때문에 숙지하고 있어야 한다.
*/
클래스로 데이터 만들기
클래스 : 물건을 생산하기 위한 설계도 도면
인터페이스 : 소비자가 객체를 사용방법
has a 포함 상속
is a 구현 상속
추상메서드 : 구현이 안된 메서드
아무것도 없는 상태에서 인터프리터로 언어를 읽어서 순서대로 실행시켜준다.
(인터프리터 : 실시간 해석 언어)
모든걸 미리 만들어놓지 않고, (변수나 객체) 런타임시에 생성이 된다.
(스택, 힙 등등)
alt + shift + s -> source 단축키
package vo;
/*
VO(Value Object)
1. 값을 저장관리 하는 객체
*/
public class PersonVo {
String name;
int age;
String addr;
@Override
public String toString() {
return String.format("[%s-%d-%s]", name,age,addr);
}
public PersonVo() {
}
public PersonVo(String name, int age, String addr) {
super();
this.name = name;
this.age = age;
this.addr = addr;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
}.
package mymain;
import java.util.ArrayList;
import java.util.List;
import vo.PersonVo;
public class MyMain_Person_list {
// 첨자이용 ArrayList 출력
// static이 없으면 인스턴스 메서드인데, 인스턴스 메서드는 객체를 생성해야 한다.
// 그러니, 객체를 생성하지 않고도 바로 사용하려면 static 메서드로 생성하면 된다.
static void useIndexDisplay(List<PersonVo> p_list2) {
System.out.println("---[useIndex]---");
for(int i = 0; i < p_list2.size(); i++) { // i = 0 1 2 3 4
PersonVo p = p_list2.get(i);
System.out.println(p);
}
}
public static void main(String[] args) {
PersonVo p = new PersonVo();
p.setName("참길동");
p.setAge(20);
p.setAddr("서울특별시 양천구 목5동");
PersonVo p2 = new PersonVo("차선일", 31, "서울특별시 양천구 목5동");
System.out.println(p.toString());
System.out.println(p2.toString());
// PersonNo 목록
List<PersonVo> p_list = new ArrayList<PersonVo>();
p_list.add(new PersonVo("선일1", 31, "서울시 양천구 목5동1"));
p_list.add(new PersonVo("선일2", 31, "서울시 양천구 목5동2"));
p_list.add(new PersonVo("선일3", 31, "서울시 양천구 목5동3"));
p_list.add(new PersonVo("선일4", 31, "서울시 양천구 목5동4"));
p_list.add(new PersonVo("선일5", 31, "서울시 양천구 목5동5"));
useIndexDisplay(p_list);
//
}
}
▶데이터 메모리를 아끼는 문자열 사용방법
- String formatter
static void test() {
// String 불변적 특징(String은 값을 바꿀 수 없다. 계속 새로운 객체를 만드는 것이다.)
String str = "a" + "b" + "c" + "d"; // 메모리 낭비 과다발생
// buffer : 임시저장소(미리 16칸을 만들어 놓는다)
// StringBuilder와 기능은 동일함(속도는 StringBuilder가 빠르다) 스레드 동기화가 안되기 때문에
StringBuffer sb = new StringBuffer(); // 16characters
sb.append("a");
sb.append("b");
sb.append("c");
sb.append("d");
String str2 = sb.toString();
// String.formatter( JDK5.0 later ) printf와 동일 (이것은 변수에 저장, printf는 출력)
String str3 = String.format("%s%s%s%s", "a","b","c","d");
System.out.println(str);
System.out.println(str2);
System.out.println(str3);
String name = "홍길동"; // %s
int age = 20; // %d
double length = 180.5; // %f
double weight = 70.5;
boolean bMarried = false; // %b or %B
System.out.printf("이름 : %s\n나이 : %d(살)\n신장 : %.1f(cm)\n기혼 : %b\n",
name, age, length, bMarried);
}
- 코드의 끝에 항상 마무리로 끝을 표시해주는 것을 습관화하자.
▶향상된 for문 (개선 루프)
public static void main(String[] args) {
String [] sido_array = {"서울", "경기", "인천", "대전"};
System.out.println("---개선 loop---");
// 배열/Collection
for(String sido : sido_array) {
System.out.println(sido);
}// 개선루프
static void loop(List<PersonVo> p_list2) {
System.out.println("---[개선loop]---");
for(PersonVo p : p_list2) {
System.out.println(p);
}// end-for
}// end-loop
▶디자인 패턴 : (개발방법론) 현업 개발자들이 어떠한 코드를 만들기 좋고 편리한 일종의 합리적인 패턴
▶Single-ton Pattern : 객체 1개만 생성 이용하자.
▶가비지컬렉터 : 힙 영역에서 사용하지 않고, 객체가 사용되지 않는 경우 데이터를 쓰레기통안에 넣어준다.
- 이 아이가 개입되면은 성능저하에 관여한다. 데이터 찌꺼기를 처리할 때, 작업이 딜레이 되기 때문이다.
- 그래서 객체를 1개만 생성해서, 효율적으로 메모리 관리를 하는게 좋다.
Access Modifier(접근제한자)
- : private
# : protected
+ : pulbic
(생략) : default
package mymain;
import java.util.Scanner;
public class _04_Example04_Jumin {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String jumin_no;
String yn = "y"; // 계속여부?
while(true) {
System.out.print("주민번호(xxxxxx-xxxxxxx):");
jumin_no = scanner.nextLine().trim();
// 주민번호 객체에게 주민번호를 전달한다.
Jumin ju = new Jumin();
ju.setJumin_no(jumin_no);
// 부가정보(출생년도/나이/띠/성별/지역/계절/간지) 추출
int year = ju.getYear();
int age = ju.getAge();
String tti = ju.getTti();
String gender = ju.getGender();
String season = ju.getSeason();
String local = ju.getLocal();
String ganji = ju.getGanji();
// String local = ju.getLocal();
System.out.println("---[결과]---");
System.out.printf("출생년도 : %d\n", year);
System.out.printf("나이 : %d(세)\n", age);
System.out.printf("띠 : %s(띠)\n", tti);
System.out.printf("성별 : %s\n", gender);
System.out.printf("태어난 계절 : %s\n", season);
System.out.printf("태어난 지역 : %s\n", local);
System.out.printf("갑자와 띠 : %s\n", ganji);
// 계속여부
System.out.println("계속(y/n)");
yn = scanner.nextLine();
//if(yn.equalsIgnoreCase("y") ==false) 소문자, 대문자 무시하고 계산한다.
if(yn.toLowerCase().equals("y") == false) {
break;
} else {
continue;
}
}// end-while
System.out.println("주민번호로 알아보는 방법이 끝났습니다.");
}
}
// int seleted = scanner.nextInt();
// System.out.println("확인할 정보를 입력하세요. 1.출생년도 2.나이 3.띠 4.성별 5.지역 6.계절 7.간지 8.나가기");
// if(seleted == 1) {
// int year = ju.getYear();
// System.out.printf("출생년도 : %d\n", year);
// } else if(seleted == 2) {
// // 나이
// } else if(seleted == 3) {
// // 나이
// } else if(seleted == 4) {
// // 나이
// } else if(seleted == 5) {
// // 나이
// } else if(seleted == 6) {
// // 나이
// } else if(seleted == 7) {
// // 간지
// } else if(seleted == 8) {
// break;
// }package mymain;
import java.sql.Date;
import java.util.Calendar;
public class Jumin {
private String jumin_no;
/*
내국인 외국인
남 여 남 여
1900 1 2 5 6
2000 3 4 7 8
1800 9 0
*/
// 방법1.
// char gender = jumin_no.charAt(7);
// 숫자형문자 -> 숫자 : '0' : 48 '1' : 49 '2' : 50
// int gender_no = gender - '0';
public void setJumin_no(String jumin_no) {
this.jumin_no = jumin_no;
}
public int getYear() {
String str_year = jumin_no.substring(0, 2);
int year = Integer.parseInt(str_year);
int gender_no = Integer.parseInt(jumin_no.substring(7,8));
switch(gender_no) {
case 1:
case 2:
case 5:
case 6: return year+1900;
case 3:
case 4:
case 7:
case 8: return year+2000;
}
return year + 1800;
}// getYear-end
public int getAge() {
Calendar cal = Calendar.getInstance();
int thisYear = cal.get(Calendar.YEAR);
// 자신의 메소드를 호출해서 정보를 얻어온다
int birth_year = this.getYear();
int age = thisYear - birth_year;
return age;
}// end:getAge()
// 12지
// 4 5 6 7 8 9 10 11 0 1 2 3 <- index (출생년도%12) : 0 ~ 11
// 자 축 인 묘 진 사 오 미 신 유 술 해
// 쥐 소 범 토 용 뱀 말 양 원 닭 개 돼
public String getTti() {
// 띠첨자 = 출생년도%12
int tti_index = this.getYear()%12;
String [] tti = {"원숭이", "닭", "개", "돼지", "쥐", "소", "호랑이", "토끼", "용", "뱀", "말", "양"};
return tti[tti_index];
}
// public String getTtii() {
//
// // 띠첨자 = 출생년도%12
// int tti_index = this.getYear()%12;
// switch(tti_index) {
// case 0 : return "원숭이";
// case 1 : return "닭";
// case 2 : return "개";
// case 3 : return "돼지";
// case 4 : return "쥐";
// case 5 : return "소";
// case 6 : return "호랑이";
// case 7 : return "토끼";
// case 8 : return "용";
// case 9 : return "뱀";
// case 10 : return "말";
// }
// return "양";
// }
public String getGender() {
/*
내국인 외국인
남 여 남 여
1900 1 2 5 6
2000 3 4 7 8
1800 9 0
000000-0000000
*/
int firstNum = Integer.parseInt(this.jumin_no.substring(7, 8));
if(firstNum %2 == 0) {
return "여자";
}
return "남자";
}
public String getSeason() {
// 345 봄 678 여름 91011 가을 1212
int month = Integer.parseInt(this.jumin_no.substring(2, 4));
if(month == 3 || month == 4 || month == 5) {
return "봄";
} else if(month == 6 || month == 7 || month == 8) {
return "여름";
} else if(month == 9 || month == 10 || month == 11) {
return "가을";
}
return "겨울";
}
public String getLocal() {
int local_num = Integer.parseInt(this.jumin_no.substring(8,10));
if(0 <= local_num && local_num <= 8) {
return "서울";
} else if(local_num <= 12) {
return "부산";
}
else if(local_num <= 15) {
return "인천";
}
else if(local_num <= 25) {
return "경기";
}
else if(local_num <= 34) {
return "강원";
}
else if(local_num <= 39) {
return "충북";
}
else if(local_num <= 41) {
return "대전";
}
else if(local_num == 44 || local_num == 96) {
return "세종";
}
else if(42 <= local_num && local_num <= 47) {
return "충남";
}
else if(local_num <= 54) {
return "전북";
}
else if(local_num <= 64) {
return "전남";
}
else if(local_num <= 66) {
return "광주";
}
else if(local_num <= 69 || local_num == 76 || local_num == 77) {
return "대구";
}
else if(local_num <= 75 || (78 <= local_num && local_num <= 81)) {
return "경북";
}
else if(local_num == 85 || local_num == 90) {
return "울산";
}
else if(local_num <= 84 || (86 <= local_num && local_num <= 93)) {
return "경남";
}
return "제주";
}
public String getGanji() {
// 10간
// 4 5 6 7 8 9 0 1 2 3 <- 년도%10(0~9)
// 갑 을 병 정 무 기 경 신 임 계
// 12지
// 4 5 6 7 8 9 10 11 0 1 2 3 <- 년도%12(0 ~ 11)
// 자 축 인 묘 진 사 오 미 신 유 술 해
int ganji_num1 = Integer.parseInt(this.jumin_no.substring(0,1));
int ganji_num2 = Integer.parseInt(this.jumin_no.substring(1,2));
int year = this.getYear();
int ganji_index1 = year%10;
int ganji_index2 = year%12;
String [][] ganji_array = {
{"경","신","임","계","갑","을","병","정","무","기"},{"신","유","술","해","자","축","인","묘","진","사","오","미"}
};
return ganji_array[0][ganji_index1] + ganji_array[1][ganji_index2];
}
}
제네릭 종결<Generic> Type
// 제네릭 사용하지 않은 경우
// Collection은 자바의 모든 객체를 저장할 수 있다.
List list = new ArrayList();
// 모든 타입은 Object 타입으로 업캐스팅이 되어서 저장된다.
list.add("안녕");// String
list.add(Integer.valueOf(20)); // Integer
list.add(10.5); // Double
list.add('A'); // Character
list.add(true); // Boolean
list.add(10L); // Long
list.add(1.0F); // Float
// 문제점 -> 몇번째 인덱스에 어떤 타입인지 일일이 알고 있어야 다운캐스팅이 가능하다.
// 내가 만들면, 알 수도 있다. 하지만, 남이 만든거라면, 어떤 타입인지 어떻게 알것인가..
// 즉, 원하는 데이터를 꺼내올때가 문제란 것이다. 제네릭은 이 안에 무슨 타입만 저장해! 하고 지정해주는 것이다.
if(list.get(0) instanceof String) {
String msg = (String) list.get(0);
} else if(list.get(0) instanceof Integer) {
Integer msg = (Integer) list.get(0);
}
// 제네릭 사용할 경우 : 저장타입이 결정되는 시점언제
List<String> sido_list = new ArrayList<String>();
sido_list.add("서울"); // 0
sido_list.add("경기"); // 1
sido_list.add("인천"); // 2
System.out.println("요소의 갯수 : " + sido_list.size());
System.out.println(sido_list.get(0));
// 내가만든 ArrayList 사용
MyArrayList myList = new MyArrayList();
myList.add("Hello");
myList.add(10);
myList.add(1.0);
System.out.println("요소의 갯수 : " + myList.size()); // 값 : 3
// 내가 클래스에서 메소드를 만들때 Object로 설정해놨기에 다운캐스팅 해야한다.
// String str = myList.get(0);
String str = (String) myList.get(0);
System.out.println(str.length()); // 값 : 5
- 기존에 제네릭을 사용하기전 ArrayList와 같이 만든 것
package util;
public class MyArrayList {
Object [] data = null;
public int size() {
// data 배열안에 값이 없으면(null) 0, 있으면 그 길이만큼
return (data == null) ? 0 : data.length;
}
public void add(Object newObj) {
// 1. 기존 배열 보다 1개 더 많게끔 임시배열 생성
Object [] imsi = new Object[this.size()+1];
// 2. 원래 배열값 -> 임시배열로 옮긴다.
for(int i = 0; i < this.size(); i++) {
imsi[i] = data[i];
}
// 3. 임시배열의 추가공간에 새데이터(newObj) 넣는다.
imsi[size()] = newObj;
// 4. 임시배열 -> data
data = imsi;
}// add-end
// 이 메소드를 불러올때 무슨 타입으로 불러올지 모르기에, 최상위 객체인 Object를 사용하는 것이다.
public Object get(int index) {
return data[index];
}// get-end
}
- 제네릭으로 변경
package util;
public class MyArrayList2<선일> {
// 일반적으로 제네릭 타입은 E : Element Type (타입이름은 자유)
선일 [] data = null;
public int size() {
// data 배열안에 값이 없으면(null) 0, 있으면 그 길이만큼
return (data == null) ? 0 : data.length;
}
public void add(선일 newObj) {
// 1. 기존 배열 보다 1개 더 많게끔 임시배열 생성
선일 [] imsi = (선일 [])new Object[this.size()+1];
// 2. 원래 배열값 -> 임시배열로 옮긴다.
for(int i = 0; i < this.size(); i++) {
imsi[i] = data[i];
}
// 3. 임시배열의 추가공간에 새데이터(newObj) 넣는다.
imsi[size()] = newObj;
// 4. 임시배열 -> data
data = imsi;
}// add-end
// 이 메소드를 불러올때 무슨 타입으로 불러올지 모르기에, 최상위 객체인 Object를 사용하는 것이다.
public 선일 get(int index) {
return data[index];
}// get-end
}
- 제네릭으로 만든 임의의 List 호출
// Integer Type만 저장할 수 있는 객체
MyArrayList2<Integer> lottoList = new MyArrayList2<Integer>();
lottoList.add(1);
lottoList.add(45);
// Generic으로 지정된 Type 외에는 다른 타입은 들어갈 수 없다.
// lottoList.add("안녕~~");
// String Type 저장할 수 있는 객체
MyArrayList2<String> fruitList = new MyArrayList2<String>();
fruitList.add("사과");
fruitList.add("딸기");
System.out.println(fruitList.get(0)); // 값 : 사과
System.out.println(fruitList.get(1)); // 값 : 딸기
System.out.println("---[과일목록]---");
for(int i = 0; i < fruitList.size(); i++) {
System.out.println(fruitList.get(i));
}
업캐스팅
업캐스팅 : 영역의 축소(자동형변환)
다운캐스팅 : 영역의 확장(강제형변환)
AdvanceCalc에서 업캐스팅을 하는 이유는? BascCalc에 있는 메소드를 사용하기 위해서?
업캐스팅을 사용하는 이유
Animal[] animals = new Animal[2];
animals[0] = new Dog();
animals[1] = new Cat();
for (Animal animal : animals) {
animal.eat(); // 각각의 동물이 먹는 행동을 출력합니다.
}
- 즉, 업캐스팅은 자식 클래스의 고유 기능을 사용하지 못하게 하는 대신, 부모 클래스 타입을 통해 다양한 자식 클래스 객체를 한꺼번에 다룰 수 있도록 해주는 장점이 있습니다.
package util;
public class BaseCalc /* extends Object */{
public int plus(int a, int b) {
return a+b;
}
public int minus(int a, int b) {
return a-b;
}
public int multiply(int a, int b) {
return a*b;
}
public int divide(int a, int b) {
return b == 0 ? 0 : a/b;
}
}package util;
import java.util.Iterator;
public class AdvanceCalc extends BaseCalc {
public int hap(int n) {
int sum = 0;
for(int i = 1; i < n; i++) {
// sum += i;
// 이미 선언되어있는 부모의 메소드를 사용
sum = super.plus(sum, i);
}
return sum;
}
// n's m승
public int pow(int n, int m) {
int result = 1;
for(int i = 0; i < m; i++) {
// result *= n;
result = super.multiply(result, n);
}
return result;
}
public double pow(double n, double m) {
int result = 1;
for(int i = 0; i < m; i++) {
// result *= n;
result = super.multiply((int)result, (int)n);
}
return result;
}
}package mymain;
import util.AdvanceCalc;
import util.BaseCalc;
public class _06_Exma06_상속 {
// BaseCalc 영역만 사용한다
static void useOnlyBaseCalc(BaseCalc bc) {
// BaseCalc bc = ac (up-casting)
int a = 10, b = 5, res;
res = bc.plus(a, b);
System.out.printf("BaseCalc : %d + %d = %d\n", a, b, res);
}
public static void main(String[] args) {
// AdvanceCalc, BaseCalc, Object 타입 모두 사용 가능하다.
AdvanceCalc ac = new AdvanceCalc();
// ac가 더 넓은 범위이기에 함축된 범위의 Object 타입을 업캐스팅이 가능하다.
Object ob = ac;
// ac가 더 넓은 범위이기에 함축된 범위의 BaseCalc 타입을 업캐스팅이 가능하다.
BaseCalc bc = ac;
useOnlyBaseCalc(ac);// 위 static 메소드에 매개변수에 사용된 참조변수가 BaseCalc이기에,
// ac를 넘겨도, AdvanceCalc 타입 기능은 사용 못한다.
useOnlyObject(ac);
// 애초 AdvanceCalc랑은 상관없는 Object 타입을 생성해놓고 AdvanceCalc로 확장을 하려고 하면 안된다.
// Object ob1 = new Object();
// AdvanceCalc ac1 = (AdvanceCalc) ob1;
}// main-end
// Object 영역만 참조(사용)해라
static void useOnlyObject(Object ob) {
// Object ob = ac
System.out.println(ob);
// Object -> AdvanceCalc 영역까지 확장
AdvanceCalc ac = (AdvanceCalc)ob;
int n = 10, result =0;
result = ac.hap(n);
System.out.printf("Object->AdvanceCalc : %d까지의 합 = %d\n", n, result);
}
}
반응형
'java(2)↗' 카테고리의 다른 글
| java 람다식(+다형성 추가 설명) (0) | 2024.05.08 |
|---|---|
| java 요약노트 (0) | 2024.05.08 |
| java 컬렉션 프레임워크 (Set, Map) (0) | 2024.05.03 |
| java 컬렉션 프레임워크(List) (0) | 2024.05.03 |
| java 제네릭 (0) | 2024.05.03 |