prog1_vizsgasor szte
DESCRIPTION
SZTE Programozás I. tárgy vizsgasoraTRANSCRIPT
SZTE – TTIK Mérnök informatika
Programozás I. tételek
2012–2013.
Készítette: Petőcz Dániel
A. ============================================================ Elmélet:
1. Mi a különbség java- alkalmazás és applet között? 2. Mi a belső osztály? Adjon rá példát! 3. Mi a különbség absztrakt és interfész osztály között? 4. Vázolja a "siker háromszöge" jelentését! 5. Mire jó a CLASSPATH környezeti változó? 6. Mi a Konstruktorok neve, és visszatérési értéke? 7. Mit tárolhat a Tömb?
============================================================ Hibakeresés:
int n; static public void m() { System.out.println(d+k+i+m+n); } int m; System.out.println(m); static final int i=1; for (i=1; i<=10; i++) { /*...*/ } double d = 1e2; for (int i=1; i<=10; i++) { double d = 4.5; } for (i=1; i<=10; i++) { int j = 2; } System.out.println(j);
============================================================ Program:
Írjon olyan programot, amely kiír 10 db (1, 100) közötti random számot, és eldönti, hogy páros-e vagy páratlan!
============================================================
A. Elmélet 1. Mi a különbség java- alkalmazás és applet között?
A különbség köztük a következő: a Java appletek olyan Java nyelven készült programok, amelyeket elsősorban web-böngészőben történő futtatásra készítettek, míg a Java alkalmazások azok a Java nyelven írt programok, amelyek a futtató számítógép operációs rendszere nyújtotta környezetre építenek és futtatásukhoz más nyelven írt alkalmazásokhoz hasonlóan nincs szükség web-böngésző programra.
2. Mi a belső osztály? Adjon rá példát!
- Osztályon- vagy metóduson belüli osztályok - logikailag nagyon szorosan összetartozó osztályok csoportosítása - megadható a láthatóságuk - máshol nem használt algoritmus teljes elrejtése a külvilágtól - a belső osztályból elérhetőek a „körülvevő” osztály elemei (kivéve ha static a belső osztály) - .class fájlnév: Külső$Belső.class - Nem kompozíció!
class A{
…
class B{
…
}
}
3. Mi a különbség absztrakt és interfész osztály között? Absztrakt osztályból lehet származtatni más osztályt, míg interfacet az osztály nem örököl, hanem megvalósít. Ezért egy osztály csak egy absztrakt osztályból származhat, viszont több interfacet is megvalósíthat. Az inrerfészben csak absztrakt metódusok vannak, de semmi egyéb, míg egy absztrakt osztálynál lenni kell legalább egy absztrakt metódusnak (törzs nélküli), és ezen kívül lehet akármi(adattag, normál metódus stb…).
4. Vázolja a "siker háromszöge" jelentését! Jelölésrendszer (Notation) 2 1 3 Folyamat Eszköz (Process) (Tool)
1. Folyamat - Fejlesztési életciklust irányítja (folyamat leírása) - Végrehajtandó lépések és a végrehajtás sorrendje - Általában iteratív és inkrementális életciklust ír elő - pl. vízesés modell
2. Jelölésrendszer
- Modellezéskor a rendszer architektúráját különböző nézetekkel írjuk le - Használati eset nézet (esettanulmány) - Nem minden rendszer igényli az összes nézetet - Új nézeteket is lehet definiálni
3. Eszköz
- Ősi eszköz: papír és ceruza :) - Nagyon sok UML eszköz van: egyszerű rajzoló programtól kifinomult objektummodellező eszközig.
5. Mire jó a CLASSPATH környezeti változó?
JAVA környezeti változó, amely tartalmaz minden olyan elérési utat, ahol a java csomagok elhelyezkednek a lokális rendszeren.
6. Mi a Konstruktorok neve, és visszatérési értéke?
- Neve: az adott osztály neve - Visszatérési érteke: nincs
7. Mit tárolhat a Tömb?
- Azonos típusú adatok tárolására alkalmas. - Ha különböző típusú adatokat akarunk tárolni, akkor gyűjteményt (kollekciót) kell használni, mint pl. az ArrayList (viszont ez objektumokat tárol).
A. Hibakeresés
int n; static public void m() { System.out.println(d+k+i+m+n); } int m; System.out.println(m); static final int i=1; for (i=1; i<=10; i++) { /*...*/ } double d = 1e2; for (int i=1; i<=10; i++) { double d = 4.5; } for (i=1; i<=10; i++) { int j = 2; } System.out.println(j);
int n;
static public void m() {
System.out.println(d+k+i+m+n); }
nem statikus változót nem használhatsz statikus metódusban
int m;
System.out.println(m);
m nincs inicializálva
static final int i=1;
for (i=1; i<=10; i++) { /*...*/ }
final változó értékén nem változtathatsz
double d = 1e2;
for (int i=1; i<=10; i++) {
double d = 4.5; }
d már deklarálva van ott, ahol mégegyszer akarja
for (i=1; i<=10; i++) {
int j = 2; }
System.out.println(j);
j változó csak a ciklusmagban látszódik
A. Program
Írjon olyan programot, amely kiír 10 db (1, 100) közötti random számot, és eldönti, hogy páros-e vagy
páratlan!
import java.util.Random; public class futtat {
public static void main(String[] args) { Random r=new Random(); for(int i=1;i<=10;i++){ int j=1+r.nextInt(100); if(j%2==0){ System.out.println(j+" páros"); } else{ System.out.println(j+" páratlan"); } }
} }
B. ============================================================ Elmélet:
1. Mit jelent az Overriding? Adjon rá példát is!
2. Mit jelent az Öröklődés az UML-ben. Adjon rá példát!
3. Mi a Garbage collector? Mik az előnyei és hátrányai?
4. Hogyan lehet megszűntetni egy objektumot?
5. Erős és gyenge tartalmazás UML-ben! Hasonlítsa össze!
6. Hol keletkeznek az objektumok?
7. Írj példát futás közbeni tömb inicializálásra!
8. Elöltesztelős ismétléses vezérlési szerkezet Java-ban!
============================================================ Hibakeresés:
1 public class Vizsga2b1 {
2 static final int i=1;
3 int n;
4 static int k;
5 static public void m() {
6 double d = 1e2;
7 int m;
8 for (i=1; i<=10; i++) {
9 double d = 4.5;
10 int j = 2;
11 System.out.println(m);
12 System.out.println(d+k+i+m+n);
13 }
14 System.out.println(j);
15 }
16 public static final void main(String[] args) {
17 m();
18 }
19 }
============================================================ Program:
Írjon egy Swinges Hello World programot, JLabel-lel!
============================================================
B. Elmélet 1. Mit jelent az Overriding? Adjon rá példát is!
felüldefiniálás : A származtatott osztály „megkapja„ az ősének minden adatát és metódusát, de újakat is definiálhat és a meglevőket is felülírhatja (ezt nevezzük overriding-nak). public class Allat { public void felülir(){ System.out.println(" metódus az állatban"); } } public class Macska extends Allat{ //a macska megkapja az állat minden tulajdonságát public void felülir(){ //de van egy saját metódusa is System.out.println("metódus a macskában"); } } public class Futtat { public static void main(String[] args) { Macska m=new Macska(); //létrehozzuk a macskát Allat a= (Allat)m; //a gyerek felülírja az ősét a.felülír(); //meghívjuk és a macska metódusát fogja kiírni } }
2. Mit jelent az Öröklődés az UML-ben. Adjon rá példát!
- Hasonlóság kifejezése az ős felé általánosítás
- Különbség a gyerek felé Specializálás
-A származtatott új típus lesz az ős interfészét duplikálja azonos típusú az őssel! (a kör az egy alakzat)
3. Mi a Garbage collector? Mik az előnyei és hátrányai?
A garbage collector (GC, szemétgyűjtő) megkísérli eltávolítani a memóriából azokat az objektumokat, amelyeket az alkalmazás már nem használ és felszabadítani az általuk elfoglalt memóriát. Előnyök
- a programozónak nem kell a memóriakezeléssel foglalkoznia - rejtve dolgozik - „kézzel” is el lehet indítani a futását - Biztonságos, könnyebb a kezelés - automatikus
Hátrányok Lassú, számításigényes feladat. Nem determinisztikus. Minden objektum törlődni fog, de nem tudni mikor. Nem minden takarítást tus elvégezni pl a nem new kulcsszóval történő memóriafoglalás Nem szavatolt a szemétgyűjtés vágrehajtása
4. Hogyan lehet megszűntetni egy objektumot?
Az objektumok automatikus megszüntetése a szemétgyűjtő mechanizmus (garbage collector) feladata. Számontartja, hogy egy objektumra hány referencia hivatkozik. Ha már nincs érvényes referencia, az objektum haszontalanná válik. Egy külön szálban futó szemétgyűjtő felszabadítja a felesleges objetumokhoz tartozó memória területet. Hogy ez pontosan mikor történik meg, nem tudjuk.
5. Erős és gyenge tartalmazás UML-ben! Hasonlítsa össze!
Kétféle aggregáció létezik. Az egyik a gyenge tartalmazás, azaz az általános aggregáció. A másik az erős tartalmazás, azaz a kompozíció, ahol a részek élettartama szigorúan megegyezik az egészével. erős tartalmazás: ha a tartalmazott objektum nem vehető ki a tartalmazóból. gyenge tartalmazás: ha a tartalmazott objektum kivehető a tartalmazóból.
6. Hol keletkeznek az objektumok?
- mindig heap-en keletkeznek, kivéve a primitív típusokat - Létre kell őket hozni new kulcsszóval - felszabadítás: gc : biztonágos és könnyű kezelés ,de lassú
7. Írj példát futás közbeni tömb inicializálásra!
int i =/* … */; int[] a1 = new int[i];
8. Elöltesztelős ismétléses vezérlési szerkezet Java-ban!
while ( F ) { M; } while (boolean-expression) statement - Ha elsőre false a feltétel eredménye, akkor nem csinál semmit sem. - break [label]: megszakítja az aktuális ismétlést és a szerkezetet követő utasítással folytatja. - continue [label]: megszakítja az aktuális ismétlést és a következővel folytatja.
B. Hibák
1 public class Vizsga2b1 {
2 static final int i=1;
3 int n; // nem statikus változót nem használhatsz statikus metódusban
4 static int k;
5 static public void m() {
6 double d = 1e2;
7 int m; // nem statikus változót nem használhatsz statikus metódusban
8 for (i=1; i<=10; i++) { //az i final változó, értékén nem változtathatsz
9 double d = 4.5; // d kétszer van definiálva
10 int j = 2;
11 System.out.println(m); // m nincs inicializálva
12 System.out.println(d+k+i+m+n);
13 }
14 System.out.println(j); // j változó csak a ciklusmagban látszódik
15 }
16 public static final void main(String[] args) {
17 m();
18 }
19 }
8. sorban i nem változtatható, mivel 2-ban finalként lett definiálva
Javítás: 2. sorban final törlése VAGY for(int i=1...
14. sorban j-t már nem látható mivel a for blokkjában definiálta Javítás: 10. sorból a definíció/deklaráció kivétele a for elé
7. sorban m inicilizálatlan, ezért a 11-ben nem írhatjuk ki Javítás: 7. sorban int m=0;
6. és 9. sorban d változót definiál, a 2. definíció elrejti a külsőt Javítás: az egyiket át kell nevezni
12. sorban nem használhatja n-t az összegben, mert n objektumváltozó, és az m() statikus, tehát csak statikust használhat Javítás: 3. sorban static int n;
Nem hibák, de sokan belebukhattak:
16. sorban a main függvény final: ez azért nem gond mert a statikus függvények implicit final-ok, ezért nem gond, hogyha kiírjuk; osztályfüggvényeknél az overridingnak nincs értelme
5. sorban static public: a módosítók sorrendje nem számít, az egyedüli lényeg hogy a visszatérési érték a függvény neve előtt legyen
6. sorban 1e2: ez 100-at jelent és teljesen legális, a lebegőpontos számok alakja (-7.2e-6 is legális) 3. és 4. sor: az objektum és osztályváltozókat nem kötelező inicializálni, azok memóriaterülete 0-
kal lesz kitöltve, viszon a lokális változókat kötelező!
B. Program
Írjon egy Swinges Hello World programot, JLabel-lel!
import javax.swing.*;
public class Hello {
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("HelloWorldSwing");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JLabel label = new JLabel("Hello World");
frame.add(label);
frame.getContentPane().add(label);
frame.pack();
frame.setVisible(true);
}
}
C. ============================================================ Elmélet:
1. Mi a különbség az osztály és az objektum között?
2. Hogyan lehet elrejteni az implementációt Java-ban?
3. Mi a kései kötés?
4. Mi az upcast és a downcast?
5. Mit használunk Kliens oldali programozásra a weben?
6. Hátul tesztelős vezérlőszerkezet Java-ban!
7. Mi a különbség az int[] a; és az int a[]; között?
============================================================ Hibakeresés:
Állatul durva!
============================================================ Program:
* Írjunk osztályt, aminek a default konstruktora kiírja a pontos időt.
* Származtassunk ebből egy másik osztályt, aminek az egyik konstruktora egy stringet vár, amit kiír
a képernyőre.
* Írjunk programot, ami a gyerekosztályból objektumot hoz létre.
* Kérdés: A futtatás során mi jelenik meg a képernyőn?
* Ami adott a programhoz: Class java.util.Date; Date();
============================================================
C. Elmélet
1. Mi a különbség az osztály és az objektum között?
Az osztály egy absztrakt fogalom, a példánya pedig egy objektum, mely tartalmazza az osztály metódusait, illetve tulajdonságait. Az objektumnak van memóriacíme, elfoglal bizonyos számú bájtot ettől a címtől kezdődően, és tudunk hivatkozni rá és a függvényeire, illetve a tulajdonságaira. Vele ellentétbe, az osztályának nincs elérhető címe, és az osztály semmiképp nem kezelhető úgy, mint egy objektum, hiszen nem az. Ez egy absztrakt fogalom, és az objektumok, melyek belőle származnak, a konkrét példányai. Hiába vannak egy osztálynak tulajdonságai, ha nem tudunk hivatkozni rájuk, hiszen azok valójában csak a példányosított objektumokban jelennek meg.
2. Hogyan lehet elrejteni az implementációt Java-ban?
Ha osztályt gyártunk, el kell rejtenünk az implementációt. A használója nem kell, hogy ismerje, nem tud róla, így nem használhatja rosszul, és nem is teheti tönkre, kevesebb lesz a programhiba. Elérés vezérlése (láthatóság) – access specifiers: elrejtésre, implementáció biztonságos módosítása, public, protected, private, alapértelmezett: „friendly” (package private: csomagon belül public, egyébként private).
3. Mi a kései kötés?
Idegen kifejezéssel late binding. A fordító nem tudja eldönteni, hogy melyik konkrét operáció hívódik meg, az örökölt, vagy a felüldefiniált. Ez futás közben derül ki a konkrét típus alapján. Javaban minden operációhívás ilyen.
4. Mi az upcast és a downcast?
Upcast: A futás közbeni típusazonosítás egyik fajtája, az ősre konvertálás, más néven upcast. Ekkor elveszítjük a konkrét típust, és a konverzió biztonságos. Downcast: Leszármazottra konvertálás, amikor jó lenne visszanyerni az eredeti típust. Ez a konverzió más nyelvekben nem biztonságos. Javaban igen, mert ellenőrizve van (RTTI). Hibás downcast‐olás esetén ClassCastException dobódik.
5. Mit használunk Kliens oldali programozásra a weben?
Kliens programozáshoz: applet - csak böngészőn belül fut - minden böngészőn működik ahol van Java interpreter (értelmező) - nem a forráskód van értelmezve, hanem a lefordított kód kerül futtatásra - JAR: tömörített formátum
6. Hátul tesztelős vezérlőszerkezet Java-ban!
Do while mint c ben
do statement while (boolean-expression);
7. Mi a különbség az int[] a; és az int a[]; között?
- Semmi mind a kettő helyes és ugyan azt a hatást érik el.
C. Hibakeresés
- nagyon nem a itt-egy-plusz-zárójel-onnan-hiányzik-egy-vessző típusú volt; - itt-ott belekavarodtam - (pl.: mikor a default konstruktorral hoz létre egy objektumot, azt írtam, az nem jó, mert nem volt leírva default; de most utólag belegondolva az automatikusa létrejön...); Csak a hibákat okozó sorokat kellett javítani. 25 pont. - A hibajavítás feladat a konstruktorok paramétereire, illetve az operációk paramétereire hivatkozott. Pl.: a függvény integert vár, de mi boolean típust adunk át, ez így hibás. * a paraméterezéssel voltak gondok, meg hogy static vagy nem static a metodus, ilyesmi...
C. Program
Írjunk osztályt, aminek a default konstruktora kiírja a pontos időt. Származtassunk ebből egy
másik osztályt, aminek az egyik konstruktora egy stringet vár, amit kiír a képernyőre. Írjunk
programot, ami a gyerekosztályból objektumot hoz létre.
Kérdés: A futtatás során mi jelenik meg a képernyőn?
Ami adott a programhoz: Class java.util.Date; Date();
import java.util.Date;
public class Ido {
Ido(){
System.out.println(new Date());
}
}
public class Stringes extends Ido{
Stringes(String s){
System.out.println(s);
}
}
public class futtat {
public static void main(String[] args) {
Stringes s = new Stringes("Ennyi a pontos idő és a dátum");
}
}
- Megjelenik a pontos idő és dátum és a String amit adtunk neki.
- A lényeg az h a gyerek örökölte az őse tulajdonságait, így a konstruktorát is, és így elég volt csak a
gyereket példányosítani a két külön osztály helyett.
D.
============================================================ Elmélet:
1. Mik a Java főbb előnyei és hátrányai?
2. Hogyan hivatkozunk pointerrel egy objektumra Javaban?
3. Írjon példát generikus osztályra, aminek egy generikus adattagja van!
4. Mi a composite tervezési minta célja, szerkezete?
5. Mikor és mire használjuk a this utasítást?
============================================================ Hibakeresés:
class Faktorialis {
static long fakt(int n){
if (n < 1)
return 1;
long f = 1;
for (int i = 1, i <= n, i++){
f *= i;
return f;
}
void faktKiir(final int a, final int b) {
if (a < b) {
int seged = a; a = b; b = a;
}
for (i = a, i <= b, i++) {
System.out.println(i * " faktorialisa:" * fakt(i);
}
public static void main(String[] args) {
faktKiir(3,7);
}
}
============================================================ Program:
Írjon egy osztályt, aminek egy protected metódusa van, helyezze bele egy csomagba majd
írjon egy csomagon kívüli futtatható állományt.
Hívja meg a protected metódust. Mit ír ki a fordító?
============================================================
D. Elmélet 1. Mik a Java főbb előnyei és hátrányai?
Előny:
- Egy magas szintű programozási nyelv, ahol nem a kódoláson van a hangsúly, hanem a tervezésen.
Emellett elvontabb dolgokat is tud ábrázolni, pl. interfészeket. Elősegíti a web programozást is
azzal, hogy platform független. Elősegíti a programozók és a programozási eszközök
kommunikációját. A Java nem csak egy nyelv, számos alkalmazhatósága van, pl. appletek.
Hátrány:
- Hiányoznak belőle olyan eszközök, mint a hardver specifikus típusok, alacsony szintű mutatók
a memória bármely részére, vagy az olyan nyelvi elemek, mint az operátor túlterhelés.
- Sok programozó hiányolja a többszörös öröklődést,
- Az interfészeken keresztül engedélyezi a típusdefiníciók többszörös öröklődését, de a
megvalósítások csak egyszeresen örököltethetők.
2. Hogyan hivatkozunk pointerrel egy objektumra Javaban?
A Java nem használ mutatókat (pointer), egy csapásra megszűntetve ezzel a C programozók kedvelt
programozási hibáinak egész seregét.
3. Írjon példát generikus osztályra aminek egy generikus adattagja van!
Public class Generikus{
ArrayList<Integer> l = new ArrayList<Integer>();
}
4. Mi a composite tervezési minta célja, szerkezete?
Cél: Rész-egész szerkezetek leképezése objektumhierarchiára (fa-szerkezetre), miközben a kliens a
rész és egész egységeket azonosan kezeli.
5. Mikor és mire használjuk a this utasítást?
Akkor használjuk, ha a metódus formális paraméterneve megegyezik valamelyik attribútum
nevével.(ha pl. van egy int a osztályváltozóm és a konstruktorban vagy a metódusban az aktuális
paraméternevem is int a akkor kell a metóduson vagy a konstruktoromon belül this-t alkalmazni)
pl :
public class A{
private int a ;
public A(int a){
this.a = a;
}
}
D. Hibakeresés
class Faktorialis {
static long fakt(int n){
if (n < 1)
return 1;
long f = 1;
for (int i = 1, i <= n, i++) // , helyett ;
f *= i;
return f;
}
void faktKiir(final int a, final int b) {
if (a < b) {
int seged = a; a = b; b = a; // a és b final, nem lehet módósítani
}
for (i = a, i <= b, i++) { // , helyett ; és "i" nincs deklarálva korábban
System.out.println(i * " faktorialisa:" * fakt(i); // * helyett +
}
public static void main(String[] args) {
faktKiir(3,7); // main statikus, faktKiir() nem, ezért ezt így nem
//lehet használni
}
}
D. Program Írjon egy osztályt, aminek egy protected metódusa van. Helyezze bele egy csomagba majd írjon
egy csomagon kívüli futtatható állományt. Hívja meg a protected metódust.
Mit ír ki a fordító?
package prot;
public class Prot {
protected void miLeszMost(){
System.out.println("alma");
}
}
import prot.Prot;
public class Fut{
public static void main(String[] args) {
Prot p =new Prot();
p.miLeszMost();
}
}
Hibát fog kiírni, mivel a protected metódust csomagon kívül nem látjuk.
E. ============================================================ Elmélet:
1. Mi a .jar kiterjesztésű fájl? 2. Mi a különbség az osztálytag és a példánytag között? 3. Számlálásos ismétléses vezérlés megvalósítása Javaban! 4. Írja le, hogy néz ki a több dimenziós tömb? 5. Az iterátor tervezési mintája! 6. Mi az a Kompozíció? Hogyan valósítjuk meg Javaban? 7. Írjon le mindent, amit a csomagokról tud!
============================================================ Hibakeresés:
??? ============================================================ Program:
* Írjon egy nem futtatható osztályt, amely egy tömbben Stringeket tárol. * Legyen konstruktora ami kezeli a tömb méretét. * Írjon egy get metódus, ami egy paraméterként kapott indexhez tartozó értéket adja vissza. * Ha nem talált ilyen indexet, akkor dobjon vissza kivételt. * Írjon egy add metódust, ami egy paraméterként kapott Stringet ad hozzá a tömbhöz, ha
nem fér el benne, akkor dobjon vissza kivételt.
E. Elmélet
============================================================
1. Mi a .jar kiterjesztésű fájl?
A JAR fájl nem más, mint egy olyan ZIP fájl, amely java osztályokat és hozzájuk tartozó meta adatokat tartalmaz.
2. Mi a különbség az osztálytag és a példánytag között?
Osztálytag - az osztályhoz tartozik - az osztály minden objektumára egyformán érvényes - módosítója a static - az osztálytag lehet: - osztályváltozó (statikus attribútum):
egy darab él belőle és a statikus memóriaterületen tárolódik az egyes objektumok osztoznak rajta
- osztálymetódus (statikus operáció): csak a többi osztálytagot látja nem hivatkozhat a this-re
Példánytag - az objektumhoz (osztálypéldányhoz) tartozik - minden egyes objektumra különbözhet - minden tag, amelynek nincs static módosítója - a példánytag lehet: - példányváltozó:
minden objektumban külön szerepel, értéke az objektum állapotára jellemző - példánymetódus:
az osztály- és példánytagokat egyaránt látja egyszerre egy adott objektumon dolgozik
3. Számlálásos ismétléses vezérlés megvalósítása Javaban!
for (initialization; boolean-expression; step) { statement } Ugyanúgy, mint C nyelven.
4. Írja le hogy néz ki a több dimenziós tömb?
int[][] a2d = { {1,2,3}, {4,5,6} }; int[][][] a3d = new int[2][3][5]; Hasonló az egydimenzióshoz.
5. Az iterátor tervezési mintája!
Célja: tároló-objektum elemeinek sorozatos elérése a reprezentációtól függetlenül
6. Mi az a Kompozíció? Hogyan valósítjuk meg Javaban?
Kompozíció: összetétel, aggregáció, rész-egész kapcsolat Egy osztály egy attribútuma egy másik osztály vagy primitív típusú, pl. class A { private String s; private int i; } S inicializálva lesz null-ra, i pedig 0-ra
7. Írjon le mindent, amit a csomagokról tud!
Lehet csak egy osztályra is kiadni Pl : import java.util.*; Miért van rá szükség? - logikai csoportosítás - nevek ütközésének elkerülése - Ha nincs megadva (mint az eddigi példákban), akkor minden új osztály egy ún. default package csomagba kerül - Ha nagy rendszert írunk, célszerű csomagokat használni. Csomagok megadása: A csomag (package) nem más mint .class fájlok halmaza Melyik csomagba tartoznak az adatok? - a forrásfájl első nem-komment sorába be kell írni: package mypackage; - ez azt jelenti, hogy a benne levő osztályok a megadott csomaghoz fognak tartozni - Az egy csomagba tartozó osztályok egy lokális könyvtárba kerülnek Csomagok nevei: - Egyedi csomagnevek - a teljes elérési útvonal bele van kódolva - konvenció szerint az internet domain név is benne van fordított sorrendben (com.sun.java.*) - Hogy a Java interpreter megtalálja, be kell állítani a CLASSPATH környezeti változót, amelynek tartalmaznia kell minden olyan elérési útvonalat, ahol a Java csomagok elhelyezkednek a lokális rendszeren. .jar fájlok esetében a fájlnév is hozzá van adva (nem csak a könyvtárnév)
E. Hibakeresés
A programjavítósban ilyen hibák voltak, mint a for ciklusban ";" helyett "," final osztálytagot akart módosítani System.out.print helyett System.in.print volt
=====================================================================
E. Program:
Írjon egy nem futtatható osztályt, amely egy tömbben Stringeket tárol. Legyen konstruktora,
ami kezeli a tömb méretét.
Írjon egy get metódus, ami egy paraméterként kapott indexhez tartozó értéket adja vissza. Ha
nem talált ilyen indexet, akkor dobjon vissza kivételt.
Írjon egy add metódust, ami egy paraméterként kapott Stringet ad hozzá a tömbhöz, ha nem
fér el benne, akkor dobjon vissza kivételt.
public class Lajos {
String [] asd;
public Lajos(int tombmeret){
asd= new String [tombmeret];
}
public String get(int index) throws Exception{
if(asd.length<index || index<0){
throw new Exception();
}else{
return asd[index];
}
}
public void add(String szoveg) throws Exception{
boolean nincsures=true;
for (int i=0;i<asd.length;i++){
if(asd[i].isEmpty()){
asd[i]=szoveg;
nincsures=false;
}
}
if(!nincsures){
throw new Exception();
}
}
}
(+1).
============================================================ Elmélet:
1. Elöl tesztelő ciklus Java-ban! 2. Láthatóságok a Java-ban! 3. Mi a különbség az interfész és az implementáció között?
4. Hogyan lehet Java‐ban több osztályból örököltetni?
5. Mit tudsz a kliensről és szerverről?
6. Mi a lényege a friendly (package private) láthatóságnak?
7. Mi a különbség az overriding és az overloading között?
8. Mit értünk az öröklődésnél általánosítás és specializálás alatt?
============================================================ Program:
Írjon programot, ami előállítja a prímszámokat 1-100-ig, 2 egymásba ágyazott for ciklussal!
============================================================ Program:
Írni kellett egy mátrix osztályt, aminek van egy privát kétdimenziós, double értékű tömbje,
egy konstruktora 2 egész szám paraméterrel (x, y: a mátrix dimenziói) és inicializálja a
mátrixot. Volt még egy get metódusa, ami a mátrix adott (x, y) elemének értékével tér vissza,
meg getX és getY metódusok, amelyek a mátrix sorainak és oszlopainak számát adják vissza.
Másik osztályban kellet írni egy print kiíró operációt, ami táblázatos alakban írja ki a
mátrixot, majd a programban létre kellett hozni egy mátrix típusú objektumot, és meg
kellett hívni rá a kiíró metódust!
============================================================ Program:
Írj egy program kommentezését tetszőlegesen javadoc‐ban.
============================================================
+1. Elmélet: 1. Elöl tesztelő ciklus Java-ban!
while() { … }
2. Láthatóságok a Java-ban!
Public : - mindenki elérheti - az osztály interfésze
Protected : - az adott osztály, annak származtatott osztályai és a csomagjában levő osztályok elérik, a többiek nem
Private: - senki nem érheti el, kivéve az adott osztály saját metódusait - főleg rejtett implementációra és adattagokra alkalmazzák
3. Mi a különbség az interfész és az implementáció között?
Az interfészben absztrakt metódusok vannak, az implementáció ezeknek a megvalósítása. Interfész: mi az, amit üzenhetünk (deklaráció) Implementáció: ami teljesíti a kérést (definíció)
4. Hogyan lehet Java‐ban több osztályból örököltetni?
A java nyelv egyik hátránya hogy nem támogatja a többszörös öröklődést. 5. Mit tudsz a kliensről és szerverről?
Kliens programozás: Kezdetben minden interaktivitás a szerver oldalánvolt A kliens programozása a megoldás: amit csak lehet, a kliens hajtson végre Hasonló a hagyományos programozáshoz, csak egy másik platformra Plug-in használata (böngésző bővítése) Szkript nyelvek HTML forráskód JavaScript, VBScript stb… Kliens programozáshoz: applet Szerver programozás: Lehet egyszerű v bonyolult: fájl kérés vagy adatbázis lekérés + HTML formázás Hagyományosan Perl-lel, CGI-vel valósítják meg Java-ban: servlet, JSP
6. Mi a lényege a friendly (package private) láthatóságnak?
- csomagon belül minden osztály eléri (public) - csomagon kívül nem elérhető (private) - szorosan kapcsolódó osztályokat lehet így csoportosítani (egymást használják)
7. Mi a különbség az overriding és az overloading között?
- Mindkét eset az azonos nevű metódusokra (ill konstruktorokra) vonatkozik. Az overriding felülfdefiniálást jelent. Pl ha egy gyerek osztály felülírja az őse metódusát. - Az overloading kiterjesztést jelent. Pl ha van egy default és egy nem default konstruktorom, akkor a fordítónak valahogyan meg kell különböztetnie őket (mivel ugyan az a nevük). Ezt a paraméterlistájuk alapján teszi meg.
8. Mit értünk az öröklődésnél általánosítás és specializálás alatt?
Általánosítás: Hasonlóság kifejezése az ős felé, tehát hogy a leszármazott miben hasonlít az ősre.
Specializálás: Különbség kifejezése a gyerek felé. A leszármazott miben különbözik ősétől.
+1. Program (1) Írjon programot, ami előállítja a prímszámokat 1-100-ig, 2 egymásba ágyazott for ciklussal!
public class Prim {
public static void main(String[] args){
int szam, j;
boolean prim;
for (szam=2; szam<=100; szam++) {
prim=true;
for (j=2; j<(szam-1); j++) {
if (szam%j==0) {
prim=false;
break;
}
}
if (prim){
System.out.print(szam+" ");
}
}
}
}
+1. Program (2)
Írni kellett egy mátrix osztályt, aminek van egy privát kétdimenziós, double értékű tömbje, egy
konstruktora 2 egész szám paraméterrel (x, y: a mátrix dimenziói) és inicializálja a mátrixot.
Volt még egy get metódusa, ami a mátrix adott (x, y) elemének értékével tér vissza, meg getX és
getY metódusok, amelyek a mátrix sorainak és oszlopainak számát adják vissza. Másik
osztályban kellet írni egy print kiíró operációt, ami táblázatos alakban írja ki a mátrixot, majd
a programban létre kellett hozni egy mátrix típusú objektumot, és meg kellett hívni rá a kiíró
metódust!
public class Matrix {
double x;
double y;
private double [][] tomb ;
public Matrix(int a,int b){
x=a;
y=b;
tomb = new double[a][b];
}
public double getXY ( int a, int b ){
return tomb [a][b];
}
public double getX(){
return x;
}
public double getY(){
return y;
}
}
public class Futtat {
public static void kiir(Matrix m){
for(int i=0;i<m.getY();i++){
for(int f=0;f<m.getX();f++){
System.out.print(m.getXY(f, i));
}
System.out.print("\n");
}
}
public static void main(String args[]){
Matrix a1 = new Matrix(4,4);
Futtat.kiir(a1);
}
}
+1 Program (3)
Írj egy program kommentezését tetszőlegesen javadoc‐ban.
/** komment */