[WikiDyd] [TitleIndex] [WordIndex

Języki i metodyka programowania II

Przykłady z wykładów w semestrze letnim 2009

Uwaga: wykłady są ułożone według dat: najnowszy na górze, najstarszy na dole.

18 maja 2009

Testowanie jednostkowe: junit.pdf

4 maja 2009

schoolmarksgui.tgz - ,,Oceny" (projekt Netbeans)

27 kwietnia 2009

20 kwietnia 2009

6 kwietnia 2009

30 marca 2009

Mówiliśmy o kilku trudnych rzeczach: dziedziczeniu, przesłanianiu metod, interfejsach, kontenerach metod i obiektach-metodach.

wszystkie klasy (zip)

Najpierw dziedziczenie i przesłanianie. Klasa Point - niejawnie dziedziczy po Object, przesłania equals, hashCode i toString:

   1 public class Point {
   2         private double x,y;
   3 
   4         public Point( double _x, double _y ) {
   5                 x = _x;
   6                 y = _y;
   7         }
   8 
   9         public void moveTo( double _x, double _y ) {
  10                 x = _x;
  11                 y = _y;
  12         }
  13 
  14         public void moveBy( double dx, double dy ) {
  15                 x += dx;
  16                 y += dy;
  17         }
  18 
  19         public double norm() {
  20                 return Math.sqrt( x*x + y*y );
  21         }
  22 
  23         public Point copy() {
  24                 return new Point( x, y );
  25         }
  26 
  27         public boolean equals( Object o ) {
  28                 return o != null
  29                                 && o instanceof Point
  30                                 && ((Point)o).x == x
  31                                 && ((Point)o).y == y;
  32         }
  33 
  34         public int hashCode() {
  35                 return (int)x + 251*(int)y;
  36         }
  37 
  38         public String toString() {
  39                 return "Point("+x+","+y+")";
  40         }
  41 }

Teraz Pixel - rozszerza Point, pokazuje jawnie wywołanie konstruktora nadklasy (super w konstruktorze).

   1 public class Pixel extends Point {
   2         private int color;
   3 
   4         public Pixel( double x, double y, int c ) {
   5                 super( x, y );
   6                 color = c;
   7         }
   8 
   9         public int getColor() {
  10                 return color;
  11         }
  12 
  13         public void setColor( int c ) {
  14                 color = c;
  15         }
  16 }

Teraz ComparablePixel - pokazuje implementację interfejsu.

   1 public class ComparablePixel extends Pixel implements Comparable<Pixel> {
   2 
   3         public ComparablePixel( double x, double y, int color ) {
   4                 super( x, y, color );
   5         }
   6 
   7         public int compareTo( Pixel o ) {
   8                 double n = norm();
   9                 double on = o.norm();
  10                 if( n < on )
  11                         return -1;
  12                 else if( n == on )
  13                         return 0;
  14                 else
  15                         return 1;
  16         }
  17 
  18 }

Teraz klasa Utils - kontener metod (a właściwie jednej metody;-)

   1 public class Utils {
   2         public static void sort( Comparable [] t, int n ) {
   3                 for( int i= 1; i < n; i++ ) {
   4                         Comparable tmp = t[i];
   5                         int j;
   6                         for( j= i; j > 0 && t[j-1].compareTo( tmp ) > 0; j-- )
   7                                 t[j]= t[j-1];
   8                         t[j]= tmp;
   9                 }
  10         }
  11 }

I przykład wykorzystania:

   1 public class Test {
   2 // klasa uruchamiana - w wywoÂłaniu podajmy parzysta liczbe liczb
   3         public static void main( String [] args ) {
   4     // sortujemy napisy
   5                 Utils.sort( args, args.length );
   6                 for( int i= 0; i < args.length; i++ )
   7                         System.out.println( args[i] );
   8 
   9                 // teraz robimy Pixele
  10     ComparablePixel [] s = new ComparablePixel[100];
  11     int n= 0;
  12     for( int i= 0; i < args.length; i += 2 )
  13       s[n++] = new ComparablePixel( Double.parseDouble( args[i] ),
  14                                     Double.parseDouble( args[i+1] ), 0 );
  15 
  16     // i sortujemy ta sama metoda, co poprzednio
  17     Utils.sort( s, n );
  18 
  19     for( int i = 0; i < n; i++ )
  20       System.out.println( s[i] );
  21 
  22         }
  23 }

Teraz dodamy do Utils metodę, która pozwoli ustalać inny porządek sortowania, niż wbudowany w klasę.

   1 public class Utils {
   2         public static void sort( Comparable [] t, int n ) {
   3                 for( int i= 1; i < n; i++ ) {
   4                         Comparable tmp = t[i];
   5                         int j;
   6                         for( j= i; j > 0 && t[j-1].compareTo( tmp ) > 0; j-- )
   7                                 t[j]= t[j-1];
   8                         t[j]= tmp;
   9                 }
  10         }
  11         public static void sort( Object [] t, int n, Comparator c ) {
  12                 for( int i= 1; i < n; i++ ) {
  13                         Object tmp = t[i];
  14                         int j;
  15                         for( j= i; j > 0 && c.compare( t[j-1], tmp ) > 0; j-- )
  16                                 t[j]= t[j-1];
  17                         t[j]= tmp;
  18                 }
  19         }
  20 }

Widoczny w ostatnim listingu Comparator to interfejs:

public interface Comparator {
        public int compare( Object o1, Object o2 );
}

Do sortowania obiektów typu Pixel możemy zaimplementować go tak:

   1 public class PointComparator implements Comparator {
   2   public int compare( Object p1, Object p2 ) {
   3     double n1 = ((Point)p1).norm();
   4     double n2 = ((Point)p2).norm();
   5     if( n1 < n2 )
   6       return 1;
   7     else if( n1 == n2 )
   8       return 0;
   9     else
  10       return -1;
  11   }
  12 }

Przykład użycia:

   1 public class Uest {
   2 
   3         public static void main( String [] args ) {
   4                 ComparablePixel [] s = new ComparablePixel[100];
   5                 int n= 0;
   6                 for( int i= 0; i < args.length; i += 2 )
   7                         s[n++] = new ComparablePixel( Double.parseDouble( args[i] ),
   8                                                       Double.parseDouble( args[i+1] ), 0 );
   9 
  10                 Utils.sort( s, n, new PointComparator() );
  11 
  12                 for( int i = 0; i < n; i++ )
  13                         System.out.println( s[i] );
  14         }
  15 
  16 }

23 marca 2009

Wykład był poświęcony podstawom projektowania interakcji między klasami. Mówiliśmy o różnicy pomiędzy interfejsem i implementacją oraz wspomnieliśmy o kartach CRC jako metodzie projektowania klas. Przy okazji wspomnieliśmy

   1 public interface IUsers {
   2                 void addUser( String n, String in, String out );
   3                 void resetIterator();
   4                 boolean isNext();
   5                 String nextName();
   6 }

   1 public class Users implements IUsers {
   2   private int noUsers;
   3   private User [] users;
   4   private int iterator;
   5 
   6   private class User {
   7     private String name;
   8     private String inbox;
   9     private String outbox;
  10 
  11     User( String n, String i, String o ) {
  12       name = n;
  13       inbox = i;
  14       outbox = o;
  15     }
  16 
  17     String getName() {
  18       return name;
  19     }
  20     String getInbox() {
  21       return inbox;
  22     }
  23     String getOutbox() {
  24       return outbox;
  25     }
  26   }
  27 
  28   public Users() {
  29     users = new User[100];
  30     noUsers = 0;
  31   }
  32 
  33   private void doubleSize() {
  34     User [] nusers = new User[ users.length * 2 ];
  35     for( int i= 0; i < noUsers; i++ )
  36       nusers[i] = users[i];
  37     users = nusers;
  38   }
  39 
  40   public void addUser( String n, String inbx, String outbx ) {
  41     if( noUsers == users.length )
  42       doubleSize();
  43 
  44     users[noUsers++] = new User( n, inbx, outbx );
  45   }
  46 
  47   public void resetIterator() {
  48     iterator= 0;
  49   }
  50 
  51   public boolean isNext() {
  52     return iterator < noUsers;
  53   }
  54 
  55   public String nextName() {
  56     return users[iterator++].getName();
  57   }
  58 
  59   public String getInbox( String name ) {
  60     int j= 0;
  61     for( int i= iterator == 0 ? 0 : iterator-1; j < noUsers; j++, i++, i %= noUsers )
  62       if( users[i].getName().equals( name ) )
  63         return users[i].getInbox();
  64     return null;
  65   }
  66 
  67   public String getOutbox( String name ) {
  68     int j= 0;
  69     for( int i= iterator == 0 ? 0 : iterator-1; j < noUsers; j++, i++, i %= noUsers )
  70       if( users[i].getName().equals( name ) )
  71         return users[i].getOutbox();
  72     return null;
  73   }
  74 }

   1 public class LUsers implements IUsers {
   2         private int noUsers;
   3         private LNode head;
   4         private LNode iterator;
   5 
   6         private class LNode {
   7                 private User data;
   8                 private LNode next;
   9 
  10                 LNode( User u ) {
  11                         data = u;
  12                         next = null;
  13                 }
  14 
  15                 LNode( User u, LNode n ) {
  16                         data = u;
  17                         next = n;
  18                 }
  19 
  20                 User getUser() {
  21                         return data;
  22                 }
  23         }
  24 
  25         private class User {
  26                 private String name;
  27                 private String inbox;
  28                 private String outbox;
  29 
  30                 User( String n, String i, String o ) {
  31                         name = n;
  32                         inbox = i;
  33                         outbox = o;
  34                 }
  35 
  36                 String getName() {
  37                         return name;
  38                 }
  39                 String getInbox() {
  40                         return inbox;
  41                 }
  42                 String getOutbox() {
  43                         return outbox;
  44                 }
  45         }
  46 
  47         public LUsers() {
  48                 head = null;
  49                 noUsers = 0;
  50         }
  51 
  52         public void addUser( String n, String inbx, String outbx ) {
  53                 head = new LNode( new User( n, inbx, outbx ), head );
  54                 noUsers++;
  55         }
  56 
  57         public void resetIterator() {
  58                 iterator= head;
  59         }
  60 
  61         public boolean isNext() {
  62                 return iterator != null;
  63         }
  64 
  65         public String nextName() {
  66                 if( iterator == null )
  67                         return null;
  68           String n = iterator.getUser().getName();
  69                 iterator = iterator.next;
  70                 return n;
  71         }
  72 
  73         public String getInbox( String name ) {
  74           LNode p = head;
  75                 while( p != null )
  76                         if( p.getUser().getName().equals( name ) )
  77                                 return p.data.getInbox();
  78                         else
  79                                 p = p.next;
  80                 return null;
  81         }
  82 
  83         public String getOutbox( String name ) {
  84           LNode p = head;
  85                 while( p != null )
  86                         if( p.getUser().getName().equals( name ) )
  87                                 return p.getUser().getOutbox();
  88                         else
  89                                 p = p.next;
  90                 return null;
  91         }
  92 }

16 marca 2009

Rozmawialiśmy o budowie i ładowaniu klas oraz o inicjalizacji obiektów: typach pól, regułach dostępu, konstruktorach i blokach inicjujących.

Kod:

   1 public class Ini {
   2 
   3   Ini( int s ) {
   4                 for( int i= s; i < x.length; i++ )
   5                         x[i] = 0;
   6         }
   7 
   8         public void set( int n, double x ) {
   9                 this.x[n]= x;
  10                 counter++;
  11         }
  12 
  13         public double get( int n ) {
  14                 counter++;
  15                 return x[n];
  16         }
  17 
  18         public static double staticGet( int n ) {
  19                 counter++;
  20                 return x[n];
  21         }
  22 
  23         public long getCounter() {
  24                 return counter;
  25         }
  26 
  27         public static long staticGetCounter() {
  28                 return counter;
  29         }
  30 
  31         double [] x;
  32 
  33         {
  34                 x = new double[10];
  35                 for( int i= 0; i < x.length; i++ )
  36                         x[i] = i;
  37         }
  38 
  39         int no;
  40         static long counter;
  41 
  42         static {
  43                 counter = 1;
  44         }
  45 }

9 marca 2009

Zaczęliśmy Javę. Mówiliśmy o budowie klasy, na przykładzie stosu liczb double.

   1 public class Stack {
   2         private double [] t;
   3         private int sp;
   4 
   5         public Stack( int size ) {
   6                 t= new double[size];
   7                 sp= 0;
   8         }
   9 
  10         public Stack() {
  11                 this( 100 );
  12         }
  13 
  14         public void push( double x ) {
  15                 if( sp == t.length ) {
  16                         double [] nt = new double[ 2 * t.length ];
  17                         for( int i= 0; i < sp; i++ )
  18                           nt[i]= t[i];
  19                         t= nt;
  20                 }
  21                 t[sp++] = x;
  22         }
  23 
  24         public void push( Stack other ) {
  25           if( sp + other.sp > t.length ) {
  26                         double [] nt = new double[ sp+other.sp ];
  27                         for( int i= 0; i < sp; i++ )
  28                                 nt[i]= t[i];
  29                         t= nt;
  30                 }
  31                 for( int i= 0; i < other.sp; i++ )
  32                   t[sp++] = other.t[i];
  33         }
  34 
  35         public double pop() {
  36                 return t[--sp];
  37         }
  38 
  39         public boolean isEmpty() {
  40                 return sp == 0;
  41         }
  42 
  43         public int getSize() {
  44                 return t.length;
  45         }
  46 }

Powiedzieliśmy też, że klasy kompiluje się zwykle do tak zwanego kodu pośredniego (gwarowo bajtkodu - ang. bytecode), który jest najczęściej uruchamiany pod kontrolą interpretera - wirtualnej maszyny Javy (ang. JVM - Java Virtual Machine) i dlatego jest przenośny. JVM uruchamia klasy - aby można było klasę uruchomić, musi ona zawierać specjalną metodę main:

   1 public class Test {
   2 
   3         public static void main( String [] args ) {
   4 
   5                 boolean haveArgs= args.length > 0;
   6 
   7                 if( haveArgs ) {
   8 
   9                         int sl = Integer.parseInt( args[0] );
  10 
  11                         Stack mys = new Stack( );
  12                         Stack s2 = new Stack( 5 );
  13 
  14                         for( int i= 0; i < sl; i++ ) {
  15                                 mys.push( 0.1*i );
  16                                 s2.push( 3.5*i );
  17                         }
  18 
  19                         mys.push( s2 );
  20 
  21                         System.out.println( "Aktualna wielkosc stosow = " + mys.getSize() + " i " + s2.getSize() );
  22 
  23                         while( ! mys.isEmpty() )
  24                                 System.out.println( mys.pop() );
  25 
  26                 } else {
  27                         System.err.println( "Ty gapciu! Podaj wielkosc stosu!" );
  28                 }
  29         }
  30 }

Przykład kompilacji i uruchomienia powyższej klasy:

jstar@edi:~/jimp2/j1$ ll
razem 16
drwxr-xr-x 4 jstar stud 4096 2009-03-09 14:15 ..
-rw-r--r-- 1 jstar prac  737 2009-03-09 15:56 Stack.java
-rw-r--r-- 1 jstar prac  575 2009-03-15 21:58 Test.java
drwxr-xr-x 2 jstar prac 4096 2009-03-15 21:59 .
jstar@edi:~/jimp2/j1$ javac Test.java
jstar@edi:~/jimp2/j1$ ll
razem 24
drwxr-xr-x 4 jstar stud 4096 2009-03-09 14:15 ..
-rw-r--r-- 1 jstar prac  737 2009-03-09 15:56 Stack.java
-rw-r--r-- 1 jstar prac  575 2009-03-15 21:58 Test.java
-rw-r--r-- 1 jstar prac 1215 2009-03-15 21:59 Test.class
-rw-r--r-- 1 jstar prac  940 2009-03-15 21:59 Stack.class
drwxr-xr-x 2 jstar prac 4096 2009-03-15 21:59 .
jstar@edi:~/jimp2/j1$ java Test
Ty gapciu! Podaj wielkosc stosu!
jstar@edi:~/jimp2/j1$ java Test 9
Aktualna wielkosc stosow = 100 i 10
28.0
24.5
21.0
17.5
14.0
10.5
7.0
3.5
0.0
0.8
0.7000000000000001
0.6000000000000001
0.5
0.4
0.30000000000000004
0.2
0.1
0.0
jstar@edi:~/jimp2/j1$ 

2015-09-23 06:44