1
Java object model
Part 3: Serialization & Reflection
2
Serialization
•
Denotes the process of storing an object to a
stream without converting to an external
representataion
•
Serialization allows an object to be persistent: that
is, to exist separate from the program that created
it
•
When an object is serialized, it is transformed into
a sequence of bytes; this can later be restored to
the original object
3
Java object serialization
•
In order for an object to be serialized, it must
implement the Serializable interface
•
Like Cloneable, Serializable is devoid of methods
•
To serialize an object, invoke the writeObject()
method of the ObjectOutputStream class; to
deserialize, invoke the readObject() method of
ObjectInputStream
4
Example
// write data to output file:
MyClass[] students = new MyClass[12];
...
ObjectOutputStream outs = new ObjectOutputStream
(new FileOutputStream(“myfile.dat”));
outs.writeObject(students);
outs.close();
// read data from input file:
ObjectInputStream ins = new ObjectInputStream
(new FileInputStream(“myfile.dat”));
MyClass students = (MyClass[]) ins.readObject();
ins.close();
5
Serialization & dependent objects
•
Serialization automatically takes into
account any additional referenced objects
-
follows all references contained in the
object being serialized & serializes them
•
Thus, any objects contained within a
serializable object must also implement
Serializable
6
Standard Java classes &
serialization
•
Many standard classes implement
Serializable
•
Examples:
–
String
–
ArrayList: means entire list of objects could be
stored in a single operation
7
The
transient
modifier
•
We may wish to exclude some information
when serializing an object:
–
passwords or other confidential data
–
extraneous data (whether or not a particular
graphical object was in a selected state, e.g.)
•
Reserved word transient can be used to
modify variable declaration; such a variable
will not be represented when the object is
serialized
8
Reflection
•
Mechanism by which a program can
analyze its objects & their capabilities at
runtime
•
Java API includes several
reflection
classes
, described on next slide
9
Reflection Classes
•
Class: describes a type
•
Package: describes a package
•
Field: describes field; allows inspection,
modification of all fields
•
Method: describes method, allows its invocation
on objects
•
Constructor: describes constructor, allows its
invocation
•
Array: has static methods to analyze arrays
10
Class class object
•
Includes class name and superclass of an
object, as we have already seen; also
includes:
–
interface types class implements
–
package of class
–
names & types of all fields
–
names, parameter types, return types of all
methods
–
parameter types of all constructors
11
Class class methods
•
getSuperClass() returns Class object that
describes superclass of a given type; returns
null is type is Object or is not a class
•
getInterfaces() returns array of Class objects
describing interface types implemented or
extended; if type doesn’t implement or
extend any interfaces, returns array of
length 0 (only returns direct superinterfaces)
12
Class class methods
•
getPackage() returns Package object;
Package has getName() method which
returns String containing package name
•
getDeclaredFields() returns array of Field
objects declared by this class or interface
–
includes public, private, protected & package
-
visible fields
–
includes both static & instance fields
–
does not include superclass fields
13
Field class methods
•
getName(): returns String containing field name
•
getType(): returns Class describing field type
•
getModifiers(): returns an int whose various bits
are set to indicate whether field is public, private,
protected, static, or final: use static Modifier
methods isPublic, isPrivate, isProtected, isStatic,
isFinal to test this value
14
Example
-
prints all static fields
of java.lang.Math
Field[] fields = math.class.getDeclaredFields();
for (int x = 0; x < fields.length; x++)
if(Modifier.isStatic(fields[x].getModifiers()))
System.out.println(fields[x].getName());
15
More Class class methods
•
getDeclaredConstructors() returns array of
Constructor objects describing class
constructors
•
Constructor object has method
getParameterTypes that returns an array of
Class objects describing the constructor’s
parameters
16
Example: printing Rectangle
constructor information
Constructor cons = Rectangle.class.getDeclaredConstructors();
for (int=0; x < cons.length; x++)
{
Class [] params = cons[x].getParameterTypes();
System.out.println(“Rectangle(”);
for (int y=0; y < params.length; y++)
{
if(y > 0) System.out.print(“, ”);
System.out.print(params[y].getName());
}
System.out.println(“)”);
}
17
Output from example
Rectangle()
Rectangle(java.awt.Rectangle)
Rectangle(int, int, int, int)
Rectangle(int, int)
Rectangle(java.awt.Point, java.awt.Dimension)
Rectangle(java.awt.Point)
Rectangle(java.awt.Dimension)
18
Class class’s
getDeclaredMethods() method
•
Returns array of Method objects
•
Method object methods include:
–
getParameterTypes(): returns array of
parameter types
–
getName(): returns method name
–
getReturnType(): returns Class object
describing return value type
19
Obtaining single Method or
Constructor objects
•
Class’s getDeclaredMethod() (note the singular) returns
a Method object if supplied with a method name and
array of parameter objects:
Method m = Rectangle.class.getDeclaredMethod(“contains”, new
Class[]{int.class, int.class});
•
For Constructor object:
Constructor c = Rectangle.class.getDeclaredConstructor(new
Class[] {});
20
Method methods
•
invoke(): can be used to call a method
described by a Method object
-
need to:
–
supply implicit parameter (null for static
methods)
–
supply array of explicit parameter values (need
to wrap primitive types)
–
if method returns a value, invoke returns an
Object; need to cast or unwrap return value, as
appropriate
21
Example
-
saying hello the hard way
import java.lang.reflect.*;
import java.io.*;
public class SayHello
{
public static void main(String[]args) throws
NoSuchMethodException, IllegalAccessException,
InvocationTargetException
{
Method m = PrintStream.class.getDeclaredMethod
(“println”, new Class[] {String.class});
m.invoke(System.out, new Object[] {“Hello!});
}
}
22
Example with return value
Method m = Math.class.getDeclaredMethod(“sqrt”, new
Class[] {double.class});
Object r = m.invoke(null, new Object[] {new
Double(10.24)});
double x = ((Double) r).doubleValue();
23
Inspecting objects
•
Can use reflection mechanism to
dynamically look up object fields as
program runs
•
To allow access to a field, call its
setAccessible() method; example:
Class c = object.getClass();
Field f = c.getDeclaredField(name);
f.setAccessible(true);
24
Inspecting objects
•
Once granted access, you can read and write any
field of the object:
Object value = f.get(object);
f.set(object, value);
•
Notes:
–
f must be a Field that describes a field of object;
otherwise, get and set throw exception
–
if field type is primitive, get returns & set expects a
wrapper
–
if field is static, supply null for object
25
Inspecting array elements
•
Field allows read/write access to arbitrary
field of object; Array works similarly on
array objects
–
for array a with index x:
–
get() method: Object value = Array.get(a,x)
–
set() method: Array.set(a,x,value);
26
Inspecting array elements
•
Finding length of array a:
int n = Array.getLength(a);
•
Creating new array (twice as large) with
static method newInstance():
Object newArray = Array.newInstance(
a.getClass().getComponentType(),
2 * Array.getLength(a) + 1);
System.arraycopy(a, 0, newArray, 0, Array.getLength(a));
a = newArray;
Enter the password to open this PDF file:
File name:
-
File size:
-
Title:
-
Author:
-
Subject:
-
Keywords:
-
Creation Date:
-
Modification Date:
-
Creator:
-
PDF Producer:
-
PDF Version:
-
Page Count:
-
Preparing document for printing…
0%
Comments 0
Log in to post a comment