GENERIC CLASS AND

SERIALIZATION
TF4235- Pemrograman Berorientasi Obyek
Informatics Department – Petra Christian University
 GENERIC CLASS
• Generic Class adalah konsep yang mengijinkan suatu class atau interface memiliki
tipe parameter dengan berbagai macam tipe data.
• Class Generic ini diterapkan sejak java versi 5.
• Class Generic dapat didefinisikan pada sebuah class, interface ataupun method,
• Programmer dapat mengaplikasikannya dengan menggunakan re-use code.
 WHY USING GENERIC?
• Pengecekan lebih baik jika dilakukan pada saat compile time.
• Mengeliminasi proses casting.
• Memungkinkan Programmers untuk meng-implementasikan generic
algorithms.
 GENERIC CLASS : SYNTAX
• Menggunakan kurung < dan > dan menggunakan 1 karakter capital biasanya menggunakan
huruf T (=type)

class ClassName <T> {

T variable;

void method(){

}
}
 GENERIC METHOD : SYNTAX
• Menggunakan kurung < dan > dan menggunakan 1 karakter capital biasanya
menggunakan huruf T (=type)

class ClassName {

public <T> void methodName(T[] elements) {

}
}
 GENERIC CLASS: EXAMPLE
KelasGeneric.java
class KelasGeneric<T> {

//T Adalah Kepanjangan dari Tipe Parameter

private T Manusia;

//Method Void Set Dengan Tipe Parameter T

protected void setManusia(T Manusia){
this.Manusia = Manusia;
}

//Method Return Get Yang Mengembalikan Nilai Manusia

protected T getManusia(){
return Manusia;
}
}
 GENERIC CLASS: EXAMPLE
Latihan.java
public class Latihan {
public static void main(String[] args){
//Membuat Instance dan Mendefinisikan Tipe Data String
KelasGeneric<String> nama = new KelasGeneric<>();
nama.setManusia("Soraya");
System.out.println("Nama: "+nama.getManusia());

//Membuat Instance dan Mendefinisikan Tipe Data Integer

KelasGeneric<Integer> umur = new KelasGeneric<>();
umur.setManusia(17);
System.out.println("Usia: "+umur.getManusia()+" Tahun");

//Membuat Instance dan Mendefinisikan Tipe Data Boolean

KelasGeneric<Boolean> kondisi = new KelasGeneric<>();
kondisi.setManusia(true);
System.out.println("Saya Sedang Belajar Java: "+kondisi.getManusia());
 GENERIC CLASS: EXAMPLE

//Membuat Instance dan Mendefinisikan Tipe Data Float

KelasGeneric<Float> IPK = new KelasGeneric<>();
IPK.setManusia(3.7f);
System.out.println("Nilai IPK: "+IPK.getManusia());

//Membuat Instance dan Mendefinisikan Tipe Data Character

KelasGeneric<Character> Karakter = new KelasGeneric<>();
Karakter.setManusia('S');
System.out.println("Inisial Nama: "+Karakter.getManusia());
}
}
 GENERIC CLASS: EXAMPLE

Hasil:
 GENERIC CLASS <MULTIPLE>:
EXAMPLE
Test.java
class Test<T, U>
{
T obj1; // An object of type T
U obj2; // An object of type U

Test(T obj1, U obj2) { // constructor

this.obj1 = obj1;
this.obj2 = obj2;
}

public void print() { // To print objects of T and U

System.out.println(obj1);
System.out.println(obj2);
}
}
 GENERIC CLASS <MULTIPLE>:
EXAMPLE
Main.java
// Driver class to test above
class Main
{
public static void main (String[] args) {
Test <String, Integer> obj = new Test<String, Integer>("Hello Guys", 15);
obj.print();
}
}
Hasil:
 GENERIC METHOD: EXAMPLE

TestM.java
// A Simple Java program to show working of user defined
// Generic functions

class TestM
{
// A Generic method example
static <T> void genericDisplay (T element)
{
System.out.println(element.getClass().getName() +
" = " + element);
}
 GENERIC METHOD: EXAMPLE

// Demo method
public static void main(String[] args)
{
// Calling generic method with Integer argument
genericDisplay(11);

// Calling generic method with String argument

genericDisplay(“Selamat Datang");
Hasil:

// Calling generic method with double argument

genericDisplay(1.0);
}
}
 SERIALIZATION &
DESERIALIZATION
• Serialization adalah suatu proses mengubah objek menjadi byte stream, agar bisa
disimpan dalam file, memori ataupun berguna dalam proses transmisi jaringan.
• Deserialization adalah kebalikan dari proses Serialization.
• Dalam proses serialization dan deserialization di Java, ada dua kelas yang sangat
berperan penting yaitu :
• kelas ObjectOutputStream.
• kelas ObjectInputStream.
• Selain itu, kelas yang mau di-serialization kan harus mengimplement interface
java.io.Serializable.
 WHY DO WE NEED SERIALIZATION
Serialization dibutuhkan karena:
• Communication: memungkinkan multiple computer systems mendesain, share and
execute objects secara simultaneously.
• Caching: Serialization meminimizes time consumption dengan cara caching objects
yang besar.
• Deep Copy: sebuah exact replica dari sebuah object bisa didapatkan dengan cara
serializing suatu object menjadi sebuah byte array, dan nanti dapat di de-serializing
kembali.
 WHY DO WE NEED SERIALIZATION
• Cross JVM Synchronization: Keuntungan utama adalah bahwa Serialization dapat
bekerja pada JVM yang berbeda yang mungkin berjalan pada architectures atau
Operating Systems yang berbeda.
• Persistence: Semua State dari object apapun dapat secara langsung disimpan dengan
menaplikasikan Serialization dan disimpan dalam suatu database yang kemudian
dapat di retrieved kemudian saat dibutuhkan.
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE
Demo.java
import java.io.*;

class Demo implements java.io.Serializable

{
public int a;
public String b;

// Default constructor
public Demo(int a, String b)
{
this.a = a;
this.b = b;
}
}
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE
Testing.java
import java.io.*;

class Testing
{
public static void main(String[] args)
{
Demo object = new Demo(1, "Hallo Guys");
String filename = "file.ser";

// Serialization
try
{
//Saving of object in a file
FileOutputStream file = new FileOutputStream(filename);
ObjectOutputStream out = new ObjectOutputStream(file);
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE

// Method for serialization of object

out.writeObject(object);

out.close();
file.close();

System.out.println("Object has been serialized");

}

catch(IOException ex)
{
System.out.println("IOException is caught");
}
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE
Demo object1 = null;

// Deserialization
try
{
// Reading the object from a file
FileInputStream file = new FileInputStream(filename);
ObjectInputStream in = new ObjectInputStream(file);

// Method for deserialization of object

object1 = (Demo)in.readObject();

in.close();
file.close();
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE
System.out.println("Object has been deserialized ");
System.out.println("a = " + object1.a);
System.out.println("b = " + object1.b);
}

catch(IOException ex)
{
System.out.println("IOException is caught");
}

catch(ClassNotFoundException ex)
{
System.out.println("ClassNotFoundException is caught");
}

}
}
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE
Hasil:
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE
Bytecode File:
 SERIALIZATION AND DESERIALIZATION:
EXAMPLE
Bytecode File:
 COPY CONSTRUCTOR
• Suatu copy constructor dalam sebuah Java class adalah sebuah constructor yang
men-create sebuah object menggunakan object lain yang ada dalam Java class yang
sama.
• Hal ini sangat membantu jika ingin membuat copy dari object yang sangat complex,
atau kalau ingin membuat deep copy dari object yang sudah ada.
 COPY CONSTRUCTOR: EXAMPLE
Complex.java
class Complex {
// Overriding the toString of Object class
private double re, im; @Override
public String toString() {
// A normal parametrized constructor return "(" + re + " + " + im + "i)";
public Complex(double re, double im) { }
this.re = re; }
this.im = im;
}

// copy constructor
Complex(Complex c) {
System.out.println("Copy constructor called");
re = c.re;
im = c.im;
}
 COPY CONSTRUCTOR: EXAMPLE
Main.java
public class Main {

public static void main(String[] args) {

Complex c1 = new Complex(10, 15);

// Following involves a copy constructor call

Complex c2 = new Complex(c1);

// Note that following doesn't involve a copy constructor call as

// non-primitive variables are just references.
Complex c3 = c2;

System.out.println(c2); // toString() of c2 is called here

}
}
 COPY CONSTRUCTOR: EXAMPLE

Bytecode File:
 CLONE OF CONSTRUCTOR
• Object cloning adalah salah satu cara untuk meng-create exact copy dari sebuah
object.
• Method clone() dari class Object digunakan untuk meng-clone atau mengcopy
sebuah object.
• Interface java.lang.Cloneable harus diimplementasikan oleh class yang object
clone nya akan dicreate.
• Jika tidak meng-implementasikan Cloneable interface, method clone() akan men-
generate CloneNotSupportedException.
 CLONE CONSTRUCTOR : SYNTAX
• Method clone() didefinisikan dalam Object class.
• Syntax dari method clone() adalah sebagai berikut:

protected Object clone() throws CloneNotSupportedException {

}
 CLONE CONSTRUCTOR : EXAMPLE
Student18.java
class Student18 implements Cloneable{
int rollno;
String name;

Student18(int rollno,String name){

this.rollno=rollno;
this.name=name;
}

public Object clone()throws CloneNotSupportedException{

return super.clone();
}
 CLONE CONSTRUCTOR : EXAMPLE
public static void main(String args[]){
try{
Student18 s1=new Student18(3021,"Gunawan");

Student18 s2=(Student18)s1.clone();

System.out.println(s1.rollno+" "+s1.name);
System.out.println(s2.rollno+" "+s2.name);

}catch(CloneNotSupportedException c){} Hasil:

}
}
 ADVANTAGE OF OBJECT CLONING

• Penggunaan Object.clone() kurang popular dibandingkan dengan penggunakan

copy constructor karena mempunyai masalah desain (Design Issue)
• Walau tidak popular namun tetap mempunyai beberapa keuntungan:
 Tidak perlu menulis code yang panjang dan berulang (repetitive code).
Hanya membuat abstract class sepanjang 4-5 baris saja
 Adalah cara yang termudah dan efisien untuk melakukan peng-copy-an, terutama jika kita
mengaplikasikannya pada project lama yang sudah di develop. Hanya mendefinisikan parent
class dan implement Cloneable didalamnya, dan mendefinisikan isi method clone() saja.
• Clone() merupakan cara tercepat untuk men-copy array.
 DISADVANTAGE OF OBJECT
CLONING
• Untuk menggunakan method Object.clone(), kita harus mengubah banyak syntax dalam
code kita, seperti implementasi interface cloneable, mendefinisikan method clone() dan
melakukan handling pada CloneNotSupportedException, dan akhirnya memanggil method
Object.clone().
• Kita harus meng implementasikan interface Cloneable yang kosong (tidak ada method
didalamnya), Kita hanya menggunakannya untuk memberitahu JVM agar kita dapat
melakukan (perform) clone() dalam object kita.
• Object.clone() adalah protected, jadi kita harus menyediakan method clone() kita sendiri
serta secara indirect memanggil Object.clone() dari nya.
 DISADVANTAGE OF OBJECT
CLONING
• Object.clone() tidak meng-invoke constructor manapun juga, sehingga kita tidak
mempunyai control apapun terhadap object construction.
• Jika kita akan menuliskan sebuah method clone dalam child class maka semua superclass-
nya harus mendefinisikan method clone() didalamnya atau meng-inherit-kannya dari parent
class yang lain. Jika tidak rangkaian super.clone() akan gagal.
• Object.clone() hanya men-support shallow copying namun kita harus me-override nya jika
kita membutuhkan deep cloning.
 JAVA ENUMS
• Enum adalah singkatan dari kata "enumerations", yang artinya "specifically listed".
• Enum adalah sebuah special "class" yang me-representasikan suatu group of
constants (unchangeable variables, seperti final variables).
• Untuk membuat sebuah enum class, gunakan keyword enum dan pisahkan setiap
constants menggunakan tanda comma.
• Enums umum dipakai dalam switch statements untuk check nilai yang bersesuaian
(corresponding values)
public class MainEnum {
enum Level { MainEnum.java
LOW,
MEDIUM,
HIGH ENUM: EXAMPLE
}
public static void main(String[] args) {
Level myVar = Level.MEDIUM;
System.out.println(myVar);

switch(myVar) {
case LOW:
System.out.println("Low level");
break;
case MEDIUM:
System.out.println("Medium level");
break;
Hasil:
case HIGH:
System.out.println("High level");
break;
}
}
}
 LOOP THROUGH AN ENUM
• Enum type punya method values(), yang akan mengembalikan suatu “array of all enum
constants”.
• Method ini sangat berguna jika kita membutuhkan suatu loop untuk mengakses seluruh
anggota dari enum.
for (Level myVar : Level.values()) {
System.out.println(myVar);
}
 DIFFERENCE BETWEEN ENUMS
AND CLASSES
• Enum dapat, seperti sebuah class, memiliki attributes dan methods. Bedanya
hanyalah pada enum constants bersifat public, static dan final (unchangeable -
cannot be overridden).
• Enum tidak dapat digunakan untuk create objects, dan tidak dapat me-extend class
yang lain (namun dapat me-implement interfaces).

Why And When To Use Enums?

• Gunakan enums jika ingin menggunakan suatu angka yang tiodak berubah angkanya
(konstan), seperti bulan hari, warna, deck of cards, dsb.
 REFERENSI
• https://www.geeksforgeeks.org/
• https://www.baeldung.com/
• https://docs.oracle.com/javase/tutorial/java/
• https://www.tutorialspoint.com/java/
• https://www.wildantechnoart.net/2017/11/belajar-menggunakan-generic-class-pada-
java.html
• http://nursalim-zone.blogspot.com/2014/11/bagaimana-cara-serialisasi-dan.html
• https://www.okedroid.com/2017/10/belajar-mengenal-serialization-pada-program-java.html
• https://www.w3schools.com/java/java_enums.asp