Organizacja zajeć:
Aby zaliczyć ćwiczenia należy:
Oddać 4 projekty (wszystkie trzeba zaliczyć) w trakcie zajęć,
Napisać kolokwium zaliczeniowe (4 zadania o podobnym stopniu trudności co projekty):
zero lub jedno zadanie - ocena 2,
dwa zadania - ocena 3,
trzy zadania - ocena 4,
cztery zadania - ocena 5.
Ocena z kolokwium, to średnia arytmetyczna średniej oceny z projektów i oceny z kolokwium. (Wszystkie projekty zaliczone na ocenę 5 zwalniają z kolokwium z oceną 5)
Program realizowany do wykladu Paradygmaty Programowania: http://math.uni.lodz.pl/~kowalcr/ParadygmatyDzienne
Na ćwiczeniach skupimy się na realizacji zagadnień dotyczących nastepujących paradygmatów programowania:
programowania proceduralnego/strukturalnego
programowania obiektowego
programowania funkcyjnego
programowania logicznego
Każdy z projektów dotyczył będzie jednego z wyżej wymienionych paradygmatów.
Instalacja środowisk pracy dla systemów z rodziny Windows:
Realizację paradygmatu Programowania Proceduralnego/Strukturalnego realizować będziemy w oparciu o język C++.
Środowisko programistyczne, którego użyjemy na zajęciach, to Dev C++. Jest ono do ściągnięcia ze strony: http://www.bloodshed.net/dev/devcpp.html
Polecana literatura do przedmiotu, to:
B. Stroustrup, Podstawy języka C++, WNT, 2002
S.B. Lippman, J., Lajoie, Podstawy języka C++, WNT, 2003
J. Grębosz, Podstawy języka C++, Symfonia C++ Standard, Tom 1 i 2, Editions 2000, 2008
Prosty program:
#include <iostream>
int main()
{
std::cout << "Hello World";
return 0;
}
Realizację paradygmatu Programowania Obiektowego realizować będziemy w oparciu o język Java.
Środowisko programistyczne, którego użyjemy na zajęciach, to Netbeans IDE. Jest ono do ściągnięcia ze strony: http://netbeans.org/
Wcześniej zainstalowac trzeba jednak JDK ze strony: http://java.sun.com/javase/downloads/index.jsp
Polecana literatura do przedmiotu, to:
C. Horstmann, G. Cornel, Java Podstawy, Hellion, 2008
API do Java 1.6 z http://java.sun.com/javase/6/docs/api/
Sun tutorial's: z http://java.sun.com/docs/books/tutorial/
Prosty program:
public class Main
{
public static void main(String args[])
{
System.out.println("Hello World");
}
}
Realizację paradygmatu Programowania Funkcyjnego realizować będziemy w oparciu o język Haskell.
Środowisko programistyczne, którego użyjemy na zajęciach, to Haskell Platform. Jest ono do ściągnięcia ze strony: http://hackage.haskell.org/platform/
Polecana literatura do przedmiotu, to:
G. Hutton, Programming in Haskell, Cambridge University Press, 2007
M. Lipovaca, Learn You a Haskell for Great Good!: A Beginner's Guide z http://learnyouahaskell.com/chapters
Prosty program:
putStrLn("Hello World")
Realizację paradygmatu Programowania Logicznego realizować będziemy w oparciu o język Prolog.
Środowisko programistyczne, którego użyjemy na zajęciach, to SWI-Prolog. Jest ono do ściągnięcia ze strony: http://www.swi-prolog.org/download/stable
Polecana literatura do przedmiotu, to:
U. Nilsson, J. Maluszynski, Logic, Programming and Prolog, John Wiley & Sons, 1995, z http://www.ida.liu.se/~ulfni/lpp/
M.A. Covington, D. Nute, A. Vellino, Prolog Programming in Depth, Prentice Hall, 1996
Prosty program:
write('Hello World').
Praca domowa: Zainstaluj wszystkie cztery wymienione powyżej srodowiska programistyczne i uruchom w każdym z nich najprostszy program.
Rozwiazac nastepujace zadania sprawdzajšce elementy programowania proceduralno/strukturalnego.
Grupa Poniedziałkowa 8.00-10.00
===============================
1a. Wejscie: n liczb naturalnych a_1,a_2,...,a_n.
Wyjscie: max i min oraz ilosc ich wystapien w ciagu a_1,a_2,...,a_n.
2a. Wejscie: n znakow typu char a_1,a_2,...,a_n (z tablicy kodow ASCII).
Wyjscie: true badz false w zaleznosci od tego czy wyraz utworzony
ze znakow a_1,a2,...,a_n, po wczesniejszym usunieciu z niego wszystkich znakow
nie bedacych litera (duza lub mala) jest palindromem.
Palindrom to wyraz, ktory wyglada tak samo czytany od konca i od
poczatku, np. ala, kokok.
3a. Wiadomo, ze sqrt(2) = 1+1/(2+1/(2+1/(2+1/(2+...
Wejscie: liczna naturalna n.
Wyjscie: wartosc funkcji rekurencyjnej f(n) obliczajacej sqrt(2)
wedlug powyzszej reguly oraz ilosc iteracji funkcji f potrzebna
do obliczenia sqrt(2) z dokladnoscia do 4 miejsc znaczacych po przecinku.
Grupa Poniedziałkowa 10.00-12.00
================================
1b. Wejscie: n liczb naturalnych a_1_a_2,...,a_n.
Wyjscie: wszystkie liczby polpierwsze wystepujace w ciagu a_1,a_2,...,a_n.
Liczba polpierwsza to liczba naturalna, ktora jest iloczynem dokladnie 2 liczb pierwszych, np.
6=3*3, 35=5*7.
2a. Wejscie: n znakow typu char a_1,a_2,...a_n (z tablicy kodow ASCII).
Wyjscie: ciag a_1,a_2,...,a_n posortowany rosnaco (po kodach) po wczesniejszym usunieciu
z niego znakow: 0,1,2,3,4,5,6,7,8,9.
3a. Wiadomo, ze sqrt(3) = 1+2/(2+2/(2+2/(2+2/(2+...
Wejscie: liczna naturalna n.
Wyjscie: wartosc funkcji rekurencyjnej f(n) obliczajacej sqrt(3)
wedlug powyzszej reguly oraz ilosc iteracji funkcji f potrzebna
do obliczenia sqrt(3) z dokladnoscia do 5 miejsc znaczacych po przecinku.
Grupa Poniedziałkowa 12.00-14.00
================================
1c. Wejscie: n liczb naturalnych a_1_a_2,...,a_n.
Wyjscie: wszystkie liczby bedace kwadratem liczby pierwszej wystepujace
w ciagu a_1,a_2,...,a_n.
Kwadtary liczb pierwszych, to np. liczby 4=2^2, 25=5^2.
2c. Wejscie: n znakow typu char a_1,a_2,...a_n (z tablicy kodow ASCII).
Wyjscie: ciag a_1,a_2,...,a_n posortowany rosnaco (po kodach) po wczesniejszym
usunieciu z niego wszystkich znakow nie bedacych litera (duza lub mala).
3c. Wiadomo, ze (sqrt(5)-1)/2 = 1+1/(1+1/(1+1/(1+1/(1+...
Wejscie: liczna naturalna n.
Wyjscie: wartosc funkcji rekurencyjnej f(n) obliczajacej sqrt(5)
wedlug powyzszej reguly oraz ilosc iteracji funkcji f potrzebna
do obliczenia sqrt(5) z dokladnoscia do 6 miejsc znaczacych po przecinku.
|===========|
| Zadanie 1 |
|===========|
Celem zadania jest zaimplementowane wlasnej ARYTMETYKI DUZYCH LICZB, tj. podstawowych dzialan
na liczbach calkowitych reprezentowanych jako stringi lub tablice znakow.
Zad 1 (klasa - na stringach lub tablicy znakow)
=============================================
Napisz funkcje:
string dodajLiczby(string s1, string s2);
lub
char *dodajLiczby(char* tab1, char* tab2);
ktora zwroci sume dwoch liczb podawanych jako stringi lub tablice znakow.
Zad 2 (klasa - na stringach lub tablicy char)
=============================================
Napisz funkcje:
bool czyPodzielnaPrzez6(string s);
lub
bool czyPodzielnaPrzez6(char* tab);
ktora zwroci true badz false w zaleznosci od tego czy dana liczba naturalna podawana jako string lub tablica znakow
jest podzielna przez 6.
|==========================================================================================================================|
| Projekt 1a (termin oddania 2 tygodnie) - BIG INTEGER ARITMETIC (wykonanie zadania na tablicy znakow daje dodatkowy plus)|
|==========================================================================================================================|
| |
| Napisac program ktory umozliwi: |
| |
| - dodawanie, odejmowanie, porownywanie dwoch liczb calkowitych |
| podawanych jako string lub tablica znakow - na ocene 3 |
| |
| - to co na 3 oraz dodatkowo mnozenie dwoch liczb calkowitych |
| podawanych jako string lub tablica znakow - na ocene 4 |
| |
| - to co na 4 oraz dodatkowo dzielenie calkowite oraz dzielenie z reszta |
| dwoch nieujemnych liczb calkowitych podawanych jako string lub tablica znakow, opracuj również obliczanie NWD |
| - na ocene 5 |
| |
| Zadbaj o czytelnosc i optymalizacje kodu!!! |
| |
| Uwaga!!! Preferowany sposob rozwiazania zadania, to: |
| |
| 1. Poslugiwanie sie typem napisowym (String), ktory do testow wczytujesz z klawiatury lub pliku. |
| 2. Poslugiwanie sie typem tablicowym (CSting), ktory do testow wczytujesz z klawiatury lub pliku. |
| |
| A zatem np. naglowek funkcji dodawanie moglby miec postac: |
| |
| string dodawanie(string s1, string s2); |
| |
| lub |
| |
| char* dodawanie(char* tab1, char* tab2); |
| |
|==========================================================================================================================|
|===========|
| Zadanie 2 |
|===========|
Celem zadania jest zaimplementowane wlasnych metod dotyczacych PARSOWANIA TEKSTU, a dokladniej sprawdzeniu czy wyraz (badz ciag wyrazow)
jest (badz sa) parzystym palindromem lub anagramem.
Przypomnijmy, ze:
Palindrom, to wyraz, liczba, zdanie a nawet wiersz, ktory ma to samo znaczenie niezaleznie od tego, czy czytamy go normalnie
(od poczatku do konca), czy od tylu (czyli od konca do poczatku).
Przyklady palindromow
---------------------
Anna.
Zez.
Co noc.
Daj jad.
Ino go dogoni.
Salut! - tu las.
Co ma tata? - moc.
A KTO I CO TAM MA? TAM MA TO CIOTKA.
Parzysty palindrom to palindrom o parzystej dlugosci znakow.
Anagram, to wyraz, wyrazenie lub cale zdanie powstale przez przestawienie liter innego wyrazu lub zdania, wykorzystujace wszystkie litery materialu wejsciowego.
Przyklady anagramow
-------------------
- Atol, lato. (atol | lato)
- Waga tara bedzie rata. (tara | rata)
- Fosa i sofa rzedem staly razem. (fosa | sofa)
- Czekaja z nadzieja psy goncze, kiedy spod miedzy wyskoczy zajaczek. (czekaja z | zajaczek)
- Oleszczyk - szok leczy! (oleszczyk | szok leczy)
- Wiadomosci Literackie: walka o moc idei i tresci. (Wiadomosci literackie | walka o moc idei i tresci)
- Czy wiesz ma jedyna - jedziemy na wczasy. (Czy wiesz ma jedyna | jedziemy na wczasy)
Uwaga!!! Zakladamy, ze palindromy i anagramy tworzymy z pelnych wyrazow (tzn wyrazow nie wolno dzielic!)
---------------------------------------------------------------------------------------------------------
Uwaga! Aby odczytać palidrom czy anagram pomijamy wielkosc liter oraz spacje i wszelkie znaki przestankowe!!!
-------------------------------------------------------------------------------------------------------------
Zad 1 (klasa na stringach lub tablicy znakow)
=============================================
Napisz program w ktorym zaimplementujesz funkcje:
bool sprawdzCzyParzystyPalindrom(string s);
lub
bool sprawdzCzyParzystyPalindrom(char* c);
do sprawdzenia czy dany napis jest parzystym palindromem. Zakladamy, ze wchodzimy do funkcji z napisem podanym z klawiatury i napis moze
sie skladac z duzych i malych liter oraz spacji. Funkcja ma odpowiedziec (prawda/falsz) czy sprawdzany napis jest parzystym palindromem czy tez nie.
Napis moze byc dowolnie dlugi i miec dowolnie duzo spacji.
Zad 2 (klasa na stringach lub tablicy znakow)
=============================================
Napisz program w ktorym zaimplementujesz funkcje:
bool sprawdzAnagram(String s1, String s2);
lub
bool sprawdzAnagram(char* c1, char* c2);
do sprawdzenia czy dany napis jest anagramem innego napisu. Zakladamy, ze wchodzimy do funkcji z dwoma napisami podanymi z klawiatury i napisy moga sie
skladac z duzych i malych liter oraz spacji. Funkcja ma odpowiedziec (prawda/falsz) czy sprawdzany napis jest anagramem w stosunku do innego napisu.
Napisy moga byc dowolnie dlugie i miec dowolnie duzo spacji.
Wskazowka!
==========
Do wylapania spacji mozesz wykorzystac funkcje
int find(string s)
string substr(int poz1,int poz2)
z klasy string lub robic to na piechote przegladajac tablice znak po znaku.
Do zamiany znakow z malych na duze (czy tez na odwrot) mozesz wykorzystac translacje na kodach ascii albo funkcje:
char toupper(char c)
char tolower(char c)
|==========================================================================================================================|
| Projekt 1b (termin oddania 2 tygodnie) - TEXT PARSING (wykonanie zadania na tablicy znakow daje dodatkowy plus) |
|==========================================================================================================================|
| |
| - Wczytanie dowolnego napisu pieciowyrazowego i stwierdzenia czy sa w nim jakies palindromy parzyste lub anagramy - na 3.|
| |
| - Wypisanie wszystkich palindormow parzystych max. pieciowyrazowych (wyrazy maja stac obok siebie) |
| i zapisanie ich do pliku - na ocene 4. |
| |
| - Znalezienie w tekscie wszystkich anagramow max. trzywyrazowych (wyrazy maja stac obok siebie) |
| i zapisanie ich do pliku - na ocene 5. |
| |
| Zakładamy (przy zadanich na 4 lub 5), ze tekst zaczytujesz z pliku tekstowego i moga byc w nim oprocz |
| liter malych i duzych rowniez symbole spacji (wiecej niz jednej), przecinka, kropki, myslnika, wykrzyknika i innych typowych |
| znakow przestankowych. Musisz najpierw pozbyc sie tych znakow a dopiero pozniej przystepowac do wlasciwego dzialania. |
| Zalecane jest uzycie struktur: |
| |
| list<string> lub vector<string>. |
| |
| Zadbaj o czytelnosc i optymalizacje kodu!!! |
| |
|===================================================
Zadania do samodzielnego rozwiazania. Test dotyczy jezyka programowania Java. Czas 60 minut.
Zadanie 1 (korzystamy z internetu) - 1 pkt.
===========================================
a) Rok powstania jezyka.
b) Pierwsza nazwa jezyka.
c) Daty kolejnych wersji jezyka.
d) Rozwin skroty Java SE, Java ME i Java EE - wymien po trzy technologie zwiazane z kazdym z nich.
e) Gdzie szukac dokumentacji do jezyka?
Zadanie 2 (korzystamy z konsoli) 2 pkt.
========================================
a) Napisz najprostszy program z "Hello World" w prostym etytorze tekstu.
b) Wyjasnij wszystkie slowa kluczowe w programie.
c) Uzywajac polecenia javac pokaz jak przekompilowac program do klasy.
d) Uzywajac polecenia java uruchom klase.
e) Pokaz jak zalozyc prosty pakiet i jak z niego korzystac (w konsoli).
Zadanie 3 (korzystamy z konsoli) 3 pkt.
========================================
a) Napisz program Czytaj.java, ktory uruchomi sie z trzema argumentami (wykorzystaj tablice String[] args) i przywita nas
Witaj.
Twoje imie: args[0]
Twoje nazwisko: args[1]
Twoj wiek: args[2]
b) Program ma dodatkowo pisac:
Za 10 lat bedziesz mial: args[2]+10 (nalezy przekonwertowac string -> int)
Przykladowe uruchomienie:
-------------------------
Czytaj Robert Kowalczyk 39
Wynik:
------
Witaj.
Twoje imie: Robert
Twoje nazwisko: Kowalczyk
Twoj wiek: 39 lat
Za 10 lat bedziesz mial: 49 lat
Zadanie 4 (mozesz korzystac z Netbeans) 4 pkt.
===============================================
a) Napisz prosty program Kalkulator.java w Netbeans ktory korzysta z argumetow (Properties/Run - podajemy argumenty)
b) Napisz prosty kalkulator ktory korzysta z 3 argumentow
args[0] - pierwsza liczba -> przekonwertowac do int
args[1] - dzialanie -> sprawdzic czy ktos podal: + - . /
args[2] - druga liczba -> przekonwertowac do int
c) zastosowac
switch (znak) {
case +: ....
brake;
case -: ....
brake;
case .: ....
brake;
case /: ....
brake;
default;
d) Zasosuj obsluge wyjatkow:
try{
}
catch (ArrayIndexOutOfBoundsException e1){
System.out.println("Podales zla ilosc parametrow");
}
catch (ArithmeticException e2) {
System.out.println("Dzielenie przez 0");
}
catch (NumberFormatException e3) {
System.out.println("Blad parsowania do int")
}
e) Sprawdzaj poprawnosc dzialania: + - . /
Przykladowe uruchomienie w konsoli:
-----------------------------------
Kalkulator 34 + 45
Wynik:
------
79
Przykladowe uruchomienie w konsoli:
-----------------------------------
Kalkulator 34 + ala
Wynik:
------
Blad parsowania do int
Przykladowe uruchomienie w konsoli:
-----------------------------------
Kalkulator 34 / 0
Wynik:
------
Dzielenie przez 0
Zadanie 5 (mozesz korzystac z Netbeans) 5 pkt.
================================================
a) Czytanie z klawiatury w Javie mozesz zrealizowac za pomoca klasy Scanner
b) Napisz program o funkcjonalnosci podobnej do zadania 4 ale zakladamy, ze 3 parametry mozesz
zaczytac z lini i moga miec one wiecj niz jedna spacje na poczatku i na koncu lini - uzyj trim() aby pozbyc sie
niepotrzebnych spacji.
Przykladowe uruchomienie w konsoli:
-----------------------------------
Kalkulator
Podaj operacje:
8 + 6
Wynik:
------
14
Zadania do samodzielnego rozwiazania. Test dotyczy jezyka programowania Java. Czas 60 minut.
Zadanie 1 (czytanie pliku) (1 pkt.)
===================================
Stworz plik o nazwie plik.txt o zawartosci:
Ala ma kota
Kota ma Ale
Wszyscy sa szczesliwi
Napisz program ktory wczyta zawartosc pliku plik.txt i wypisze na konsole:
1) zawartosc pliku
2) liczbe lini z pliku
3) liczbe wyrazow z pliku
4) liczbe liter z pliku
Zadanie 2 (przetwarzanie pliku) 2 pkt.
=======================================
Napisz program ktory zapisze w pliku wynik.txt liczbe wystapien slow "liczby" z pliku liczby.txt (wielkosc liter nieistotna).
Zadanie 3 (przetwarzanie pliku) 3 pkt.
======================================
W pliku pi.txt zapisano 100 000 kolejnych cyfr rozwiniecia liczby pi.
Napisz program ktory wczyta plik i statystyke wystepowania cyfr w pliku, tzn.
cyfra 0 - ... wystapien
cyfra 1 - ... wystapien
cyfra 2 - ... wystapien
cyfra 3 - ... wystapien
cyfra 4 - ... wystapien
cyfra 5 - ... wystapien
cyfra 6 - ... wystapien
cyfra 7 - ... wystapien
cyfra 8 - ... wystapien
cyfra 9 - ... wystapien
Celem niniejszych zajec jest zbudowanie od podstaw prostej aplikacji okienkowej w Javie reagujacej na zdarzenia odbierane z klawiatury i myszy.
Zajecia pokazuja zastosowanie kokcepcji programowania obiektowego oraz zdarzeniowego.
=============
| Cwiczenie 1 |
=============
Najprostsza aplikacja okienkowa w Javie:
import javax.swing.JFrame;
public class Okienko extends JFrame
{
public Okienko()
{
setTitle("Okienko");
setSize(200,200);
setLocation(600, 400);
//lub setBounds(600,300,200,200);
setResizable(false);
}
public static void main(String[] args) throws Exception
{
JFrame okno = new Okienko();
okno.setVisible(true);
okno.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
=============
| Cwiczenie 2 |
=============
Zbudujemy teraz prosta klaske z nasluchem jak na rysunku Kalkulator.png.
Tworzymy szkielet okna jak powyzej. Dodajemy Layout. Wybierzmy GridLayout (layout siatkowy).
setLayout(new GridLayout(4,2)); // 4 wiersze i 2 kolumny
Dodajemy teraz dwie etykiety na liczby i jedna na sume oraz pola tekstowe do pisania.
JLabel etykieta1 = new JLabel("liczba1");
JTextField liczba1 = new JTextField(10);
JLabel etykieta2 = new JLabel("liczba2");
JTextField liczba2 = new JTextField(10);
JLabel etykieta3 = new JLabel("suma");
JTextField suma = new JTextField(10);
oraz zdejmujemy edytowalnosc na ostatnie pole
suma.setEditable(false);
Wszystkie elementy powinny byc ladowane na panele:
JPanel jp1 = new JPanel();
JPanel jp2 = new JPanel();
JPanel jp3 = new JPanel();
Nastepnie wkladamy na panele odpowiednie etykiety i pola tekstowe:
jp1.add(etykieta1);
jp1.add(liczba1);
jp2.add(etykieta2);
jp2.add(liczba2);
jp3.add(etykieta3);
jp3.add(suma);
Wkladamy teraz panele do glownego okna:
add(jp1);
add(jp2);
add(jp3);
Dodajemy teraz przycisk
JButton przycisk = new JButton("wykonaj");
i wkladamy przycisk do okna
add(przycisk);
Teraz dodamy nasluch. Mozna to zrobic na rozne sposoby. Zawsze jednak trzeba:
i) utworzyc obiekt nasluchujacy, ktory jest egzemplarzem klasy implementujacej interfejs AcctionListener,
ii) podpiac obiekt nasluchu pod zrodlo powodujace zdarzenie, np. pod przycisk (zdarzenie to klikniecie na nim),
iii) zaimplementowac jedyna metode:
acctionPerformed(AcctionEvent e);
A zatem:
1) Dodajemy klasie Kalkulator mozliwosc implementacji interfejsu ActionListener:
public class Kalkulator extends JFrame implements ActionListener
2) Podpinamy pod przycisk mozliwosc wylapywania zrodla zdarzen jakim sa klikniecia na nim:
przycisk.addActionListener(this);
3) Implementujamy odpowiednio metode:
acctionPerformed(AcctionEvent e)
Odczytujemy liczby z pol liczba1 i liczba2, konwertujemy je do int i ich sume wyswietlamy w polu suma:
int l1 = Integer.parseInt(liczba1.getText());
int l2 = Integer.parseInt(liczba2.getText());
int liczba = l1+l2;
suma.setText(liczba+"");
i odpowiednio obslugujemy blad konwersji.
UWAGA!!!
========
Mozemy docisnac okienko do minimalnych rozmiarow przez:
okienko.pack();
Mozemy rowniez wplynac na motyw wygladu okien:
//styl Metal (domyslny)
UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
//styl Motif
//UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
//styl Windows
//UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
=============
| Cwiczenie 3 |
=============
Zbudujmy jeszcze jedna prosta aplikacje jak na rysunku NotatnikZadanko.png.
1) Najpierw zbudujmy szkielet okna (zwrocmy uwage na roznice w metodzie wywolywania okna).
import javax.swing.JFrame;
public class Notatnik extends JFrame
{
public Notatnik()
{
setTitle("Notatnik");
setResizable(false);
}
public static void main(String[] args)
{
SwingUtilities.invokeLater(new Runnable()
{
@Override
public void run()
{
Notatnik not = new Notatnik();
not.setVisible(true);
not.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
});
}
}
2) Zbudujmy teraz okienko o wielkosc 1/2 szerokosc ekranu x 1/2 wysokosc ekranu i ustawmy go na srodku.
Pobieramy zestaw narzedziowy:
Toolkit zestaw = Toolkit.getDefaultToolkit();
Budujemy obiekt typu Dimension:
Dimension rozmiarEkranu = zestaw.getScreenSize();
Ustalamy nowa szrokosc i wysokosc ekranu i ja ustawiamy:
int szerEkranu = rozmiarEkranu.width; // ciekawostka to blad projektantow jezyka
int wysEkranu = rozmiarEkranu.height; // ciekawostka to blad projektantow jezyka
setBounds(szerEkranu/4,wysEkranu/4,szerEkranu/2,wysEkranu/2);
Tworzymy obszar tekstowy:
JTextArea textArea = new JTextArea();
Tworzymy panel przewijalny z paskami przewijania i dodajemy na niego obszar tekstowy:
JScrollPane sp = new JScrollPane
(textArea,JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
Tworzymy BorderLayout dla calego okna:
setLayout(new BorderLayout());
Dodajemy panel przewijalny na centrum okna:
add(sp,BorderLayout.CENTER);
Tworzymy panel na przyciski z ustawieniem domyslnego Layoutu:
JPanel przyciski = new JPanel(new FlowLayout());
Dodajemy panel z przyciskami na poludnie okna:
add(przyciski,BorderLayout.SOUTH);
Tworzymy przyciski zmieniajace kolor obszaru tekstowego i ustawiamy na nich odpowiednie akcje:
JButton zi = new JButton("zielony");
zi.setActionCommand("1");
JButton zo = new JButton("żółty");
zo.setActionCommand("2");
JButton bi = new JButton("biały");
bi.setActionCommand("3");
Dodajemy przyciski do Panelu:
przyciski.add(zi);
przyciski.add(zo);
przyciski.add(bi);
Dodajemy nasluch na okno:
public class Notatnik extends JFrame implements ActionListener
Powiazanie obiektu nasluchujacego (biezacej klasy) ze zrodlem wystapienia zdarzenia:
zi.addActionListener(this);
zo.addActionListener(this);
bi.addActionListener(this);
Implementowanie metody nasluchujacej:
actionPerformed(ActionEvent e);
Sprawdzenie ktory przycisk zostal wcisniety i wykonanie odpowiedniej akcji:
switch (Integer.parseInt(e.getActionCommand()))
{
case 1:
{
textArea.setBackground(Color.GREEN);
break;
}
case 2:
{
textArea.setBackground(Color.YELLOW);
break;
}
case 3:
{
textArea.setBackground(Color.WHITE);
break;
}
}
=======================================
| Zadanie do wykonania na plusa (w domu)|
=======================================
Rozbuduj dalsza funkcjonalnosc Notatnika do tej zaprezentowanej na rysunku NotatnikCwiczenie.jpg.
1) Przerob wszystkie przyciski JButton na JRadioButton oraz ustaw odpowiednie komendy akcji i nasluchy:
JRadioButton bi = new JRadioButton("bialy",true);
bi.setActionCommand("11");
bi.addActionListener(this);
itd.
Uwaga!!! Mozesz komendy akcji ponumerowac: 11, 12, 13.
Pamietaj o stworzeniu grupy:
ButtonGroup bg = new ButtonGroup();
i dodaniu do niej wszytskich przyciskow:
bg.add(bi);
itd.
Odpowiednio zaimplementuj metode:
void acctionPerformed(AccionEvent e);
do obslugi wszystkich przyciskow.
2) Stworz dwa przyciski JButton ustawiajace tytul (na samym poczatku tekstu ma sie pojawic: Szanowny Panie) i podpis
(na koncu tekstu ma sie pojawic: Z powazaniem) w obszarze tekstowym textArea.
Dodaj odpowiednie komendy akcji oraz nasluchy:
JButton tytul = new JButton("Tytul");
tytul.setActionCommand("21");
tytul.addActionListener(this);
itd.
Uwaga!!! Mozesz komendy akcji ponumerowac: 21, 22.
Odpowiednio zaimplementuj metode:
void acctionPerformed(AccionEvent e);
do obslugi wszystkich przyciskow.
3) Dla wiekszej czytelnosci programu stworz funkcje:
JPanel doDolnyPanel();
ktora dodasz w konstruktorze okna na poludniu i ktora zbuduje dolne przyciski sterujace okna:
add(doDolnyPanel(),BorderLayout.SOUTH);
Najlepiej wczesniej stworz panel zbiorczy, na ktorym umiescisz dwa panele pomocnicze i na jednym z nich beda przyciski typu JButton, na drugim JRadioButton:
JPanel przyciski = new JPanel(new GridLayout(1,2));
JPanel panelLewy = new JPanel(new FlowLayout(FlowLayout.CENTER));
JPanel panelPrawy = new JPanel(new FlowLayout(FlowLayout.CENTER));
4) Stworz funkcje:
JMenuBar doPasekMenu()
ktora zbuduje pasek menu do okna. Pamietaj o dodaniu jej w konstruktorze okna poleceniem:
setJMenuBar(doPasekMenu());
5) Zbuduj wszystkie elementy paska menu: mPlik, mEdycja i mPomoc:
JMenu mPlik = new JMenu("Plik");
JMenuItem otworz = new JMenuItem("Otworz");
JMenuItem zapisz = new JMenuItem("Zapisz");
JMenuItem zakoncz = new JMenuItem("Zakoncz");
itd.
6) Przypisz odpowiednie komendy akcji oraz nasluchy:
otworz.setActionCommand("31");
zapisz.setActionCommand("32");
zakoncz.setActionCommand("33");
otworz.addActionListener(this);
zapisz.addActionListener(this);
zakoncz.addActionListener(this);
itd.
Uwaga!!! Numeruj kolejne poziomy przez 41, 42, 43 (czcionka mala, czcionka duza, wyczysc) i 51 (o autorze).
7) Klawisze skrotow tworz uzywajac polecenia:
otworz.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));
itd.
klawisze skrotow tzw. mnemoniki uzywane z klawiszem Alt tworz uzywajac polecenia:
mPlik.setMnemonic('P');
itd.
8) W celu wczytania pliku mozesz zastosowac konstrukcje:
JFileChooser pliki = new JFileChooser(".");
if (JFileChooser.APPROVE_OPTION==pliki.showOpenDialog(this))
try
{
File f=pliki.getSelectedFile();
setTitle(f.getAbsolutePath()+" Notatnik");
BufferedReader br = new BufferedReader(new FileReader(f));
String temp="";
while (br.ready())
{
temp+=br.readLine()+"\n";
}
textArea.setText(temp);
}
catch (IOException ex)
{
System.out.println("Brak pliku");
}
9) W celu zapisu pliku mozesz zastosowac konstrukcje:
JFileChooser pliki = new JFileChooser(".");
if (JFileChooser.APPROVE_OPTION==pliki.showSaveDialog(this))
try
{
File f=pliki.getSelectedFile();
BufferedWriter bw = new BufferedWriter(new FileWriter(f));
bw.write(textArea.getText());
bw.flush();
bw.close();
}
catch (IOException ee)
{
System.out.println("Problemy z zapisem");
}
10) W menu mEdycja obsluz powiekszanie i pomniejszanie czcionki w polu testowym. Sama czcionke mozesz modyfikowac stosujac:
Font f = new Font("Arial",Font.PLAIN,10);
Font f = new Font("Arial",Font.PLAIN,18);
a nastepnie:
textArea.setFont(f);
11) W medu mPomoc mozesz zastosowac standardowe modalne informacyjne okienko dialogowe za pomoca konstrukcji:
JOptionPane.showMessageDialog(this,"Autor: Jan Kowalski");
===================================================================================================
| Projekt 2a (termin oddania 2 tygodnie) - Edytor Tekstu |
| |
===================================================================================================
| |
| Na ocene 3 - stworzyc aplikacje okienkowa o funkcjonalnosci widocznej w pliku |
| NotatnikZaliczenie.jpg z dodatkowa opcja ustawiania czcionki Bold i Italic. |
| |
| Na ocene 4 - stworzyc aplikacje okienkowa z taka funkcjonalnoscia jak na ocene 3 oraz dodatkowo:|
| - dodaj mozliwosc zawijania wierszy, |
| - dodaj mozliwosc wybor stylu czcionki, |
| - dodaj mozliwosc wydruku dokumentu, |
| - dodaj mozliwosc wlaczenia paska stanu. |
| |
| Na ocene 5 - stworzyc aplikacje okienkowa z taka funkcjonalnoscia jak na ocene 4 oraz dodatkowo:| | |
| - dodaj mozliwosc cofania i przywracania tekstu, |
| - dodaj mozliwosc wyszukiwania slow w tekscie. |
| |
| Ponadto opracuj sposob zapisu tekstu do pliku w taki sposob aby po otworzeniu go ponownie, |
| otwieral sie on z wszystkimi poprzednio nalozonymi ustawieniami na tekst (np. pogrubieniem |
| tekstu, pokolorowaniem tekstu, itp.). |
| |
===================================================================================================
=========================================================================================================
| Projekt 2b (termin oddania 2 tygodnie) - Hipermarket |
========================================================================================================
| |
| Ogolny opis projektu: |
| |
| W kazdym Hipermarkecie znajduja sie produkty przeroznych rodzajow o roznych wlasnosciach: |
| |
| - produkty spozywcze (nazwa, cena, termin waznosci, sklad, tabela wartosci kalorycznych, ...), |
| - artykuly chemiczne (nazwa, cena, termin waznosci, sklad, srodki ostroznosci, ...), |
| - AGD RTV (nazwa, cena, okres gwarancji, ...). |
| ... |
| |
| Zakupy klienta na ogol przebiegaja tak: |
| |
| - klient wchodzac do sklepu, bierze koszyk, |
| - klient wrzuca do koszyka produkty, ktore chce kupic, |
| - po zastanowieniu klient ewentualnie zmienia zdanie i odkłada na polke wczesniej wybrany produkt, |
| - klient idzie do kasy na koniec kolejki i czeka na obsluge, |
| - klient placi za zakupy. |
| |
| Zaprojektowac i zaimplementowac: |
| |
| - klasy reprezentujšce produkty w sklepie, |
| - klasy realizujace funkcjonalnosc koszyka jako abstrakcyjny typ danych (np. stos, kolejka), |
| - klase klienta, |
| - abstrakcyjny typ danych realizujšcy kolejke klientow do kasy (np. kolejka). |
| |
| Przy projektowaniu klas nalezy wykorzystac mechanizm dziedziczenia, klasy abstrakcyjne |
| oraz polimorfizm. |
| |
| Napisac program testujacy. Przed wyslaniem klienta do sklepu nalezy odpowiednio zaopatrzyc sklep. |
| tzn. wprowadzic roznego rodzaju produkty (dowolna metoda np. z pliku). |
| Wysłac kilku klientow do sklepu po zakupy. W odpowiedniej kolejnosci obsluzyć klientow. |
| |
| Ocena w zaleznosci od zlozonosci projektu. Mozna skorzystac z gotowych klas typu: Stack, Quee itp. |
| |
=================================================================================================
Sa to pierwsze zajecia wprowadzajace w zagadnienia programowania funkcyjnego poswieconego Haskellowi.
Korzystajac z dystrybucji Glasgow Haskell Compiler mamy do dyspozycji kompilator (ghc) i interpreter (ghci).
Uwaga!!! Wszystkie omowione dalej polecenia zakladaja obsuge kompilatora i interpretera z poziomu systemu opracyjnego Windows, tj. mamy tutaj na mysli odwolania do polecen opartych na komunikacji z powloka systemu operacyjnego.
1. Najprostszy program:
-----------------------
Standardowy prompt interpretera ghci, to:
Prelude>_
(1 sposob) Uzywajac interpretera ghci mozemy teraz wypisac na ekran "Hello World":
Prelude>"Hello World"
"Hello World"
lub w taki sposob:
Prelude>putStrLn "Hello World"
"Hello World"
(2 sposob) Inny sposob to uzycie kompilatora ghc. Tworzymy plik teksowy
cwiczenie.hs
o zawartosci:
main = do
putStrLn "Hello World"
i kompilujemy go nastepnie poleceniem:
ghc -o cwiczenie cwiczenie.hs
Nastepnie uruchamiamy:
cwiczenie.exe
Oczywiscie musimy miec poprawnie ustawiona sciezke systemowa (path) do polecenia ghc.
(3 sposob) Mozemy równiez zaladowac modul poleceniem
:load lub :l
i wyjsc pozniej na poziom standadowego modulu Prelude poleceniem
:m.
2. Haskell jako kalkulator:
---------------------------
Mozemy traktowac interpreter Haskella jako kalkulator:
Prelude>8+4
12
Prelude>23/6
3.833333333333335
Prelude>34-35
-1
Prelude>2^4
16
Prelude>sin 1
0.841470984807896
Prelude>pi
3.141592653589793
3. Wybrane funkcje wbudowane stosowane do typow liczbowych:
-----------------------------------------------------------
abs - wartosc bezwzgledna
atan - arcus tanges
ceiling - calosc + 1
cos - cosinus
div - dzielenie calkowite
exp - exponent
floor - calosc
log - logarytm
max - maksimum
min - minimum
mod - operator reszty z dzielenia
pi - wartosc pi
round - zaokragla do najblizszej calkowitej
sin - sinus
sqrt - pierwiastek
tan - tanges
^ - operator potegowania
succ - operator ktory zwieksza argument o jeden
pred - operator ktory zmniejsza argument o jeden
Warto korzystac ze strony:
http://zvon.org/other/haskell/Outputglobal/index.html
4. Dwa rodzaje komentarzy:
--------------------------
-- komentarz jednolinijkowy
{-
komentarz blokowy
komentarz blokowy
-}
5. Definicja prostej funkcji, np. obliczajacej kwadrat danego wyrazenia:
------------------------------------------------------------------------
Sposob 1: Z uzyciem interpretera:
.................................
Prelude>let kwadrat x = x * x
Prelude>kwadrat 3
9
Prelude>kwadrat (-3)
9
Sposob 2: Ladujac funkcje z pliku:
..................................
Przygotowujemy plik cwiczenie.hs o zawartosci:
kwadrat x = x * x
i zachowujemy go (dla przykladu) na c:\. W interpreterze zmieniamy teraz biezacy katalog na c:\ poleceniem:
Prelude>:cd c:\
Ładujemy plik do pamieci:
Prelude>:load cwiczenie.hs
Wywolujemy w koncu funkcje kwadrat dla odpowiednich argumentow:
*Main>kwadrat 3
9
*Main>kwadrat (-3)
9
Opusczenie modulu Main odbywa sie za pomoca polecenia:
*Main>:m
Sposob 3. Przygotowujac plik skompilowany:
..........................................
Przygotowujemy plik o zawartosci:
kwadrat x = x * x
main = print(kwadrat 4)
Nastepnie kompilujemy go i wywolujemy.
Uwaga!!! Pamietajmy, ze w Haskellu typy (argumentu i wartsoci) funkcji mozemy zdefiniowac co przydaje sie chociazby przy kontroli poprawnosci programu.
W naszym przypadku funkcje kwadrat moglibysmy zdefiniowac jako:
kwadrat:: Int -> Int
kwadrat x = x*x
-- jesli funkcja ta mialaby operowac na liczbach calkowitych
kwadrat::Float->Float
kwadrat x = x*x
-- jesli funkcja ta mialaby oprarowac na liczbach zmiennoprzecinkowych pojedynczej precyzji
6. Kilka polecen ogolnych:
--------------------------
Pomoc, tj. liste dostepnych polecen systemowych uzyskujemy za pomoca:
Prelude>:?
lub
Prelude>:help
Wsrod nich warte uwagi jest polecenie
Prelude>:!
ktore pozwala uzyskiwac polecenia zewnetrzej powloki systemowej. Np.
Prelude>:! cd
pokaze aktualny katalog z ktorego ladujemy pliki, a np.
Prelude>:! dir
wylistuje jego zawartosc. Polecenie:
Prelude><ctrl>+l
czysci ekran. Warto pamietac rowniez o przyciku
<tab>
ktory uzupelnia kontekst wprowadzanych polecen.
:set prompt "ghci> ".
zmiana prompta
7. Zmienne:
-----------
Prelude>let r=4
Prelude>r
4
Prelude>let pole = pi*r*r
--niestety jest blad, tj. problem ze scisla kontrola typow
Prelude>let r=4.0
Prelude>pole
50.26548245743669
Prelude>let r=5.0
Prelude>pole
50.26548245743669
--nie ma zatem zmiany (to wlasnie swoista cecha jezykow funkcyjnych)
Prelude>let pole =pi*r*r
Prelude>pole
78.53981633974483
8. Funkcje wielu zmiennych:
---------------------------
--definicja funkcji dwoch zmiennych obliczajaca pole prostokata
Prelude>let poleProstokata a b = a*b
--definicja funkcji trzech zmiennych obliczajaca pole prostopadloscianu (wykorzystujaca poprzednia definicje)
Prelude>let poleProstopadloscianu a b c = poleProstokata a b * c
--wywolanie funkcji liczacej pole prostopadloscianu
Prelude>poleProstopadloscianu 2 3 4
24
|-----------------------|
| Zadanie 1 (klasa) |
|-----------------------|
Zdefiniuj funkcje
wypisz a
przyjmujaca imie jako parametr a i witajaca sie, tj. po podaniu np:
wypisz Robert
funkcja zwraca nam na ekran:
"Witaj Robert!"
Uwaga!! Do laczenia lancuchow znakow sluzy operator:
++
9. Typy danych:
---------------
Haskell ma scisla kontrole typow i kazda fukcje mozemy (choc nie musimy) zdefiniowac podajac odpowiednie typy skladowe. Warto to jednak robic dla podnoszenia czytelnosci kodu jak rowniez
dla sprawniejszego usuwania bledow. Samo sprawdzenie typu (nie tylko funkcji) odbywa sie przy uzyciu polecenia:
Prelude>:t
lub
Prelude>:type
I tak:
Prelude>:t "Hello"
"Hello"::[char]
Prelude>:t 'e'
'e'::Char
Prelude>:t 1<3
1<3::Bool
Prelude>let i=5
Prelude>:t i
i::Integer
Prelude>lez z=5.6
Prelude>:t z
z::Double
Prelude>:t 5
5::(Num t) => t
Prelude>:t 5.0
5.0:: (Fractional t) => t
Podstawowe typy Haskella, to:
Int - liczby calkowite z ograniczonego zakresu [-2^29 .. 2^29-1]
Integer - liczby calkowite o dowolnej precyzji
Float - liczba zmiennoprzecinkowa pojedynczej precyzji
Double - liczba zmiennoprzecinkowa podwójnej precyzji
Char - typ znakowy (Unicode)
Bool - zmienne logiczne
Relacje miedzy elementami: LT (less then - mniejszy niż), EQ (equal - równy), GT (greater then - większy niż)
Prelude>compare 1 2
LT
Typy funkcji:
Prelude>:t kwadrat
kwadrat::(Num a) => a->a
Kilka przykladow uzycia operatorow logicznych:
Prelude>True && False
False
Prelude>True && (1<4)
True
Prelude>False || False
False
Prelude>1==2
False
Prelude>2 /= 3 -- operator <>
True
Prelude>not True
False
10. Listy:
----------
Listy sa obecne prawie w kazdym programie napisanym w jezyku Haskell. Sa to homogeniczne struktury danych.
Lista pozwala na przechowywanie dowolnej liczby elementow tego samego typu.
Listy sa otoczone nawiasami kwadratowymi, a ich elementy oddzielone przecinkami.
Prelude> let imiona = ["Zosia", "Kasia", "Małgosia"]
Prelude> let liczby = [3,4,5]
Dolaczanie elementow do listy:
Prelude> 2 : liczby
[2,3,4,5]
Prelude> liczby
[3,4,5]
Prelude> 0 : 1 : 2 : liczby
[0,1,2,3,4,5]
--zauwazmy ze lista tak naprawde jest niezmienna
Pierwszy i wszystkie poza pierwszym elementy listy:
Prelude> head liczby
3
Prelude> tail liczby
5
Lista znakow:
Prelude>"Haskell"
"Haskell"
Prelude>'H':'a':'s':'k':'e':'l':'l':[]
"Haskell"
Sekwencje:
Prelude>[1,2..10]
[1,2,3,4,5,6,7,8,9,10]
Prelude>[5,3..(-1)]
[5,3,1,-1]
Zbudowanie sekwencji nieskonczonej (uzyte leniwe wartosciowanie)
Prelude>[1,2..]
Listy list:
Prelude> [[1,2,3],[2,3,4],[3,4,5]]
[[1,2,3],[2,3,4],[3,4,5]]
11. Funkcje biblioteczne do pracy na listach.
typ: (!!) :: [a] -> Int -> a
opis: (!!) lista poz - zwraca element stojacy na pozycji poz w liscie lista lub sygnalizuje blad (exception)
przyklad: (!!) [4,5,6] 1 zwraca element 5
typ: length :: [a] -> Int
opis: length lista - zwraca dlugosc listy lista
przyklad: length [4,5,6] - zwraca liczbe 3
typ: (++) :: [a] -> [a] -> [a]
opis: (++) lista1 lista2 - zwraca sume (mnogosciowa) list lista1 i lista2
przyklad: (++) [1,2,3] [4,5,6] - zwraca liste [1,2,3,4,5,6]
typ: drop :: Int -> [a] -> [a]
opis: drop n lista - zwraca liste pozbawiona n pierwszych elementow
przyklad: drop 1 [4,5,6] - zwraca liste [5,6]
typ: sum :: (Num a) => [a] -> a
opis: sum lista - zwraca sume wszystkich elementow listy lista
przyklad: sum [4,5,6] - zwraca liczbe 15
typ: product :: (Num a) => [a] -> a
opis: product lista - zwraca iloczyn wszystkich wlementow listy lista
przyklad: product [4,5,6] - zwraca liczbe 120
typ: map :: (a->b) -> [a] -> [b]
opis: map f lista - zwraca liste [f(lista !! 0), f(lista !! 1), ..., f(lista !! ((length lista)-1)))]
przyklad: map (+2) [4,5,6] - zwraca liste [6,7,8]
typ: filter :: (a -> Bool) -> [a] -> [a]
opis: filter f lista - zwraca liste zlozona z tych i tylko tych elementow f(lista !! i) ktore sa prawdziwe (tj. maja wartosc logiczna True)
przyklad: filter (>0) [-1,-2,1,2] - zwraca [1,2]
typ: null :: [a] -> Bool
opis: null lista - zwraca False jesli lista jest niepusta i True jesli jest pusta
przyklad: null [] - zwraca true
typ: take :: Int -> [a] -> [a]
opis: take n lista - zwraca liste n poczatkowych elementow z listy lista
przyklad: take 2 [4,5,6] - zwraca liste [4,5]
repeat i circle - pokazac na przykladzie
|-----------------------|
| Zadanie 2 (klasa) |
|-----------------------|
1) Utworz funkcję
zwiekszaDwaRazy x
ktora zwieksza kazdy argument dwa razy.
2) Utworz liste
liczbyNaturlneDwucyfrowe = [10,11,12,...,99].
3) Zastosuj funkje map oraz zwiekszDwaRazy do listy liczbyNaturalneDwucyfrowe.
12. Konstrukcja listy za pomoca kwantyfikatora:
[wyrazenie | x <- lista, warunek] - tworzy liste elementow wedlug wzoru wyrazenie na mocy listy lista oraz przy zachodzeniu warunku warunek
Przykladowo polecenie:
[x^2 | x <- [1..10], even x]
utworzy liste:
[4,16,36,64,100]
pitagoras = [(a, b, c)| c <- [1 ..]
, b <- [1 .. c]
, a <- [1 .. b]
, a^2 + b^2 == c^2]
|-----------------------|
| Zadanie 3 (klasa) |
|-----------------------|
Uzywajac kwantyfikatorow stworz macierz 5x5 jednostkowa za pomoca listy list
Wykorzystaj konstrukcje if:
if warunek then instrukcja1 else instrukcja2
|------------------------|
| Zadanie domowe za ++ |
|------------------------|
Zdefiniuj funkcje ktora dla dowolnej listy liczb calkowitych obliczy sume pierwiastkow jej elementow.
Wykonaj wywolanie programu dla listy wszystkich liczb podzielnych przez 5 z przedzialu [1,200].