자바

[Java 고급] 14장 보조 스트림 클래스

반응형

 

BufferedOutputStream (버퍼 스트림) : 바이트 기반 스트림

 

 

  • 보조 스트림 사용 전
package kr.or.ddit.basic;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class T11BufferedIOTest {
	public static void main(String[] args) {
		// 입출력 성능 향상을 위해 버퍼를 사용하는 보조 스트림
		FileOutputStream fos = null;
		
		try {
			fos = new FileOutputStream("d:/D_Other/bufferTest.txt");
			
			for(char ch='1'; ch<='9'; ch++) {
				fos.write(ch);
			}
			
			System.out.println("작업 끝");
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 

결과 화면1

 

bufferTest.txt

 

 

 

  • 보조 스트림 사용 후

버퍼 크기를 지정하지 않으면 기본적으로 버퍼크기는 8192byte(8KB)로 설정된다.
보조 스트림만 close() 해주면 된다.

 

 

package kr.or.ddit.basic;

import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class T11BufferedIOTest {
	public static void main(String[] args) {
		// 입출력 성능 향상을 위해 버퍼를 사용하는 보조 스트림
		FileOutputStream fos = null;
		BufferedOutputStream bos = null;
		
		try {
			fos = new FileOutputStream("d:/D_Other/bufferTest.txt");
			
			// 버퍼 크기를 지정하지 않으면 기본적으로 버퍼크기는 8192byte(8KB)로 설정된다.
			bos = new BufferedOutputStream(fos, 5); // 버퍼 크기는 5byte로 세팅
			
			for(char ch='1'; ch<='9'; ch++) {
				bos.write(ch);
			}
			
			System.out.println("작업 끝");
            
			bos.flush(); // 작업을 종료하기 전 버퍼에 남아있는 데이터를 모두 출력 시킨다.
						 // close() 호출 시 자동으로 호출됨.
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				bos.close(); // 보조 스트림만 닫으면 됨
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 

결과 화면2

 

bufferTest.txt

 

 

 

사용법 뜻
flush() 작업을 종료하기 전 버퍼에 남아있는 데이터 모두 출력
close() 호출 시 자동으로 호출

 

 

 

BufferedReader (버퍼 스트림) : 문자 기반 스트림 

 

한 줄 씩 읽어오는 특징이 있다.

 

 

  • 보조 스트림 사용 전
package kr.or.ddit.basic;

import java.io.FileReader;
import java.io.IOException;

public class T12BufferedIOTest {
	public static void main(String[] args) {
		
		FileReader fr = null;
		
		try {
			fr = new FileReader("./src/kr/or/ddit/basic/T11BufferedIOTest.java");
			
			int data = 0;
			
			while ((data = fr.read()) != -1) {
				System.out.print((char)data);
			}
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				fr.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 

결과 화면3

 

 

 

  • 보조 스트림 사용 후
package kr.or.ddit.basic;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class T12BufferedIOTest {
	public static void main(String[] args) {
		
		FileReader fr = null;
		
		BufferedReader br = null;
		
		try {
			fr = new FileReader("./src/kr/or/ddit/basic/T11BufferedIOTest.java");
			br = new BufferedReader(fr);
			
			/*
			int data = 0;
			
			while ((data = fr.read()) != -1) {
				System.out.print((char)data);
			}
			*/
			
			String tempStr = null;
			
			int cnt = 1;
			while((tempStr = br.readLine()) != null) {
				System.out.printf("%4d : %s\n", cnt++, tempStr);
			}
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				fr.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

 

결과 화면4

 

 

 

DataInputStream & DataOutputStream : 기본 타입 입출력

 

출력용 데이터를 해당 자료형에 맞게 출력해주기 위해 사용하는 보조 스트림 객체

 

 

  • 사용법
사용법 뜻
DataInputStream 보조 스트림 객체
하단의 방식을 쓸 수 있게 하기 위해 사용함
DataOutputStream
writeUTF() 문자열 데이터 출력 (UTF-8)
readUTF() 문자열 데이터 읽기 (UTF-8)
writeInt() 정수형 데이터 출력
readInt() 정수형 데이터 읽기
writeFloat() 실수형(Float) 출력
readFloat() 실수형(Float) 읽기
writeDouble() 실수형(Double) 출력
readDouble() 실수형(Double) 읽기
writeBoolean() 논리형 데이터 출력
readBoolean() 논리형 데이터 읽기

 

 

package kr.or.ddit.basic;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 기본 타입 입출력을 위한 보조 스트림
 */
public class T13DataIOStreamTest {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("d:/D_Other/test.dat");
		
		// 출력용 데이터를 해당 자료형에 맞게 출력해주기 위해 보조 스트림 객체 사용
		DataOutputStream dos = new DataOutputStream(fos);
		
		dos.writeUTF("홍길동"); 	// 문자열 데이터 출력(UTF-8)
		dos.writeInt(17);		// 정수형 데이터 출력
		dos.writeFloat(3.14f);	// 실수형(Float) 출력
		dos.writeDouble(3.14);	// 실수형(Double) 출력
		dos.writeBoolean(true);	// 논리형 데이터 출력
		
		System.out.println("출력 완료...");
		
		dos.close();
		
		///////////////////////////////////////////////////////////////////
		// 출력한 데이터 읽어오기
		
		FileInputStream fis = new FileInputStream("d:/D_Other/test.dat");
		
		DataInputStream dis = new DataInputStream(fis);
		
		System.out.println("문자열 데이터 : " + dis.readUTF());
		System.out.println("정수형 데이터 : " + dis.readInt());
		System.out.println("실수형(Float) 데이터 : " + dis.readFloat());
		System.out.println("실수형(Double) 데이터 : " + dis.readDouble());
		System.out.println("논리형 데이터 : " + dis.readBoolean());
		
		System.out.println("데이터 읽기 완료...");
		
		dis.close();
	}
}

 

결과 화면5

 

 

 

PrintStream & PrintWriter : 프린터 기능 제공

 

: 모든 타입의 데이터를 출력해 주는 기능을 제공하는 스트림

 

 

package kr.or.ddit.basic;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;

/**
 * 프린터 기능을 제공하는 보조 스트림
 * @author PC-10
 *
 */
public class T14PrintStreadmTest {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("d:/D_Other/print.txt");
		
		// PrintStream 은 모든 타입의 데이터를 출력해 주는 기능을 제공하는 스트림
		PrintStream out = new PrintStream(fos);
		out.print("안녕하세요. PrintStream입니다.\n");
		out.println("안녕하세요. PrintStream입니다.2");
		out.println("안녕하세요. PrintStream입니다.3");
		out.println(3.14);
		out.println(out);  // 객체 출력
		
		out.close();
		
		////////////////////////////////////////////////////////////////
		
		FileOutputStream fos2 = new FileOutputStream("d:/D_Other/print2.txt");
		PrintWriter pw = new PrintWriter(new OutputStreamWriter(fos2, "CP949"));
		
		pw.print("안녕하세요. PrintWriter입니다.\n");
		pw.println("안녕하세요. PrintWriter입니다.2");
		pw.println("안녕하세요. PrintWriter입니다.3");
		pw.println(3.14);
		pw.println(pw); // 객체 출력
		
		pw.close();
	}
}

 

PrintStream으로 찍은 것

 

PrintWriter로 찍은 것

 

 

 

ObjectInputStream & ObjectOutputStream : 객체 입출력

 

 

사용법 뜻
ObjectInputStream byte 를 Object 또는 Data 형태로 데이터 변환
ObjectOutputStream Object 또는 Data를 byte 형태로 데이터 변환
writeObject() ObjectOutputStream 사용할 때 사용
readObject() ObjectInputStream 사용할 때 사용
defaultWriteObject() 직렬화, 역직렬화 사용시 사용
defaultReadObject() 직렬화, 역직렬화 사용시 사용

 

 

package kr.or.ddit.basic;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

/**
 * 객체 입출력 스트림 예제
 */
public class T15ObjectStreamTest {
	public static void main(String[] args) {
		MemberVO mem1 = new MemberVO("김일규", 23, "대전");
		MemberVO mem2 = new MemberVO("이미숙", 25, "서울");
		MemberVO mem3 = new MemberVO("이평강", 23, "광주");
		MemberVO mem4 = new MemberVO("이종진", 23, "대구");
		
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;

		try {
			fos = new FileOutputStream("d:/D_Other/memObject.bin");
			
			// 객체 저장 기능을 위한 스트림 객체 생성
			oos = new ObjectOutputStream(fos);
			
			// 객체 저장하기
			oos.writeObject(mem1);
			oos.writeObject(mem2);
			oos.writeObject(mem3);
			oos.writeObject(mem4);
			
			System.out.println("객체 저장 완료...");
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

class MemberVO {
	private String name;
	private int age;
	private String addr;
	
	public MemberVO(String name, int age, String addr) {
		super();
		this.name = name;
		this.age = age;
		this.addr = addr;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

	public String getAddr() {
		return addr;
	}

	public void setAddr(String addr) {
		this.addr = addr;
	}
}

 

결과 화면6 : 객체의 직렬화

 

 

 

객체의 직렬화 (<-> 역직렬화: 객체를 읽음)

: 객체를 스트림 형식으로 파일을 저장하는 방식

바이트 스트림(stream of bytes) 형태로 연속전인(serial) 데이터로 변환하는 포맷 변환 기술

 

=> 직렬화 하기 위해 Serializable 인터페이스를 구현해주어야 함.

 

 

package kr.or.ddit.basic;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 객체 입출력 스트림 예제
 */
public class T15ObjectStreamTest {
	public static void main(String[] args) {
		MemberVO mem1 = new MemberVO("김일규", 23, "대전");
		MemberVO mem2 = new MemberVO("이미숙", 25, "서울");
		MemberVO mem3 = new MemberVO("이평강", 23, "광주");
		MemberVO mem4 = new MemberVO("이종진", 23, "대구");
		
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;

		try {
			fos = new FileOutputStream("d:/D_Other/memObject.bin");
			
			// 객체 저장 기능을 위한 스트림 객체 생성
			oos = new ObjectOutputStream(fos);
			
			// 객체 저장하기
			oos.writeObject(mem1); // 직렬화 작업 진행됨
			oos.writeObject(mem2);
			oos.writeObject(mem3);
			oos.writeObject(mem4);
			
			System.out.println("객체 저장 완료...");
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

class MemberVO implements Serializable {
	// 자바는 Serialializable 인터페이스를 구현하는 클래스만 직렬화 할 수 있도록 제한하고 있음
	
	private String name;
	private int age;
	private String addr;
	
	public MemberVO(String name, int age, String addr) {
		super();
		this.name = name;
		this.age = age;
		this.addr = addr;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

	public String getAddr() {
		return addr;
	}

	public void setAddr(String addr) {
		this.addr = addr;
	}
}

 

결과 화면7

 

 

package kr.or.ddit.basic;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 객체 입출력 스트림 예제
 */
public class T15ObjectStreamTest {
	public static void main(String[] args) {
		MemberVO mem1 = new MemberVO("김일규", 23, "대전");
		MemberVO mem2 = new MemberVO("이미숙", 25, "서울");
		MemberVO mem3 = new MemberVO("이평강", 23, "광주");
		MemberVO mem4 = new MemberVO("이종진", 23, "대구");
		
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;

		try {
			fos = new FileOutputStream("d:/D_Other/memObject.bin");
			
			// 객체 저장 기능을 위한 스트림 객체 생성
			oos = new ObjectOutputStream(fos);
			
			// 객체 저장하기
			oos.writeObject(mem1); // 직렬화 작업 진행됨
			oos.writeObject(mem2);
			oos.writeObject(mem3);
			oos.writeObject(mem4);
			
			System.out.println("객체 저장 완료...");
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		//////////////////////////////////////////////////
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		
		try {
			fis = new FileInputStream("d:/D_Other/memObject.bin");
			ois = new ObjectInputStream(fis);
			
			Object obj = null;
			
			while((obj = ois.readObject()) != null) {
				// 읽어온 객체를 원래의 객체로 캐스팅 후 사용
				MemberVO mv = (MemberVO) obj;
				System.out.println("이름 : " + mv.getName());
				System.out.println("나이 : " + mv.getAge());
				System.out.println("주소 : " + mv.getAddr());
				System.out.println("----------------------------");
			}
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

class MemberVO implements Serializable {
	// 자바는 Serialializable 인터페이스를 구현하는 클래스만 직렬화 할 수 있도록 제한하고 있음
	
	private String name;
	private int age;
	private String addr;
	
	public MemberVO(String name, int age, String addr) {
		super();
		this.name = name;
		this.age = age;
		this.addr = addr;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

	public String getAddr() {
		return addr;
	}

	public void setAddr(String addr) {
		this.addr = addr;
	}
}

 

결과 화면8 : 파일을 마지막에 다다르면 EOFException이 발생함. ex.printStackTrace();을 주석처리 하면  EOFException을 보여주지 않음

 

 

 

  • transient 사용

transient => 직렬화 되지 않았으면 하는 인스턴스 변수를 지정
   (static 변수는 직렬화 대상이 아님)
   직렬화가 되지 않는 멤버 변수는 기본값으로 저장된다.
   (참조형 변수 : null, 숫자형 변수 : 0)

 

 

package kr.or.ddit.basic;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 객체 입출력 스트림 예제
 */
public class T15ObjectStreamTest {
	public static void main(String[] args) {
		MemberVO mem1 = new MemberVO("김일규", 23, "대전");
		MemberVO mem2 = new MemberVO("이미숙", 25, "서울");
		MemberVO mem3 = new MemberVO("이평강", 23, "광주");
		MemberVO mem4 = new MemberVO("이종진", 23, "대구");
		
		FileOutputStream fos = null;
		ObjectOutputStream oos = null;

		try {
			fos = new FileOutputStream("d:/D_Other/memObject.bin");
			
			// 객체 저장 기능을 위한 스트림 객체 생성
			oos = new ObjectOutputStream(fos);
			
			// 객체 저장하기
			oos.writeObject(mem1); // 직렬화 작업 진행됨
			oos.writeObject(mem2);
			oos.writeObject(mem3);
			oos.writeObject(mem4);
			
			System.out.println("객체 저장 완료...");
			
		} catch (IOException ex) {
			ex.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
		//////////////////////////////////////////////////
		FileInputStream fis = null;
		ObjectInputStream ois = null;
		
		try {
			fis = new FileInputStream("d:/D_Other/memObject.bin");
			ois = new ObjectInputStream(fis);
			
			Object obj = null;
			
			while((obj = ois.readObject()) != null) {
				// 파일을 마지막에 다다르면 EOFException이 발생함.
				
				// 읽어온 객체를 원래의 객체로 캐스팅 후 사용
				MemberVO mv = (MemberVO) obj;
				System.out.println("이름 : " + mv.getName());
				System.out.println("나이 : " + mv.getAge());
				System.out.println("주소 : " + mv.getAddr());
				System.out.println("----------------------------");
			}
			
		} catch (IOException ex) {
//			ex.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		
	}
}

class MemberVO implements Serializable {
	// 자바는 Serialializable 인터페이스를 구현하는 클래스만 직렬화 할 수 있도록 제한하고 있음
	
	// transient => 직렬화 되지 않았으면 하는 인스턴스 변수를 지정
	//				(static 변수는 직렬화 대상이 아님)
	//				직렬화가 되지 않는 멤버 변수는 기본값으로 저장된다.
	//				(참조형 변수 : null, 숫자형 변수 : 0)
	
	private String name;
	private transient int age;
	private String addr;
	
	public MemberVO(String name, int age, String addr) {
		super();
		this.name = name;
		this.age = age;
		this.addr = addr;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

	public String getAddr() {
		return addr;
	}

	public void setAddr(String addr) {
		this.addr = addr;
	}
}

 

결과 화면9

 

 

 

  • 부모 클래스가 Serializable 인터페이스를 구현하고 있지 않을 경우 부모객체의 필드값 처리 방법

1. 부모 클래스가 Serializable 인터페이스를 구현

package kr.or.ddit.basic;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class T16NonSerializableParentTest {
/*
 * 부모 클래스가 Serializable 인터페이스를 구현하고 있지 않을 경우 부모객체의 필드값 처리 방법
 * 
 * 1. 부모 클래스가 Serializable 인터페이스를 구현하도록 해야한다.
 * 2. 자식 클래스에 writeObject()와 readObject()메서드를 구현하여 부모객체의 필드값을 
 * 처리할 수 있도록 한다.
 */
	
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		ObjectOutputStream oos = 
				new ObjectOutputStream(
						new FileOutputStream("d:/D_Other/nonSerializableTest.bin"));
		
		Child child = new Child();
		child.setParentName("부모");
		child.setChildName("자식");
		
		oos.writeObject(child);
		System.out.println("객체 저장 완료...");
		oos.close();
		
		///////////////////////////////////////////////////////////////
		
		ObjectInputStream ois = 
				new ObjectInputStream(
						new FileInputStream("d:/D_Other/nonSerializableTest.bin"));
		
		Child child2 = (Child)ois.readObject(); // 역직렬화
		System.out.println("parentName : " + child2.getParentName());
		System.out.println("childName : " + child2.getChildName());
		
		ois.close();
	}
}


// Serializable 인터페이스를 구현하지 않은 부모 클래스
class Parent {
	private String parentName;

	public String getParentName() {
		return parentName;
	}

	public void setParentName(String parentName) {
		this.parentName = parentName;
	}
}

// Serializable 인터페이스 구현한 자식 클래스
class Child extends Parent implements Serializable {
	private String childName;

	public String getChildName() {
		return childName;
	}

	public void setChildName(String childName) {
		this.childName = childName;
	}
}

 

결과 화면10

 

 

2. 자식 클래스에 writeObject()와 readObject()메서드를 구현

package kr.or.ddit.basic;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class T16NonSerializableParentTest {
/*
 * 부모 클래스가 Serializable 인터페이스를 구현하고 있지 않을 경우 부모객체의 필드값 처리 방법
 * 
 * 1. 부모 클래스가 Serializable 인터페이스를 구현하도록 해야한다.
 * 2. 자식 클래스에 writeObject()와 readObject()메서드를 구현하여 부모객체의 필드값을 
 * 처리할 수 있도록 한다.
 */
	
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		ObjectOutputStream oos = 
				new ObjectOutputStream(
						new FileOutputStream("d:/D_Other/nonSerializableTest.bin"));
		
		Child child = new Child();
		child.setParentName("부모");
		child.setChildName("자식");
		
		oos.writeObject(child);
		System.out.println("객체 저장 완료...");
		oos.close();
		
		///////////////////////////////////////////////////////////////
		
		ObjectInputStream ois = 
				new ObjectInputStream(
						new FileInputStream("d:/D_Other/nonSerializableTest.bin"));
		
		Child child2 = (Child)ois.readObject(); // 역직렬화
		System.out.println("parentName : " + child2.getParentName());
		System.out.println("childName : " + child2.getChildName());
		
		ois.close();
	}
}


// Serializable 인터페이스를 구현하지 않은 부모 클래스
class Parent {
	private String parentName;

	public String getParentName() {
		return parentName;
	}

	public void setParentName(String parentName) {
		this.parentName = parentName;
	}
}

// Serializable 인터페이스 구현한 자식 클래스
class Child extends Parent implements Serializable {
	private String childName;

	public String getChildName() {
		return childName;
	}

	public void setChildName(String childName) {
		this.childName = childName;
	}
	
	/**
	 * 직렬화 될 때 자동으로 호출됨.
	 * (접근 제한자가 private이 아니면 자동 호출되지 않음) 
	 * @param oos
	 * @throws IOException
	 */
	private void writeObject(ObjectOutputStream oos) throws IOException {
		oos.writeUTF(getParentName());
		oos.defaultWriteObject();
	}
	
	/**
	 * 역직렬화가 될 때 자동으로 호출됨.
	 * (접근 제한자가 private이 아니면 자동 호출 되지 않음)
	 * @param ois
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
		setParentName(ois.readUTF());
		ois.defaultReadObject();
	}
	
}

 

결과 화면11

 

 

반응형

'자바' 카테고리의 다른 글

[Java 고급] 16장 JDBC  (0) 2024.02.02
[Java 고급] 15장 람다식  (0) 2024.02.02
[Java 고급] 13장 스트림 클래스  (1) 2024.01.31
[Java 고급] 12장 File 객체  (0) 2024.01.30
[Java 고급] 10.5장 Test  (1) 2024.01.29

티스토리툴바