tugas besar client server "membuat game domino"

coding :

package game;

import game.exceptions.InvalidFaceValueException;
import game.exceptions.InvalidNumberOfPlayersException;
import game.exceptions.InvalidPieceToPlayException;
import game.exceptions.NotPlayersTurnException;

import java.rmi.NotBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.ArrayList;
import java.util.List;

import server.Server;
import client.Client;
import client.ClientRemote;
import game.Board;
import game.Domino;

public class Game {
        public static final int NUMBER_OF_MESSAGES_PER_GAME = 3;
     
        public static final int NUMBER_OF_PLAYERS = 4; // numero de jogadores total por jogo. deve ser um múltiplo de 2
        private static final int CURR_PLAYER_UNDEFINED = -1;
     
        private List<Domino> dominoes;
        private List<Player> players; // jogadores do jogo
        private Board board; // mesa do jogo (situação atual das peças jogadas
        private int currentPlayer = CURR_PLAYER_UNDEFINED; // jogador atual
        private Domino firstPiece = null;

        private Server server;
             
        // Players can be added to the game all in one time by the Game object constructor
        public Game(List<Player> players, Server server) throws InvalidNumberOfPlayersException {
                this.server = server;
             
                if (players == null || players.size() != NUMBER_OF_PLAYERS) {
                        throw new InvalidNumberOfPlayersException();
                }
             
                List<Player> tempPlayers = new ArrayList<Player>();
                for (Player p: players) {
                        p.setCurrentGame(this);
                        tempPlayers.add(p);
                }
             
                // sorteando a ordem dos jogadores, o jogador de indice 0 será parceiro do jogador de indice 2, e o 1 do 3
                this.players = new ArrayList<Player>();
                for (int i = 0; i < NUMBER_OF_PLAYERS; i++) {
                        this.players.add(tempPlayers.remove((int) (Math.random() * (NUMBER_OF_PLAYERS - i))));
                }
             
                this.board = new Board();
        }
     
        public void startGame() throws RemoteException {              
                // Creating game pieces
                createDominoPieces();
             
                System.out.println("Existem " + players.size() + " Jogadores no jogo sendo iniciado.");
                             
                // ramdom dominoes to decide players pieces
                for (int i = 0; i < NUMBER_OF_PLAYERS; i++) {
                        List<Domino> pieces = new ArrayList<Domino>();
                     
                        for (int j = 0; j < 6; j++) {
                                int index = (int) (Math.random() * (28 - (i * 6 + j)));
                                pieces.add(dominoes.remove(index));                          
                        }
                        players.get(i).setPieces(pieces);
                }

                // decidindo quem sera o primeiro jogador (encontrar o dozão ou outra carroça)
                currentPlayer = CURR_PLAYER_UNDEFINED;
                int firstPiece = 6;
                this.firstPiece = null;
                do {
                        for (Player p: players) {
                                for (Domino d: p.getPieces()) {
                                        if (d.getFace1() == firstPiece && d.getFace2() == firstPiece) {
                                                currentPlayer = players.indexOf(p);
                                                this.firstPiece = d;
                                                break;
                                        }
                                }
                                if (currentPlayer != CURR_PLAYER_UNDEFINED) break; // já foi  encontrado o jogador que ira iniciar
                        }
                        firstPiece--; // procurar por uma carroça de menor valor
                } while (currentPlayer == CURR_PLAYER_UNDEFINED && firstPiece >= 0);
                if (currentPlayer == CURR_PLAYER_UNDEFINED) currentPlayer = 0;
             
                waitForPlayersToBeReady();
             
                // enviar uma mensagem a cada jogador, indicando que um jogo está sendo iniciado
                for (Player p: players) {
                        p.getStub().receiveMessage("Game", "O jogo está sendo iniciado.");
                }
             
                // setando os parceiros dos jogadores, e chamando o método remoto em cada jogador para iniciar o jogo
                List<String> playersNames = new ArrayList<String>();
                for (int i = 0; i < players.size(); i++) {
                        playersNames.add(players.get((currentPlayer + i) % NUMBER_OF_PLAYERS).getUserName());
                }
                if (NUMBER_OF_PLAYERS % 2 == 0) {
                        for (int i = 0; i < NUMBER_OF_PLAYERS / 2; i++) {
                                Player p = players.get(i);
                                p.setPartner(players.get(i + NUMBER_OF_PLAYERS / 2).getUserName());
                                p.getStub().startGame(playersNames, p.getPieces());
                             
                                p = players.get(i + NUMBER_OF_PLAYERS / 2);
                                p.setPartner(players.get(i).getUserName());
                                p.getStub().startGame(playersNames, p.getPieces());
                        }    
                }
             
                refreshPlayersTurns();
        }
     
        private void createDominoPieces() {
                dominoes = new ArrayList<Domino>();
                for (int i = 0; i <= 6; i++) {
                        for (int j = i; j <= 6; j++) {
                                try {
                                        dominoes.add(new Domino(i, j));
                                } catch (InvalidFaceValueException e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }
     
        private void waitForPlayersToBeReady() throws RemoteException {
                for (Player p: players) {
                        String service = Client.SERVICE_NAME_PREFIX + p.getUserName();                
                        Registry registry = LocateRegistry.getRegistry();
                     
                        ClientRemote stub = null;
                        int i = 0;
                        do {
                                try {
                                        stub = (ClientRemote) registry.lookup(service);
                                        System.out.println("O Servico remoto do jogador " + p.getUserName() + " esta pronto.");
                                } catch (NotBoundException e) {
                                        System.out.println("O Jogador " + p.getUserName() + " ainda não inicializou o serviço remoto");
                                        try {
                                                Thread.sleep(500);
                                                i++;
                                        } catch (InterruptedException e1) {
                                                e1.printStackTrace();
                                        }
                                }    
                        } while (stub == null || i >= 20);
                     
                        if (i >= 20) removePlayer(p);
                     
                        p.setStub(stub);
                }
        }
     
        public void makeMove(Player p, Domino d, int position) throws NotPlayersTurnException, InvalidPieceToPlayException {
                if (players.get(currentPlayer).equals(p)) {
                        if (d != null) {
                                if (board.isAValidPieceToPlay(d, position)) {
                                        board.addPiece(d, position);
                                        players.get(currentPlayer).getPieces().remove(d);
                                        currentPlayer = (currentPlayer + 1) % NUMBER_OF_PLAYERS;
                                } else {
                                        throw new InvalidPieceToPlayException();
                                }
                        } else {
                                currentPlayer = (currentPlayer + 1) % NUMBER_OF_PLAYERS;
                        }
                             
                        for (Player player: players) {
                                if (!player.equals(p)) {
                                        try {
                                                player.getStub().moveMade(d, position);
                                        } catch (RemoteException e) {
                                                removePlayer(player);
                                                return;
                                        }
                                }
                        }
                     
                        // TODO verificar se o jogo terminou
                        if (p.getPieces().size() == 0) {
                                // o jogador bateu: finalizar o jogo
                                playerWon(p);
                                return;
                        } else {
                                boolean finalized = true;
                                for (Player pTemp: players) {
                                        for (Domino dTemp: pTemp.getPieces()) {
                                                if (board.isAValidPieceToPlay(dTemp, Board.POSITION_START) || board.isAValidPieceToPlay(dTemp, Board.POSITION_END)) {
                                                        finalized = false;
                                                        break;
                                                }
                                        }
                                        if (!finalized) break;
                                }
                                if (finalized) {
                                        countPiecesPoints();
                                        return;
                                }
                        }
                     
                        // iniciando em uma nova Thread para poder retornar sem ficar bloqueado
                        new Thread() {
                                public void run() {
                                        refreshPlayersTurns();                                        
                                }
                        }.start();
                     
                } else {
                        throw new NotPlayersTurnException();
                }
        }
     
        private void refreshPlayersTurns() {
                // chamando o método para que os jogadores iniciem as jogadas
                PlayerThread t = null;
                for (int i = 0; i < NUMBER_OF_PLAYERS; i++) {
                        if (i == currentPlayer) {
                                // iniciando uma nova thread, para que a atual (do jogo) não fique bloqueada
                                t = new PlayerThread(players.get(i)) {                                
                                        public void run() {
                                                try {
                                                        p.getStub().myTimeToPlay();
                                                } catch (RemoteException e) {
                                                        remoteExceptionThrowed = true;
                                                }    
                                        }
                                };
                                t.start();
                        } else {
                                try {
                                        players.get(i).getStub().waitAnotherPlayersMove();
                                } catch (RemoteException e) {
                                        removePlayer(players.get(i));
                                        return;
                                }
                        }
                }
             
                if (t != null) {
                        if (t.isRemoteExceptionThrowed()) {
                                removePlayer(players.get(currentPlayer));
                                return;
                        } else {
                                while (t.getState() != Thread.State.TERMINATED) {
                                        try {
                                                Thread.sleep(300);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
                }
        }
     
        // retorno o numero de caracteres máximo de uma mensagem, dada a quantidade de mensagens ainda disponíveis
        public static int getNumberOfCharsByAvailableMessages(int availableMessages) {
                int maximumNumberOfChars = 10;
             
                if (availableMessages <= NUMBER_OF_MESSAGES_PER_GAME && availableMessages >= 0) {
                        return maximumNumberOfChars - (NUMBER_OF_MESSAGES_PER_GAME - availableMessages) * 2;
                }
             
                return 0;
        }

        public boolean isAValidPieceToPlay(Domino d) {
                // verificando se a peça está com o jogador da vez
                for (Domino pd: players.get(currentPlayer).getPieces()) {
                        if (pd.equals(d)) {
                                // verificando se a peça pode ser jogada
                                if (board.getDominoes() == null || board.getDominoes().size() == 0) {
                                        if (firstPiece == null) {
                                                return true;
                                        } else {
                                                return firstPiece.equals(d);
                                        }
                                } else {
                                        boolean valid = board.isAValidPieceToPlay(d, Board.POSITION_START) || board.isAValidPieceToPlay(d, Board.POSITION_END);
                                        if (valid) return true;
                                        else return false;
                                }
                        }
                }
             
                return false;
        }

        public void removePlayer(final Player playerToRemove) {
                // os outros jogadores devem ser liberados para jogar
                for (Player player: players) {
                        if (playerToRemove != player) {
                                try {
                                        player.setCurrentGame(null);
                                     
                                        player.getStub().receiveMessage("Servidor", "O Jogador " + playerToRemove.getUserName() + " saiu do jogo. O jogo está sendo finalizado.");
                                        player.getStub().receiveMessage("Servidor", "Outro Jogo será iniciado assim que possível");
                                     
                                        PlayerThread pt = new PlayerThread(player) {
                                                public void run() {
                                                        try {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_PLAYER_LOGGED_OUT, "O Jogador " + playerToRemove.getUserName() + " saiu do jogo.\nO jogo está sendo finalizado.");
                                                                server.freePlayer(p);
                                                        } catch (RemoteException e) {
                                                                remoteExceptionThrowed = true;
                                                                Game.this.server.removePlayer(p);
                                                        }            
                                                }
                                        };
                                        pt.start();
                                } catch (RemoteException e) {
                                        this.server.removePlayer(playerToRemove);
                                }
                        }
                }
        }
     
        private void playerWon(final Player winner) {
                for (Player player: players) {
                        try {
                                player.setCurrentGame(null);
                             
                                if (player != winner) {
                                        player.getStub().receiveMessage("Servidor", "O Jogador " + player.getUserName() + " Bateu! Um Novo Jogo Será iniciado.");    
                                } else {
                                        player.getStub().receiveMessage("Servidor", "Você Venceu o Jogo!!! Um Novo Jogo Será iniciado.");
                                }
                             
                             
                                PlayerThread pt = new PlayerThread(player) {
                                        public void run() {
                                                try {
                                                        if (p != winner) {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_PLAYER_WON, "O Jogador " + winner.getUserName() + " Bateu!\nUm novo jogo será iniciado assim que possível.");  
                                                        } else {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_PLAYER_WON, "Você Venceu o Jogo!!!\nUm novo jogo será iniciado assim que possível.");
                                                        }                                                    
                                                        server.freePlayer(p);
                                                } catch (RemoteException e) {
                                                        remoteExceptionThrowed = true;
                                                        Game.this.server.removePlayer(p);
                                                }            
                                        }
                                };
                                pt.start();
                        } catch (RemoteException e) {
                                this.server.removePlayer(player);
                        }
                }
        }
     
     
        private void countPiecesPoints() {
                int less = -1;
                final List<Player> winners = new ArrayList<Player>();
             
                // contagem dos pontos
                for (Player p: players) {
                        if (less == -1 || p.getPoints() < less) {
                                winners.clear();
                                winners.add(p);
                                less = p.getPoints();
                        } else if (p.getPoints() == less) {
                                winners.add(p);
                        }
                }
             
                String w = "";
                for (Player p: winners) {
                        w += p.getUserName();
                        if (winners.indexOf(p) < winners.size() - 2) {
                                w += ", ";
                        } else if (winners.indexOf(p) == winners.size() - 2) {
                                w += " e ";
                        }
                }
             
                final String s = w;
             
                for (Player player: players) {
                        try {
                                player.setCurrentGame(null);
                             
                                if (winners.size() == 1) {
                                        if (!winners.contains(player)) {
                                                player.getStub().receiveMessage("Servidor", "O Jogador " + winners.get(0).getUserName() + " Venceu nos pontos! Um Novo Jogo Será iniciado.");
                                        } else {
                                                player.getStub().receiveMessage("Servidor", "Você Venceu o Jogo nos Pontos!!! Um Novo Jogo Será iniciado.");
                                        }
                                } else {
                                     
                                        player.getStub().receiveMessage("Servidor", "Empate entre os jogadores " + w + "! Um Novo Jogo Será iniciado.");      
                                     
                                }
                             
                                PlayerThread pt = new PlayerThread(player) {
                                        public void run() {
                                                try {
                                                        if (winners.size() == 1) {
                                                                if (!winners.contains(p)) {
                                                                        this.p.getStub().endGame(Client.END_GAME_CAUSE_GAME_CLOSED, "O Jogador " + winners.get(0).getUserName() + " Venceu nos Pontos!\nUm novo jogo será iniciado assim que possível.");    
                                                                } else {
                                                                        this.p.getStub().endGame(Client.END_GAME_CAUSE_GAME_CLOSED, "Você Venceu o Jogo nos Pontos!!!\nUm novo jogo será iniciado assim que possível.");
                                                                }
                                                        } else {
                                                                this.p.getStub().endGame(Client.END_GAME_CAUSE_GAME_CLOSED, "Empate entre os jogadores " + s + "!\nUm novo jogo será iniciado assim que possível.");
                                                        }
                                                        server.freePlayer(p);
                                                } catch (RemoteException e) {
                                                        remoteExceptionThrowed = true;
                                                        Game.this.server.removePlayer(p);
                                                }            
                                        }
                                };
                                pt.start();
                        } catch (RemoteException e) {
                                this.server.removePlayer(player);
                        }
                }
        }
}

Konfigurasi Jaringan Client Server

Konfigurasi Klien Jaringan Client Server
Untuk melakukan konfigurasi jaringan pada Windows XP, beberapa langkah yang dapat kamu lakukan diantaranya adalah setting kartu jaringan, konfigurasi TCP/IP, dan pemetaan drive jaringan.

Konfigurasi Jaringan Klien Windows XP
Langkah konfigurasi komputer klien Windows P pada jaringan Client Server adalah :

•     Pastikan kartu jaringan telah terinstal driver dengan benar, klik Start, Settings, Control Panel, dobel klik System. Pilih tabulasi Hardware, kemudian klik Device Manager.
•     Setelah kartu jaringan terinstal driver dengan benar, lakukan konfigurasi alamat IP, klik Start, Control Panel dan dobel klik Network Connections, dobel klik Local Area Connections. Atau, kamu dapat juga mengklik icon Local Area Connections pada taskbar.
•     Pada kotak dialog Local Area Connections Status, klik Properties sehingga akan ditampilkan kotak dialog Local Area Connection Properties. Pilih Internet Protocol (TCP/IP), kemudian klik Properties.
•     Pilih Use the following IP address dan masukkan IP Address dan Subnet mask-nya. Selanjutnya, masukkan alamat IP Addres Server, sebagai contoh, masukkan 192.168.0.2 dengan Subnet Mask 255.255.255.0. Setelah selesai memasukkan alamat IP, klik tombol OK.
•     Lakukan pengujian koneksi dari komputer klien dengan komputer server, buka jendela Command Prompt (DOS Prompt). Ketik ping <nama komputer/IP Address>. Pastikan pesan yang ditampilkan Reply from 192.168.0.1, yang berarti komputer klien telah terhubung dengan komputer server.

Menghubungkan dengan Komputer Server
Langkah menghubungkan komputer klien Windows XP dengan komputer server adalah :

1. Klik Start, Setting, Control Panel, dobel klik System, pilih tabulasi Computer Name dan klik Change.
2. Pada kotak dialog Computer Name Change, pilih Domain di bagian Member Of. Kemudian masukkan nama domain server pada kotak isiannya. klik OK untuk mengakhiri.
3. Masukkan User Name dan Password untuk dapat bergabung dengna domain. Masukkan user Administrator atau yang setingkat dari Windows 2003 Server, beserta passwordnya. Klik OK.
4. Tunggu prosesnya beberapa saat hingga ditampilkan pesan terhubung dengan domain. Klik OK untuk menyetujuinya.
5. Sistem akan meminta boot ulang, setelah komputer melakukan boot ulang maka akan ditampilkan kotak dialog Welcome to Windows, dan tekan Ctrl+Alt+Delete secara bersamaan.
6. Setelah itu akan ditampilkan pengisian user name dan password, masukkan User name dan Password pada kotak yang telah disediakan.

KONFIGURASI DHCP SERVER DAN SETING PADA KOMPUTER CLIENT

KONFIGURASI DHCP SERVER DAN SETTING PADA KOMPUTER KLIEN

Dengan Dynamic Host Configuration Protokol (DHCP) membuat administrasi jaringan TCP/IP menjadi lebih mudah.Pada server DHCP kita tidak perlu membberikanalamt IP secara manual pada setiap nnode (workstation), karena server DHCP akan memberikan alamat ip secara dinamis pada komputerworkstation tersebut . Batas alamat IPyang diberikan untuk node (workstation ) cukup di setting dari address pool pada Mikrotik OS DHCP Server. Ada 2 jenis DHCPdalam system jaringan yaitu :

DHCP Server

DHCP yang akan memberikan alamat ip ke work station.

DHCP client

DHCP yang akan menerima alamat IP yang diberikan oleh DHCP server

Sebelum melakukan settingmikrotik os sebagai DHCP Server internet, pastikan option DHCP telah diaktifkan (dipilih)saat menginstal mikrotik OS . Untuk membuat DHCP Server diperlukan langkah – langkah sebagi berikut:

a. Mmbuat address pool dan menentukan IP Range

b. Mengaktifkan DHCPServer.

c. Setting InternetGateway Server.

Konfigurasi dengan winbox :

1. Instalasi interface

Klik menu interface –>nameàGeneral–>Apply–>OK

 

2. Setting IP address
Klik menu IPàAddressàtanda+ warna merahàApply–>OK

 

3. Konfigurasi IP gateway
Klik menu IP routeàtanda+ warna merah –>Apply–>OK

 

4.KOnfigurasi IP DNS
KlikmenuIP –>DNSàSettings–>Apply–> OK

 

5. Setting Address pool

Klik menu IPàpoolàpoolsàKlik tanda+warna merah–>Apply –>Ok

 

6. Klik menuIP–>DHCP Server–>Networksàtanda+awrna merah–>Apply–>OK

 

 

 7. Menentukan interface lan DHcp Dan mengaktifkan dhcp server
Klik menu IP–>DHCP Server–>DHCPàtanda + warna merah–>Apply–>Ok

 

8. setting IP firewall nat
Klik menu IP–>firewallàNAT–>tanda + warna merah–>Apply–>OK

 

SETTING PADA KOMPUTER CLIENT
9.Klik Start –>Control PanelàNetwork ConnectionsàLocal Area ConnectionàPropertiesàInternet Protokol(TCP/IP)àIPaddress automatically–>OK

menghubungkan komputer server dan client

   Cara menghubungkan komputer server dan client
Banyak Email masuk yang menanyakan Bagaimana cara menghubungkan komputer server dan client? selalu saya jawab lewat email. Nah daripada mesti menjawab lewat email maka jawaban tersebut saya posting disini.
Bagaimana Cara menghubungkan komputer server dan client? sebenarnya cukup mudah yaitu sebagai berikut:
untuk menggunakan software client diperlukan minimal 2 komputer yang terhubung dalam jaringan LAN

    satu komputer sebagai server (diinstal software server)
    satu atau yang lain lagi client (diinstal software client)

cara setting atau pengaturan komputer server dan komputer client

•     setting IP server dengan model statis misal 192.168.1.1
•     pada server buka C:\Program Files\NamaSoftware cari folder dbfile
•     sharing folder tersebut full
•     pada client klik icon connect database dan arahkan ke server misal \\192.168.1.1\dbfile
•     pilih file db yang nampak dan klik ok
•     client sudah terhubung

Untuk mengatur otoritas user hanya dilakukan di komputer server selanjutnya program di komputer client akan membaca sesuai pengaturan user dan password yang dimasukkan.
Tambahan untuk cara menghubungkan komputer server dan client pada windows 7 dan windows vista caranya sama tetapi ada yang khusus yaitu : software server tidak diinstal di c:\ tapi di d:\ atau lainnya asal jangan di c:\

•     setting IP server dengan model statis misal 192.168.1.1
•     pada server buka D:\NamaSoftware cari folder dbfile
•     sharing folder tersebut full
•     pada client klik icon connect database dan arahkan ke server misal \\192.168.1.1\dbfile
•     pilih file db yang nampak dan klik ok
•     client sudah terhubung

analisa perancangan berbasis objek

Analisa dan Perancangan Berbasis Objek
Object Oriented analaysis adalah metode analisis yang memeriksa requirements (syarat/keperluan yang harus dipenuhi suatu sistem) dari sudut pandang kelas-kelas dan objek-objek yang ditemui dalam ruang lingkup permasalahan.
Object Oriented Design adalah metode untuk mengarahkan arsitektur software yang didasarkan pada manipulasi objek-objek sistem atau subsistem.

Konsep Dasar OOAD (Object Oriented Analysis and Design)
OOAD mencakup analisis dan desain sebuah sistem dengan pendekatan objek, yaiut analisis berorientasi objek (OOA) dan desain berorientasi objek (OOD). OOA adalah metode analisis yang memerika requirement (syarat/keperluan) yang harus dipenuhi sebuah sistem) dari sudut pandang kelas-kelas dan objek-objek yang ditemui dalam ruang lingkup perusahaan. Sedangkan OOD adalah metode untuk mengarahkan arsitektur software yang didasarkan pada manipulasi objek-objek sistem atau subsistem.
Terdapat beberapa konsep dalam OOAD, yaitu :
- Objek (object)

    Objek adalah benda secara fisik dan konseptual yang ada di sekitar kita. Sebuah objek memiliki keadaan sesaat yang disebut state.
    State dari sebuah objek adalah kondisi dari objek atau himpunan keadaan yang menggambarkan objek tersebut. State dinyatakan dengan nilai dari atribut objeknya.
    Atribut adalah nilai internal suatu objek yang mencerminkan karakteristik objek, kondisi sesaat, koneksi dengan objek lain dan identitas.
    Behaviour (perilaku objek) mendefinisikan bagaimana sebuah objek bertindak dan memberi reaksi. Behaviour ditentukan oleh himpunan semua atau beberapa operasi yang dapat dilakukan oleh objek tersebut, yang dicerminkan oleh interface, service, dan method dari objek tersebut.
    Interface adalah pintu untuk mengakses service dari objek
    Service adalah fungsi yang dapat dikerjakan oleh sebuah objek
    Method adalah mekanisme internal objek yang mencerminkan perilaku objek tersebut

- Kelas (class)
Class adalah himpunan objek yang sejenis yaitu mempunyai sifat (atribut), perilaku umum (operasi), relasi umum dengan objek lain dan semantik umum. Class adalah abstraksi dari objek dalam dunia nyata. Class menetapkan spesifikasi perilaku dan atribut dari objek tersebut.
- Kotak Hitam (black boxes)
Sebuah objek adalah kotak hitam. Konsep ini menjadi dasar implementasi objek. Dalam operasi OO hanya developer yang dapat memahami detail proses yang ada didalam kotak tersebut, sedangkan user tidak perlu mengetahui apa yang dilakukan yang penting mereka dapat menggunakan objek untuk memproses kebutuhan mereka. Kotak hitam berisi kode dan data.

    Encapsulation, yaitu proses menyembunyikan detail implementasi sebuah objek. Untuk mengakses data objek tersebut adalah melalui interface. Untuk berkomunikasi dengan objek digunakan message.
    Message adalah permintaan agar objek menerima untuk membawa metode yang ditunjukkan oleh perilaku dan mengembalikan result dari aksi tersebut kepada objek pengirim (sender)

- Asosiasi dan Agregasi

    Asosiasi adalah hubungan yang mempunyai makna antara sejumlah objek. Asosiasi digambarkan dengan sebuah garis penghubung diantara objeknya. Contohnya : Asosiasi karyawan dengan unit kerja. Setiap karyawan bekerja di satu unit kerja, sedangkan unit kerja dapat memiliki beberapa karyawan.
    Agregasi adalah bentuk khusus sebuah asosiasi yang menggambarkan seluruh bagian pada suatu objek merupakan bagian dari objek yang lain. Contohnya : Kopling dan piston adalah bagian dari mesin, sedangkan mesin, roda, body merupakan bagian dari sebuah mobil.

Kelebihan

    Dibandingkan dengan metode SSAD, OOAD lebih mudah digunakan dalam pembangunan sistem
    Dibandingkan dengan SSAD, waktu pengembangan, level organisasi, ketangguhan,dan penggunaan kembali (reuse) kode program lebih tinggi dibandingkan dengan metode OOAD (Sommerville, 2000).
    Tidak ada pemisahan antara fase desain dan analisis, sehingga meningkatkan komunikasi antara user dan developer dari awal hingga akhir pembangunan sistem.
    Analis dan programmer tidak dibatasi dengan batasan implementasi sistem, jadi desain dapat diformliasikan yang dapat dikonfirmasi dengan berbagai lingkungan eksekusi.
    Relasi obyek dengan entitas (thing) umumnya dapat di mapping dengan baik seperti kondisi pada dunia nyata dan keterkaitan dalam sistem. Hal ini memudahkan dalam mehami desain (Sommerville, 2000).
    Memungkinkan adanya perubahan dan kepercayaan diri yang tinggi terhadap kebernaran software yang membantu untuk mengurangi resiko pada pembangunan sistem yang kompleks (Booch, 2007).
    Encapsliation data dan method, memungkinkan penggunaan kembali pada proyek lain, hal ini akan memperingan proses desain, pemrograman dan reduksi harga.
    OOAD memungkinkan adanya standarisasi obyek yang akan memudahkan memahami desain dan mengurangi resiko pelaksanaan proyek.
    Dekomposisi obyek, memungkinkan seorang analis untuk memcah masalah menjadi pecahan-pecahan masalah dan bagian-bagian yang dimanage secara terpisah. Kode program dapat dikerjakan bersama-sama. Metode ini memungkinkan pembangunan software dengan cepat, sehingga dapat segera masuk ke pasaran dan kompetitif. Sistem yang dihasilkan sangat fleksibel dan mudah dalam memelihara.

Kekurangan

    Pada awal desain OOAD, sistem mungkin akan sangat simple.
    Pada OOAD lebih fockus pada coding dibandingkan dengan SSAD.
    Pada OOAD tidak menekankan pada kinerja team seperti pada SSAD.
    Pada OOAD tidak mudah untuk mendefinisikan class dan obyek yang dibutuhkan sistem.
    Sering kali pemrogramam berorientasi obyek digunakan untuk melakukan anlisisis terhadap fungsional siste, sementara metode OOAD tidak berbasis pada fungsional sistem.
    OOAD merupakan jenis manajemen proyek yang tergolong baru, yang berbeda dengan metode analisis dengan metode terstruktur. Konsekuensinya adalah, team developer butuh waktu yang lebih lama untuk berpindah ke OOAD, karena mereka sudah menggunakan SSAD dalam waktu yang lama ( Hantos, 2005).
    Metodologi pengembangan sistem dengan OOAD menggunakan konsep reuse. Reuse merupakan salah satu keuntungan utama yang menjadi alasan digunakannya OOAD. Namun demikian, tanpa prosedur yang emplisit terhadap reuse, akan sangat sliit untuk menerapkan konsep ini pada skala besar (Hantos, 2005).


Perancangan Terstruktur (Structured Analisys and Design / SSAD)
Metode ini diperkenalkan pada tahun 1970, yang merupakan hasil turunan dari pemrograman terstruktur. Metode pengembangan dengan metode terstruktur ini terus diperbaiki sampai akhirnya dapat digunakan dalam dunia nyata.
Perancangan ini bertujuan untuk membuat model SOLUSI terhadap PROBLEM yang sudah dimodelkan secara lengkap pada tahap analisis terstruktur. Ada empat kegiatan perancangan yang harus dilakukan, yaitu:

    Perancangan arsitektural; kita merancang struktur modul P/L dengam mengacu pada model analisis yang sesuai (DFD). Langkahnya adalah: mengidentifikasi jenis aliran (transform flowatau transaction flow), menemukan batas-batas aliran (incoming flow dan outgoing flow), kemudian memetakannya menjadi striktur hirarki modul. Selanjutnya, kita alokasikan fungsi-fungsi yang harus ada pada modul-modul yang tepat.
    Perancangan data; kita merancang struktur data yang dibutuhkan, serta merancang skema basisdata dengan mengacu pada model analisis yang sesuai (ERD).
    Perancangan antarmuka; kita merancang antarmuka P/L dengan pengguna, antarmuka dengan sistem lain, dan antarmuka antar-modul.
    Perancangan prosedural; kita merancang detil dari setiap fungsi pada modul. Notasi yang digunakan bisa berupa flow chart, algoritma, dan lain-lain

Pastikan bahwa model perancangan yang dibuat sudah mengakomodasi kebutuhan non fungsional.
Berikut ini merupakan kelebihan dan kekurangan metode perancangan terstruktur :
Kelebihan

    Milestone diperlihatkan dengan jelas yang memudahkan dalam manajemen proyek
    SSAD merupakan pendekatan visual, ini membuat metode ini mudah dimengerti oleh pengguna atau programmer.
    Penggunaan analisis grafis dan tool seperti DFD menjadikan SSAD menjadikan bagus untuk digunakan.
    SSAD merupakan metode yang diketahui secara umum pada berbagai industry.
    SSAD sudah diterapkan begitu lama sehingga metode ini sudah matang dan layak untuk digunakan.
    SSAD memungkinkan untuk melakukan validasi antara berbagai kebutuhan
    SSAD relatif simpel dan mudah dimengerti.

Kekurangan

    SSAD berorientasi utama pada proses, sehingga mengabaikan kebutuhan non-fungsional.
    Sedikit sekali manajemen langsung terkait dengan SSAD
    Prinsip dasar SSAD merupakan pengembangan non-iterative (waterfall), akan tetapi kebutuhan akan berubah pada setiap proses.
    Interaksi antara analisis atau pengguna tidak komprehensif, karena sistem telah didefinisikan dari awal, sehingga tidak adaptif terhadap perubahan (kebutuhan-kebutuhan baru).
    Selain dengan menggunakan desain logic dan DFD, tidak cukup tool yang digunakan untuk mengkomunikasikan dengan pengguna, sehingga sangat sulit bagi pengguna untuk melakukan evaluasi.
    Pada SAAD sulit sekali untuk memutuskan ketika ingin menghentikan dekomposisi dan mliai membuat sistem.
    SSAD tidak selalu memenuhi kebutuhan pengguna.
    SSAD tidak dapat memenuhi kebutuhan terkait bahasa pemrograman berorientasi obyek, karena metode ini memang didesain untuk mendukung bahasa pemrograman terstruktur, tidak berorientasi pada obyek (Jadalowen, 2002).


Perbedaan Analisa Berbasis Objek dan Yang Terstruktur

    Perancangan Terstruktur : Modul merupakan unit dari kode software yang menjalankan fungsi.
    Perancangan Berorientasi Objek : Modul objek yang mengenkapsulasi atribut dan kode program untuk berjalan.

metode terstruktur

      METODE TERSTRUKTUR
Kelebihan
·         Milestone diperlihatkan dengan jelas yang memudahkan dalam manajemen proyek
·         SSAD merupakan pendekatan visual, ini membuat metode ini mudah dimengerti oleh pengguna atau programmer.
·         Penggunaan analisis grafis dan tool seperti DFD menjadikan SSAD menjadikan bagus untuk digunakan.
·         SSAD merupakan metode yang diketahui secara umum pada berbagai industry.
·         SSAD sudah diterapkan begitu lama sehingga metode ini sudah matang dan layak untuk digunakan.
·         SSAD memungkinkan untuk melakukan validasi antara berbagai kebutuhan
·         SSAD relatif simpel dan mudah dimengerti.
Kekurangan
·         SSAD berorientasi utama pada proses, sehingga mengabaikan kebutuhan non-fungsional.
·         Sedikit sekali manajemen langsung terkait dengan SSAD
·         Prinsip dasar SSAD merupakan pengembangan non-iterative (waterfall), akan tetapi kebutuhan akan berubah pada setiap proses.
·         Interaksi antara analisis atau pengguna tidak komprehensif, karena sistem telah didefinisikan dari awal, sehingga tidak adaptif terhadap perubahan (kebutuhan-kebutuhan baru).
·         Selain dengan menggunakan desain logic dan DFD, tidak cukup tool yang digunakan untuk mengkomunikasikan dengan pengguna, sehingga sangat sliit bagi pengguna untuk melakukan evaluasi.
·         Pada SAAD sliit sekali untuk memutuskan ketika ingin menghentikan dekomposisi dan mliai membuat sistem.
·         SSAD tidak selalu memenuhi kebutuhan pengguna.
·         SSAD tidak dapat memenuhi kebutuhan terkait bahasa pemrograman berorientasi obyek, karena metode ini memang didesain untuk mendukung bahasa pemrograman terstruktur, tidak berorientasi pada obyek (Jadalowen, 2002).

Perbandingan Pendekatan OO dan Terstruktur

   Perbandingan Pendekatan OO dan Terstruktur

Perbedaan yang paling dasar dari pendekatan terstruktur dan pendekatan OO( Object Oriented ) atau berorientasi objek adalah pada metode berorientasifungsi atau aliran data ( Data Flow Diagram(DFD)) (pendekatan terstruktur),dekomposisi permasalahan dilakukan berdasarkan fungsi atau proses secara hirarki, mulai dari konteks sampai proses-proses yang paling kecil, sementara pada metode berorientasi objek. dekomposisi permasalahan dilakukan berdasarkan objek-objek yang ada dalam sistem.

Dari perbandingan tersebut, didapatkan bahwa dua metodologi tersebut hanya memenuhi sebagian dari siklus hidup pengembangan sistem. Namun, pada dasarnya kedua metodologi tersebut bisa digunakan untuk melakukan analisa dan perancangan sebuah sistem