Instrucțiuni de decizie în Limbajul Java

 Instrucțiunea if-else

Sintaxă:                                    

if (expresie) { ... lista instrucțiuni } else  { ... lista instrucțiuni }

Semantică:

Se evaluează expresia dintre paranteze care trebuie sa returneze o valoare booleană. Dacă ea returnează true atunci se execută lista de instrucțiuni din corpul if. Dacă ea returnează false se execută lista de instrucțiuni else.

 

Exemplu:

int x = 4; if( x % 2 == 0 ) x = 100; else x = 1000;

❗ Instrucțiunea if  poate avea mai multe forme:

Instrucțiunea switch-case

Sintaxă:

switch (expresie) {    case valoare_particulara1 : < expresie 1 >    break;    case valoare_particulara2 : < expresie 2 >    break;     …    default : < expresie >   }

Semantică:

Execuţia instrucțiunii switch începe întotdeauna prin evaluarea expresiei dintre parantezele rotunde. Această expresie trebuie să fie de tipul caracter, octet, întreg scurt sau întreg. Selectorul instrucțiunii switch poate fi și de tip String începând cu versiunea Java 7.

 După evaluarea expresiei se trece la compararea valorii rezultate cu valorile particulare specificate în etichetele case din interiorul blocului de instrucțiuni. Dacă una dintre valorile particulare este egală cu valoarea expresiei, se execută instrucțiunile începând de la eticheta case corespunzătoare acelei valori în jos, până la capătul blocului. Dacă nici una dintre valorile particulare specificate nu este egală cu valoarea expresiei, se execută instrucțiunile care încep cu eticheta default, dacă aceasta există.

Este important ca fiecare expresie de tip case să fie terminată cu instrucțiunea break deoarece aceasta asigura ieșirea din structură.

Notă!

1.     Constantele case trebuie să fie de același tip ca și selectorul.

2.     Nu pot exista 2 constante case cu același nume.

3.     Cel mult o constantă poate fi asociată unui selector.

 

Exemplu switch cu selector de tip int:

public class Main{

  public static void main(String[] args) {

   int selector = 2;

    switch(selector){

     case 1:

       System.out.println("Valoarea este egala cu 1");

     break;

     case 2:

       System.out.println("Valoarea este egala cu 2");

     break;

     case 3:

       System.out.println("Valoarea este egala cu 3");

     break;

     case 4:

       System.out.println("Valoarea este egala cu 4");

     break;

   default:

      System.out.println("Valoarea nu aparține intervalului");

    }

}}

Rezultat: 

Exemplu switch cu break omis:

public class Main{

  public static void main(String[] args) {

   int selector = 6;

    switch(selector){

     case 2:

     case 4:

     case 6:

     case 8:

       System.out.println("Numar par");

     break;

   default:

      System.out.println("Numar impar");

    }

}}

Rezultat: 

Notă! Într-un switch, dacă nu pui break, programul continuă să execute și instrucțiunile din cazurile următoare. Acest comportament se numește fall-through.

Poate fi util pentru a grupa cazuri similare, dar dacă uiți break din greșeală, programul poate produce rezultate neașteptate. 

Exemplu switch cu selector de tip String:

public class Main{

  public static void main(String[] args) {

  String luna = "Iunie";

  switch (luna) {

    case "Iunie":

    case "Iulie":

    case "August":

       System.out.println("E vară");

    break;

   default:

    System.out.println("Nu e vară");

}

}} 

Exemplu de expresie cu switch: Începând cu Java 12, instrucțiunea switch a fost extinsă și poate fi folosită nu doar ca o structură de control, ci și ca o expresie care returnează o valoare. 

Asta înseamnă că putem atribui direct rezultatul unui switch unei variabile. 

public class Main{

  public static void main(String[] args) {

   int valoare = 3;

   String rezultat = switch (valoare) {

    case 1 -> "unu";

    case 2 -> "doi";

    case 3, 4 -> "trei sau patru";

    default -> "alt număr";

     };

System.out.println(rezultat);

}}

Să aveți o zi deosebită!

❤️

Tipuri identice și tipuri compatibile. Conversia implicită și explicită

Tipuri identice

Două variabile sunt de tip identic dacă:

• sunt declarate cu același tip de date (ex. ambele int, ambele double, ambele String).

• atribuirea dintre ele se face direct, fără conversii.

Exemplu:

public class TipuriIdentice {
public static void main(String[] args) {
   int a = 5; // variabilă int
   int b = 10; // variabilă int
   a = b; // tipuri identice: corect
   System.out.println("a = " + a); // afișează 10
}
}

Tipuri compatibile

Două variabile sunt de tipuri compatibile dacă:

• pot fi atribuite una alteia, dar este necesară o conversie de tip (implicită sau explicită).
• exemplu: int este compatibil cu double, dar nu identic.

Exemplu:

public class TipuriCompatibile {
public static void main(String[] args) {
int x = 7;
double y = x; // conversie implicită int → double
System.out.println("y = " + y); // afișează 7.0
double z = 9.8;
int w = (int) z; // conversie explicită double → int
System.out.println("w = " + w); // afișează 9
}
}

Deci:

• int → double se face automat (se mărește precizia).
• double → int necesită conversie explicită (se pierde partea zecimală).

Rețineți ! 

Implicit în limbajul Java se convertesc:

• byte la short, int, long, float, double;
• short la int, long, float, double;
• int la long, float, double;
• char la int, long, float, double;
• long la float, double;
• float la double;

Explicit în limbajul Java se convertesc:

• byte la char;
• char la byte, short;
• short la byte, char;
• int la byte, short, char;
• long la byte, short, char, int, long;
• float la byte, short, char, int, long;
• double la byte, short, char, int, long, float.

Situații de incompatibilitate

Există cazuri unde tipurile nu sunt nici identice, nici compatibile.

Exemplu

public class Incompatibil {
public static void main(String[] args) {
int nr = 10;
String text = "Salut";
nr = text; // EROARE: int și String nu sunt compatibile
}
}

Deoarece int și String sunt tipuri complet diferite acestea nu pot fi atribuite.

Clase și obiecte. Sintaxă și semantică

Clasa stă de fapt la baza programării orientate e obiecte, pe ea este construit întregul limbaj Java, deoarece clasa definește obiectul.

O clasă reprezintă un șablon sau un tip de bază pentru crearea obiectelor. Este un tip abstract de date definit de programator. Atunci când definim o clasă nouă creăm un nou tip de date.

O clasă descrie un set de caracteristici (date, atribute sau variabile de instanță) și comportamente (funcționalitate, metode sau funcții) pe care obiectele create din acea clasă le vor avea. Clasa în POO întrunește toate obiectele de una şi aceeași natură, ceea ce înseamnă că obiectele care aparțin uneia și aceleiași clase au una şi aceeași structură şi comportament.

Sintaxa de definire a unei clase este: 

Prima parte din declarația unei clase o constituie modificatorii de acces care sunt opționali. După numele clasei putem specifica, dacă este cazul, faptul că respectiva clasă este subclasă a unei alte clase cu numele nume_super_clasă, sau/şi că implementează una sau mai multe interfeţe ale căror nume trebuie separate prin virgulă.

Corpul unei clase este cuprins între { } şi are ca conţinut:

• declararea şi inițializarea variabilelor de instanţă şi de clasă;
• declararea şi implementarea constructorilor;
• declararea şi implementarea metodelor de instanţă şi de clasă;
• declararea unor clase interne.

Reţineţi!

• într-un fișier Java pot fi definite mai multe clase;
• într-un fișier Java numai o clasă poate avea modificatorul public;
• fișierul Java ce conține o clasă publică trebuie să fie cu același nume ca și clasa publică.

O clasă poate avea unul din următoarele cuvinte rezervate în declarația acestora:

Exemplu de declarație de clasă: 

În Java orice clasă conţine 2 tipuri de elemente : atribute (variabilele) şi metode. 

Clasa String. Limbajul Java.

Definiție:

public final class String extends Object implements Serializable, Comparable<String>, CharSequence

Descriere:

Clasa String se află în pachetul java.lang și este utilizată pentru crearea și prelucrarea șirurilor de caractere. Este o clasă închisă spre modificare (immutable), adică o clasă obiectele căreia nu se modifică. Orice valoare atribuită obiectului rămâne în sistem creând astfel a mulțime de obiecte neutilizate. Pentru a crea un șir de caractere puteți utiliza sintaxa: 

String identificator = ”Valoare”; 

De exemplu: String zi = ”Luni”;

Ori de câte ori compilatorul găsește un literal String în codul sursă acesta crează un obiect de tipul clasei String ce va conține ca valoare literalul. 

La fel ca și în cazul celorlalte obiecte, puteți folosi constructorul clasei String pentru a crea o instanță a acestei clase. 

De exemplu: String zi = new String(”Luni”);

Metode:

a) char charAt(int index) - returnează caracterul ce se află pe poziția index. Indicele caracterului din șir variază de la 0 la length()-1. 

De exemplu:

          String s = "Java";

          System.out.println(s.charAt(1)); //a

b) public boolean equals(Object unObiect) – returnează true dacă obiectul curent este echivalent ca valoare cu string-ul unObiect, în caz contrar returnează false. Se ține cont de litere mari și mici.

De exemplu:

String s = "Java";

String s1 = "Java";

String s2 = "java";

System.out.println(s.equals(s1)); //true

System.out.println(s.equals(s2));  //false

c) public boolean equalsIgnoreCase(String altString) - returnează true dacă obiectul curent este echivalent ca valoare cu string-ul altString, în caz contrar returnează false. Nu se ține cont de litere mari si mici.
De exemplu:

String s = "Java";

String s1 = "java";

String s2 = "Java";

System.out.println(s.equalsIgnoreCase(s1)); //true

System.out.println(s.equalsIgnoreCase(s2)); //true

d) public int length() - returnează lungimea șirului de caractere.
De exemplu:

String s = "Java";

System.out.println(s.length()); //4

e) public boolean isEmpty() - returnează true dacă și numai dacă length() este 0.
De exemplu:

String s = "Java" ;

String s2 = "";

System.out.println(s.isEmpty());  // false

System.out.println(s2.isEmpty());  // true

f) public boolean startsWith(String prefix, int toffset) - verifică dacă substrigul din șirul dat începând cu poziția toffset începe cu prefixul prefix. 

De exemplu:

String s = "Programare" ;

System.out.println(s.startsWith("ram", 3));   //false

System.out.println(s.startsWith("ram", 4));   //true

System.out.println(s.startsWith("ram", 10));  //false

System.out.println(s.startsWith("ram", -3));  //false

g) public boolean startsWith(String prefix) - verifică dacă șirul dat începe cu prefixul prefix.
De exemplu:

String s = "Programare" ;

System.out.println(s.startsWith("Prog"));  //true

System.out.println(s.startsWith("ram"));   //false

h) public boolean endsWith(String suffix) - verifică dacă șirul dat finisează cu sufixul suffix.
De exemplu:

String s = "Programare" ;

System.out.println(s.endsWith("re"));      //true

i) public int indexOf(String ch) - returnează indicele caracterului ch în cadrul unui șir de caractere.
De exemplu:

String s = "Programare" ;

System.out.println(s.indexOf("r")); //1

System.out.println(s.indexOf("b")); //-1

System.out.println(s.indexOf("P")); //0

System.out.println(s.indexOf("p")); //-1

j) public int lastIndexOf(String ch) - returnează indicele ultimei apariți a caracterului ch în cadrul unui șir de caractere. 

De exemplu:

String s = "Programare" ;

System.out.println(s.lastIndexOf("r")); //8

System.out.println(s.lastIndexOf("b")); //-1

System.out.println(s.lastIndexOf("o")); //2

k) public String concat(String str) – concatinează două șiruri de caractere. 

De exemplu:

String s = "programez in " ;

String s1 = " Java" ;

s.concat(s1);

System.out.println(s);     // programez

String s3 = s.concat(s1);

System.out.println(s3);     // programez in Java

System.out.println("Eu ".concat(s3)+" azi"); //Eu programez in Java azi

l) public String replace(char oldChar, char newChar) - returnează un string rezultat din înlocuirea tuturor aparițiilor caracterelor specificate în oldChar prin newChar. 

De exemplu:

String s = "tata";

System.out.println(s.replace("t", "m")); //mama

System.out.println("Ei pleaca".replace("Ei", "Ele")); //Ele pleaca

m) public boolean contains(CharSequence s) – returnează true daca și numai dacă șirul de caractere conține secvența căutată specificată prin s.
De exemplu:

String s = "Programez in Java";

System.out.println(s.contains("Java")); //true

System.out.println("Ei pleaca".contains("Ele")); //false

n) public String toLowerCase() - Convertește toate literele șirului de caractere în litere mici.
De exemplu:

String s = "Programez";

System.out.println(s.toLowerCase());   //programez

System.out.println("Ei pleaca".toLowerCase());   //ei pleaca
o) public String toUpperCase() - Convertește toate literele șirului de caractere în litere mari.
De exemplu:

String s = "Programez";

System.out.println(s.toUpperCase()); //PROGRAMEZ

System.out.println("in java".toUpperCase()); //IN JAVA

p) public String substring(int beginIndex) - returnează un subșir din șirul asupra căruia s-a apelat metoda începând cu indexul elementului din șir specificat prin beginIndex.
De exemplu:

String s = "Programez";

System.out.println(s.substring(3)); // gramez

System.out.println(s.substring(-1)); 

// StringIndexOutOfBoundsException

System.out.println(s.substring(9)); // nu se afiseaza nimic

q) substring(int IndexInitial, int IndexFinal) - returnează un subșir din șirul asupra căruia s-a apelat metoda data începând cu caracterul aflat pe poziția IndexInitial pînă la caracterul cu indicele IndexFinal.

De exemplu:

String s = "Programez";

System.out.println(s.substring(0,7)); // Program

System.out.println(s.substring(0,10)); 

//StringIndexOutOfBoundsException 

System.out.println(s.substring(1,1)); 

// nu se afiseaza nimic

System.out.println(s.substring(3,1)); 

// StringIndexOutOfBoundsException

r) public String trim() - întoarce o copie a șirului fără spațiile de la începutul și sfârșitul șirului. 

De exemplu:

String s = "  Programez  ";

String s1 = "Programez";

System.out.println(s.equals(s1)); //false

System.out.println(s.trim().equals(s1)); //true

A se acorda o deosebită atenție atunci cînd lucrați cu operatorul de concatenare +. 

Se va ține cont de următoarele reguli:
1. Dacă ambii operanzi sunt numerici operatorul + va efectua operația de adunare.
2. Dacă unul din operanzi este String operatorul + va efectua concatenarea.
3. Expresia este evaluată de la stânga la dreapta.

De exemplu:

String s1 = "Hello";

int a = 3;

String s2 ="4";

String s3 ="4";

System.out.println(a+s1); //3Hello

System.out.println(s1+a); //Hello3

System.out.println(s2+s3); //44

System.out.println(1+2); //3

System.out.println("a"+"b"); //ab

System.out.println("a"+3); //a3

System.out.println("a"+3+4); //a34

System.out.println(3+"a"); //3a

System.out.println(3+4+"a"+6+1); //7a61

System.out.println("a"+6+1); //a61

System.out.println(6+1+"a"); //7a

Sper din tot sufletul că această postare vă este de folos! O zi deosebită să aveți !