import java.io.*;

class FileEx1

{

public static void main(String[] args) throws IOException

{

File f = new File("c:\\jdk1.5\\work\\ch14\\FileEx1.java");

String fileName = f.getName();

int pos = fileName.lastIndexOf(".");

System.out.println("경로를 제외한 파일이름 - " + f.getName());

System.out.println("확장자를 제외한 파일이름 - " + fileName.substring(0,pos));

System.out.println("확장자 - " + fileName.substring(pos+1));

System.out.println("경로를 포함한 파일이름 - " + f.getPath());

System.out.println("파일의 절대경로        - " + f.getAbsolutePath());

System.out.println("파일이 속해 있는 디렉토리 - " + f.getParent());

System.out.println();

System.out.println("File.pathSeparator - " + File.pathSeparator); // 파일 전체 path 구분자. ;

System.out.println("File.pathSeparatorChar - " + File.pathSeparatorChar);

System.out.println("File.separator - " + File.separator); // 디렉터리 구분다. /

System.out.println("File.separatorChar - " + File.separatorChar);

System.out.println();

System.out.println("user.dir="+System.getProperty("user.dir"));

System.out.println("sun.boot.class.path=" + System.getProperty("sun.boot.class.path"));

}

}

실행결과)

경로를 제외한 파일이름 - FileEx1.java

확장자를 제외한 파일이름 - FileEx1

확장자 - java

경로를 포함한 파일이름 - c:\jdk1.5\work\ch14\FileEx1.java

파일의 절대경로        - c:\jdk1.5\work\ch14\FileEx1.java

파일이 속해 있는 디렉토리 - c:\jdk1.5\work\ch14

File.pathSeparator - ;

File.pathSeparatorChar - ;

File.separator - \

File.separatorChar - \

user.dir=E:\Eclipse_Source\JAVA\My_Lib

sun.boot.class.path=C:\Program Files (x86)\Java\jre6\lib\resources.jar;C:\Program Files (x86)\Java\jre6\lib\rt.jar;C:\Program Files (x86)\Java\jre6\lib\sunrsasign.jar;C:\Program Files (x86)\Java\jre6\lib\jsse.jar;C:\Program Files (x86)\Java\jre6\lib\jce.jar;C:\Program Files (x86)\Java\jre6\lib\charsets.jar;C:\Program Files (x86)\Java\jre6\lib\modules\jdk.boot.jar;C:\Program Files (x86)\Java\jre6\classes

1 이미 존재하는 파일을 참조할 때

File f = new File("c:\\jdk\\work\\ch14", "File1.java");

2. 기존에는 없는 파일을 새로 생성할 때

File f = new File("c:\\jdk\\work\\ch14", "File2.java");

f. createNewFile(); //새로운 파일이 생성된다.

import java.io.File;

public class Exam_02 {

public static void main(String[] ar) {

File f = new File("Exam_01.java");// 존재하든 관계없이 파일 객체 생성 가능

File f1 = new File("Exam_03.java");// 존재 안하든 관계없이 파일 객체 생성 가능

File f2 = new File("C:" + File.separator + "test" + File.separator + "lecture\\Exam_02.java");

File dir = new File("E:\\Eclipse_Source\\JAVA\\Java_KSH\\io");

File f3 = new File(dir, "Exam_04.java");

File f4 = new File("E:\\Eclipse_Source\\JAVA\\Java_KSH\\io", "Exam_05.java");

}

}

import java.io.File;

import java.util.Date;

public class Exam_04 {

public static void main(String[] ar) {

File f = new File("aaa");

// 폴더 만들기

f.mkdir();

File ff = new File("bbb/ccc/ddd/eee");

// 복수의 폴더 만들기

ff.mkdirs();

//File fff = new File("Exam_01");

// 수정일자 변경

f.setLastModified(new Date().getTime());

f.setReadOnly();

//ff.setLastModified(new Date().getTime());

}

}

import java.io.File;

import java.io.FileDescriptor;

import java.io.FileOutputStream;

import java.io.IOException;

public class Exam_05 {

public static void main(String[] ar) throws IOException {

// 출력 객체 만들기, FileDescriptor.out: 콘솔에 출력하기

FileOutputStream fos1 = new FileOutputStream(FileDescriptor.out);// 파일 객체, network 객체

File f = new File("C:\\test\\aaa.txt");

// 두번째 매개변수에 true면 덮어쓰기 하지 않고 내용이 추가된다.

FileOutputStream fos2 = new FileOutputStream(f, true);

byte[] by = new byte[]{'H', 'e', 'l', 'l', 'o', ' ', 'J', 'a', 'v', 'a'};

fos1.write(by, 6,4); 

// index[6]에서 부터 4번째 문자열 출력

fos2.write(by);

fos1.write(65);

fos1.close();

fos2.close();

}

}

import java.io.BufferedInputStream;

import java.io.DataInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

public class Exam_08 {

public static void main(String[] ar) throws IOException {

File f = new File("C://test/bbb.txt");

FileInputStream fis = new FileInputStream(f);

BufferedInputStream bis = new BufferedInputStream(fis, 1024);

DataInputStream dis = new DataInputStream(bis);

while(true) {

int x = dis.read();

if(x == -1) break;

System.out.print(x);

}

dis.close();

}

}

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStreamReader;

public class Exam_10 {

public static void main(String[] ar) throws IOException {

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

// 한줄로 요약

//BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

File f = new File("C://test/ccc.txt");

FileReader fr = new FileReader(f);

BufferedReader br1 = new BufferedReader(fr);

System.out.print("문자열 = ");

String str = br.readLine();

System.out.println("str = " + str);

System.out.print("숫자 = ");

int x = Integer.parseInt(br.readLine());

System.out.println("x = " + x);

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

while(true) {

// 개행하며 한 줄씩 읽어들이기

String s = br1.readLine();

if(s == null) break;

System.out.println("s = " + s);

}

br.close();

br1.close();

}

}

import java.io.*;

class FileReaderEx1 {

public static void main(String args[]) {

try {

String fileName = "test.txt";

FileInputStream fis = new FileInputStream(fileName);

FileReader fr = new FileReader(fileName);

int data =0;

// FileInputStream을 이용해서 파일내용을 읽어 화면에 출력한다.

while((data=fis.read())!=-1) {

System.out.print((char)data);

}

System.out.println();

fis.close();

// FileReader를 이용해서 파일내용을 읽어 화면에 출력한다.

while((data=fr.read())!=-1) {

System.out.print((char)data);

}

System.out.println();

fr.close();

} catch (IOException e) {

e.printStackTrace();

}

} // main

}

import java.io.*;

class InputStreamReaderEx 

{

public static void main(String[] args) 

{

String line = "";

try {

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

System.out.println("사용중인 OS의 인코딩 :" + isr.getEncoding());

do {

System.out.print("문장을 입력하세요. 마치시려면 q를 입력하세요. ");

line = br.readLine();

System.out.println("입력하신 문장 : "+line);

} while(!line.equalsIgnoreCase("q"));

// br.close();   // System.in과 같은 표준입출력은 닫지 않아도 된다.

System.out.println("프로그램을 종료합니다.");

} catch(IOException e) {}

} // main

}

public abstract class InputStream{

...

abstract int read();

// 입력스트림으로부터 1byte를 읽어서 반환한다. 읽을 수 없으면 -1을 반환한다.

int read(byte[] b, int off, int len){

  // 입력스트림으로부터 ien개의 byte를 읽어서 byte배열 b의 off위치부터 저장한다.

...

for(int i-off, i < off+len; i++){

b[i]=(byte)read();

// read()를 호출해서 데이터를 읽어서 배열을 채운다.

}

...

}

int read(byte[] b){

  // 입력스트림으로부터 byte배열 b의 크기만큼 데이터를 읽어서 배열 b에 저장한다.

return read(b, 0, b.length);

}

...

// 먼저 기반스트림을 생성한다.FileInputStream은 InputStream의 자손 클래스이다.

FileInputStream fis = new FileInputStream("test.txt");

// 기반스트림을 이용해서 보조스트림을 생성한다.

BufferedInputStream bis = new BufferedInputStream(fis);

// 보조 스트림인 BufferedInputStream으로 부터 데이터를 읽는다.

bis.read();

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)