plik

Obiekty w JAVIE

●

Wszystkie (prawie) byty w JAVIE to obiekty

●

Manipulowanie obiektami odbywa się poprzez

referencje do nich

Stworzenie referencji do obiektu klasy

String

String s;

Powyższa linia tworzy tylko referencje a nie obiekt,

co więcej referencja ta nie wskazuje na żaden

obiekt.

Bezpieczniejszą techniką jest tworzenie i

jednoczesne inicjalizowanie referencji :

String s = „abcdefgh”;

Obiekty w JAVIE cd.

●

Trzeba tworzyć wszystkie obiekty:

String s = new String(„abcdefgh”);

Powyższa linia tworzy nowy obiekt klasy

String

przypisuje referencje do niego do zmiennej s.

Linia ta określa też jak ma być skonstruowany obiekt

klasy

String

– jakim ciągiem znaków ma być

zainicjalizowany

Typy proste

void

IEEE754

64 bity

double

IEEE754

32 bity

float

-1

-2

64 bity

long

–1

-2

32 bity

int

–1

-2

16 bitów

short

+127

-128

8 bitów

byte

unicode 2

-1

unicode 0

16 bitów

char

boolean

max

min

rozmiar

typ

Typy proste

Void

void

Double

double

Float

float

Long

long

Integer

int

Short

short

Byte

byte

Character

char

Boolean

boolean

‘opakowanie’ obiektowe

typ

Słowa kluczowe

abstract continue for

new

switch

assert default

package

synchronized

boolean do

goto

private

this

break

double

implements protected throw

byte

else

import

public

throws

case

enum

instanceof

return

transient

catch

extends int

short

try

char

final

interface

static

void

class

finally

long

strictfp

volatile

const

float

native

super

while

Zasięg nazw

Zasięg określa widzialność i czas życia zdefiniowanej nazwy.

Zasięg jest ograniczany przez nawiasy klamrowe

{}

Przykład:

{

int x = 12;

/* w tym miejscu tylko zmienna x jest dostepna */

{

int q = 96;

/* tu sa dostepne zmienne x i q */

}

/* tu tylko zmienna x jest dostepna */

/* zmienna q jest poza zasiegiem */

}

Zasięg nazw

Inaczej niż w c++ w JAVIE nie ma przykrywania

zmiennych

Przykład:

{

int x = 12;

{

int x = 96; /* niepoprawne w JAVIE */

}

Zasięg obiektu

Zasięg obiektów jest w JAVIE inny niż typów prostych:

{

String s = new String(„abc”);

} /*koniec zasiegu */

referencja s jest poza zasiegniem wiec nie
ma do niej dostepu. Natomiast obiekt
String ciagle istnieje i zajmuje pamiec
(ale nie ma do niego dostepu bo nie
istnieje już żadna referencja do niego)

Klasy

Klasa definiuje zachowanie obiektów, będących

instancjami tej klasy – czyli służy do definiowania

typu:

class NazwaTypu { /*definicja*/ }

Tworzenie obiektu (instancji) tej klasy:

NazwaTypu o = new NazwaTypu();

Klasy

Klasa może zawierać dwa typy elementów:



Pola

(dane) będące instancjami innych

obiektów, lub typów prostych



Metody

(funkcje) będące operacjami

przeprowadzanymi na obiekcie, bądź klasie

Klasy - pola

Przykład klasy zawierającej tylko

pola

class Dane

{

int i;

float f;

}

/* ... */

Dane d = new Dane();

d.i = 32;

d.f = 23.6f;

Klasy - pola

Dostęp do składowych (pól i metod) odbywa się

poprzez kropkę:

refernecjaDoObiektu.skladowa

np.:

d.i = 32;

lub:

koloGlowne.Srodek.x = 23;

Klasy - metody

Metody służą do wykonywania operacji na

obiekcie (lub klasie), określają one, jakie

komunikaty rozumieją obiekty klasy.

Podstawowymi składnikami metody są: nazwa,

argumenty, zwracany typ oraz ciało metody:

zwracanyTyp nazwaMetody(/*argumenty*/) {

/* cialo metody */

}

W JAVIE metody mogą być jedynie składowymi

klas!

Klasy - metody

Przykładowa funkcja (musi być zdefiniowana

wewnątrz klasy) która pobiera jeden argument

typu String i zwraca int:

int foo(String s) {

return s.length() * 2;

}

Funkcja bezargumentowa, nic nie zwracająca:

void fun() {

/* zrob cos */

return; /* return może być pominiete */

}

Słowo kluczowe static

Poprzedzenie składowej (pola, metody) słowem

static

oznacza, że ta składowa odnosi się do

klasy

a nie do

obiektu

Jest ono użyteczne gdy:



Chcemy aby jakieś pole było współdzielone

przez wszystkie obiekty danej klasy, lub żeby

istniało gdy nie istnieją jeszcze żadne obiekty

tej klasy



Potrzebujemy metody, która nie jest związana

z żadnym konkretnym obiektem klasy

Operator przypisania ‘=‘

Operator ten przypisuje elementowi po lewej stronie

wartość elementu znajdującego się po prawej stronie.

Nie można przypisywać niczego do elementów stałych:

a = 4; /* przypisanie wartosci 4 do zmiennej a */
4 = a; /* BLAD proba przypisania do stalej */

Dla typów prostych

przypisanie

oznacza

skopiowanie

zawartości.

Dla typów obiektowych, w przypadku których

manipulujemy referencjami, przypisanie oznacza

ustawienie referencji będącej po lewej stronie operatora

na obiekt wskazywany przez referencję po prawej stronie

operatora.

Operatory matematyczne

Przykład:

public class AutoInc {

public static void main(String[] args) {

int a = 0;

int x = 0;

x = a++; /* x ma wartosc 0 */

x = a; /* x ma wartosc 1 */

a = 0;

x = ++a; /* x ma wartosc 1 */

x = a; /* x dalej ma wartosc 1 */

}

Operatory porównania

●

Operator równości (==)

●

Operator nierówności (!=)

●

Operator mniejszości (<)

●

Operator większości (>)

●

Operator ‘mniejszy lub równy’ (<=)

●

Operator ‘większy lub równy’ (>=)

Wszystkie operatory porównania zwracają

wynik typu

boolean

(

true

lub

false

)

Operatory porównania

Porównanie obiektów wersja 1:

public class Porownanie1 {

public static void main(String[] args) {

Integer n1 = new Integer(56);

Integer n2 = new Integer(56);

System.out.println(n1 == n2);

System.out.println(n1 != n2);

}

Operatory porównania

Porównanie obiektów wersja 2:

public class Porownanie2 {

public static void main(String[] args) {

Integer n1 = new Integer(56);

Integer n2 = new Integer(56);

System.out.println(n1.equals(n2));

}

Operatory

? :

<< >> >>>

<<=

>>=

>>>=

http://java.sun.com/docs/books/tutorial/java/nutsandbolts/opsummary.html

Wyrażenie warunkowe

Postać wyrażenia warunkowego:

boolean-exp ? value0 : value1

W przypadku gdy boolean-exp ma wartość

true

wyrażenie przyjmuje wartość

value0,

natomiast w

przypadku gdy ma wartość

false

wyrażenie przyjmuje

wartość

value1

Przykład:

static int abs(int v) {

return v > 0 ? v: -v;

}

Instrukcja warunkowa if-else

Składnia:

if( Boolean-expression )

statement

else

statement

lub:

if( Boolean-expression )

statement

Instrukcja break

Instrukcja

break

służy do przerywania wykonywania

bieżącego poziomu pętli.

Przykład:

static void breakTest(int v) {

for( int i = 0; i < 100; i++ ) {

if( v/i < 10 ) break;

System.out.println(i)

}

Instrukcja break cd.

Przykład 2:

static void breakTest2() {

int i = 0;

while( true ) {

if( i > 100 ) break;

System.out.println(i);

i++;

}

Instrukcja continue

Instrukcja

continue

przerywa wykonywanie bieżącej

iteracji pętli i przechodzi do następnej iteracji

rozpoczynając od początku ciała pętli.

Przykład:

static void continueTest() {

for( int i = 0; i < 100; i++ ) {

if( i % 10 < 2 ) continue;

System.out.println(i)

}

Instrukcja wyboru switch

Składnia:

switch(integral-selector) {

case integral-val1: statement; break;

case integral-val2: statement; break;

case integral-val3: statement; break;

//...

default: statement;

}

Instrukcja wyboru switch cd.

Przykład:

public static void switchTest(int v) {

int r = v %4;

switch(r) {

case 0:

System.out.println(”Podzielna przez 4”);

break;

case 1:

System.out.println(”Reszta z dzielenia wynosi 1”);

break;

// ...

}

Konstruktor

●

Konstruktor jest metodą klasy służącą do inicjalizacji

nowo tworzonych obiektów tej klasy.

●

Konstruktor jest automatycznie wołany gdy tworzony

jest nowy obiekt.

●

Nazwa konstruktora jest taka jak nazwa klasy do której

należy

●

Jeśli nie zdefiniuje się żadnego konstruktora to

dodawany jest automatycznie domyślny konstruktor

bezparametrowy

Konstruktor

Przykład:

class Kwadrat {

Kwadrat() {

System.out.println(”Konstruktor klasy Kwadrat”);

}

public class TestKonstruktora1 {

public static void main(String[] args) {

for(int i = 0; i < 10; i++)

new Kwadrat();

}

Konstruktor

Przykład 2:

class Kwadrat {

Kwadrat(int b) {

System.out.println(”Ctor klasy Kwadrat o boku ” + b);

}

public class TestKonstruktora2 {

public static void main(String[] args) {

for(int i = 0; i < 10; i++)

new Kwadrat(i);

}

Konstruktor

Przykład 3:

class Kwadrat {

Kwadrat() {

System.out.println(”Konstruktor klasy Kwadrat”);

}

Kwadrat(int b) {

System.out.println(”Ctor klasy Kwadrat o boku ” + b);

}

Konstruktor

Przykład 3 cd:

public class TestKonstruktora3 {

public static void main(String[] args) {

for(int i = 0; i < 10; i++) {

if( i % 3 != 0 ) {

new Kwadrat(i);

}

else {

new Kwadrat();

}

Przeciążanie funkcji w klasie

W ramach jednej klasy nie może być dwóch

metod o takich samych nazwach i odbieranych

parametrach.

Mogą natomiast istnieć dwie metody o takich

samych nazwach ale różniące się odbieranymi

parametrami – decyzja, której z nich użyć jest

podejmowana na podstawie parametrów.

Przeciążanie funkcji w klasie cd.

Przykład:

class P {

void foo() {

System.out.println(”Foo wersja 1”);

}

void foo(int i) {

System.out.println(”Foo wersja 2”);

}

void foo(String s) {

System.out.println(”Foo wersja 3”);

}

Przeciążanie funkcji w klasie cd.

Przykład cd.:

public class TestPrzeciazania {

public static void main(String[] args) {

P p1 = new P();

p.foo(); // wersja 1

p.foo(10); // wersja 2

p.foo(”Test”); // wersja 3

}

Słowo kluczowe this

Słowo kluczowe

this

może być używane tylko wewnątrz

niestatycznych

metod klasy i oznacza bieżący obiekt na

którym wykonywana jest metoda.

Przykład:

class X { void f(int i) { /*...*/ } }

X a = new X(), b = new X();

a.f(1);

b.f(2);

Funkcja f musi wiedzieć na którym obiekcie klasy X ma

operować jest to możliwe dzięki przekazaniu do niej ukrytej

referencji do obiektu jako pierwszego argumentu.

Słowo kluczowe this cd.

Ponieważ referencja do obiektu jest ukryta nie ma do niej

normalnego dostępu, jednak właśnie słowo kluczowe

this

zapewnia ten dostęp.

Normalnie nie ma potrzeby używania słowa kluczowego

this

Przykład:

class Y {

void f1() { /* ... */ }

void f2() { f1(); /* ... */ }

void f3() { this.f1(); /* ... */ }

}

Słowo kluczowe this cd.

Przykład 2:

class Z {

int i = 0;

Z zwieksz() { i++; return this; }

void print() { System.out.println(”i=” + i); }

public static void main(String[] args) {

Z a = new Z();

a.zwieksz().zwieksz().zwieksz().print();

}

Wywołanie konstruktora z innego
konstruktora

Przykład:

class Prostokat {

int bokA = 0;

int bokB = 0;

Prostokat(int a, int b) {

bokA = a;

bokB = b;

}

// ...

Wywołanie konstruktora z innego
konstruktora cd.

// ...

Prostokat(int a) {

this(a,a);

}

Prostokat() {

this(10,10);

//! this(10); // nie można wolac dwa razy

}

Inicjalizacja zmiennych

Java nie gwarantuje, że stworzona zmienna jest

poprawnie zainicjalizowana. W przypadku gdy wystąpi

próba odwołania do niezainicjalizowanej zmiennej,

podczas kompilacji zostanie zgłoszony błąd.

Przykład:

void foo() {

int i;

i++;

}

Inicjalizacja składowych obiektu

Gdy składowymi klasy są typy proste to Java domyślnie je

inicjalizuje:

class Wartosci {

boolean t; // domyslna war. false

char c; // domyslna war. ‘\0’

byte b; // domyslna war. 0

short s; // domyslna war. 0

int i; // domyslna war. 0

long l; // domyslna war. 0

float f; // domyslna war. 0.0

double d; // domyslna war. 0.0

//...

}

Inicjalizacja składowych obiektu

W Javie można do składowych przypisać wartość

początkową inną niż wartość domyślna:

class Wartosci {

boolean t = true;

char c = ‘q’

byte b = 10;

short s = 0xaa

int i = 555;

long l = 23

float f = 3.14f

double d = 3.141592;

Kwadrat k = new Kwadrat(); // inicjalizacja referencji

}

Inicjalizacja składowych obiektu

Można też zawołać funkcje w celu inicjalizacji zmiennej:

class Inicjalizacja {

int i = f();

}

Można wołać też funkcje z parametrami, ale parametrami

nie mogą być niezainicjalizowane zmienne:

class Inicjalizacja {

//! j = g(i); // blad ‘i’ nie jest zainicjalizowane

int i = f();

int j = g(i); // ok. ‘i’ jest już zainicjalizowane

}

Inicjalizacja tablic

Definicja tablicy:

int[] t1;

lub

int t1[]; // definicja w stylu C

Inicjalizacja tablicy:

int t1[] = { 1, 5, 6, 13 };

Możliwe jest też przypisanie jednej tablicy do drugiej,

jest to przypisanie

referencji

int[] t2;

t2 = t1;

Inicjalizacja tablic cd.

Przykład:

public class Tablice {

public static void main(String[] args) {

int[] t1 = { 1, 2, 5, 8, 12 };

int[] t2;

t2 = t1;

for(int i = 0; i < t2.length; i++)

t2[i]++;

for(int i = 0; i < t1.length; i++)

System.out.println(

”

t1[” + i + ”] = ” + t1[i] );

}

Inicjalizacja tablic cd.

Możliwe jest też określenie rozmiaru inicjalizowanej

tablicy:

int[] t = new int[54];

Dla typów obiektowych oprócz zainicjalizowania

samej tablicy, trzeba też inicjalizować każdy

element tej tablicy:

Integer[] t = new Integer[20]; // inicjalizacja tablicy

for(int i = 0; i < t.length; i++ ) {

t[i] = new Integer(0); // inicjalizacja elementow

}

Tablice wielowymiarowe

Java pozwala na łatwy sposób tworzenia tablic

wielowymiarowych:

int[][] t1 = {

{ 1, 2, 3},

{ 4, 5, 6},

};

for(int i = 0; i < t1.length; i++)

for(int j = 0; j < t1[i].length; j++)

System.out.println( ”t1[” + i + ”][” + j +

”

] = ” + t1[i][j]);

//...

Dostęp do składowych klasy

●

Jeśli nie ma określonego specyfikatora postępu to jako

domyślny przyjmowany jest „friend”, który oznacza

możliwość postępu w ramach tego samego pakietu

(pliku).

Dostęp w ramach pakietu

●

Specyfikator

public

oznacza, że wszyscy mają dostęp do

składowej

●

Specyfikator

private

dopuszcza dostęp do składowej

tylko w ramach tej samej klasy

●

Specyfikator

protected

dopuszcza dostęp do składowej

tylko w ramach tej samej klasy i klas z niej

dziedziczących

Dziedziczenie

Przykład:

class A {

private String s = new String(”Klasa A”);

public void append(String str) { s += str; }

public void foo1() { append(” foo1()”); }

public void foo2() { append(” foo2()”); }

public void print() { System.out.println(s); }

public static void main(String[] args) {

A obiekt1 = new A();

obiekt1.foo1(); obiekt1.foo2();

obiekt1.print();

}

Dziedziczenie

Przykład cd:

public class B extends A {

public void foo2() {

append(” B.foo2()”);

super.foo2(); // wywolanie metody klasy bazowej

}

public void foo3() { append(” foo3()”); }

public static void main(String[] args) {

B obiekt = new B();

obiekt.foo1(); obiekt.foo2(); obiekt.foo3();

A.main(args); // test klasy bazowej

}

Implementacja obiektów

public class Czytelnik {

public Czytelnik() {
}

private String imie;

private String nazwisko;

void wypozyczKsiazke(Long

identyfikatorKsiazki) {

// ... implementacja
}

void zwrocKsiazke(Long

identyfikatorKsiazki) {

// ... implementacja

}

Szablony klas

●

'Para' wersja 1 – typy Object

public class ParaV1 {

Object pierwszy;

Object drugi;

public ParaV1(Object p, Object d) {

pierwszy = p;

drugi = d;

}

public Object getPierwszy() { return pierwszy; }

public void setPierwszy(Object p) { pierwszy = p; }

//...

public static void main(String[] args) {

ParaV1 para = new ParaV1("tekst", new Integer(20));

String tekst = (String)para.getPierszy(); // !!!

}

Szablony klas

●

'Para' wersja 2 – klasa uogólniona (szablon)

public class ParaV2<S,T> {

S pierwszy;

T drugi;

public ParaV2(S p, T d) {

pierwszy = p;

drugi = d;

}

public S getPierszy() { return pierwszy; }

public void setPierwszy(S p) { pierwszy = p; }

//...

public static void main(String[] args) {

ParaV2<String, Integer> p1 = new ParaV2<String,

Integer>("tekst", new Integer(20));

String tekst = p1.getPierwszy();

ParaV2<Integer, Integer> p2 = new ParaV2<Integer,

Integer>(new Integer(0), new Integer(20));

Integer i = p2.getPierwszy();

} }

Szablony klas

●

'Para' wersja 2 – klasa uogólniona (szablon)

public class ParaV2<S,T> {

//...

// niepoprawna funkcja !!!

void foo() {

pierwszy.wypozyczKsiazke(new Long(1));

}

Szablony klas

●

'Para' wersja 2 (szablon) – metoda zamiany na
String

public class ParaV2<S,T> {

//...

public String toString() {

return new String(”Para: [ ” + pierwszy + ”, ” +

drugi + ”]”);

}

Szablony klas

public class ParaV2<S,T> {

//...

public boolean equals(Object o) {

if (!(o instanceof Para<?,?>)) return false;

Para<S, T> p = (Para<S,T>)o;

if ((getPierwszy() != null) && (getDrugi() != null))

return getPierwszy().equals(p.getPierwszy()) &&

getDrugi().equals(p.getDrugi());

else

if ((getPierwszy() == null) && (getDrugi() == null))

return (p.getPierwszy() == null) && (p.getDrugi() == null);

else

if (getPierwszy() == null)

return (p.getPierwszy()==null) &&

(getDrugi().equals(p.getDrugi()));

else

return getPierwszy().equals(p.getPierwszy()) &&

(p.getDrugi()==null);

}

Metody parametryzowane typami

public class TestMetody {

<T> ParaV2<T,T> utworzPare(T v) {

return new ParaV2<T,T>(v, v);

}

void test() {

ParaV2<Integer, Integer> p =

utworzPare(new Integer(202));

}

Szablony klas

●

'Para' wersja 3 – klasa uogólniona z
ograniczeniami

public class ParaV3<S extends Comparable<S> ,T extends

Comparable<T> > {

S pierwszy;

T drugi;

public ParaV3(S p, T d) {

pierwszy = p;

drugi = d;

}

public S getPierwszy() { return pierwszy; }

public void setPierwszy(S p) { pierwszy = p; }

// ...

}

Szablony klas

●

'Para' wersja 4 – klasa uogólniona z większymi
ograniczeniami

public class ParaV3<S extends Comparable<S> ,T extends

ParaV2<T,T> & Comparable<T> > {

S pierwszy;

T drugi;

public ParaV3(S p, T d) {

pierwszy = p;

drugi = d;

}

public S getPierwszy() { return pierwszy; }

public void setPierwszy(S p) { pierwszy = p; }

// ...

}

Wilcards (dżokery)

public int IloscElementow(Collection<?> c) {

//...

}

public <T> void wstaw(T elem, Collection<? super T> kol) {

//...

}

Wyjątki

●

Sytuacje wyjątkowe mogą wystąpić nawet w
bezbłędnie napisanych programach. Przykłady:

–

Błędne dane podane przez użytkownika (np. obliczanie

pierwiastka kwadratowego, rzeczywistego z ujemnej
liczby)

–

Brak miejsca na dysku do zapisania danych

–

Brak pamięci

●

Program (i język programowania) powinien
umożliwiać obsługę takich sytuacji wyjątkowych.

●

Zazwyczaj nie jest możliwa

Wyjątki

●

Program składa się z wielu modułów, dodatkowo
moduły mogą pochodzić z różnych bibliotek

–

problemy:

●

autor biblioteki może wykryć błędy czasu wykonywania, ale

nie wie co z nimi zrobić

●

użytkownik biblioteki może wiedzieć, jak postępować z
takimi błędami, lecz nie może ich wykryć – gdyby mógł

obsłużyłby je we własnym kodzie

–

rozwiązanie - rozdzielenie obsługi błędów na:

●

powiadamianie o błędnych warunkach, których nie można

obsłużyć lokalnie

●

obsługę błędów wykrytych gdzie indziej

Wyjątki w Javie

public class Wyjatek {

void metoda(boolean x) throws Exception {

if(x == false) throw new Exception();

}

public static void main(String[] args) throws Exception {

Wyjatek w = new Wyjatek();

System.out.println("przed metoda");

w.metoda(false);

System.out.println("po metodzie");

}

Wyjątki w Javie

przed metoda

Exception in thread "main" java.lang.Exception

at Wyjatek.metoda(Wyjatek.java:3)

at Wyjatek.main(Wyjatek.java:9)

●

Wynik działania:

Wyjątki w Javie

public class Wyjatek {

void metoda(boolean x) throws Exception {

if(x == false) throw new Exception();

}

public static void main(String[] args) throws Exception {

Wyjatek w = new Wyjatek();

System.out.println("przed metoda");

try {

w.metoda(false);

} catch(Exception ex) {

System.out.println("Obsluga Wyjatku");

ex.printStackTrace(System.out);

}

System.out.println("po metodzie");

}

Wyjątki w Javie

przed metoda

Obsluga Wyjatku

java.lang.Exception

at Wyjatek.metoda(Wyjatek.java:3)

at Wyjatek.main(Wyjatek.java:10)

po metodzie

●

Wynik działania: