Clases y objetos



Descargar 61,09 Kb.
Fecha de conversión20.07.2017
Tamaño61,09 Kb.
        1. Clases y objetos

Una de las características centrales de la programación orientada a objetos (OOP) es la partición del programa completo en pequeñas entidades autónomas, llamadas objetos, con interacciones bien definidas, lo que reduce la complejidad global y ayuda a la calidad del programa de diferentes maneras.


Un objeto organiza datos y operaciones relacionadas en una “caja negra”, que oculta las estructuras de datos, las representaciones y el código interno de la vista exterior. Una estructura de datos es concreta cuando se conocen sus elementos exactos. Una estructura es abstracta, si sólo se conoce su comportamiento y no sus detalles de implantación. Por tanto la abstracción de datos pone el énfasis en el ocultamiento de los detalles internos de los datos y sólo presenta su comportamiento externo. Un objeto también contiene mecanismos, o códigos, que son necesarios para operar las estructuras de datos que están adjuntos a los códigos para formar una unidad inseparable. A esta técnica se le llama encapsulación.
El elemento básico de la programación orientada a objetos es una clase, la cual define la forma y comportamiento de un objeto. La construcción de clases de Java soporta abstracción y encapsulación de datos. Una clase describe la construcción de un objeto y sirve como base para construirlo, especifica su funcionamiento interno, y su interfaz pública. Una clase tiene un nombre y especifica a los miembros que pertenecen a ella; estos pueden ser campos o atributos (datos) y métodos (funciones). Una vez que se define una clase, su nombre se vuelve un nuevo tipo de datos y se usa para:

Un objeto es similar a una variable salvo que el objeto puede contener varias variables (variables de instancia) y métodos (rutinas que realizan operaciones).


ESTRUCTURA GENERAL DE UNA CLASE

[protección de acceso][modificador] class nombre_de_la_clase [extends nombre_superclase]

[implements nombre_interface [,nombre_interface] ]

{ [modificador] [variables finales;]

[modificador] [variables de clase;]

[modificador] [variables de referencia;]

metodo ()

{sentencias;}

.

.

metodo ()



{sentencia}

}
Dentro de una clase se pueden definir otras clases pero solo una podrá ser public y además ésta será la que coincida con el nombre del archivo fuente de java.


Para la creación de un objeto se necesita el operador new, y que se declaren las variables de instancia dentro de una clase. Mediante una clase se pueden declarar varios objetos que tendrán los mismos atributos.
CREACIÓN DEL OBJETO

nomb_clase nomb_objeto=new nomb_clase([valores]);


Cuando se hace referencia a un método este debe estar declarado y desarrollado al igual que el objeto. Para declarar y desarrollar un método debe estar dentro de una clase y se debe indicar el valor que devuelve, el nombre y los valores que se le pasan. new crea una única instancia de una clase y devuelve una referencia a ese objeto.




CREACIÓN Y DESARROLLO DEL MÉTODO

[protección de acceso][modificador][tipo de valor devuelto] nombre_método([parámetros])

{ [modificador] [variables locales]

sentencias;

[return [valor devuelto];]

}
Un parámetro se declara poniendo tipo identificador, y si son varios van separados por una coma. Los datos primitivos se devuelven por valor, mientras que los objetos (tipos referenciados) por referencia.


Si tenemos que hacer referencia a las variables de instancia y los métodos contenidos en un objeto se necesita el operador punto(.).

Objeto.nomb_método( );

Objeto.nomb_método(parámetros);

Objeto.variable;

Variable_referencia= Objeto.nomb_método( );

Variable_referencia= Objeto.nomb_método( parámetros);

Variable_referencia= Objeto.variable;
EJEMPLO: Teniendo una clase con 2 variables y un método. Desde la otra clase se crea el objeto, se llama al método y se muestran los valores del objeto.
class punto

{ int x;

int y;


void inicio( )

{x=10;y=20;}

}
class principal

{ public static void main(String args[])

{ punto p=new punto( );

System.out.println (“objeto creado”);



p.inicio( );

System.out.println(p.x + “ “+p.y);

}

}
Este ejemplo se guarda bajo el nombre de principal.java.


EJEMPLO: En este programa se le pasan valores al método.
class punto

{ int x;


int y;

void inicio(int a, int b)

{x=a;y=b;}

}
class principal_2

{ public static void main(String args[])

{ int a=10;



punto p=new punto( );

System.out.println (“objeto creado”);



p.inicio(a,20);

System.out.println(p.x + “ “+p.y);

}

}
Este ejemplo grabarlo con el nombre principal_2.java


CONSTRUCTORES: Es un método que inicializa un objeto inmediatamente después de su creación. Tienen el mismo nombre de la clase en la que residen. No devuelven ningún tipo de dato ni siquiera void. Al ser automático no necesita ser llamado.
EJEMPLO:

class punto

{ int x , y;

punto(int a, int b)

{x=a;y=b;}

}
class principal_3

{public static void main(String args[])

{int a=10, b=20;

punto p=new punto(a,b);

System.out.println(“objeto creado”);

System.out.println(p.x+” “+p.y);

}

}


Este ejemplo grabarlo con el nombre de principal_3.java
El constructor inicializa todo el estado interno de un objeto para que el código que crea una instancia con el operador new tenga un objeto integro y utilizable inmediatamente.
Se llama al método constructor justo después de crear la instancia y antes de que new devuelva al punto de la llamada.
Un constructor nulo es aquel que no toma argumentos y no hace nada, y en ocasiones debe estar presente para permitir el uso. A veces se proporciona automáticamente para:

  • Si una clase no define un constructor, entonces se proporciona automáticamente un constructor nulo que no hace nada.

  • Si una clase define cualquier constructor, entonces no se proporciona automáticamente ninguno. Esto es adecuado si no se requiere el constructor nulo. Pero si éste es necesario, debe darse explícitamente uno apropiado.

Clases abstractas

Una clase abstracta es aquella que contiene al menos un método abstracto, y se define poniendo en su cabecera el modificador abstract. Este tipo de clases no se puede instanciar, es decir, no podemos crear objetos de ella, se usa como clase base para la herencia, y da bases también para el polimorfismo. Las subclases de una clase abstracta están obligadas a sobrescribir (implementar) todos los métodos abstractos que heredan, si no es así se considera también abstracta. Puede tener constructores.
Una clase concreta es aquella que tiene todos sus métodos implementados y ésta si puede ser instanciada.
Un método abstracto siempre va a ser un método dinámico.

Ejemplo:


public class Ejemplo_Abstractos extends Clase_Abstracta
{static void imprime(String msg)
{System.out.println(msg);}
//implementacion del metodos de la clase abstracta
public int suma(int a,int b)
{return a+b;}

public static void main(String arg[])


{Ejemplo_Abstractos obj=new Ejemplo_Abstractos();
imprime("la suma de 3 + 2 es="+obj.suma(3,2));
imprime("la resta de 3 - 2 es="+obj.resta(3,2));
}
}

abstract class abstracta


{abstract public int suma(int a,int b);
public int resta(int a,int b)
{return a-b;}
}

Herencia
HERENCIA: Relaciona clases una encima de otra de una manera jerárquica. Esto permite que una clase herede todas las variables y métodos de sus ascendientes, además de crear los suyos propios. Para heredar una clase hay que utilizar la palabra clave extends.

class nombre_clase extends nombre_superclase

{ Cuerpo;

}

EJEMPLO: Partiendo de los ejemplos anteriores vamos a crear una jerarquía de clases.

class punto{

int x , y;

punto(int a, int b)

{x=a;y=b;}



}
class punto2 extends punto

{ int z;


punto2(int a, int b, int c)

{ super(a,b);

z=c;

}

}


class principal_4

{ public static void main(String args[])

{ int a=10, b=20,c=30;

punto2 p=new punto2(a,b,c);

System.out.println(“objeto creado”);

System.out.println(p.x+” “+p.y+” “+p.z);

}

}


Este ejemplo grabarlo con el nombre de principal_4.java
La sentencia super lo que hace es llamar al constructor de la superclase (clase de la que heredamos). En la función principal es donde se crea el objeto que llama al miembro constructor, al cual hay que pasar 3 valores (uno para la clase punto2 y dos para la clase punto).
Cada clase de java deriva directamente o indirectamente de la clase Object (java.lang)
Asignación de objetos a variables de su superclase
Superclase variable=SubclaseVariable;

Superclase objeto=new Subclase();


POLIMORFISMO: Posibilidad de utilizar una misma expresión para invocar diferentes versiones de un mismo método, determinando en tiempo de ejecución la versión del método que se debe ejecutar.
Ventajas del uso del polimorfismo:

  • Reutilización del código – permitirá agrupar instrucciones de este tipo en un bloque de código para que pueda ser ejecutado con cualquier objeto de las subclases esto es debido a que se utiliza una variable de una clase pueda escribirse una única instrucción que sirva para invocar a diferentes versiones del mismo método.

  • Permite que diferentes objetos respondan de modo diferente al mismo mensaje

  • Hace mas flexible al sistema

Adquiere su máxima potencia cuando se utiliza en unión a la herencia.



SOBRECARGA: Se utiliza para crear más de un método con el mismo nombre, pero con distinto número de parámetros y operaciones distintas. La sobrecarga se puede utilizar para miembros constructores o para la herencia. EJEMPLO:

class punto

{ int x,y;

punto(int a, int b)

{x=a; y=b;}

punto()

{x=-1;y=-1;}

}
class principal_5

{ public static void main(String args[])

{ punto p=new punto();



punto p2=new punto(10,20);

System.out.println(p.x+” “+p.y);

System.out.println(p2.x+” “+p2.y);

}

}


Este ejemplo grabarlo con el nombre de principal_5.java
this – valor de referencia especial llamado this, que se utiliza dentro de cualquier método para referirse al objeto actual. El valor this se refiere al objeto sobre el que ha sido llamado el método actual. Se puede utilizar this siempre que se requiera una referencia a un objeto del tipo de la clase actual. También se puede utilizar para hacer referencia a variables de clases que lleven el mismo nombre que una variable local dentro del mismo método. EJEMPLO:

class Punto

{ int x, y;

Punto (int x, int y)

{ this.x=x;

this.y=y;

}

}
class CrearPunto



{ public static void main (String args[])

{Punto p=new Punto (15, 20);

System.out.println(“x= “+p.x + “y= “+p.y);

}

}



A continuación se presenta un ejemplo donde se mezclan los dos tipos de declaraciones y llamados de los métodos:

import java.io.*;

class arreglo

{public static void main(String args[])

{int a []=new int [10];

arreglo obj_ar=new arreglo();

a=obj_ar.leerArreglo();

obj_ar.imprimirArreglo(a);

}
public static String cad()

{BufferedReader entrada=new BufferedReader(new InputStreamReader(System.in));

try {return entrada.readLine();}

catch(IOException e)

{return " ";}

}
public static int ent()

{try {return Integer.parseInt(cad());}

catch(NumberFormatException e)

{return 0;}

}
int [] leerArreglo()

{int a[]=new int [10];

for (int i=0; i<10; i++)

{System.out.println("Proporciona el valor "+(i+1));

a[i]=ent();

}

return a;



}
void imprimirArreglo(int a[])

{for (int i=9;i>=0; i--)

{System.out.println("valor "+(i+1)+" "+a[i]);}

}

}



Maria Eugenia Puga Nathal Página 20/07/2017


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal