1 복잡하고 긴 쿼리문을 뷰로 정의하면 접근을 단순화시킬 수 있다. 

2 보안에 유리하다.

INSERT INTO EMP_VIEW30

VALUES(8000, 'ANGEL', 30);

SELECT * FROM EMP_VIEW30;

SELECT * FROM EMP_COPY;

CREATE OR REPLACE

VIEW EMP_VIEW(사원번호, 사원명, 급여, 부서번호)

AS 

SELECT EMPNO, ENAME, SAL, DEPTNO 

FROM EMP_COPY;

SELECT * FROM EMP_VIEW

WHERE 부서번호=30;

CREATE VIEW VIEW_SAL

AS

SELECT DEPTNO, SUM(SAL) AS "SalSum", AVG(SAL) AS "SalAvg"

FROM EMP_COPY

GROUP BY DEPTNO;

SELECT ROWNUM, EMPNO, ENAME, HIREDATE

FROM EMP;

SELECT EMPNO, ENAME, HIREDATE

FROM EMP

ORDER BY HIREDATE;

SELECT ROWNUM, EMPNO, ENAME, HIREDATE

FROM EMP

ORDER BY HIREDATE;

CREATE OR REPLACE VIEW VIEW_HIRE

AS

SELECT EMPNO, ENAME, HIREDATE

FROM EMP

ORDER BY HIREDATE;

SELECT ROWNUM, EMPNO, ENAME, HIREDATE

FROM VIEW_HIRE;

SELECT ROWNUM, EMPNO, ENAME, HIREDATE

FROM VIEW_HIRE

WHERE ROWNUM<=5;

SELECT ROWNUM, EMPNO, ENAME, HIREDATE

FROM ( SELECT EMPNO, ENAME, HIREDATE

FROM EMP

ORDER BY HIREDATE)

WHERE ROWNUM<=5;

SELECT * FROM EMP_VIEW30;

SELECT VIEW_NAME, TEXT

FROM USER_VIEWS;

1) 사용자가 뷰에 대해서 질의를 하면 USER_VIEWS에서 뷰에 대한 정의를 조회합니다.

2) 기본 테이블에 대한 뷰의 접근 권한을 살핀다.

3) 뷰에 대한 질의를 기본 테이블에 대한 질의로 변환합니다.

4) 기본 테이블에 대한 질의를 통해 데이터를 검색합니다.

5) 검색된 결과를 출력합니다.

INSERT INTO EMP_VIEW30

VALUES(1111, 'AAAA', 30);

SELECT * FROM EMP_VIEW30;

SELECT * FROM EMP_COPY;

CREATE TABLE DEPT_COPY

AS

SELECT * FROM DEPT;

CREATE TABLE EMP_COPY

AS

SELECT * FROM EMP;

CREATE [OR REPLACE] [FORCE | NOFORCE] VIEW view_name

[(alias, alias, alias, ...)]

AS subquery

[WITH CHECK OPTION]

[WITH READ ONLY];

SELECT EMPNO, ENAME, DEPTNO

FROM EMP_COPY

WHERE DEPTNO=30;

CREATE VIEW EMP_VIEW30

AS 

SELECT EMPNO, ENAME, DEPTNO

FROM EMP_COPY

WHERE DEPTNO=30;

SELECT * FROM EMP_VIEW30;

CONN system/manager

GRANT CREATE VIEW TO scott;

CREATE VIEW EMP_VIEW30

AS 

SELECT EMPNO, ENAME, DEPTNO

FROM EMP_COPY

WHERE DEPTNO=30;

DESC EMP_VIEW30

SELECT * FROM EMP_VIEW30;

class Person<T>{

    public T info;// p1 일시 데이터 타입은 String이된다.(인스턴스 생성시 String 제네릭 생성)

// p2 일시 데이터 타입은 StringBuilder이 된다.

}

public class GenericDemo {

    public static void main(String[] args) {

        Person<String> p1 = new Person<String>();

        Person<StringBuilder> p2 = new Person<StringBuilder>();

    }

}

public T info;

class Person<T>{

Person<String> p1 = new Person<String>();

Person<String> p1

new Person<String>();

ArrayList<Tv> tvList = new ArrayList<Tv>();

// Tv객체만 저장할 수 있는 ArrayList를 생성

tvList.add(new Tv());

tvList.add(new Radio());// 컴파일 에러

class Product{ }

class Tv extends Product{ }

class Audio extends Product{ }

//Product 클래스의 자손객체들을 저장할 수 있는 ArrayList를 생성

ArrayList<Product> list = new ArrayList<Product>();

list.add(new Product());

list.add(new Tv());

list.add(new Audio());

Product p = list.get(0);// 형변환이 필요없다.

Tv t = (Tv)list.get(i);// 형변환을 필요로 한다.

ArrayList<Product> list = new ArrayList<Tv>();//허용안함

List<Tv> tvList = new ArrayList<Tv>();// But, 허용된다.

public static void printAll(ArrayList<? extends Product> list){//Product 또는 그 자손들이 담긴 ArrayList를 매개변수로 받는 메서드

for(Unit u : list){

System.out.println(u);

}

}

class EmployeeInfo{

    public int rank;

    EmployeeInfo(int rank){ this.rank = rank; }

}

class Person<T, S>{//복수의 제네릭을 사용할 시에는 ','를 사용한다.

    public T info;

    public S id;

    Person(T info, S id){ 

        this.info = info; 

        this.id = id;

    }

}

public class GenericDemo {

    public static void main(String[] args) {

        Person<EmployeeInfo, int> p1 = new Person<EmployeeInfo, int>(new EmployeeInfo(1), 1);

    }

}

class EmployeeInfo{

    public int rank;

    EmployeeInfo(int rank){ this.rank = rank; }

}

class Person<T, S>{

    public T info;

    public S id;

    Person(T info, S id){ 

        this.info = info;

        this.id = id;

    }

}

public class GenericDemo {

    public static void main(String[] args) {

        EmployeeInfo e = new EmployeeInfo(1);

        Integer i = new Integer(10);

        Person<EmployeeInfo, Integer> p1 = new Person<EmployeeInfo, Integer>(e, i);

        System.out.println(p1.id.intValue());

    }

}

EmployeeInfo e = new EmployeeInfo(1);

Integer i = new Integer(10);

Person<EmployeeInfo, Integer> p1 = new Person<EmployeeInfo, Integer>(e, i);

Person p2 = new Person(e, i);// 제네릭 생략함

class EmployeeInfo{

    public int rank;

    EmployeeInfo(int rank){ this.rank = rank; }

}

class Person<T, S>{

    public T info;

    public S id;

    Person(T info, S id){ 

        this.info = info;

        this.id = id;

    }

    public <U> void printInfo(U info){// U 데이터 타입은 info라는 매개변수의 데이터타입(EmployeeInfo)이 된다.

        System.out.println(info);

    }

}

public class GenericDemo {

    public static void main(String[] args) {

        EmployeeInfo e = new EmployeeInfo(1);

        Integer i = new Integer(10);

        Person<EmployeeInfo, Integer> p1 = new Person<EmployeeInfo, Integer>(e, i);

        p1.<EmployeeInfo>printInfo(e);//

        p1.printInfo(e);// 제네릭 생략이 가능함

    }

}

abstract class Info{//부모 클래스가 반드시 추상클래스일 필요가 없다.

    public abstract int getLevel();

}

class EmployeeInfo extends Info{

    public int rank;

    EmployeeInfo(int rank){ this.rank = rank; }

    public int getLevel(){

        return this.rank;

    }

}

class Person<T extends Info>{// info 클래스나 info의 자식클래스만이 제네릭으로 올 수 있는 데이터 타입이 된다.(info의 자식이면 OK, 자식이 아니면 컴파일 에러)

    public T info;

    Person(T info){ this.info = info; }

}

public class GenericDemo {

    public static void main(String[] args) {

        Person p1 = new Person(new EmployeeInfo(1));

        Person<String> p2 = new Person<String>("부장");

    }

}

class Person<T extends Info>{

interface Info{

    int getLevel();

}

class EmployeeInfo implements Info{

    public int rank;

    EmployeeInfo(int rank){ this.rank = rank; }

    public int getLevel(){

        return this.rank;

    }

}

class Person<T extends Info>{// extends는 상속이 무엇인가가 아니라, 부모가 누군가를 확인하는 코드이다.(implement가 아니다.)

    public T info;

    Person(T info){ this.info = info; }

}

public class GenericDemo {

    public static void main(String[] args) {

        Person p1 = new Person(new EmployeeInfo(1));

        Person<String> p2 = new Person<String>("부장");

    }

}

import java.util.ArrayList;

public class ArrayListDemo {

    public static void main(String[] args) {

        String[] arrayObj = new String[2];

        // 배열의 크기 지정--> 생성후 변경 불가

        arrayObj[0] = "one";

        arrayObj[1] = "two";

        // arrayObj[2] = "three"; 오류가 발생한다.

        // --> 배열의 크기 변경 불가 (배열은 배열의 크기를 알 때만 사용할 수 있다.)

        for(int i=0; i<arrayObj.length; i++){

            System.out.println(arrayObj[i]);

        }

        ArrayList<String> al = new ArrayList<String>(); // <Strinf>: al 참조변수에 추가되는 값이 String 데이터 타입이라는 것을 지정한다.

        // 배열과 비슷하나, 객체 생성후 몇개의 값을 사용할 지 지정할 필요가 없다.

        // --> 여기서 al 참조변수는 컨테이너라고 한다.(자료를 담는 그릇이 된다.) --> 아래의 코드는 add()를 이용하여 al에 one, two, Three를 넣은 모습이다.

        al.add("one");

        al.add("two");

        al.add("three");

        // 값을 추가해도 상관없다. outofbound 에러 없음

        for(int i=0; i<al.size(); i++){// 배열은 length

        // String value = al.get(i);// value 변수에 리턴되는 데이터타입은 ArrayList이므로 String으로 데이터타입 지정시 에러가 발생한다. 

        // 그래서 (String)al.get(i) 또는 ArrayList<String>을 객체 선언시 지정해야 한다. 

            System.out.println(al.get(i));//i=1이면 one, i=2이면 two, 제네릭을 통해서 (String)al.get(i)을 통해 형변환할 필요가 없다.

        }

    }

}

실행결과)

one

two

one

two

three

import java.util.ArrayList;

import java.util.HashSet; 

import java.util.Iterator;

public class ListSetDemo {

    public static void main(String[] args) {

        ArrayList<String> al = new ArrayList<String>();

        al.add("one");

        al.add("two");

        al.add("two");

        al.add("three");

        al.add("three");

        al.add("five");

        System.out.println("array");

        Iterator<String> ai = al.iterator(); //<String>에서 제네릭을 선언하지 않았다면 (String)로 형변환을 해야 한다.

        while(ai.hasNext()){

            System.out.println(ai.next());

        }

        HashSet<String> hs = new HashSet<String>();

        hs.add("one");

        hs.add("two");

        hs.add("two");

        hs.add("three");

        hs.add("three");

        hs.add("five");

        Iterator<String> hi = hs.iterator();

        System.out.println("\nhashset");

        while(hi.hasNext()){

            System.out.println(hi.next());

        }

    }

}

실행결과)

array

one

two

two

three

three

five

hashset

two

five

one

three

import java.util.*;

public class MapDemo {

    public static void main(String[] args) {

        HashMap<String, Integer> a = new HashMap<String, Integer>();

        a.put("one", 1);// key, value

        a.put("two", 2);

        a.put("three", 3);

        a.put("four", 4);

        System.out.println(a.get("one"));

        System.out.println(a.get("two"));

        System.out.println(a.get("three"));

        iteratorUsingForEach(a);

        iteratorUsingIterator(a);

    }

    // Map 데이터 iterator 기능 없음 --> Map 데이터 가져오는 방법 1

    static void iteratorUsingForEach(HashMap<String, Integer> map){

        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        for (Map.Entry<String, Integer> entry : entries) {

            System.out.println(entry.getKey() + " : " + entry.getValue());

            //Map 데이터를 가져오는 방법 --> getKey()=key값 ,getValue()=value값

        }

    }

    // Map 데이터 iterator 기능 없음 --> Map 데이터 가져오는 방법 2

    static void iteratorUsingIterator(HashMap<String, Integer> map){

        Set<Map.Entry<String, Integer>> entries = map.entrySet();

        Iterator<Map.Entry<String, Integer>> i = entries.iterator();

        while(i.hasNext()){

            Map.Entry<String, Integer> entry = i.next();

            System.out.println(entry.getKey()+" : "+entry.getValue());

        }

    }

}

import java.util.*;

class GenericsEx5

{

public static void main(String[] args) 

{

HashMap<String,Student> map = new HashMap<String,Student>();

map.put("1-1", new Student("자바왕",1,1,100,100,100));

map.put("1-2", new Student("자바짱",1,2,90,80,70));

map.put("2-1", new Student("홍길동",2,1,70,70,70));

map.put("2-2", new Student("전우치",2,2,90,90,90));

Student s1 = map.get("1-1");

System.out.println("1-1 :" + s1.name);

Iterator<String> itKey = map.keySet().iterator();

// key값만 가져오는 경우

while(itKey.hasNext()) {

System.out.println(itKey.next());

}

Iterator<Student> itValue = map.values().iterator();

int totalSum = 0;

// value값만 가져오는 경우

while(itValue.hasNext()) {

Student s = itValue.next();

System.out.println(s);

totalSum += s.total;

}

System.out.println("전체 총점:"+totalSum);

} // main

}

class Student extends Person implements Comparable<Person> { 

String name = ""; 

int ban = 0; 

int no = 0; 

int koreanScore = 0; 

int mathScore = 0; 

int englishScore = 0; 

int total = 0; 

Student(String name, int ban, int no, int koreanScore, int mathScore, int englishScore) { 

super(ban+"-"+no, name);

this.name = name; 

this.ban = ban; 

this.no = no; 

this.koreanScore = koreanScore; 

this.mathScore = mathScore; 

this.englishScore = englishScore; 

total = koreanScore + mathScore + englishScore; 

} 

public String toString() { 

return name + "\t" 

+ ban + "\t" 

+ no + "\t" 

+ koreanScore + "\t" 

+ mathScore + "\t" 

+ englishScore + "\t" 

+ total + "\t"; 

} 

   // Comparable<Person>이므로 Person타입의 매개변수를 선언.

public int compareTo(Person o) { 

  return id.compareTo(o.id);    // String클래스의 compareTo()를 호출

}

} // end of class Student 

class Person  {    

     String id;

     String name;

     Person(String id, String name) { 

         this.id = id;

         this.name = name; 

     }

}

public interface Iterator{

boolean hasNext();

Object next();

void remove();

}

public interface Collection{

...

public Iterator iterator();

...

}

List list = new ArrayList();

Iterator it = list.iterator();

while(it.hasNext()){

System.out.println(it.next());

}

Map map = new HashMap();

...

Iterator it = map.keySet().iterator();

import java.util.*;

class IteratorEx1{

public static void main(String[] args) {

ArrayList list = new ArrayList();

list.add("1");

list.add("2");

list.add("3");

list.add("4");

list.add("5");

Iterator it = list.iterator();

while(it.hasNext()) {

Object obj = it.next();

System.out.println(obj);

}

} // main

} // class

실행 결과)

1

2

3

4

5

import java.util.*;

class ArrayListEx1

{

    public static void main(String[] args) 

    {

        ArrayList<Integer> list1 = new ArrayList<Integer>(10);

        list1.add(new Integer(5));

        list1.add(new Integer(4));

        list1.add(new Integer(2));

        list1.add(new Integer(0));

        list1.add(new Integer(1));

        list1.add(new Integer(3));

        ArrayList list2 = new ArrayList(list1.subList(1,4)); 

        print(list1, list2);

        Collections.sort(list1);    // list1과 list2를 정렬한다.

        Collections.sort(list2);    // Collections.sort(List l)

        print(list1, list2);

        System.out.println("list1.containsAll(list2):"+ list1.containsAll(list2));

        list2.add("B");

        list2.add("C");

        list2.add(3, "A");

        print(list1, list2);

        list2.set(3, "AA");

        print(list1, list2);

        // list1에서 list2와 겹치는 부분만 남기고 나머지는 삭제한다.

        System.out.println("list1.retainAll(list2):" + list1.retainAll(list2)); 

        print(list1, list2);

        //  list2에서 list1에 포함된 객체들을 삭제한다.

        for(int i= list2.size()-1; i >= 0; i--) {

        //--> for문의 카운터를 0부터 증가시킨 것이 아니라, list2.size()-1 부터 감소시키면서 거꾸로 반복시켰다.

       //만약 카운터를 증가시켜가면서 삭제하면 한 요소가 삭제될 때마다 빈 공간을 채우기 위해 나머지 요소들이 자리이동을 하기 때문에 올바른 결과를 얻을 수 없다. 그래서 카운터를 감소시켜가면서

       //삭제를 해야 자리이동이 발생해도 영향을 받지 않고 작업이 가능하다.

            if(list1.contains(list2.get(i)))

                list2.remove(i);

        }

        print(list1, list2);

    } // main

    static void print(ArrayList list1, ArrayList list2) {

        System.out.println("list1:"+list1);

        System.out.println("list2:"+list2);

        System.out.println();       

    }

} // class

실행 결과)

list1:[5, 4, 2, 0, 1, 3] 

list2:[4, 2, 0]

list1:[0, 1, 2, 3, 4, 5] // Collections.sort(List1)을 이용해서 정렬하였다.(Collections는 클래스이다.)

list2:[0, 2, 4]

list1.containsAll(list2):true // list1이 list2의 모든 요소를 포함하고 있는 경우에만 true를 얻는다.

list1:[0, 1, 2, 3, 4, 5]

list2:[0, 2, 4, A, B, C]// add(Object obj)를 이용해서 새로운 객체를 저장하였다.

list1:[0, 1, 2, 3, 4, 5]

list2:[0, 2, 4, AA, B, C]// set(int index, Object obj)를 이용해서 저장된 객체를 변경하였다.

list1.retainAll(list2):true// retainAll의 작업결과로 list1에 변화가 있었으므로 true를 반환한다.

list1:[0, 2, 4]// list2와의 공통 요소 이외에는 모두 삭제되었다.(변화가 있었다.)

list2:[0, 2, 4, AA, B, C]

list1:[0, 2, 4]

list2:[AA, B, C]

1 static이 붙은 변수들은 객체들이 다 같이 공유하는 데이터를 의미한다.

2 static이 붙은 메소드들은 객체들의 데이터와 관계없는 완벽하게 공통적인 로직을 정의할 때 사용한다.

3 따라서 static 메소드에서는 인스턴스 변수나 객체의 메소드를 사용할 수 없다.

    Random random = new Random( ); ①

    double a = Math.ramdom( ); ②

class Exam_02_Sub {

private String name;

private double don = 1000.0;

private static float iyul = 0.05f;

// static 초기화 구문(static 초기화: 객체 발생 이전)

static {

iyul = 0.05f;

 // 보통 생성자를 선언하여 초기화 하는 것과 같은 구문이다.

// iyul이라는 공간을 0.05f로 초기화 및 선언한다.

// 이렇게 static 선언하면 객체 생성을 하지 않고도 iyul을 사용할 수 있다.

}

// static 메서드: static 필드 컨트롤 목적 즉, static 필드 초기화 및 수정하게 할 목적인 것이다.

public static void setIyul(float iyul) {

Exam_02_Sub.iyul = iyul;

// this.iyul=iyul; this를 넣을 수 없다. static에는 0번째 매개변수가 없다. 

// 왜냐하면 static메서드는 모든 객체가 공유하는 메서드이므로 자기자신이라는 것은 있을 수 없다.

// static 메서드는 this.disp();를 할 수 없다. -->this들어가는 것은 static에서 무조건 쓸 수 없다.

// static 메서드 안에서 일반 메서드를 호출하려면 객체 생성를 해야 한다. 바로 다이렉트로 일반 메서드를 사용할 수 없다.

Exam_02_Sub es = new Exam_02_Sub("C", 1000.0, 0.05f);

es.disp();

}

public Exam_02_Sub(String name, double don, float iyul) {

this.name = name;

this.don = don;

Exam_02_Sub.iyul = iyul;

// 같은 클래스 내부에서는 일반 메서드끼리는 호출이 가능하다.

// this.disp();

}

public void disp() {

System.out.println("name : " + this.name);

System.out.println("don : " + this.don);

// 일반 메서드에서 static을 다이렉트로 호출이 가능하다.

System.out.println("iyul : " + Exam_02_Sub.iyul);

} 

}

public class Exam_02 {

// 일반 메서드를 main 메서드 안에서 호출하려면 static 메서드로 만들어야 한다. 그렇지 않으면 객체생성후 메서드 호출 요한다.

// 일반 메서드로 만들면 this 때문에 static 메서드에서 호출할 수 없다.

public static void main(String[] ar) {

Exam_02_Sub es = new Exam_02_Sub("A", 1000.0, 0.07f);

es.disp();

System.out.println();

Exam_02_Sub es1 = new Exam_02_Sub("B", 1000.0, 0.03f);

es.disp();

es1.disp();

System.out.println();

Exam_02_Sub es2 = new Exam_02_Sub("C", 1000.0, 0.05f);

es.disp();

es1.disp();

es2.disp();

}

}

class Exam_02_Sub_01 {

private String name;

private double don = 1000.0;

private static float iyul = 0.05f;

//private float iyul = 0.05f;

public Exam_02_Sub_01(String name, double don, float iyul) {

this.name = name;

this.don = don;

Exam_02_Sub_01.iyul = iyul;

}

public void disp() {

System.out.println("name : " + this.name);

System.out.println("don : " + this.don);

System.out.println("iyul : " + Exam_02_Sub_01.iyul);

}

}

public class Exam_02_01 {

public static void main(String[] ar) {

Exam_02_Sub_01 es = new Exam_02_Sub_01("A", 1000.0, 0.07f);

es.disp();

System.out.println("-------------");

Exam_02_Sub_01 es1 = new Exam_02_Sub_01("B", 1000.0, 0.03f);

es.disp();

es1.disp();

System.out.println("-------------");

Exam_02_Sub_01 es2 = new Exam_02_Sub_01("C", 1000.0, 0.05f);

es.disp();

es1.disp();

es2.disp();

}

}

1) 클래스를 설계할 때, 멤버변수 중 모든 인스턴스에 공통적으로 사용해야하는 것에 static을 붙인다.

생성된 각 인스턴스는 서로 독립적이기 때문에 각 인스턴스의 변수는 서로 다른 값을 유지한다. 그러나 모든 인스턴스에서 같은 값이 유지되어야 하는 변수는 static을 붙여서 클래스변수로 정의해야 한다.

2) 클래스변수(static 변수)는 인스턴스를 생성하지 않아도 사용할 수 있다.

static이 붙은 변수는 클래스가 메모리에 올라갈 때 이미 자동적으로 생성되기 때문이다.

3) 클래스메서드는 인스턴스변수를 사용할 수 없다.

인스턴스변수는 인스턴스가 반드시 존재해야만 사용할 수 있는데,  클래스메서드는 인스턴스 생성 없이 호출가능하므로 클래스메서드가 호출되었을 때 인스턴스가 존재할 수도 있고, 존재하지 않을 수도 있다.

그래서 클래스메서드에서 인스턴스변수의 사용을 금지한다. 그러나, 인스턴스변수나 인스턴스메서드에서는 static이 붙은 멤버들을 사용하는 것이 언제나 가능하다. 인스턴스변수가 존재한다는 것은 static이 붙은 변수가 이미 메모리에 존재한다는 것을 의미하기 때문이다.

4) 메서드 내에서 인스턴스변수를 사용하지 않는다면, static을 붙이는 것을 고려한다.

메서드의 작업내용 중에서 인스턴스변수를 필요로 한다면, static을 붙일 수 없다. 반대로 인스턴스변수를 필요로 하지 않는다면 static을 붙이자. 메서드 호출시간이 짧아지기 때문에 효율이 높아진다.

인스턴스 메서드는 실행 시 호출되어야할 메서드를 찾는 과정이 추가적으로 필요하기 때문에 시간이 더 걸린다.

class MyMath2 {

long a, b;

// 인스턴스변수 a, b만을 이용해서 작업하므로 매개변수가 필요없다.

long add() { return a + b; } // a, b는 인스턴스변수

long subtract() { return a - b; }

long multiply() { return a * b; }

double divide() { return a / b; }

// 인스턴스변수와 관계없이 매개변수만으로 작업이 가능하다.

static long add(long a, long b) { return a + b; }     // a, b는 지역변수

static long subtract(long a, long b) { return a - b; }

static long multiply(long a, long b) { return a * b; }

static double divide(double a, double b) { return a / b; }

}

class MyMathTest2 {

public static void main(String args[]) {

// 클래스메서드 호출(객체생성없이 매개변수만으로 작업 수행)

System.out.println(MyMath2.add(200L, 100L));

System.out.println(MyMath2.subtract(200L, 100L));

System.out.println(MyMath2.multiply(200L, 100L));

System.out.println(MyMath2.divide(200.0, 100.0));

MyMath2 mm = new MyMath2();

mm.a = 200L;

mm.b = 100L;

// 인스턴스메서드는 객체생성 후에만 호출이 가능함.

System.out.println(mm.add());

System.out.println(mm.subtract());

System.out.println(mm.multiply());

System.out.println(mm.divide());

}

}

실행결과)

300

100

20000

2.0

30

100

20000

2.0

class TestClass{

void instanceMethod(){} //인스턴스 메서드

static void staticMethod(){} // static 메서드

void instanceMethod2(){ //인스턴스 메서드

instanceMethod();//다른 인스턴스메서드를 호출한다.

staticMethod();// static 메서드를 호출한다.

}

static void staticMethod2(){//static 메서드

instanceMethod();// 에러!! 인스턴스메서드를 호출할 수 없다. static 메서드는 같은 클래스 내의 인스턴스 메서드를 호출할 수 없다.

staticMethod();// static 메서드는 호출할 수 있다.

}

}// end of class;

class TestClass2{

int iv;// 인스턴스변수

static int cv;// 클래스 변수

void instanceMethod(){// 인스턴스메서드

System.out.println(iv);// 인스턴스 변수를 사용할 수 있다.

System.out.println(cv);// 클래스변수를 사용할 수 있다.

}

static void staticMethod(){// static 메서드

System.out.println(iv);// 에러! 인스턴스 변수를 사용할 수 없다.

System.out.println(cv);//  클래스 변수를 사용할 수 있다.

}

}// end of class

class MemberCall {

int iv = 10;

static int cv = 20;

int iv2 = cv;

        // static int cv2 = iv;// 에러. 클래스변수는 인스턴스 변수를 사용할 수 없음.

static int cv2 = new MemberCall().iv;// 이처럼 객체를 생성해야 사용가능.

static void staticMethod1() {

System.out.println(cv);

    // System.out.println(iv); // 에러. 클래스메서드에서 인스턴스변수를 사용불가.

MemberCall c = new MemberCall();

System.out.println(c.iv);  // 객체를 생성한 후에야 인스턴스변수의 참조가능.

}

void instanceMethod1() {

System.out.println(cv);

System.out.println(iv); // 인스턴스메서드에서는 인스턴스변수를 바로 사용가능.

}

static void staticMethod2() {

staticMethod1();

    // instanceMethod1(); // 에러. 클래스메서드에서는 인스턴스메서드를 호출할 수 없음.

MemberCall c = new MemberCall();

c.instanceMethod1(); // 인스턴스를 생성한 후에야 호출할 수 있음.

  }

void instanceMethod2() {// 인스턴스메서드에서는 인스턴스메서드와 클래스메서드

staticMethod1();//  모두 인스턴스 생성없이 바로 호출이 가능하다.

instanceMethod1();

}

}

cf.) MemerCall c = new MemberCall();

      int result = c. instanceMethod(); 

      int result = new MemberCall().instanceMethod(); 

      --> 위의 두 줄을 다음과 같이 한 줄로 할 수 있다.

1) 인스턴스 메소드는 클래스 맴버에 접근 할 수 있다.

2) 클래스 메소드는 인스턴스 맴버에 접근 할 수 없다. 

class C1{

    static int static_variable = 1;

    int instance_variable = 2;

    static void static_static(){

        System.out.println(static_variable);

    }

    static void static_instance(){

        // 클래스 메소드에서는 인스턴스 변수에 접근 할 수 없다. 

        //System.out.println(instance_variable);

    }

    void instance_static(){

        // 인스턴스 메소드에서는 클래스 변수에 접근 할 수 있다.

        System.out.println(static_variable);

    }

    void instance_instance(){        

        System.out.println(instance_variable);

    }

}

public class ClassMemberDemo {  

    public static void main(String[] args) {

        C1 c = new C1();

        // 인스턴스를 이용해서 정적 메소드에 접근 -> 성공

        // 인스턴스 메소드가 정적 변수에 접근 -> 성공

        c.static_static();

        // 인스턴스를 이용해서 정적 메소드에 접근 -> 성공

        // 정적 메소드가 인스턴스 변수에 접근 -> 실패

        c.static_instance();

        // 인스턴스를 이용해서 인스턴스 메소드에 접근 -> 성공

        // 인스턴스 메소드가 클래스 변수에 접근 -> 성공

        c.instance_static();

        // 인스턴스를 이용해서 인스턴스 메소드에 접근 -> 성공 

        // 인스턴스 메소드가 인스턴스 변수에 접근 -> 성공

        c.instance_instance();

        // 클래스를 이용해서 클래스 메소드에 접근 -> 성공

        // 클래스 메소드가 클래스 변수에 접근 -> 성공

        C1.static_static();

        // 클래스를 이용해서 클래스 메소드에 접근 -> 성공

        // 클래스 메소드가 인스턴스 변수에 접근 -> 실패

        C1.static_instance();

        // 클래스를 이용해서 인스턴스 메소드에 접근 -> 실패

        //C1.instance_static();

        // 클래스를 이용해서 인스턴스 메소드에 접근 -> 실패

        //C1.instance_instance();

    } 

}

실행결과)

1

1

2

1

class Card{

String kind;// 카드의 무늬(인스턴스 변수)

int number;// 카드의 숫자(인스턴스 변수)

static int width;// 카드의 폭(클래스 변수)

static int weight;// 카드의 높이(클래스 변수)

}

class CardTest{

public static void main(String argd[]){

System.out.println("Card.width="+Card.width);

System.out.println("Card.height="+Card.height);

// 클래스 변수는 객체 생성 없이 ‘클래스이름.클래스변수’로 직접 사용 가능하다.

Card c1 = new Card();

c1.kind = "Heart";

c1.number = 7;

Card.c2 = new Card();

c2.kind = "Spade";

c2.number = 4;// 인스턴스변수의 값을 변경한다.

System.out.println("c1은“+c1.kind+","+c1.number+"이며, 크기는 ("c1.width+","+c1.height+")");

System.out.println("c2은“+c2.kind+","+c2.number+"이며, 크기는  ("c2.width+","+c2.height+")");

System.out.println("c1의 width와 height를 각각 50,80으로 변경합니다.“);

c1.width = 50;

c1.height = 80;// 클래스 변수의 값을 변경한다.

System.out.println("c1은“+c1.kind+","+c1.number+"이며, 크기는 ("c1.width+","+c1.height+")");

System.out.println("c2은“+c2.kind+","+c2.number+"이며, 크기는  ("c2.width+","+c2.height+")");

}

}

class Card{

String kind;

int number;

static int width =100;

static int height =250;

}

실행결과)

Card.width=100

Card.height=250

c1은Heart,7이며, 크기는 (100,250)

c2은Spade,4이며, 크기는  (100,250)

c1의 width와 height를 각각 50,80으로 변경합니다.

c1은Heart,7이며, 크기는 (50,80)

c2은Spade,4이며, 크기는  (50,80)

<servlet>

<servlet-name>shopping-1</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>shopping-1</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<servlet>

<servlet-name>shopping-1</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>shopping-1</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

<!-- ApplicationContext 빈 설정 파일-->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

              <!--빈 설정 파일들간에 구분은 줄바꿈(\n),컴마(,),세미콜론(;)등으로 한다.-->

                            /WEB-INF/config/easycompany-service.xml,/WEB-INF/config/easycompany-dao.xml 

            </param-value>

</context-param>

<!-- 웹 어플리케이션이 시작되는 시점에 ApplicationContext을 로딩하며, 로딩된 빈정보는 모든 WebApplicationContext들이 참조할 수 있다.-->

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<servlet>

<servlet-name>employee</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/config/easycompany-service.xml</param-value>

</init-param>

</servlet>

<servlet>

<servlet-name>webservice</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/config/easycompany-webservice.xml</param-value>

</init-param>

</servlet>

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

version="2.5">

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<servlet>

<servlet-name>shopping3-2</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>shopping3-2</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

</web-app>

 <servlet>

        <servlet-name>dispather</servlet-name>

        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>

<param-name>contextConfiguration</param-value>

<param-value>

/WEB-INF/main.xml

/WEB-INF/dds.xml

</param-value>

</init-param>

</servlet>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

/WEB-INF/security.xml 

/WEB-INF/applicationContext.xml

</param-value>

</context-param>

<servlet>

<servlet-name>shopping3-7</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>shopping3-7</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

version="2.5">

<filter>

<filter-name>CharacterEncodingFilter</filter-name>

<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>UTF-8</param-value>

</init-param>

<init-param>

<param-name>forceEncoding</param-name>

<param-value>true</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>CharacterEncodingFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<servlet>

<servlet-name>shopping3-3</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>shopping3-3</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

</web-app>

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"

version="2.5">

<!-- 필터 설정 -->

<filter>

<filter-name>CharacterEncodingFilter</filter-name>

<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>UTF-8</param-value>

</init-param>

<init-param>

<param-name>forceEncoding</param-name>

<param-value>true</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>CharacterEncodingFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<!-- 리스너 설정 -->

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>/WEB-INF/security.xml /WEB-INF/applicationContext.xml</param-value>

</context-param>

<!-- DispathcherSerlvet 설정 -->

<servlet>

<servlet-name>shopping3-7</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>shopping3-7</servlet-name>

<url-pattern>*.html</url-pattern>

</servlet-mapping>

<!-- <filter-mapping> 요소에서의 'springSecurityFilterChain'은 'org.springframework.web.filter.DelegatingFilterProxy'에 붙인 필터 이름이다. 

DelegatingFilterProxy 클래스는 스프링이 제공하는 필터이고, 실제 처리를 필터 이름에 일치하는 이름의 Bean에 위임한다. 

스프링 시큐리티는 'springSecurityFilterChain'이라는 이름으로 스프링에 Bean을 등록하기 때문에 이렇게 필터를 정의하면 스프링 시큐리티 기능이 유효해 진다. 

또한 애플리케이션의 모든 URL에 대해 이 필터 체인을 유효하게 하고, 스프링 시큐리티를 작동시킨다.-->

<filter>

<filter-name>springSecurityFilterChain</filter-name>

<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>

</filter>

<filter-mapping>

<filter-name>springSecurityFilterChain</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<!-- 이중 로그인을 막기 위한 리스너 클래스이다.-->

<listener>

<listener-class>org.springframework.security.web.session.HttpSessionEventPublisher</listener-class>

</listener>

<!-- error 페이지 설정 -->

<error-page>

<error-code>403</error-code>

<location>/WEB-INF/jsp/noAuthority.jsp</location>

</error-page>

</web-app>