memory

캡슐화는 data를 외부에서 접근하지 못하도록 제한하는것을말한다
자기클래스에서만 접근할수있는 private 접근제어자를 붙인다

public void setNumber(int n) {
number = n;
}
public void getNumber() {
return number;
}

멤버변수에 값을 설정하고 불러올수있는

set, get method를 만든다 

//public class Student
private String name;
private int id;
private int age; 

//private를 이용할경우 같은 클래스 내에서만 접근가능하다

public void setName(String name) {
this.name = name;
}

public void setId(int id) {
this.id = id;
}

public void setAge(int age) {
this.age = age;
} 

public String getName() {
return name;
} 

public int getId() {
return id;
}

public int getAge() {
return age;
//다른클래스에서 접근할수 있또록 set,get method를 만든다
   
public void showInfo() {
  System.out.println(getName());
  System.out.println(getId());
  System.out.println(getAge());
} //한번에 불러올수있도록 method를 만들어줄수도 있다

//main
Student stu = new Student();
stu.name = "jusung"; 

System.out.println(stu.name);

//같은 클래스이므로 접근가능하다
---------
//public class School
//main
Student stu = new Student();
stu.name="jusung";
System.out.println(stu.name); //error

//다른 클래스이므로 private란 변수 name에 접근할수없다

stu.setName("jusung");
stu.setId(1234);
stu.setAge(55555);
System.out.println(stu.getName());
System.out.println(stu.getId());
System.out.println(stu.getAge());
//이와같이 private일경우 set,get method를 이용해 접근해야한다

stu.showInfo(); 

//Student 에서 만들어논 method를이용해 한번에 불러온다

method overloading이란 하나의 클래스에
같은 이름의 method를 여러개 정의하는걸
오버로딩이라고 한다
overloading 조건에는 method 이름이 같아야하고
매개변수의 개수, 데이터타입 또는 순서가 달라야한다.
매개변수가 달라 함수명을 달리해야할경우

개발자 입장에서 불편하기때문에 overloading을 사용한다 

//public class MethodOverloading
public void getAdd() {
System.out.println("overloading");
} //매개변수가 없기때문에 문제없이 overloading이 된다

public int getAdd(int i, int j) {
return i+j;
}

public int getAdd(int i, int j, int k) {
return i+j+k;
}

public double getAdd(double i, int j, int k) {
return (double)(i+j+k);
}

public int getAdd(float i, int j, int k) {
return (int)(i+j+k);
}

public int getAdd(int i, float j, int k) {
return (int)(i+j+k);
} //data type의 순서가 다르기 때문에 overloading이 성립된다

public double getAdd(int i, int j, int k) {
return i+j+k;
} //return 타입은 관계가없고 갯수가 같으므로 overloading이 되지 않는다

public double getAdd(int ii, int jj) {
return ii+jj;
} //매개변수의 타입이같고 갯수가 같아서 overloading이 되지 않는다

//main
MethodOverloading mOver = new MethodOverloading(); //객체생성

mOver.getAdd();
int a = mOver.getAdd(1,2);
int b = mOver.getAdd(1,2,3);
double e = mOver.getAdd(1.3, 2, 3);
int c = mOver.getAdd(1.2F, 2, 4);
int d = mOver.getAdd(1, 1.2F,3);

System.out.println(a+b+c+d+e);
--------
//class TextBook 
String title;
String author;
int grade;

public TextBook() {
title = "kor";
author = "jusung";
} 

//생성자는 멤버변수를 초기화 할때 사용한다 

//변수앞에 String을 붙여서 초기화할시

//지역변수가되서 초기화가되지않는다

1.
public TextBook(String title) {
this.title = title;
} 

//매개변수 갯수가 달라서 오버로딩이 성립된다

2.
public TextBook(String title) {
this(title,"jusung"); //생성자가 생성자를 호출할수있다
} 

//this()는 생성자를 호출하는 method
//this()는 생성자 안에서만 사용한다
//this()는 반드시 생성자 첫줄에 써야한다

public TextBook(String title, String author) {
this.title = title;
this.author = author;
}

//자기 클래스의 instance 변수를 접근할때 this를 사용한다
//사용자가 생성자를 만들경우 기본생성자가 생성되지않는다
//매개변수를 가지는 생성자를 인자생성자라고한다
//this는 static method에서는 사용할수 없다.

public TextBook(String title, String author, int grade) {
this.title = title;
this.author = author;
this.grade = grade;
}

public void getBook() {
System.out.println(this.title);
System.out.println(author);
System.out.println(grade);
} //this를 넣나 안넣나 상관이 없다.

//public class ConstructorOverloading
//main

TextBook tb = new TextBook();
System.out.println(tb.title); //kor이 출력된다
System.out.println(tb.author); //jusung이 출력된다

//기본생성자 초기화를 kor, jusung으로 했기때문이다
         
TextBook tb = new TextBook("kor","jusung");
System.out.println(tb.title); //kor이 출력된다
System.out.println(tb.author); //jusung이 출력된다
         
TextBook tb1 = new TextBook("kor"); 
tb1.getBook(); 

//1. "kor"이 출력되고 나머지는 default값
//2. 생성자가 생성자를 호출한경우 

//"jusung"도 같이 출력되고 나머진 default값 
         
TextBook tb2 = new TextBook("kor","jusung");
tb2.getBook();

//"kor","jusung"이 출력되고 나머지는 default값
         
TextBook tb3 = new TextBook("kor","jusung",5);
tb3.getBook(); 

//"kor","jusung",5 이 출력된다

1. join.jsp

2. joinOk.jsp

3. login.jsp

4. loginOk.jsp

5. logout.jsp

6. main.jsp

7. modify.jsp

8. modifyOk.jsp

9. member.js

10. memberDAO.java

11. memberDTO.java

*memberDAO and memberDTO must be in "first" package

*must be connected to DB with Connection pool setting

*must change DB setting into your account.

<this is the last step of JSP register and log in process

So, you need to do previouse two steps to follow this>

1. in the previous step, you have done Connection pool setting

and made database, DAO, DTO.

2. modify.jsp 작성

a. session을 통해 id를 가져온다

b. 가져온 id로 getMember method를 통해 

모든 정보를 mdto에 가져온다 

3. updateInfo function 을 member.js 에 추가한다

a. 비밀번호의 동일성을 확인한다

b. modifyOk.jsp 파일로 data를 전송한다

4. modifyOk.jsp 작성

a. 세션을통해 id를 mdto에 가져오고 

mdao에 updateMember method를 실행한다

b. return된 n값으로 update 여부를 보여준다

5. memberDAO 에 updateInfo method를 추가한다

mdto에서 가져온 정보로 DB를 update한다.

6. DB check

//public class Member
static int aa; //class 변수
String str; //instance 변수

public Member() {
System.out.println("Constructor");
} 

//생성자를 만들지 않아도 기본 생성자가 자동으로 생성된다.

//생성자에는 static이 없고 반환타입이 없다 

public static void yy() {
System.out.println("class method");
}

public static String yyy() {
System.out.println("반환값이 있는 class method");
return "return value";
}

public void bb() {
System.out.println("instance method");
}

public int xxx() {
System.out.println("반환값이 있는 instance method")
return 1000;
}

public void zz(String str1) {
System.out.println("매개변수가 있는 메소드"+str1);
}

//main
Member mem = new Member(); //Constructor가 출력된다

//생성자를 호출하는건 객체를 생성한다는 의미이다. 

Member.yy(); //class method 가출력된다
//같은 클래스일경우 class명 없이 yy();로 호출가능하다

mem.bb(); //class method가 출력된다

mem.zz("parameter");
//string type의 형태로 호출해줘야한다
//parameter 값을 str1에 넘겨주고 문장을 출력할때 그값을 이용해 출력한다

String str2 = yyy();
System.out.println(str2); //return value가 출력된다
//yyy method를 호출해서 반환값 return value를 str2에 돌려준다

int qq = mem.xxx();
System.out.println(qq);
//xxx method를 호출해 반환값 1000을 qq에 돌려준다

하나의 페이지에 여러개의 클래스가 있을수있지만  
public class는 한번만 존재해야하며
public 타입을 가지는 클래스를 파일명으로한다 
main method 를 가지는 클래스에 public타입을 준다 

class 변수는 static이 붙는 변수로 static 변수라고 한다
class 변수는 클래스명.변수명 으로 호출한다  
같은 클래스일경우 클래스명없이 호출가능하다

instance 변수는 static이 붙지않고 class영역에서 선언된변수를 말한다 
instance 변수는 instance 생성후 생성한 객체명.변수명 으로 호출한다 
class 변수와 instance변수는 class영역에 선언되 멤버변수로 불린다 
멤버변수는 초기화하지 않을경우 default값이 들어간다

static 변수는 공유변수로 각각의 instance가 같이사용한다  
static 변수는 instance생성과 상관없이 생성된다 

생성자는 instance(객체)를 생성할때 호출하고 생성자명은 해당class명과 동일해야한다 
반환타입이 없어야 하고 멤버변수를 초기화할때 사용한다
CarDemo()생성자를 호출해서 new 연산자를 통해 클래스에 객체를 생성한다

생성자 없이 멤버변수를 초기화할때는 static String kind = "소형차"; 식으로 가능하다 

생성자를 이용하여 멤버변수를 초기화할수있다

local 변수는 method안에서 선언된변수를 말한다 
local 변수는 method의 block이 끝나는순간 사라진다. 
local 변수는 초기화를 해줘야한다.

class method에는 static이 붙고 class 변수만 사용할수있다
class method호출은 class명.method명 으로 호출하고 instance를 생성할필요없다

JVM 은 main method가 있어야 실행되기때문에  
main method는 static 이 붙어 객체생성없이 실행된다 

//class CarDemo
static String kind = "소형차"; //class변수
int number;  //instance 변수 
int speed;
String color;  

public CarDemo() {  
kind="소형차";  
int aa = 20;  
}  //생성자이용해 멤버변수 초기화

public static void kind() { 
System.out.println("소형차");
} //class method

public void speedUp() {  
    kind="대형차"; 
    speed +=10;  
} //instance method에는 class 변수를 사용할수있다 

public void speedDown() {  
speed -=5;  
}  

//public class CarTest
static String kind1; //class변수

//main
CarDemo myCar = new CarDemo(); //instance 생성 
myCar.color="white"; 
CarDemo yourCar = new CarDemo(); 

System.out.println(CarDemo.kind); //class변수 호출 
System.out.println(kind1); //같은클래스내 class변수 호출 

System.out.println("myCar.color"); //instance변수 호출

System.out.println(myCar.kind); //공유변수이므로 같은값이 나온다 
System.out.println(yourCar.kind); 

myCar.kind = "중형차"; 
System.out.println(myCar.kind); 
System.out.println(yourCar.kind); //공유변수로 "중형차"가 출력된다  

int c = 100; //지역변수는 초기화 해줘야 한다 
System.out.println(c); 

System.out.println(aa); //생성자 안에서 선언된변수로 block밖에선 사용할수없다. 

System.out.println(myCar.speed); //0 
myCar.speedUp(); //멤버 메소드는 인스턴스 생성후 호출이가능하다 
System.out.println(myCar.speed); //10 

System.out.println(yourCar.speed); //0 
yourCar.speedUp(); //(참조변수명.메소드명) 
System.out.println(yourCar.speed); //10 

CarDemo.kind(); //class method 호출

클래스를 속성(필드)과 기능(method) 로 정의하고
객체화를통해 인스턴스(객체)가 된다

객체는 속성(variable)과 기능(method)의 집합이며,

속성과 기능을 객체의 멤버라고한다

car2 = car1과 같이 하나의 참조변수는 

여러개의 객체를 가리킬수있다. 

//class Car
int number;
int speed;
String color;
//class에서 선언된 변수는 default값 0,null을 가진다

public void speedUp() {  //접근제어자, 반환타입, 메소드명 의형태로 작성
    speed +=10;
}

public void speedDown() {  //void 는 반환타입이 없다.
speed -=5;
}

//실행하기위해 main method에서 new라는 연산자를통해 객체를 생성해야한다
//main 
Car myCar = new Car(); //클래스를 객체화한다
Car yourCar = new Car();

//(class명 참조변수 = new class명();) 

myCar.number=1;
myCar.speed=10; //myCar의 변수만 변한다
myCar.color=Black;
System.out.println(myCar.speed); //speed 10 
myCar.speedUp(); //method 호출
System.out.println(myCar.speed); //speed 20
System.out.println(myCar.number); // 1
System.out.println(myCar.color); //Black

yourCar.speed=30; 
System.out.println(yourCar.speed); //speed 30
yourCar.speedDown();
System.out.println(yourCar.speed); //speed 25

main이라는 method는 JVM이 호출해서 자동으로 실행된다
main method 에서 String type의 
args 배열 이라는 매개변수를 이용해 값을 출력한다
run, configuration, arguments에서 입력가능(eclips)

System.out.println(args.length);
//args 배열의 크기를 출력

for(int i = 0; i<args.length; i++) {
System.out.println(args[i]);
} //args 배열의 값을 출력

for Each문은 배열과 함께사용할때 유용하다
for(변수 : 배열변수){}
for(String str : args) {
System.out.println(str);
} //배열의 각 index의 값을 

str변수로 가져와서 출력한다 

data 입력받는 방법
import java.io.*; //to use System.in
import java.utill.*; //to use Scanner

throws IOException{ //입력을 받을때 예외처리를 해주어야한다
int n = System.in.read()-'0'; //값을 읽고 int형으로 받아 ASCII값으로 반환한다
//0~9 사이의 ASCII값은 48~57이다 그래서 0을빼줄시 정수가 출력된다
System.out.println(n);

InputStreamReader id = new InputStreamReader(System.in);
//System.in 을통해 값이 입력되면 InputStreamReader라는 클래스가 생성된다

//System.in은 한단어만 받아올수있는반면

//InputStreamReader은 여러단어를 받아올수있다
while(true) {
int n = id.read(); //read method를 통해 한글자씩 읽어온다
     if(n == -1) //-1 ASCII 값은 Ctr+z를 의미한다
     break;
     System.out.println((char)n);
}

//Scanner method는 예외처리가 필요없고 간단하다
Scanner sc = new Scanner(System.in);
System.out.println(sc.next()); //next method를 이용해서 문자를 읽어온다
System.out.println(sc.nextInt()); //정수형으로 반환하는 method