memory

상속이란 extends란 키워드를 사용해

기존클래스를 재사용해서 

새로운 클래스를 작성하는것으로 
두 클래스를 부모(super class)와

자손(sub class)의 관계를 맺어주고
자손은 부모의 모든 멤버를 상속받는다
상속받을수있는 클래스는 단하나이다.
상속관계(is-a), 포함관계(has-a)

//class Human
String name;
int age;

public Human() {
this("haha",123) 

} //본인클래스에서 다른 인자를 호출하기위해선 this method를이용한다

//super class에 인자생성자를 만들경우

//기본생성자가 자동으로 생성되지않기때문에

//super class에 기본생성자를 직접 만듬으로써 

//Sub class에 생성자를 만들지않아도 문제가없다.

public Human(String name, int age) { //인자생성자 생성
this.name = name; //name 과 age를 매개변수를통해 받아온다
this.age = age; //자식클래스에서는 부모생성자를 super를 이용해 만들어야한다
}

public void getInfo() {
System.out.println(name+age);

}

//super : 부모클래스의 객체를 의미, 부모클래스의 변수를 접근
//this : 자신의 객체를 의미, 자신클래스의 변수를 접근
//super() method: super class의 생성자를 호출하기위한 method
//this() method: 자신의 생성자를 호출하기위한 method

//super() method는 생성자 안에서만 호출할수있다. 
//항상 생성자의 첫줄에 와야한다 
//static method안에서는 사용할수 없다. 
//유저가 생성자를 작성하지 않는경우 하위클래스 생성자에서 자동으로 호출한다 

//class Employee extends Human

//Human class를 extends 키워드를 이용하여 상속받는다
super();
int salary;

public Employee() {
super(); //super method를 이용해 super class의 기본생성자를 호출한다
} //생성자를 만들지않아도 기본생성자가 생성되면서 super method가 만들어진다
  //super class에서 인자생성자를 만들경우 super class에 기본생성자가 없어지므로
  //super class에 따로 기본생성자를 만들어주거나 
  //Sub class에 super method를 포함한 생성자를 만들어줘야한다

public Employee(String name, int age, int salary) {
super(name, age); //부모클래스의 생성자를 불러오기위해 super method를 이용한다
this.salary = salary; //salary를 추가해준다
}

public void getInfo() {  
System.out.println(name+age+salary);
} //부모클래스에서 int salary를 추가해 확장시켜준다

//super class에 기본생성자에 다른 인자를 가져와

//name, age인자를 초기화시켰으므로

//haha, 123, default 값 0이 출력된다

//super class에 getInfo() method를 overriding한것으로

//super class에 method를 subclass에서 재정의한것이다

//호출하고자하는 method 는 super class에 존재해야하고

//접근 제어자는 super class보다 넓거나 같다야 한다.

//반환 타입, method명, 매개변수와 type이 같아야하고

//수행할 명령은 달라야 한다.

//class Student extends Human

//public class Inheritance
//main

Employee em = new Employee("hoho",123,999);
em.getInfo();

//Employee는 Human으로부터 상속을 받았기때문에 작동된다

//super method를 이용해 Sub class 에 

//생성자를 overriding 했기때문에 
//hoho,123,999가 출력된다

Student stu = new Student();
stu.getInfo();

//Student는 Human으로부터 상속을 받았기때문에 작동된다

//본인 class에서 overridng된 생성자가

//getInfo method를통해 먼저 호출한다

캡슐화는 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