Slides:



Advertisements
Podobne prezentacje
Java Data Objects.
Advertisements

Wstęp do strumieni danych
Analiza wywołania i przebiegu przerwań w systemie Linux

ALLEGRO PIERWSZA GRA: WYŚCIG
C++ w Objectivity Marcin Michalak s1744. Pomocne pakiety: Data Definition Language (DDL). Standard Template Library (STL). Active Schema.
Java vs C# Michał Prządka Tomasz Nowak
STL - Standard Template Library Autor: Błażej Chodarcewicz rainbow.mimuw.edu.pl/~bc189380/STL/
OOPC++ - operatory1 Operatory class complex { private: double re, im; public: complex (double r, double i = 0) { re = r; im = i; } friend complex operator+
GUI Struktury Spotkanie integracyjne Nazwa wydziału: EAIiE Nazwa katedry: Informatyka Miejsce i data prezentacji: Kraków,
Zakres i zasięg deklaracji Zakres : obszar programu, w którym identyfikator może być użyty zakres globalny : cały program zakres lokalny : definicja pojedynczej.
Inżynieria oprogramowania Lecture XXX JavaTM – część IV: IO
Mirosław Ochodek Sponsorzy: JFace Jak jeszcze szybciej tworzyć interfejsy? ECESIS Eclipse Community Education Project An.
Gniazda komunikacji sieciowej w języku Java
Testowanie oprogramowania metodą badania pokrycia kodu
Łukasz Monkiewicz.
Współprogramy Plan: Motywacja Składnia Scenariusz obiektu współprogramu Przykłady Producent – konsument ( instrukcja attach ) Czytelnik -pisarze ( instukcja.
Czytanie, pisanie i rysowanie (czyli klasa I szkoły podstawowej)

142 JAVA – sterowanie i wątki public class A20 extends javax.swing.JApplet implements ActionListener { private int licznik = 0; private JTextField t =
Obsługa systemu wejścia-wyjścia
„Tworzenie aplikacji sieciowych w języku Java”
Projekt współfinansowany przez Unię Europejską w ramach Europejskiego Funduszu Społecznego Tworzenie aplikacji sieciowych w języku Java Networking Prezentacja.
Projekt współfinansowany przez Unię Europejską w ramach Europejskiego Funduszu Społecznego Tworzenie aplikacji sieciowych w języku Java Exceptions Prezentacja.
Projekt współfinansowany przez Unię Europejską w ramach Europejskiego Funduszu Społecznego Tworzenie aplikacji sieciowych w języku Java Threads Prezentacja.
Język C# Copyright, 2004 © Adam Czajka.
Przestrzeń System podstawowe klasy i klasy bazowe.
REKURENCJA.
Java 3 MPDI Programowanie obiektowe W7. import java.io.*; public class X { // kontrukcja throws – określenie jakie wyjątki może dana metoda // sygnalizować
PIO 3_2, Zofia Kruczkiewicz1 Wykład 3 – część druga Iteracyjno-rozwojowy cykl oprogramowania 3.
PRZELICZNIK DŁUGOŚCI w programie NetBeans IDE autorzy: Michał Mrozek i Marcin Mrugała 2012.
Krzysztof Manuszewski
W większości języków programowania biblioteki wejścia/wyjścia ukrywają szczegóły obsługi poszczególnych mediów pod abstrakcją strumienia (ang. stream).
Obsługa systemu wejścia-wyjścia
db4o Kacper Skory Marcin Talarek
Seminarium problemowe
Systemy wejścia i wyjścia Michał Wrona. Co to jest system wejścia i wyjścia? Pobierania informacji ze źródeł danych, zdolnych przesyłać sekwencje bajtów,
PIO 2_2, Zofia Kruczkiewicz1 Wykład 2 – część druga Iteracyjno-rozwojowy cykl oprogramowania 2.
PIO. Autor -Zofia Kruczkiewicz1 Wykład 1-część druga Wstęp do inżynierii oprogramowania. Cykle rozwoju oprogramowania (część biznesowa aplikacji) iteracyjno-rozwojowy.
Elektronika cyfrowa Prezentacja Remka Kondrackiego.
Podstawowe jednostki informacji, co to jest bit i bajt?
To jest bardzo proste  Lekcja nr 3
Tablice.
Podstawy programowania
TYPY STRUKTURALNE Tablice Tablicą nazywamy złożoną strukturę danych, która zawiera zbiór elementów tego samego typu.
Informatyka MTDI1 Wykład 11 Delphi Pascal c.d. Pliki Typ zbiorowy
Wykonała Sylwia Kozber
Antonie de Saint-Exupery
HTML Podstawy języka hipertekstowego Damian Urbańczyk.
Warsztaty C# Część 2 Grzegorz Piotrowski Grupa.NET PO
Warsztaty C# Część 3 Grzegorz Piotrowski Grupa.NET PO
SKALA MAPY Skala – stosunek odległości na mapie do odpowiadającej jej odległości w terenie. Skala najczęściej wyrażona jest w postaci ułamka 1:S, np. 1:10.
A. Jędryczkowski – 2006 ©. Tablica to struktura danych zawierająca zbiór obiektów tego samego typu i odpowiada matematycznemu pojęciu wektora (tablica.
Turbo Pascal umożliwia wykorzystanie w programach zbiorów teoriomnogościowych, których elementy muszą należeć do pewnego określonego typu. Typ zbiorowy.
Pliki elementowe – A. Jędryczkowski © 2007 Turbo Pascal umożliwia wykorzystanie w programach plików elementowych. Pliki takie zawierają informację zakodowaną
Budowa programu #include /*instrukcje preprocesora */ #include int main(void) { /*podstawowa funkcja programu */ int a=1; /*deklaracja i inicjalizacja.
W.K. (c) Bazy danych Access. 2W.K. (c) 2007 Baza danych - definicje Baza danych to zbiór informacji dotyczących określonego tematu (stanowiących.
Temat 5: Elementy meta.
Warsztaty użytkowników programu PLANS – Karwia06 Język makropoleceń JMP programu PLANS Część I mgr inż. Tomasz Zdun.
Instrukcja switch switch (wyrażenie) { case wart_1 : { instr_1; break; } case wart_2 : { instr_2; break; } … case wart_n : { instr_n; break; } default.
Instrukcja switch switch (wyrażenie) { case wart_1 : { instr_1; break; } case wart_2 : { instr_2; break; } … case wart_n : { instr_n; break; } default.
Obsługa strumienia wejścia/wyjścia /zajęcia nr 2/ printf – wyświetlanie scanf – ??? dla printf: \n - nowa linia \t - tabulator poziomy \b - znak cofania.
Instrukcje sterujące: W instrukcjach sterujących podejmowane są decyzje o wykonaniu tych czy innych instrukcji programu. Decyzje te podejmowane są w zależności.
Rozdział 3: Bezpieczeństwo w sieci opartej na systemie Windows 2000.
TROCHĘ HISTORII Marek Zając PO CO UŻYWAĆ OPENCL? Marek Zając.
1 Strumienie Hierarchie klas strumieniowych, strumienie bajtowe - klasy InputStream i OutputStream i ich metody, klasa File, strumienie plikowe, strumienie.
Piotr Czapiewski Wydział Informatyki ZUT.  Extensible Markup Language  Język znaczników  Human-readable and machine-readable  Niezależny od platformy.
Wprowadzenie Przygotował Adam Zawadzki
Wydział Elektroniki Kierunek: AiR Zaawansowane metody programowania Wykład 6.
Strumienie w języku Java Bartosz Walter InMoST Wielkopolska sieć współpracy w zakresie innowacyjnych metod wytwarzania oprogramowania Termin realizacji:
Zapis prezentacji:

JAVA – kontenery: interfejsy Collection i Map import java.util.*; public class Prog57 { public static void main(String [] arg) { Collection c = new ArrayList(); // ArrayList jest rodzaju List c.add("one"); c.add(new Integer(3)); System.out.println(c); // [one, 3, one] Collections.fill((List)c,"one"); // działa tylko dla List i pokrewnych, zastępuje istniejące elem. System.out.println(c); // [one, one, one] Collection c2 = new HashSet(); // HashSet jest rodzaju Set , będzie można dodawać tylko po jednym // elemencie każdego rodzaju c2.add("one"); c2.add("two"); c2.add(new Integer(3)); System.out.println(c2); // [two, one, 3] // odwzorowanie klucz--wartość Map m = new HashMap(); m.put("one","1"); m.put("two","2"); m.put(new Double(3.12),"3.12"); System.out.println(m); // {two=2, one=1, 3.12=3.12 } // klucz z lewej, wartość z prawej } } //Prog57 JAVA 2 w praktyce

JAVA – kontenery a typy przechowywanych obiektów import java.util.*; class MyType { float f = 3.3f; } public class Prog58 { public static void main(String [] arg) { ArrayList c = new ArrayList(); c.add("one"); c.add("two"); c.add(new Integer(3)); System.out.println(" rozmiar = " + c.size()); // 4 System.out.println(c); // [one, two, 3 ] String s = (String)c.get(1); // wyjmowanie elementu o nr System.out.println(s); // two // s = (String)c.get(2); // wyjątek , niezgodne typy c.add(new MyType()); // s = (String)c.get(4); // wyjątek , niezgodne typy }} //Prog58 ArrayList można traktować jak tablicę o rozszerzalnej pojemności JAVA 2 w praktyce

JAVA – inteligentny kontener dla klasy obiektów import java.util.*; class MyType { float f = 3.3f; MyType(float t) { f = t; } public float show(int nr) { return f; } } class MyTypeList { private ArrayList a = new ArrayList(); public void add(MyType t) { a.add(t); } public MyType get(int nr) { return (MyType)a.get(nr); } public int size() { return a.size(); } public float show(int nr) { return ((MyType)a.get(nr)).f; } public class Prog59 { public static void main(String [] arg) { MyTypeList m = new MyTypeList(); m.add(new MyType(2.1f)); m.add(new MyType(3.1f)); System.out.println(" rozmiar = " + m.size()); // 2 System.out.println(m.show(0)); // 2.1 MyType t = new MyType(0.2f); t = m.get(0); System.out.println(t.show(0)); // 2.1 } } //Prog59 JAVA 2 w praktyce

JAVA –implementacja metod interfejsu Collection System.out.println(a); // tak jak w l Object [] ob = l.toArray(); // zwraca Object [] z elem. kontenera System.out.println(ob.length); //--> 5 String [] s = (String [])l.toArray(new String [1]); // zwrot tab [] a.clear(); // usuwa wszystko z a System.out.println(a.isEmpty()); // czy jest pusta? true l.remove("lin1"); // usuń argument "lin1" System.out.println(l); // [lin2, lin3, lin1, lin1] a.add("lin1"); l.removeAll(a); // usuń wszystkie argumenty z l które są w a a.add("lin3"); l.retainAll(a); // część wspólna zbiorów pozostanie w l System.out.println(l.size() + " " + l); // -> 1 [lin3] System.out.println(l.contains("lin3")); // czy zawiera element -> true System.out.println(l.contains(a)); // czy zbiór a jest podzbiorem l? – //-> false } } //Prog60 import java.util.*; public class Prog60 { public static void prt(Collection c) { Iterator i = c.iterator(); // iterator while(i.hasNext()) System.out.print(" - " + i.next()); System.ot.println(); } public static void main(String [] arg) { LinkedList l = new LinkedList(); ArrayList a = new ArrayList(); l.add("lin1"); l.add("lin2"); l.add("lin3"); l.add("lin1"); l.add("lin1"); a.addAll(l); // kopiuje z L - > a Prog60.prt(a); // wypisuje z użyciem iteratora JAVA 2 w praktyce

JAVA – List : LinkedList i ArrayList Interfejs List – zachowuje kolejność elementów i dodaje nowe metody do interfejsu Collection, między innymi ListIterator pozwalający na przeglądanie listy w obu kierunkach i wstawiania i wyjmowania ze środka listy (zalecane dla LinkedList) ArrayList – najlepsza (szybka) w przypadku dostępu swobodnego do elementów LinkedList – szybkie wstawianie i usuwanie elementów,optymalny dostęp sekwencyjne do środka listy, posiada dodatkowe metody addFirst(), addLast(), getFirst(), getLast(), removeFirst(), removeLast() import java.util.*; public class Prog61{ public static void main(String [] arg) { LinkedList l = new LinkedList(); ArrayList a = new ArrayList(); l.add("lin3"); l.add("lin1"); l.add("lin2"); a.addAll(l); l.add(1,"lin1"); // na pozycję 1 int poz = l.indexOf("lin2"); // pozycja elementu ListIterator it = a.listIterator(); // start od początku it = a.listIterator(1); // start od pozycji 1 poz = a.lastIndexOf("lin1"); l.remove(2); //usuń element na pozycji 2 l.set(0,"mig"); // ustaw pozycje 0 na "mig" if(it.hasNext()) { Object t = it.next(); poz = it.nextIndex(); } if(it.hasPrevious()) { Object t = it.previous(); poz = it.previousIndex(); } it.add("su22"); it.set("tu154"); it.remove(); // usuń element } } //Prog61 JAVA 2 w praktyce

JAVA – Set : HashSet i TreeSet Interfejs Set – te same metody co interfejs Collection, ale różne zachowanie. Nie można przechowywać więcej niż jednego egzemplarza wartości każdego z obiektów. Elementy umieszczone w Set muszą definiować metodę equals() w celu możliwości ustalenia ich unikatowości. Set nie zapewnia utrzymywania obiektów w żadnym ustalonym porządku. (*)HashSet – dla zbiorów wymagających szybkiej lokalizacji elementu.Elementy muszą definiować metodę hashCode(). TreeSet – zbiór uporządkowany typu SortedSet, posiada metody comparator(), first(), last(), subSet(), headSet(), tailSet(). import java.util.*; class MyType implements Comparable { float f; String s; MyType(float a, String s) { this.s = s; f=a;} public boolean equals(Object o){ return (o instanceof MyType) && (f == ((MyType)o).f ) ; } public int hashCode() {return (int)f; } public int compareTo(Object o) { float ff = ((MyType)o).f ; return (ff > f? -1: (ff==f? 0:1) );} } equals - do ustalenia niepowtarzalności compareTo - do sortowania (kolejność) hashCode - dla tablic HashSet + equals public class Prog62{ public static void main(String [] arg) { Set a = new HashSet(); // Set a = new TreeSet(); a.add(new MyType(1.0f,"jeden")); a.add(new MyType(2.0f,"dwa")); a.add(new MyType(3.0f,"dwa")); // zgodnie z naszą //compareTo nie są te same a.add(new MyType(1.0f,"jeden")); // próba dodania tego //samego.. System.out.println(a.size()); // --> 3 } } //Prog62 JAVA 2 w praktyce

JAVA – TreeSet JAVA 2 w praktyce System.out.println(a.size()); // --> 4 System.out.println(a); // [ jeden 1.0, dwa 2.0, trzy 3.0, cztery 4.0 ] Object o1 = a.first(); // zwraca najmniejszy element Object o2 = a.last(); // zwraca największy element Iterator i = ((Collection)a).iterator(); Object m2 = i.next(); i.next(); Object m3 = i.next(); System.out.println(o1); System.out.println(o2); SortedSet a2 = a.subSet(m2,m3); // podzbiór od elem. do elem. < m3 System.out.println(a2); // [jeden 1.0, dwa 2.0 ] a2 = a.headSet(m3); // zwraca zbiór elementów < od podanego System.out.println(a2); // [jeden 1.0, dwa 2.0 ] a2 = a.tailSet(m3); // zwraca zbiór elementów > bądź == System.out.println(a2); // [trzy 3.0, cztery 4.0] } } //Prog63 import java.util.*; class MyType implements Comparable { float f; String s; MyType(float a, String s) { this.s = s; f=a;} public boolean equals(Object o){ return (o instanceof MyType) && (f == ((MyType)o).f ) ; } public int hashCode() {return (int)f; } public int compareTo(Object o) { float ff = ((MyType)o).f ; return (ff > f? -1: (ff==f? 0:1) ); } public String toString(){ return s + f; } } public class Prog63{ public static void main(String [] arg) { SortedSet a = new TreeSet(); a.add(new MyType(1.0f,"jeden")); a.add(new MyType(2.0f,"dwa")); a.add(new MyType(3.0f,"trzy")); a.add(new MyType(4.0f,"cztery")); JAVA 2 w praktyce

JAVA – Map: HashMap i TreeMap Interfejs Map – przechowuje pary klucz-wartość, można więc odnaleźć wartość podając klucz (*) HashMap – zalecana implementacja Map oparta na tablicy haszującej, wszystkie elementy muszą udostępniać metodę hashCode() TreeMap – zbiór typu SortedMap uporządkowany, posiada metody firstKey(), lastKey(), subMap(), headMap(), tailMap() import java.util.*; class Licznik { int i; public String toString(){ return " "+ i; } } public class Prog64{ public static void main(String [] arg) { HashMap ht = new HashMap(); Random ra = new Random(); for(int i = 0; i < 1000; i++) // losowanie liczby z zakresu 0-10 { Integer r = new Integer( Math.abs(ra.nextInt()%10) ); if ( ht.containsKey(r) ) // jeżeli jest klucz ((Licznik)ht.get(r)).i++; // zwiększ wartość else ht.put(r, new Licznik()); // jak nie ma załóż nowy klucz } System.out.println(ht); } //Prog64 JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów import java.util.*; class Subject implements Comparable { String s; float wsp; static int i; int nr ; Subject(String s, float w) {this.s = s; wsp = w; nr = i++; } public int hashCode() { return (int)wsp + s.hashCode() ; } public boolean equals(Object o) { return ((o instanceof Subject) && (s == ((Subject)o).s)); } public int compareTo(Object o) { String ss =( ((Subject)o).s); return( s.compareTo(ss)); } public String toString() { return " \n Subject["+ nr +"] " + s + "(" + wsp +")"; } } class Teacher { String s; int i; Teacher(String s, int i ) { this.s = s; this.i = i;} public String toString() { return s + " "+ i; } public boolean equals(Object o) { return ((o instanceof Teacher) && (s == ((Teacher)o).s) && (i == ((Teacher)o).i)); } } JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów public class Prog65{ public static void main(String [] arg) { HashMap ht = new HashMap(); //TreeMap ht = new TreeMap(); ht.put(new Subject("C++ ",4.0f), new Teacher("assistant",1)); ht.put(new Subject("Java ",5.0f), new Teacher("assistant",1)); ht.put(new Subject("Pascal ",3.0f), new Teacher("lecturer ",3)); ht.put(new Subject("Fortran",2.0f), new Teacher("professor",4)); ht.put(new Subject("Pascal ",4.0f), new Teacher("lecturer ",2)); // inny kod haszujący System.out.println("odwzorowanie klucz-wartosc "); System.out.println(ht); System.out.println("wartosci:\n "); // sprawdzenie czy zawiera wartość if (ht.containsValue(new Teacher("assistant",1))) // działa dzięki przesłonięciu equals() { Collection value = ht.values(); //wartości mogą się powtarzać stąd Collection System.out.println(value); } System.out.println("klucze:\n "); if (ht.containsKey(new Subject("Fortran",2.0f))) // działa dzięki przesłonięciu equals() Set key = ht.keySet(); // klucze są unikatowe zatem - Set System.out.println(key); key.removeAll(key); // zmiana kluczy zmienia odwzorowanie System.out.println(ht); // teraz puste }} } //Prog65 JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów Wersja Prog65 dla HashMap() Wersja Prog65 dla TreeMap() TreeMap() korzysta z compareTo(), i porządkuje elementy według String stąd Pascal 4.0 nie może być nowym kluczem JAVA 2 w praktyce

JAVA – implementacja Map dla kluczy własnych typów import java.util.*; class Subject implements Comparable { String s; float wsp; static int i; int nr ; Subject(String s, float w) {this.s = s; wsp = w; nr = i++; } public int compareTo(Object o) { String ss =( ((Subject)o).s); return( s.compareTo(ss)); } public String toString() { return " \n Subject["+ nr +"] " + s + "(" + wsp +")"; } } public class Prog66{ public static void main(String [] arg) { TreeMap ht = new TreeMap(); ht.put(new Subject("C++ ",4.0f),”1”); ht.put(new Subject("Java ",5.0f), ”2”); ht.put(new Subject("Pascal ",3.0f), ”3”); ht.put(new Subject("Fortran",2.0f), ”4”); ht.put(new Subject("Algol ",4.0f), ”5”); System.out.println("odwzorowanie klucz-wartość "); System.out.println(ht); Object small = ht.firstKey(); //pierwszy klucz System.out.println(small); Object high = ht.lastKey(); // ostatni klucz System.out.println(high); high = new Subject("Java ",5.0f); small = new Subject("C++ ",4.0f); SortedMap m1 = ht.subMap(small,high); // odwzorowanie o podzbiorze kluczy System.out.println(m1); // odwzorowanie o kluczach < od podanego m1 = ht.headMap(high); // odwzorowanie o kluczach > = od podanego m1 = ht.tailMap(small); }} //Prog66 JAVA 2 w praktyce

JAVA – niemodyfikowalne kontenery Collections i Map import java.util.*; class Subject implements Comparable { String s; float wsp; static int i; int nr ; Subject(String s, float w) {this.s = s; wsp = w; nr = i++; } public int compareTo(Object o) { String ss =( ((Subject)o).s); return( s.compareTo(ss)); } public String toString() { return " \n Subject["+ nr +"] " + s + "(" + wsp +")"; } } public class Prog67{ public static void main(String [] arg) { Map ht = new TreeMap(); ht.put(new Subject("C++ ",4.0f),"1"); ht = Collections.unmodifiableMap(ht); // ht.put(new Subject("C ",1.0f),"6"); zabronione }} //Prog67 Składnia dla Collection, Set i List: Collections. unmodifiableCollection(Collection c) Collections. unmodifiableList(List c) Collections. unmodifiableSet(Set c) JAVA 2 w praktyce

JAVA – obsługa błędów JAVA 2 w praktyce import java.util.*; // własna klasa wyjątku class MyException extends Exception { MyException() {} MyException(String message) { super(message);} } public class Prog68{ // definicja metody w której może wystąpić public static void function (int i) throws MyException { if (i == 1) throw new MyException(" jestem z f "); public static void main(String [] arg) { try { Prog68.function(1); } catch (MyException e) { System.out.println(" zlapalem swój"); // najpierw klasa pochodna } catch (Exception e) { System.out.println(" zlapalem "); // bazowa nie może być wcześniej } finally { // bo kod dla błędu typu MyException nie // byłby wykonywany System.out.println(" zlapalem czy nie to koniec"); } //Prog68 try { // blok chroniony ...............(tu może powstać wyjątek) } catch( Typwyjątku identyfikator) { } catch ( Typwyjątku identyfikator) { ........ } finally { czynności wykonywane za każdym razem } !! catch wykonywane jest tylko dla pierwszego pasującego JAVA 2 w praktyce

JAVA – klasa Exception JAVA 2 w praktyce Exception dziedziczy z Throwable zwracanie komunikatu: String getMessage() String getLocalizedMessage() opis Throwable łącznie dostępnymi szczegółami: String toString() ślad stosu wywołań: void printStackTrace() //std. wyjście void printStackTrace(PrintStream) // na podany strumień void printStackTrace(PrintWriter) // na podany strumień zapis w obiekcie Throwable informacje o stanie stosu: Throwable fillInStackTrace() import java.util.*; public class Prog69{ public static void main(String [] arg) { try { throw new Exception ("jestem wyjątkiem "); } catch (Exception e) { System.err.println(" getMessage = " + e.getMessage()) ; System.err.println(" getLMessage = " + e.getLocalizedMessage()); System.err.println(" toString = " + e); e.printStackTrace(System.err); } } //Prog69 JAVA 2 w praktyce

JAVA –wyrzucenie wyjątku na inny poziom import java.util.*; public class Prog70{ public static void f() throws Exception{ throw new Exception(" wygenerowany w f "); } public void fowner() throws Throwable { try{ f(); }catch (Exception e) { System.err.println("wewnątrz fowner "); e.printStackTrace(System.err); // przekazanie na wyższy poziom lub nowy Throwable A) throw e; B) // throw e.fillInStackTrace(); //nowy } } public static void main(String [] arg) throws Throwable{ try { Prog70 m = new Prog70(); m.fowner(); } catch (Exception e) { System.err.println("mam wyjątek w main"); e.printStackTrace(System.err); // ślad pamięta że e pochodzi z f() } }} //Prog70 A B JAVA 2 w praktyce

JAVA – wyjątki a przeciążanie import java.util.*; class AException extends Exception{} class BException extends Exception{} class CException extends Exception{} class SException extends AException{} interface First { void set() throws AException,BException; //void move() throws AException,BException; void open() throws AException; } class Second implements First { public void set() {System.out.println("");} // ok nic nie trzeba //zgłaszać // public void move() throws CException {} // nie można //dodawać niedziedziczących wyjątków public void open() throws SException {}; // taki można W metodzie przeciążonej można zgłaszać jedynie wyjątki z klasy podstawowej lub wyjątki które dziedziczą po wyjątkach klasy bazowej public class Prog71{ public static void main(String [] arg) { try { Second f = new Second(); f.set(); // f.move(); f.open(); } catch (Exception e) { System.err.println("mam wyjatek "); } } //Prog71 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia : klasa File import java.io.*; import java.util.*; class DirFilter implements FilenameFilter{ // to klasa reprezentująca filtr String s; DirFilter(String s) { this.s = s;} public boolean accept(File dir, String name) { // obcięcie informacji o ścieżce String f = new File(name).getName(); // inaczej File x = new File(name); f = x.getName(); return f.indexOf(s) != -1; } // jeżeli dany podciąg nie występuje indexOf zwraca -1 } // zatem wynik false public class Prog72{ public static void main(String [] arg) { File path = new File("."); // ustawia na bieżący katalog String [] list; if( arg.length == 0 ) list = path.list(); // wszystkie pliki i katalogi else list = path.list(new DirFilter(arg[0])); // jeśli arg np "java” w list będą tylko // katalogi i pliki z takim ciągiem znaków w nazwie for(int i = 0; i < list.length; i++) // list używa funkcji accept System.out.println(list[i]); }} //Prog72 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: klasa File public class Prog73{ public static void fileHistory(String name) { File f = new File(name); System.out.println( " \nFile location: " + f.getAbsolutePath() + " \nRead ready ?: " + f.canRead() + " \nReadOnly ? : " + !(f.canWrite()) + " \nName : " + f.getName() + " \nParent ? : " + f.getParent() + " \nLength ? : " + f.length() + " \nModified ? : " + f.lastModified()); } public static void main(String [] arg) { File path; if (arg.length != 0) path = new File(arg[0]); // pobranie ścieżki katalogu else path = new File("."); // domyślnie bieżący String [] list; File current; list = path.list(); System.out.println(" Listing of " + path.getAbsolutePath()); for(int i = 0; i < list.length; i++){ current = new File(list[i]); if (current.isDirectory()) System.out.println("directory "+ list[i]); if (current.isFile()) Prog73.fileHistory(list[i]); } } //Prog73 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: klasa File if (arg.length == 3) { dpath = new File(arg[0]); f1path = new File(arg[0]+"\\"+arg[1]); f2path = new File(arg[0]+"\\"+arg[2]); try{ if (!dpath.exists()) dpath.mkdirs(); // tworzy katalog f1path.createNewFile(); File f3path = new File(arg[0]+"nowy.dat"); f3path.createNewFile(); // nowy plik f3path.renameTo(f2path); // zmiana nazwy } catch (IOException e ) { // wymagana obsługa System.err.println(" Error occur in block 1 " ); } System.out.println("listing:"); list = dpath.list(); for(int i =0; i< list.length;i++) System.out.println(list[i]); f1path.delete(); System.out.println("usunięte"); for(int i =0; i< list.length;i++) System.out.println(list[i]); }catch (Exception e ) { System.err.println(" Error occur in block 2 " ); } }}} //Prog74 import java.io.*; import java.util.*; class DirFilter implements FilenameFilter{ String s; DirFilter(String s) { this.s = s;} public boolean accept(File dir, String name) { String f = new File(name).getName(); return f.indexOf(s) != -1; } } public class Prog74{ public static void main(String [] arg) { File dpath, f1path, f2path; String [] list; JAVA 2 w praktyce

System.out jest opakowany w PrintStream !!! JAVA – System wejścia - wyjścia: hierarchia klas dla strumieni bajtowych InputStream (abstrakcyjna) OutputStream (abstrakcyjna) ByteArrayInputStream (tablica jako źródło) ByteArrayOutputStream(tworzy bufor w pamięci) StringBufferInputStream (string jako źródło) Deprecated!! FileInputStream (plik jako źródło) FileOutputStream PipedInputStream (potok w wielowątkowych) PipedOutputStream (potok w wielowątkowych) SequenceInputStream(konwersja dwóch strumieni w jeden) klasy dekoratory (zapewniające użyteczny interfejs): FilterInputStream (abstrakcyjna) FilterOutputStream(abstrakcyjna) DataInputStream (dla danych typu podstawowego) DataOutputStream BufferedInputStream (dla strumieni buforowanych) BufferedOutputStream PrintStream (formatuje dane wyjściowe) LineNumberInputStream (śledzi numery wierszy) PushbackInputStream (umożliwia cofanie do strumienia ostatniego znaku) System.out jest opakowany w PrintStream !!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog75{ public static void main(String [] arg) { boolean zapis = true; try { FileOutputStream fileOut = new FileOutputStream("c:\\jdk\\moj.dat"); int [] dane = { 2, 45, 158 }; for(int i = 0; i<dane.length; i++) FileOut.write(dane[i]); fileOut.close(); } catch (IOException e ) { zapis = false; System.err.println("błąd zapisu"); } if(zapis) { FileInputStream fileInp = new FileInputStream("c:\\jdk\\moj.dat"); boolean eof = false; while(!eof) { int value = fileInp.read(); if (value != -1) System.out.println(" "+value); else eof = true; } fileInp.close(); } catch (IOException e ) { System.err.println("błąd odczytu"); } } } } //Prog75 Strumienie wyjścia powiązane z plikami nadpisują istniejące pliki !!!!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog76{ public static void main(String [] arg) { boolean zapis = true; boolean eof = false; byte [] tablica = { 1,2,3,4,5,6,7,8,9,10 }; try { ByteArrayInputStream inp = new ByteArrayInputStream(tablica); FileOutputStream fileOut = new FileOutputStream("c:\\jdk\\moj.dat"); BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); // fileout będzie buforowany bufOut.write(tablica[0]); //-> 1 bufOut.write(tablica,1,2); // z tablicy od elementu 1 zapisze 5 bajtów --> 2,3 eof = false; while(!eof) {byte value = (byte)inp.read(); // read zwraca w formacie int if (value != -1) bufOut.write(value); //-> 1,2,3,4,5,6,7,8,9,10 else eof = true; } bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { ByteArrayOutputStream out = new ByteArrayOutputStream(30); // tworzy 30 bajtowy bufor w pamięci BufferedInputStream bufInp = new BufferedInputStream(new FileInputStream("c:\\jdk\\moj.dat")); eof = false; while(!eof) { int value = bufInp.read(); if (value != -1) out.write(value) ; // zapis do bufora bufInp.close(); byte [] tab = out.toByteArray(); // utworzenie tablicy o zawartości bufora for(int i =0; i < tab.length; i++) System.out.println(tab[i]); } catch (IOException e ) { System.err.println("błąd odczytu"); } } } } //Prog76 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog77{ public static void main(String [] arg) { boolean zapis = true; try { FileOutputStream fileOut = new FileOutputStream("c:\\jdk\\moj.dat"); BufferedOutputStream bufOut = new BufferedOutputStream(fileOut); DataOutputStream dataOut = new DataOutputStream(bufOut); dataOut.writeInt(2); dataOut.writeBoolean(zapis); dataOut.writeUTF(" To koniec zawartości pliku"); dataOut.close(); } catch (IOException e ) { zapis = false; System.err.println("błąd zapisu"); } if(zapis) { try { DataInputStream dataInp = new DataInputStream(new BufferedInputStream(new FileInputStream("c:\\jdk\\moj.dat"))); if (dataInp.available() != 0){ // jeżeli plik zawiera jakieś bajty (nie jest pusty) int x = dataInp.readInt(); boolean b = dataInp.readBoolean(); String s = dataInp.readUTF(); System.out.println(" " + x + " " + b + " " + s); } dataInp.close(); } catch (IOException e ) { System.err.println("błąd odczytu"); } } }} //Prog77 readBoolean() writeBoolean(); readByte() writeByte() readShort() writeShort() readInt() writeInt() readLong() writeLong() readFloat() writeFloat() readDouble() writeDouble() readUTF() writeUTF() JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog78{ public static void main(String [] arg) { boolean zapis = true; boolean eof = false; try { StringBufferInputStream st = new StringBufferInputStream("jestem strumieniem"); BufferedOutputStream bufOut = new BufferedOutputStream(new FileOutputStream("c:\\jdk\\moj.dat")); eof = false; while(!eof) { char znak = (char)st.read(); if (znak != (char)-1 ) bufOut.write((byte)znak); else eof = true; } bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedInputStream bufInp = new BufferedInputStream(new FileInputStream("c:\\jdk\\moj.dat")); while(!eof) { char znak = (char)((byte)bufInp.read()); if (znak != (char)-1) System.out.println(znak); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } } } //Prog78 Uwaga ta klasa ma znacznik Deprecated!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe import java.io.*; import java.util.*; public class Prog79{ public static void main(String [] arg) { boolean zapis = true; try { PrintStream pout = new PrintStream(new BufferedOutputStream(new FileOutputStream("c:\\jdk\\moj.dat"))); pout.println(2.0); pout.println(3); pout.println('z'); pout.print(" to jest dobre "); pout.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedReader bufInp = new BufferedReader(new FileReader("c:\\jdk\\moj.dat")); // strumień znakowy !!! // zgodny z UNICODE String a,b,c,d; a = bufInp.readLine() ; b = bufInp.readLine() ; c = bufInp.readLine() ; d = bufInp.readLine() ; System.out.println(a + " " + b + " " + c + " " +d ); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } }} //Prog79 Strumienie wyjścia powiązane z plikami nadpisują istniejące pliki !!!!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe InputStream (abstrakcyjna) Reader (abstrakcyjna) ByteArrayInputStream (tablica jako źródło) CharArrayReader StringBufferInputStream (string jako źródło) Deprecated!! StringReader FileInputStream (plik jako źródło) FileReader PipedInputStream (potok w wielowątkowych) PipedReader OutputStream (abstrakcyjna) Writer (abstrakcyjna) ByteArrayOutputStream(tworzy bufor w pamięci) ByteArrayOutputStream(tworzy bufor w pamięci) - brak - StringWriter FileOutputStream FileWriter PipedOutputStream (potok w wielowątkowych) PipedWriter (potok w wielowątkowych) Konwersja: InputStream  (InputStreamReader  Reader OutputStream  (OutputStreamWriter)  Writer JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe klasy dekoratory (zapewniające użyteczny interfejs): FilterInputStream (abstrakcyjna) FilterReader BufferedInputStream (dla strumieni buforowanych) BufferedReader LineNumberInputStream (śledzi numery wierszy) LineNumberReader PushbackInputStream (umożliwia cofanie ostatniego znaku) PushbackInputReader FilterOutputStream(abstrakcyjna) FilterWriter(abstrakcyjna) BufferedOutputStream (dla strumieni buforowanych) BufferedWriter PrintStream (formatuje dane wyjściowe) PrintWriter JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe import java.io.*; import java.util.*; public class Prog80{ public static void main(String [] arg) { boolean zapis = true; try { PrintWriter bufOut = new PrintWriter(new BufferedWriter(new FileWriter("c:\\jdk\\moj2.dat"))); for(int i = 0; i < 5; i++) bufOut.println("nr " + i); bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedReader bufInp = new BufferedReader(new FileReader("c:\\jdk\\moj2.dat")); String [] tab = new String[100]; int i = 0; while((tab[i++] = bufInp.readLine()) != null); // czytanie liniami for(i = 0; tab[i]!=null ; i++) System.out.println(tab[i] ); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } } } //Prog80 Strumienie wyjścia powiązane z plikami nadpisują istniejące pliki !!!!! JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie znakowe import java.io.*; import java.util.*; public class Prog81{ public static void main(String [] arg) { boolean zapis = true; File fname = new File("c:\\jdk\\moj2.dat"); if (fname.exists() && fname.isFile()){ // sprawdzamy czy jest taki plik try { BufferedReader strInp = new BufferedReader(new StringReader(" jestem komunikatem ")); PrintWriter bufOut = new PrintWriter(new BufferedWriter(new FileWriter(fname))); bufOut.println(strInp.readLine()); bufOut.close(); } catch (IOException e ) { zapis = false; System.err.println("blad zapisu"); } if(zapis) { try { BufferedReader bufInp = new BufferedReader(new FileReader("c:\\jdk\\moj2.dat")); String [] tab = new String[100]; int i = 0; while((tab[i++] = bufInp.readLine()) != null); for(i = 0; tab[i]!=null ; i++) System.out.println(tab[i] ); bufInp.close(); } catch (IOException e ) { System.err.println("blad odczytu"); } } } //if }} //Prog81 FileWriter(String, ovveride Yes = true, No = false) FileWriter(”mój.dat”) - nadpisze plik FileWriter(”mój.dat”,false) - nadpisze plik FileWriter(”mój.dat”,true) - dopisze na koniec pliku JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: System.in import java.io.*; import java.util.*; public class Prog83{ public static void main(String [] arg) { try{ // system.in to obiekt InputStream BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); // konwertujemy na Reader String s,s1=new String(); System.out.println(" pisz co chcesz, pusty wiersz przerywa wczytywanie " ); while((s = input.readLine()).length() != 0 ) s1+=s+" "; System.out.println(s1); // system.out jest już opakowany w PrintStream System.out.print(" Podaj wiek : "); s =input.readLine(); int w = Integer.parseInt(s); System.out.print(" Podaj wzrost w metrach : "); double r = Double.parseDouble(s); System.out.println(" Masz lat: " + w + " i wzrostu " + r + " metra "); } catch (IOException e ) { System.err.println("czytaj polecenia !!");} }} //Prog83 JAVA 2 w praktyce

JAVA – System wejścia - wyjścia: strumienie bajtowe- pliki o dostępie swobodnym import java.io.*; import java.util.*; public class Prog82{ public static void main(String [] arg) { try { RandomAccessFile file = new RandomAccessFile("test.dat","rw"); // rw read and write for(int i = 0; i < 5; i++) { System.out.println(file.getFilePointer()); // 0,4,8,12,16 file.writeInt(i);} file.close(); RandomAccessFile file2 = new RandomAccessFile("test.dat","rw"); // rw read and write System.out.println(file2.getFilePointer()); // -> 0 pokazuje pozycje file2.seek(8); // -> ustaw od 8 bajtu int i = file2.readInt(); System.out.println(" odczytalem = " + i); // -> 2 file2.seek(20); file2.writeUTF("text"); String s = file2.readUTF(); System.out.println(" odczytalem = " + s); // -> text file2.close(); RandomAccessFile file3 = new RandomAccessFile("test.dat","r"); // r - read only file3.seek(12); i = file3.readInt(); System.out.println(" odczytalem ponownie= " + i); // - > 3 file3.close(); }catch(IOException e ) { System.err.println("blad"); } }} //Prog82 JAVA 2 w praktyce

JAVA – zmiana standardowych strumieni (przekierowanie) metody statyczne: System.setIn(InputStream); System.setOut(PrintStream); System.setErr(PrintStream); import java.io.*; import java.util.*; public class Prog84{ public static void main(String [] arg) throws IOException { BufferedInputStream input = new BufferedInputStream(new FileInputStream("Prog84.java")); PrintStream output = new PrintStream(new BufferedOutputStream(new FileOutputStream("wyniki.dat"))); System.setIn(input); System.setOut(output); System.setErr(output); BufferedReader read = new BufferedReader(new InputStreamReader(System.in)); String s; while((s=read.readLine())!= null) System.out.println(s); // czytamy z wejściowego i zapisujemy do wyjściowego output.close(); } } //Prog84 JAVA 2 w praktyce

JAVA – kompresja GZIP JAVA 2 w praktyce GZIPOutputStream(OutputStream) GZIPInputStream(InputStream) import java.io.*; import java.util.*; import java.util.zip.*; public class Prog85{ public static void main(String [] arg) throws IOException { BufferedInputStream input = new BufferedInputStream(new FileInputStream("Prog85.java")); BufferedOutputStream output = new BufferedOutputStream ( new GZIPOutputStream ( new FileOutputStream ("Prog85.gz"))); int bajt; while ((bajt = input.read()) != -1 ) output.write(bajt); input.close(); output.close(); BufferedReader input2 = new BufferedReader ( new InputStreamReader ( new GZIPInputStream ( new FileInputStream ("Prog85.gz")))); String s; while((s=input2.readLine())!= null) System.out.println(s); input2.close(); }} //Prog85 JAVA 2 w praktyce

JAVA – kompresja Zip: dodawanie do archiwum import java.io.*; import java.util.*; import java.util.zip.*; public class Prog86{ public static void main(String [] arg) throws IOException { FileOutputStream fileout = new FileOutputStream("testuj.zip"); // plik archiwum CheckedOutputStream sumaout = new CheckedOutputStream(fileout, new Adler32()); // dla sumy kontrolnej ZipOutputStream zipfileout = new ZipOutputStream( new BufferedOutputStream( sumaout)); String [] files = new String [] {new String("Prog85.java"), new String("Prog86.java") }; int bajt; for(int i = 0; i < files.length; i++) { BufferedInputStream inp = new BufferedInputStream( new FileInputStream(files[i])); ZipEntry ze = new ZipEntry(files[i]); zipfileout.putNextEntry(ze); // dodawanie do archiwum while ((bajt = inp.read())!= -1 ) zipfileout.write(bajt); inp.close(); } // for zipfileout.close(); System.out.println(" suma kontrolna = " + sumaout.getChecksum().getValue() ); // suma kontrolna }} //Prog86 JAVA 2 w praktyce

JAVA – kompresja Zip: odczyt z archiwum import java.io.*; import java.util.*; import java.util.zip.*; public class Prog87{ public static void main(String [] arg) throws IOException { FileInputStream fileinp = new FileInputStream("testuj.zip"); CheckedInputStream sumainp = new CheckedInputStream(fileinp, new Adler32()); ZipInputStream zipfileinp = new ZipInputStream( new BufferedInputStream( sumainp)); int bajt; ZipEntry ze; while((ze = zipfileinp.getNextEntry())!=null) { // odczyt składników (plików) System.out.println(" Rozpakowuje plik o nazwie " + ze); BufferedOutputStream out = new BufferedOutputStream ( new FileOutputStream(ze.getName())); // nazwa składnika(pliku) while((bajt = zipfileinp.read()) != -1) out.write(bajt); out.close(); } System.out.println(" suma kontrolna = " + sumainp.getChecksum().getValue() ); } //Prog87 JAVA 2 w praktyce