Constructor(생성자)
package sample26_constructor;
public class MyClass {
public static void main(String[] args) {
/*
constructor : 생성자
함수(메소드)
메소드명은 클래스명과 동일하다.
return value가 없다.
overload가 가능하다. // 이름이 같은 함수여도 매개변수 개수나 타입이 다르다.
class를 생성 시에 자동 호출된다.
별도의 호출이 불가능하다. (!= 초기화)
생략이 가능하다.
초기값을 넣어서 사용하거나
destructor : 소멸자 // 지금은 사라짐.
소멸 시에 호출되는 함수
*/
// BaseClass bc = { 1, "홍길동" }; 다른 클래스에서 함수 선언하고 싶음. -> 에러 => constructor
// BaseClass bc = new BaseClass();
// BaseClass bc = new BaseClass(3);
BaseClass bc = new BaseClass(3, "성춘향");
}
}
class BaseClass{
int number;
String name;
public BaseClass() {
System.out.println("BassClass BaseClass()");
}
public BaseClass(int num) {
System.out.println("BassClass BaseClass(int num)");
}
public BaseClass(int num, String na) {
System.out.println("BassClass BaseClass(int num, String na)");
number = num;
name = na;
}
public void method() {
}
public void method(int n) { // OverLoad : 매개변수로 구분. 이름은 같은데 다른 함수.
// 동일한 기능을 하는 함수들을 이름을 같게 프로그래밍 함.
}
}This
package sample27_this;
public class MainClass {
public static void main(String[] args) {
/*
this 키워드(pointer) : 그 객체의 주소(참조)
*/
MyClass clsOne = new MyClass();
System.out.println(clsOne);
System.out.println(clsOne.getThis());
clsOne.method();
// MyClass clsTwo = new MyClass();
// System.out.println(clsTwo);
// MyClass cls =new MyClass("tom");
// MyClass cls = new MyClass();
}
}
class MyClass{
String name;
public MyClass() {
this("john"); // this를 서로 쓰면 서로 호출하므로 error
System.out.println("MyClass MyClass()");
}
public MyClass(String name) {
// this(); // 기본 생성자 호출
// MyClass cls =new MyClass("tom"); -> 한 줄로 두개의 overload 한꺼번에 출력함
System.out.println("MyClass MyClass(String name)");
this.name = name; // left name : 전역 변수(멤버 변수), right name : 지역 변수
}
MyClass getThis() { // 0번째 매개변수로 모든 메소드에 추가되어 있다. (MyClass this)
return this;
}
void method() {
System.out.println(this);
this.name = "일지매"; // this 생략해서 사용해왔음.
this.getThis();
}
// this를 꼭 써야하는 경우 -> 매개변수 충돌났을 때
void setName( String name ) {
// name = name; // compiler는 좌 name과 우 name을 구분하지 못함.
this.name = name;
}
void setnameMethod() {
String name = "홍길동"; // local 변수
this.name = name;
}
}CRUD
Create 생성 - 추가
Read 검색
Update 수정
Delete 삭제
Address Book
Main Class
package main;
import java.util.Scanner;
import dao.AddressDao;
public class MainClass {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
AddressDao dao = new AddressDao();
boolean end = false; // break 두 번 안 쓰고 while문 탈출 방법
// menu
out:while(true) {
// AddressDao dao = new AddressDao();
// 이 위치면 while문 다시 오면 다시 리셋 됨.
System.out.println("<< 주소록 >>");
System.out.println("1. 지인 추가");
System.out.println("2. 지인 삭제");
System.out.println("3. 지인 검색");
System.out.println("4. 지인 수정");
System.out.println("5. 모두 출력");
System.out.println("6. 파일 저장");
System.out.println("7. 종료");
System.out.println(">> ");
int choice = sc.nextInt();
switch(choice) {
case 1:
dao.insert();
break;
case 2:
dao.delete();
break;
case 3:
dao.select();
break;
case 4:
dao.update();
break;
case 5:
dao.allDataPrint();
break;
case 6:
dao.filesave();
break;
case 7:
// System.exit(0); // 강제 종료: 프로그램까지 다 꺼버리니까 주의
// return; -> break 대신 쓸 수 있으므로 잘 안 쓴다.
System.out.println("프로그램을 종료합니다.");
break out;
default:
}
}
}
}data
package data;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class FileProc {
// 파일 쓰기, 읽기
private File file = null;
public FileProc(String filename) {
file = new File("c:\\tmp\\" + filename + ".txt"); // 파일 생성
// 실제 파일이 생성되는 부분
try {
if(file.createNewFile()) {
System.out.println("파일 생성 성공!");
}else {
System.out.println("기존의 파일이 있습니다.");
}
}catch (IOException e) {
e.printStackTrace();
}
}
public String[] read() {
String datas[] = null;
try {
BufferedReader br = new BufferedReader(new FileReader(file));
// 데이터의 총 갯수를 구한다.
int count = 0;
String str = "";
while((str = br.readLine()) != null) { // 파일 끝까지 읽기 위해 반복
count++;
}
br.close();
// 배열 할당
datas = new String[count];
// 파일로부터 배열에 저장
br = new BufferedReader(new FileReader(file)); // 포인터 초기화
// 맨 밑에 있는 포인터를 다시 맨 위로 올림.
int w = 0;
while((str = br.readLine()) != null) {
datas[w] = str;
w++; // 이 줄 없이, datas[w++] = str; 로 해도 됨.
}
br.close();
}catch (FileNotFoundException e) { // Exception만 적으면, 모든 exception
e.printStackTrace();
}catch (IOException e) {
e.printStackTrace();
}
return datas;
}
public void write(String datas []) {
try {
PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(file)));
for (int i = 0; i < datas.length; i++) {
pw.println(datas[i]);
}
pw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("파일에 저장되었습니다.");
}
}DAO(Data Access Object)
실제로 DB에 접근하는 객체다. DAO는 프로젝트의 서비스 모델과 실제 데이터베이스를 연결하고 CRUD를 수행하는 class 역할
package dao;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import data.FileProc;
import dto.HumanDto;
// Data Access Object
// 데이터를 접근하고 편집하는 object
//추가, 삭제, 검색, 수정
public class AddressDao {
Scanner sc = new Scanner(System.in);
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 변수를 100개 생성
private HumanDto humanArr[] = new HumanDto[100];
private int count;
private FileProc fp = null; // composition : 구성, 작문
public AddressDao() { // 객체 생성
// 변수들에 객체를 생성
/*
for(int i=0; i < humanArr.length; i++) {
humanArr[i] = new HumanDto();
}
*/
fp = new FileProc("address"); // fp = FileProc
fileload();
// 테스트용 데이터
/*
humanArr[0] = new HumanDto("홍길동", 24, "123-4567", "서울시", "절친");
humanArr[1] = new HumanDto("성춘향", 16, "234-4567", "남원시", "여사친");
humanArr[2] = new HumanDto("일지매", 22, "135-4567", "부산시", "동호회");
humanArr[4] = new HumanDto("홍길동", 30, "555-4567", "서울시", "친구");
*/
// 데이터를 새로 읽었을 때 배열에 할당되지 않는 공간을 탐색
int nextcount = 0;
for (int i = 0; i < humanArr.length; i++) {
// 생성된 객체를 검사 삭제한 데이터 검사, 제외
if (humanArr[i] != null) {
nextcount++;
}
}
count = nextcount;
// count = 0; -> 저장된 데이터에서 지인추가하면 첫 째줄 삭제 됨.
}
// 추가, 삭제, 검색, 수정
public void insert() {
System.out.println("지인을 추가합니다.");
System.out.print("이름 = ");
String name = sc.next();
System.out.print("나이 = ");
int age = sc.nextInt();
System.out.print("전화번호 = ");
String phone = sc.next();
System.out.print("주소 = ");
String address = "";
try {
address = br.readLine();
} catch(IOException e) {
e.printStackTrace();
}
System.out.print("메모 = ");
String memo = sc.next();
/*
humanArr[count].setName(name);
humanArr[count].setAge(age);
humanArr[count].setAddress(address);
humanArr[count].setMemo(memo);
*/
// OR
// 위에 for문을 이용하지 않았다면(메모리 차지를 안했다면)
humanArr[count] = new HumanDto(name, age, phone, address, memo);
count++;
}
public void delete() {
System.out.print("삭제할 지인의 이름 = ");
String name = sc.next();
// 검색
int index = search(name);
if(index == -1) {
System.out.println("지인의 정보를 찾을 수 없습니다.");
}
else if(index != -1) {
// 삭제
humanArr[index].setName("");
humanArr[index].setAge(0);
humanArr[index].setPhone("");
humanArr[index].setAddress("");
humanArr[index].setMemo("");
System.out.println("지정한 지인의 정보를 삭제하였습니다.");
}
}
public void select() { // 동명이인도 고려
// 검색
System.out.print("찾을 지인의 이름을 입력하시오.");
String name = sc.next();
int index = search(name);
/*
// 동명이인 찾기.
for(int i = 0; i < humanArr.length; i++) {
if(humanArr[i] != null
&& name.equals(humanArr[i].getName())) {
System.out.println(humanArr[i].toString());
}
} // 요건 데이터 찾으면서 바로 출력함.
*/
// 동명이인 찾기, 찾을 사람이 몇명인지?
int count = 0;
for(int i = 0; i < humanArr.length; i++) {
if(humanArr[i] !=null
&& name.equals(humanArr[i].getName())) {
count++;
}
}
if(count<1) {
System.out.println("검색한 지인을 찾을 수 없습니다.");
return;
}
HumanDto hdto[] = new HumanDto[count];
int n = 0;
for (int i = 0; i < humanArr.length; i++) {
if (humanArr[i] != null
&& name.equals(humanArr[i].getName())) {
hdto[n] = humanArr[i];
n++;
}
}
// 찾은 데이터의 배열
for (int i = 0; i < hdto.length; i++) {
System.out.println(hdto[i].toString());
}
}
public void update() {
// 검색
System.out.print("수정할 지인의 이름을 입력하시오. : ");
String name = sc.next();
int index = search(name);
// 이름이 없을 시
if(index == -1) {
System.out.println("지인의 정보를 찾을 수 없습니다.");
return;
}
// 수정
System.out.println(humanArr[index].toString());
System.out.print("수정할 항목을 입력하시오. : ");
String prov = sc.next();
//전화번호
if(prov.equals("전화번호") == true) {
System.out.print("바꿀 번호를 입력하시오. : ");
String rePhone = sc.next();
humanArr[index].setPhone(rePhone);
}
// 주소
else if(prov.equals("주소") == true) {
System.out.print("바꿀 주소를 입력하시오. : ");
String reAddress = sc.next();
humanArr[index].setAddress(reAddress);
}
//메모
else if(prov.equals("메모") == true) {
System.out.print("바꿀 메모를 입력하시오. : ");
String reMemo = sc.next();
humanArr[index].setPhone(reMemo);;
}
System.out.println("정상적으로 수정이 완료되었습니다.");
}
// 검색기능 클래스
private int search(String name) { // 다른 외부에서 사용 안 하므로 private
int index = -1;
for(int i = 0; i < humanArr.length; i++) {
if( humanArr[i] != null
&& name.equals(humanArr[i].getName())) {
index = i;
break;
}
}
return index;
}
public void allDataPrint() {
for(int i = 0; i < humanArr.length; i++) {
if(humanArr[i] != null
&& humanArr[i].getName().equals("") == false) {
// 지워진 부분도 검색되므로 humanArr[i].getName().equals("") == false
System.out.println(humanArr[i].toString());
} // if 문
} // for 문
} // allDataPrint 문
public void filesave() {
// 실제 배열에 들어 있는 데이터
int count = 0;
for (int i = 0; i < humanArr.length; i++) {
// 생성된 객체를 검사 삭제한 데이터 검사, 제외
if (humanArr[i] != null && !humanArr[i].getName().equals("")) {
count++;
}
}
String dataArr[] = new String[count];
/*
데이터 들어가는 방식
이름나이전화번호주소메모
홍길동24123-4567서울시친구 -> x 나중에 데이터 못 불러옴.
홍길동*24*123-4567*서울시*친구
*/
count = 0;
for (int i = 0; i < humanArr.length; i++) {
if (humanArr[i] != null &&
!humanArr[i].getName().equals("")) {
// i=2 데이터 삭제됐다면, count = 0 1 2 - i = 0 1 3
dataArr[count] = humanArr[i].toString();
count++;
}
}
fp.write(dataArr);
}
public void fileload() { // 함수는 소문자로 사용해도 무방, 변수는 대문자 섞어줘야 함.
String datas[] = fp.read();
/*
for (String s : datas) { // 제대로 로드 되는 지 확인 코드
System.out.println(s);
}
*/
for (int i = 0; i < datas.length; i++) {
String split[] = datas[i].split(":"); // split length -> 5
// split[0] -> 이름
// split[1] -> 나이
humanArr[i] = new HumanDto(split[0],
Integer.parseInt(split[1]),
split[2],
split[3],
split[4]);
}
}
}DTO(Data Transfer Object)
계층간 데이터 교환이 이루어 질 수 있도록 하는 객체.
- 유저가 입력한 데이터를 DB에 넣는 과정을 보겠습니다.
- 유저가 자신의 브라우저에서 데이터를 입력하여 form에 있는 데이터를 DTO에 넣어서 전송합니다.
- 해당 DTO를 받은 서버가 DAO를 이용하여 데이터베이스로 데이터를 집어넣습니다.
package dto;
// Data Transfer Object : 쓰기, 읽기
// VO : Value Object : 읽기 전용
// 주소록의 한명의 데이터를 담는 object
public class HumanDto {
// 사람의 정보에 항목(column)
// 이름, 나이, 전화번호, 주소, 메모
private String name;
private int age;
private String phone;
private String address;
private String memo;
public HumanDto() {
}
public HumanDto(String name, int age, String phone, String address, String memo) {
this.name = name;
this.age = age;
this.phone = phone;
this.address = address;
this.memo = memo;
}
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 getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getMemo() {
return memo;
}
public void setMemo(String memo) {
this.memo = memo;
}
@Override
public String toString() {
/*
return "HumanDto [name=" + name + ", age=" + age + ", phone=" + phone + ", address=" + address + ", memo="
+ memo + "]"; 파일에 데이터 저장을 위해 형식을 변환해야 함.
*/
return name + ":" + age + ":" + phone + ":" + address + ":" + memo;
}
}
Today I Learned