[WikiDyd] [TitleIndex] [WordIndex

Programowanie obiektowe: Java i C++

Zajęcia w sem. zimowym 2008

29.10.2008

Rozmawialiśmy o technice projektowania struktury programu (praca zespołowa, przypadki użycia, scenariusz, karty CRC, UML), zasadach wiązania klas i bibliotece Java Collection Framework.

Rozpoczęliśmy pracę nad projektem Telbook.

Uzgodniliśmy interfejsy:

   1 public interface Communicator {
   2     public void sendMessage(String message);
   3 }

   1 public interface Contact {
   2     public String getName();
   3     public void setName( String name );
   4     public Communicator getCommunicator();
   5     public Communicator setCommunicator( Communicator c );
   6     public void sendMessage(String message);
   7 }

   1 public interface TelBook {
   2     public Collection<Contact> find( String pattern );
   3     public void add( Contact newOne );
   4     public Collection<Contact> remove( String pattern );
   5     public void merge( TelBook other );
   6 }

Zaimplementowaliśmy Contact

   1 public class ContactImplementation implements Contact {
   2     private String name;
   3     private Communicator c;
   4     
   5     public ContactImplementation(String name, Communicator c) {
   6         this.name = name;
   7         this.c = c;
   8     }
   9     
  10     public void sendMessage(String message) {
  11         if( c != null ) c.sendMessage(message);
  12     }
  13 
  14     public String getName() {
  15         return name;
  16     }
  17 
  18     public void setName(String name) {
  19         this.name = name;
  20     }
  21 
  22     public Communicator getCommunicator() {
  23         return c;
  24     }
  25 
  26     public Communicator setCommunicator(Communicator c) {
  27         Communicator tmp = this.c;
  28         this.c = c;
  29         return tmp;
  30     }
  31     
  32     @Override
  33     public boolean equals( Object o ) {
  34         return o != null && o instanceof Contact && ((Contact)o).getName().equals( name );
  35     }
  36     
  37     @Override
  38     public int hashCode() {
  39         return name.hashCode();
  40     }
  41     
  42     @Override
  43     public String toString() {
  44         return name + "  : " + c.toString();
  45     }
  46 }

Wyjaśniliśmy sobie potrzebę istnienia (przesłonięcia) metod equals, hashCode, toString.

22.10.2008

Abstrakcja, polimorfizm, związki pomiędzy klasami: dziedziczenie a kompozycja, wzorzec Stan

Dynamiczne ładowanie klas

   1 package classfornamesample;
   2 
   3 /**
   4  *
   5  * @author jstar
   6  */
   7 public class Main {
   8 
   9     /**
  10      * @param args the command line arguments
  11      */
  12     public static void main(String[] args) {
  13         if (args.length > 0) {
  14             try {
  15                 Class c = Class.forName(args[0]);
  16                 System.out.println( "Załadowana klasa " + args[0]);
  17                 Object o = c.newInstance();
  18                 Comm com = (Comm) o;
  19                 com.sendMessage( "jest super");
  20             } catch (ClassNotFoundException e) {
  21                 System.err.println("Nie moge znalezc " + args[0] + ".class");
  22             } catch( InstantiationException e) {
  23                 System.err.println("Klasa " + args[0] + " nie ma odpowiedniego konstruktora");
  24             } catch( IllegalAccessException e ) {
  25                 System.err.println("Nie mogę użyć konstruktora klasa " + args[0] );
  26             } catch( ClassCastException e) {
  27                 System.err.println(args[0] + " nie implementuje interfejsu Comm" );
  28             }
  29         }
  30     }
  31 }

   1 package classfornamesample;
   2 
   3 /**
   4  *
   5  * @author jstar
   6  */
   7 public interface Comm {
   8     public void sendMessage( String s);
   9 }

   1 public class Sms implements classfornamesample.Comm {
   2   public void SendMessage( String m ) {
   3     System.out.println( "Sms: wysyłam \""+ m + "\"" );
   4   }
   5 }

15.10.2008

Enkapsulacja: stanu, implementacji, typów, obiektów

   1 

08.10.2008

Pisaliśmy prościutkie klasy w Javie: stos napisów:

   1 /**
   2  *
   3  * @author JSTAR
   4  */
   5 public class StosNapisow {
   6 
   7     private String[] stos = new String[3];
   8     private int ileJest = 0;
   9 
  10     public StosNapisow() {
  11     }
  12 
  13     public void włóż(String s) {
  14         if (ileJest >= stos.length) {
  15             String[] nowa = new String[stos.length * 2];
  16             for (int i = 0; i < stos.length; i++) {
  17                 nowa[i] = stos[i];
  18             }
  19             stos = nowa;
  20         }
  21         stos[ileJest] = s;
  22         ileJest++;
  23     }
  24 
  25     public boolean niePusty() {
  26         if (ileJest > 0) {
  27             return true;
  28         } else {
  29             return false;
  30         }
  31     }
  32 
  33     public String wyjmij() {
  34         if (niePusty()) {
  35             String tmp = stos[ileJest - 1];
  36             ileJest--;
  37             return tmp;
  38         } else {
  39             return null;
  40         }
  41     }
  42 }

i klasa testująca:

   1 /**
   2  *
   3  * @author JSTAR
   4  */
   5 public class P1 {
   6 
   7     /**
   8      * @param args the command line arguments
   9      */
  10     public static void main(String[] args) {
  11         StosNapisow s = new StosNapisow();
  12         for( String n : args )
  13             s.włóż( n );
  14         while( s.niePusty() ) {
  15             System.out.println( s.wyjmij() );
  16         }
  17     }
  18 }

Dowiedzieliśmy się jak program w Javie jest zapisywany, kompilowany i uruchamiany. Mówiliśmy o metodzie main, dostępie do klas, metod, pól, inicjalizacji obiektów, konstruktorach domyślnych i regułach nazywania klas, metod i pól. Stworzyliśmy pierwszy prosty projekt w NetBeansie.


2015-09-23 06:47