Programowanie obiektowe /Java/
Laboratorium nr 4
1 Konstruktor domyślny
1 package pl.kielce.tu.lab4;
2
3 public class Constructor {
4 }
Przykład 1: src/pl/kielce/tu/lab4/Constructor.java{link}
Kompilacja (z poziomu katalogu src):
javac pl/kielce/tu/lab4/Constructor.java
Deasemblacja (z poziomu katalogu src):
javap pl.kielce.tu.lab4.Constructor
Wynik:
Compiled from "Constructor.java"
public class Constructor extends java.lang.Object {
public Constructor();
}
2 Wywoływanie konstruktorów z konstruktorów this
1 package pl.kielce.tu.lab4;
2
3 class Constructors {
4 int i;
5 int j;
6
7 Constructors(int i) {
8 this.i = 1;
9 }
10
11 Constructors(int i, int j) {
12 this(i);
13 this.j = j;
14 }
15
16 public static void main(String[] args) {
17 Constructors c1 = new Constructors(5);
18 Constructors c2 = new Constructors(10, 11);
19 System.out.println("c1.i = " + c1.i + " c1.j = " + c1.j);
20 System.out.println("c2.i = " + c2.i + " c2.j = " + c2.j);
21 }
22 }
Przykład 2: src/pl/kielce/tu/lab4/Constructors.java{link}
1
3 Inicjalizacja składowych
Zmienne lokalne muszą zostać zainicjalizowane przed użyciem:
void function(){
int i;
System.out.println(i); //Błąd
}
Inicjalizacja składowych klasy wykonywana jest automatycznie.
1 package pl.kielce.tu.lab4;
2
3 public class Init {
4 int i;
5 int j = 7;
6 int k;
7 String p;
8 String q = "\\\\--//";
9 String s;
10
11 Init() {
12 i = 10;
13 p = "//--\\\\";
14 }
15
16 public static void main(String[] args) {
17 Init init = new Init();
18 System.out.println("i = " + init.i + " p = " + init.p);
19 System.out.println("j = " + init.j + " q = " + init.q);
20 System.out.println("k = " + init.k + " s = " + init.s);
21 }
22 }
Przykład 3: src/pl/kielce/tu/lab4/Init.java{link}
4 Jawna inicjalizacja statyczna static{}
1 package pl.kielce.tu.lab4;
2
3 import java.util.Random;
4
5 public class StaticInit {
6 static int n;
7 static {
8 Random r = new Random();
9 for (int i = 0; i < 10; i++)
10 n += r.nextInt();
11 n /= 10;
12 }
13
14 public static void main(String[] args) {
15 System.out.println("StaticInit.n = " + StaticInit.n);
16 }
17 }
Przykład 4: src/pl/kielce/tu/lab4/StaticInit.java{link}
2
5 Inicjalizacja egzemplarza{}
1 package pl.kielce.tu.lab4;
2
3 import java.util.Random;
4
5 public class ObjectInit {
6 int i;
7 int j;
8 int n;
9 {
10 Random r = new Random();
11 for (int i = 0; i < 10; i++)
12 n += r.nextInt();
13 n /= 10;
14 }
15
16 ObjectInit(int i) {
17 this.i = i;
18 }
19
20 ObjectInit(int i, int j) {
21 this.i = i;
22 this.j = j;
23 }
24
25 public static void main(String[] args) {
26 ObjectInit i1 = new ObjectInit(1);
27 System.out.println("i1.n = " + i1.n);
28 ObjectInit i2 = new ObjectInit(2, 3);
29 System.out.println("i2.n = " + i2.n);
30 }
31 }
Przykład 5: src/pl/kielce/tu/lab4/ObjectInit.java{link}
6 Inicjalizacja tablicy
1 package pl.kielce.tu.lab4;
2
3 import java.util.Arrays;
4
5 class TableInit {
6
7 public static void main(String[] args) {
8
9 int[] tab1 = new int[3];
10 System.out.println("tab1.length = " + tab1.length + " tab1[0] = " + tab1[0]);
11 int[] tab2 = { 10, 20, 30 };
12 System.out.println("tab2.length = " + tab2.length + " tab2[0] = " + tab2[0]);
13 String tab3[] = new String[3];
14 System.out.println("tab3.length = " + tab3.length + " tab3[0] = " + tab3[0]);
15 String tab4[] = "Ala ma kota".split(" ");
16 System.out.println("tab4.length = " + tab4.length + " tab4[0] = " + tab4[0]);
17
18 boolean tab5[];
19 // System.out.println("tab5.length = " + tab5.length); // Błąd
20 // tab5 = {true, false, true}; // Błąd
3
21 tab5 = new boolean[3];
22 // System.out.println("tab5[4] = " + tab5[4]); // Wyjątek
23
24 int[] tab6 = tab2;
25 System.out.println("tab6.length = " + tab6.length + Arrays.toString(tab6));
26 int[] tab7 = Arrays.copyOf(tab2, 2);
27 System.out.println("tab7.length = " + tab7.length + Arrays.toString(tab7));
28 int[] tab8 = Arrays.copyOfRange(tab2, 1, 2);
29 System.out.println("tab8.length = " + tab8.length + Arrays.toString(tab8));
30
31 }
32 }
Przykład 6: src/pl/kielce/tu/lab4/TableInit.java{link}
7 Zmienne listy argumentów
1 package pl.kielce.tu.lab4;
2
3 class VarArgs {
4
5 static void main1(Object[] args) {
6 for (Object o : args)
7 System.out.println(o);
8 }
9
10 static void main2(Object... args) {
11 for (Object o : args)
12 System.out.println(o);
13 }
14
15 public static void main(String[] args) {
16 // main1(1,2,3); //Błąd
17 // main1(java.lang.Object[]) in VarArgs cannot be applied to (int,int,int)
18 main1(new Object[] { 1, 2, 3 });
19 main2(1, 2, 3);
20 }
21 }
Przykład 7: src/pl/kielce/tu/lab4/VarArgs.java{link}
8 Typy wyliczeniowe
1 package pl.kielce.tu.lab4;
2
3 enum Days {
4 MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
5 };
6
7 public class Enums {
8
9 private static String engToPl(Days d) {
10 switch (d) {
11 case MONDAY:
12 return "Poniedziałek";
13 case TUESDAY:
14 return "Wtorek";
4
15 case WEDNESDAY:
16 return "Środa";
17 case THURSDAY:
18 return "Czwartek";
19 case FRIDAY:
20 return "Piątek";
21 case SATURDAY:
22 return "Sobota";
23 case SUNDAY:
24 return "Niedziela";
25 default:
26 return "";
27 }
28 }
29
30 public static void main(String[] args) {
31 Days d = Days.MONDAY;
32 System.out.println(d.ordinal() + " : " + engToPl(d));
33 d = Days.SUNDAY;
34 System.out.println(d.ordinal() + " : " + engToPl(d));
35 }
36 }
Przykład 8: src/pl/kielce/tu/lab4/Enums.java{link}
Kompilacja (z poziomu katalogu src):
javac pl/kielce/tu/lab4/*.java
Deasemblacja (z poziomu katalogu src):
javap pl.kielce.tu.lab4.Days
Wynik:
Compiled from "Enums.java"
final class pl.kielce.tu.lab4.Days extends java.lang.Enum {
public static final pl.kielce.tu.lab4.Days MONDAY;
public static final pl.kielce.tu.lab4.Days TUESDAY;
public static final pl.kielce.tu.lab4.Days WEDNESDAY;
public static final pl.kielce.tu.lab4.Days THURSDAY;
public static final pl.kielce.tu.lab4.Days FRIDAY;
public static final pl.kielce.tu.lab4.Days SATURDAY;
public static final pl.kielce.tu.lab4.Days SUNDAY;
public static pl.kielce.tu.lab4.Days[] values();
public static pl.kielce.tu.lab4.Days valueOf(java.lang.String);
static {};
}
9 Finalizatory
 W C++1 obiekty są zawsze niszczone (w programach wolnych od błędów), podczas gdy w Javie obiekty
nie zawsze podlegają odśmiecaniu, albo mówiąc inaczej:
1. Obiekty mogą nie zostać poddane odśmiecaniu.
2. Odśmiecanie pamięci to nie to samo co destrukcja obiektów.
3. Odśmiecanie dotyczy wyłącznie pamięci.
 finalize() istnieje ze względu na możliwość wykonywania czegoś w stylu języka C  alokacji pamięci za
pomocą mechanizmu innego niż normalny dla Javy. Może się to odbywać poprzez metody natywne, które są
sposobem na wywołanie z Javy kodu nienapisanego w Javie.
1
Thinking in Java, Bruce Eckel, Wydanie IV, Helion, 2006
5
10 Przykładowa treść laboratorium
Proszę stworzyć oraz uruchomić aplikację zgodną ze specyfikacją podaną przez prowadzącego.
6