CLASES Y OBJETOS en JAVA

CLASES Y OBJETOS en JAVA

El elemento básico de la programación orientada a objetos es una clase. Una clase define la forma y comportamiento de un objeto. 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).

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.

CREACIÓN Y DESARROLLO DEL MÉTODO

valor devuelto nombre_método([valores])
{
cuerpo;
}

 

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(valores);
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);
}
}

 

 

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{
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);
}
}

 

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{
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);
}
}

 

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{
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);
}
}

 

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).

 

SOBRECARGA: Se utiliza para crear más de un método con el mismo nombre, pero con distinto numero 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{
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);
}
}

 

 

 

STATIC: El uso de este modificador nos permite utilizar el método y las variables sin necesidad de crear objetos. Los métodos estáticos solo pueden llamar a métodos estáticos. Hay que ser consciente que es equivalente  a declararlas como globales.

            EJEMPLO:

                 class estatica{
           static int a=3;
static int b;
           static void metodo(int x)
{
System.out.println(“x= “ +x);
System.out.println(“a= “ +a);
System.out.println(“b= “ +b);
}

public static void main(String args[])
{
metodo(42);
}
}

Si la llamada al método static esta en otra clase distinta, se tiene que poner el nombre de la clase  en donde esta declarado el método static y el operador punto (.).

nomb_clase.nomb_metodo([parámetros]);

           
ABSTRACT: Se utiliza cuando en  una clase se defina un método sin proporcionar una implementación completa de este método. Con ello conseguimos que en distintas clases tengamos métodos con el mismo nombre y desarrollar el método en una de las clases.

EJEMPLO:

   abstract class abstracta{
  abstract funcion();
}

class subclase extends abstracta{
int x;
void funcion2(){System.out.println(“Función Dos”);}
void funcion() {System.out.println(“Func.Abstracta”);}
}

class inicial{
public static void main(String args[]){
subclase var=new subclase();
// abstracta var=new subclase();igual que la anterior.
var.funcion();
}
}

 

 

 

PROTECCIÓN DE ACCESO: Estos modificadores nos indican en que partes de un programa podemos utilizar los métodos y variables. Tenemos tres:

            private: Solo tendrán acceso los de la misma clase donde estén definidos.
public: Se pude hacer referencia desde cualquier parte del programa.
protected: Se puede hacer referencia desde la misma clase y las subclases.

 

SENTENCIA FINAL: Se utiliza para definir valores y que estos no puedan ser modificados desde ningún lugar de nuestro programa. Esto implica que las referencias futuras a este elemento se basarán en la definición.

                        final  tipo identificador = valor;

 

EJEMPLO:
final int NUEVO_ARCHIVO=1;
final int ABRIR_ARCHIVO=2;
final int GUARDAR_ARCHIVO=3;
final int CERRAR_ARCHIVO=4;