1.

Fie urmãtorul bloc de instructiuni Java:

{
int x = 12;
q=1;
{
int q = 96;
// Both x & q available
x=q;
}
q=x;
x=1;
}
Care afirmatie este adevarata:
a. instructiunea x=q; este corecta;
b. instructiunea q=x; este corecta;
c. instructiunea x=1; este incorecta;
d. instructiunea q=1; este corecta;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2. Fie urmãtorul bloc de instructiuni Java:
{
int x = 10;
x=1;
{
int x = 100;
}
x=2;
}
Care afirmatie este adevarata:
a. instructiunea x=1; este incorecta;
b. instructiunea int x = 100; este incorecta;
c. instructiunea x=2; este incorecta;
d. instructiunea int x = 10; este incorecta;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3. Fie urmatoarea clasa Java:
class D {
int i;
float f;
boolean b;
}
Care afirmatie este adevarata:
a. instructiunea D d = new D(1); este corecta;
b. instructiunea D d = new D(1,1); este corecta;
c. instructiunea D d = new D(); este corecta;
d. instructiunea D d = new D(1,1,1); este corecta;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4. Fie urmatoarea metoda Java:
int storage(String s) {
return s.length() * 2;
}
si instructiunea
int i=storage(”Java”);
Care afirmatie este adevarata:
a. instructiunea este incorecta;
b. i va primi valoarea 4;
c. i va primi valoarea 16;
d. i va primi valoarea 8;

1
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5. Fie urmãtoarea clasã Java:
class C{
public static int i=1;
}
Si instructiunile:
C x=new C();
C y=new C();
x.i =x.i ?+1;

Care afirmatie este adevarata:

a. Dupa executarea instructiunii x.i =x.i ?+1; avem x.i = 2 si y.i=2;
b. Dupa executarea instructiunii x.i =x.i ?+1; avem x.i = 2 si y.i=1;
c. Dupa executarea instructiunii x.i =x.i ?+1; avem x.i = 1 si y.i=2;
d. Dupa executarea instructiunii x.i =x.i ?+1; avem x.i = 1 si y.i=1;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
6. Fie urmãtoarea clasã Java:
class C{
public static void main(String args[]){
System.out.println(args[0]);
System.out.println(args[1]);
}
}
Daca se executa linia de comanda:
>java C Curs Java An 3
atunci se va afisa:
a. Curs Java An
b. Curs
Java
c. Java An 3
d. Curs
Java
An
3
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

7. Fie urmãtoarea clasã Java:

class C{
public static void main(String args[]){
for(int i=0;i<args.length; i++)
System.out.println(“ “ + args[i]);
}
}
Daca se executa linia de comanda:
>java C Curs Java An 3
atunci se va afisa:
a. Curs
Java
b. Curs Java An
c. Curs
Java
An
3
d. Java An 3

2
8. Fie urmãtoarea clasã Java:
public class Person{
public Person(String p){name=new String(p);
System.out.println(++nr);
}
public static void main(String[] args){
while(true)f();
}
private static void f(){Person p =
new Person("Ionescu");
// obiectele NU se acumuleaza
// in heap si NU blocheaza executarea, spre deosebire de C++
}
private String name;
private static long nr=0;
};
Care afirmatie este adevarata:
a. Programul nu se opreste din executare;
b. Programul se termina, cu mesaj de eroare, deoarece la un moment
dat nu mai exista memorie suficienta pentru crearea obiectelor
Person;
c. Programul are erori de sintaxa;
d. Programul se termina, fara mesaj de eroare.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
9. Fie urmatoarele clase Java:
class Overflow extends Exception{
public Overflow(Stack o){source=o;}
public Stack getSource(){return source;}
private Stack source;
}
class Underflow extends Exception{
public Underflow(Stack o){source=o;}
public Stack getSource(){return source;}
private Stack source;
}
class Stack{
public Stack(int n, String s){
dim=n; name=s; top=-1;
v= new Object[dim];
}
public void insert(Object o) throws Overflow{
if(top < dim-1) v[++top]=o;
else throw new Overflow(this);
}
public void delete() throws Underflow{
if(top >=0) top--;
else throw new Underflow(this);
}
public Object item() throws Underflow{
if(top >=0) return v[top];
else throw new Underflow(this);
}
public String getName(){return name;}
private Object v[];
private int dim;
private int top;
private String name;
3
}
public class StackDriver{
public static void main(String args[]){
Stack s1,s2;
s1=new Stack(2, "stiva Tudor");
s2=new Stack(2, "stiva Andrei");
try{
s1.insert("aa");
s1.delete();
s1.item();
} catch (Overflow e){
System.out.println("Overflow la " +
e.getSource().getName());
} catch (Underflow e){
System.out.println("Unnderflow la " +
e.getSource().getName());
}
}
}
Care afirmatie este adevarata:
a. Programul afiseaza: Overflow la stiva Tudor
b. Programul afiseaza: Underflow la stiva Tudor
c. Programul afiseaza: Overflow la stiva Andrei
d. Programul afiseaza: Underflow la stiva Andrei
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

10. Fie urmatoarele clase Java:

class Overflow extends Exception{
public Overflow(Stack o){source=o;}
public Stack getSource(){return source;}
private Stack source;
}
class Underflow extends Exception{
public Underflow(Stack o){source=o;}
public Stack getSource(){return source;}
private Stack source;
}
class Stack{
public Stack(int n, String s){
dim=n; name=s; top=-1;
v= new Object[dim];
}
public void insert(Object o) throws Overflow{
if(top < dim-1) v[++top]=o;
else throw new Overflow(this);
}
public void delete() throws Underflow{
if(top >=0) top--;
else throw new Underflow(this);
}
public Object item() throws Underflow{
if(top >=0) return v[top];
else throw new Underflow(this);
}
public String getName(){return name;}
private Object v[];
private int dim;
4
private int top;
private String name;
}
public class StackDriver{
public static void main(String args[]){
Stack s1,s2;
s1=new Stack(2, "stiva Tudor");
s2=new Stack(2, "stiva Andrei");
try{
s2.insert("aa");
s2.delete();
s2.item();
} catch (Overflow e){
System.out.println("Overflow la " +
e.getSource().getName());
} catch (Underflow e){
System.out.println("Unnderflow la " +
e.getSource().getName());
}
}
}

Care afirmatie este adevarata:

a. Programul afiseaza: Underflow la stiva Andrei
b. Programul afiseaza: Underflow la stiva Tudor
c. Programul afiseaza: Overflow la stiva Tudor
d. Programul afiseaza: Overflow la stiva Andrei
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

11. Fie urmatoarele clase Java:

class Overflow extends Exception{
public Overflow(Stack o){source=o;}
public Stack getSource(){return source;}
private Stack source;
}
class Underflow extends Exception{
public Underflow(Stack o){source=o;}
public Stack getSource(){return source;}
private Stack source;
}
class Stack{
public Stack(int n, String s){
dim=n; name=s; top=-1;
v= new Object[dim];
}
public void insert(Object o) throws Overflow{
if(top < dim-1) v[++top]=o;
else throw new Overflow(this);
}
public void delete() throws Underflow{
if(top >=0) top--;
else throw new Underflow(this);
}
public Object item() throws Underflow{
if(top >=0) return v[top];
else throw new Underflow(this);
}
5
public String getName(){return name;}
private Object v[];
private int dim;
private int top;
private String name;
}
public class StackDriver{
public static void main(String args[]){
Stack s1,s2;
s1=new Stack(2, "stiva Tudor");
s2=new Stack(2, "stiva Andrei");
try{
s1.insert("aa");
s1.delete();
s2.insert("aa");
s2.insert( new Integer(10));
s2.insert("aa");
} catch (Overflow e){
System.out.println("Overflow la " +
e.getSource().getName());
} catch (Underflow e){
System.out.println("Unnderflow la " +
e.getSource().getName());
}
}
}

Care afirmatie este adevarata:

a. Programul afiseaza: Overflow la stiva Tudor
b. Programul afiseaza: Overflow la stiva Andrei
c. Programul afiseaza: Underflow la stiva Tudor
d. Programul afiseaza: Underflow la stiva Andrei
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

12. Fie urmatoarele clase Java:

class Stack{
public Stack(int n, String s){
dim=n; name=s; top=-1;
v= new Object[dim];
}
public void insert(Object o) {
v[++top]=o;
}
public void delete(){
top--;
}
public Object item(){
return v[top];
}
public String getName(){return name;}
private Object v[];
private int dim;
private int top;
private String name;
}
public class StackDriver{
public static void main(String args[]){
6
Stack s1,s2;
s1=new Stack(2, "stiva Tudor");
s1.insert("aa");
s1.insert( new Integer(10));
System.out.println("Varful stivei: " + s1.item());
}
Care afirmatie este adevarata:
a. Programul afiseaza:
Varful stivei: aa
b. Programul afiseaza: stiva Tudor
c. Programul afiseaza:
Varful stivei: 10
d. Programul afiseaza: 2
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

13. Fie urmatoarele clase Java:

class Stack{
public Stack(int n, String s){
dim=n; name=s; top=-1;
v= new Object[dim];
}
public void insert(Object o) {
v[++top]=o;
}
public void delete(){
top--;
}
public Object item(){
return v[top];
}
public String getName(){return name;}
private Object v[];
private int dim;
private int top;
private String name;
}
public class StackDriver{
public static void main(String args[]){
Stack s1,s2;
s1=new Stack(2, "stiva Tudor");
s1.insert("aa");
s1.insert( new Integer(10));
s1.delete();

System.out.println("Varful stivei: " + s1.item());

}
Care afirmatie este adevarata:
a. Programul afiseaza: stiva Tudor
b. Programul afiseaza:
Varful stivei: 10
c. Programul afiseaza: 2
d. Programul afiseaza:
Varful stivei: aa
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

7
14. Fie urmatoarele clase Java: identica cu 13, sunt inversate variantele de raspuns
class Stack{
public Stack(int n, String s){
dim=n; name=s; top=-1;
v= new Object[dim];
}
public void insert(Object o) {
v[++top]=o;
}
public void delete(){
top--;
}
public Object item(){
return v[top];
}
public String getName(){return name;}
private Object v[];
private int dim;
private int top;
private String name;
}
public class StackDriver{
public static void main(String args[]){
Stack s1,s2;
s1=new Stack(2, "stiva Tudor");
s1.insert("aa");
s1.insert( new Integer(10));
s1.delete();
System.out.println("Varful stivei: " + s1.item());
}
Care afirmatie este adevarata:
a. Programul afiseaza:
Varful stivei: aa
b. Programul afiseaza:
Varful stivei: 10
c. Programul afiseaza: stiva Tudor
d. Programul afiseaza: 2
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

15. Fie urmatoarele clase Java:

class Stack{
public Stack(int n, String s){
dim=n; name=s; top=-1;
v= new Object[dim];
}
public void insert(Object o) {
v[++top]=o;
}
public void delete(){
top--;
}
public Object item(){
return v[top];
}
public String getName(){return name;}
private Object v[];
private int dim;
8
private int top;
private String name;
}
public class StackDriver{
public static void main(String args[]){
Stack s1,s2;
s1=new Stack(2, "stiva Tudor");
s2=new Stack(2, "stiva Andrei");
s1.insert("aa");
s2.insert( new Integer(10));
System.out.println("Varful stivei: " + s1.item());
}
}
Care afirmatie este adevarata:
a. Programul afiseaza: stiva Tudor
b. Programul afiseaza:
Varful stivei: aa
c. Programul afiseaza: 2
d. Programul afiseaza:
Varful stivei: 10
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

16. Fie urmatoarele clase Java:

class CoadaCirculara{
public CoadaCirculara(int n, String s){maxDim=n; nume=s; v= new Object[maxDim];}
public boolean esteGoala(){return numarElemente==0;}
public boolean estePlina(){return numarElemente==maxDim;}
public void adauga(Object ob){
numarElemente++;
ultim= (ultim+1)%maxDim;
v[ultim]=ob;
}
public void elimina(){
numarElemente--;
prim=(prim+1)%maxDim;
}
public Object element(){
return v[prim];
}
// specializarea metodei Object.equals
// doua cozi sunt egale daca au aceleasi elemente
// chiar daca ele au dimensiuni maxime sau nume diferite
public boolean equals(Object obiectOarecare) {
if (obiectOarecare instanceof CoadaCirculara) {
CoadaCirculara cc= (CoadaCirculara)obiectOarecare;
boolean b=true;
b=b && (cc.numarElemente==numarElemente);
int i=prim;
int nr=numarElemente;
while(b && (nr !=0)){
b=b && cc.v[i].equals(v[i]);
nr--; i=(i+1)%maxDim;
}
return b;
}
return false;
}
9
public String nume(){return nume;}
private Object v[];
private int maxDim; // numarul maxim de elemente
private int prim=0;//pozitia primului element din lista
private int ultim=-1; //pozitia elementului adaugat ultima data
//lista are elementele in vectorul v, de la prim la ultim,
//in sensul acelor de ceasrnic
private int numarElemente=0; // numarul de elemente din coada
private String nume;// numele cozii
}
public class TestCoadaCirculara{
public static void main(String[] args){
CoadaCirculara x=new CoadaCirculara(3,"X");
CoadaCirculara y=new CoadaCirculara(3,"Y");
x.adauga("aa");
y.adauga("aa");
if(x.equals(y)) System.out.println("X=Y");
y.adauga("aa");
if(x.equals(y)) System.out.println("X=Y");
}
}
Care afirmatie este adevarata:
a. Programul afiseaza:
X=Y
X=Y
b. Programul nu afiseaza nimic
c. Programul afiseaza:
X=Y
d. Programul afiseaza: 3
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
17. Fie urmatoarele clase Java:
class CoadaCirculara{
public CoadaCirculara(int n, String s){maxDim=n; nume=s; v= new
Object[maxDim];}
public boolean esteGoala(){return numarElemente==0;}
public boolean estePlina(){return numarElemente==maxDim;}
public void adauga(Object ob){
numarElemente++;
ultim= (ultim+1)%maxDim;
v[ultim]=ob;
}
public void elimina(){
numarElemente--;
prim=(prim+1)%maxDim;
}
public Object element(){
return v[prim];
}
public String nume(){return nume;}
private Object v[];
private int maxDim; // numarul maxim de elemente
private int prim=0;//pozitia primului element din lista
private int ultim=-1; //pozitia elementului adaugat ultima data
//lista are elementele in vectorul v, de la prim la ultim,
//in sensul acelor de ceasrnic
private int numarElemente=0; // numarul de elemente din coada
private String nume;// numele cozii
10
}
public class TestCoadaCirculara{
public static void main(String[] args){
CoadaCirculara x=new CoadaCirculara(3,"X");
CoadaCirculara y=new CoadaCirculara(3,"Y");
x.adauga("aa");
y.adauga("aa");
if(x.equals(y)) System.out.println("X=Y");
y.adauga("aa");
if(x.equals(y)) System.out.println("X=Y");
}
}
Care afirmatie este adevarata:
a. Programul afiseaza: 3
b. Programul afiseaza:
X=Y
X=Y
c. Programul afiseaza:
X=Y
d. Programul nu afiseaza nimic
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18. Fie urmatoarele clase Java:

class CoadaCirculara{
public CoadaCirculara(int n, String s){maxDim=n; nume=s; v= new
Object[maxDim];}
public boolean esteGoala(){return numarElemente==0;}
public boolean estePlina(){return numarElemente==maxDim;}
public void adauga(Object ob){
numarElemente++;
ultim= (ultim+1)%maxDim;
v[ultim]=ob;
}
public void elimina(){
numarElemente--;
prim=(prim+1)%maxDim;
}
public Object element(){
return v[prim];
}
public String nume(){return nume;}
private Object v[];
private int maxDim; // numarul maxim de elemente
private int prim=0;//pozitia primului element din lista
private int ultim=-1; //pozitia elementului adaugat ultima data
//lista are elementele in vectorul v, de la prim la ultim,
//in sensul acelor de ceasrnic
private int numarElemente=0; // numarul de elemente din coada
private String nume;// numele cozii
}
public class TestCoadaCirculara{
public static void main(String[] args){
CoadaCirculara x=new CoadaCirculara(3,"X");
x.adauga("a");
x.adauga("b");
x.adauga("c");
x.adauga("d");
11
x.adauga("e");
x.adauga("f");
System.out.println(x.element());
}
}
Care afirmatie este adevarata:
a. Programul afiseaza: b
b. Programul afiseaza: d
c. Programul afiseaza: c
d. Programul afiseaza: a
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
19. Fie urmatoarele clase Java:
public interface Actualizare{
public void actualizareNume(String nume);
public void actualizareVarsta(int varsta);
}
interface Afisare{
public void afisare();
public void actualizareVarsta(int varsta);
}
public class Persoana{
public Persoana(String nume, int varsta){
this.nume=nume; this.varsta=varsta;
}
public Persoana(){}
protected String nume="XXXX";
protected int varsta=0;
}
class PersoanaSpecializata extends Persoana
implements Actualizare, Afisare{
public void actualizareNume(String nume){this.nume=nume;}
public void actualizareVarsta(int varsta){this.varsta=varsta;}
public void afisare(){
System.out.println("nume= "+nume);
System.out.println("varsta= " + varsta);
}
}
public class Client{
public static void main(String args[]){
PersoanaSpecializata p=new PersoanaSpecializata();
Actualizare act=p;
Afisare afis=p;
act.actualizareNume("Ionescu");
act.actualizareVarsta(58);
afis.afisare();
}
}
Care afirmatie este adevarata:
a. Programul este incorect deoarece o clasa nu poate implementa dou ã
interfete
b. Programul este incorect deoarece metoda public void afisare() nu
face parte din clasa Persoana
c. Programul afiseaza:
nume= Ionescu
varsta= 58
d. Programul este incorect deoarece metoda public void actualizareVarsta(int
varsta) nu face parte din clasa PersoanaSpecializata
12
20. Fie urmatorul program Java:
import java.awt.*;
import java.awt.event.*;
class Model{
private int x=0;
public Model(){};
public void actiune(){x++;System.out.println(x);};
}
public class View extends Frame{
private Button b;
private Model m;
private Controller c;
public static void main(String args[]){
Frame f= new View();
}
public View(){
setTitle("Exemplu Model-View-Controller");
b= new Button("Actiune");
add(b);
m=new Model();
c=new Controller(m);
b.addActionListener(c);
setSize(100,50);
setVisible(true);
}
}
class Controller implements ActionListener{
private Model md;
public Controller(Model p){
md=p;
}
public void actionPerformed(ActionEvent e){
md.actiune();
}
}
Care afirmatie este adevarata, dacã se face de douã ori click pe butonul stang mouse
asupra butonului Actiune:
a. Programul nu afiºeazã nimic
b. Programul afiseazã:
12
c. Valoarea atributului f.m.x rãmâne mereu la valoarea 0
d. Programul afiºeazã:
01
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

21. Fie urmatorul program Java:

import java.awt.*;
import java.awt.event.*;
class Model{
private int x=0;
public Model(){};
public void increment(){x++;}
public int get_x(){return x;}
}
public class View extends Frame{
private Button b;
13
protected Model m;
private Controller c;
protected TextField tf;
public static void main(String args[]){
Frame f= new View();
}
public View(){
setTitle("Exemplu Model-View-Controller");
b= new Button("Actiune");
add("North",b);
m=new Model();
c=new Controller(this);
b.addActionListener(c);
tf=new TextField(10);
add("Center",tf);
setSize(100,250);
setVisible(true);
}
}
class Controller implements ActionListener{
private View vw;
public Controller(View v){
vw=v;
}
public void actionPerformed(ActionEvent e){
vw.m.increment();
vw.tf.setText(String.valueOf(vw.m.get_x()));
}
}

Care afirmatie este adevarata, dacã se face de douã ori click pe butonul stang mouse
asupra butonului Actiune:
a. În câmpul de text f.tf este afiºatã valoarea 1
b. Programul nu afiºeazã nimic
c. În câmpul de text f.tf este afisatã valoarea 2
d. Valoarea atributului f.m.x rãmâne mereu la valoarea 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

14
22. Fie urmatorul program Java:
import java.util.Observer;
import java.util.Observable;
import java.awt.*;
import java.awt.event.*;
public class Observator extends Frame
implements WindowListener, Observer{
static protected ModelObservabil m=new ModelObservabil();
protected Button exitB, actB;
protected TextField field;
private ButtonController buttonC;
public static void main(String args[]){
Frame fn=new Observator(0);// nu observa pe m
Frame f01=new Observator(1);// observa pe m
Frame f02=new Observator(1);// observa pe m
}
public Observator(int i){
if (i==1)m.addObserver(this);
Panel p= new Panel();
buttonC=new ButtonController(this);
exitB= new Button("Exit");
exitB.addActionListener(buttonC);
actB= new Button("modifica");
actB.addActionListener(buttonC);
field= new TextField("MyTextField");
field.setEditable(true);
p.add(exitB);
p.add(actB);
add(field);
add("North",p);
addWindowListener(this);
setSize(160,110);
setVisible(true);
}
public void windowClosed(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowActivated(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowClosing(WindowEvent e){dispose();
//System.exit(0);
}
public void update(Observable observ, Object ob){
field.setText(m.afis);
}
}
class ButtonController implements ActionListener{
Observator view;
public ButtonController(Observator win){
view=win;
}
public void actionPerformed (ActionEvent e){
Object source=e.getSource();
if (source == view.exitB) System.exit(0);
else {
15
view.m.modifica();
};
}
}
class ModelObservabil extends Observable{
protected int i=0;
protected String afis=" ";
public ModelObservabil(){
setChanged();
notifyObservers();
}
public void modifica(){
i++;
afis= " "+ i;
setChanged();
notifyObservers();
}
}

Care afirmatie este adevarata, dacã se face de click pe butonul stang mouse asupra
butonului „modifica” din fereastra fn:
a. Doar in câmpul de text field al ferestrei fo2 este afiºatã valoarea actualizata a
atributului Observator.m.i
b. În câmpul de text field al tuturor ferestrelor este afiºatã valoarea actualizata a
atributului Observator.m.i
c. Doar in câmpul de text field al ferestrei fo1 este afiºatã valoarea actualizata a
atributului Observator.m.i
d. Doar in câmpul de text field al ferestrelor fo1 si fo2 este afisatã valoarea
actualizata a atributului Observator.m.i
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 1. Un program scris în Java poate rula pe orice platforma deoarece:
a. Limbajul Java e derivat din C++
b. Compilatorul este identic cu cel de C++
c. Masina virtuala translateaza interpreteaza programul si translateaza apelurile sistem
d. Api-ul este portabil
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 2. Ce este un Applet?
a. Un tip de calculator
b. Un program care ruleaza direct pe orice calculator
c. Un sit web interactiv
d. Un program care ruleaza în contextul unui browser
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 3. Un applet va rula în orice browser deoarece
a. Serverul are o masina virtuala incorporata
b. Browserul are o masina virtuala incorporata
c. Browserul interpreteaza direct codul sursa
d. Appleturile nu au nevoie de o masina virtuala
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 4. Care este scopul metodei statice main ?
a. Sa creeze o interfata cu utilizatorul
b. Actioneaza ca un punct de intrare în program
c. Creaza ferestrele si butoanele aplicatiei
d. Actioneaza ca o poarta spe sistemul de operare
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

16
____ 5. O clasa Applet furnizeaza:
a. Un browser care sã ruleze apletul
b. Metode care definesc aspectul si comportamentul apletului
c. A pagina HTML speciala
d. Permisiunile de a comunica cu serverul
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 6. Ce metoda apeleaza browserul pe un applet nou incarcat?
a. Main
b. Start
c. Paint
d. Init
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 7. Care este rolul declaratiilor import?
a. Permite referirea claselor fara utilizarea de prefixe
b. Elimina necesitatea declararii variabilelor
c. Permite importul imaginilor folosite
d. Elimina apelurile directe a functiilor fara clase
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 8. In cazul implementarii unei interfete trebuie sã definim in mod obligatoriu :
a. Doua metode ale interfetei
b. Numai anumite metode ale interfetei
c. Orice metoda a interfetei
d. Toate metodele interfetei
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 9. Aplicatiile Java ruleaza pe urmatorul sistem de operare:
a. Windows
b. Linux
c. UNIX
d. Toate cele trei
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 10. Urmatorul cod sursa Java se afla într-un fisier. Cum se numeste fisierul?
class Foo {
public static void println() { System.out.println("Foo"); }
}
public class FooDemo {
public static void main(String[] argv) {
System.out.println("FooDemo");
Foo.println();
}
}
a. Foo.java
b. Foo.class
c. FooDemo.Java
d. Foodemo.class
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 11. Daca bo este boolean, numar este int sir este string atunci care din urmatoarele linii este incorecta?
a. If(bo)
b. If(numar<0)
c. If(numar<=1)
d. If(sir==”Java”)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

17
____ 12. Care sunt valorile variabilelor a ºi b dupa executarea instructiunilor:
int a = 1, b = -2;
a = a + b;
b = a – b;
a = a – b;
a. a=1, b=2
b. a=0, b=1
c. a=2, b=-3
d. a=-2, b=1
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 13. Clasa BorderLayout contine campuri statice pentru:
a. Adaugarea unor componente in anumite zone ale containerul
b. Introducerea unor metode noi
c. Specificarea culorii, si a fontului
d. Afisarea ferestrei unui applet
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 14. Constructorul are foloseste la:
a. Eliberarea memoriei
b. Importa pachete
c. Initializeaza masina virtuala
d. Initializeaza noile obiecte create
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 15. System.out.println este
a. O variabila
b. O clasa
c. Un obiect
d. O metoda
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 16. Ce valori poate lua o variabila de tip boolean?
a. 1
b. 0
c. “true”
d. false
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 17. Care din urmatoarele tipuri de date poate retine valori de la -32.768 la 32.767 ?
a. char
b. short
c. byte
d. int
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 18. Ce valoare va avea variabila x dupa executarea operatiilor?
int x = 0;
x = (5*4) % 7;
x = x / 5;
a. 6
b. 5
c. 1
d. 0
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

18
____ 19. Ce valoare va avea variabila numar la finalul buclei?
int numar = 1;
for (int x = 0; x < 4; x++)
{
numar = numar << 1;
}
a. 1
b. 4
c. 16
d. 32
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 20. Ce efect va avea intructiunea urmatoare?
System.out.println("The answer is: "+17+3);
a. Programul nu se compileaza
b. Se va afisa: The answer is 20
c. Se va afisa: The answer is 173
d. Se va genera o exceptie
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 21. Care este efectul liniilor de cod urmatoare?
if("String".toString() == "String")
System.out.println("Equal");
else
System.out.println("Not Equal");
a. Programul nu se compileaza
b. Afiseaza Equal
c. Afiseaza Not Equal
d. Genereaza o exceptie
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 22. O clasa care implementeaza interfata urmatoare …
public interface AQuestion
{
public abstract void someMethod() throws Exception;
}
a. Va fi in mod necesar o clasa abstracta
b. Ar trebui sa defineasca metoda public abstract void someMethod();
c. Ar trebui sã defineasca o metoda public void someMethod() care va emite exceptii
d. Ar trebui sã defineasca o metoda public void someMethod() care nu va emite exceptii
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 23. O clasa care implementeaza interfata urmatoare va implementa în mod obligatoriu
public interface AQuestion
{
void someMethod();
}
a. o metoda public void someMethod();
b. o metoda friend void someMethod();
c. o metoda public void someMethod(); care obligatoriu va emite exceptii
d. o metoda public abstract void someMethod();
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

19
____ 24. Care din liniile din codul de mai jos prezinta o problema de incapsulare ?
1. class BadCode {
2. int num;
3. public int getNum() {
4. return num;
5. }
6. public void setNum(int num) {
7. this.num = num;
8. }
9. ...
10. }
a. Linia 1
b. Linia 2
c. Linia 4
d. Linia 7
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 25. Care din liniile urmatoare va genera o exceptie ?
1. class BadCode {
2. private Foo foo;
3. public BadCode (Foo f) {
4. foo = f;
5. }
6. public BadCode() {}
7. protected void useFoo() {
8. int num = foo.num;
9. String name = foo.name;
10. ....
11. }
12. ....
13. }
a. Linia 2
b. Linia 4
c. Linia 6
d. Linia 8
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 26. Dorim sa implementam o clasa total protejata si care sa nu mai fie extensibila, care din liniile
urmatoare ar trebui modificata?
1. class Test {
2. private int key = 1234;
3. //...
4. protected void setKey(int privateKey) {
5. this.key = privateKey;
6. }
7. protected int getKey() {
8. return this.key;
9. }
10. //...
11. }
a. Linia 1
b. Linia 2
c. Linia 4
d. Linia 8
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

20
____ 27. Functia Clone() are ca scop:
class Test {
private int key = 1234;
//...
public Test () {}
public Test (int k) { this.key = k; }
protected int getKey(){return this.key; }
public final Object clone() throws
java.lang.CloneNotSupportedException {
throw new java.lang.CloneNotSupportedException();
}
//...
}
a. definirea unei clase clonabile
b. definirea unei clase extensibile
c. definirea unei clase care nu poate fi extinsa
d. clasa si orice derivare a acesteia va fi neclonabila
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 28. Pentru a bloca serializarea unei clase trebuie sa:
a. Definim clasa ca fiind finala
b. Definim clasa ca fiind statica
c. Definim o metoda readObject
d. Definim o metoda writeObject
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 29. Codul sursa urmator ne spune ca:
public boolean match(Object o) {
return this.getName() == ((SomeClass)o).getName();
}
a. obiectele sunt identice
b. obiectele sunt egale
c. obiectele fac parte din aceiasi clasa
d. nici una
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 30. Pentru a defini un camp care sa stocheze informatii sensibile (conturi, nr. de card) se va folosi:
a. String
b. StringBuffer
c. Char array
d. Char
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 31. Ce efect va produce urmatorul program Java?
public class Test
{
public void method(Object o)
{
System.out.println("Object Version");
}
public void method(String s)
{
System.out.println("String Version");
}
public static void main(String args[])
{
Test t = new Test();
t.method(null);
}
}
a. Programul nu se compileaza
b. Se compileaza dar produce o exceptie la rulare
c. Afiseaza “Object Version”
d. Afiseaza “String Version”
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

21
____ 32. Ce efect va produce urmatorul program Java?
public class Test
{
public void method(StringBuffer sb)
{
System.out.println("StringBuffer Version");
}
public void method(String s)
{
System.out.println("String Version");
}
public static void main(String args[])
{
Test t = new Test();
t.method(null);
}
}
a. Programul nu se compileaza
b. Se compileaza dar produce o exceptie la rulare
c. Afiseaza “StringBuffer Version”
d. Afiseaza “String Version”
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 33. Ce efect are urmatorul program Java?
public class Test{
public static void main(String args[]){
System.out.println("Before Try");
try{
}
catch(Throwable t){
System.out.println("Inside Catch");
}
System.out.println("At the End");
}
}
a. Nu se complieaza: nici un obiect Throwable nu a fost emis in blocul try
b. Nu se compileaza: nu pot fi prinse obiecte Throwable, ci numai obiecte Exception
c. Afiseaza “Before Try” si “At the End”
d. Afiseaza “Before Try” , “Inside Catch” si “At the End”
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 34. Ce efect are urmatorul program Java?
public class Test{
public static void main(String args[]){
System.out.println("Before Try");
try{
}
catch(IOException t){
System.out.println("Inside Catch");
}
System.out.println("At the End");
}
}
a. Nu se complieaza: nici un obiect IOException nu a fost emis in blocul try
b. Nu se compileaza: nu pot fi prinse obiecte IOException, ci numai Exception
c. Afiseaza “Before try” si “At the End”
d. Afiseaza “Before try” , “Inside Catch” si “At the End”
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

22
____ 35. Care din urmatoarele afirmatii este adevarata?
a. O metoda statica nu poate returna un obicet Exception
b. O metoda statica nu poate emite un obiect Exception
c. O metoda statica nu poate returna o variabila statica a clasei
d. O metoda statica nu poate returna o variabila nestatica a clasei
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 36. Cum se va comporta urmatorul program?
public class A
{
private void method1() throws Exception
{
throw new RuntimeException();
}
public void method2()
{
try
{
method1();
}
catch(RuntimeException e)
{
System.out.println("Caught Runtime Exception");
}
catch(Exception e)
{
System.out.println("Caught Exception");
}
}
public static void main(String args[])
{
A a = new A();
a.method2();
}
}
a. Programul nu se compileaza
b. Afiseaza “Caught Exception”
c. Afiseaza “Caught Runtime Exception”
d. Afiseaza ambele mesaje
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 37. Cum se va comporta urmatorul program?
class Base{
public void aMethod() throws ClassNotFoundException
{
}
}
public class Derived extends Base
{
public void aMethod() throws RuntimeException
{
}
}
a. Programul nu se compileaza deoarece RuntimeException nu este derivata din
RuntimeException
b. Se lanseaza o exceptie ClassNotFoundException la compilare
c. Se lanseaza o exceptie RuntimeException la rulare
d. Se compileaza corect
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
23
____ 38. Cititi cu atentie urmatorul co sursa:
import java.awt.*;
public class TestFrame extends Frame
{
Button bNorth = new Button("North");
Button bSouth = new Button("South");
Button bEast = new Button("East");
Button bWest = new Button("West");
Button bCenter = new Button("Center");
public TestFrame()
{
setLayout(new BorderLayout());
add(bSouth,BorderLayout.SOUTH);
add(bWest,BorderLayout.WEST);
add(bEast,BorderLayout.EAST);
add(bNorth,BorderLayout.NORTH);
add(bCenter);
setLayout(new FlowLayout());
validate();
pack();
setVisible(true);
}
public static void main(String args[])
{
TestFrame tf = new TestFrame();
}
}
a. Programul nu se compileaza
b. Se compileaza si afiseaza butoanele pe o singura linie
c. Se compileaza dar genereaza o exceptie
d. Se compileaza si afiseaza butoanele sub forma de grid
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 39. O clasa care are totii constructorii privati :
a. Trebuie declarata clasa finala
b. Poate fi instantiata
c. Poate fi mostenita
d. Nu poate fi mostenita
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
____ 40. Urmariti cu atentie codul urmator:
public class NiceThreads implements Runnable
{
public void run()
{
while(true) { }
}
public static void main(String args[])
{
NiceThreads nt1 = new NiceThreads();
NiceThreads nt2 = new NiceThreads();
NiceThreads nt3 = new NiceThreads();
nt1.run();
nt2.run();
nt3.run();
}
}
a. Se compileaza si lanseaza patre fire care vor rula la infinit
b. Se compileaza si se lanseaza un singur fir
c. Programul nu se compileaza
d. Se compileaza dar genereaza o exceptie la rulare
24