Anda di halaman 1dari 39

PEMROGRAMAN LANJUT

Sistem Informasi PTIIK UB


Semester Genap 2014/2015

KONSEP OOP
DIAGRAM UML

Dr. Eng. Herman Tolle


Program Teknologi Informasi & Ilmu Komputer, Universitas Brawijaya
Materi Pemrograman Lanjut

1. Review Pemrograman Dasar


2. Konsep OOP,
3. Class dan object,
4. UML Class Diagram
5. Fungsi overloading dan konstruktor,
6. Enkapsulasi,
7. Inheritance/pewarisan,
8. Polymorphism Pemrograman
Berorientasi Objek
Relasi Antar Kelas

Suatu class dapat dibangun dari ataupun


memiliki keterkaitan dengan kelas yang lain
Secara umum relasi antar class adalah:
Depedensi (uses-a); (relasi menggunakan)
Agregasi (has-a); (relasi mempunyai )
Inheritance (is-a); (relasi adalah)
Relasi antar Kelas
1. Asosiasi
Multiplicity
Directed Assosiation
Reflexive Association
2. Aggregasi
Komposisi
3. Inheritance / Generalisasi
4. Realization
Association

Association A---->B
Composition A-----<filled>B
Aggregation A-----<>B
Aggregation
In transportation systems Car has many Passenger,
relationship between them is Aggregation.

public class Car


{
private Person[] Penumpang;
}

public class Person


{
private String name;
}
Composition
Composition : Since Engine is part-of Car, relationship
between them is Composition.

public class Car


{
private final Engine engine;
public Car()
{
engine = new Engine();
}
}

class Engine
{ private String type; }
Composition vs Aggregation
Jika suatu objek adalah bagian dari (part-of) objek lain,
misalnya Engine is part of Car, maka asosiasi atau relationship
diantara keduanya disebut Composition (Komposisi).
Jika suatu objek memiliki objek lain maka ini disebut
Aggregation (Agregasi).
Aggregation (many-to-one relationships)
Whole Part ( Composition)
Containership
Collection
Group
Composition
Komposisi adalah bentuk khusus dari Agregasi (disebut juga death
relationship). Child Object (Objek yang digunakan dalam objek
induknya) tidak memiliki lifecycle. Jika objek induknya dihapus maka
objek anaknya juga akan terhapus.
Misalnya:
House -----<filled> Rooms
House can contain multiple rooms there is no independent life of
room and any room can not belong to two different houses. If we
delete the house - room will automatically be deleted.
Questions -----<filled> options. Single questions can have multiple
options and option can not belong to multiple questions. If we delete
questions options will automatically be deleted.
Relasi

Relasi 1 to 1 (one to one): satu objek A hanya


memiliki pasangan 1 objek B
Relasi 1 to N atau 1.. * (one to many) : satu objek
A bisa memiliki minimal 1 atau banyak objek B
Relasi 0 to N atau 0..* (zero to many): satu objek A
bisa memiliki banyak objek B atau tidak ada sama
sekali
Relasi M to M atau N.. N (many to many): objek A
dan objek B bisa muncul lebih dari 1x
Aggregation Hierarchy

"weak has-A" - where there is more of a peer-to-peer


relationship between abstractions (association)
ex: Instructor has students, Students have instructor

Community School Classroom


Schools Faculty Tables
Businesses Students Chairs
Residents Administrators Students
Classrooms Instructor
Inheritance Hierarchy

an "is-A" relationship
Inheritance
for type - a re-use of common interface
for class - a re-use of common interface and
implementation

Person Student
Name Name
Attendence
Current
Grade
Class Diagram
Visibility
Attributes normally should be private, methods invoked by clients
should be public
Visibility markers in UML
A plus sign (+) indicates public visibility
A minus sign (-) indicates private visibility
A sharp sign (#) indicates protected visibility

Navigability
Navigability arrows indicate in which direction an association can
be traversed
Bidirectional navigability
Associations with navigability arrows at both ends or no navigability
arrows at all can be traversed in either direction

15
Contoh Class Diagram
Comparison of
Functional vs. OO Views
Register Submit
Student Grade
Student
Students Grades Score
Register( ) Name
Students Submit Score( ) 0..* Value
Print Transcript( )
Student/Grades

Print
Transcript
Addition of a New Student Type
Student
Register Score
Submit Name
Student Register( )
Grade Submit Score( ) 0..* Value
Print Transcript( )
Students/
Pass Fail Students Grades/PF

Students Impact
Student/Grades/PF Areas
PassFail Student
Print
Transcript Print Transcript( ) function override

Changes in data types cause significant impact to


functional approaches
OO approaches allow new object types to re-define
functionality
Addition of New Report Type

Register Submit Student


Score
Student Grade Register( ) Name
Submit Score( ) Value
Print Transcript( ) 0..*
Students Grades Impact Print Report Card(

Areas
Students
Student/Grades/PF
Student/Grades/PF
PassFail Student
Print Print
Print Transcript( )
Transcript Report Print Report Card(
Card

Changes in functionality based on stable data causes


significant impact across objects
Functional approaches allow new functions to augment
functionality
Re-organization of OO
Abstractions
Transcript Transcript
0..1 Student
Score 0..1
Print( ) Print( ) Student
Name Score
Register( )
Submit 0..* Value Register( )
Name
Score( ) 0..* Value
Submit Score( )
Determine Grade( )

Transcript
0..1
Print( ) Student
Score PassFail Student
Name
Register( )
0..* Value Determine Grade( )
Submit Score( )
Report Card Determine Grade( )
0..1
Print( )

PassFail Student

Determine Grade( )

Data dependent behavior handled by derived classes


New functionality handled by new associated classes
("wrappers", "adapters", "views")
Diagram UML

The Unified Modeling Language (UML) is a


general-purpose modeling language in the field of
software engineering.
Provides a set of graphic notation techniques to
create visual models of object-oriented software-
intensive systems.
Developed by Grady Booch, Ivar Jacobson and
James Rumbaugh at Rational Software in the 1990s
SYSTEM MODELS (in UML notation)

Functional Model use case diagrams (synthesized from


scenarios from phenomena and concepts)
Object Model class diagrams (representing object
structures as objects, attributes, associations, and
operations)
Dynamic Model sequence diagrams, statechart diagrams
and activity diagrams (describe the internal behavior or
finite state machine of the system). SD are inter-object
messaging and interactions, while SC-diagrams depict the
finite state machine description of an objects behavior
Case Study: ATM System

Fig. 8.24 | Class diagram with visibility markers.


24
Fig. 8.25 | Class diagram with navigability arrows.

25
Starting to Program the Classes of the ATM System

Implementing the ATM system from its UML design


(for each class)
Declare a public class with the name in the first
compartment and an empty no-argument constructor
Declare instance variables based on attributes in the
second compartment
Declare references to other objects based on associations
described in the class diagram
Declare the shells of the methods based on the operations
in the third compartment
Use the return type void if no return type has been specified

26
Fig. 8.24 | Class diagram with visibility markers.

27
1 // Class Withdrawal represents an ATM withdrawal transaction 28
2
3
public class Withdrawal
{
Class for Outline
4 // no-argument constructor
Withdrawal
5 public Withdrawal()
Empty no-argument withdrawal.ja
6 {
7 } // end no-argument Withdrawal constructor
constructor
va
8 } // end class Withdrawal
Fig. 8.24 | Class diagram with visibility markers.

29
1 // Class Withdrawal represents an ATM withdrawal transaction 30
2
3
public class Withdrawal
{
Outline
4 // attributes
5 private int accountNumber; // account to withdraw funds from

6 private double amount; // amount to withdraw withdrawal.ja
7 va
8 // no-argument constructor
9 public Withdrawal() Declare instance
10 { variables
11 } // end no-argument Withdrawal constructor
12 } // end class Withdrawal
Fig. 8.25 | Class diagram with navigability arrows.

31
1 // Class Withdrawal represents an ATM withdrawal transaction 32
2
3
public class Withdrawal
{
Outline
4 // attributes
5 private int accountNumber; // account to withdraw funds from
6 private double amount; // amount to withdraw
withdrawal.ja
7
8 // references to associated objects
va
9 private Screen screen; // ATMs screen
10 private Keypad keypad; // ATMs keypad
11 private CashDispenser cashDispenser; // ATMs cash dispenser
12 private BankDatabase bankDatabase; // account info database
13
14 // no-argument constructor
15 public Withdrawal()
16 {
17 } // end no-argument Withdrawal constructor Declare references to other
18 } // end class Withdrawal
objects
Fig. 8.24 | Class diagram with visibility markers.

33
1 // Class Withdrawal represents an ATM withdrawal transaction 34
2
3
public class Withdrawal
{
Outline
4 // attributes
5 private int accountNumber; // account to withdraw funds from
6 private double amount; // amount to withdraw
7
withdrawal.ja
8 // references to associated objects va
9 private Screen screen; // ATMs screen
10 private Keypad keypad; // ATMs keypad
11 private CashDispenser cashDispenser; // ATMs cash dispenser
12 private BankDatabase bankDatabase; // account info database
13
14 // no-argument constructor
15 public Withdrawal()
16 {
17 } // end no-argument Withdrawal constructor
18
19 // operations
20 public void execute()
21 {
22 } // end method execute
23 } // end class Withdrawal Declare shell of a method with
return type void
Studi Kasus: Sistem Penggajian Pegawai

date
Employee -day: int;
-fullName: string; - month: int;
- birthDate: date; - year int;
-hireDate: date; + date(d,m,y);
-salary: Salary; + setDate(d, m, y);
-numberOfEmployee: int static
+employee(name, birth)
+getName(): string
+getBirthdate(); Salary
- gajiPokok
+ hitungGaji()
Tugas 3

Studi Kasus: Pegawai & Gaji Harian


Pengembangan dari tugas sebelumnya, dengan
menambahkan atribut baru (birthday , hiredate,
salary)
Rule baru:
1. Jika masa kerja > 3 bulan maka Gaji Pokok lebih besar z%
atau x rupiah
2. Jika umur > y tahun maka dapat Tunjangan Lain-lain
sebesar w rupiah
Laporan

Soal (Kasus, Rules, Konstanta)


Diagram Class beserta relasinya
Buat implementasi class
Buat program implementasi class (min 3
pegawai)
Screenshot

Deadline: 21 April 2014, Dikirim ke email dosen.


Dicetak dan dikumpulkan tgl 22 April 2014
Modular Programming
Memisahkan data dengan proses
Contoh:
menggunakan konstanta
final static int gajiPokok = 5000;
final static int minKerja = 3;
final static double gajiNaik = 0.2;
Rules:
If (lamaKerja > minKerja) gajiPokokPegawai =
gajiPokok * (1 + gajiNaik);

Beri Nilai