MINISTERUL EDUCAȚIEI ȘI CERCETĂRII

AL REPUBLICII MOLDOVA
Universitatea Tehnică a Moldovei
Facultatea Calculatoare, Informatică şi Microelectronică
Departamentul Informatică și Ingineria Sistemelor

Raport
pentru lucrarea de laborator Nr.1

la cursul de “Tehnici avansate de programare”

Tema: Clase, obiecte, constructori

Verificat:

Chișinău – 2023

1
 Cuprins
TEMA LUCRĂRII..............................................................................................................3

SCOPUL LUCRĂRII:........................................................................................................3

ETAPELE DE REALIZARE:............................................................................................3

SARCINA 1:........................................................................................................................3

CODUL:..............................................................................................................................3
OUTPUT:............................................................................................................................4

CONCLUZII........................................................................................................................6

2
 Lucrare de laborator nr. 1
Tema lucrării: Clase, obiecte, constructori
Scopul lucrării:

 Însuşirea modalităţilor de creare a claselor, obiectelor în Java;

 Însuşirea modalităţilor de prelucrare a şirurilor de caractere utilizând clasele de bază;

Etapele de realizare:

1. Crearea unor clase noi;

2. Crearea şi iniţializarea obiectelor
3. Utilizarea metodelor claselor Sting şi StringBuffer pentru modificarea şirurilor;
4. Crearea interfeţii programului;
5. Prezentarea lucrării.

1.Sarcina 1:
În fiecare cuvânt din textul dat simbolul de pe poziţia indicată a cuvântului de
înlocuit cu un simbol dat. Dacă poziţia indicată este mai mare ca lungimea cuvântului,
corecţia nu se face.
Codul:
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

System.out.print("Introduceți textul: ");

String sentence = scanner.nextLine();

System.out.print("Introduceți poziția simbolului de înlocuit:

");
int position = scanner.nextInt();

System.out.print("Introduceți simbolul de înlocuit: ");

char symbol = scanner.next().charAt(0);

Text myText = new Text(sentence, position, symbol);

3
 myText.changeSentence();
System.out.println("Textul rezultat: " + myText.getSentence());
}
}

class Text
{
private String mySent;
private int pos;
private char symb;
private String newSent = "1.";
public Text( String mySent, int pos, char symb)
{
this.mySent = mySent;
this.symb = symb;
this.pos = pos;
}
public String getSentence()
{
return newSent;
}
public void changeSentence()
{
String[] words = mySent.split("[\\s,.:;?!]+");

for (int i = 0; i < words.length; i++) {

if (pos < words[i].length()) {
StringBuilder sb = new StringBuilder(words[i]);
sb.setCharAt(pos, symb);
words[i] = sb.toString();
}
}
newSent = String.join(" ", words);
}
}

4
Output:

Figura 1.1. Rularea programului

La rularea acestui program, în terminal se va afișa fraza „Introduceți textul”, care solicită
de la utilizator introducerea de la tastatură a unei propoziții și apăsarea butonului Enter.

Figura 1.2. Introducerea poziției

După ce textul a fost citit, se solicită inserarea poziției pentru înlocuire, adică a câta literă
din cuvinte va fi modificată.

Figura 1.3. Simbolul pentru înlocuire

După alegerea poziției, va fi nevoie de introdus și simbolul nou cu care vor fi înlocuite
literele de pe poziția specificată anterior.

Figura 1.4. Propoziția modificată

În final, la ecran se va afișa textul scris la început și modificat conform cerințelor scrise la
fiecare pas al programului. Putem observa că fiecare a 3-a literă a fost înlocuită cu „q”. De

5
asemenea putem menționa că dacă cuvântul este mai scurt decât poziția aleasă, nimic nu se
modifică.

2.Sarcina 2:
Elaborați un program Java care va crea un meniu recursiv. Acesta trebuie să cuprindă
următoarele funcții (cu apelare ulterioară ale acestora în funcția main()):
1. Citește șirul de caractere de la tastatură;
2. Afișează șirul de caractere;
3. Calculează și afișează lungimea șirului;
4. Calculul conform variantelor;
5. ....
6. Ieșire din program.
Varianta 1:
Se dă un tablou unidimensional de tip Char. Să se modifice toate caracterele primului
cuvânt în litere mari; să se identifice cel mai mare cuvânt din șir; să se numere câte cuvinte există
în șir; să se înlocuiască toate caracterele ‘a’ întâlnite în șir cu caracterul ‘*’; să se găsească și să se
afișeze ultima poziție a caracterului ‘a’; să se inverseze șirul de caractere; să se insereze după
fiecare cuvânt din șir numărul de litere a cuvântului respectiv; să se șteargă din șir cuvântul care
începe cu caracterul ‘e’.
Codul:

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
Text text = new Text();

while (true) {
System.out.println(
"\n1. Citește șirul de caractere de la tastatură;\
n" +
"2. Afișează șirul de caractere;\n" +
"3. Calculează și afișează lungimea
șirului;\n" +
"4. Modifică caracterele primului cuvânt în
litere mari;\n" +
"5. Identifică cel mai mare cuvânt din
șir;\n" +
"6. Calculează câte cuvinte sunt în șir;\n"
+
"7. Modifică caracterul 'a' cu '*';\n" +
6
 "8. Identifică ultima poziție a
caracterului 'a';\n" +
"9. Inversarea șirului;\n" +
"10. Inserează după fiecare cuvânt numărul
de litere;\n" +
"11. Șterge din șir cuvintele care încep cu
'e';\n" +
"12. Ieșire din program;\n");

System.out.print("Introduceti optiunea: ");

int choice = scanner.nextInt();
scanner.nextLine();

switch (choice) {
case 1:
System.out.print("Introduceți șirul: ");
String sentence = scanner.nextLine();
text.get(sentence);
break;
case 2:
System.out.println("Șirul introdus: " +
text.show());
scanner.nextLine();
break;
case 3:
System.out.println("Lungimea șirului este: " +
text.leng());
scanner.nextLine();
break;
case 4:
text.upper();
System.out.println("Șirul modificat: " +
text.show());
scanner.nextLine();
break;
case 5:
System.out.println("Cel mai lung cuvânt este: " +
text.longword());
scanner.nextLine();
break;
case 6:
System.out.println("Șirul conține " + text.wordnum()
+ " cuvinte");
scanner.nextLine();
break;
case 7:
text.moda();
System.out.println("Șirul modificat: " +
text.show());
scanner.nextLine();
break;
case 8:
System.out.println("Ultima poziție a caracterului
„a”: " + text.lasta());
scanner.nextLine();
break;
case 9:
System.out.println("Șirul inversat este: " +
text.invert());
scanner.nextLine();
break;
case 10:
7
 System.out.println("Șirul cu numărul de litere după
cuvinte: " + text.addLeng());
scanner.nextLine();
break;
case 11:
System.out.println("Șirul fără cuvinte ce încep cu
„e”: " + text.remove());
scanner.nextLine();
break;
case 12:
System.out.println("La revedere!");
return;
default:
System.out.println("Optiunea incorectă!");
break;
}

}
}
}

class Text
{
private String sent;

public Text()
{
this.sent = "";
}
public void get(String sent)
{
this.sent = sent;
}
public String show()
{
return sent;
}
public int leng()
{
return sent.length();
}
public void upper()
{
String[] words = sent.split("[\\s,.:;?!]+");
words[0] = words[0].toUpperCase();
sent = String.join(" ", words);
}
public String longword()
{
String[] words = sent.split("[\\s,.:;?!]+");
int lenght = 0;
int word = 0;
for (int i = 0; i < words.length; i++)
{
if (lenght < words[i].length())
{
lenght = words[i].length();
word = i;
}
}
return words[word];
8
 }
public int wordnum()
{
String[] words = sent.split("[\\s,.:;?!]+");
return words.length;
}
public void moda()
{
String[] words = sent.split("[\\s,.:;?!]+");

for (int i = 0; i < words.length; i++) {

words[i] = words[i].replace("a","*");
}
sent = String.join(" ", words);
}
public int lasta()
{
return sent.lastIndexOf("a");
}
public String invert()
{
StringBuilder sb = new StringBuilder((sent));
sb.reverse();
return sb.toString();
}
public String addLeng()
{
String[] words = sent.split("[\\s,.:;?!]+");

for (int i = 0; i < words.length; i++)

{
words[i] = words[i] + "(" + words[i].length() + ")";
}
String newSent = String.join(" ", words);
return newSent;
}
public String remove()
{
String[] words = sent.split("[\\s,.:;?!]+");
List<String> lastwords = new ArrayList<String>();

for (int i = 0; i < words.length; i++)

{
if (!words[i].toLowerCase().startsWith("e"))
{
lastwords.add(words[i]);
}
}
String newSent = String.join(" ", lastwords);
return newSent;
}
}

9
 Output:

Figura 2.1. Meniul

La rularea acestui cod, în consolă va apărea acest meniu cu opțiuni conform variantei. E
necesar de introdus numărul opțiunii dorite. Dacă este introdusă opțiune inexistentă, se va afișa un
mesaj meniul va apărea din nou.

Figura 2.2. Opțiunea 1

La alegerea primei opțiuni se va cere introducerea de la tastatură a unui șir, pentru al
procesa la următoarele opțiuni.

Figura 2.3. Opțiunea 2

Opțiunea 2 afișează în consolă șirul introdus anterior.

Figura 2.4. Opțiunea 3

Opțiunea 3 afișează lungimea șirului introdus, în cazul de față lungimea șirului „Șir pentru
testare” este 18.

Figura 2.5. Opțiunea 4

10
 Opțiunea 4 modifică toate caracterele primului cuvânt în litere majuscule.

Figura 2.6. Opțiunea 5

Opțiunea 5 identifică și returnează cel mai lung cuvânt, în șirul introdus cel mai lung este
„testare”.

Figura 2.7. Opțiunea 6

Opțiunea 6 identifică și returnează numărul de cuvinte în șirul introdus, în acest caz sunt 3
cuvinte.

Figura 2.8. Opțiunea 7

Opțiunea 7 înlocuiește toate caracterele „a” cu „*” și returnează șirul modificat. Puteți
observa că sunt salvate modificările efectuate de celelalte opțiuni a meniului.

Figura 2.9. Opțiunea 8

Opțiunea 8 returnează ultima poziție a caracterului „a” din șirul introdus. Dacă în șir nu
există acest caracter, va fi returnată valoarea –1.

Figura 2.10. Opțiunea 9

Opțiunea 9 inversează șirul introdus și-l returnează. Această funcție nu modifică șirul
inițial.

Figura 2.11. Opțiunea 10

Opțiunea 10 returnează un șir nou ce conține numărul de litere după fiecare cuvânt.

11
 Figura 2.12. Opțiunea 11
Opțiunea 11 returnează șirul, eliminând toate cuvintele care încep cu litera „e”. În șirul
inițial nu existau asemenea cuvinte, de aceea a fost introdus un alt șir „Este important să depui mult
efort”. Puteți observa că au rămas doar cuvintele „important să depui mult”.

12
Concluzii
Efectuând această lucrare de laborator am făcut cunoștință cu softul Cisco Packet Tracer
este un software de simulare a rețelei dezvoltat de Cisco Systems. Oferă un mediu vizual pentru a
simula configurația și comportamentul routerelor și comutatoarelor Cisco. Packet Tracer este
folosit în mod obișnuit pentru a exersa abilitățile de configurare a rețelei și de depanare și pentru a
preda și învăța concepte cheie în rețelele de computere.
În Cisco Packet Tracer, un hub este un dispozitiv de rețea care funcționează la nivelul fizic
al modelului OSI(Open Systems Interconnection-acronim pentru interconectarea sistemelor
deschise) și oferă un punct de conectare comun pentru mai multe dispozitive de rețea. Acesta
transmite datele primite de la un dispozitiv către toate celelalte dispozitive conectate. Un
comutator, pe de altă parte, operează la nivelul de legătură de date al modelului OSI și oferă o
conexiune dedicată pentru fiecare dispozitiv din rețea. Utilizează adrese MAC pentru a redirecționa
datele către dispozitivul de destinație corect, ceea ce este mai eficient decât abordarea de difuzare
utilizată de hub-uri.
În concluzie pot spune că principala diferență dintre un hub și un comutator în Cisco
Packet Tracer este că un hub transmite date către toate dispozitivele conectate, în timp ce un
comutator utilizează adrese MAC pentru a redirecționa datele către dispozitivul de destinație
corect.

13