Programare orientată pe obiecte: Java - pachete, clase, metode și proprietăți

Teoretic, voi urma aceleași puncte de interes ca în cazul lecției despre ActionScript.
Voi folosi ca IDE, Eclipse-ul, pentru că e OpenSource iar pentru exemplele de mai jos este numai bun.
Deschideți deci Eclipse, selectați File-New Project-Java-Java Project, dați un nume, gen "TutorialObiecteJava", salvați-l pe desktop și dați "Finish".

Dați click dreapta pe folderul "src" - și deocamdată creați o nouă clasă, asigurându-vă că bifați opțiunea "public static void main(String [] args)".

Acum o să aveți următorul cod în pagină:
public class Main {
/**
* @param args
*/
 public static void main(String[] args) {
 // TODO Auto-generated method stub
 }
}
rețineți că java va compila numai ce se află în funcția "main(String[] args )". Pentru cei obișnuiți cu Actionscript va fi foarte dureros să constate că în Java nu există cuvântul "function". Fiecare metodă se declară direct cu "public void" sau "private int" sau "protected string".
Deocamdată clasa "Main" după cum vedeți nu are un constructor. Constructorii de clasă se declară simplu cu "public Constructor(){}", fără a mai pune void. Spre deosebire de Actionscript unde lucrurile functionează în ambele variante, în Java e foarte important să nu pui void după constructor. De ce? Pentru că în Java poți avea mai multe funcții cu același nume dar cu parametrii diferiți.
Adică poți face codul tău să arate cam așa:
public class Main {
public Main(){
System.out.println("constructorul lui Main");
}

public void Main(){
System.out.println("metoda Main");
}

public void Main(int valoare){
System.out.println("metoda Main cu int="+valoare);
}

public static void main(String[] args) {
Main main=new Main();
main.Main();
main.Main(2);
}
}
și să afișeze:
constructorul lui Main
metoda Main
metoda Main cu int2
Binețeles, dacă primește parametrii diferiți poți avea mai mulți constructori cu același nume la un singur obiect, de genul:
public class Main {
public Main(){
System.out.println("constructorul lui Main");
}
public Main(String parametru){
System.out.println("constructorul lui Main cu parametrul "+parametru);
}
public void Main(){
System.out.println("metoda Main");
}
public void Main(int valoare){
System.out.println("metoda Main cu int="+valoare);
}
public static void main(String[] args) {
Main main=new Main();
main=new Main("Hai noroc");
}
}
care va afișa:
constructorul lui Main
constructorul lui Main cu parametrul Hai noroc

(asta o puteți numi programare monoverbală - adică să folosești un cuvânt în tot codul)

1. Pachete
Dar haide mai bine să separăm lucrurile: dați click dreapta pe folderul "src" din proiect si creați un nou pachet: "lume.animale", iar în pachetul "lume.animale" adăugați clasa "Mamifer".
Observați că prima linie este
package lume.animale;
Pentru a importa în Main clasa Mamifer puteți folosi
import lume.animale.Mamifer;
fie cu wildcard, pentru tot pachetul:
import lume.animale.*;
Observați că spre deosebire de ActionScript, în Java pachetul nu trebuie marcat cu acolade.

2.Clase
Inițializarea unei clase se face după modelul:
Clasă variabilă=new Clasă();
adică
private Mamifer mamifer=new Mamifer();
iar clasa Mamifer, dupa modelul stabilit deja, poate avea următorul cod:

package lume.animale;
public class Mamifer {
static public String BIPED="biped";
private String numeMamifer;
private String sunet="nedefinit";
public int numarDePicioare=0;
protected int numarDeOchi=2;

public String getSunet() {
return sunet;
}

public String getNume() {
return numeMamifer;
}

public void setSunet(String sunet) {
this.sunet = sunet;
}

protected void faZgomot(){
System.out.println(numeMamifer +" face "+getSunet());
}

private void pregatire(){
System.out.println(numeMamifer +" se apleaca si face...");
}

public void faSunet(){
pregatire();
faZgomot();
}

public Mamifer(String nume){
if(nume==null){
numeMamifer="numeNedefinit";
}else{
numeMamifer=nume;
}
}

public Mamifer(){
numeMamifer="mamifer necunoscut";
}

public static void definitie(){
String definitie = "Clasă de vertebrate superioare care au corpul acoperit cu păr, nasc pui vii și îi hrănesc cu laptele lor";
System.out.println(definitie);
}
}

3.Proprietăți și metode private, parametrii impliciți
Observați că Mamifer are 2 constructori: astfel
new Mamifer() // va returna numele mamiferului "mamifer necunoscut"
new Mamifer("caine") // va returna numele mamiferului "caine", iar
new Mamifer(null) // va returna numele mamiferului "numeNedefinit"
dacă am fi renunțat la constructorul Mamifer() la instanțierea
new Mamifer() // codul ar fi aruncat o eroare de compilare, deoarece constructorul Mamifer(String nume) necesită cel puțin un parametru, caz în care programatorul este obligat să scrie între acolade un șir de caractere
Apropo: în Java, spre deosebire de ActionScript există o diferență fundamentală între ghilimele duble - "" și cele single: ''. Cele single se folosesc la variabile tip char, gen 'a', iar cele duble la String-uri, gen "aa". Cine știe puțin C e obișnuit cu diferențierea.

4. Proprietățile și metodele publice știm deja că pot fi apelate de oriunde, iar proprietățile pot fi schimbate cum vrem. Nici aici, și nici în ActionScript nu e posibil să suprascrii o metodă publică după instanțiere. (Rog specialiștii să nu râdă, și să aștepte lecția de Javascript)

5. După cum v-am spus, getteri și setteri sunt tot metode publice, și sunt tratate ca atare:
setSunet("ham") va face ca getSunet() să returneze "ham" iar getNume() va returna variabila privata definita de constructor. Din păcate, în Java nu avem cuvântul "get" ca să putem face metode pe care să le scriem ca pe variabile.

6. Metode și proprietății statice:
Simplu: pot fi apelate fără instanțiere: Mamifer.definitie(); sau System.out.println(Mamifer.BIPED);

7. Proprietățile și metodele protejate sunt accesibile numai claselor care extind clasa curentă. Deci haide să creăm clasa Pisică astfel:

La extindere, o clasa in Java ia automat proprietățile constructorului din clasa-mamă.
Pentru că Mamifer are un constructor fara parametrii, Pisica va moșteni acest constructor. Dacă comentăm codul
// public Mamifer(){
// numeMamifer="mamifer necunoscut";
// System.out.println("constructor fara string");
// }
din "Mamifer", o sa vedem că linia
new Pisica()
va arunca o eroare de genul
Implicit super constructor Mamifer() is undefined for default constructor. Must define an explicit constructor
Cred ca intelegeți ideea: orice clasa are nevoie de minim un constructor implicit, fie al ei, fie moștenit.
Să considerăm în continuare că Mamifer are un constructor implicit, deci Pisica nu mai are nevoie musai de un constructor. Dacă nu-i definim un constructor însă, Pisica nu va avea un nume prestabilit. La instanțiere numele ei nu va fi pisică, deoarece constructorii din Mamifer returneaza doar "numeNedefinit" și "mamifer necunoscut", iar proprietatea "numeMamifer" este privată. La "numarDeOchi" avem acces, deoarece este protejată, la fel și la "faZgomot()", dar nu și la "numeMamifer". Așa că suprascriem constructorul astfel:
public Pisica(){
super("pisica");
}

8. Polimorfism, ovveride și superiorizare:
Hai sa facem un experiment: scrieți în clasa Pisica codul ăsta:
public void faZgomot(){
System.out.println("miau");
}
Ce am făcut? Am creat functia publică faZgomot(). Cum așa? Păi în Mamifer nu există o funcție cu același nume și cu aceeași parametrii, doar că era protejată? Ba da... tocmai ce am suprascris-o, ba chiar am făcut-o și publică. Atenție însă, dacă îi schimb tipul, nu o mai pot superioriza. Codul
public void faZgomot(){
System.out.println("miau");
super.faZgomot();
}
va arunca un stack overflow; Corect este
protected void faZgomot(){
System.out.println("miau");
super.faZgomot();
}
Acum, clasa Pisica va arăta cam așa:
package lume.animale;
public class Pisica extends Mamifer {
public Pisica(){
super("pisica");
}
protected void faZgomot(){
System.out.println("MIAU");
}
}
și da, o putem instanția fără probleme astfel:
Mamifer pisica=new Pisica();

9. Să recapitulăm ce avem în Main:
import lume.animale.*; 

public class Main {
private Mamifer mamifer; 

public Main(){
System.out.println("generam clasa Main::");
}

public void arataAnimale(){
//metoda statica
Mamifer.definitie();
//instantiere
mamifer=new Mamifer("catel");
//setare publica
mamifer.setSunet("HAM");
//apelare publica
mamifer.faSunet();
//o noua instantiere
mamifer=new Pisica();
mamifer.faSunet();
}

public static void main(String[] args) {
/*
* instantierea si apelarea directă
* a unei clase nu este de obicei
* recomandată deoarece nu există un
* control direct asupra variabile generate.
* Ea este permisă de obicei în
* metoda main de compilare, doar dacă
* este singură.
* */
new Main().arataAnimale();
}
}