Podstawowe aspekty programowania w Javie by WzmWYhF6

VIEWS: 11 PAGES: 137

									Podstawowe aspekty
programowania w Javie




      Michał Kuciapski
      m.kuciapski@univ.gda.pl
Cel przedmiotu
      Celem przedmiotu jest ukazanie
      podstawowych elementów składni
      języka programowania Java wraz
      z wykazaniem praktycznego ich
      zastosowania w tworzeniu
      aplikacji konsolowych, na
      podstawie rozbudowanego
      przykładu przy wsparciu ze strony
      technik analizy i projektowania
      obiektowego.
Programowanie obiektowe
Programowanie obiektowe

Koncepcja, korzyści i podstawowe
             pojęcia
Koncepcja programowania obiektowego

Programowanie obiektowe zakłada tworzenie
  oprogramowania składającego się ze społeczności
  obiektów, ułożonych w hierarchiczne struktury i
  potrafiących komunikować się ze sobą poprzez
  przesyłanie wiadomości, dla realizowania celów
  systemu.
Programowanie obiektowe czerpie swoją koncepcję
  z rzeczywistego świata otaczającego nas
  składającego się z olbrzymiej ilości obiektów, jak
  np.: ludzie, budynki i struktur, jak np. organizacje.
                                                 5 z 137
  Koncepcja programowania obiektowego

          Model problemu                                        Rzeczywiste
                                                                  obiekty



                Algorytm                                      Model problemu



                Program                                          Obiekty
                                                             oprogramowania
       Tradycyjny, uproszczony                            Podejście obiektowe
    proces rozwiązywania problemu                    proces rozwiązywania problemu

Na podstawie „Object-Oriented Programming: From Problem Solving to Java”,   6 z 137
             Charles River Media 2003
Korzyści programowania obiektowego – dlaczego?


• Jednolitość – jedna reprezentacja problemu
• Zrozumiałość – organizacja kodu (klas) zgodnie z
  dziedziną zastosowania
• Rozszerzalność – jednolitość reprezentacji dziedziny
  problemu ułatwia równoległe rozwijanie oprogramowania
• Stabilność – przejrzystość organizacji kodu i jego
  modularność minimalizują konieczność zmian
• Wielokrotny użytek – decentralizacja kodu na komponenty


                                                       7 z 137
Podstawowe pojęcia obiektowości
     Pojęcie                            Interpretacja
                      Każdy byt – pojęcie lub rzecz – mający znaczenie w
      obiekt
   (ang. object)      kontekście    rozwiązywania   problemu   w   danej
                      dziedzinie przedmiotowej.

       klasa          Uogólnienie zbioru obiektów, które mają takie same
    (ang. class)      atrybuty, operacje, związki i znaczenie.

                      Ignorowanie tych aspektów (cech, właściwości)
    abstrakcja        przedmiotu, które nie są istotne z punktu widzenia
 (ang. abstraction)   bieżącego celu, a koncentrowanie się na aspektach
                      właściwych.
                      Możliwość nadawania tej samej nazwy różnym
                      atrybutom i operacjom oraz wykonywania różnych
    polimorfizm
(ang. polymorphism)   procedur i akcji przez operacje o tych samych
                      nazwach; pozwala na redukcję liczby nazw atrybutów
                      i operacji.

                                                                8 z 137
Podstawowe pojęcia obiektowości
     Pojęcie                            Interpretacja
                     Różnicowanie    dostępu   do   obiektu    poprzez
                     ujawnienie otoczeniu tylko tych informacji o jego
   hermetyzacja
(ang. encapsulation)
                     atrybutach/operacjach, które są niezbędne do
                     efektywnego odwoływania się do tego obiektu w
                     systemie za pośrednictwem komunikatów.
                      Przyporządkowanie atrybutów i operacji klasom
                      obiektów na podstawie hierarchicznej zależności
   dziedziczenie      między     nimi.    Możliwe     jest   wielokrotne
 (ang. inheritance)   dziedziczenie, co oznacza, że dana klasa dziedziczy
                      atrybuty i operacje z dowolnej liczby klas
                      nadrzędnych.
                      Specyfikacja    wymiany       informacji    między
    komunikat
  (ang. message)
                      obiektami,    zawierająca    zlecenia    wykonania
                      określonej operacji.



                                                                9 z 137
Paradygmat obiektowy

Opanowywanie złożoności (dziedziny) problemu
 opiera się na powszechnie stosowanych zasadach:
  – rozróżnianie poszczególnych obiektów
  – tworzenie pojęć - łączenie obiektów w klasy
  – znajdowanie zależności między pojęciami -
    klasami, wyprowadzanie nowych
  – określanie relacji między obiektami



                                                10 z 137
Programowanie obiektowe

      Klasy i obiekty
Klasa – definicja i koncepcja
Klasa – opis obiektu lub obiektów z jednolitym zbiorem
  atrybutów i usług, zawierający opis tworzenia nowych
  obiektów w klasie.


Klasa = wspólne własności + wspólne zachowania


Klasy dla umożliwienia pisania programów tak, jak
  rozważany problem są zoorganizowane w struktury, co
  zapewnia: stabilność , przejrzystość, zrozumiałość i
  wielokrotną wykorzystywalność kodu.

                                                 12 z 137
Klasa – przykład struktury
                          Component
                                                             Button
               Container                                    Canvas
                                                           Checkbox
    Window                 Panel
                                                                 Label
                                                                 List
  Frame               Dialog                                Scrollbar
                                                            TextArea
                    FileDialog                              TextField
                Hierarchia głównych klas pakietu AWT
 Okno, posiadającektóreco ma określonąform iodbieraćktóry może
 Okno dialogowe, obramowanie i modalne Kontener,
 Nadklasa klas zawierających zawiłych pozycję i rozmiar oraz
 Reprezentacja czegoś umożliwia może posiadać skojarzony
Okno dialogowe,posiadamoże komponenty. konkretnego pliku z
 Okno które nie które obramowania
 Umożliwia tworzenie bardziej byćwybranie – dostosowywanie        13 z 137
 nim obiektprzedstawione na i zarządzać ich rozmieszczeniem.
 może być MenuBar
systemu plików. potrzeb. klasekranie i odbierać zdarzenia
 komunikaty od
 kontenerów do użytkownika.
 zawierać obiekty innych
  Definiowanie klasy – wersja uproszczona
class NazwaKlasy {
   //pola
   typ_zmiennej zmienna;
   …
   // konstruktor - metoda o tej samej nazwie co klasa – wywoływana automatycznie
   // przy tworzeniu obiektu danej klasy
   NazwaKlasy (typ_argumentu nazwaAgrumentu){
      treść konstruktora
   }
   // metody
   typ_zwracanej_wartości nazwaMetody (typ_argumentu nazwaAgrumentu [,…]){
        treść metody
   }
   …
} //koniec definicji klasy


                                                                    14 z 137
   Definiowanie klasy – wersja kompletna
[modyfikatory] class NazwaKlasy [extends NazwaNadklasy] [implements
   NazwyInterfejsów] {
   //pola
[modyfikatory] typ_zmiennej zmienna;
  …
// konstruktor - metoda o tej samej nazwie co klasa – wywoływana automatycznie
   // przy tworzeniu obiektu danej klasy
   NazwaKlasy (typ_argumentu nazwaAgrumentu [,…]){
       treść konstruktora
   }
   // metody
[modyfikatory] typ_zwracanej_wartości nazwaMetody (typ_argumentu
   nazwaAgrumentu [,…]){
         treść metody
   }
   …
} //koniec definicji klasy
                                                                                 15 z 137
Definiowanie klasy – modyfikatory
Modyfikatory dostępu (widoczności)
 Nazwa                                  Opis
public     Klasa jest ogólnodostępna.
brak       Dostęp do klasy mają klasy jedynie z tego samego pliku
           definicji klas.

Modyfikatory właściwości
 Nazwa                                  Opis
abstract   Reprezentuje abstrakcyjną koncepcję, opisującą pewne
           własności wspólne dla grupy klas z niej dziedziczących,
           stanowiąc dla nich niejako szablon. Dla samej klasy
           abstrakcyjnej nie są tworzone obiekty.
final      Definicja klasy jest ostateczna i przesłanianie nie jest możliwe
           poprzez dziedziczenie

                                                                 16 z 137
Definiowanie klasy – abstract i final

                                  abstract
                                  jeśli final
           X          X




                                         17 z 137
 Definiowanie klasy – przykłady deklaracji

• Public:
   – public class Nauczyciel {definicja}
   – public class Nauczyciel extends Osoba {definicja}
• Bez modyfikatora dostępu:
   – class Nauczyciel {definicja}
• Abstract:
   – abstract class FiguraPłaska {definicja}
   – public abstract class Osoba {definicja}
• Final:
   – public final class Math extends Object {definicja}


                                                     18 z 137
Definiowanie klasy – przykłady definicji




                                           19 z 137
Definiowanie klasy – przykłady definicji




                                           20 z 137
  Definiowanie klasy – przykłady definicji
                                         public class Klient {
                                           public static int wiek;
                                           public static byte ilośćLat = 26;
cd Data Model

                                             public static miesiąceŻycia(byte lata)
                 Klient
                                             {
                                                 return lata * 12;
   +   wiek: int
   +   ilośćLat: byte = 26

   +   miesiąceŻycia(lata :byte) : int       }

                                             public static void main(String[] args)
                                             {
                                                 wiek = miesiąceŻycia(ilośćLat);
                                                 System.out.writeln(wiek);
                                             }
                                         }
                                                                               21 z 137
Klasy – dziedziczenie - definicja i koncepcja
Dziedziczenie - jest operacją polegającą na utworzeniu
  nowej klasy na bazie klasy już istniejącej. Nowa klasa nosi
  podklasy (ang. subclass), a klasa z której dziedziczy nazwę
  nadklasy     (ang.      superclass).      Podklasa      jest
  uszczegółowieniem nadklasy.

Dziedziczenie polega na „przejęciu” pól i metod z jednej
  klasy (nadklasy) przez drugą klasę (podklasę).

Związek dziedziczenia można opisać słowem „jest” – np.
  student jest osobą.

Stosowanie    dziedziczenia    pomaga          w     praktyce
  wykorzystywać zasadę ponownego użycia.
                                                      22 z 137
Klasy – dziedziczenie - założenia
Dziedziczenie w języku Java:
• Jest możliwe wyłącznie jednokrotne – wyłącznie
  jedna nadklasa;
• Podczas dziedziczenia są uwzględnione
  modyfikatory dostępu i właściwości:
   – Niemożliwe jest dziedziczenie z klas o modyfikatorach:
     private, final
   – Pola i metody o modyfikatorze dostępu private nie są
     dziedziczone;
• Podczas dziedziczenia są uwzględnione typy klas –
  niemożliwe jest dziedziczenie z klas lokalnych czy
  wewnętrznych
                                                     23 z 137
Klasy – dziedziczenie - deklaracja

[modyfikatory] class NazwaKlasy [extends NazwaNadklasy]
• extends – słowo kluczowe wskazujące, że klasa dziedziczy
  pola i metody innej klasy
• NazwaNadklasy – nazwa klasy, z której klasa dziedziczy
  pola i metody

Przykłady:
   – public class Student extends Osoba
   – class Analiza extends Applet



                                                  24 z 137
Klasy – dziedziczenie - przykłady




                                    25 z 137
 Klasy – dziedziczenie - przykłady
cd Data Model


                                                    Osoba
                                                             {root}




                                          PracownikObsługiKina




   Pracow nikInformacj iRezerw acj i                Kasjer               KinoOperator




                Pracow nikKasGastronomicznych                Pracow nikKasBiletow ych
                                          {l eaf}                                {l eaf}



                                                                                           26 z 137
Klasy – dziedziczenie - przykłady



Pola i obwody figur płaskich


Gra RPG



                                    27 z 137
Typy klas

  Nazwa                              Opis
wewnętrzna Klasa zdefiniowana w miejscu, w którym może wystąpić
             definicja pola danych lub metody. Klasy wewnętrzne, w
             odróżnieniu od zewnętrznych, mogą mieć modyfikator
             static, wskazujący że, klasa wewnętrzna ma takie same
             właściwości jak klasa zewnętrzna.
lokalna      Zdefiniowana w bloku programu Javy. Klasa taka może
             odwoływać się do wszystkich zmiennych widocznych w
             miejscu wystąpienia jej definicji. Klasa lokalna jest
             widoczna, i może zostać użyta, tylko w bloku w którym
             została zdefiniowana.
anonimowa    Klasa bez nazwy i konstruktora, definiowana za pomocą
             wyrażenia w klamrach znajdującego się w konstruktorze
             nadklasy.

                                                         28 z 137
Typy klas – przykłady – klasa wewnętrzna
public class Test
{
    private int m_nLiczba = 0;
    private Licznik licznik;
    public static void main(String args[])
    {
           Test test = new Test();
           test.licznik = test.new Licznik();
           test.licznik.dodaj();
           System.out.println("Licznik = " + test.licznik.wez());
    }
    class Licznik
    {
           public int wez()
           {
                        return m_nLiczba;
           }
           public void dodaj()
           {
                        m_nLiczba++;
           }
    }// koniec definicji klasy wewnętrznej Licznik
}// koniec definicji klasy zewnętrznej Test
                                                                    29 z 137
Typy klas – przykłady – klasa lokalna
public class Test
{
  private int m_nLiczba = 0;
  public static void main(String args[])
  {
     final Test test = new Test();
     class Licznik
        {
           int wez()
           {return test.m_nLiczba; }
           void dodaj()
           {test.m_nLiczba++; }
        };
     Licznik licznik = new Licznik();
     licznik.dodaj();
     System.out.println("Licznik = " + licznik.wez());
  }
}

                                                         30 z 137
Typy klas – przykłady – klasa anonimowa
public class Test
{
   private int m_nLiczba = 0;
   private Licznik licznik;
   public static void main(String args[])
   {
          Test test = new Test();
          test.licznik.dodaj();
          PrintWriter stdout = new PrintWriter(System.out, true);
          stdout.println("Licznik = "+test.licznik.wez());
   }
   Test()
   {
          this.licznik = new Licznik()
                      {
                                public int wez()
                                {return m_nLiczba; }
                                public void dodaj()
                                {m_nLiczba++; }
                      };
   }
}
                                                                    31 z 137
Klasy – pakiety – definicja i koncepcja
Pakiety są zbiorem klas wydzielonych ze względu na
  wspólną tematykę i ułożonych hierarchicznie. Organizacja
  klas w ten sposób umożliwia lepsze ich zarządzanie i jest
  odpowiednikiem bibliotek w językach proceduralnych.

Organizacja klas w pakiety ułatwia znacząco              ich
  wykorzystanie przy definiowaniu nowych.

Możliwe jest tworzenie własnych pakietów jak i dodawanie
  definiowanych klas do już istniejących.

Umieszczenie klas w pakiecie jest analogiczne            do
 umieszczenia klas w strukturze katalogów.
                                                    32 z 137
 Klasy – pakiety – przykłady
    Pakiet                              Opis
java.lang     Zawiera   podstawowe      klasy    Java    automatycznie
              importowane do każdej klasy.
java.applet   Klasy związane z tworzeniem appletów.

java.awt      (AWT - Abstract Window Toolkit) zawiera klasy dla
              tworzenia interfejsu graficznego użytkownika oraz grafiki.
java.io       Zawiera klasy zarządzające wejściowym i wyjściowym
              strumieniem danych.
java.util     Zawiera szereg dodatkowych klas narzędziowych.

java.net      Zawiera klasy sieciowe dla podstawowych protokołów
              stosowanych w Internecie: FTP, HTTP, SMTP, NNTP oraz
              TCP/IP.

                                                             33 z 137
Klasy – pakiety – wykorzystanie i definiowanie
Wykorzystanie poprzez wyrażenie:
 import ścieżka_do_pakietu(ów);
              import java.io.*;
   Przykład
              import java.util.*;


Definiowanie poprzez wyrażenie:
package ścieżka_umieszczenia_pakietu;
   Przykład package figury;
             package figury.płaskie;

Instrukcje związane z pakietami są umieszczane na początku
  definicji klasy.
                                                    34 z 137
Klasy – pola – definicja i nazewnictwo

Pola danych są atrybutami klasy, pełniącymi rolę
  analogiczną do zmiennych lub stałych, z tą różnicą, że są
  widoczne co najmniej w obrębie całej klasy.

Pola danych są one deklarowane na tych samych zasadach,
  co zmienne lokalne, ale bezpośrednio po deklaracji klasy.

Dla rozróżnienia nazw pól od pozostałych zmiennych
  należy stosować podczas deklaracji nazwy zgodnie z
  przyjętą konwencją. Najczęściej używa się przedrosków,
  jak pol czy atr, np.: polImie, atrImie.


                                                    35 z 137
Klasy – pola - deklaracja
[modyfikatoryPola] TypPola NazwaPola;
      Nazwa                                      Opis
modyfikatoryPola       Określają tryb dostępu (np. private) i
                       właściwości pola (np. static)
TypPola                Specyfikuje typ pola danych;
NazwaPola              Określa nazwę deklarowanego pola.

Przykłady:
   • private boolean atrPracuje = true;
   • BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   • static double atrPI = 3,14;
   • protected String polNazwisko;
   • double oceny[] = new double[10];
                                                                     36 z 137
Klasy – pola - przykłady
public class WyswietlInformacje
{
   private int iloscZnalezien = 0;Pole
   // dalsze instrukcje
   public int[] wyszukiwanieOsoby(ArrayList parOsoba, String
             parSzukania[], String parTyp)
   {
     int[] pozycjeWyszukane = new int[10];   Zmienna
     if (parTyp.equals("nauczyciel"))
     {
       // dalsze instrukcje
       if (nauczyciel.imie.equals(parSzukania[0]) &&
                         nauczyciel.nazwisko.equals(parSzukania[1]))
           {
             // dalsze instrukcje
             iloscZnalezien++;  Wykorzystanie atrybutu
              // dalsze instrukcje
           }
     }
 }

                                                                       37 z 137
Klasy – pola - modyfikatory dostępu

Są wspólne dla pól danych i metod
 Nazwa                                Opis
public     Wszystkie klasy mają dostęp do pól danych i metod public.
private    Dostęp do metod i pól danych posiadają jedynie inne metody
           tej samej klasy.
protected Metoda lub pole danych protected lub może być używana
           jedynie przez metody swojej klasy oraz metody wszystkich jej
           klas pochodnych.
package    Jest to modyfikator domyślny, wszystkie metody i pola
           danych bez modyfikatora dostępu traktowane są jako typu
           package. Metody (lub pola danych) typu package mogą być
           używane przez inne klasy danego pakietu.



                                                              38 z 137
Klasy - pola i metody – modyfikatory dostępu



Modyfikator   klasa    podklasa   pakiet   wszędzie
private            X
protected          X       X          X
public             X       X          X         X
package            X                  X




                                            39 z 137
Klasy – pola - modyfikatory właściwości
  Nazwa                           Opis
final       Oznacza, że wartość może dla tego pola zostać
            zainicjonowana wyłącznie podczas tworzenia
            obiektu i nie może być później modyfikowana. Pole
            danych jest stałą.
static      Pole danych odnosi się klasy a nie obiektu, co
            oznacza, że dla wszystkich obiektów danej klasy
            pole statyczne ma tę samą wartość.
transient   Nie jest trwałą częścią obiektu i nie zostanie
            zachowane przy archiwizacji obiektu.
volatile    Może modyfikowane asynchronicznie, przez
            konkurencyjne   wątki  w      programach
            wielowątkowych.
                                                    40 z 137
Klasy – pola - przykłady
                              public class Test
class Pole                    {
{                               int poleFinal;
                                Pole pole1 = new Pole();
   private int prywatne;
                                void testujPola() {
   protected int chronione;         pole1.prywatne = 1;
   public int publiczne;            pole1.chronione = 1;
   final int finalne = 0;           pole1.publiczne = 1;
   static int statyczne;            poleFinal = pole1.finalne;
                                    pole1.finalne = 1;
   int pakietowe;
                                    pole1.statyczne = 1;
}                                   pole1.pakietowe = 1;
                                }
                              }


                                                          41 z 137
Klasy – pola - przykłady
class Pole
{
   static int statyczne = 0;
}
public class Test
{
  Pole pole1 = new Pole();
  Pole pole2 = new Pole();
  void testujPola() {
      System.out.println("Wywołanie   poprzez klasę:" + Pole.statyczne);
      System.out.println("Wywołanie   poprzez obiekt:" + pole1.statyczne);
      pole2.statyczne = 2;
      System.out.println("Wywołanie   poprzez obiekt:" + pole1.statyczne);
      Pole.statyczne = 100;
      System.out.println("Wywołanie   poprzez obiekt:" + pole2.statyczne);
  }
}
                                                                        42 z 137
Klasy – metody – definicja i nazewnictwo

Metoda jest zbiorem instrukcji (blokiem kodu) przypisanych
 do jednej przestrzeni nazw mającej właściwość
 wielokrotnego wykorzystania.
    Metodą od której rozpoczynane jest
    wykonywanie umożliwienie wielokrotnego wywołania
Celem metod jest aplikacji jest:
  tego samego fragmentu kodu poprzez podanie jego nazwy.
         public static void main (String args[])

Metody mogą {być definiowane w dowolnym miejscu klasy.
            }
Metody nie zwracające wartości noszą nazwę procedur, a
  metody zwracające wartości noszą nazwę funkcji.

                                                   43 z 137
 Klasy – metoda - deklaracja
[modyfikatory] TypZwracanejWartości nazwaMetody([Parametry])
{
   //treść metody
 }

        Nazwa                             Opis
 modyfikatoryPola      Określa tryb dostępu (np.         private)      i
                       właściwości metody (np. static)
 TypZwracanejWartości Specyfikuje typ zwracanej wartości przez
                       metodę – void jeśli metoda nie zwraca
                       wartości.
 NazwaMetody           Określa nazwę deklarowanej metody.

 Parametry             Są zmiennymi przekazywanymi do metody
                       wykorzystywanymi przez jej instrukcję

                                                            44 z 137
Klasy – metody - modyfikatory dostępu

Są wspólne dla pól danych i metod
 Nazwa                                Opis
public     Wszystkie klasy mają dostęp do pól danych i metod public.
private    Dostęp do metod i pól danych posiadają jedynie inne metody
           tej samej klasy.
protected Metoda lub pole danych protected lub może być używana
           jedynie przez metody swojej klasy oraz metody wszystkich jej
           klas pochodnych.
package    Jest to modyfikator domyślny, wszystkie metody i pola
           danych bez modyfikatora dostępu traktowane są jako typu
           package. Metody (lub pola danych) typu package mogą być
           używane przez inne klasy danego pakietu.



                                                              45 z 137
Klasy - pola i metody – modyfikatory dostępu



Modyfikator   klasa    podklasa   pakiet   wszędzie
private            X
protected          X       X          X
public             X       X          X         X
package            X                  X




                                            46 z 137
Klasy – pola - modyfikatory właściwości

   Nazwa                               Opis
final        Oznacza, że definicja metody jest ostateczna i nie jest
             możliwe jej przesłanianie podczas dziedziczenia.
static       Metoda odnosi się klasy a nie obiektu, co oznacza, że
             metodę można wywoływać dla klasy bez konieczności
             tworzenia obiektów tej klasy.
abstract     Definicja metody zawiera jedynie deklarację, wskazując, że
             każda dziedzicząca klasa musi posiadać jej implementację.
synchronized Wykorzystywany     w     programach wielowątkowych,
             zapewniający wykonanie wszystkich metod dla jednego
             wątka oznaczonych tym modyfikatorem przed dostępem
             do nich kolejnego wątka.
native       Metoda jest napisana w innym języku niż Java.


                                                             47 z 137
Klasy – metody - przykłady
public Nauczyciel dodaj() throws IOException
 {
    PobieranieDanych tym = new PobieranieDanych();
    tym.dodajNauczyciel();
    if (tym.czyPracuje.equals(""))
       return new Nauczyciel(tym.imie, tym.nazwisko,
             tym.wiek);
    else
       return new Nauczyciel(tym.imie, tym.nazwisko,
             tym.wiek, tym.pracuje, tym.pensja);
 }
     Słowo kluczowe po którym podajemy
     zwracaną przez funkcje wartość
                                                 48 z 137
 Klasy – metody - przykłady

public static void zapiszDaneNauczycieli(ArrayList daneNauczycieli)
throws IOException
        {
           FileWriter plikNauczyciele = new FileWriter("nauczyciele.txt");
           Object zapiszDane[] = daneNauczycieli.toArray();
           String dane;
              for (int i = 0; i < zapiszDane.length; i++)
              {
                Nauczyciel nauczyciel = (Nauczyciel) zapiszDane[i];
                dane = nauczyciel.przygotujInformacje();
                plikNauczyciele.write(dane);
       }
       plikNauczyciele.close();
  }


                                                                49 z 137
 Klasy – metody - przykłady
public void usuwanieOsoby(ArrayList parOsoba, int parPozycjeWyszukane[])
  throws IOException
 {
   PobieranieDanych tym = new PobieranieDanych();
   if (tym.czyUsunac() == true)
    {
      for (int i = 0, wielkoscZmniejszenia = 0; i < this.iloscZnalezien; i++,
        wielkoscZmniejszenia++)
      {
         parOsoba.remove(parPozycjeWyszukane[i] -
                   wielkoscZmniejszenia);
         }
      System.out.println("Pozycje skasowane");
    }
 }


                                                                  50 z 137
Klasy – metody - przeciążenie
Przeciążanie metod polega na definiowaniu metod o tych
  samych nazwach, rozróżnianych na podstawie ilości lub
  typów parametrów. Umożliwia to wywołanie odpowiedniej
  metody w zależności od parametrów wywołania. Nie
  możliwe jest rozróżnianie metod na podstawie zwracanych
  przez nie typów wartości.



Przeciążanie umożliwia posiadanie definicji szeregu metod
  wykonujących różne instrukcje, ale posiadające tą samą
  nazwę. Znacząco ułatwia to programowanie i poprawia
  przejrzystość kodu.

                                                  51 z 137
Klasy – metody – przeciążenie
Przykład

public Prostokąt(double parBok1) {
   atrNazwa = "Kwadrat";
   atrBokLubPromień = parBok1;
 }

 public Prostokąt(double parBok1, double parBok2) {
   atrNazwa = "Prostokąt";
   atrBokLubPromień = parBok1;
   atrBok2 = parBok2;
 }
                                                      52 z 137
Klasa – konstruktor – definicja



Konstruktor jest metodą wywoływaną w trakcie
 tworzenia obiektu, służącą głównie inicjalizacji
 wartości pól obiektu.



Konstruktor posiada identyczną nazwę z nazwą
  klasy i podobnie jak pozostałe metody może być
  przeciążany.

                                             53 z 137
Klasa – konstruktor – definicja


Konstruktor jest metodą wywoływaną w trakcie
 tworzenia obiektu, służącą głównie inicjalizacji
 wartości pól obiektu.



Konstruktor posiada identyczną nazwę z nazwą
  klasy i podobnie jak pozostałe metody może być
  przeciążany.


                                             54 z 137
Klasa – konstruktor – założenia


Gdy klasa nie posiada zdefiniowanego konstruktora
  wykonywany jest domyślny konstruktor nadklasy.



Za pomocą słowa kluczowego super możliwe jest
  wywołanie konstruktora nadklasy.

Słowo kluczowe this oznacza odwołanie do
  aktualnego obiektu.
                                           55 z 137
Klasa – konstruktor – przykład

public class Student extends Osoba
{
public Student (String parImie, String parNazwisko, int
  parWiek, int parNrIndeksu, double parSrednia)
  {
         super(parImie, parNazwisko, parWiek);
         this.nrIndeksu = parNrIndeksu;
         this.srednia = parSrednia;
  }
}




                                                          56 z 137
Klasa – konstruktor – przykład
public abstract class Osoba
{
  protected String imie;
  protected String nazwisko;
  protected int wiek;
  public Osoba ()
  {
  }
  public Osoba (String parImie, String parNazwisko, int parWiek)
  {
      this.imie = parImie;
      this.nazwisko = parNazwisko;
      this.wiek = parWiek;
  }
                                                        57 z 137
Obiekt – definicja i koncepcja
Obiekt jest abstrakcją czegoś w dziedzinie problemu, odzwierciedlającą
  zdolności systemu do przechowywania informacji o tym, interakcji z
  tym czymś, lub obie te rzeczy.

Obiekt programistyczny jest modelem rzeczywistego obiektu, np.:
  student czy nauczyciel. Jest swego rodzaju nowym typem danych.

Obiekt jest generowany na podstawie wzorca klasy, będącej abstrakcją
  grupy obiektów o podobnej charakterystyce.

Obiekt =
      (identyfikakacja) - nazwa
       + stan (pola)
       + zachowanie (metody)

                                                             58 z 137
Obiekt - klasyfikacja
• Obiekty interfejsu użytkownika
   – Użytkownik programu kontaktuje się bezpośrednio z nimi
   – Nazywane są czasami widgets (window gadgets)
   – Przykłady: przyciski, listy wyboru, listy przewijane
• Obiekty środowiska operacyjnego
   – Są kontrolowane przez system operacyjny
   – Udostępniają usługi innym obiektom
• Obiekty zadaniowe
   – Dokumenty
   – Multimedia
   – Obiekty dziedziny przedmiotowej – np.: faktura, konto, pracownik

                                                              59 z 137
  Obiekt – deklaracja, inicjalizacja, definicja
• Deklaracja
    – TypObiektu NazwaObiektu;
    – Przykład: Nauczyciel nauczyciel1;
• Inicjalizacja
    – NazwaObiektu = new NazwaObiektu(ParametryKonstruktora);
    – Przykład: nauczyciel1 = new Nauczyciel(” Jan”, ”Adamski”, 29);
• Definicja
    – TypObiektu NazwaObiektu = new
      NazwaObiektu(ParametryKonstruktora);
    – Przykład
        Student student1 = new Student(tym.imie, tym.nazwisko, tym.wiek,
        tym.nrIndeksu, tym.srednia);


                                                                       60 z 137
Obiekt – odwołanie do pól i metod
Odwoływanie do pól i metod obiekty następuje za pomocą
  operatora „.”

Przykłady:
•   imie = parImie;
•   this.imie = noweDane.imie;
•   tym.czyPracuje.equals("");
•   UzupełnijAtrybuty();
•   System.out.println(wyswietlanyTekst);
•   tym.wiek = Integer.parseInt(dane);
•   OperacjePlikowe.wczytajDaneNauczycieli(nauczyciele);
•   nauczyciele.add(dodawany.dodaj());
•   daneNauczycieli.add(new Nauczyciel(tym.imie, tym.nazwisko, tym.wiek, tym.pracuje,
    tym.pensja));
                                                                         61 z 137
 Związki pomiędzy obiektami i klasami

   Bardzo rzadkie są przypadki, aby obiekty funkcjonowały zupełnie
        niezależnie od siebie Można wyróżnić 2 rodzaje związków pomiędzy
        nimi.

   Asocjacja

   Związek o charakterze strukturalnym
   Wskazuje, które obiekty wzajemnie się „znają”
          cd Data Model


               ZakładKarny                         Osadzony




Przykład: OperacjePlikowe.wczytajDaneNauczycieli(nauczyciele);

                                                              62 z 137
 Związki pomiędzy obiektami i klasami
Kompozycja

Związek o charakterze całość-część          cd Data Model
Ma mocniejszy charakter – jeden z obiektów nie może
     istnieć bez drugiego                      a)
Obiekty wzajemnie wiedzą o swoim istnieniu              PolisaUbezpieczeniow a

Można opisać ten związek słowem „ma”                                 1
  class Samochód
  {
    Podwozie podwozie = new Podwozie();
    Koło[] koło = new Koło[4];                                       1..*
    Karoserja karoserja = new Karoserja();
    void złóż()                                                  Składka
    {
      //instrukcje
    }
  }
                                                                    63 z 137
Obiekty i klasy - polimorfizm

Polimorfizm to możliwość nadawania tej samej nazwy
  różnym atrybutom i operacjom oraz wykonywania różnych
  procedur i akcji przez operacje o tych samych nazwach;
  pozwala na redukcję liczby nazw atrybutów i operacji.

Polimorfizm     umożliwia   rozróżnianie   operacji dla
  poszczególnych obiektów klas będących specyfikacjami
  nadklasy, gdy są wykonywane jako obiekt nadklasy.

Polimorfizm umożliwia podstawianie pod obiekt nadklasy
  obiektów podklas.


                                                 64 z 137
Obiekty i klasy – polimorfizm - przykład
                                   public class Koło extends FiguraPłaska
public abstract class FiguraPłaska {
{                                            public double obwód()
  protected String atrNazwa;                 {
  FiguraPłaska()                                      return 12.8;
  {
                                             }
     this.atrNazwa = "Nieznana";
                                    }
     }
                                   public class Kwadrat extends FiguraPłaska
  public double obwód()
                                   {
  {
                                            public double obwód()
      return 0.0;                           {
  }                                                  return 4.9;
}                                           }
                                   }
                                                                65 z 137
Obiekty i klasy – polimorfizm – przykład c.d
public class Wyświetl
{
   public static void wyświetlInf(FiguraPłaska parFigura)
   {
          System.out.println(parFigura.atrNazwa);
          System.out.println(parFigura.obwód());
   }
}
public class Program
{
          public static void main (String args[])
          {
                    Koło koło = new Koło();
                    Kwadrat kwadrat = new Kwadrat();
                    Wyświetl.wyświetlInf(koło);
                    Wyświetl.wyświetlInf(kwadrat);
          }
}
                                                            66 z 137
Obiekt - usuwanie

Java nie wymaga definiowania destruktorów. Jest tak dlatego, że
   istnieje mechanizm automatycznego zarządzania pamięcią (ang.
   garbage collection). Obiekt istnieje w pamięci tak długo, jak
   długo istnieje do niego jakakolwiek referencja w programie, w tym
   sensie, że gdy referencja do obiektu nie jest już przechowywana
   przez żadną zmienną obiekt jest automatycznie usuwany a
   zajmowana przez niego pamięć zwalniana.


W Javie zautomatyzowane istnieje możliwość deklaracji specjalnej
  metody finalize, która będzie wykonywana przed usunięciem
  obiektu z pamięci. Deklaracja takiej metody ma zastosowanie, gdy
  nasz obiekt np.: ma referencje do urządzeń wejścia-wyjścia.


                                                            67 z 137
Obiekt – usuwanie - przykład

protected void finalize () throws Throwable
{
  if (m_plik != null)
  {
      m_plik.close();
      m_plik = null;
  }
}


                                              68 z 137
Obiekty – rzutowanie – definicja i składnia


Rzutowanie     (ang.     casting)     polega   na
 skonwertowaniu zmiennej do pożądanego typu.
 Możliwe jest jedynie rzutowanie określonych
 typów na inne np.: double na int i odwrotnie.

W przypadku tworzonych obiektów możliwe jest
 jedynie rzutowanie nadklasy na podklasę
 (najczęstszy przypadek) i na odwrót. W drugim
 przypadku następuje utrata pól i metod
 niezdefiniowanych w nadklasie.
                                           69 z 137
Obiekty – rzutowanie – przykład
public class Koło extends FiguraPłaska
{
  // wcześniejsze instrukcje
   double pole()
   {
       return 34.1;
   }
}
public class Wyświetl
{
   public static void wyświetlInf(FiguraPłaska parFigura)
   {
           Koło koło = new Koło();
           //wcześniejsze instrukcje
           koło = (Koło)parFigura;
           System.out.println(koło.pole());
   }
}

                                                            70 z 137
Obiekty – podstawowe typy
  Nazwa                        Opis
Object     Klasa znajdująca się na szczycie hierarchii,
           obiektowi typu Object może być przypisany
           dowolny obiekt.
String     String imię = new String(”Antoni”);
           Imie.equals("Koło");
Integer,   Integer dniUrlopu = new Integer(17);
Double
           iRok.toString() ;
           Integer.parseInt(br.readLine());
Date       Date data = new Date(2006, 1, 14);
           Date dziś = new Date();
           dziś.getYear();
                                               71 z 137
Obiekty – podstawowe typy – String - metody

         Nazwa                                      Opis
equals (Object object)       Porównuje napis do obiektu.
indexOf(String str, int      Zwraca pozycję pierwszego znalezionego napisu
fromIndex)                   rozpoczynając szukanie od podanego indeksu.
length()                     Zwraca długość napisu.
replace(char oldChar,        Zwraca nowy tekst z zamienionymi wszystkimi
char newChar)                wystąpieniami oldChar na newChar.
substring                    Zwraca nowy napis który jest fragmentem
(int beginIndex,             wcześniejszego od indeksu początkowego do
int endIndex)                końcowego.
toLowerCase()                Konwertuje      wszystkie     znaki   napisu   na
toUpperCase()                małe/duże.
trim()                       Kopiuje napis z pominięciem początkowych i
                             końcowych spacji.

http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html        72 z 137
Obiekty – podstawowe typy – String - przykład
public class StringTest
{
  public static void main(String[] args){
     String dane = " Arkadiusz Radomski ";
     System.out.println("Dane: " + dane);
     System.out.println("Dane z małej litery: " + dane.toLowerCase());
     System.out.println("Nazwisko na pozycji:" +
         dane.indexOf("Radomski"));
     System.out.println("Znaki od 5 do 12:" + dane.substring(5,12));
     System.out.println("Długość napisu" + dane.length());
     System.out.println("Napis bez początkowych i końcowych spacji: " +
         dane.trim() + "****");
     }
}

                                                              73 z 137
 Obiekty – podstawowe typy – Date - metody

         Nazwa                                         Opis
after(Date when)             Sprawdza    czy   data        znajduje   się      po/przed
before(Date when)            wyspecyfikowanej dacie.
compareTo(Date               Sprawdza dwie daty pod kątem sortowania.
anotherDate)
equals(Object obj)           Sprawdza daty pod kątem identyczności.
getDate() getDay()           Zwraca odpowiednio: datę / dzień / godzinę / minuty /
getHours() getMinutes()      miesiąc / sekundy / czas / rok. Metody te oprócz
getMonth() getSeconds()      getTime() są zamienione przez metodę get klasy
getTime() getYear()          Calendar – np. Calendar.get(Calendar.DAY_OF_MONTH)
setDate(int date) , …,       Umożliwiają ustawienie odpowiedniego parametru daty.
setTime(long time)           Analogicznie jak wcześniej są one zamienione przez
                             metodę         klasy      Calendar       –      np.
                             Calendar.set(Calendar.SECOND, int seconds)
toString()                   Przekształca datę na napis.


 http://http://java.sun.com/j2se/1.4.2/docs/api/java/util/Date.html         74 z 137
Obiekty – podstawowe typy – Date - format

 Za format daty jest odpowiedzialna klasa DateFormat.

 Podstawowe style w zależności od długości prezentacji daty:
    – SHORT - np. 12.13.52 or 3:30pm
    – MEDIUM - np. Jan 12, 1952
    – LONG – np. January 12, 1952 or 3:30:32pm
    – FULL – np. Tuesday, April 12, 1952 AD or 3:30:42pm PST.

 Metoda getInstance() umożliwia pobranie lokalnego profilu
   wyświetlania daty. Metoda format(Date date) umożliwia
   przeformatowanie daty zgodnie z przyjętym profilem.



http://http://java.sun.com/j2se/1.4.2/docs/api/java/util/Date.html   75 z 137
Obiekty – podstawowe typy – Date - przykład
import java.util.*; import java.text.DateFormat;
public class TestData
{
    static Date data = new Date(1997,12,05,14,45,32);
    public static void main(String args[])
    {
       System.out.println("Wprowadzona data: " + data.toString());
       System.out.println("Rok: " + data.getYear());
       System.out.println("Czas: " + data.getTime());
       data.setYear(27);
       System.out.println("Nowa data: " + data.toString() );
       DateFormat formatDaty = DateFormat.getInstance();
       System.out.println("Data pokazana zgodnie z profilem lokalnym:\n"
        + formatDaty.format(data)) ;
       formatDaty = DateFormat.getDateTimeInstance(DateFormat.FULL,
            DateFormat.FULL);
       System.out.println("Data pokazana zgodnie z profilem \"najdłuższym\":\n"
        + formatDaty.format(data));
    }
}
                                                                                  76 z 137
Obiekty – podstawowe typy – Date - pozostałe klasy
 Pakiet java.util zawiera dwie klasy związane z datą i czasem systemowym:
      Calendar
      GregorianCalendar
 Obiekt reprezentujący kalendarz z aktualną datą i czasem można więc
      utworzyć na dwa sposoby:
      Calendar calendar = Calendar.getInstance();
      GregorianCalendar calendar = new GregorianCalendar ();
 Pobranie daty i czasu umożliwia metoda get():
      int dzien = calendar.get(Calendar.DAY_OF_MONTH);
      int miesiac = calendar.get(Calendar.MONTH)+1;
      int rok = calendar.get(Calendar.YEAR);
      int godz = calendar.get(Calendar.HOUR_OF_DAY);
      int min = calendar.get(Calendar.MINUTE);
      int sek = calendar.get(Calendar.SECOND);


                                                                77 z 137
Interfejsy - definicja

Interfejsy są szablonami klas wyrażającymi jedynie, że klasa
  która je implementuje musi zaimplementować wszystkie
  metody wyrażone w interfejsie. Dzięki temu wymuszają ich
  określoną składnię - zawieranie określonych procedur i
  funkcji przez klasę.

Każdy interfejs i klasa może implementować dowolną ilość
  interfejsów.

Interfejsy definiuje się podobnie do klas.


                                                    78 z 137
Interfejsy – definiowanie i wykorzystanie
Deklaracja: [modyfikatory] interface NazwaInterfejsu
{
   //deklaracje metod
}
Przykład: public interface Uruchamianie
             {
                int przykładowaMetoda(int y);
             }

Wykorzystanie: Deklaracja_klasy implements nazwa interfejsu
Przykład:
class Animacja extends Applet implements Uruchamianie
  {
  }
                                                         79 z 137
Programowanie obiektowe

        Kolekcje
Kolekcje - definicja
Kolekcje umożliwiają przechowywanie i zarządzanie w pamięci
  obiektami dowolnego typu. Są one kontenerami – elementami
  umożliwiającymi przechowywanie wielu obiektów.

Kolekcję są elementem zbliżonym funkcjonalnie do tablic z
  dwoma zasadniczymi różnicami:
   – Mogą przechowywać obiekty różnego typu
   – Automatycznie zarządzają wielkością kolekcji

Celem kolekcji jest umożliwienie dynamicznego dodawania i
  usuwania obiektów bez konieczności „zarządzania pamięcią
  im przydzielaną” – są „automatycznie dopasowującą się do
  zawartości tablicą”.

                                                   81 z 137
Kolekcje – struktura - interfejsy

            Collection                             Map



   Set         List         Queue               SortedMap



SortedSet
              Analogicznieutrzymująca możesekwencją),
              Ułożona Collection SortedSet zawierać
              Kolekcja, mapująca niereprezentuje grupę
              Kolekcja która klucze (identyfikatory)
                                 jak
                                 wykorzystywana jest do
              Interfejs kolekcja (nazywanaposortowane     to
              duplikatów utrzymującaelementówsłów w
              kolekcja zawieraćwielu kluczlista przed
              mogąca
              do wartości.nazywanych Przykłady użyć:
              przechowywania Każdy
              rosnąco                 Przykład: elementami.
              obiektów elementy. duplikatyposortowane
                              elementów.           musi być
                                                 elementów.
              rosnąco i może mapować jedynieproduktów
              Przykłady: kolekcje Posiada dodatkowe
              Wszystkiepary klucze/wartości. Przykład –
              słowniku.
              ich przetworzeniem. implementują jednej
              unikalny        kolekcja     palet    do
              poker, plan studentów, procesy uruchomione ten
              książka określający lista pracowników.
              przychodzących
              wartości. Koncepcja magazynu, rejestracja
              interfejs telefoniczna,zbliżona do Hashtable.
              operacje: dodawania, wyciągania i inspecji.
              na komputerze. do sposób przekazywania
              wejść osób do kabiny z nimi.
              Przykład - kolejka zadań do wykonania.
              kolekcji i manipulowaniabankomatem.

                                                   82 z 137
Kolekcje – przykładowe implementacje

                         List


         Vector                     ArrayList



  Implementuje kolekcję (listę) podobnie jak tablicę
                      kolekcję    (listę)   jako    klasa
  wektora (Vector), z tą różnicą, że dostęp do kolekcji
  automatycznie dopasowującą swoją wielkość do
  zawartości. Obiekty (czyt. nie ma wsparcia dla
  jest asynchroniczy mogą być pobierane analogicznie
  jak w tablicach za pomocą Dostęp do kolekcji typu
  dostępu synchronicznego).indeksu. Vektor jest klasą
  ArrayList przez kilka wątków nie jest bezpieczny.
  kontenera, która umożliwia dostęp synchroniczny –
  wielowątkowy.

                                                   83 z 137
Kolekcje – przykładowe implementacje c.d

                       Map


       HashTable                  TreeMap



                                     kolekcję   (mapę)
  HashTable<K,V> implementuje mapę z kluczami typu
  Implementuje      TreeMap(K,V)
  K i wartościami typu typu K i wartości (obiekty)
  przechowującą klucze V. Klasa definiująca klucz musi
  wspierać metody hashcode() oraz equals(). Ten typ
  typu V ułożone w rosnącej kolejności.
  kolekcji jest typem wspierającym synchroniczność –
  możliwy dostęp przez wiele wątków.


                                                84 z 137
Kolekcje – zdefiniowanie
Aby móc zdefiniować zmienną typu kolekcji należy najpierw
  zaimportować odpowiednie klasy:
   – wszystkie - import java.util.*;
   – konkretną - import java.util.Vector;

Deklaracja:
TypKolekcji [<TypWartości>] NazwaKolekcji = new TypKolekcji
  [<TypWartości>]();

Przykłady:
• ArrayList nauczyciele = new ArrayList();
• Vector<String>names = new Vector<String>();
• Map<String, Integer> m = new HashMap<String, Integer>();
                                                            85 z 137
Kolekcje – podstawowe metody

  Nazwa                             Opis
containsAll   Zwraca true jeśli docelowa kolekcja zawiera
              wszystkie elementy wyspecyfikowanej kolekcji.
addAll        Dodaje wszystkie elementy do kolekcji docelowej
              kolekcji wyspecyfikowanej.
removeAll     Usuwa wszystkie elementy kolekcji, które znajdują
              w wyspecyfikowanej kolekcji.
retainAll     Usuwa kolekcji wszystkie elementy, które nie są
              zawarte w wyspecyfikowanej kolekcji.

clear         Usuwa wszystkie elementy z kolekcji


                                                       86 z 137
Kolekcje – podstawowe metody c. d.
 Nazwa                           Opis
toArray   Powoduje utworzenie z kolekcji tablicy.
add       Powoduje dodanie elementu do kolekcji.
remove    Powoduje usunięcie elementu z kolekcji.
set       Umożliwia zmodyfikowanie elementu kolekcji.
get       Powoduje pobranie elementu kolekcji.
next      Powoduje przejście do kolejnego elementu kolekcji.
search    Umożliwia wyszukanie elementu w kolekcji poprzez
          zwrócenie jego pozycji.
sort      Powoduje posortowanie kolekcji.
reverse Powoduje odwrócenie kolejności elementów kolekcji.

                                                    87 z 137
Kolekcje – przykłady wykorzystania metod
• s1.containsAll(s2) ;
• names.add(firstname);
• nauczyciele.add(dodawany.dodaj());
• nauczyciele.clear();
• studenci.next();
• parOsoba.remove(parPozycjeWyszukane[i] -
  wielkoscZmniejszenia);
• Object listaStudentow[] = parStudenci.toArray();
• parOsoba.get(parPozycjeWyszukane[numerOsoby - 1]);
• a.set(i, a.get(j));
                                                       88 z 137
Kolekcje - przechodzenie
Przy wykorzystaniu pętli for-each możliwe jest przejście
  przez wszystkie elementy kolekcji oraz tablicy.

Składnia: for (TypWartości zmienna : nazwaKolekcji)
           {
             //instrukcje
           }

Przykład:
for (Object o : collection)
  System.out.println(o);

                                                      89 z 137
 Kolekcje – przykłady - Vector
import java.util.Vector;
public class PrzykładVector{
  public static void main(String[]args){
        Vector<String> imiona = new Vector<String>();
        String[] imionaL = {„Adam", „Jan", „Gosia", „Patryk" };
        for(String imie : imionaL){
            imiona.add(imie);
        }
  for(String imie : imiona){
        System.out.println(imie);
     }
  }
}
                                                            90 z 137
  Kolekcje – przykłady - ArrayList
public void wyswietlListaNauczycieli(ArrayList parNauczyciele)
  {
      Object listaNauczycieli[] = parNauczyciele.toArray();
      int licznikNauczyciele;
      System.out.println("\nL i s t a n a u c z y c i e l i :\n");
      for (licznikNauczyciele = 0; licznikNauczyciele < listaNauczycieli.length;
                   licznikNauczyciele++)
        {
           String wyswietlanyTekst, parPracuje;
            Nauczyciel nauczyciel = (Nauczyciel) listaNauczycieli[licznikNauczyciele];
            wyswietlanyTekst = licznikNauczyciele + 1 + ".";
            System.out.println(wyswietlanyTekst);
            nauczyciel.wyswietlInformacje();
        }
  }

                                                                          91 z 137
  Kolekcje – przykłady - Map
import java.util.*;
public class Freq {
  public static void main(String args[]) {
      Map<String, Integer>            m=
         new HashMap<String, Integer>();
    for (String a : args) {
         Integer freq = m.get(a);
         m.put(a, (freq == null ? 1 : freq + 1));
      }
      System.out.println(m.size() + " różnych słów:");
      System.out.println(m);
  }
}
                                                         92 z 137
Programowanie obiektowe

         Wyjątki
Definicja i koncepcja
Wyjątki (ang. exceptions) są sytuacją niestandardową
 (specjalną) związaną z działaniem programu, powodującą
 zawieszenie się lub niepoprawne wykonanie programu.

Java posiada mechanizm obsługi wyjątków umożliwiający
  odpowiednie zareagowanie w takiej sytuacji i uniknięcie
  zawieszenia lub niepoprawnego wykonania programu.

Przechwycenie wyjątku umożliwia przerwanie normalnego
  wykonywania programu i wykonanie instrukcji związanych z
  jego obsługą.



                                                  94 z 137
Przykłady sytuacji krytycznych

Istnieje szereg sytuacji krytycznych głównie związanych z:
• Operacjami na plikach:
    – Próba otwarcia pliku który nie istnieje,
    – Próba zapisania danych do pliku, do którego nie mamy
      uprawnień.
• Niekompatybilne konwersje typów (np. ClassCastException,
   NumberFormatException )
• Próba dostępu do elementu tablicy dalszym niż ostatni indeks
   (ArrayOutOfBoundsException)
• Brak obiektu odwołania (NullPointerException)



                                                     95 z 137
Struktura klas




                 96 z 137
Generowanie sytuacji wyjątkowych

Generowanie   (zgłoszenie)   wyjątku dokonujemy poprzez
  throw new Exception("..."), jako utworzenie obiektu
  typu Exception i przerywanie wykonania bieżącej metody.



Aby wskazać i poinformować JVM, że metoda może
  generować wyjątek typu Exception należy na jej końcu
  dodać słowa kluczowe throws Exception. Użycie tej frazy
  jest obowiązkowe, jeśli nasza metoda może generować
  wyjątek, np. dla metod posiadających instrukcję związane z
  I/O.


                                                    97 z 137
Generowanie sytuacji wyjątkowych - przykład
Przykład:
public class WywolajWyjatek
{
    static public void main(String args[]) throws Exception
    {
           Liczba liczba = new Liczba();
           liczba.dziel(1);
    }
}
class Liczba
{
    int m_i = 10;
    int dziel(float i) throws Exception
    {
           if (i/2 != 0)
                        throw new Exception("Liczba nieparzysta!");
           if (i == 0)
                        throw new Exception("Dzielenie przez zero!");
           return (int)(m_i/i);
    }
}
                                                                        98 z 137
Obsługa wyjątków - składnia
try
{
   //blok instrukcji gdzie może wystąpić wyjątek
}
catch (ObiektImplementujacyInterfejsThrowable nazwaZmiennej)
{
    //blok instrukcji obsługujących wystąpienia sytuacji wyjątkowej jest
    wykonywany tylko, gdy wystąpi wyjątek typu takiego jak typ zmiennej będącej
    parametrem bloku catch
}
…
finally //opcjonalnie
{
    // ten blok instrukcji jest wykonywany przed opuszczeniem sterowania, //nawet
    jeśli blok try zawiera instrukcję return lub spowodował //wystąpienie wyjątku
}
                                                                      99 z 137
Obsługa wyjątków - przykład
public class WywolajWyjatek
{
  static public void main(String args[]) throws Exception
  {
        Liczba liczba = new Liczba();
        try
        { liczba.dziel(1); }
        catch (Exception e)
        { e.printStackTrace(); }
       System.out.println("obsługa wyjątków działa");
  }
}
                                                    100 z 137
Obsługa wyjątków - przykład
public static void zapiszDaneNauczycieli(ArrayList daneNauczycieli)
  throws IOException
  {
      FileWriter plikNauczyciele = new FileWriter("nauczyciele.txt");
      Object zapiszDane[] = daneNauczycieli.toArray();
      String dane;
         for (int i = 0; i < zapiszDane.length; i++)
         {
           Nauczyciel nauczyciel = (Nauczyciel) zapiszDane[i];
           dane = nauczyciel.przygotujInformacje();
           plikNauczyciele.write(dane);
        }
        plikNauczyciele.close();
  }

                                                                101 z 137
Obsługa wyjątków - przykład

import java.io.*;
class WyjątekZapisz
{
   public static void zapisz(String ścieżka) throws IOException
   {
      FileWriter plik = new FileWriter(ścieżka);
      String dane = "Przykładowe Dane";
      plik.write(dane);
      plik.close();
   }
}



                                                             102 z 137
Obsługa wyjątków – przykład c. d.
public class Test
{
  public static void main(String args[]) throws IOException
  {
     try{
         WyjątekZapisz wyjątek = new WyjątekZapisz();
         wyjątek.zapisz("c:\\aaa1\\dane.txt");}
     catch (IOException ioe){
            System.out.println(ioe.toString());
         }
     System.out.println("Program jest wykonywany dalej");
  }
}


                                                              103 z 137
Obsługa wyjątków - przykład
import java.io.*;
public class WyjątekWczytaj
{
   static File plik = new File("nieistniejacy.txt");
   public static void main(String args[]) throws IOException
    {
      try {
         FileInputStream wczytanie = new FileInputStream(plik);
         int dane;
         dane = wczytanie.read();
         wczytanie.close();
         }
       catch (IOException ioe){
             ioe.printStackTrace();
             System.out.println("Blad przy otwarciu pliku " + plik.getName());}
   }
}


                                                                                  104 z 137
Obsługa wyjątków – ważne metody

Ważne metody dla obiektów klasy Exception:
       Nazwa                              Opis
getClass() ;          Zwraca nazwę klasy wyjątku.
getMessage());        Zwraca opis wyjątku.
printStackTrace();    Powoduje wypisanie na ekranie ścieżki
                      wywołań do metody, w której wystąpił
                      wyjątek.

Przykład:
System.out.println("Przy operacji typu \"" + wyjątki[i] + "\"
wystąpił wyjątek: \n" + e.getClass() + "\n z następującą
informacją: " + e.getMessage());
                                                          105 z 137
Definiowanie własnych klas wyjątków - koncepcja
W Javie możliwe jest definiowanie własnych klas
 wyjątków dla obsługi sytuacji, uznawanych przez
 programistę za wyjątkowe.


Klasa, która ma być odpowiedzialna za obsługę wyjątków w
   swojej definicji musi być podklasą (dziedziczyć) z klasy
   Exception.


Aby wyjątki dla danej metody były obsługiwane przez naszą
  klasę wyjątków należy na końcu jej deklaracji dodać słowo
  kluczow throws oraz nazwę klasy obsługującej wyjątki –
  throws NazwaKlasyWyjątku.
                                                   106 z 137
Definiowanie własnych klas wyjątków - składnia
class NazwaKlasyWyjątku extends Exception
{
        NazwaKlasyWyjątku()
    {
    }
        NazwaKlasyWyjątku(String s)
        {
            super("\Tekst wyświetlany przez wyjątek: " + s);
        }
}

                                                         107 z 137
Definiowanie własnych klas wyjątków - przykład
class WyjątekŚrednia extends Exception
{
   WyjątekŚrednia()
   {
   }
   WyjątekŚrednia(String s)
   {
      super(s);
   }
}
                                            108 z 137
Definiowanie własnych klas wyjątków – przykład c. d.
class Student{
   double sumaOcen = 0; int ilośćOcen = 0; double średnia = 0;
   void operacjeŚrednia() throws WyjątekŚrednia {
       try {
         średnia = sumaOcen / ilośćOcen;
         if (średnia < 2)
         throw new WyjątekŚrednia("Średnia nie może być niższa niż 2");
         if (średnia > 5)
         throw new WyjątekŚrednia("Średnia nie może być wyższa niż 5");
         System.out.println("Średnia ocen wynosi:" + this.średnia);}
       catch(Exception e) {
          System.out.println("Wyjątek: " + e.getClass() + " z następującym
         komentarzem - " + e.getMessage());}
   }
}

                                                                  109 z 137
Definiowanie własnych klas wyjątków – przykład c. d.

public class TestWyjątki
{
  public static void main(String[] args) throws Exception
  {
      Student student = new Student();
      student.sumaOcen = Double.parseDouble(args[0]);
      student.ilośćOcen = Integer.parseInt(args[1]);
      student.operacjeŚrednia();
  }
}


                                                     110 z 137
Obsługa wielu wyjątków - koncepcja

Istnieje możliwość obsługi wielu wyjątków odnośnie jednego
   fragmentu kodu try w podzieleniu na konkretne ich typy –
   np. zarówno błędu braku pliku (obiekt typu IOException) do
   otwarcia oraz jego końca podczas wczytywania (obiekt typu
   EOFException).


W celu obsługi wielu wyjątków należy dla bloku try
 zdefiniować odpowiednie bloki catch z paramerami jako
 obiekty odpowiadające klasom wyjątków.



                                                     111 z 137
Obsługa wielu wyjątków - składnia

try
{
   //blok instrukcji gdzie może wystąpić wyjątek
}
catch (ObiektImplementujacyInterfejsThrowable nazwaZmiennej)
{
   //blok instrukcji obsługujących wystąpienia sytuacji wyjątkowej
}
catch (ObiektImplementujacyInterfejsThrowable nazwaZmiennej)
{
   //blok instrukcji obsługujących wystąpienia sytuacji wyjątkowej
}
…


                                                            112 z 137
Obsługa wielu wyjątków - przykład
class NieprawidłowościŚrednia extends WyjątekŚrednia
{
   NieprawidłowościŚrednia()
   {
   }
   NieprawidłowościŚrednia(int ilośćOcen, double średnia)
   {
      super(„\nNieprawidłowości średniej\n" + "Średnia
       wynosi zaledwie:" + średnia + "\n przy ilości
       zaliczonych przedmiotów poniżej minimum równemu:"
       + ilośćOcen);
   }
}
                                                   113 z 137
Obsługa wielu wyjątków – przykład c. d.
class Student{
…
 void operacjeŚrednia() throws Exception
   {
       try
       {
        …
        if ((ilośćOcen < 8) && (średnia < 3.5))
          throw new NieprawidłowościŚrednia(ilośćOcen, średnia);
          System.out.println("Średnia ocen wynosi:" +
                 this.średnia);
        …


                                                         114 z 137
Obsługa wielu wyjątków – inna wersja
public class TestWyjątki
{
  public static void main(String[] args) throws Exception {
      Student student = new Student();
      student.sumaOcen = Double.parseDouble(args[0]);
      student.ilośćOcen = Integer.parseInt(args[1]);
      try{ student.operacjeŚrednia(); }
      catch(NieprawidłowościŚrednia nś)
      { nś.printStackTrace(); }
      catch(WyjątekŚrednia wś)
      { wś.printStackTrace(); }
  }
}


                                                              115 z 137
Programowanie obiektowe

   Operacje wejścia - wyjścia
Koncepcja

Operacje wejścia wyjścia (ang. Input / Output, I/O) w Javie
  zrealizowane są za pomocą klas zawartych w pakiecie
  java.io.

Programy Javy używają strumieni (ang. streams) do
  wykonywania operacji wejścia /wyjścia, z tym, że zarówno
  źródłem wejściowym (ang. input source) jak i źródłem
  wyjściowym (ang. output source) może być wszystko, co
  zawiera dane:
   – pliki,
   – łańcuchy znakowe – również pobierane z klawiatury,
   – pamięć.

                                                   117 z 137
Koncepcja
Począwszy od wersji Javy 1.1 zdefiniowano nowe,
  przeznaczone do poprawnego czytania strumienie znaków
  w standardzie Unicode.

Klasy obsługujące operacje I/O w Javie mają model
   warstwowy, co oznacza, że poszczególne klasy posiadają
   stosunkowo ograniczone możliwości, ale możliwe jest
   uzyskanie ich odpowiednich właściwości poprzez dodanie
   wyspecjalizowanych klas. Przykładowo, klasa wejściowa
   InputStream nie jest buforowana (co oznacza, że
   jednocześnie może być pobierany wyłącznie jeden znak),
   ale dzięki klasie BufferedInputStream możliwe jest
   dodanie buforowania do klasy InputStream.

                                                  118 z 137
Przegląd klas strumieni - InputStream

Jest abstrakcyjną nadklasą dla szeregu klas (np.:
  FileInputStream,    SequenceInputStream)  dostarczającą
  podstawowy interfejs programistyczny wraz z częściową
  implementacją strumieni wejściowych. Klasa InputStream
  definiuje metody przeznaczone do:
   – czytania bajtów lub tablic bajtów
   – zaznaczenia pozycji w strumieniu
   – opuszczenia części bajtów z wejścia
   – znajdowania liczby dostępnych bajtów do czytania i
     resetowania bieżącej pozycji w strumieniu

                                                 119 z 137
Przegląd klas strumieni - InputStream c.d.


Podczas tworzenia nowego strumienia wejściowego, następuje
  jego automatyczne otworzenie.


Strumień wejściowy zostaje zamknięty:
   – poprzez użycie metody close
   – gdy do obiektu InputSteam nie         ma   już    żadnych
     referencji i jest usuwany z pamięci




                                                      120 z 137
Przegląd klas strumieni - OutputStream
Klasa OutputStream podobnie jak klasa InputStream jest
   abstrakcyjną nadklasą dla wielu klas (np.: FileOutputStream,
   PrintStream). Dostarcza ona minimalny interfejs programistyczny
   wraz z częściową implementacją strumieni wyjściowych.


Klasa ta definiuje metody zapisywania bajtów lub tablic bajtów.


Strumień wyjściowy jest automatycznie otwierany, gdy jest tworzony.
   Jego zamknięcie następuje:
   – poprzez użycie metody close,
   – gdy do obiektu OutputStream nie ma już żadnych referencji i
     jest usuwany z pamięci (ang. garbage collected).

                                                         121 z 137
Przegląd klas strumieni – strumienie znakowe

W wersji Java 1.1 do pakietu java.io dodano nowe klasy do
 czytania strumieni zawierających znaki (ang. character
 streams). Klasy te działają podobnie, jednak zamiast czytać i
 zapisywać bajty czytają i zapisują 2-bajtowe znaki Unicode.
 Ułatwia to pisanie programów niezależnych od standardu
 kodowania znaków.


Strumienie znakowe nie są użyteczne tam gdzie dane są
   zapisywane binarnie, np.: odczytywanie plików dźwiękowych
   czy implementacja protokołów sieciowych.


                                                    122 z 137
Przegląd klas strumieni – strumienie znakowe

Klasy:
  – Do odczytu – Reader, np.:
     • BufferedReader
     • FileReader
  – Do zapisu – Writer, np.:
     • BufferedWritter
     • FileWritter


                                      123 z 137
 Strumienie wejściowe – klawiatura

InputStreamReader – umożliwia odczytanie pojedynczych znaków.


Deklaracja:
InputStreamReader nazwaStrumienia = new InputStreamReader(InputStream in);
Przykład:
InputStreamReader is = InputStreamReader(System.in);
Metody:
    – close() – zamyka strumień
    – getEncoding() – zwraca nazwę systemu kodowania
    – read() – umożliwia wczytanie pojedynczego znaku



                                                                    124 z 137
http://java.sun.com/j2se/1.4.2/docs/api/java/io/InputStreamReader.html
 Strumienie wejściowe – klawiatura
BufferedReader – umożliwia odczytanie znaków, które są buforowane co
  daje możliwość odczytywania również tablic i całych linii.


Deklaracja:
BufferedReader nazwaStrumienia = new BufferedReader(Reader in);
Przykład:
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Metody:
    – close() – zamyka strumień
    – getEncoding() – zwraca nazwę systemu kodowania
    – read() / readLine() – umożliwia wczytanie pojedynczego znaku / całej
                             linii

http://java.sun.com/j2se/1.4.2/docs/api/java/io/BufferedReader.html 125 z 137
Strumienie wejściowe – klawiatura - przykład

BufferedReader br = new BufferedReader(new
  InputStreamReader(System.in));

public void dodajOsoba () throws IOException
  {
      System.out.println("");
      System.out.print("Podaj imie ");
      imie = br.readLine();
      System.out.print("Podaj nazwisko ");
      nazwisko = br.readLine();
      System.out.print("Podaj wiek ");
      wiek = Integer.parseInt(br.readLine());
  }


                                                126 z 137
Strumienie wyjściowe – ekran


System.out.print() / System.out.println() / – umożliwiają
  wypisanie na ekranie znaków. Ponadto instrukcja println
  powoduje przejście do nowego wiersza.


Przykład:
System.out.println("Jaką operację chcesz wykonać (wpisz numer):");




                                                         127 z 137
  Strumienie wyjściowe – ekran

PrintWriter – klasa umożliwiająca wypisanie na ekranie znaków. Zastępuje
   metody klasy System.out.


Deklaracja:
PrintWriter nazwaStrumienia = new PrintWriter(OutputStream out, boolean autoFlush) ;
Przykład:
PrintWriter pw = PrintWriter(System.out, true) ;
Metody:
    – close()
    – getEncoding()
    – print() / println()


 http://java.sun.com/j2se/1.4.2/docs/api/java/io/FileWriter.html       128 z 137
 Strumienie wyjściowe – ekran - przykład

import java.io.*;
public class WypisanieDanych
{


    public static void main(String args[])
    {
        char[] wybór = {'1','2','3','4'};
        PrintWriter pw = new PrintWriter(System.out, true);
        pw.print("Jaką operację chcesz wykonać (wpisz numer):");
        pw.println(wybór);
    }
}

                                                          129 z 137
 Strumienie wejściowe – plik

FileReader – umożliwia odczytanie pojedynczych znaków z pliku.


Deklaracja:
FileReader nazwaStrumienia = new FileReader(String fileName);
Przykład:
FileReader fr = new FileReader(”c:\studenci.txt”);
Metody:
    – close() – zamyka plik
    – getEncoding() – zwraca nazwę systemu kodowania pliku
    – read() – umożliwia wczytanie pojedynczego znaku




http://java.sun.com/j2se/1.4.2/docs/api/java/io/FileReader.html   130 z 137
Strumienie wejściowe – plik - przykład
 public static void wczytajDaneStudentow(ArrayList daneStudentow) throws
 IOException
  {
    Object zapiszDane[] = daneStudentow.toArray();
    BufferedReader wczytanie = new BufferedReader(new
       FileReader("studenci.txt"));
    PobieranieDanych tym = new PobieranieDanych();
    String dane = new String();
    try
    {
    while (true) {
          dane = wczytanie.readLine();
            if (dane == null)
             break;
          tym.imie = dane;
                 …
                                                              131 z 137
Strumienie wejściowe – plik – przykład c. d.
          dane = wczytanie.readLine();
          tym.nazwisko = dane;
          dane = wczytanie.readLine();
          tym.wiek = Integer.parseInt(dane);
          dane = wczytanie.readLine();
          tym.nrIndeksu = Integer.parseInt(dane);
          dane = wczytanie.readLine();
          tym.srednia = Double.parseDouble(dane);
          daneStudentow.add(new Student(tym.imie, tym.nazwisko,
                tym.wiek, tym.nrIndeksu, tym.srednia));
        }
        wczytanie.close();
      } catch(EOFException e) {
        wczytanie.close();
      }
  }
                                                            132 z 137
 Strumienie wyjściowe – plik

FileWriter – umożliwia zapisywanie danych do pliku.


Deklaracja:
FileWriter nazwaStrumienia = new FileWriter(String fileName, boolean append);
Przykład:
FileWriter plikNauczyciele = new FileWriter("nauczyciele.txt");
Metody:
    – close() – zamyka plik
    – getEncoding() – zwraca nazwę systemu kodowania pliku
    – write() – zapisuje dane do pliku



http://java.sun.com/j2se/1.4.2/docs/api/java/io/FileReader.html       133 z 137
Strumienie wyjściowe – plik – przykład
public static void zapiszDaneNauczycieli(ArrayList daneNauczycieli)
  throws IOException
  {
      FileWriter plikNauczyciele = new
  FileWriter("nauczyciele.txt");
      Object zapiszDane[] = daneNauczycieli.toArray();
      String dane;
         for (int i = 0; i < zapiszDane.length; i++)
         {
           Nauczyciel nauczyciel = (Nauczyciel) zapiszDane[i];
           dane = nauczyciel.przygotujInformacje();
           plikNauczyciele.write(dane);
        }
        plikNauczyciele.close();
  }
                                                                134 z 137
 Strumienie wejściowe/wyjściowe – plik
RandomAccessFile – jest klasą umożliwiająca odczyt/zapis danych do pliku,
  począwszy od dowolnego miejsca.

Miejsce dostępu określa kursor o nazwie file pointer, od którego możliwy jest
   odczyt/zapis danych. Służą do tego dwie metody:
     –   getFilePointer – zwraca aktualną pozycję kursora
     –   seek(long pos) – umożliwia ustawienie pozycji kursora

Tryby dostępu:
     – ”r” – dostęp w trybie odczytu
     – ”rw” – dostęp w trybie zapisu
     – ”rws” – dostęp w trybie zapisu i odczytu z wymaganiem
                 synchronicznego zapisu danych i metadanych pliku
     – ”rwd” - dostęp w trybie zapisu i odczytu z wymaganiem
                 synchronicznego zapisu danych

                                                                   135 z 137
http://java.sun.com/j2se/1.4.2/docs/api/java/io/RandomAccessFile.html
 Strumienie wejściowe/wyjściowe – plik c. d.

Deklaracja:
RandomAccessFile nazwaStrumienia = new RandomAccessFile(String name,
  String mode);
Przykład:
RandomAccessFile raf = new RandomAccessFile ("nauczyciele.txt”,”rw”);
Metody:
    – close() – zamyka plik
    – read() / readLine() – wczytują dane z pliku
    – write(typ) / writeChars(String s) – zapisują dane do pliku




http://java.sun.com/j2se/1.4.2/docs/api/java/io/FileReader.html    136 z 137
Proszę o ewentualne pytania




Michał Kuciapski

								
To top