file_id stringlengths 5 10 | content stringlengths 57 33.1k | repo stringlengths 8 77 | path stringlengths 6 174 | token_length int64 19 8.19k | original_comment stringlengths 7 10.6k | comment_type stringclasses 2
values | detected_lang stringclasses 1
value | prompt stringlengths 21 33.1k |
|---|---|---|---|---|---|---|---|---|
2759_33 | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, aplikacja też jest usuwana
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania aplikacji do innego komputera:
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis jest niepoprawny
// Application a = new Application("SQL Server", "2019", computer2);
}
} | Barteck197/PJ-MAS-2 | src/Main.java | 1,651 | // z bazy, aplikacja też jest usuwana | line_comment | pl | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, <SUF>
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania aplikacji do innego komputera:
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis jest niepoprawny
// Application a = new Application("SQL Server", "2019", computer2);
}
} |
2759_34 | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, aplikacja też jest usuwana
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania aplikacji do innego komputera:
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis jest niepoprawny
// Application a = new Application("SQL Server", "2019", computer2);
}
} | Barteck197/PJ-MAS-2 | src/Main.java | 1,651 | // Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną | line_comment | pl | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, aplikacja też jest usuwana
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu <SUF>
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania aplikacji do innego komputera:
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis jest niepoprawny
// Application a = new Application("SQL Server", "2019", computer2);
}
} |
2759_35 | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, aplikacja też jest usuwana
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania aplikacji do innego komputera:
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis jest niepoprawny
// Application a = new Application("SQL Server", "2019", computer2);
}
} | Barteck197/PJ-MAS-2 | src/Main.java | 1,651 | // Próba przypisania aplikacji do innego komputera: | line_comment | pl | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, aplikacja też jest usuwana
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania <SUF>
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis jest niepoprawny
// Application a = new Application("SQL Server", "2019", computer2);
}
} |
2759_36 | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, aplikacja też jest usuwana
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania aplikacji do innego komputera:
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis jest niepoprawny
// Application a = new Application("SQL Server", "2019", computer2);
}
} | Barteck197/PJ-MAS-2 | src/Main.java | 1,651 | // Taki zapis jest niepoprawny | line_comment | pl | import java.time.LocalDate;
public class Main {
public static void main(String[] args) {
System.out.println("* Asocjacja binarna:");
// ================== asocjacja binarna ================== //
// Przypadek biznesowy: Pracownik może posiadać wiele kluczy-kart
// ale jedna karta może mieć w danym momencie tylko jednego właścicela
Employee e1 = new Employee("Marek");
Employee e2 = new Employee("Ania");
Employee e3 = new Employee("Jan");
KeyCard c1 = new KeyCard();
KeyCard c2 = new KeyCard();
KeyCard c3 = new KeyCard();
// Powiązanie Pracownika z kartą
// tutaj przykład wywołania metody na obiekcie klasy KeyCard
c1.setOwner(e1);
c2.setOwner(e1);
c3.setOwner(e2);
// Próba ustawienia nowego właściciela karty
c1.setOwner(e3);
// ... można też wywołać metodę na obiekcie Employee
e3.addKeyCard(c2);
e1.listCards();
e2.listCards();
e3.listCards();
System.out.println("* Asocjacja z atrybutem:");
// ================== asocjacja z atrybutem ================== //
// Przypadek biznesowy: Klient składa zamówienie w sklepie
// Relacja: Klient <-> Produkt wymaga stworzenia
// dodatkowej klasy asocjacji: Zamówienie. Liczności: w relacji
// klient <-> produkt = *-*
Client client1 = new Client("Adrianna");
Client client2 = new Client("Monika");
// Client client3 = new Client("Krzysztof");
Product product1 = new Product("Jabłko", 3.49f);
Product product2 = new Product("Gruszka", 3.99f);
// Product product3 = new Product("Banan", 2.49f);
// Product product4 = new Product("Brzoskwinia", 5.49f);
// Product product5 = new Product("Liczi", 8.79f);
// Product product6 = new Product("Śliwka", 6.99f);
// W momencie tworzenia zamówienia automatycznie tworzone jest
// połączenie zwrotne z instancjami obiektów client i product
Order order1 = new Order(LocalDate.of(2022, 12, 16), 5, client1, product1);
System.out.println(client1.getClientName());
System.out.println(product1.getProductName());
System.out.println(order1);
Order order2 = new Order(LocalDate.of(2022, 12, 14), 12);
// Teoretycznie można przypisać zamówienie do klienta i produktu po utworzeniu
// zamówienia w systemie, choć biznesowo nie ma to za bardzo sensu.
// Technicznie jest to możliwe
// Zarówno od strony klienta
client2.addOrder(order2);
// Jak i od strony zamówienia
order2.setClient(client2);
// W takim przypadku należy też pamiętać o przypisaniu produktu
product2.addToOrder(order2);
// albo
order2.setProduct(product2);
System.out.println(client2.getClientName());
System.out.println(order2);
System.out.println("* Asocjacja kwalifikowana:");
// ================== asocjacja kwalifikowana ================== //
// Przypadek biznesowy: W zespole gra wielu zawodników, każdy z nich
// ma przypisany numer, który nosi na koszulce. Po tym numerze można
// jednoznacznie zidentyfikować zawodnika w ramach zespołu
Player p1 = new Player("London", "Donovan", "US", 8);
Player p2 = new Player("Artur", "Boruc", "PL", 1);
Player p3 = new Player("Sergio", "Aguero", "UR", 11);
Player p4 = new Player("Andrij", "Deshchytsia", "BL", 76);
Team t1 = new Team("FK Kovno");
Team t2 = new Team("Atletic Alicante");
p1.setTeam(t1);
p2.setTeam(t2);
p3.setTeam(t1);
p4.setTeam(t2);
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(p4);
// Szukamy gracza z numerem 1 w drużynie 2
try {
System.out.println(t2.findPlayerInTeam(1));
} catch (Exception e) {
throw new RuntimeException(e);
}
System.out.println("* kompozycja");
// ================== kompozycja ================== //
// Przypadek biznesowy: Aplikacja zainstalowana na komputerze
// nie może istnieć samodzielnie. W momencie usunięcia komputera
// z bazy, aplikacja też jest usuwana
Computer computer1 = new Computer("Stacja robocza anowak");
Computer computer2 = new Computer("Serwer biurowy");
try {
// Tworzenie obiektu Application odbywa się poprzez specjalną metodę statyczną
Application app1 = Application.CreateApplication(computer1, "Apache", "2.4");
System.out.println(app1);
// Próba przypisania aplikacji do innego komputera:
// computer2.addApplication(app1);
} catch (Exception e) {
throw new RuntimeException(e);
}
// Taki zapis <SUF>
// Application a = new Application("SQL Server", "2019", computer2);
}
} |
2760_0 | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
| Arax734/ChessGame | src/pole.java | 507 | // cyfra odpowiadajaca poziomej pozycji | line_comment | pl | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca <SUF>
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
|
2760_1 | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
| Arax734/ChessGame | src/pole.java | 507 | // cyfra odpowiadajaca pionowej pozycji | line_comment | pl | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca <SUF>
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
|
2760_2 | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
| Arax734/ChessGame | src/pole.java | 507 | // ewentualna przypisana figura | line_comment | pl | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana <SUF>
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
|
2760_3 | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
| Arax734/ChessGame | src/pole.java | 507 | // Sprawdzamy czy pionek przeciwnika może ruszyć się na pole | line_comment | pl | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy <SUF>
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
|
2760_4 | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch dla pozycji pola
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
| Arax734/ChessGame | src/pole.java | 507 | // Symulujemy ruch dla pozycji pola | line_comment | pl | public class pole {
private String color; // kolor pola
private int szerokosc; // cyfra odpowiadajaca poziomej pozycji
private int wysokosc; // cyfra odpowiadajaca pionowej pozycji
protected figura figura; // ewentualna przypisana figura
public pole(int szerokosc, int wysokosc, String color) {
this.szerokosc = szerokosc;
this.wysokosc = wysokosc;
this.color = color;
}
public String getColor() {
return color;
}
public int getWysokosc() {
return wysokosc;
}
public int getSzerokosc() {
return szerokosc;
}
public figura getFigure() {
return figura;
}
public void setFigure(figura figura) {
this.figura = figura;
}
public boolean czy_pole_jest_atakowane(pole[][] szachownica, String color){
// Sprawdzamy czy pionek przeciwnika może ruszyć się na pole
for (int rank = 0; rank < 8; rank++) {
for (int file = 0; file < 8; file++) {
pole currentSquare = szachownica[rank][file];
figura currentPiece = currentSquare.getFigure();
if (currentPiece != null && currentPiece.getColor() != color) {
// Symulujemy ruch <SUF>
if (currentPiece instanceof pion) {
if (currentPiece.symuluj_ruch_dla_krola(this, szachownica)) {
return true;
}
} else if (currentPiece.symuluj_ruch(this, szachownica)) {
return true;
}
}
}
}
return false;
}
}
|
2761_0 | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
| gbzaleski/PO-1-Pokrycie-Zbioru | cover/Set.java | 411 | // Klasa pojedynczego setu. | line_comment | pl | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego <SUF>
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
|
2761_1 | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
| gbzaleski/PO-1-Pokrycie-Zbioru | cover/Set.java | 411 | // Dodanie zbioru elementów naturalnych. | line_comment | pl | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru <SUF>
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
|
2761_2 | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
| gbzaleski/PO-1-Pokrycie-Zbioru | cover/Set.java | 411 | // Dodanie ciagu nieskończonego. | line_comment | pl | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu <SUF>
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
|
2761_3 | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
| gbzaleski/PO-1-Pokrycie-Zbioru | cover/Set.java | 411 | // Dodanie ciagu skończonego. | line_comment | pl | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu <SUF>
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
|
2761_4 | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
| gbzaleski/PO-1-Pokrycie-Zbioru | cover/Set.java | 411 | // Obliczenie ile nowych elementów może pokryć ten set. | line_comment | pl | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile <SUF>
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
|
2761_5 | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego zbioru tym setem.
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
| gbzaleski/PO-1-Pokrycie-Zbioru | cover/Set.java | 411 | // Pokrycie rozważanego zbioru tym setem. | line_comment | pl | package cover;
import java.util.ArrayList;
import java.util.Arrays;
// Klasa pojedynczego setu.
public class Set
{
ArrayList<SetElement> Elements;
public Set()
{
Elements = new ArrayList<>();
}
// Dodanie zbioru elementów naturalnych.
public void append(int[] tabDiscrete)
{
Elements.add(new Discrete(tabDiscrete));
}
// Dodanie ciagu nieskończonego.
public void append(int start, int step)
{
Elements.add(new Arithm(start, step));
}
// Dodanie ciagu skończonego.
public void append(int start, int step, int end)
{
Elements.add(new Arithm(start, step, end));
}
// Obliczenie ile nowych elementów może pokryć ten set.
public int allCommonValues(boolean[] curCovered)
{
boolean[] backUpCovered = Arrays.copyOf(curCovered, curCovered.length);
int counter = 0;
for (SetElement element: Elements)
{
counter += element.commonValues(backUpCovered);
}
return counter;
}
// Pokrycie rozważanego <SUF>
public void coverAll(boolean[] curCovered)
{
for (SetElement element: Elements)
{
element.cover(curCovered);
}
}
}
|
2763_1 | package CheckingMouse;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import CheckingMouse.EditingCheckingGraphMousePlugin.EdgeChecker;
import javax.swing.JOptionPane;
import model.Arc;
import model.MyVertex;
/**
* @author Elpidiusz
*/
public class ArcChecker implements EdgeChecker<MyVertex, Arc> {
@Override
public boolean checkEdge(Graph<MyVertex, Arc> g, VisualizationViewer<MyVertex, Arc> vv, Arc edge, MyVertex start, MyVertex end, EdgeType dir) {
if (start.getClass() == end.getClass()) {
JOptionPane.showMessageDialog(vv, "E, łączyć można tylko wierzchołki różnych typów",
"Arc check", JOptionPane.ERROR_MESSAGE);
return false;
} else if (g.findEdge(start, end) != null) {//może się przydać
JOptionPane.showMessageDialog(vv, "No parallel edges allowed in this graph!",
"Arc Check", JOptionPane.ERROR_MESSAGE);
return false;
}
return true;
}
}
| gre123/SMiP-Metody-Formalne- | SMiP/src/CheckingMouse/ArcChecker.java | 348 | //może się przydać | line_comment | pl | package CheckingMouse;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import CheckingMouse.EditingCheckingGraphMousePlugin.EdgeChecker;
import javax.swing.JOptionPane;
import model.Arc;
import model.MyVertex;
/**
* @author Elpidiusz
*/
public class ArcChecker implements EdgeChecker<MyVertex, Arc> {
@Override
public boolean checkEdge(Graph<MyVertex, Arc> g, VisualizationViewer<MyVertex, Arc> vv, Arc edge, MyVertex start, MyVertex end, EdgeType dir) {
if (start.getClass() == end.getClass()) {
JOptionPane.showMessageDialog(vv, "E, łączyć można tylko wierzchołki różnych typów",
"Arc check", JOptionPane.ERROR_MESSAGE);
return false;
} else if (g.findEdge(start, end) != null) {//może się <SUF>
JOptionPane.showMessageDialog(vv, "No parallel edges allowed in this graph!",
"Arc Check", JOptionPane.ERROR_MESSAGE);
return false;
}
return true;
}
}
|
2764_0 | //To funkcja wyewnątrz klasy, to funkja wykonywana przez obiekt stworzona wg klasy w symulowanym środowisku
// blok który zawiera jakieś instrukcje
// może być uruchomiona (wywoływana) poprzez odwołanie się do jej nazwy()
public class Metody {
public void policzWyynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int pobierzWynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
return result;
}
public void policzWyynikParam( int number){
System.out.println("Number ma wartość: " + number);
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< number; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int add(int firstNumber, int secondNumber, String word) {
System.out.println("Suma to: " + (firstNumber + secondNumber));
return firstNumber + secondNumber;
}
}
| AniaPasyk/JavaCourse | src/Metody.java | 429 | //To funkcja wyewnątrz klasy, to funkja wykonywana przez obiekt stworzona wg klasy w symulowanym środowisku | line_comment | pl | //To funkcja <SUF>
// blok który zawiera jakieś instrukcje
// może być uruchomiona (wywoływana) poprzez odwołanie się do jej nazwy()
public class Metody {
public void policzWyynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int pobierzWynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
return result;
}
public void policzWyynikParam( int number){
System.out.println("Number ma wartość: " + number);
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< number; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int add(int firstNumber, int secondNumber, String word) {
System.out.println("Suma to: " + (firstNumber + secondNumber));
return firstNumber + secondNumber;
}
}
|
2764_1 | //To funkcja wyewnątrz klasy, to funkja wykonywana przez obiekt stworzona wg klasy w symulowanym środowisku
// blok który zawiera jakieś instrukcje
// może być uruchomiona (wywoływana) poprzez odwołanie się do jej nazwy()
public class Metody {
public void policzWyynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int pobierzWynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
return result;
}
public void policzWyynikParam( int number){
System.out.println("Number ma wartość: " + number);
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< number; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int add(int firstNumber, int secondNumber, String word) {
System.out.println("Suma to: " + (firstNumber + secondNumber));
return firstNumber + secondNumber;
}
}
| AniaPasyk/JavaCourse | src/Metody.java | 429 | // blok który zawiera jakieś instrukcje | line_comment | pl | //To funkcja wyewnątrz klasy, to funkja wykonywana przez obiekt stworzona wg klasy w symulowanym środowisku
// blok który <SUF>
// może być uruchomiona (wywoływana) poprzez odwołanie się do jej nazwy()
public class Metody {
public void policzWyynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int pobierzWynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
return result;
}
public void policzWyynikParam( int number){
System.out.println("Number ma wartość: " + number);
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< number; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int add(int firstNumber, int secondNumber, String word) {
System.out.println("Suma to: " + (firstNumber + secondNumber));
return firstNumber + secondNumber;
}
}
|
2764_2 | //To funkcja wyewnątrz klasy, to funkja wykonywana przez obiekt stworzona wg klasy w symulowanym środowisku
// blok który zawiera jakieś instrukcje
// może być uruchomiona (wywoływana) poprzez odwołanie się do jej nazwy()
public class Metody {
public void policzWyynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int pobierzWynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
return result;
}
public void policzWyynikParam( int number){
System.out.println("Number ma wartość: " + number);
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< number; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int add(int firstNumber, int secondNumber, String word) {
System.out.println("Suma to: " + (firstNumber + secondNumber));
return firstNumber + secondNumber;
}
}
| AniaPasyk/JavaCourse | src/Metody.java | 429 | // może być uruchomiona (wywoływana) poprzez odwołanie się do jej nazwy() | line_comment | pl | //To funkcja wyewnątrz klasy, to funkja wykonywana przez obiekt stworzona wg klasy w symulowanym środowisku
// blok który zawiera jakieś instrukcje
// może być <SUF>
public class Metody {
public void policzWyynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int pobierzWynik(){
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< 100; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
return result;
}
public void policzWyynikParam( int number){
System.out.println("Number ma wartość: " + number);
System.out.println("Zaraz policzę wynik");
int result = 0;
for (int i = 0 ; i< number; i++){
result = result + i;}
System.out.println("Rezultat to: " + result);
}
public int add(int firstNumber, int secondNumber, String word) {
System.out.println("Suma to: " + (firstNumber + secondNumber));
return firstNumber + secondNumber;
}
}
|
2766_0 | package pl.sdacademy.pojazdy;
public class Amfibia implements Motorowka, Pojazd { // w przeciwieństwie do dziedziczenia klas, możemy impelementować wiele interfejsów - w ten sposób nasza klasa może realizować wiele zachowań
@Override
public void plyn() { //tę metodę MUSIMY zaimpelementować - nie ma domyślnej implementacji w interfejsie Motorowka
System.out.println("Amfibia płynie!");
}
@Override
public void jedz() { //impelementacja tej metody jest opcjonalna bo interfejs Pojazd posiada jej domyślną implementację
System.out.println("Amfibia jedzie");
}
}
| mikewojtyna/sdacademy-examples | 11_interfejsy/src/main/java/pl/sdacademy/pojazdy/Amfibia.java | 208 | // w przeciwieństwie do dziedziczenia klas, możemy impelementować wiele interfejsów - w ten sposób nasza klasa może realizować wiele zachowań | line_comment | pl | package pl.sdacademy.pojazdy;
public class Amfibia implements Motorowka, Pojazd { // w przeciwieństwie <SUF>
@Override
public void plyn() { //tę metodę MUSIMY zaimpelementować - nie ma domyślnej implementacji w interfejsie Motorowka
System.out.println("Amfibia płynie!");
}
@Override
public void jedz() { //impelementacja tej metody jest opcjonalna bo interfejs Pojazd posiada jej domyślną implementację
System.out.println("Amfibia jedzie");
}
}
|
2766_1 | package pl.sdacademy.pojazdy;
public class Amfibia implements Motorowka, Pojazd { // w przeciwieństwie do dziedziczenia klas, możemy impelementować wiele interfejsów - w ten sposób nasza klasa może realizować wiele zachowań
@Override
public void plyn() { //tę metodę MUSIMY zaimpelementować - nie ma domyślnej implementacji w interfejsie Motorowka
System.out.println("Amfibia płynie!");
}
@Override
public void jedz() { //impelementacja tej metody jest opcjonalna bo interfejs Pojazd posiada jej domyślną implementację
System.out.println("Amfibia jedzie");
}
}
| mikewojtyna/sdacademy-examples | 11_interfejsy/src/main/java/pl/sdacademy/pojazdy/Amfibia.java | 208 | //tę metodę MUSIMY zaimpelementować - nie ma domyślnej implementacji w interfejsie Motorowka | line_comment | pl | package pl.sdacademy.pojazdy;
public class Amfibia implements Motorowka, Pojazd { // w przeciwieństwie do dziedziczenia klas, możemy impelementować wiele interfejsów - w ten sposób nasza klasa może realizować wiele zachowań
@Override
public void plyn() { //tę metodę <SUF>
System.out.println("Amfibia płynie!");
}
@Override
public void jedz() { //impelementacja tej metody jest opcjonalna bo interfejs Pojazd posiada jej domyślną implementację
System.out.println("Amfibia jedzie");
}
}
|
2766_2 | package pl.sdacademy.pojazdy;
public class Amfibia implements Motorowka, Pojazd { // w przeciwieństwie do dziedziczenia klas, możemy impelementować wiele interfejsów - w ten sposób nasza klasa może realizować wiele zachowań
@Override
public void plyn() { //tę metodę MUSIMY zaimpelementować - nie ma domyślnej implementacji w interfejsie Motorowka
System.out.println("Amfibia płynie!");
}
@Override
public void jedz() { //impelementacja tej metody jest opcjonalna bo interfejs Pojazd posiada jej domyślną implementację
System.out.println("Amfibia jedzie");
}
}
| mikewojtyna/sdacademy-examples | 11_interfejsy/src/main/java/pl/sdacademy/pojazdy/Amfibia.java | 208 | //impelementacja tej metody jest opcjonalna bo interfejs Pojazd posiada jej domyślną implementację | line_comment | pl | package pl.sdacademy.pojazdy;
public class Amfibia implements Motorowka, Pojazd { // w przeciwieństwie do dziedziczenia klas, możemy impelementować wiele interfejsów - w ten sposób nasza klasa może realizować wiele zachowań
@Override
public void plyn() { //tę metodę MUSIMY zaimpelementować - nie ma domyślnej implementacji w interfejsie Motorowka
System.out.println("Amfibia płynie!");
}
@Override
public void jedz() { //impelementacja tej <SUF>
System.out.println("Amfibia jedzie");
}
}
|
2767_0 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // zmienne (czyli pola) obiektów klasy Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli <SUF>
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_1 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // każde ogniwo może mieć jakąś nazwę | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo <SUF>
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_2 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // zmienna "nazwa" typu String: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" <SUF>
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_3 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // oraz mieć połączenie z następnym ogniwem w łańcuchu | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć <SUF>
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_4 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // zmienna "nastepne" typu Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" <SUF>
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_5 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w <SUF>
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_6 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // i zapisujemy w niej nowy obiekt klasy Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy <SUF>
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_7 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego <SUF>
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_8 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1 | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy <SUF>
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_9 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem <SUF>
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_10 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // i zapisujemy w niej nowy obiekt klasy Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy <SUF>
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_11 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // ale to jest to samo co gdybyśmy napisali najpierw: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to <SUF>
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_12 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // ogniwo2 = new Ogniwo(); | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = <SUF>
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_13 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa" | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis <SUF>
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_14 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // która jest niezależna od takiej samej zmiennej pierwszego obiektu: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest <SUF>
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_15 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2 | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy <SUF>
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_16 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa <SUF>
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_17 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo, | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci <SUF>
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_18 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // z kolejną nazwą: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną <SUF>
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_19 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2", | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, <SUF>
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_20 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1" | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej <SUF>
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_21 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // wiedział jakie jest jego następne ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie <SUF>
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_22 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne" | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze <SUF>
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_23 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // tym razem obiektu ogniwo2: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem <SUF>
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_24 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości) | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej <SUF>
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_25 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, <SUF>
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_26 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest <SUF>
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_27 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy <SUF>
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_28 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String) | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. <SUF>
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_29 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // a ogniwo1.nastepne to obiekt, który został wcześniej zapisany | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne <SUF>
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_30 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // w polu "nastepne" obiektu ongiwo1. | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu <SUF>
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_31 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne <SUF>
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_32 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on <SUF>
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_33 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne <SUF>
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_34 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy) | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to <SUF>
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_35 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // wiec ogniwo1.nastepne.nazwa to jakby | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa <SUF>
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_36 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // ogniwo1.nastepne to ogniwo2 | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to <SUF>
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_37 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to <SUF>
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_38 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // czyli ogniwo2.nastepne a więc ogniwo3 | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne <SUF>
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_39 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w <SUF>
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_40 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze <SUF>
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_41 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się <SUF>
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_42 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // to będzie znów pierwsze - a po nim następne to drugie itd. | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie <SUF>
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_43 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp. | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli <SUF>
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_44 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // Wcześniej to drugie było zapisane jako "nastepne" w pierwszym | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to <SUF>
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_45 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak <SUF>
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_46 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // stało się to jeszcze o jedno dalej: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się <SUF>
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_47 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // Teraz jaka jest nazwa nastepnego po pierwszym: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka <SUF>
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2767_48 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista01.java | 2,033 | // (wychodzi trzecie ogniwo bo drugiego już nie ma) | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
Ogniwo nastepne;
}
public class Lista01 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.nazwa = "Pierwsze ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.nazwa);
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.nazwa = "Drugie ogniwo";
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.nazwa);
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.nazwa = "Trzecie ogniwo";
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.nazwa);
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.nastepne = ogniwo2;
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.nastepne = ogniwo3;
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.nastepne = null;
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println(ogniwo1.nastepne.nastepne.nazwa);
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.nastepne = ogniwo1;
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println(ogniwo1.nastepne.nastepne.nastepne.nastepne.nazwa);
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.nastepne = ogniwo1.nastepne.nastepne;
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println(ogniwo1.nastepne.nazwa);
// (wychodzi trzecie <SUF>
}
}
|
2769_0 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // zmienne (czyli pola) obiektów klasy Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli <SUF>
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_1 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // każde ogniwo może mieć jakąś nazwę | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo <SUF>
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_2 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // zmienna "nazwa" typu String: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" <SUF>
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_3 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // oraz mieć połączenie z następnym ogniwem w łańcuchu | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć <SUF>
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_4 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // zmienna "nastepne" typu Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" <SUF>
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_5 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // metody obiektów klasy Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów <SUF>
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_6 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // to jest setter bo zmienia nazwę: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest <SUF>
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_7 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // to jest getter bo podaje nazwę: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest <SUF>
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_8 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // to jest setter dla następnego ogniwa: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest <SUF>
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_9 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // to jest getter dla następnego ogniwa: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest <SUF>
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_10 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // to jest metoda, która usuwa kolejne ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest <SUF>
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_11 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w <SUF>
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_12 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // i zapisujemy w niej nowy obiekt klasy Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy <SUF>
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_13 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego <SUF>
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_14 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1 | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy <SUF>
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_15 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem <SUF>
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_16 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // i zapisujemy w niej nowy obiekt klasy Ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy <SUF>
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_17 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // ale to jest to samo co gdybyśmy napisali najpierw: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to <SUF>
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_18 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // ogniwo2 = new Ogniwo(); | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = <SUF>
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_19 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa" | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis <SUF>
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_20 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // która jest niezależna od takiej samej zmiennej pierwszego obiektu: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest <SUF>
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_21 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2 | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy <SUF>
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_22 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa <SUF>
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_23 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo, | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci <SUF>
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_24 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // z kolejną nazwą: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną <SUF>
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_25 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2", | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, <SUF>
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_26 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1" | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej <SUF>
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_27 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // wiedział jakie jest jego następne ogniwo: | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie <SUF>
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
2769_28 | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne"
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
| rsp/bak16 | bak/bakp/cw08/Lista02.java | 2,309 | // podobnie ze zmienną ogniwo3, którą zapisujemy w zmiennej "następne" | line_comment | pl | class Ogniwo {
// zmienne (czyli pola) obiektów klasy Ogniwo:
// każde ogniwo może mieć jakąś nazwę
// zmienna "nazwa" typu String:
private String nazwa;
// oraz mieć połączenie z następnym ogniwem w łańcuchu
// zmienna "nastepne" typu Ogniwo:
private Ogniwo nastepne;
// metody obiektów klasy Ogniwo:
// to jest setter bo zmienia nazwę:
void zmienNazwe(String nowaNazwa) {
this.nazwa = nowaNazwa;
}
// to jest getter bo podaje nazwę:
String podajNazwe() {
return this.nazwa;
}
// to jest setter dla następnego ogniwa:
void setNastepne(Ogniwo noweNastepne) {
this.nastepne = noweNastepne;
}
// to jest getter dla następnego ogniwa:
Ogniwo getNastepne() {
return this.nastepne;
}
// to jest metoda, która usuwa kolejne ogniwo:
void usunNastepne() {
this.setNastepne( this.getNastepne().getNastepne() );
}
}
public class Lista02 {
public static void main(String[] args) {
System.out.println("--- Tworzymy nowe ogniwa i nadajemy im nazwy:");
// tworzymy w naszej metodzie main() nową zmienną "ogniwo1" typu Ogniwo:
Ogniwo ogniwo1;
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
ogniwo1 = new Ogniwo();
// zmieniamy jego wewnętrzną zmienną "nazwa" - każdy obiekt ma swoją:
ogniwo1.zmienNazwe("Pierwsze ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo1
// jako ogniwo1.nazwa:
System.out.println("Stworzylismy ogniwo1 o nazwie " + ogniwo1.podajNazwe() );
// tym razem w jednej linijce tworzymy nową zmienną "ogniwo2" typu Ogniwo
// i zapisujemy w niej nowy obiekt klasy Ogniwo:
Ogniwo ogniwo2 = new Ogniwo();
// ale to jest to samo co gdybyśmy napisali najpierw:
// Ogniwo ogniwo2;
// a potem:
// ogniwo2 = new Ogniwo();
// zapisujemy napis "Drugie ogniwo" w jego zmiennej "nazwa"
// która jest niezależna od takiej samej zmiennej pierwszego obiektu:
ogniwo2.zmienNazwe("Drugie ogniwo");
// teraz możemy odwoływać się do tej zmiennej obiektu ogniwo2
// jako ogniwo2.nazwa - tak samo jak z obiektem ogniwo1:
System.out.println("Stworzylismy ogniwo2 o nazwie " + ogniwo2.podajNazwe() );
// i trzeci obiekt typu Ogniwo - zapisany w nowej zmiennej typu Ogniwo,
// z kolejną nazwą:
Ogniwo ogniwo3 = new Ogniwo();
ogniwo3.zmienNazwe("Trzecie ogniwo");
System.out.println("Stworzylismy ogniwo3 o nazwie " + ogniwo3.podajNazwe() );
System.out.println("--- Laczymy ze soba ogniwa:");
// zapisujemy obiekt, który znajduje się w naszej zmiennej "ogniwo2",
// w zmiennej "nastepne" obiektu "ogniwo1" żeby obiekt "ogniwo1"
// wiedział jakie jest jego następne ogniwo:
System.out.println("Laczymy pierwsze ogniwo z drugim.");
ogniwo1.setNastepne(ogniwo2);
// podobnie ze <SUF>
// tym razem obiektu ogniwo2:
System.out.println("Laczymy drugie ogniwo z trzecim.");
ogniwo2.setNastepne(ogniwo3);
// w zmiennej następne obiektu ogniwo3 zapisujemy wartość null (czyli brak wartości)
// żeby pokazać, że to ogniwo jest ostatnie i nie ma już następnego:
System.out.println("Ustalamy, ze trzecie nie ma juz nastepnego.");
// to jest niepotrzebne bo wartość domyślna to null ale nie zaszkodzi:
ogniwo3.setNastepne(null);
// teraz możemy się odwoływać do pól (czyli zmiennych) wszystkich tych obiektów
// czyli np. ogniwo3.nazwa to jakiś łańcuch znaków (String)
// a ogniwo1.nastepne to obiekt, który został wcześniej zapisany
// w polu "nastepne" obiektu ongiwo1.
// Skoro ogniwo1.nastepne to jest jakiś obiekt klasy Ogniwo
// to on też ma jakąś nazwę: ogniwo1.nastepne.nazwa
// oraz kolejne następne ogniwo: ogniwo1.nastepne.nastepne
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2 (bo takie tam zapisaliśmy)
// wiec ogniwo1.nastepne.nazwa to jakby
// (ogniwo1.nastepne).nazwa czyli:
// ogniwo2.nazwa
System.out.println("Jaka jest nazwa nastepnego po nastepnym po nr 1:");
System.out.println( ogniwo1.getNastepne().getNastepne().podajNazwe() );
// ogniwo1.nastepne to ogniwo2
// ogniwo1.nastepne.nastepne to jakby (ogniwo1.nastepne).nastepne
// czyli ogniwo2.nastepne a więc ogniwo3
// więc:
// ogniwo1.nastepne.nastepne.nazwa to:
// ogniwo2.nastepne.nazwa czyli:
// ogniwo3.nazwa
// Jeśli w polu "nastepne" ostatniego obiektu w naszym łańcuchu ogniw
// zapiszemy pierwsze ogniwo, to łańcuch będzie zamknięty i będziemy mogli
// poruszać się po nim w nieskończoność - tzn. następne ogniwo po trzecim
// to będzie znów pierwsze - a po nim następne to drugie itd.
System.out.println("Laczymy ogniwo 3 z pierwszym.");
ogniwo3.setNastepne(ogniwo1);
// Teraz jeśli po trzecim ogniwie jest znów pierwsze, to po nim jest drugie itp.
System.out.println("Jakie jest teraz piate ogniwo:");
System.out.println( ogniwo1.getNastepne().getNastepne().getNastepne().getNastepne().podajNazwe() );
System.out.println("Teraz usuwamy drugie ogniwo z łańcucha.");
// Wcześniej to drugie było zapisane jako "nastepne" w pierwszym
// ale jak usuniemy to ogniwo to chcemy, żeby następnym dla pierwszego
// stało się to jeszcze o jedno dalej:
ogniwo1.usunNastepne();
// Teraz jaka jest nazwa nastepnego po pierwszym:
System.out.println("Jaka jest nazwa ogniwa nastepnego po nr 1:");
System.out.println( ogniwo1.getNastepne().podajNazwe() );
// (wychodzi trzecie ogniwo bo drugiego już nie ma)
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.