**property 와 getter & setter
1.접근자 메소드
=>인스턴스 변수에 접근하기 위한 메소드
=>객체 지향 프로그래밍에서는 인스턴스 변수에 인스턴스(객체)가 직접 접근하는 것을 권장하지 않습니다.
인스턴스가 인스턴스 변수에 직접 접근하게 되면 예기치 않은 상황이 발생할 수 있기 때문입니다.
변수는 일반적으로 동기화(Synchronized)의 대상이 아닙니다.
대다수의 프로그래밍 언어가 동기화의 단위가 메소드 또는 인스턴스입니다.
a 가 data를 수정하고 있는데 b가 못 들어오게끔 lock을 걸어야 한다.
나한테 잔액이 balance : 1000
인터넷 뱅킹 atm
두개 동시에 수정 가능
A가 출금을 할 경우 lock이 생긴다.
B에서 lock이 되여있어서 사용못한다.
lock이 메소드 방식으로 한다. 변수로 하면 언제 끝나는지 모르겠다.
알림을 줘야 한다. 그럼 B에서 가면 된다.
메소드는 작업이니깐 작업이 끝나면 알림이 가능하다. 동기화의 대상이 메소드이다.
변수는 알림기능이 불가하다.
일을 해주는 것이 메소드이다.
1).getter
=>인스턴스 변수의 데이터를 리턴해주는 메소드
=>메소드의 리턴 타입은 인스턴스 변수의 리턴 타입과 동일하게 만듭니다.
=>메소드의 이름은 get변수명 으로 하는데 변수명의 첫글자는 대문자로 하고 변수의 자료형이 boolean인 경우는 get대신에 is를 사용하는 것이 관례
=>메소드의 내용은 인스턴스 변수를 리턴하는 것만 하는 것이 보통입니다.
2).setter
=>인스턴스 변수의 값을 설정하는 메소드
=>메소드의 리턴 타입은 void
=>메소드의 이름은 set변수명으로 하는데 변수명의 첫글자는 대문자
=>인스턴스 변수와 동일한 자료형의 매개변수를 받아서 인스턴스 변수에 그 값을 저장하는 내용을 소유
=>저장할 때는 다른 내용을 추가하기도 하는데 저장하기 전에 유효성 검사를 해서 저장 가능한 데이터인지 확인하는 작업이나 값이 변경된다는 내용을 다른 곳에 알려주기도 합니다.
key - Value Observing이라고도 합니다.
예: 신용도 바꿔면 메소드 온다든가
class T{
private int age; //private 은 클래스 내부에서만 사용이 가능
private String name;
//setter 메소드
public void setAge(int n){
age = n;
}
public void setName(String n){
name = n;
}
//getter 메소드
public int getAge(){
return age;
}
public String getName(){
return name;
}
}
T ob = new T(); //인스턴스 생성
ob.setAge(50);
ob.setName("park");
System.out.println("이름:" + ob.getName());
3)최근에 등장한 IDE들은 대부분 접근자 메소드를 자동으로 만들어주는 기능을 제공
4)권장사항인데 인스턴스 변수가 SCALA DATA가 아닌 배열이나 List인 경우 인덱스를 받아서 하나만 가져오거나 하나만 수정하는 메소드도 만드는 것을 권장합니다.
2.Property(속성)
=>인스턴스가 변수를 호출하는 것처럼 사용하지만 실제로는 getter나 setter와 같은 접근자 메소드를 호출하는 것
=>VB,VC#,PYTHON,KOTLIN,SWIFT등에서는 이 프로퍼티를 지원=>여기에서는 VECTOR이나 지원해서 그렇다. 인스턴스 변수 잘 사용하지 않는다.
?.X = 10(set x하는 것이다.)
=>java에서는 지원을 하지 않지만 java web programming 에서 EL을 이용해서 이 프로퍼티를 지원합니다.
3.DTO(DATA Transfer Object, Variable Object, Domain Class)
=>여러개의 정보를 묶어서 하나로 만들기 위한 클래스
어떤 것을 묶어서 하나로 만들것인가
4.실습 -DTO클래스를 만들고 main에서 클래스의 인스턴스를 만들고 내부 데이터 사용
1). DTO클래스
public class Student {
//인스턴스 변수 선언
private int num;
private String name;
private String major;
//접근자 메소드
//오른쪽 마우스 클릭 ->Source ->Generate getters and setters ->select All -> Generate
public int getNum() {
return num;
}
public void setNum(int num) {
//this가 붙으면 메소드 내부에서는 찾지 않고
//메소드 외부에서 먼저 찾습니다.
//this.num은 메소드 외부에 있는 인스턴스 변수 num이고
//num 은 메소드의 매개변수 num이 됩니다.
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
}
2) main 메소드를 소유한 클래스
public static void main(String[] args) {
// Student 클레스의 인스턴스 생성
Student student = new Student();
//인스턴스 변수에 값을 설정
student.setNum(1);
student.setName("park");
student.setMajor("CS");
//인스턴스 변수의 값 가져오기
System.out.println("번호:"+student.getNum());
System.out.println("이름:"+student.getName());
System.out.println("전공:"+student.getMajor());
}
**Recursion - Recursive Call(재귀 호출)
=>메소드가 메소드 내부에서 자신의 메소드를 다시 호출 하는 것
=>메소드는 호출되면 자신의 메모리 영역(Stack)을 생성하고 자신의 작업이 종료되면(return)자신의 메모리 영역을 해제합니다.
메소드의 작업이 종료되기 전에 다른 메소드를 호출하면 Stack이 쌓이게 됩니다.
메모리 사용량이 늘어나고 실행의 결과도 여러 번 되돌아 가는 구조를 갖기 때문에 늦게 나오게 됩니다.
=>알고리즘을 표현할 때 쉽게 표현할 수 있는 경우가 많아서 종종 이용합니다.
10까지의 합: 10 + 9 까지의 합(9+8까지의 합)
=>위와 같은 형태로 합을 구할려고 했는데 결과에 다시 합이 나오는 경우
=>이런 경우에는 반드시 종료 시점이 있어야 합니다.
합의 경우는 1까지의 합은 1 이렇게 종료 시점이 명확하게 있어야 합니다.
=>재귀로 구현 할 수 있는 것들로는 합계, 팩토로얼(곱), 피보나치 수열, 하노이의 탑, 퀵 정렬이나 병합 정렬등이 있습니다.
재귀 메소드 구현 방법
리턴타입 메소드이름(리턴타입과 동일한 자료형 매개변수이름){
if(정료조건){
return 값;
}else{
return 메소드이름(매개변수);
}
}
=>매개변수로 대입되는 데이터가 참조형이라면 return을 하지 않을 수도 있습니다.
1-n까지의 합을 구해주는 메소드(재귀를 이용)
int hap(int n){
if(n ==1){
return 1;
}
return n + hap(n-1);
}
return n + hap(n-1); =>합이 합을 계속 하면 중단 할수 없어서 중단 조건을 만들어야 한다.
4까지의 합
4 + hap(3)
4 + 3 + hap(2)
4 + 3 + 2 + hap(1)
다음에는 1이니깐 return 1이 된다. 4+3+2+1
=>재귀를 만들 때 주의할 점은 반드시 중단을 하거나 아무일도 하지 않는 조건을 만들어야 한다는 것입니다.
그렇지 않으면 무한 반복하다가 프로그램이 메모리 부족으로 종료됩니다.
클래스 : 모형 설계도 공통된 내용
저정 변수
일 : 메소드
인스턴스 :제품
1fibonacci수열
1,1,2,3,5,8,13,21,34,55,89...
f2:1
f1:1
result :2
f2 = f1
f1 =result
result = f2+f1
첫번째와 두번째 항은 무조건 1
세번째 항 부터는 앞쪽 2개 항의 합
fn = f(n-1) + f(n-2)
단 f1= 1, f2 =1
재귀로 가능한 이유
f(10) ->f(9) + f(8)
감독관 배치 : 첫번째 감독관하고 두번째 감독관은 첫번쨰 빼고 .....
1)재귀를 이용하지 않고 해결
public int fibo1(int n){
if (n == 1 || n ==2){
return 1;
}
//if에 return이 있으면 메소드 수행이 종료된다. 그래서 else사용할 필요 없다.
else{
//피보나치 수열의 값을 저장할 변수
int result = -1;
//계산할 값 이전 2번째 항의 값을 저장할 변수
int f2 = 1;
//계산할 값 이전 1번째 항의 값을 저장할 변수
int f1= 1;
for(int i = 3; i <= n ; i= i+){
result = f2 + f1;
f2= f1;
f1 =result;
}
//피보나치 수열의 값 리턴
return result;
}
}
2)재귀를 이용해서 해결
public int fibo2(int n){
if(n ==1 || n == 2){
return 1;
}else{
return fibo2(n-1) + fibo2(n-2);
}
}
메소드 호출 -> 스택 1개
fibo1(10)
stack 1메가 있으면 해결 가능하다.
피보나치 수열은 stack 의 개수가 늘어나서 메모리가 많아야 한다.
1).stack은 1메가 가지고 한다 그래서 피보나치는 메모리 방면에서 고려해야 한다.
2).fibo1은 한번 계산하면 끝난다.
fibo2는 시간도 많이 쓸수 밖에 없다. 왜냐하면 계산하면 돌아가야 한다.
느리고 시간이 많이 사용한다.
하노이탑 알고리즘 : 최적으로 옮기는 것
https://hyeonstorage.tistory.com/355
1.B를 2에 올린다.
2.A를 3에 올린다.
3.B를 3에 올린다.
1.C를 3에 올린다.
2. B를 2에 올린다.
3. C를 2에 올린다.
4. A를 3에 올린다.
5. C를 1에 올린다.
6. B를 3에 올린다
7. C를 3에 올린다.
그래서 하노이탑은 2의 n제곱의 -1 최적이다.
목적지 와 옮기는것
재귀는 메모리가 많을 쓰고 시간이 느리다.
재귀를 사용하지 않을 경우 빨리 나오는데
재귀를 사용하면 속도가 많이 느러진다.
c -> 성능은 높은데 난이도가 높다
python->성능은 낮은데 난이도가 낮다. => 빠를 가능성이 높다.
메모리 방면에서도 고려해야 한다.
퀵sort
5 3 8 4 9 1 2
보통은 pivot을 첫번째 것으로 정하는데 책에서는 보통 random으로 설정한다.
퀵sort 도 재귀를 사용하기 때문에 속도가 늦어질 수 있다.
5 3 8 4 9 1 2
1.5를 pivot로 설정한다. 3 4 1 2 5 8 9
5보다 작은 것을 왼쪽 5보다 큰 것을 오른쪽으로 이동한다.
3.왼쪽에서 3을 pivot로 설정한다. 3 4 1 2 중에서
오늘쪽에서 8를 pivot로 설정한다. 8 9 중에서
1 2 3 4 5 8 9
4. 왼쪽에서 1 2중에서 1를 pivot로 설정한다.
한번 밖에 안되서
data 나열
pivot를 추측한다.
모든 데이터와 비교해서 pivot보다 작으면 왼쪽 크면 오른쪽
piov설정 후 quick sort
분할된 배열의 데이터 개수가 한개가 될때 까지 계속 수행한다.
sort =>quick sort
퀵 sort =>퀵 sort한다.
******
피본나치 수열
배열 만들고 출력 -> 합계 평균 -> 최소값의 위치 -> 정렬 ->선택, 버블 삽입
->퀵
string :문자열 메소드 구현
알고스팟 =>python으로 간단한 문제 들이 있다.
정올
2.피보나치 수열 확인
main을 소유한 클래스 에 작성: 메소드의 코드를 읽어보고 매개변수를 50정도로 늘려서 둘의 차이를 확인
Main.java
// 재귀를 이용하지 않고 n번째 피보나치 수열의 값을 리턴하는 메소드
//1 1 2 3 5 8 13 21 34 55
public static int fibo1(int n) {
// 첫번째나 두번째는 무조건 1
if (n == 1 || n == 2) {
return 1;
}
// 세번째 부터는 이전 2개 항의 합
else {
int result = -1;
// 현재 계산할 항의 이전 두번째 항의 값을 저장할 변수
int f2 = 1;
// 현재 계산할 항의 이전 첫번째 항의 값을 저장할 변수
int f1 = 1;
for (int i = 3; i <= n; i++) {
// 이전 2개 항의 합을 계싼하고 2개 항을 다음 항으로 이동
result = f2 + f1;
f2 = f1;
f1 = result;
}
return result;
}
}
//재귀를 이용해서 피보나치 수열의 값을 찾아주는 메소드
public static int fibo2(int n) {
if (n == 1 || n == 2) {
return 1;
} else {
//fibo2 메소드 네에서 fibo2를 호출하기 때문에 재귀라고 함
return fibo2(n - 1) + fibo2(n - 2);
}
}
public static void main(String[] args) {
// static은 static밖에 못 부른다.
// class는 역할 별로 하는 것이 좋다.
// 현재 클래스 내부에 있는 메소드를 호출할 때는 이름만 기재하면 됩니다.
int r = fibo1(50);
System.out.println("r: " + r);
// 재귀함수가 늦다. stack은 종료되면 없어진다.
r = fibo2(50);
System.out.println("r: " + r);
}
**Constructor(생성자)
=>인스턴스를 만들 때 호출하는 메소드
=>생성자는 반드시 new라는 예약어와 함께 호출
1.자바에서의 생성자
1)클래스를 만들면 매개변수가 없는 기본 생성자가 제공되는데 클래스 안에 생성자를 만들면 이 생성자는 소멸됩니다.
2)생성자의 이름은 클래스이름으로 만들어야 합니다.
3)생성자 오버로딩(메소드 이름은 같고 매개변수의 개수나 자료형이 다른 경우)이 가능합니다.
Temp.java파일 만들기
public class Temp{
public int x;
}
javac Temp.java
javap -c Temp > Temp.bc
public Temp{
public int x ;
}
init하는 목적이
생성자 추가
public class Temp{
public int x;
public Temp(){
}
}
생성자에 내용이 없을 때 결과는 같다.
public class Temp{
public int x;
public Temp(int y){
x = y;
}
}
2.생성자를 만드는 목적
=>인스턴스 변수의 값을 초기화할 목적으로 많이 생성
=>인스턴스가 생성될 때 다른 작업을 같이 수행하고자 하는 경우에도 생성
3.생성자를 만들때 주의할 점
=>매개변수가 없는 생성자를 default constructor라고 하는데 이 생성자가 없는 경우 생성자를 호출할 때 반드시 매개변수를 대입해야 합니다.
=>default constructor가 없는 클래스로 부터 상속받는 경우에는 반드시 생성자를 만들어서 상위클래스의 생성자를 호출하는 구문을 만들어 주어야 합니다.
이 경우는 andriod에서 많이 발생
4.실습
1).id와 pw를 문자열로 저장할 수 있는 클래스 생성 -Member
public class Member {
private String id;
private String pw;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPw() {
return pw;
}
public void setPw(String pw) {
this.pw = pw;
}
}
2)main메소드를 소유한 실행 클래스를 만들고 main메소드 안에서 인스턴스를 만들고 값을 저장한 후 값을 출력
// Member 클래스의 인스턴스를 생성
//자바 개발자의 대부분은 인스턴스를 1개만 만드는 경우 클래스 이름의 첫글자만
//소문자로 변환해서 이름을 생성을 합니다.
//자바 개발을 할 때는 인스턴스를 자동으로 생성해주는 스프링 프래임워크를 많이 사용하는데
//스피링이 이름을 만들 때 이 규칙을 적용
Member mem1 = new Member();
System.out.println("id:" +mem1.getId() +" pw:" +mem1.getPw());
5.생성자를 별도로 만들지 않으면 인스턴스 변수의 값들은 기본값으로 채워집니다.
1)기본값
boolean ->false
정수 ->0
실수 ->0.0
나머지는 null
2)위의 실습 결과는 id는 null그리고 pw는 null이 출력
3)모든 인스턴스들이 id는 root pw는 1234로 초기화된 상태에서 시작하도록 하고자 함
=>인스턴스를 만들고 setter .메소드를 호출해서 id와 pw값을 변경해서 해결 가능
Member mem1 = new Member();
mem1.setId("root");
mem1.setPw("1234");
System.out.println("id:" +mem1.getId() +" pw:" +mem1.getPw());
인스턴스를 1개만 생성한다면 위의 방법을 이용하는 것이 나쁘지 않지만 여러 개를 생성해야 하는 경우 매변 위와 같은 작업을 하는 것은 비효율적입니다.
Member mem1 = new Member();
mem1.setId("root");
mem1.setPw("1234");
System.out.println("mem1.id:" +mem1.getId() +" mem1.pw:" +mem1.getPw());
Member mem2 = new Member();
mem2.setId("root");
mem2.setPw("1234");
System.out.println("mem2.id:" +mem2.getId() +" mem2.pw:" +mem2.getPw());
오라클에서는 default sysdate와 같은 기능이다.
메소드 호출하면 stack에 할당하고 다시 돌아간다.
인스턴스 만들 때 만다 설정하면 set을 부럴 필요없다.
4개가 없으면 메모리 효율도 좋아지지 않는가
=>위와 같은 경우는 생성자를 만들어서 생성자에게 값을 설정하는 것이 효율적입니다.
4)Member클래스에 Id에 root를 pw 에 1234를 설정하는 생성자를 만듬
//Member클래스의 생성
//생성자는 리턴 타입없이 클래스 이름을 그래도 사용
//매개변수가 없는 생성자를 Default Constructor 라고 합니다.
public Member() {
id = "root";
pw = "1234";
}
5).main을 실행해보면 setter를 호출하지 않아도 root에 1234로 호출
6.매개변수가 있는 생성자
=>생성자는 오버로딩이 가능하기 때문에 기본 생성자가 있는 경우에도 매개변수가 있는 생성자를 만들 수 있습니다.
=>매개변수가 있는 생성자는 매개변수로 데이터를 대입받아서 인스턴스 변수를 초기화 할 목적으로 만듭니다.
=>외부에서 데이터를 주입받아서 인스턴스 변수를 초기화 할 수 있다면 setter메소드의 호출 횟수가 줄어들고
다양한 방법으로 인스턴스를 생성할 수 있게 됩니다.
=>객체 지향 언어에서는 생성자의 종류만큼 인스턴스를 생성할 수 있는 방법이 있습니다.
예: 게임을 만들때
class Unit{
// 총알을 가져와야 한다.
int bullet; //기본적으로 총알을 500개 주고 싶다.
}
Unit unit = new Unit();
unit.bullet = 500;
비행기 만들고 500주고 해서 .계속 추가한다. 게임 100번하면 100번해줘야 한다.
여러개 만들면 메모리 할당 등 문제 있다.
그래서 기본적인 것을 다 주는게 낳다.
class Unit{
int bullet;
public unit(){
bullet = 500;
}
public unit(money){
}
}
예: graphic문제 4각형 그리기
생성자 만들면 4각형은 이렇게 만들면 되 제시해준다.
여러가지 형태의 생성자를 제공해준다.
Rect()
Rect(x1, y1, x2, y2);
Rect(x,y,w,h)
시작하는 방법이 여러개 있어야 한다.만들어지는 방법을 다양화 하고 싶을때 다양하게 만든다.
public Member() {
id = "root";
pw = "1234";
}
이것 없으면 데이터 안주고는 안된다.그래서 이것 삭제시는 돈이 있어야 돌아간다.
*** 생성자 만드는것
python에서 기본값을 안주고 해도 된다. __init__
생성자 만드는 이유
어떤 특정한 값을 하고 싶을때 -기본적으로 하는 것
여러가지 형태로 하고 싶을때 -매개변수 받아서 하는 것
7.this() & super()
=>생성자에서 자신의 클래스의 다른 생성자를 호출할 때는 this( 매개변수)를 이용할 수 있습니다.
=>super()는 상위 클래스의 생성자를 호출할 때 이용
생성자를 만들면 우리가 작성하지 않아도 가장 위에 super() 구문이 포함됩니다.
상위 클래스의 매개변수가 없는 생성자를 호출하는 구문입니다.
=>상위 클래스에 매개변수가 없는 생성자(Default Constructor)가 없는 경우 클래스를 상속받으면 에러가 발생합니다.
=>생성자를 만들지 않으면 이런 생성자가 자동으로 포함됨
public 클래스이름(){
super();
}
상위 클래스의 매개변수가 없는 생성자를 호출하는 구문이 자동으로 포함되기 때문에 에러 발생
이런 경우에는 생성자를 만들고 super(매개변수)를 직접 호출해 주어야 합니다.
=>super()는 가장 위에 나와야 합니다.
=>this()는 super()를 제외하고 가장 위에 나와야 합니다.
8.인스턴스 배열에서의 생성자
=>인스턴스 배열을 만들 때 크기만 설정한 경우에는 각각의 인덱스에서 생성자를 호출해서 대입해 주어야 합니다.
클래스이름 [] 배열이름 = new 생성자이름[개수];
=>개수 만큼의 인스턴스를 저장할 수 있는 공간이 생성된 것입니다.
위의 경우는 인스턴스는 만들어지지 않았습니다.
배열이름[인덱스] = new 생성자(); 를 호출해서 각각에 대입을 해주어야 합니다.
=>main메소드에 작성하고 실행
//Member 클래스의 인스턴스 배열을 생성
//Member 인스턴스의 참조를 저장할 수 있는 공간 2개를 생성
Member[] ar = new Member[2];
for(Member imsi : ar) {
System.out.println(imsi); //null결과가 다 null로 나온다. 안 만들어졌다.
}
//공간에 인스턴스를 생성해서 대입
ar[0] = new Member();
ar[1] = new Member();
for(Member imsi : ar) {
System.out.println(imsi);
//java0108.constructor.Member@15db9742
//java0108.constructor.Member@6d06d69c
}
9.인스턴스 필드 이니셜라이저
=>클래스 안에 {}를 만들고 괄호 안에 내용을 작성하면 생성자를 호출할 때 {}안의 내용이 자동으로 수행됩니다.
=>Member클래스에 작성하고 main을 실행해서 생성자가 호출 될 때 마다 코드가 실행되는지 확인
//static {}는 클래스를 처음 사용할 때 1번만 호출
//게임할때 로그 한번만 보고 싶을때 첫번쨰 초기화
//클래스 안에 {}를 만들고 작성하면 생성자를 호출할 때
//생성자 보다 먼저 호출되서 내용을 수행
//할때 마다 보여줘야 할 경우
{
System.out.println("객체를 생성합니다.");
}
10.참조형 변수 사이의 대입
=>참조형 데이터는 실제 데이터가 아니라 참조를 대입해주기 때문에 참조형 변수끼리 대입을 하면 동일한 영역을 가리키게 됩니다.
=>하나의 변경이 다른 하나에 영향을 주게 됩니다.
=>특별한 경우가 아니면 참조형 변수 사이의 대입은 하지 않는 것이 좋습니다.
=>참조형 변수의 데이터는 되도록이면 복제를 해서 다른 곳에 대입하는 것이 좋습니다.
복제를 하는 방법은 보통 2자리를 권장하는데 하나는 복사 생성자를 이용하는 것이고 다른 하나는 clone이라는 메소드를 만들어서 넘겨주는 것 입니다.
=>생성자 중에서 자신의 자료형을 매개변수로 받는 생성자가 있으면 이것은 복사 생성자이면 java에서 clone메소드는 현재 인스턴스를 복제해서 새로운 인스턴스를 만들어서 리턴하는 메소드입니다.
실제 개발 할 경우 많이 사용합니다.
commit 과 rollback
응용 프로그램 만들때
대표적인것은 power point
office에서는 임시파일이 먼저 만들어진다.
저장 누르기 전까지는 반영이 안된다.
1) main 메소드에 작성해서 참조형 변수 사이의 대입 확인
//하나의 인스턴스를 생성하고 내부 데이터 설정
Member origin = new Member();
origin.setId("gggg");
origin.setPw("100100100");
//참조형 사이의 대입
//origin이 가리키고 있는 인스턴스를 weak도 가리킵니다. call by reference
Member weak = origin;
//weak가 id를 변경했는데 origin것도 변경
weak.setId("dddd");
System.out.println(weak.getId()); //dddd
System.out.println(origin.getId());//dddd
2)동일한 값을 갖는 인스턴스를 사용하고자 할 때 복제해서 사용하는 것을 권장
이 복제하는 것을 다른 말로 Deep Copy라고 합니다.
R과 다른 프로그래밍의 차이점:
R
파이썬의 분석라이브러리
기본적으로 작업을 하게 하면 결과를 리턴한다. 원본에 작업을 하는 경우는 드뭄
R <- ,= 이것등 많이 사용한다.
R은 가공해서 데이터 사용한다.
복재는 메모리 2배사용한다.
원본데이터 ->가공 ->모델 생성 ->평가
평가는 모델이 제대로 됬는지 알 수 없다.
정확도가 50%정도 나오면 다시 시작해야 한다.
다시 원본데이터로 돌아가야 한다.
수집 ->데이터를 만들고 ->탐색해서 보고 ->가공 -> (샘플링) -> 모델 생성 ->평가 ->보고서 / 제품
가공 ->데이터 바꾸는 것
원본을 변경 시키면 수집부터 다시 해야 한다.
가공을 할 때 복사본을 가공할 경우 데이터 까지만 돌아가면 된다.
=>아래는 원본을 바꿔는 케이스라서 아래 방식은 안좋다.
r = 데이터
r = r가공
시간은 수집이 잴 오래 걸린다.
변수 handleng하고 파일 중에서
cpu -> MainMemory(변수) <-> 디스크
<->네트워크
cpu재일 비싸다.
왼만하면 디스크나 네트워크로 안간다.
MainMemory용량이 부족할 때 디스크 그다음 네트워크
복제하면 메모리가 많이 필요하다.메모리를 많이 사용한다.
그래서 스마트폰에서는 복제를 하지 않았느데 최근에는 좀한다.
deep copy copy() deepcopy()
3)Member 클래스에 복사 생성자를 추가하거나 clone메소드 추가
=>복사 생성자는 자신과 동일한 자료형의 매개변수를 갖는 생성자를 만들고 그 안에서 데이터를 전부 복사해서 리턴하도록 만들저주면 됩니다.
=>이러한 일을 해주는 메소드를 만들 때는 이름을 clone으로 만드는 것을 권장
=> Member클래스에 추가
//인스턴스르 복제해주는 메소드
public Member clone() {
//인스턴스를 새성
Member other = new Member();
//데이터를 복제
other.id = this.id;
other.pw = this.pw;
//복제된 데이터를 갖는 객체를 리턴
return other;
}
cloud등 만들때 clone이 매우 중요하다.
=>MAIN메소드에 코드를 작성하고 확인
//origin을 복제해서 대입
Member deep = origin.clone();
//현재는 내용이 같습니다
System.out.println(deep.getId()); //dddd
System.out.println(origin.getId());//dddd
//복제를 해서 deep에 대입해주었기 때문에 변경하기 전에는 같은 내용을 같지만
//한쪽에서 내용을 변경해도 다른쪽에는 영향이 없기 떄문에 deep의 내용을 변경해서 origin은 그대로
deep.setId("ddfdfd");
System.out.println(deep.getId()); //ddfdfd
System.out.println(origin.getId());//dddd
11. java에서의 메모리 정리
=>heap에 만들어진 데이터는 프로그램 실행 도중 메모리 정리를 할 수 있는데 java에서는 가리키고 있는 변수가 없으면 정리 대상이 되고 시스템이 필요한 시점에 garbage collection을 호출해서 정리를 합니다.
=>강제로 메모리 정리를 시키고 싶다면 참조형 변수에 null을 대입해서 정리 대상이 되도록 할 수 있습니다.
=>참조형 사이에 대입을 하게 되면 변수에 null 을 대입해서 메모리 정리가 안 될 수 있습니다.
Member origin = new Member();
Member weak = origin;
origin = null;//null을 대입해도 메모리 정리 대상이 안됩니다. origin이 2개 가리키고 있기 때문이다.
weak = null;//이것 까지 해주어야만 메모리 정리가 됩니다.
a= b =>이경우는 메모리 정리가 잘 안되고 소스읽기도 불편할 경우가 많다. 참조형 데이터 등
이 작업을 하는 경우는
=>참조형 변수의 데이터를 다른 참조형에 대입하는 경우는 메소드 안에서 만들어진 참조형 데이터를 외부에서 사용하기 위해서 외부변수에 대입하는 경우가 대부분
생성자가 없으면 자동으로 만들어준다.
변수나 메소드가 없을 수 도 있다.
클래스 만드면 모아서 저장하겠다고 생각한다.
데이터베이스 테이블
*클래스 ->저장하고 싶은 항목 : 변수
->변수에 접근할 수 있는 접근자 메소드
->변수의 값을 초기화하는 생성자
작업클래스 (모양이 어떻게 된느지?)
è 여러개를 가져오는 메소드
è 한개를 가져오는 메소드
è 삽입하는 메소드
è 삭제하는 메소드
è 갱신하는 메소드
예: 게사판 게시물
**게시판 작업
1.클래스 구성
1).게시판 데이터 1개를 저장할 클래스 (글번호, 제목 , 내용)
2).게시판 작업을 위한 클래스
=>게시판 전체 목록을 리턴하는 메소드
=>글 번호를 받아서 글 번호에 해당하는 데이터 1개를 리턴하는 메소드
=>게시판 데이터를 매개변수로 받아서 저장하는 메소드
=>게시판 데이터를 매개변수로 받아서 수정하는 메소드
=>글 번호를 받아서 글 번호에 해당하는 데이터를 삭제하는 메소드
이런한 5가지 작업을 curd(create, read, update, delete) 라고 합니다.
3).실행 클래스(나중에는 UI로 담당하는 부분(View)과 이벤트를 처리하는 부분으로 분할(EventHandler, Controller))
2.게시판 데이터를 저장할 클래스를 생성
=>글번호 , 제목 , 내용을 저장하는 클래스
=>글번호는 1번부터 자동으로 생성
=>출력하는 메소드에 인스턴스를 대입하면 인스턴스의 내용을 출력해주도록 하는 메소드
li = [10,20]
print(li) =>li.__str__
package java.study;
public class Board {
//저장할 항목을 private 변수로 생성
//글번호 ,제목, 내용
private int num;
private String title;
private String content;
//인스턴스 변수 사용을 위한 접근자 메소드
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
//디버깅을 위한 메소드
//출려가는 메소드에 인스턴스를 대입했을 때 호출되는 메소드
//자바는 인스턴스를 출력하는 메소드에 대입하면 toString 이라는 메소드가 호출됩니다.
//인스턴스 변수의 값을 전부 확인하고자 할 때 일일이 get메소드를 부르는 것은 코드의 낭비
//이런 경우에는 toString()을 호출해서 한번에 확인
@Override
public String toString() {
return "Board [num=" + num + ", title=" + title + ", content=" + content + "]";
}
}
3.java 단위 테스트
=>java Application을 실행할려면 main메소드를 갖는 클래스가 필요
=>Java Web Application을 실행할려면 WAS가 필요
=>부분적으로 로직을 만들고 로직을 테스트하기 위해서 main을 만드는 것이나 was를 이용해서 실행하는 것은 자원의 낭비
=>java로직을 테스트하기 위한 라이브러리가 이클립스에서 제공되는데 이름은 JUnit
=>JUnit라티브러리르 추가하고 클래스를 만든 후 메소드 위에 @Test라고만 붙이면 단위테스트가 가능
main없어도 가능하다.
1) JUnit라이브러리를 프로젝트에 추가(java버전 변경도 동일한 메뉴)
=>프로젝트 선택하고 마우스 오른쪽을 클릭하고 [Build Path] ->[Configure Build Path]를 선택
=>Libraries 탭에서 [add library]버튼을 클릭하고 JUnit을 선택
4나 5버전을 선택하고 apply
2)테스트를 위한 클래스 생성 -클래스 이름은 Test만 아니면 된다.
package java.study;
import org.junit.Test;
public class BoardTest {
//테스트 메소드 만들기
@Test
public void testMethod() {
Board board = new Board();
System.out.println(board);
}
}
3)테스트 할 때는 클래스 내부 아무곳에서나 커서를 두고 마우스 오른쪽을 클릭하고 [Run As] -[JUnit Test] 를 클릭하면 됩니다.
Board의 내용을 출력한다.
현재 결과는 num = 0 title= null content = null로 출력
TDD(Test Driven Development) 테스트 주도 개발
예전방식:
분석
설계
구현
테스트
최근에는 테스트 하면서 구현
중간중간 테스트 무료로 사용한 가장 쉬운것은 junit
4.static변수와 생성자를 이용해서 num의 값을 일련번호로 대입
=>static변수는 1번 만들어지면 소멸되지 않고 계속 사용할 수 있습니다.
=>instance변수는 instance가 생성될 때 마다 별도로 생성됩니다.
=>Board클래스에 코드를 작성하고 Test메소드를 수정한 후 확인
1)Board클래스 코드 추가
//일련번호 생성을 위한 static 변수를 1개 생성
private static int sequence;
//생성자
public Board() {
//static변수는 이전에 수정한 내용을 가지고 있기 때문에 1씩 증가
sequence = sequence+1;
//num은 인스턴스 변수라서 생성자를 호출 할 때 마다 매번 새로 생성
//새로 생성되는 num에 sequence의 값을 대입하면 일려번호가 됩니다.
num = sequence;
}
num은 instance변수 부를때마다 새로 생성된다.
sequence 은 static변수이다. 새로 생성되지 않는다.
static은 값을 계속 이어서 가지는 것이다.
2)Test메소드를 수정하고 실행
//테스트 메소드 만들기
@Test
public void testMethod() {
Board board = new Board();
System.out.println(board);
Board board1 = new Board();
System.out.println(board1);
}
5.작업을 위한 클래스 - BoardService
package java.study;
//게시판 작업을 위한 메소드
public class BoardService {
//Board 100개를 저장할 수 있는 공간을 100개 생성해서 이름을 list라고 붙임
//Board가 아니고 Board가 가르킬 수 있는 것이 100개 이다.
Board[] list = new Board[100];
//Board[]이것은 현재는 배열이지만 리스트 배우면 리스트로 바꾼다.
//전체 목록이나 일부 목록을 리턴하는 메소드
//return 타입은 List
//일부 목록을 가져올 때는 매개변수로 페이지 번호를 갖는 경우가 많습니다.
public Board[] getList() {
return list;
}
//페이지 번호에 해당하는 데이터를 가져오는 메소드
//제목이나 내용을 주고 싶을 경우
//list 0 -99
public Board[] getList(int pageNo) {
//한 페이지에 10개씩 있다고 가정
//0 -9 번 까지
Board[] r = new Board[10];
//pageNo가 1일 때는 0과 9., pageNo가 2일 때는 10과 19
int start = (pageNo-1) * 10;
int end = pageNo * 10 -1;//end는 안 여줘도 된다. 10페이지 구해서 여주면 되기때문에
//시작과 끝이 9 차이나면 된다.
for(int i = 0; i <10; i = i+1){
r[i] = list[start +1];
}
return null;
}
//글번호에 해당하는 데이터를 1개 가져오는 메소드
//기본키를 매개변수로 받아서 처리
//상세보기를 처리하는 메소드
//메일 보기도 같다.
public Board getBoard(int num) {
//list 에서 num이라는 글 번호를 가진 데이터를 찾아서 리턴
Board board = null;
//list를 순환하면서 num과 같은 글번호를 가진 데이터를 board에 대입
for (Board temp: list) {
if(temp != null) {
//동일한 글 번호를 찾으면 더 이상 반복문을 수행할 필요가 없어서 break
if(temp.getNum() == num) {
board = temp;
break;
}
}
}
//동일한 글번호가 없으면 null을 리턴
//디비 연동으 framework를 이용한다.
//selectList selectOne 없으면 null
//증복검사,로그인 할때 등 null확인 해야 한다.
return board;
}
//글쓰기를 처리하는 메소드
//데이터 삽입을 처리하는 메소드
//수행 결과를 알려주고자 할 때는 boolean이나 init로 리턴
//수행 결과를 알려주지 않고자 할 때는 void(실패는 없다라는 가정)
//매개변수는 데이터 1개
private int cnt;
public boolean insertBoard(Board board) {
//맨 마지막 위치에 데이터를 대입
list[cnt] = board;
cnt = cnt+1;
return true;
}
//글수정을 처리하는 메소드
//리턴 타입은 삽입과 동일
//매개변수도 삽입과 동일
//수정을 할 때는 기본키(글번호)의 값이 자동으로 설정되는 것 이 다릅니다.
public boolean updateBoard(Board board) {
//글번호에 해당하는 데이터를 찾아서 데이터를 찾으면 board로 대체
for (int i = 0; i < cnt; i++) {
Board imsi = list[i];
//글번호 비교
if(imsi != null) {
if(imsi.getNum() == board.getNum()) {
list[i] = board;
break;
}
}
}
return true;
}
//삭제를 처리하는 메소드
//삭제를 할 때는 데이터 전체가 필요하지 않고 일반적으로 기본키만 필요합니다.
public boolean deleteBoard(int num) {
//list에 모든 데이터를 순회해서 글번호가 num인 데이터를 찾아서 그 위치에 null을 대입
for (int i = 0; i < cnt; i++) {
Board imsi = list[i];
//글번호 비교
if(imsi != null) {
if(imsi.getNum() == num) {
list[i] = null;
break;
}
}
}
return true;
}
}
6.실행 클래스를 만들어서 실행
스크립트 언어가 아니면 entery point가 있어야 한다.
python도 entery point가 있다. __main__.py
여기에 있는 것을 먼저 실행해야 한다. python은 모듈이름으로
java, c ,c# main
=>main 메소드를 소유한 클래스를 생성
제대로 ui동작하는지 확인해야 한다.
java는 다중상속이 안된다.
