PROGRAMA CON SUBCLASES BANQUITOS

CALIFICADORES DE JAVA

METODOS Y LIBRERIAS DE JAVA

Herencia

 

Con la herencia, podemos crear tantas clases que queramos y heredar sub-clases de otras sub-clases.
toda esta estructura de clases y subclases, se denomina Jerarquía de clases, un término que leerán muy a menudo.

dentro de la jerarquía de clases, tenemos a la clase superior, clase padre o clase base, que será la primera clase creada, teóricamente la clase base debe ser abstracta .

la clase inferior, o clase hija, clase heredada, subclase, es la que le precede a la clase padre. Todas estas heredaran atributos sin importar la cantidad de ancestros que existan.

La herencia también tiene otra extraordinaria cualidad: es posible ocultar o redefinir los métodos heredados.
la redefinición de los métodos ya la vimos, se trata de crear un método nuevo con el mismo nombre y mismos argumentos usando la sobrecarga.

claro esta es una redefinición total, porque sería escribiendo todo desde cero, pero podemos redefinir un método basándonos en el método heredado, es decir, no vamos a escribir desde cero, solo añadimos lo nuevo a lo que ya tenemos heredado.

tomemos la clase OperacionesMatematicas.java como clase base

public class OperacionesMatematicas { private int RESULTADO;   public Integer sumar(int OPERANDO1,int OPERANDO2){ RESULTADO=OPERANDO1+OPERANDO2; return RESULTADO; } }

ahora crearé OperacionesMatematicas1.java que será la clase hija

public class OperacionesMatematicas1 extends OperacionesMatematicas{ private int RESULTADO;   public Integer sumar(int OPERANDO1, int OPERANDO2, int OPERANDO3){ RESULTADO =super.sumar(OPERANDO1,OPERANDO2) + OPERANDO3; return RESULTADO; } }

ahora le daremos uso creando el objeto Sumar a partir de la clase hija:

public static void main(String[] args) { OperacionesMatematicas1 Sumar=new OperacionesMatematicas1();   System.out.println(Sumar.sumar(30, 4,6)); }

observen que aparecen los 2 métodos y hay una sentencia nueva llamada super
super es una variable especial que sirve para hacer referencia a la clase padre heredada, podemos tener métodos con el mismo nombre, mas sin embargo, podemos acceder a métodos ancestros mediante super. 

la redefinición la estamos haciendo en la clase OperacionesMatematicas1.java, observen que simplemente llamo a sumar de 2 argumentos (heredado) y añado la otra operación, que es sumar un tercer argumento.
 no hay desperdicio de código
en programas con cantidades industriales de lineas de código es de mucho agradecer la redefinición de métodos a través de la herencia.

 

THIS

La palabra clave this se refiere al objeto de contexto (comúnmente conocido como el objeto actual [current object]). En general, en un método, this se refiere a la invocación del objeto.

Utilice el término this para referirse al objeto actual. En general, this se refiere al objeto que se llama en un método. Utilice this como se indica a continuación:

this[.Nombrepropiedad]

PROGRAMA CON RAIZ CUADRATICA, POTENCIA, Y AREAS DE FIGURAS ARITMETICAS

En las tres primeras imagenes observamos  un programa que maneja una ecuacion cuadratica,  utiliza varios objetos y estos contenidos en diversas subclases

En esta imagen encontramos una de las subclases la cual nos nombra la declaracion de la potencia y la raiz, las cuales van a ser objetos a manejarsen en el programa y las nombramos por medio del metodo Math.

En esta imagen visualizamos la segunda subclase  del programa la cual nos muestra el SENO, COSENO Y TANGENTE, pertenecientes a los catetos que vamos a manejar para poder hallar los perimetros de determinadas figuras aritmeticas, proceso el cual se va a usar en el programa

En esta imagen tenemos tambien otroa subclasecon unas lineas de codigo, cuyos bloques poseen diversas operaciones las cuales se manejan en el programa.

En la siguiente imagen tenemos la ultima subclase la cual en sus lineas de codigo contiene el bloque con las areas de las diferentes figuras aritmeticas del programa.

Y finalmente las dos ultimas imagenes muestran el programa ya ejecutado.

EJERCICIO No CUATRO

EJERCICIO SIN CORRECCION

class Cuenta{
 protected int numero cuenta;
 protected double saldo;
 public Cuenta (int cuenta, double inicial){
  numero cuenta=cuenta;
  saldo=inicial;
 }//FIN CONSTRUCTOR CUENTA
 public void depositar(double cantidad){
  saldo=saldo+ cantidad;
 }//FIN METODO DEPOSITO
 public double saldo(){
  return saldo;
 }//FIN METODO SALDO
}//FIN CLASE DE CUENTA

class Banco{
 public static void main (String[]Args){ //SE CREA LA CUENTA
 Cuenta cuenta_1=new Cuenta(123456, 2505.32);
 //SE CONSULTA EL SALDO
 double total cuenta=cuenta_1.saldo;
 System.out.println("Total actual en la cuenta: "+total cuenta +"EUROS ");
 }//CIERRE DEL MAIN
}//FIN DE LA clase Banco

EJERCICIO CORREGIDO Y COMPILADO

EJERCICIO DOS

TRY CATCH

QUE ES Y COMO FUNCIONA TRY-CATCH ?:

EL TRY CATCH  es un controlador que permite solucionar los errores que se presenten en un bloque de codigo mientras un programa se este ejecutando.
La instrucción try-catch consta de un bloque try seguido de una o más cláusulas catch, las cuales especifican controladores para diferentes excepciones.
El bloque try contiene el código protegido que puede causar la excepción. Este bloque se ejecuta hasta que se produce una excepción o hasta completarse satisfactoriamente; la cláusula catch se puede utilizar sin argumentos, en cuyo caso captura cualquier tipo de excepción y se conoce como cláusula catch general; también puede aceptar un argumento de objeto derivado de System.Exception, en cuyo caso trata una excepción específica.
Es posible utilizar más de una cláusula catch específico en la misma instrucción try-catch. En este caso, el orden de las cláusulas catch es importante, ya que las cláusulas catch se examinan por orden. Las excepciones más específicas se capturan antes que las menos específicas.

PROGRAMA SUBCLASE "LINDA"

En este programa observamos lo que se denomina una subclase de un mismo programa

En donde el programa principal es programa1 y la subclase es Linda

Este es el SWITCH que recopila los ejemplos de los ejercicios

1.      Do-while         (SWITCH “todo el programa”)

2.      Secuencial       (Área de un triángulo)

3.      Condicional    (Análisis “Adivina el Numero”)

4.      For                 (Suma de Matrices)

5.      Vector            (Operaciones entre vectores)

En la primera Imagen Observamos lo que es la clase los métodos de entrada y el ménu del programa

ENCAPSULAMIENTO

ENCAPSULAMIENTO: Es el  ocultamiento del estado, es decir, de los datos miembro, de un objeto de manera que sólo se puede cambiar mediante las operaciones definidas para ese objeto.

Cada objeto está aislado del exterior, es un módulo natural, y la aplicación entera se reduce a un agregado o rompecabezas de objetos. El aislamiento protege a los datos asociados a un objeto contra su modificación por quien no tenga derecho a acceder a ellos, eliminando efectos secundarios e interacciones.

De esta forma el usuario de la clase puede obviar la implementación de los métodos y propiedades para concentrarse sólo en cómo usarlos. Por otro lado se evita que el usuario pueda cambiar su estado de maneras imprevistas e incontroladas.

POLIMORFISMO

POLIMORFISMO

Es la  capacidad para que varias clases derivadas de una antecesora utilicen un mismo método de forma diferente.

Por ejemplo, podemos crear dos clases distintas: Pez y Ave que heredan de la  superclase Animal. La  clase Animal tiene el método abstracto mover que se implementa de forma distinta en cada una de las subclases (peces y aves se mueven de forma distinta).

Como se mencionó anteriormente, el concepto de polimorfismo se puede aplicar tanto a funciones como a tipos de datos. Así nacen los conceptos de funciones polimórficas y tipos polimórficos. Las primeras son aquellas funciones que pueden evaluarse o ser aplicadas a diferentes tipos de datos de forma indistinta; los tipos polimórficos, por su parte, son aquellos tipos de datos que contienen al menos un elemento cuyo tipo no está especificado.

PRIVATE PROTECTED PUBLIC

PRIVATE: Este término indica que la clase tiene un acceso restringido, sobre todos los usuarios excepto el creador o programador, y usuarios seleccionados.
PROTECTED: Este término indica que la clase mencionada está protegida bajo seguridad,  por el autor. 
 PUBLIC: Este término indica que la clase mencionada es accesible para cualquier usuario.

TIPOS DE CLASES

R/

Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son:
abstract

Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.

final

Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.

public

Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.

synchronizable

Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban.

SUBCLASES

R/Una subclase se define mediante:

class B extends A
{
  // variables que B agrega a A
  int z;
  // Métodos que B agrega a A
  // Observe que B también posee x
  void Incz() { z= z+x; }
}

Se dice que la clase B hereda todas las variables y métodos de A. También se dice que B se deriva de A o que A es la clase base para B.

HERENCIA

R/
La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave.

class Pato extends Ave {
        int numero_de_patas;
        }

La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave.
Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada sustituyendo a la función Suma_a_i():

import MiClase;
    public class MiNuevaClase extends MiClase {
        public void Suma_a_i( int j ) {
            i = i + ( j/2 );
            }
        }

Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa a 10, pero la llamada al método Suma_a_i() produce un resultado diferente:

MiNuevaClase mnc;
    mnc = new MiNuevaClase();
    mnc.Suma_a_i( 10 );

En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (aminal). En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la compartición de funcionalidad que se encuentra implementada en Java a través de interfaces.

DESTRUCTOR EN JAVA

Un destructor es un método que se invoca automáticamente cuando el objeto se destruye. Java no posee destructores, porque tiene recolección de basuras. C++ posee destructores.

CONSTRUCTOR

R/El constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase.

Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un objeto de dicha clase.

 Cuando se crea una nueva instancia de MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructor de la clase:

MiClase mc;
    mc = new MiClase();

La palabra clave NEW se usa para crear una instancia de la clase.
Antes de ser instanciada con new no consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a 10.
Se puede referenciar la variable (de instancia) i con el nombre del objeto:

mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis para llamar al método Suma_a_i() utilizando el nuevo nombre de clase MC:

mc.Suma_a_i( 10 );

y ahora la variable mc.i vale 21.

DEFINICION DE METODO

R/Un método es un procedimiento cuya invocación siempre va asociada a un objeto.

Los métodos se definen en la declaración de la clase:

class A {
  int x, y; // variables de instancia
  // Métodos
  void Set(int vx, int vy) { x= vx; y= vy; }
  void Incx() { x++; }
  void Print() { System.out.println(x+" "+y); }
}
A a= new A();
a.Set(10, 20);
a.Print();      // 10 20
a.Incx();
a.Print(); // 11 20
Incx(); // error, falta indicar el objeto
A a2= new A();
a2.Set(5, 6);
a2.Print();     // 5 6
a.Print();      // 11 20

METODO

R/un método tiene las siguiente sintaxis:
tipo-retorno nombre-método
       ( tipo-parámetro nombre, ... )
{ instrucciones }
Si el procedimiento no retorna nada se coloca void. En las instrucciones las variables que se accesen que no sean parámetros o variables locales del procedimiento deben ser variables de instancia del objeto.

Una variable de tipo objeto es una referencia (puntero) a un objeto:

A a1= new A();
A a2= new A();
A a3= a2;
a1.Set(1,2);
a2.Set(5,6);
a3.Set(8,9);
a1.Print(); // 1 2
a2.Print(); // 8 9
a3.Print(); // 8 9

En este caso las variables a2 y a3 referencian el mismo objeto, mientras que a1 y a2 referencian objetos distintos.

Una referencia puede ser pasada como argumento y puede ser retornada por un método.

class A {
  ...
  void CopyFrom(A from) { x= from.x; y= from.y }
  A MakeCopy()
  {
    A acopy= new A();
    acopy.Set(x, y);
    return acopy;
  }
}

A a1= new A();
a1.Set(1,2);
A a2= new A();
a2.CopyFrom(a1);
a2.IncX();
a2.Print(); // 2 2
a1.Print(); // 1 2
A a3=a1.MakeCopy();
a3.Print(); // 1 2

Dentro de un método, el identificador this contiene una referencia al objeto con que se invocó este método.

class A {
  ...
  void CopyTo(A to)
  { to.CopyFrom(this); }
}

En Java no existe enlace directo entre identificador y objeto como en C o Pascal:

En C o C++
  A a;   // a es el objeto
  A *pa; // pa es una referencia al objeto
En Pascal
  var a: A;  // a es el record
      a: A^; // a es una referencia al objeto

Las variables se pueden inicializar con la referencia nula:

A a;
a= null;
a.x= 0;    // error, a es la ref. nula

Un objeto puede referenciar otros objetos:

class Eslabon {
  Eslabon next;
  A a;
  void Encadenar(Eslabon anext) { next= anext; }
}
...
for(Eslabon e= prim; e!=null; e= e.next)
  e.a.Print();

Los arreglos y strings son objetos predefinidos.

String s= null;
s.substring(1,2); // error
int[] a= null;
a[0]=0;           // error

Se pueden crear arreglos de referencias a objetos. No se pueden crear arreglos de objetos.

A[] aArr= new A[10];
aArr[0].x=1; // error, aArr[0] es nulo
for (int i=0; i<aArr.length; i++)
  aArr[i]= new A();

Ningún objeto se destruye explícitamente: No hay free ni delete

A a= new A();
a= new A();   

El objeto que se creó primero ya no es alcanzable y por lo tanto el recolector de basura recuperará el espacio que ocupa.

COMO SE CREA UN OBJETO ?

R/ Todos los objetos se crean con new:

A a1= new A();

A es el tipo del objeto creado. También se dice que A es la clase del objeto o que el objeto es una instancia de la clase A. La variable a1 también es de tipo A, o análogamente a1 es de la clase A, porque a1 debe contener siempre referencias a objetos que pertenecen a la clase A.

                          

COMO SE CREA UNA CLASE?

R/COMO CREAR UNA CLASE: En java los programas o aplicaciones se escriben en ficheros que tienen la extencion .java
Una aplicación puede tener uno o más ficheros con extensión .java
Cada uno de estos ficheros .java contiene una Clase
Cada vez que se crea una nueva Clase, se crea su correspondiente fichero con el nombre de la Clase y con extensión .java
En nuestro caso, vamos a crear una Clase que la vamos a llamar HolaMundo siguiendo los siguientes pasos
nos situamos en la ventana Projects y con el botón derecho del ratón seleccionamos el paquete paqholamundo
elegimos New Other

En el cuadro de dialogo New File elegimos la categoria Java y el tipo de fichero Java Main Class y hacemos click sobre el boton NEXT

en el campo de Texto Class Name indicamos que la Clase se va a llamar HolaMundo y hacemos clic sobre el botón FINISH y Listo.