Propòsit

Aquesta unitat té el proposit d’explicar el paradigma de la programació orientada a objectes. Una vegada exposada aquesta “nova” filosofia de programació farem una sèrie de problemes pràctics amb el llenguatge java.

Durant aquest curs ja hem desenvolupat una aplicació de principi a fi. El nostre sistema ha seguit el paradigma de la programació estructurada i modular. Aquest fet ens ha permés programar de manera ràpida i hem pogut aprendre la programació d’alguns algoritmes bàsics.

Els principals paradigmes que aporta la POO són:

features of oop

  • Les classes i objectes.
  • L’abstracció de dades.
  • Encapsulació.
  • L’ocultació de informació.
  • L’herència de Classe.
  • El Polimorfisme.

Primer de tot veurem d’on surt la idea de la POO fent un recorregut històric de la programació de màquines.

Deguidament farem exercicis pràctics que ens permetran entendre com funciona la POO al llenguatge JAVA.


Història

La programació és una activitat humana que es va començar a desenvoluplar durant la segona meitat del segle XX. Podem suposar que encara ens trobam a l’origen de la seva història i que el futur ens aportarà avanços tècnics i teòrics que milloraran resultats.

Durant la seva curta història ha tengut dues petites revolucions. La primera, protagonitzada per Wirth, Dijstra i altres com Kernigham i Ritchie. És l’anomenada programació estructurada.

Els primers programes són símplement instruccions que podein donar a una computadora certes operacions. Un programa és el camí per realitzar un càlcul.

A mesura que les computadores es van fer més sofisticadesels seus llenguatges propis varen anar canviant i va sorgir la necessitat de crear uns llenguatges intermitjos on qualsevol usuari fos capaç d’entendre i que no depenia d’una màquina concreta on s’havien d’executar els programes. Així varen sorgir els primers llenguatges que es varen fer famosos i també varen apareixer els primers compiladors.

Un compilador és el programa encarregat de traduïr d’un llenguatge de programació a un llenguatge màquina. Ho fa en varies fases, ho podeu consultar a “fases de un compilador“.

L’aparició d’aquests llenguatges intermitjos i els seus compiladors marcà l’inici de la programació com a ciència.

Davers els anys 60 es feien programes que arribaven a tenir cents de mils de línies de codi.

Fer correccions a n’aquests tipus de programes i afegir millores es va convertir en una tasca quasi impossible. Davant aquest problema varen sorgir una sèrie de científics de la computació que varen propossar idees que es convertiren en un nou concepte, la programació estructurada.

Formalment la programació estructurada proposa dues idees bàsiques: no repetir codi i protegir les variables per tal que poguessin ser emprades de manera correcta.

  • Els procediments i les funcions són els sistemes emprats per no repetr codi. Els dissenyadors d’un programa decidiran quines seran les funcions i els procediments que s’han d’implementar per tal de no repetir codi.
  • Per protegir les variables es van desenvolupar llenguatges que permeten definir variables locals. Són variables que sols poden ser emprades dins una funció o procediment. D’aquesta forma cap altre funció del programa podrà canviar el seu valor.

Amb aquestes millores es va aconseguir la disminució de línies de codi per programa, són més codificables i també són més fàcils de corregir i millorar.

Els llenguatges C o Pascal son els llenguatges estructurals més coneguts.

Simulació d’ocupació de memòria d’un mateix programa en versió estructurada i en versió modular. Fixa’t que la memòria ocupada s’ha reduït, el codi principal de l’aplicació modular cridarà les funcions i procediments com necessiti. Les variables estan més protegides.

El llenguatge C per la seva banda va esdevenir molt potent. Compta amb un sistema de punters a memòria que pot sortir de les seves propies posicions de memòria de programa. És capaç d’implementar sistemes operatius.

El creador de Pascal va millorar la programació estrucutrada i va crear el llenguatge MODULA2 un llenguatge modular. Els mòduls del llenguatge permeten objectes o classes. Per millorar la programació i el control del programa es van crear mòduls que representaven es estats dels objectes i es defineixen els mètodes que describien el comportament. Els procediments i les variables podien se d’àmbit públic o privat. Amb aquesta tècnica es millorava Pascal i es donava una passa important cap a la Programació de classes o programació orientada a objectes.

Altres llenguatges com Smalltalk varen fer aplicar la POO sobre la seva estructura. Varen sorgir idees com les subclasses que heretaven propietats d’una superclasse. També va sorgir una idea que va ajudar a evitar els problemes de la memòria dinàmica: els constructors i els destructors d’objectes. “Aquesta idea és semblant als punters de C peró no requerix de tanta abstracció mental per part del programador, o sigui el programa pot crèixer en moement que s’està executant.”

A principis dels anys 90 també es va popularitzar un llenguatge semblant a C, fou el C++ creat per Stronstroup. La idea era combinar la sintaxi i possibilitats del llenguatge C. Aquest fet va ajudar a popularitzar la programació orientada a objectes i va preparar el camí a l’aparició del Java.

El llenguatge Java va aplicar tots els coneixements previs per poder crear un llenguatge orientat a objectesq que fos fàcil d’utilitzar. Es sembla un poc al C original i es pareix molt al C++.

Algunes característiques pròpies dels llenguatges orientats a objectes són:

  1. Coneixement i ús de les tècniques de la programació modular i estructurada.
  2. Ús de llibreries de classes.
  3. Memòria dinàmica.
  4. Classes i objectes: Podriem entendre una classe com un petit programa que defineix el comportament d’algun concepte programable. Una classe és la definició d’un objecte, un objecte és la seva instanciació.
  5. Herència i extensió de classes: Una classe pot ser l’extensió de una altra classe. Sense haver de repetir més codi es poden crear classes que hereten el comportament, podent afegir o canviar comportaments i variables.
Aproximació al comportament d’un Poo dins memòria. El programa principal main conté l’estructura lògica de control. També és l’encarregat de crear i manipular els objectes. Es clar que el programa pot oferir una intefície per oferir el control a l’usuari.

Classes i objectes.

Tot programa serà una classe, i cada programa pot tenir moltes més classes. Un  exemple de programa senzill és el típic Helloworld amb el codi:


1
2
3
4
5
6
7
8
9
<span style="color: #808080;"><tt>
<span class="keyword">public</span> <span class="keyword">class</span> <span class="classname">HelloWorld</span> <span class="cbracket">{</span>
    <span class="keyword">public</span> <span class="keyword">static</span> <span class="type">void</span> <span class="function">main</span><span class="symbol">(</span><span class="normal">String</span><span class="symbol">[]</span><span class="normal"> args</span><span class="symbol">)</span> <span class="cbracket">{</span>
        <span class="comment">// Prints "Hello, World" to the terminal window.</span>
<span class="normal">        System</span><span class="symbol">.</span><span class="normal">out</span><span class="symbol">.</span><span class="function">println</span><span class="symbol">(</span><span class="string">"Hello, World"</span><span class="symbol">);</span>
    <span class="cbracket">}</span>
<span class="cbracket">}

</span></tt></span>

Al codi hi podem veure que està dins d’una classe Helloworld. Dins la classse té un únic mètode “main” que és el mètode que s’executa quan el programa arranca. La classe Helloworld tampoc empra variables.

La paraula classe prové del concepte “classe d’objecte”. Una classe consta de:

  • Estats: Un conjunt de variables preparats per mantenir els valors de la classe.
  • Mètodes: Un conjunt de funcions i procediments que implementen el funcionament de la classe.
    • Constructors: Són essencials alhora de implementar una classe. Sino els posam la classe posa per defecte un mètode constructor sense paràmetres i els valors inicialitzats a zero, així i tot convé implementar-ne un o més.
    • Getters: Són els mètodes que ens retornen els valors dels estats d’un objecte.
    • Setters: Mètodes encarregats de canviar valors de l’estat de un objecte.
    • Mètodes d’accions: Calculen nous valors.

Exemple Punt:

Un altre exemple de Classe és aquella que defineix un punt damunt un pla cartesià. (X,Y).

1. Implementació de la Classe Punt.

La implementació de la classe ha ‘estar dins un arxiu amb el nom exacte de la classe. En aquest cas ha de tenir el nom “Punt.java”. 

1
 

1
<strong><span style="color: #ff0000;">//DECLARACIÓ DE LA CLASSE</span></strong>
1
 
1
<strong><span style="color: #ff0000;">public class Punt{</span></strong>
1
 
1
<strong><span style="color: #0000ff;">//ESTATS DE LA CLASSE</span></strong>
1
<span style="color: #0000ff;"><strong>private int X;</strong> //VARIABLE DE POSICIÓ X</span>
1
<span style="color: #0000ff;"><strong>private int Y;</strong> //VARIABLE DE POSICIÓ Y</span>
1
<span style="color: #008080;"><strong>public static MIN=0;</strong></span>
1
<span style="color: #008080;"><strong>public static MAX=400;</strong></span>
1
 
1
2
3
<strong><span style="color: #800080;">//MÈTODES CONTRUCTORS
</span></strong><span style="color: #800080;">//Constructor amb paràmetres x i y
</span><span style="color: #800080;">//que indiquen la posició del punt creat</span>
1
<strong><span style="color: #800080;">public Punt (int x,int y){</span></strong>
1
<strong><span style="color: #800080;">X=x;</span></strong>
1
<strong><span style="color: #800080;">Y=y;</span></strong>
1
<strong><span style="color: #800080;">        }</span></strong>
1
<span style="color: #800080;">//Constructor sense paràmetres. SOBRECÀRREGA</span>
1
<span style="color: #800080;">//Si contruïm un objecte punt sense paràmetres</span>
1
<span style="color: #800080;">//ens crearà un Punt a X=15,Y=15.</span>
1
<strong><span style="color: #800080;">public Punt(){</span></strong>
1
<strong><span style="color: #800080;">X=15;</span></strong>
1
<strong><span style="color: #800080;">Y=15;</span></strong>
1
<strong><span style="color: #800080;">}</span></strong>
1
<span style="color: #ff6600;"><strong>//MÈTODES SETTERS</strong></span>
1
<span style="color: #ff6600;">//Permeten canviar els valors dels estats de l'objecte.</span>
1
<span style="color: #ff6600;">//El canvi de valors mitjançant un setter ens permet controlar </span>
1
<span style="color: #ff6600;">//característiques de la Classe (tal com número màxim i mínim)</span>
1
<span style="color: #ff6600;">//a n'aquest exemple de SetY sols deixarà posar nombres entre 0 i 400;</span>
1
<strong><span style="color: #ff6600;">public void setX(int x){X=x;}</span></strong>
1
<span style="color: #ff6600;"><strong>public void setY(int y){</strong></span>
1
<strong><span style="color: #ff6600;">if ((y&gt;min) &amp;&amp; (y&lt;max)){</span></strong>
1
<strong><span style="color: #ff6600;">Y=y;</span></strong>
1
<strong><span style="color: #ff6600;">}else{</span></strong>
1
<strong><span style="color: #ff6600;">System.out.println("el valor ha d'estar entre " + min + " i " + max);</span></strong>
1
<strong><span style="color: #ff6600;">}</span></strong>
1
<span style="color: #808000;"><strong>//MÈTODES GETTERS</strong></span>
1
<span style="color: #808000;">//Són Mètodes que retornen els estats de les variables</span>
1
<span style="color: #808000;">//fixa't en la declaració de tipus de retorn i el return.</span>
1
<span style="color: #808000;"><strong>public int getX(){</strong></span>
1
<span style="color: #808000;"><strong>return X;</strong></span>
1
<span style="color: #808000;"><strong>}</strong></span>
1
<span style="color: #808000;"><strong>public int getY(){</strong></span>
1
<span style="color: #808000;"><strong>return Y;</strong></span>
1
<span style="color: #808000;"><strong>}</strong></span>

 

1
<span style="color: #008000;"><strong>//MÈTODES ACCIONS SOBRE LA CLASSE.</strong></span>
1
<span style="color: #008000;">//són mètodes que implementen requisits sobre la classe. </span>
1
 <span style="color: #008000;">//En el nostre cas implementarem moviments simples i</span>
1
<span style="color: #008000;">//un mètode que ens retorna els valors del punt (x i y) a la consola</span>
1
//Moviments que augmenten en 1 els valors de x o y.
1
<strong><span style="color: #008000;">public void mouDreta(){X++;}</span></strong>
1
<strong><span style="color: #008000;">public void mouEsquerra(){X--;}</span></strong>
1
<strong><span style="color: #008000;">public void mouAmunt(){Y++;}</span></strong>
1
<strong><span style="color: #008000;">public void mouAvall(){Y--;}</span></strong>
1
<strong><span style="color: #008000;">public String mostraXY(){</span></strong>
1
<strong><span style="color: #008000;">return "X: " + this.getX + ",  Y = " + this.getY;</span></strong>
1
<strong><span style="color: #008000;">}</span></strong>
1
<span style="color: #ff0000;">}</span>

 

Sobrecàrrega és la propietat que permet declarar mètodes amb el mateix nom però diferent signatura (paràmetres diferents). A la classe anterior podem veure que s’han declarat dos mètodes constructors diferents amb el mateix nom i diferent signatura.

2. Instàcia de la classe Punt. Creació d’un objecte a partir d’una classe.

Una classe defineix com serà un objecte, un objecte i una classe no és el mateix. Per obtenir un objecte hem de instanciar una classe, procediment que crea un espai nou a memòria principal  de la mida de la classe.

Creació dels objectes de tipus Punt a i b, invocant el constructor de classe Punt.

 

Algunes coses que es interessant saber:

  • El mètode main:
    • És el mètode principal. És el primer mètode que s’executa quan s’engega el programa.
    • Pot estar dins la classe que s’executa o pot estar dins una classe especial que conté el mètode.

Per fer una prova de l’exercici cream un mètode principal main que farà proves de funcionament. El codi pot ser el següent:

public static void main(String[] args) {

// TODO code application logic here
System.out.println(“El programa s’està executant.”);
Punt a= new Punt(1,1);
System.out.println(“Ja tenim el punt creat “);
System.out.println(a.mostraXY());
System.out.println(“Movem el punt a la dreta “);
a.mouDreta();
System.out.println(a.mostraXY());
}

La seva sortida serà:

El programa s’està executant.
Ja tenim el punt creat
X: 1, Y= 1
Movem el punt a la dreta
X: 2, Y= 1


Exercicis.

  1. Implementació de la classe Punt.
    1. Amb el Netbeans crea un nou projecte amb el nom ExecicisJava.
    2. Crea la classe punt creant un nou arxiu “Punt.java”.
    3. Implementa la classe amb els estats, els mètodes (contructors, getters, setters i acció)
    4. Al main de ExercicisJava, implementa:
      1. Creació de dos objectes puntA i puntB. Com explica al dibuix anterior.
      2. El puntA ha d’estar situat a 10,10
      3. El puntA ha d’estar situat a 100,100
      4. Mostra la informació puntA i puntB.
      5. Mou puntA a la dreta i mostra la informació.
      6. Mou puntB la dreta deu vegades.
      7. Mostra la informació puntA i puntB.
    5. Crea el mètode distància amb les següents condicions:
      1. El mètode s’implementa dins la classe punt i tendrà la signatura de public double distancia(int p).displaymath360
      2. Calcularà la distància entre el punt que la invoca i el punt p.
      3. Implementa i fes una mostra de resultats mostrant informació per la consola. Dibuixa i reflexiona sobre els resultats.

Herència i Extensió de Classes.

L’herència és la funció més important de la programació orientada a objectes. Com s’ha comentat abans l’objectiu principal d’aquest paradigma és la de poder modificar i ampliar codi.

Una classe pot ser una subclasse d’una altra:

  • Hereta les variables i els mètodes de la classe mare.
  • Pot ampliar afagir estats.
  • Pot modificar mètodes de la classe mare. @override
  • Polimorfisme: Els Objectes classe i subclasse poden ser identificats mitjançant la classe mare.


O sigui que podriem emprar la classe Punt per fer una subclasse Cercle, quadrat o rectangle a partir de la classe Punt. Com es fa això?

 

  1. Cream un nou arxiu de classe i l’anomenam “Cercle.java”.
  2. A la declaració de classe hi hem d’afegir la sentència extends i darrera la Classe que extendem (heretam)
    • public class Cercle extends Punt { … }
  3. Posam la variable Radi com a nou estat de la classe. Com a una Classe normal.
  4. Implementam els constructors. Per referirmos a la contrucció d’estats de la Classe mare ho farem amb el mètode especial super().
    • public Cercle(int x, int y,int r) {
      • super(x,y);
      • R=r;}
  5. Per crear un objecte ho hem de fer de la forma: “Punt n = new Punt();”.

http://www.juntadeandalucia.es/servicios/madeja/contenido/libro-pautas/18#Clases_finales

http://studytipsandtricks.blogspot.com.es/2012/04/features-of-object-oriented-programming.html

What is Object Oriented Programming (OOP)

admin2on batxilleratPropòsit Aquesta unitat té el proposit d'explicar el paradigma de la programació orientada a objectes. Una vegada exposada aquesta 'nova' filosofia de programació farem una sèrie de problemes pràctics amb el llenguatge java. Durant aquest curs ja hem desenvolupat una aplicació de principi a fi. El nostre sistema ha seguit el...Blog Aula Informàtica Gimnèsia