Chapter 1 Introduction to Java

4 downloads 155953 Views 2MB Size Report
... Cleveland State University – Prof. Victor Matos. Adapted from: Introduction to Java Programming: Comprehensive Version, Eighth Edition by Y. Daniel Liang ...

Chapter 15 Abstract Classes and Interfaces

CIS265/506 Cleveland State University – Prof. Victor Matos

Adapted from: Introduction to Java Programming: Comprehensive Version, Eighth Edition by Y. Daniel Liang


More specialized

More general

Abstract Classes and Abstract Methods

2 2

This example was introduced in Chapter 11.

Abstract Classes and Abstract Methods

Aside - Useful links: An UML Tutorial /RationalEdge/sep04/bell/ Google’s Draw-io: A free-ware UML drawing tool

3 3

Example1:Superclasses and Subclasses public abstract class GeometricObject {




private String color = "white"; private boolean filled; private java.util.Date dateCreated;

// Return TRUE is object is filled public boolean isFilled() { return filled; }

// Construct a default geometric object protected GeometricObject() { dateCreated = new java.util.Date(); }

// Set filled to either: true/false public void setFilled(boolean filled) { this.filled = filled; }

// createa obj with color and filled value protected GeometricObject(String color, boolean filled) { dateCreated = new java.util.Date(); this.color = color; this.filled = filled; }

// Get dateCreated public java.util.Date getDateCreated() { return dateCreated; } // Return a string representing this object public String toString() { return "created on " + dateCreated + "\ncolor: " + color + " and filled: " + filled; }

// Return color public String getColor() { return color; } // Set a new color public void setColor(String color) { this.color = color; }

// Abstract method getArea public abstract double getArea(); // Abstract method getPerimeter public abstract double getPerimeter(); }




Example1: Superclasses and Subclasses public class Circle4 extends GeometricObject { private double radius = 1;

/** Return diameter */ public double getDiameter() { return 2 * radius; }


2 3


public Circle4() { } public Circle4(double radius) { super(); this.radius = radius; } public Circle4(double radius, String color, boolean filled) { super(color, filled); this.radius = radius; //setColor(color); //setFilled(filled); }

/** Return perimeter */ public double getPerimeter() { return 2 * radius * Math.PI; } /* Print the circle info */ public void printCircle() { System.out.println(toString() + " Circle created on: " + getDateCreated() + " and the radius is " + radius); }

/** Return radius */ public double getRadius() { return radius; } /** Set a new radius */ public void setRadius(double radius) { this.radius = radius; }


/** Return area */ public double getArea() { return radius * radius * Math.PI; }


public String toString() { return ">>> Circle " + getColor() + "\n" + super.toString() + "\n>>> Radius: " + getRadius() + " Perimeter: " + getPerimeter() + " Area: " + getArea(); } }


Example1: Superclasses and Subclasses 1 public class Rectangle extends GeometricObject { private double width; private double height;




/** Return height */ public double getHeight() { return height; }

public Rectangle() { }

/** Set a new height */ public void setHeight(double height) { this.height = height; }

public Rectangle(double width, double height) { super(); this.width = width; this.height = height; }

/** Return area */ public double getArea() { return width * height; }

public Rectangle( double width, double height, String color, boolean filled) { super(color, filled); this.width = width; this.height = height; // setColor(color); // setFilled(filled); }

/** Return perimeter */ public double getPerimeter() { return 2 * (width + height); } public String toString() { return "\n>>> Rectangle " + getColor() + "\n" + super.toString() + "\n>>> Height: " + getHeight() + " Width: " + getWidth() + " Perimeter: " + getPerimeter() + " Area: " + getArea();

// Return width public double getWidth() { return width; } // Set a new width public void setWidth(double width) { this.width = width; } 6


} }


Abstract Classes and Abstract Methods •

An abstract class, like any other Java class, consists of class variables, constructors, mutators, and user-defined (concrete and abstract) methods.

Unlike concrete classes they cannot be instantiated .

Abstract classes are good for: • specifying virtual methods via signatures, those methods must be implemented by descendents of the abstract class. • Providing some concrete although very general methods and variables for subclasses to use

Example: public abstract double computeTaxes(int ssn, int w2Nbr) ; One of my subclasses must compute taxes using SSN andW2 form. If returned value is positive then “you owe”, a negative value means “a refund”

7 7

abstract method in abstract class Some regulations:

8 8

An abstract method cannot be contained in a non-abstract class (concrete classes must have concrete methods).

If a subclass of an abstract superclass does not implement all the abstract methods, the subclass must be defined abstract.

In other words, in a non-abstract subclass extended from an abstract class, all the abstract methods must be implemented, even if they are not used in the subclass.

object cannot be created from abstract class More rules:

9 9

An abstract class cannot be instantiated using the new operator.

However you can still define its constructors, which are invoked in the constructors of its subclasses.

For instance, the constructors of GeometricObject are invoked in the Circle class and the Rectangle class.

superclass of abstract class may be concrete A subclass can be abstract even if its superclass is concrete. Example: The Object class is concrete, but its subclasses, such as GeometricObject, may be abstract.

10 10

abstract class as type Although you cannot create an instance from an abstract class, an abstract class can be used as a data type. The following fragment is correct:

Concrete subclass

GeometricObject g1 = new Circle(2, "RED", true); System.out.println( g1.toString() ); System.out.println( g1.getClass() ); System.out.println( g1 instanceof GeometricObject );


11 11

>>> Circle RED created on Fri Feb 03 17:11:00 EST 2012 color: RED and filled: true >>> Radius: 2.0 Perimeter: 12.566370614359172 Area: 12.566370614359172 csu.matos.Circle true

Example: The Abstract Calendar and the Date class  

An instance of java.util.Date represents a ‘concrete’ specific instant in time with millisecond precision. java.util.Calendar is an abstract base class for extracting detailed information such as year, month, date, hour, minute and second from a Date object. Subclasses of Calendar can implement specific calendar systems such as    

12 12

Gregorian calendar, Lunar Calendar, Jewish calendar, and Chinese calendar.

Currently, java.util.GregorianCalendar for the Gregorian calendar is supported in the Java API.

Example: The Abstract Calendar and the Date class Java.util.Date

Aside-1 Date Class

13 13

Dates are represented as a signed long that counts the number of milliseconds since midnight, January 1, 1970, GMT Time.


Recommended approach is to use a java.text.DateFormat object to obtain a meaningful string out of a date

has many deprecated methods to manipulate date/time

Example: The Abstract Calendar and the Date class Java.text.DateFormat

Aside-2 DateFormat Class Date now = new Date(); DateFormat df = DateFormat.getDateInstance(); String s = df.format(now); System.out.println("Today is " + s); DateFormat DateFormat DateFormat DateFormat String String String String String

s0 s1 s2 s3 s4

df1 df2 df3 df4

= = = = =

= = = =

DateFormat.getDateInstance(DateFormat.SHORT); DateFormat.getDateInstance(DateFormat.MEDIUM); DateFormat.getDateInstance(DateFormat.LONG); DateFormat.getDateInstance(DateFormat.FULL);

df.format(now); df1.format(now); df2.format(now); df3.format(now); df4.format(now);

System.out.println("(Default) System.out.println("(SHORT) System.out.println("(MEDIUM) System.out.println("(LONG) System.out.println("(FULL)

Today Today Today Today Today

is is is is is

" " " " "

+ + + + +

s0); s1); s2); s3); s4);

// old deprecated style, bad-habit int hour = now.getHours(); int min = now.getMinutes(); int sec = now.getSeconds(); System.out.println ( hour + ":" + min + ":" + sec );

14 14

Today is Feb 16, 2012 (Default) Today is Feb 16, 2012 (SHORT) Today is 2/16/12 (MEDIUM) Today is Feb 16, 2012 (LONG) Today is February 16, 2012 (FULL) Today is Thursday, February 16, 2012 15:43:50

Example: The Abstract Calendar Class and Its GregorianCalendar subclass Aside 3- A note from Wikipedia

Lunar calendars differ as to which day is the first day of the month. For some lunar calendars, such as the Chinese calendar, the first day of a month is the day when an astronomical new moon occurs in a particular time zone. For others, such as some Hindu calendars, each month begins on the day after the full moon or the new moon. Others were based in the past on the first sighting of a lunar crescent, such as the lunisolar Hebrew calendar (19-years cycle).

15 15

Pope Gregory XIII ordered in 1582 adoption of a new calendar to replace the Julian calendar (in use since 45BC).The average length of a year under the Julian system was 365days and 6 hours.This was about11 minutes longer than the correct value (365d 5h 49m 12s). In 13 centuries this error grew up to be ten days.The Pope decreed on 24 February 1582, that the day after Thursday, 4 October 1582 would be not Friday, 5 October, but Friday, 15 October 1582.

Hindu Calendar

Maya Apocalypse Calendar

Gregory XIII 1582

Example: The Abstract Calendar Class and Its GregorianCalendar subclass No. Name

Aside 4- A note from Wikipedia

 The Gregorian solar calendar counts days as the basic unit of time.Years

have 365 or 366 days; and repeats completely every 400 years.  Of these 400 years, 303 common years have 365 days and 97 leap years

have 366 days.  A calendar mean year has exactly 365+ 97/400 days = 365.2425 days

= 365 days, 5 hours, 49 minutes and 12 seconds.  Month length is L = 30 + { [ M + floor(M/8) ] MOD 2 }, where L is the

month length in days and M is the month number 1 to 12.  The expression is valid for all 12 months, but for M = 2 (February)

adjust by subtracting 2 and then if it is a leap year add 1.

16 16


1 January


2 February

28 or 29

3 March


4 April


5 May


6 June


7 July


8 August


9 September


10 October


11 November


12 December


Example: The Abstract Calendar Class and Its GregorianCalendar subclass


Example: The GregorianCalendar Class 

You can use new GregorianCalendar() to construct a default GregorianCalendar with the current time. Calendar calendar = new GregorianCalendar();

Use new GregorianCalendar(year, month, date) to construct a GregorianCalendar with the specified year, month, and date. Calendar calendar = new GregorianCalendar(2525, 0, 31); Date d = cal.getTime(); System.out.println ( d ); // Mon Jan 01 00:00:00 EST 2525

18 18

The month values are 0-based, days are not  0 is for January, 11 for December.  1 for Sunday, 7 for Saturday

Example: Fields contained in the Calendar class Constant



The year of the calendar.


The month of the calendar with 0 for January.


The day of the calendar (1-31).


The hour of the calendar (12-hour notation).


The hour of the calendar (24-hour notation).


The minute of the calendar.


The second of the calendar.


The day number within the week with 1 for Sunday.


Same as DATE.


The day number in the year with 1 for the first day of the year.


The week number within the month.


The week number within the year.


Indicator for AM or PM (0 for AM and 1 for PM).


Calendar calendar = new GregorianCalendar(); int minute = int year =

calendar.get(Calendar.MINUTE); calendar.get(Calendar.YEAR);

int hourOfDay = calendar.get(Calendar.HOUR_OF_DAY); 19

Example: Getting Date/Time Information from Calendar import java.util.*; public class TestCalendar { public static void main(String[] args) { // Calendar calendar1 = new Calendar() // ERROR!!! Calendar is abstract // Construct a Gregorian calendar for the current date and time Calendar calendar = new GregorianCalendar(); System.out.println("Current time is " + new Date()); System.out.println("YEAR:\t" + calendar.get(Calendar.YEAR)); System.out.println("MONTH:\t" + calendar.get(Calendar.MONTH)); System.out.println("DATE:\t" + calendar.get(Calendar.DATE)); System.out.println("HOUR:\t" + calendar.get(Calendar.HOUR)); System.out.println("HOUR_OF_DAY:\t" + calendar.get(Calendar.HOUR_OF_DAY)); System.out.println("MINUTE:\t" + calendar.get(Calendar.MINUTE)); System.out.println("SECOND:\t" + calendar.get(Calendar.SECOND)); System.out.println("DAY_OF_WEEK:\t" + calendar.get(Calendar.DAY_OF_WEEK)); System.out.println("DAY_OF_MONTH:\t" + calendar.get(Calendar.DAY_OF_MONTH)); System.out.println("DAY_OF_YEAR: " + calendar.get(Calendar.DAY_OF_YEAR)); System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.DAY_OF_YEAR)); 20 20

Example: Getting Date/Time Information from Calendar System.out.println("WEEK_OF_MONTH: " + calendar.get(Calendar.WEEK_OF_MONTH)); System.out.println("WEEK_OF_YEAR: " + calendar.get(Calendar.WEEK_OF_YEAR)); System.out.println("AM_PM: " + calendar.get(Calendar.AM_PM));

// Construct a calendar for September 11, 2001 Calendar calendar2 = new GregorianCalendar(2001, 8, 11); System.out.println("September 11, 2001 is a " + dayNameOfWeek(calendar2.get(Calendar.DAY_OF_WEEK))); } public static String dayNameOfWeek(int dayOfWeek) {

else else else else else else else } } 21 21

if(dayOfWeek if(dayOfWeek if(dayOfWeek if(dayOfWeek if(dayOfWeek if(dayOfWeek if(dayOfWeek return null;

== == == == == == ==

1) 2) 3) 4) 5) 6) 7)

return return return return return return return

"Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday";

Example: Getting Date/Time Information from Calendar Console Current time is Fri Feb 03 20:18:09 EST 2012 YEAR:


























September 11, 2001 is a Tuesday

22 22

What is an interface? Why is an interface useful?    

23 23

An interface is a special Java class that contains only constants and abstract methods. Like abstract classes, they cannot be instantiated using new. The intent of an interface is to specify behavior for objects. For example, you can indicate that the objects are:  Comparable  Cloneable  Serializable  Fulfilling any other user-define forms of behavior

UML Representation of Classes and Interfaces   

24 24

Java classes use single inheritance. An interface is depicted with a relatively similar UML notation. A Match-Making app may want Client to extend person and implement the interface: LoveCompatible as well as Comparable A banking app may want its Client class to extend Person implement Comparable and ignore the LoveCompatible interface.

Define an Interface To distinguish an interface from a class, Java uses the following syntax to define an interface: public interface InterfaceName { constant declarations; method signatures; }

Example: public interface Edible { /** Describe how to eat */ public abstract String howToEat(); } 25 25

Example: Using Interfaces  

The Edible interface specifies whether an object is edible and if so, it recommends the best way to eat the object. This behavior is accomplished by letting the class for the object implement the Edible interface using the implements keyword. In the example, the classes Chicken and Fruit implement the Edible interface, however DeadlySpider does not.

public interface Edible { /** Describe best way to eat it */ public abstract String howToEat(); }

26 26

Example: Using Interfaces public class TestEdible { public static void main(String[] args) { Object[] objects = {new DeadlySpyder(), new Chicken(), new Apple()}; for (int i = 0; i < objects.length; i++) if (objects[i] instanceof Edible) System.out.println(((Edible)objects[i]).howToEat()); } } class Animal { // Data fields, constructors, and methods omitted here } class Chicken extends Animal implements Edible { public String howToEat() { return "Chicken: Fry it"; } } class DeadlySpider extends Animal { } abstract class Fruit implements Edible { // Data fields, constructors, and methods omitted here } class Apple extends Fruit { public String howToEat() { return "Apple: Make apple cider"; } }

27 27

class Orange extends Fruit { public String howToEat() { return "Orange: Make orange juice"; } }

Omitting Modifiers in Interfaces In an interface 

All data fields are public final static and

all methods are public abstract.

For this reason, these modifiers can be omitted, as shown below: public interface T1 { public static final int K = 1; public abstract void p(); }


public interface T1 { int K = 1; void p(); }

A constant defined in an interface can be accessed using syntax InterfaceName.CONSTANT_NAME (e.g., T1.k ). 28 28

Example: The Comparable Interface • •

Assume you need to compare two Circle objects. You could use a Java fragment such as: if ( circle1.getArea() == circle2.getArea() ){ // do something here... }

However to compare two Client objects you may say if ( client1.getId() == client2.getId() ){ // do something here... }

29 29

Previous ideas are OK, but perhaps a more general way of comparing objects is needed. For example if ( circle1.compareTo(circle2) == 0 ){ // do something here... }


The Comparable Interface When you try to contrast two arbitrary objects, they should be comparable. The Java interface supporting object comparisons is defined as follows: // interface for comparing objects defined in the java.lang package

package java.lang; public interface Comparable { public int compareTo(Object o); }

Example: int

result 30 30

result = firstObject.compareTo(secondObject);

0 if firstObject == secondObject > 0 if firstObject > secondObject < 0 if firstObject < secondObject

Why the Comparable Interface ? The fundamental goal of the Comparable interface is to decide how to arrange two objects from an arbitrary class according to an intuitive notion of a ‘natural ordering’, sequencing, or arrangement of those kind of elements. For instance, consider the following sets of objects Integers: Strings: Dates: Rectangles: 31 31

-n < … otherRectangle.getArea() ) return 1; else return -1; } @Override

3 37 37


// Override the protected clone method defined in the Object class

public Object clone() throws CloneNotSupportedException { return super.clone(); }

Example: The Cloneable Interface public static void main(String[] args) throws

CloneNotSupportedException {

Rectangle r1 = new Rectangle(10, 20, "blue", true); Rectangle r2 = (Rectangle) r1.clone(); System.out.println(" r1==r2 is " + (r1 == r2)); ⟵ prints false System.out.println(" r1.equals(r2) is " + r1.equals(r2)); ⟵ prints false System.out.println(" r1.compareTo(r2) is " + r1.compareTo(r2)); ⟵ prints 0 }

 Rectangles r1 and r2 are two different objects with identical contents.  The clone method in the Object class copies each field from the original object

to the target object.  If the field is of a primitive type, its value is copied. For example, the value

of area ( double type) is copied from r1 to r2.  If the field is of an object, the reference of the field is copied. For example,

the field dateCreated is of the Date class, so its reference is copied into r2.  This process is referred to as a shallow copy rather than a deep copy, meaning


that if the field is of an object type, the object’s reference is copied rather than its contents.

Example: Overriding the Equals method public class Rectangle

extends GeometricObject implements Cloneable, Comparable {

// variables, constructors, and other methods omitted for editing ...

@Override public boolean equals(Object obj) { Rectangle other = (Rectangle) obj; if (

this.getColor().equals(other.getColor() ) && this.getDateCreated().equals(other.getDateCreated() ) && this.getHeight() == other.getHeight() && this.getWidth() == other.getWidth() ) return true; else return false; } }

 You may override the Equals method of the Rectangle class to return true

each time the contents of the two compared objects are the same.  After this change is made the test code in previous page produces: 39

r1==r2 is false r1.equals(r2) is true r1.compareTo(r2) is 0

Interfaces vs. Abstract Classes 

In an interface, the data must be constants; an abstract class can have all types of data.

Each method in an interface has only a signature without implementation; an abstract class can have concrete methods. Variables

Constructors •

Abstract class

No restrictions

All variables • • Interface must be public static final 40 40


Constructors are invoked by subclasses through constructor chaining. An abstract class cannot be instantiated using the new operator.

No restrictions.

No constructors. An interface cannot be instantiated using the new operator.

All methods must be public abstract instance methods

Whether to use an interface or a class? 

In general, a strong is-a relationship that clearly describes a parent-child relationship should be modeled using classes. 

A weak is-a relationship, also known as a ‘is-kind-of’ relationship, indicates that an object possesses certain property. A weak is-a relationship can be modeled using interfaces. 

41 41

For example, a Staff Member is a Person. So their relationship should be modeled using class inheritance.

For example, all strings are comparable, so the String class implements the Comparable interface.

You can also use interfaces to circumvent single inheritance restriction if multiple inheritance is desired.

Becoming a Better IT Professional ACM Code of Ethics and Professional Behavior* Rule 2.1 Strive to achieve the highest quality, effectiveness and dignity in both the process and products of professional work. Excellence is perhaps the most important obligation of a professional.The computing professional must strive to achieve quality and to be cognizant of the serious negative consequences that may result from poor quality in a system. Translating the rule to our context Whenever you write a Java class try to make your ‘best effort’; each professionally crafted Java class is expected to implement the following interfaces: Comparable, Comparator, Cloneable, Serializable 42 42

* For a complete list of rules of conduct see:

Wrapper Classes 1. Primitive data types (int, long, float,…) are not used as objects in Java (objects add extra processing overhead). 2. However, many Java methods require the use of objects (not primitive types) as arguments. For example, the add( object) method in the ArrayList . 3. Java offers a convenient way to wrap a primitive data type into an object ( e. g., wrapping int into the Integer class, and wrapping double into the Double class). 4. The corresponding class is called a wrapper class. 5. Java provides Boolean, Character, Double, Float, Byte, Short, Integer, and Long wrapper classes for primitive data types. 43 43

Wrapper Classes 1. The wrapper classes do not have zero-argument constructors. 2. The instances of all wrapper classes are immutable, i.e., their internal values cannot be changed once the objects are created.

44 44

Wrappers: The toString, equals, and hashCode Methods 

Each wrapper class overrides the   

toString, equals, and hashCode

methods defined in the Object class.

45 45

With the exception of Boolean all the wrapper classes implement the Comparable interface.

Therefore the compareTo method is implemented in the wrapper classes (all but Boolean).

The Number Class 1. Each numeric wrapper class extends the abstract Number

class, which contains the methods doubleValue,








2. These methods “convert” objects into primitive type values.

3. Subclasses of Number support other methods such as

46 46





Example: Using Class-Wrapper Methods Integer n1 = new Integer(111); Integer n2 = new Integer("111"); Integer n3 = 111; Integer n4 = Integer.MAX_VALUE; Integer n5 = Integer.MIN_VALUE; Integer n6 = Integer.SIZE; Integer n7 = Integer.decode("1234");

Integer n8 = Integer.parseInt("1234"); Integer n9 = Integer.valueOf("1234"); String s1 = String.valueOf(1234);

47 47

Example: Largest Rectangle in a List Objective: Various rectangles are placed in a list. Find the location of the largest . Assume the class Rectangle implements Comparable 1

public static void main(String[] args) { Rectangle rectangle; ArrayList list.add( list.add( list.add( list.add( list.add(

list = new ArrayList(); new Rectangle(10,20) ); new Rectangle(10,21) ); new Rectangle(11,15) ); new Rectangle(12,21) ); new Rectangle(15,10) );

for (int i=0; i>> Rectangle white created on Sat Feb 04 22:19:21 EST 2012 color: white and filled: false >>> Height: 20.0 Width: 10.0 Perimeter: Loc: 1 >>> Rectangle white created on Sat Feb 04 22:19:21 EST 2012 color: white and filled: false >>> Height: 21.0 Width: 10.0 Perimeter: Loc: 2 >>> Rectangle white created on Sat Feb 04 22:19:21 EST 2012 color: white and filled: false >>> Height: 15.0 Width: 11.0 Perimeter: Loc: 3 >>> Rectangle white created on Sat Feb 04 22:19:21 EST 2012 color: white and filled: false >>> Height: 21.0 Width: 12.0 Perimeter: Loc: 4 >>> Rectangle white created on Sat Feb 04 22:19:21 EST 2012 color: white and filled: false >>> Height: 10.0 Width: 15.0 Perimeter:

60.0 Area: 200.0

62.0 Area: 210.0

52.0 Area: 165.0

66.0 Area: 252.0

50.0 Area: 150.0

Solution 3 >>> Rectangle white created on Sat Feb 04 22:19:21 EST 2012 color: white and filled: false >>> Height: 21.0 Width: 12.0 Perimeter: 66.0 Area: 252.0

BigInteger and BigDecimal 

If you need to compute with very large integers or high precision floating-point values, you can use the  BigInteger and 

  

51 51


An instance of BigInteger can represent an integer of any size. The largest integer of the long type is Long. MAX_ VALUE ( i. e., 9223372036854775807). Both are part of the java.math package, they extend the Number class and implement the Comparable interface.

Case Study: The Rational Class ( your turn ! ) java.lang.Number +byteValue(): byte +shortValue(): short +intValue(): int +longVlaue(): long +floatValue(): float +doubleValue():double

java.lang.Comparable compareTo(Object): int

Rational -numerator: long -denominator: long +Rational() +Rational(numerator: long, denominator: long) +getNumerator(): long +getDenominator(): long +add(secondRational: Rational): Rational +multiply(secondRational: Rational): Rational +subtract(secondRational: Rational): Rational +divide(secondRational: Rational): Rational +toString(): String -gcd(n: long, d: long): long 1

52 52


Add, Subtract, Multiply, Divide

JSON Encoding JSON Encoding

53 53

JSON stands for JavaScript Object Notation. This is a text-based “human-readable” and “open-format” standard intended for the representation of structured data. JSON’s original purpose is to act as a language-independent data interchange vehicle.

Objects are written in JSON as a curly-braced ({ }) delimited string. The various properties inside the object are recursively annotated as a comma separated set of ‘key:value’ pairs.

Array elements are enclosed in square brackets ([ ]) and separated by commas.

JSON is language and platform independent and it is available for a large number of programming environments [Jackson, Gson, Jayrock-Ref-Microsoft].

JSON Encoding Why JSON ? Positive features: (1) transparency – the developer can see objects as plain text, (2) it can be used on cross-platform applications involving a variety of operating systems and programming languages, (3) It is relatively easy to use and understand, (4) No need to posses original source code to add Serializable annotation support, (5) The technology is already well understood, diffused, and supported .

54 54

CAUTION is needed when JSON is used as a data-interchange vehicle over the data network, because as any plain-text message, there are some risks of eavesdropping.

JSON Encoding 1. Encoding Simple Data Types // Create an instance of a Gson-JSON encoder Gson gson = new Gson(); // must import* API // PART1. serialize primitive data elements (strings, numbers) String jsonString = gson.toJson("Game of Thrones"); String javaValue1 = gson.fromJson(jsonString, String.class); System.out.println(javaValue1); // prints “Game of thrones” // PART2. deserialize primitive data elements String jsonString2 = gson.toJson(4321); Integer javaValue2 = gson.fromJson(jsonString2, Integer.class); System.out.println(jsonString2); // prints 4321

55 55

Download API (Jar) from:


JSON Encoding 2. Encoding Simple Objects // PART1. Serialize a single Person object Gson gson = new Gson(); Person person0 = new Person("Daenerys Targaryen", 18); jsonString = gson.toJson(person0); System.out.println("Json string: " +

jsonString );

// PART2. Deserialize a single Person object Person personDecoded = gson.fromJson(jsonString, Person.class); System.out.println("Java object: " +

personDecoded );

The previous fragment produces the following output: Json string: {"name":"Daenerys Targaryen","age":18} 56 56

Java object: Person(name=Daenerys Targaryen, age=18)

JSON Encoding 3. Encoding a List of Objects // PART1. create a (Generic) list of Person objects ArrayList lstPerson = new ArrayList(); lstPerson.add(new Person("Daenerys Targaryen", 17)); lstPerson.add(new Person("Tiryion Lannister", 30)); lstPerson.add(new Person("Arya Stark", 11)); // convert Java collection to JSON string String jsonList = gson.toJson(lstPerson); System.out.println("Json list: " + jsonList ); // PART2. use Java reflection to find the list's type Type arrPersonType = new TypeToken(){}.getType(); ArrayList lst2 = gson.fromJson(jsonList, arrPersonType); System.out.println("Java list:" + lst2 );

The list of Person objects is encoded as follows: Json list:

57 57

[ {"name":"Daenerys Targaryen","age":18}, {"name":"Tiryion Lannister","age":30}, {"name":"Arya Stark","age":11} ]

JSON Encoding 3. Encoding a List of Objects Json list

• • • •

58 58


[ {"name":"Daenerys Targaryen","age":18}, {"name":"Tiryion Lannister","age":30}, {"name":"Arya Stark","age":11} ]

A JSON array is delimited by square-braces ([ ]). Each element in the array is a Person object including the attributes “name” and “age”. Objects are enclosed inside curly-braces({ }) and separated by commas. The Gson TypeToken class is used to extract the collection’s generic type information

JSON Encoding 4. Encoding a Subclass Assume the PersonHouse class is an extension of the Person class. It contains the additional house attribute. Consider the following example: // PART1. Encode subclass PersonHouse person4 = new PersonHouse("Jon Snow", 23, "Stark"); String jsonPerHome = gson.toJson(person4); System.out.println("Json subclass: " + jsonPerHome); // PART2. Decode string PersonHouse person4again = gson.fromJson(jsonPerHome, PersonHouse.class); System.out.println("Java subclass: " + person4again);

The output produced by this fragment is

59 59

Json subclass: {"House":"Stark","name":"Jon Snow","age":23} Java subclass: PersonHouse( House=Stark Person(name=Jon Snow, age=23) )

JSON Encoding 5. Encoding a 1:Many Relationship Assume the existence of a House class including the properties: houseName and characters (represented as a dynamic list of Person objects). ArrayList theStarks.add(new theStarks.add(new theStarks.add(new

theStarks = new ArrayList(); Person("Catelyn Stark", 40)); Person("Sansa Stark", 14)); Person("Bran Stark", 9));

//PART1. Encoding complex 1:m class House starkHouse = new House("Stark", "Winterfell", theStarks); String jsonHouse = gson.toJson(starkHouse); System.out.println("\nJson House: " + jsonHouse); //PART2. Decoding complex 1:m class House javaHouse = gson.fromJson(jsonHouse, House.class); System.out.println("Java House: " + javaHouse);

The output produced by this example is: Json House: 60 60

{"houseName":"Stark","location":"Winterfell", "personLst":[{"name":"Catelyn Stark","age":40}, {"name":"Sansa Stark","age":14}, {"name":"Bran Stark","age":9}]}

JSON Encoding Alternative Decoding based on traversing the JSON data structure looking for jsonElements (which could be: jsonObject, jsonArray, or jsonPrimitive tokens) private static void jsonHouseNodeParsing(String jsonHouseStr) { String result = ""; try { JsonElement jelement = new JsonParser().parse(jsonHouseStr); JsonObject jobject = jelement.getAsJsonObject(); String jHouseName = jobject.get("houseName").toString(); String jLocation = jobject.get("location").toString(); // JsonPrimitive jLocation = jobject.getAsJsonPrimitive("location"); System.out.println(jHouseName + "\n" + jLocation); JsonArray jarray = jobject.getAsJsonArray("personLst");

61 61

for (int i = 0; i < jarray.size(); i++) { jobject = jarray.get(i).getAsJsonObject(); result = jobject.get("name").toString() + " " + jobject.get("age").toString(); System.out.println(" " + result); } } catch (Exception e) { System.out.println(e.getMessage()); } }// jsonNodeParsing

JSON Encoding Alternative Decoding Approach


Example using alternative decoding

JSON encoded string {"houseName":"Stark", "location":"Winterfell", "personLst":[ {"name":"Catelyn Stark","age":40}, {"name":"Sansa Stark","age":14}, {"name":"Bran Stark","age":9} ] }

62 62

Decoded Nodes "Stark" "Winterfell" "Catelyn Stark" 40 "Sansa Stark" 14 "Bran Stark" 9