Curs 8 POO Calc. 2, 23.11.

2021

Metoda split()
public String[] split(String separator)
Este folosita pt a extrage "atomii" - componentele unui sir, delimitate
prin separatorul dat ca parametru

public class Main {

public static void main(String[] args) {

String s="Ana are mere";
//extrag cuvintele:
String cuvinte[]=s.split(":");
for(int i=0;i<cuvinte.length;i++)
System.out.println(cuvinte[i]);
}

Metoda split() alternativa mai simpla la clasa StringTokenizer

Pt a separa corect cuvintele ce sunt separate cu mai multe spatii in propozitie,

folosim ca separator
o expresie regulata (regexp).
Expresia regulata ce defineste separatorul UNUL SAU MAI MULTE SPATII este:
\\s+
\s - spatiu
+ un cuantificator: unul sau mai multe

String s="Ana are mere";

//extrag cuvintele:
String cuvinte[]=s.split("\\s+");
System.out.println("Nr cuvinte="+cuvinte.length);
for(int i=0;i<cuvinte.length;i++)
System.out.println(cuvinte[i]);

Ex. Citim ca string un timp in formatul hh:mm:ss. Ex: "15:20:44".

Sa convertim si sa afisam timpul exprimat in secunde.

Scanner sc=new Scanner(System.in);

System.out.print("timp=");
String st=sc.nextLine();
String timp[]=st.split(":");
int h =Integer.parseInt(timp[0]);
int min =Integer.parseInt(timp[1]);
int sec =Integer.parseInt(timp[2]);
int secTotal=3600*h+60*min+sec;

Criptarea unui sir cu algo. Caesar

---------------------------------
Cripteaza doar literele
Substituie litere cu litera aflata in alfabet la distanta 3 de ea. Ex:
A--->D
B--->E
...
X--->A
Y--->B
Z--->C
ex:
A+B=XY

Criptat:
D+E=AB
Citim un sir s1. Il convertim la litere mari si construim sirul s2
obtinut prin criptarea Caesar
Conversia la litere mari a unui sir se face cu metoda toUpperCase() din clasa
String
public String toUpperCase()

Putem verica daca un carcatere este litera cu metoda statica isLetter() din
clasa Character:
public static boolean isLetter(char ch)
import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);
System.out.print("sir=");
String s1=sc.nextLine();
s1=s1.toUpperCase();
String s2="";//va fi sirul criptat
//Parcurgem pe s1 caracter cu caracter:
int i;
for(i=0;i<s1.length();i++) {
char ch=s1.charAt(i);
if(Character.isLetter(ch)) {
if(ch=='X')s2=s2+'A';
else if(ch=='Y')s2=s2+'B';
else if(ch=='Z')s2=s2+'C';
else {
char chCriptat=(char)((int)ch+3);
s2=s2+chCriptat;
}
}else s2=s2+ch;
}

System.out.println(s2);
}

CRIPTAREA PRIN TRANSPOZITIE CU MATRICE

Se copiaza sirul intr-o matrice patratica.
Sirul criptat se obtine parcurgand matricea pe coloane.
Ex:
ABCD
lungime=4 deci dimensiune=2
A B
C D
Parcurgem pe coloane:
ACBD

Ex: ABCDEFG
lungime=7, deci dimensiune=3
A B C
D E F
G - -
Sirul criptat va fi:
ADGBE-CF-

import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner sc=new Scanner(System.in);
String s1=sc.nextLine();
int L=s1.length();
int radical=(int)Math.sqrt(L);
int N;//dimensiune matrice
if(radical*radical==L)N=radical;
else N=radical+1;
char m[][]=new char[N][N];
//O umplem cu spatii:
int i,j;
//Copiem pe s1 in matrice:
int k=0;//index in sirul s1
for(i=0;i<N;i++)
for(j=0;j<N;j++)
//s-a terminat sir?
if(k>=L)m[i][j]=' ';
else {
m[i][j]=s1.charAt(k);
k++;
}
String s2="";//sirul criptat
//Parcurg matricea pe coloane:
for(i=0;i<N;i++)//parcurg cu indexul i coloanele
for(j=0;j<N;j++)
s2=s2+m[j][i];
System.out.println(s2);
}

MOSTENIRE. CLASE DERIVATE

Mostenirea este o trasatura specifica POO (ca si incapsularea, polimorfism, etc)
Prin mostenire modificam o clasa existenta (denumita clasa de baza sau clasa
parinte)
pentru a obtine o clasa noua (denumita clasa derivata sau clasa fiu).
Deci in loc sa construim de la 0 o noua clasa, cautam o clasa pe care sa o
modificam ( sau sa o
extindem, sa o mostenim).
Mostenirea conduce la cresterea productivitatii in programare (vom programa doar
diferentele fata de
clasa existenta )
Pentru a putea obtine prin mostenire o noua clasa , trebuie ca intre clasa fiu si
clasa parinte sa fie
o relatie de tipul: "este_un" sau "este_o" (engl: "is_a")
Exemplu:
Avem clasele Vehicul, Cerc, Fruct, Casa
Vrem sa obtinem o noua clasa: Mar
Care ar putea fi clasa de baza ?
mar este_un vehicul ? NU
mar este_un fruct ? DA
Cuvantul cheie folosit pt mostenire in Java este: extends
class Mar extends Fruct{
//aici se programeaza doar diferentele fata de clasa de baza Fruct
}

Ce se mosteneste din clasa de baza in clasa derivata ?

-membrii clasei de baza care sunt public sau protected
NU se mostenesc membrii private !
NU se mostenesc constructorii !

In clasa derivata putem sa adaugam si modificari fata de clasa de baza, si anume:

- putem crea in clasa derivata noi variabile de instanta
- putem crea in clasa derivata noi metode
- putem redefini metode ale clasei de baza (le pastram semnatura)
@Override

Cuvantul cheie protected:

- putem accesa un membru protected al clasei de baza, din orice clasa ce face
parte din
acelasi package cu clasa de baza SI din orice clasa derivata din clasa de baza
( chiar daca
nu este in acelasi package cu clasa de baza )

Putem impiedica mostenirea cu cuvantul cheie final, astfel:

final class NuSePoateMosteni {
...
}

In Java nu exista mostenire multipla, asa cum exista in C++.

In Java o clasa derivata poate avea un singur parinte.
De asemenea, o clasa derivata poate fi clasa de baza (parinte) pentru o
clasa ce o derivez din ea.

Ex. de mostenire:
In programarea grafica in Java, calsa pe care o scriem in care dessenam interfata
grafica
mosteneste compartamentul de fereastra din clasa de biblioteca JFrame:
class Fereastra extends JFrame{
//doar diferentele se programeaza
}

Clasa Object: este stramosul tuturor claselor din Java.

In clasa Object sunt definite mai multe metode care in general sdunt redefinite
(@Override) in alte clase. Ex:
public boolean equals(Object obj){
if(this==obj)return true;
else return false;
}

De ex. calsa String redefineste metoda equals() a.i. compara continutul a doua
stringuri

Alta metoda din Object:

public String toString()
returneaza o reprezentare ca String a unui obiect
Ex: clasa de baza Patrat
clasa derivata PatratColor
class Patrat{
private int a;
public Patrat(int a){
this.a=a;
}
public void set(int a){
this.a=a;}
public int get(){
return a;
}
public int arie(){
return a*a;
}
public void afisare(){
System.out.println("latura="+a);
}
}

class PatratColor extends Patrat{

//programam doar diferentele:
private String culoare;
//noul constructor (constructorul calse de baza nu se mosteneste !):
public PatratColor(int a, String culoare){
// GRESIT: this.a=a; a este private in clasa de baza, nu am acces la ea din
clasa derivata
//set(a); DA, este corect
//Apelez constructorul clasei de baza, astfel:
super(a);
this.culoare=culoare;
}
//mostenim set(), get(), arie()
//Adaugam:
public void setCuloare(String c){culoare=c;}
public String getCuloare(){return culoare;}
//Redefinim afisare():
@Override
public void afisare(){
System.out.println("latura="+get());
//sau, puteam apela metoda afisare() a clasei de baza astfel: super.afisare();
System.out.println("culoare="+culoare);
}
}

Ex de folosire:
class Test{
public static vopid main(String args[]){
PatratColor p=new PatratColor(4, "alb");
int rez=p.arie(); System.out.println(rez);
p.afisare();
}
}