04.3.- Variables, clases, métodos

Nota:
Este documento lo empecé el 21 de junio de 2012 , y ha tenido varias revisiones hasta hoy.
Iré retocándolo, así que, si pasas por aquí regularmente, seguro habrá cosas nuevas.

Comprueba las últimas revisiones en el ícono indicado de la esquina superior derecha:
T5xslt01.gif
T5xslt01.gif


GUIÓN
1.- Clases
1.1.- Introducción
1.2.- Ejemplos del package aClases1
1.2.1.- Clase01Texto.java: un ejemplo en modo texto
1.2.2.- Clase02ModoTexto.java: crea de un Frame utilizando código
1.2.3.- Clase03ModoGrafico.java: Clase en modo gráfico con NetBeans

2.- Métodos
2.1.- Introducción
2.2.- Clases de métodos
2.2.1.- Métodos de Clase
2.2.1.1.- Declaración de métodos de clase
2.2.1.2.- La llamada al método de clase.
2.2.1.3.- Ejemplos del Package "bMetodos1Multiplicacion"
2.2.1.3.1.- Multiplicacion20121Base.java: Código que realiza una multiplicación sin utilizar método
2.2.1.3.2.- Multiplicacion20122RND.java: Como el anterior pero los valores de las variables generadas aleatoriamente
2.2.1.3.3.- Multiplicacion20123MET.java: Mismo ejemplo que el anterior pero ahora utilizando un método
2.2.1.4.- Ejemplo del Package "bMetodos2Adivina1"
2.2.1.4.1.- El fichero "Clase04AdivinaMiNumero1.java": El juego "Adivina mi número" versión 1

2.2.2.- Métodos de instancia
2.2.2.1.- Inroducción
2.2.2.2.- Declaración y llamada de métodos de instancia
2.2.2.3.- Instancias y constructores
2.2.2.4.- Ejemplos de clases instanciadas y métodos de instancia
2.2.2.4.1.- Ejemplos Package "cInstancias1Ejemplo"
2.2.2.4.1.1.- "FicheroDosClases1.java" ejemplo de instancia muy básico pero interesante
2.2.2.4.1.2.- "FicheroDosClases2.java" modo texto (Lo hemos explicado en el punto "2.2.2.2.-").
2.2.2.4.1.3.- "FicheroDosClases2.java" Variante del ejemplo 2.2.2.2
2.2.2.4.2.- Ejemplos del package "cInstancias2Suma", Añadir argumentos
2.2.2.4.2.1.- El fichero "MainGrafico.java"
2.2.2.4.2.2.- El fichero "MainTexto.java"
2.2.2.4.2.3.- El fichero "RealizaSuma.java"
2.2.2.4.3.- Ejemplos del package "cInstancias3Multiplicacion"
2.2.2.4.3.1.- El fichero "MultiplicacionMain.java", Clase principal en modo texto
2.2.2.4.3.2.- El fichero "MultiplicaciónMetodo.java", Clase secundaria, interesante, posee una instancia de la API
2.2.2.4.3.4.- El fichero "MultiplicacionJFrame.java". Clase en modo gráfico
2.2.2.4.4.- Ejemplos del Package cInstancias4Ejemplos1.
2.2.2.4.4.1.- El fichero "cArgumentos1Texto.java".Es un solo fichero, contiene dos clases, la llamada al método y el método utilizan argumentos para comunicar los valores de sus variables.
2.2.2.4.4.2.- El fichero "Principal.java", Dos clases, llamada a clase principal y secundaria
2.2.2.4.5.- Ejemplos del package "cInstancias5Calculo"
2.2.2.4.5.1.- El fichero "CalculoMain.java", Clase principal, calcula el área de algunas figuras geométricas
2.2.2.4.5.2.- El fichero "Calculos.java", clase secundaria. Interesante los argumentos de los métodos de instancia
2.2.2.4.6.- El package "cInstancias6Adivina2"
2.2.2.4.6.1.- El fichero "AdivinaMiNumero.java" , El juego adivina mi número version2
2.2.2.4.6.2.- El fichero "GenerarNumAleatorio.java"
2.2.2.4.6.3.- El fichero "MetodoAvisos.java"

3.- Variables

4.- Modificadores
4.1.- Modificadores de acceso (o de visibilidad) public, private, protected y default
4.2.- Modificadores de clases y métodos: static, final, abstract.
4.3.- Mecanismos de sincronización: volatile y syncrhonized.
4.4.- Otras: strictfp

====BORRAR

3.- Mas conceptos relacionados con los métodos (en redacción)
3.1.- Métodos Get y Set
3.2.- El operador this
3.3.- Clases abstractas
3.4.- Modificadores
3.5.- Anotaciones @
(pendientes)
  • Atributos, argumentos. parametros (¿son tres conceeptos o solo dos?)
  • Layout
  • Listeners y eventos: puedes consultar esta página (aunque aún no está terminada):04.10.- Listeners y Eventos
  • referencias a objetos this o el operador this
  • herencia
  • Polimorfismo
  • Sobreescritura de métodos ¿o sobrecarga??
  • Métodos nativos--> Un método nativo es un método Java que se ha realizado en otro lenguaje de programación
  • los métodos get y put?? ¿o Los métodos con get y set?
  • Super ??
==

Los he realizado con esta versión:
NetBeans IDE 7.1.1
Java: 1.6.0_31
System: Windows 7 Home

DESCARGA
Al final de la página hay un enlace para descargar una aplicación que contiene ejemplos agrupados por packages en el mismo orden en que los veremos en esta página.



0.- Introducción

a) En esta página hablaremos de clases y métodos de java a través de ejercicios que pueden descargarse al final de la página. Estimamos que tienen un nivel básico y medio.
Dentro de los ejemplos también veremos sobre las variables, como se declaran, nombran y usan.
En principio pretendo mostrar las diferencias en la programación según utilicemos código en modo texto o utilizando un IDE como NetBeans. Lo normal es que ambas versiones no sean compatibles y hay que adaptar las aplicaciones.
Nos centramos mas en explicar como funciona el código utilizado en una aplicación para que realice una tarea de la manera que necesitamos.

b) También añadimos algo de teoría. En este caso interesa conocer los diferentes tipos de relaciones que establecen las clases entre sí. Lo he sacado de varias fuentes pero la mas completa es esta: http://slashmobility.com/slash/cursos/fundamentos-java/Curso-Java-Inicial-5-Relaciones-entre-Objetos.pdf.
Y esto es un resumen de las posibles relaciones entre clases:
  • Clientela. Cuando una clase (principal) utiliza objetos (métodos) de otra clase (secundaria):
    • No necesitamos conocer detalles de su implementación (de la la otra clase) sino como funciona o que tarea realiza.
    • Parece que no pueden utilizarse para pasarse valores de variables. El método puede realizar lo previsto en su código. Haciendo pruebas (y hasta donde he visto) encontre que sirven pueden:
      • mostrar información o mensajes definidos en el método de la clase secundaria
      • Realizar y mostrar cálculos o datos que el propio método (de la clase secundaria) realiza (con valores de variables definidos en la clase secundaria o introducidos por teclado o fichero...
      • imprime mensajes de acuerdo a lo definido en el método.
      • No utiliza ni comparte variables ni valores de las variables de la clase principal, no devuelve ni comparte valores de la clase secundaria o sus métodos.
      • Por ello no devuelven valores de variables. Según interpreto, la respuesta de un método de la clase secundaria en una relación de clases de clientela no podrá verse en modo gráfico en la clase principal, solo en modo texto en la salida Output de NetBeans.
      • Parece que para usarlas debemos invocarlas usando el nombre de la clase y el método. Ver "2.2.1.- Métodos de Clase" en esta misma página

  • Composición. Esta es facil de identificar, la hemos usado frecuentemente en esta página, en realidad casi de manera exclusiva. Llevan un constructor:
    • Hay una clase principal y una secundaria
    • Pueden compartir valores de variales
    • Necesitan que la clase principal llame o invoque a los metodos de la clase secundaria
    • Los métodos llevan argumentos (variables) que permiten compartir valores de las variables entre la clase principal y la secundaria.
    • Puede llamarso invocarse a los metodos de la clase secundaria ue tamien pueden llevar argumentos.
    • Muy interesante lo que recogemos sobre los métodos de instancia (ver punto "2.2.2.- Métodos de instancia"), como declararlos y añadirles código y acerca del funcionamiento de sus argumentos.
  • Anidamiento (o internas). Definir clase/s dentro de otra clase. Sirven para incrementar el nivel de encapsulación y ocultamiento. Hay de varios tipos:
  • Herencia. Si disponemos de una clase y partiendo de ella definimo otra/s clase/s a las que podemos añadir nuevas características o alguna funcionalidad especifica (especialización). (creo que he usado alguna en esta página, veré de localizarla), no hay que escribir de nuevo el código de la clase madre.
    • Se usa la palabra reservada "extends" ??
    • Se pueden heredar:
      • Atributos
      • Metodos
      • Los constructores no se heredan
    • Se pueden sobreescribir o sobrecagar
    • En las relaciones de herencia se puede utilizar la palabra reservada "super" (parece que solo se puede usar cuando hay un constructor). Sirve para hacer una llamada al constructor de la superclase para que inicie los atributos heredados ??
    • Tambien se utiliza "final" Impide la herencia de una clase al declararla como final
    • La herencia puede adaptar en el descendiente los miembros heredados:
      • Adición
      • Redefinición
      • Anulación
    • La herencia puede hacer una redefinición de métodos es decir cambiar el comportamiento de un método heredado??
    • Sobrecarga no es lo mismo que redefinición ??
    • Object: Todos las clases en Java heredan en última instancia de Object. Es como si fuera la raiz de todas las clases. Incluso si creamos una clase independiente, Java la hace heredar implícitamente de Object.
    • Clone: Es una palabra (reservada??) que pertenece también a la herencia. Crea un objeto que es copia “superficial” ?? del objeto actual independientemente de su tipo.

c) Otros conceptos pendientes de situar en la relación de clases que les correspondan:
  • Atributos, argumentos. parametros (ya se han explicado en los métodos de instancia)
  • Layout
  • Listeners y eventos: puedes consultar esta página (aunque aún no está terminada):04.10.- Listeners y Eventos
  • Anotaciones @
  • Polimorfismo
  • Métodos nativos--> Un método nativo es un método Java que se ha realizado en otro lenguaje de programación
  • los métodos get y put
  • Los métodos con get y set
  • Threads, fuente: http://www.arrakis.es/~abelp/ApuntesJava/Threads2.htm

Bien, visto la cantidad de conceptos parece que aún nos queda mucho que aprender sobre java. Este esquema es interesante porque ayuda a situar numerosos conceptos o palabras reservadas que, en mi caso ya conocia, pero apareciasn desperdigadas. Ahora podemos ver como cada concepto está situado en el tipo de relación de clases que le corresponde.

Seguramente este esquema tendré que retocarlo porque aún tengo dudas sobre que aplicación determinada corresponde con una relación de clases.

Este diagrama (en proceso de actualización) trataré de situar los tipos de relaciones entre clases y adjudicar a la que corresponda los temas que tocamos en esta página. También da una idea de como está estructurado ese contenido.

Clases2c.gif




1.- Clases

1.1.- Introducción

La clase es la base de la programación en java (La unidad fundamental de programación en Java es la clase) .En realidad una clase, su creación y uso es inicialmente sencillo. Pero tranquilo, enseguida se complican :), no hay mas que ver el diagrama anterior.

En estos ejemplos veremos como crear distintos tipos de clase, utilizando código en modo texto, utilizando código en modo gráfico y en modo gráfico utilizando NetBeans.

En Java podemos utilizar dos GUI (Interfaz Gráfica de Usuario) AWT y SWING. Para no liarnos mucho diremos que ambas pueden realizar las mismas tareas, podemos programar las mismas cosas:
  • "A pelo": directamente creando un fichero en un editor de texto adecuado para java, añadiendo componentes a través de código y ejecutando en modo consola (muchos programadores prefieren este sistema antes que cualquier IDE).
  • Utilizando un IDE (Entorno de Desarrollo Integrado) como NetBeans (o Eclipse, etc), donde podemos:
    • Seguir programando "a pelo" pero ejecutamos desde el IDE con el que trabajemos, en este caso NetBeans.
    • O utilizar objetos que ya están diseñados como los que podemos encontrar en la 'celebre' ventana Palette de NetBeans y entonces si hay diferencias en el código porque los objetos Palette añaden código de manera automatica para:
      • Crear el objeto
      • Para añadir otras: importar paquetes de clases; crear métodos, constructores... que puede usar el objeto creado o son necesarias para su funcionamiento. Por ejemplo
        • Definir las propiedades de los objetos
        • Al añadir objetos se crean "layouts" que permiten situar ordenadamente los objetos en el frame, en programación en modo gráfico a base de código hay que añadirlo a mano si lo necesitamos..
        • Al crear eventos, para un objeto (un jButton por ejemplo) se añade código para eventos y listener (escuchadores) y se importan las clases para gestionarlos es decir para detectar si hemos pulsado o no el botón y en consecuencia ejecutar las líneas de código que le hemos añadido. El código generado en NetBeans no es compatible con el realizado " a mano" para la misma tarea:
        • Esto hace que programas gráficos a base de código y programas gráficos NetBeans (o de cualquier otro IDE) no sean compatibles y hay que "adaptarlos".
    • Pero nos encontraremos con problemas de compatibilidad entre modo grafico utilizando solo codigo y modo grafico utilizando solo NetBeans

A continuación vienen algunos ejemplos de creación de clases, siempre en NetBeans:
  • En modo texto
  • En modo gráfico (usando solo código)
  • En modo gráfico usando la Palette de NetBeans

En realidad, trabajando con NetBeans, al crear un fichero de manera automática genera código para sus clases y métodos básicos para poder ejecutarlos y esto es lo que veremos en los siguientes tres puntos. El interés está en ver las diferencias entre las clases según como la hemos creado. Más adelante veremos como añadir código para que realicen alguna tarea.

1.2.- Ejemplos del package aClases1

En esta captura vemos como localizar en el fichero de descarga el paquete de las clases que explicamos a continuación. Como ves hay tres ficheros, cada uno es un ejemplo.
nb71-14.gif

Nota:
Quizá sea interesante vistar el punto "23.- Crear proyecto, package y ficheros para una aplicación NetBeans" de la página 04.5.- Como hacer... donde se da información sobre como crear proyectos y ficheros en NetBeans.

1.2.1.- Clase01Texto.java: un ejemplo en modo texto

Esta es la captura del código del fichero Clase01Texto.java, es un ejemplo en modo texto:
nb7-83.gif
Vemos:
a) Elementos ya conocidos:
  • La ventana con solapas para Proyectos (y files y servicios)
  • La ventana Members View donde he seleccionado la opción (flecha roja) que muestra los elementos creados (vemos solo la clase y el método main).
  • La ventana de trabajo (Source) donde vemos el código generado por NetBeans
  • La ventana de Salida (Output) donde se muestra el resultado de la ejecución del fichero en modo texto

b) La clase:
  • Su declaración: "public class Clase01Texto {}
  • Su cuerpo es todo el código que queda entre llaves
  • Como vemos a esta clase le falta añadir código para que trate algún dato, lo busque, lo muestre, etc., lo veremos más adelante.

1.2.2.- Clase02ModoTexto.java: crea de un Frame utilizando código

Esta es la captura Clase02ModoTexto.java del código de un Frame creado en AWT / SWING:
nb7-84.gif
Observamos:
  • Es necesario importar (a mano) la clase "import javax.swing.JFrame;" Con ella podremos instanciar el objeto JFrame MiVentana.
  • La clase principal es: "public class Clase02ModoTexto extends JFrame{" . En realidad es la única clase del fichero. Dentro de ella vemos el método "main" ya conocido de anteriores capturas y dentro del método main encontramos código añadido a mano:
    • Esta línea de código sirve para instanciar un objeto: 'JFrame MiVentana = new JFrame("Frame código" );'. En este caso es un objeto JFrame de nombre MiVentana que además contiene el título que aparecerá al ejecutarlo en la barra de título. En realidad ese código es un constructor (ver punto "2.2.2.1.- Instancias y constructores" de esta página).
    • Las siguientes dos líneas del código son propiedades del jFame. Una dice que el frame debe ser visible y otra define su tamaño.
  • En la captura anterior también podemos ver el resultado de la ejecución de la aplicación: un Frame creado aún sin ningún objeto dentro y la ventana de salida de datos.
  • Está visible solo la opción "Code", código, y no se muestra la opción "Design" dado que estamos trabajando en modo gráfico pero todo a base de código, el jFrame se crea a partir de la instancia declarada "a mano" del código del constructor, tambien "a mano" declaramos sus propiedades.

1.2.3.- Clase03ModoGrafico.java: Clase en modo gráfico con NetBeans

Y este del fichero creado en NetBeans utilizando objetos ya diseñados.
nb7-85.gif

Observamos:
  • El código que vemos se ha generado automáticamente
  • No es necesario importar el paquete "import javax.swing.JFrame;"
  • La clase principal lo busca en las librerias: "public class Clase03ModoGrafico extends javax.swing.JFrame {".
  • Se genera un método nuevo, "public Chapuzas02clase02b() {",que será en el que añadamos código (también podría añadirse llamadas a otros métodos dentro de este mismo método, cada uno con su correspondiente tarea, lo veremos más adelante).
  • Observamos en la secuencia de números de línea algunos saltos que corresponden a líneas de código que se generan automáticamente y no puede modificarse desde el teclado. Si las desplegamos veremos que en este caso son líneas que definen el estilo del 'layout' (veremos mas adelante que es, pero básicammente ayuda a situar de manera proporcionada elementos en el frame)
  • Observamos también el método main y dentro de él código generado automáticamente. Exactamente, por ahora, no puedo explicar como funciona, pero parece que interviene en la creación de un jFrame en blanco y lo hace visible.
  • @SuppressWarnings("unchecked"), anotaciones, se genera automáticamente al crear el jFrame. Sirve para suprimir las advertencias de compilación, indica que el programador no desea ser notificado sobre ella. Veremos que hay mas código precedido de @ con distintas funciones.
  • Ahora está disponible la solapa con la opción Design además de Code. Pulsandola hacemos visible los objetos creados, la ventana Palette, la ventana de propiedades y podemos modificar las propiedades de los objetos.
  • En esta captura vemos las opciones Source y Design. He seleccionado Design y muestra donde podemos buscar objetos que necesitemos (Palette) y donde modificar sus propiedades. Normalmente cuando cambiamos las propiedades por defecto el iten modificado se muestras en negrita. En este caso:
    • Vemos el jFrame creado al que he cambiado en Propiedades su tamaño (200,200) para que coincida con el ejemplo anterior.
    • y el texto de la barra de título.
    • Por defecto adjudica otras propiedades como ser visible y las de layout
  • nb7-86.gif

Conclusión
  • Podemos realizar una aplicación en modo gráfico de las dos maneras: solo texto u objetos de Palette.
  • La primera a base de utilizar solo código, obliga a utilizar código (constructores) para definir/crear/instanciar los objetos y las propiedades de los objetos.
  • La segunda permite utilizar objetos desde la ventana Palette de NetBeans (o de cualquier otro IDE) y definir en la ventana Propiedades de cada objeto cuales serán sus características. No obstante, si es de nuestro interés, también podemos modificar propiedades a través de código. Lo cierto es que de esta manera gran parte del codigo no lo escribimos a mano, pero NetBeans (o el IDE que usemos) se encarga de crearlo de manera automática.
  • Las propiedades hacen referencia a numerosas opciones del objeto: color y tipo de borde; color de fondo; color, tamaño; tamaño, color y tipo de fuente; posición, si visible u oculto....
  • Utilizando objetos a través de un IDE se añade código para crearlos automáticamente con propiedades configuradas por defecto. Y también se añade código de manera automática para:
    • para definir los Layout (lo veremos más adelante).
    • Posiblemente listener y eventos también añadan código de manera automática (también lo veremos más adelante). Esto haría, por ejemplo, que el código para arrastrar y soltar en modo ejecución un objeto como label o button sea diferente de manera significativa según empleemos objetos Palette o los creemos en código.
    • ...

Las clases creadas que vemos en estas capturas les falta añadirles código para realizar alguna tarea.
En los siguientes puntos veremos ejemplos de ello.

Si estamos utilizando clases debemos conocer

a) Básico
  • Si utilizamos una clase con main --> clase principal
  • Si utilizamos clases sin main--> clases secundarias
b) En la herencia
  • superclase (o clase padre o clase base)
  • subclase (o clase hija o clase derivada)

c) En la declaración de clases Abstractas
  • ??
  • ??
d) En las clases internas
  • Clase contenedora
  • Clase interna


los nombre con que podemos encintrarlas segun

2.- Métodos

2.1.- Introducción

  • Un método es es un trozo de código encapsulado que realiza una tarea. En realidad la tarea a realizar puede ser muy simple, de una sola línea de código o muy compleja con multiples instrucciones. En ocasiones casi es mejor no utilizar un método y dejar el código dentro de la clase principal.
  • Para crear un método necesitamos una clase que lo contenga y:
    • La declaración del método: este es un ejemplo de creación de un código, "public static void metodomul(){}".
    • Su cuerpo, es el código que colocamos entre las llaves de apertura y cierre y en él definimos la tarea que queremos que haga.
    • Más abajo veremos la captura de un ejemplo
  • Para poder ejecutarlo es necesario llamarlo (o invocarlo) desde algún lugar del código de la clase principal (a veces desde un objeto como jButton y otras desde otro método...).
  • Al llamar a un método, la ejecución del programa pasa al método y cuando éste acaba, la ejecución continúa a partir del punto del programa donde se produjo la llamada.
  • Distinguimos los métodos porque empiezan en minúsculas, y las clases porque empiezan con mayúsculas. Es una convención para programar en java.
  • Los métodos pueden crearse:
    • Dentro del fichero de la clase principal (la que tiene el método main)
    • Dentro de un fichero con dos clases, la principal y la secundaria.
    • Dentro de uno (o mas) fichero(s) con clase(s) secundaria(s), se necesita al menos un fichero con la clase principal para poder ejecutarlo.
  • Veremos ejemplos más adelante.

Notas:
  • En el fichero "Multiplicacion20121Base", más abajo, veremos como una clase realiza la multiplicación de dos números aleatorios sin crear ningún método para ello. En el fichero "Multiplicacion20122MET" realizamos la misma tarea pero esta vez con un método. Lo que quiero decir es que el código puede funcionar de las dos maneras. Solo varía la situación concreta que sugiere como mejor la creación de uno o mas métodos para agrupar el código de la clase de manera que cada método realice una tarea especializada, un cálculo, comparar, seleccionar, etc.
  • La ventaja que tiene esto es separar código que realiza tareas específicas del resto del código, básicamente el código que queda sin encapsular en métodos en una clase es el que se encarga de mostrar los objetos y mostrar los datos obtenidos en los métodos. En modo gráfico el que contiene jFrame, jLabel,,jTextField... y en general objetos que forman el interface que permite la comunicación entre el usuario y el ordendor.
  • Esto permite que podamos hacer el mantenimiento y modificación de una aplicación más facilmente: corregimos resultados erróneos, añadimos nuevas funciones, mejoramos la precisión del cálculo, mejoramos el código, lo reutilizamos (un método puede ser llamado desde varios puntos de la clase o de otro método...).

2.2.- Clases de métodos

A continuación presento los dos tipos de métodos que podemos usar en java. Veremos sencillos programas en modo texto y en modo gráfico de las distintas maneras de declararlos y llamarlos, desde un mismo fichero o desde distintos ficheros. No trato de ser exhaustivo, pero sí tener ejemplos variados de su uso que puedan servir para crear otros adaptados a las necesidades de la aplicación que cada uno quiera realizar.
Los dos tipos de métodos son:
  • Métodos de clase (static): Solo necesitan ser declarados y llamados
  • Métodos de instancia: Necesitan un constructor y ser instanciados, y también ser llamados. Devuelven un valor con el comando "return".


2.2.1.- Métodos de clase

2.2.1.0.- Introducción
En realidad, en java podemos hacer programas sin utilizar métodos. Definimos en el listado las instrucciones que queremos que ejecute el programa y estas se ejecutan secuencialmente.

Pero si el programa es grande y tiene muchas líneas de código podemos agrupar trozos de código por la tarea que realizan y crear un método que las contenga. Las ventajas son:
  • Trabajamos con objetos
  • Podemos colocar los métodos en zonas del listado donde
    • localizarlos facilmente
    • dejar el resto del código mas límpio para acceder a él y realizar pruebas
  • También, si es incomodo tenerlos todos en el mismo fichero, crear un fichero nuevo con una clase que los contenga. Entonces tendremos que llamarlos desde la clase principal.
  • Incluso podemos crear ficheros cuyas clases tengan métodos especializados o relacionados con tareas afines.
  • En general tiene la ventaja de:
    • Dejar el código de la clase principal mas despejado
    • Poder probarlos por separado
    • Y muy interesante: un mismo método puede ser llamado desde diversos puntos de la aplicación.
2.2.1.1.- Declaración de métodos de clase
En esta captura vemos un método de clase (pertenece al ejemplo Multiplicacion20122MET.java, ver más abajo):
nb7-94.gif
Observamos:
  • La declaración del método de clase: Comprende el código "public static void metodomul()" y la apertura y cierre de llaves { }. El nombre del metodo es "metodomul()". El nombre del método lo pone el programador y suele hacer referenca a algo relacionado con la tarea que realiza. Servirá para invocarlo.
  • El cuerpo del método: está situado entre las llaves de apertura y cierre. En este caso formado por tres líneas, dos que generan un número aleatorio de acuerdo a la variable "aleatorio" (ver Nota) para las variables "multiplicando" y "multiplicador" y otra línea para el resultado de la multiplicación que se almacena en la variable "producto".
  • Como el método tiene el modificador "public" la clase puede disponer de los valores de las variables para mostrarlos en la pantalla. Más adelante veremos otros tipos de modificadores.
Nota:
La variable "aleatorio" está definida a 9 (ver package "bMetodos1Multiplicacion" fichero Multiplicacion20123MET.java más adelante).

2.2.1.2.- La llamada al método de clase.
En esta captura la vemos (pertenece al ejemplo Multiplicacion20123MET.java, ver mas abajo):
nb7-95.gif
  • La llamada a un método de clase (y a uno de instancia) se hace desde la clase principal, la que tiene el método main, desde otro método, desde jButton....
  • Los métodos de clase se pueden invocar sin crear (instanciar), un objeto de la clase en la que se han definido (luego veremos que esto sí es necesario para los métodos de instancia).
    • Si son métodos de clase que se encuentran dentro de la clase principal que los llama con invocarlos/llamarlos con su nombre es suficiente.
    • Si están en otra clase y se le invoca desde la clase principal, debe ponerse el nombre de la clase seguido del operador punto (.) y el nombre del método. Si fuera el caso de la captura siguiente seria "DosClases.imprimir()".
  • Para invocar los métodos de instancia, hay que ponerles delante el nombre de la instancia de la clase donde están. En esta captura vemos que el método se llama "imprimir()" y la instancia de la clase "mensaje". Por eso la llamada al método es "mensaje.imprimir();" (los métodos de instancia los veremos en el punto "2.2.2.- Métodos de instancia", lo pongo aqui para ver la diferencia de la llamada entre métodos de clase y de instancia).
  • nb7-91.gif
Recuerda, la llamada a un método:
  • De clase
    • imprimir() -->en la misma clase
    • ClaseSecundaria.imprimir() --> en otra clase (clase.metodo)
  • De instancia:
    • mensaje.imprimir() --> en un método de instancia (instancia.metodo() ), los veremos en el punto "2.2.2.- Métodos de instancia".

Características de los métodos de clase:
  • Pueden estar dentro de la clase principal o dentro de otra(s) clase(s) secundarias.
  • Se cargan en memoria en tiempo de compilación y no a medida que se ejecutan las líneas de código del programa. En principio no entiendo esto, pero. lo que si he notado es que un error en un método de clase, aunque esté en otra clase y otro fichero da error en la clase principal.
  • Van precedidos del modificador static. Para invocar a un método estático no se necesita crear un objeto (instancia) de la clase en la que se define:
  • Si se invoca desde la clase en la que se encuentra definido, basta con escribir su nombre.
  • Si se le invoca desde una clase distinta, debe anteponerse a su nombre, el de la clase en la que se encuentra seguido del operador punto (.) <NombreClase>.metodoDeClase
  • Suelen emplearse para realizar operaciones comunes a todos los objetos de la clase. No afectan a los estados de los mismos (a los valores de sus variables), (hay que conocer mas sobre el modificador "static").
  • No conviene usar muchos métodos de clase, son mas rápidos pero menos flexibles y no se hace un uso efectivo de la memoria.
  • Como hemos indicado la llamada puede estar en la misma clase, en otro método, en un jButton, etc.

2.2.1.3.- Ejemplos del Package "bMetodos1Multiplicacion"
Estamos aqui:
nb71-15.gif
Multiplicacion20121Base.java: Código que realiza una multiplicación sin utilizar método
En este caso no he creado ningún método. Se imprime siempre el mismo resultado porque el valor de cada variable está definido en el listado.

Nota:
Si tienes interés puedes modificar el código para introducir los datos por el teclado en modo texto a través de la ventana Output, ver punto "22.- Introducir datos por el teclado en modo texto" de la página 04.5.- Como hacer...
Multiplicacion 07.gif
Observamos:
  • La ventana Projets donde vemos el nombre del:
    • proyecto
    • Package
    • El nombre del fichero .java
  • La ventana Source con el código del fichero:
    • La clase principal con:
      • Declaración de las variables con static
      • El método Main con varias líneas de código para mostrar los datos utilizados y el resultado.
  • La ventana de salida de resultados muestra impreso en modo texto los valores de la variable utilizadas y el producto de ambas.

Multiplicacion20122RND.java: Como el anterior pero los valores de las variables generadas aleatoriamente
Seguimos en modo texto y sin usar método, todo dentro de la clase principal. Las variables se generan de manera aleatoria, cada vez que ejecutamos genera variables nuevas y su producto:
Multiplicacion 08.gif
Más adelante veremos otra forma interesante de generar números aleatorios.

Observamos lo conocido de la captura del fichero Multiplicacion20121Base.java y las variables generadas aleatoriamente:
  • Una clase
  • Dentro declaramos:
    • Las variables generadas por el método Math. Interesante porque lo encontraremos más adelante cuando hablemos de instancias y constructores.
    • El método main y dentro de él contiene las variables y el producto que se mostrarán en la ventana de salida de resultados
  • La ventana de salida

Multiplicacion20123MET: Mismo ejemplo que el anterior pero ahora utilizando un método
Multiplicacion 10.gif

Observamos:
  • Cosas ya comentadas en capturas de ejercicios anteriores
  • La clase principal que ahora tiene dentro, además del método main, la declaración de un nuevo método:
    • El nuevo método se declara con "public static void metodomul()" y sus llaves de apertura y cierre.
    • Entre las llaves de apertura y cierre vemos el código que antes se encontraba en el cuerpo de la clase principal y sirve para:
      • Generar las variables que representan al multiplicando y multiplicador.
      • Calcular la variable producto que contiene el resultado de la multiplicación.
  • En la ventana Members View vemos todos los elementos creados hasta este momento, observamos como ahora muestra también el nuevo método.
  • Podríamos decir que el método encapsula dentro de él líneas de código que antes se encontraban en el cuerpo de la clase.
  • Vemos en el cuerpo de la clase la llamada al método creado: metodomul(); Es interesante porque así es como hay que llamar al método cuando está dentro de la clase principal. Cuando está en otra clase hay que utilizar:
    • El nombre de la clase (no se ha instanciado)
    • El nombre usado para instanciarla. El nombre de la instancia creada se antepone al nombre del metodo, lo veremos con detalle en el punto "2.2.2.- Métodos de instancia".
Nota:
  • La importacia de un método de este tipo (método de clase) es que tenemos acotado a unas pocas líeas, las que forman el método, un código que podemos localizar facilmente y sobretodo modificar, ampliar, mejorar para observar su resultado de manera que no afecte al resto del programa.
  • Los valores generados no se imprimen en el método creado (aunque puede hacerse) sino que devuelven los valores al método "main" que es donde se imprimen (y es lo que pretendía hacer).

2.2.1.4.- Ejemplos en modo gráfico
nb71-16.gif
Clase04AdivinaMiNumero1.java: El juego "Adivina mi número" versión 1
La verdad es que hay muchas posibilidades de mostrar aplicaciones en modo gráfico. Los tres ejemplos vistos hasta ahora podrian hacerse en modo gráfico.

Para no repetir y cansar, mejor observa este ejemplo que es el juego "Adivina mi número". Esta versión contiene varios métodos de clase todos dentro de la clase principal (Más adelante veremos otra versión de este juego en el apartado "2.2.2.- Métodos de instancia" donde los métodos están en clases secundarias)

Esta es la captura de la pantalla del juego tras realizar con éxito un acierto (en realidad, jugando bien se acierta en 6 jugadas):
nb7-87.gif
Es un jFrame en el que hay situados varios objetos, todos creados con arrastrar y soltar desde la ventana Palette de NetBeans.

Vemos:
  • La barra de tÍtulo
  • Un jLabel para el nombre del juego en el Frame
  • Al lado un jTextFiel para introducir números del 1 al 100 usando el teclado
  • Un jLabel que puede dar mensajes:
    • De felicitación: "Acertaste, felicidades", que es el que vemos
    • "Mi número es mayor", es una pista para que introduzcamos un número mayor que la anterior jugada
    • "Mi número es menor", es una pista para que introduzcamos un número menor que en la anterior jugada
  • Cuatro jLabel que ayudan a que el jugador conozca cuantas jugadas ha realizado y cuantos aciertos ha conseguido
  • Un botón para pulsar una vez escrito un número en el jTextField.

En esta y las siguientes capturas veremos como se declara un método, como añadirle código para que realice la tarea que necesitamos, como llamarlo y como podemos llamar a un mismo método desde distintos lugares del código del programa.

Recuerda que ahora estamos trabajando con métodos de clase y en modo gráfico.

Esta es una captura de parte del código:
nb7-88.gif
Vemos cosas conocidas:
  • La declaración del package al que pertenece el fichero
  • La clase que es necesario importar, permite cambiar el color del texto de los mensajes de ayuda(azul) y felicitación (rojo)
  • La declaración de la clase principal que es una extensión de JFrame. Sirve para crear un jFrame sobre el que se colocan diversos objetos (que ya hemos visto en los comentarios a la primera captura).
  • La declaración de las variables que vamos a utilizar.
Y cosas nuevas
  • El metodo "public Clase04AdivinaMiNumero1() {". Se crea por defecto al crear el jFrame y aún no tengo claro que tipo de método es. Lo que si sabemos es que puede contener código propio (aunque en este caso no le he puesto ninguno) y puede contener llamadas a métodos de instancia como en este caso la llamada al método "numeroAleatorio()".
  • La declaración del método de instancia "public void numeroAleatorio() { " y el código que contiene. El código sirve para:
    • Generar un número aleatorio desde el 1 al 100, en realidad es la única línea de código que interesa, las siguientes dan ayuda de distinta manera al programador.
    • Imprimirlo en la ventana de salida de datos, como una pista para las pruebas del programador, después es mejor comentar la línea.
    • Ocultar/mostrar una jLabel que justamente también muestra/oculta el número aleatorio obtenido. Si lo ponemos a true muestra la respuesta.
    • Adjudicar a la etiqueta anterior el número aleatorio generado para mostrarlo en el frame. Es una ayuda para el programador mientras hace pruebas de funcionamiento del programa. Estas dos lÍneas podemos comentarlas, borrarlas o poner la anterior a false si no queremos mostrar la respuesta correcta del juego.

Esta es otra captura, continuación de la anterior:
nb7-89.gif
Vemos:
  • Es un segundo método de clase.
  • Este método se ejecuta, es invocado, al pulsar el jButton situado en el jFrame. El código del botón lo veremos y explicaremos en la siguiente captura.
  • Básicamente lo que hace es evaluar si el número introducido por el jugador al compararlo con el generado aleatoriamente es:
    • igual: da mensaje de felicitación
    • mayor: da aviso para que introduzca uno menor
    • menor: da aviso para que introduzca uno mayor
    • Estos mensajes pueden verse:
      • En modo texto en la ventana de salida (output)
      • En la etiqueta jLabel1 del jFrame en modo gráfico.
  • Tiene dos acumuladores "jugadas++" y "aciertos++" que presentan sus valores en el frame en sus correspondientes jLabel.
  • Observemos como los mensajes de felicitación y ayuda se muestran siempre en la misma label: jLabel1.
  • Así mismo como el código "jLabel1.setForeground(Color.red);" del mensaje de acierto se muestra en rojo y los de ayuda en azul. Interesante porque esto no se puede hacer desde las propiedades del objeto de NetBeans donde solo admite configurar un color.
  • Es un ejemplo interesante para conocer el bucle "if" que lo veremos frecuentemente y facilmente en otros programas de estas páginas.

Y esta captura es la del código del jButton:
nb7-90.gif
jButton es un objeto cuyo código, inicialmente, no se ve en el cuerpo de la clase. Para que aparezca su código pulsamos en modo "Desing" dos veces sobre él con el ratón. No puede modificarse a mano. En su declaración vemos que contiene un evento (ver 04.10.- Listeners y Eventos) y entre las llaves he añadido el código que queremos ejecutar.

Al pulsarlo en modo ejecución se producen varias cosas:
  • La variable de "tuNumero" es de tipo String y guarda el contenido del número introducido en el jTextField situado en el frame.
  • Como es del tipo String es necesario pasarla a tipo int (entero), esto es lo que hacemos al almacenarla en la variable "tuNumero2". Es necesario hacerlo para poder comparar tipos iguales (int -enteros-) entre la variable "tuNumero2" y "numeroAleatorio".
  • Dado que la trasformación a 'int' solo admite números enteros he utilizado un "try" "catch" para evitar el error que se produce cuando introducimos letras o el jTextfield está vacío. De esta manera no se interrumpe la ejecución del programa aunque avisa del tipo de error.
  • Una vez verificado que el dato introducido es un número la secuencia de ejecución continúa hasta la llamada al método "compara();" que lo hemos visto más arriba en una captura y sus observaciones.
  • Una vez que termina el método "compara();" vuelve al mismo sitio de que partió y se encuentra con esta linea: "jTextField1.setText("");" que lo que hace es borrar el número contenido en el jTextField para dejarlo en blanco y poder introducir uno nuevo para otra jugada.
  • He marcado la llamada al método "compara();" que, como ya hemos visto es como se invoca a un método que está en la misma clase.

Reflexión:
  • Bien, esto es lo que podemos decir por ahora acerca de los métodos de clase. Como último detalle decir que es posible eliminar los métodos (public void numeroAleatorio() y public void compara()) y su código incluirlo en el cuerpo de la clase principal, aunque es mas facil hacer modificaciones y en general mantenimiento del programa si utilizamos los métodos (lo siento, creo que es la tercera vez que comento esta idea).
  • También hemos visto como declarar y utilizar variables aunque lo veremos con más detalle en el apartado 3.- Variables
  • Hasta donde he podido ver, para introducir datos por teclado y mostrar datos y resultados se utiliza:
    • En modo gráfico: La clase principal, es la clase que contiene todos los objetos que podemos ver en la pantalla y que forman el interface (jaLabel, jButton, jTextField... en general los de la ventana Palette). Estos objetos deben estar en la clase principal.
      • Podemos pasar variables de los métodos a la clase principal y de la clase principal a los métodos. Nada nuevo porque para eso sirven los métodos. Ojo: no podemos pasar valores de variables de la clase principal a la secundaria o viceversa porque con los métodos de clase la relacion que se establece entre clases es de clientela (para ello habria que crear una istancia de la clase secundaria, lo veremos en el punto siguiente).
      • Hasta donde ha podido ver no podemos pasar variables que contengan la definición de propiedades de un objeto, por ejemplo para cambiar el color del texto o del fondo de un jLabel en función de la respuesta que muestra. La definicion de propiedades en modo grafico deben hacerse en la clase principal
      • Los métodos y la clase principal también pueden mostrar resultados con la sentencia System.out.println("texto"+variable); en la ventana Output.
    • En modo texto: Tanto en la clase principal como en los métodos podemos poner la sentencia System.out.println("texto"+variable); y podremos ver la respuesta en la ventana Output.
    • Aún no lo diria de manera segura, pero parece que interesa que tanto cuando programamos en modo texto como en modo gráfico los datos se introduzcan y los resultados se muestren desde la clase con el método main. Mostrar resultados desde los métodos puede ser interesante mientras se programa la aplicación, luego mejor comentar líneas o eliminarlas.


2.2.2.- Métodos de instancia

2.2.2.1.- Introducción
En ejemplos anteriores he hecho referencia a ellos para notar sus diferencias con los métodos de clase.
Es necesario usarlos (ver nota) cuando tenemos que conectar código que está en dos clases, una será la clase principal (tiene el método main) y otra la clase secundaria (sin main) que es la que contiene los métodos que necesitamos usar y es la que tendremos que instanciar.

Notas:
  • Curioso, la clase principal también puede instanciarse, ver esta dirección: http://www.adrformacion.com/cursos/java/leccion2/tutorial9.html.
  • Curioso, también podemos usar métodos de clase para conectar dos clases, principal y secundaria sin instanciar la secundaria. No veo cuando será mejor utilizar una u otra forma.
  • Normalmente hablo de clase principal y una clase secundaria, pero desde la clase principal podemos instanciar objetos de cuantas clases secundarias necesitemos.
  • La clase secundaria puede instanciar tambien clases.
  • La clase secundaria no suele llevar código del método main, pero podría llevarlo. Sería entonces una clae ejecutable también. En realidad no interfiere para ser instanciada solo que:
    • Podriamos ejecutarla por separado mientras la estamos programando para probar su código.
    • Pero al ejecutar la aplicación desde la clase principal esta otra clase que también tiene el método main funcionaría como secundaria.

Podemos encontrarnos con varias posibilidades:
  • En un fichero con una clase principal que podemos instanciar (me parece muy rebuscado pero pondré un ejemplo en cuanto pueda)
  • En un fichero con dos clases, una para la clase principal, la que contiene el método main, y otra clase secundaria (sin main) que contenga los métodos.
  • En dos (o mas) ficheros uno para la clase principal y otro(s) con clases secundarias (sin main) con los métodos a ejecutar.
  • En módo texto y en modo gráfico
  • Interesante. Hasta donde he visto la declaración y la llamada a un método de instancia no se ve influida por donde está situada la clase secundaria (en el mismo fichero que la clase principal o en ficheros distintos), una vez que tenemos la instancia, los métodos se declaran e invocan de la misma manera.

Comparación entre métodos de clase y métodos de instancia
Métodos de clase
Métodos de instancia
Normalmente se utilizan dentro de la clase principal. Tambien pueden:
  • Utilizarse en dos o mas clases, principal y secundaria
  • En uno o mas ficheros
  • No es necesario realizar ninguna instancia de la clase secundaria
Se utilizan para conectar dos clases distintas
  • Una debe ser clase principal
  • La(s) otra(s) seran clases secundarias
  • Pueden estar en el mismo fichero o en ficheros distintos
  • La propia clase principal también puede instanciarse
Declaración:


  • Para declarar un método de clase necesitamos:
    • declarar el método
    • cuerpo del método
Declaración
  • Para declarar un metodo de instancia necesitamos instanciar la clase secundaria
  • La instancia de la clase secundaria se realiza en la clase principal
  • Para instanciar la clase secundaria necesitamos utilizar un constructor

  • Para declarar un método de instancia necesitamos:
    • declarar el metodo y parametros
    • cuerpo del metodo
      • Dentro del cuerpo usar return y el nombre de la variable que pasa el valor
Llamada o invocación a un método de clase
  • Si esta en la misma clase: metodo();
  • Si esta en otra clase: nombredelaclase.metodo();
Llamada o invocación a un método de instancia
  • Si está en la misma clase: nombredelainstancia.metodo();
  • Si esta en otra clase: nombredelaintancia.metodo();
  • Es decir en ambos casos se hace de la misma manera
Seguramente el esquema anterior no ayuda mucho pero en los siguientes ejemplos quedarán mas claros los conceptos de objeto, instancia y constructor, como declarar los métodos de instancia y como realizar su invocación.

2.2.2.2.- Declaración y llamada de métodos de instancia
Como hemos comentado mas arriba la declaración y la llamada a un método de instancia no se ve influida por donde está situada la clase secundaria (en el mismo fichero que la clase principal o en ficheros distintos), una vez que tenemos la instancia de la clase los métodos de instancia se declaran e invocan de la misma manera.

Estamos aqui:
nb71-18.gif

Usaremos el fichero FicheroDosClases2.java:
Este es el primer ejemplo de un método de instancia. Esta realizado con dos clases en un mismo fichero y en modo texto. Una clase hace de principal, tiene el método main, la otra hace de secundaria, no tiene método main, pero tiene el método que vamos a instanciar.
Esta es la captura de su código:
nb71-17.gif

Es un ejemplo muy interesante, bueno, en realidad todos los métodos de instancia funcionan de la misma manera como luego veremos en los siguientes ejemplos.

a)Previo
Para poder utilizar un método de instancia necesitamos un constructor. Un constructor es un método especial que crea la instancia de un objeto de la clase en que se encuentra el método que queremos utilizar, será entonces un método de instancia.

Este es el código del constructor "ClaseSecundaria2 mensaje = new ClaseSecundaria2();"

Cuando ejecutamos el programa este código instancia un objeto de la clase "ClaseSecundaria". Podemos decir que la "ClaseSecundaria" es como una plantilla y el objeto instanciado de la clase "ClaseSecundaria", a la que hemos dado el nombre "mensaje" es como una copia de esa plantilla, tiene sus métodos, variables y demás elementos que tenía la clase el original. Como la clase ha sido instanciada el (los) método(s) que tiene dentro son métodos de instancia.

b) Declaración del método de instancia
Necesitamos:
  • Declarar el método y parámetros
  • Cuerpo del método
    • Dentro del cuerpo usar return y el nombre de la variable que pasa el valor a la clase principal

Esta es la captura del código del método de instancia que también podiamos ver en la captura anterior:
nb71-19.gif
Vemos
  • La declaración del método con un parámetro: public String imprimir(String prueba) {}
    • El parámetro es "String prueba". Declara el tipo de variable y el nombre de la variable
    • Esta variable tomará un valor en el tratamiento de datos que se hace en el cuerpo del método de instancia.
    • Un parámetro puede declarar más variables, cada una con su tipo.
    • Los tipos pueden ser int, double, String... En general cualquier otro tipo que sirva para indicar cual es el tipo de la variable que estamos usando.
    • En el mismo argumento pueden ir variables con distintos tipos.
  • El cuerpo del método. Lo he marcado en azul en la captura. Vemos como:
    • El nombre de la variable debe ser igual en el argumento y en el retorno de la variable, "return prueba".
    • En este caso la variable 'prueba' devuelve un String que es la suma de las dos variables de tipo String definidas en el cuerpo del método.
    • En este package hay además otros dos ficheros de ejemplo que muestran variaciones de código en el método y obtienen el mismo resultado.

c) Llamada al método de instancia:
La llamada al método de instancia, en este caso, está en la clase principal (puede haber clases secundarias que necesiten instanciar otra clase entonces también tendrán una llamada a su instania). Es esta línea, "texto=mensaje.imprimir(texto);". En realidad la invocación es este trozo: mensaje.imprimir(texto);" que recibe el valor de una variable del método de instancia.

Vemos:
  • La variable "texto":
    • Es la que guarda el valor recibido, a través del return, del método de instancia.
    • Es del mismo tipo que la declarada en el método de instancia: String
    • Hasta donde he podido ver el nombre distinto de la variable no impide el buen funcionamiento, en realidad lo que hace el método de instancia es enviar un valor a la clase principal que es recibido por la variable que se encuentre en la invocacion o llamada al método.
    • Hasta donde he visto usar el mismo nombre de variable, la recibida de return y la que guardara el valor recibido no interfiere en el funcionamiento del programa.
  • El operador =
    • Asigna a la variable 'texto" el valor que recibe de la llamada realizada al método de instancia.
  • El nombre de la instancia 'mensaje'
    • Es el nombre que hemos dado al objeto instanciado. Funciona como una variable que contiene la instancia de la clase (sus metodos, variables y demás componentes que pudiera tener, ye hemos dicho que es una copia de la clase secundaria).
    • Indica cual es la instancia de la clase secundaria que debe buscar
    • En ejercicios mas complejos puede haber mas instancias de clases secundarias. Con el nombre de la instancia indicamos la ruta de busqueda.
    • El nombre de la instancia lo pone el programador (no es una palabra reservada, un comando o nada parecido, es solo un nombre que suele hacer referencia a la tarea que hace dentro de la aplicación para identificarla .
  • 'imprimir'
    • Es el método de instancia "public static void imprimir" que ahora está en el objeto instanciado.
    • mensaje.imprimir() es la ruta para llegar al método que está en la instancia.
  • 'texto'
    • Es una variable. Se ha definido dentro de la clase principal como de tipo String para que pueda recibir valores tipo Struing que es el mismo tipo que devuelve el método de instancia a través de return.




Instancias

2.2.2.4.- Instancias y constructores
Hemos hablado de manera resumida de:
    • Objetos
    • Instancias
    • Constructores
Estos conceptos están interrelacionados, así que no podemos hablar de uno sin nombrar a los demás. A continuación trato de ampliarlo y veremos algunos ejemplos.

a) Objetos:
En informática los objetos son encapsulación de datos. La encapsulación permite que la interacción con el objeto se realice a través de los métodos del objeto y sus variables. El objeto instanciado de una clase no es la clase original, es como una copia de la plantilla/clase original que además podemos instanciar mas veces dándoles nombres distintos.

Un objeto tiene:
  • Tiempo de vida: Se crea cuando se ejecuta el constructor de la instancia, dejan de existir por la intervención del "recogedor de basura" (garbage collector) que los destruye o al salir de la aplicación. La mayoría de los objetos sólo existen durante una parte de la ejecución del programa.
  • Estado: Todo objeto posee un estado, definido por sus atributos (variables en la clase original).
  • Comportamiento: Está definido por sus métodos, para que el resto de objetos que componen los programas puedan interactuar con él.

Un objeto representa a una clase donde hemos situado código que realiza una tarea que necesitamos para nuestra aplicación. Desde la clase principal podemos hacer llamadas al objeto y:
  • Disponer de sus variables (atributos) para pasarle desde la clase principal los valores que nos interesen para que sean tratadas en sus métodosy devolvernos el resultado (a la clase principal).
  • Utilizar sus métodos para las tareas en que estén definidos en el objeto.
  • Básicamente, interpreto, es como incorporar el código del objeto a la clase principal. Se entiende que ese objeto sirve para realizar las tareas para las que le hemos llamado. La llamada al método instanciado se realiza desde la clase principal, ejecuta el método instanciado y las tareas que se encuentren en él. Cuando acaba vuelve a la siguiente línea del punto de partida (la llamada al método) de la clase principal.

En java hay muchas clases que podemos convertir en objetos instanciados de una clase:
  • Clases creadas por nosotros: Como las clases que hemos creado hasta ahora en esta página o mejor como el ejercicio que hemos visto en el apartado "2.2.2.2.- Declaración y llamada de métodos de instancia". También las utilizaremos en los ejemplos que encontraremos mas abajo (punto =========== =========)
  • Clases de la API de java: Pueden importarse las clases que necesitemos. Por ejemplo, cuando utilizamos este código "import javax swing.*" lo que hacemos es cargar el paquete "javax.swing" que proporciona una colección de clases con las que podemos crear objetos (con sus variables -contenido- y métodos -comportamiento-) para utilizarlos en nuestra aplicación. Con las clases de "import javax swing.*" podemos crear objetos como JPanel,JFrame, JButton, JLabel...
    • Nota: Creando estos objetos con la ventana Palette de NetBean automáticamente se añade el código de los constructores de la instancia. En modo gráfico, con NetBeans, podemos crear cuantos objetos repetidos de un objeto necesitemos, el código de cada objeto, el objeto y el constructor de la instancia de cada uno se añade automáticamente. En modo gráfico utilizando solo código, podemos hacer lo mismo que en NetBeans, tenemos que añadir el constructor a mano y podemos instanciar la misma clase cuantas veces necesitemos simplemente usando un nombre distinto en el constructor. Ejemplo:
      • JPanel paneluno = new JPanel
      • JPanel paneldos = new JPanel
      • JLabel etiquetanueva = new JLabel
      • JLabel etiquetvieja = new JLabel

  • Puede verse un esquema interesante sobre las clases de la API en: http://www.polinux.upv.es/drupal/files/charlaSwing.pdf , página 4.
  • En esta captura se crea un jFrame (es un ejemplo que ya hemos visto en el punto 1.2.2.- Clase02ModoTexto.java: crea de un Frame utilizando código):
  • nb7-84b.gif
  • Observamos:
      • El código crea una aplicación gráfica en modo texto
      • Se ha importado las clases JFrame: "import javax.swing.JFrame;"
      • Dentro de la clase main tenemos (añadidos "a mano"):
        • un constructor para crear la instancia del objeto JFrame, de nombre MiVentana
        • una sentencia para hacerlo visible
        • Una sentencia para darle tamaño
  • Caso interesante el paquete de las clases de Math. Ya hemos usado esta clase como en este código que genera un número aleatorio para el juego Adivina mi número, fichero "Clase04AdivinaMiNumero1.java":
  • nb7-93.gif
  • La clase Math del paquete java.lang contiene la librería matemática de Java. Math es una clase con métodos. En realidad los métodos de Math son funciones matemáticas iguales a las que poseen otros lenguajes. Pero su funcionamiento es peculiar:
    • El constructor de la clase es privado, por los que no se pueden crear instancias de la clase. Entonces no es necesario utilizar código de un constructor para crearlas. Esto ocurre porque Math es:
      • public para que se pueda llamar desde cualquier sitio
      • y static para que no haya que inicializarla.
    • Francamente no entiendo bien esta explicación. Lo que debe quedar claro es que podemos utilizar las funciones de la clase Math sin necesidad de crear una instancia, y que en consecuencia tampoco necesitan código para el constructor de la instancia.
    • La clase Thread, del mismo paquete java.lang cuenta con varios: uno que se emplea para retardar la ejecución de código es “void sleep(long retardo)” (interesante).

Dirección interesante:

b) Instancia:
Instanciar una clase es crear un objeto de esa clase. El objeto instanciado de una clase no existe hasta que no se ejecuta la aplicación, entonces el código del constructor lo crea. La instancia desaparece cuando termina la ejecución del programa.

Lo normal es que la clase a instanciar sea una clase que no tiene main y el código de su/sus métodos sirva para realizar una tarea que necesitamos desde la clase principal: le entreguemos unos datos (variables), él o los métodos que contiene hacen el tratamiento de esos datos y nos devuelve el resultado a la clase principal que es donde se muestran en modo texto o gráfico.

Podemos crear más instancias añadiendo nuevos constructores. Usamos el mismo código del constructor pero en lugar de "mensaje" le damos otro nombre y lo lanzamos de la misma manera con el nuevo nombre.

Las instancias de una clase lo que crea son objetos con las caracteristicas de la clase instanciada. Podemos considerar la clase como una plantilla y los objetos como copias de ella.

El objeto que se crea tiene los atributos y métodos de la clase a la que pertenece.

Los objetos y sus características se usan en la construcción de programas, ya sea como contenedores de datos o como partes funcionales del programa.


c) Constructor
El constructor es un método especial que crea un objeto de la clase desde donde es llamado. Se les utiliza para inicializar las variables de la instancia (la 'copia' de la clase instanciada, el nombre dado a una instancia suele asignarsele la idea de que es una variable que contiene la copia de la instancia). Se declara en la clase principal, en él indicamos cual es la clase secundaria que queremos instanciar.

Declaración del método constructor
Lo identificamos por su código. Hay dos formas completamente equivalentes de expresar el código de un constructor:

Forma 1:Esta forma se usa menos, aunque en ejemplos códigos en modo texto pueden aparecer:

ClaseSecundaria mensaje
mensaje = new ClaseSecundaria();

  • Declaración de una variable: ClaseSecundaria mensaje
    • Nombre de la clase: ClaseSecundaria
    • Nombre del objeto instanciado: mensaje
  • Declaración del objeto y reservar espacio en memoria: mensaje = new ClaseSecundaria();
    • Utilizamos el objeto declarado: mensaje
    • operador new y de nuevo el nombre de la clase secundaria
    • y queda creado el constructor

Forma 2: esta es la que encontraremos normalmente:
ClaseSecundaria mensaje = new ClaseSecundaria();

Con este código, el constructor, podemos generar objetos que son instancias de clases. Podemos instanciar distintos objetos de una misma clase cambiandole el nombre. Interesante que el objeto empieza a existir cuando
ejecutamos la aplicación que es cuando se ejecuta el código del método constructor.

Esta invocación es implícita y se realiza automáticamente cuando se utiliza el operador new. Los constructores tienen algunas características especiales:
El constructor no es un miembro más de una clase. Sólo es invocado cuando se crea el objeto (con el operador new). No puede invocarse explicitamente en ningún otro momento.

Analizamos este código:
  • Se coloca en la clase principal, que es a que usará los métodos instanciados. Tambien puede colocarse en una clase secundaria si es instanciada desde la clase principal y va a utilizar métodos de otra clase secundaria.
  • ClaseSecundaria: Este es el nombre de la clase que queremos instanciar. Es una característica de este tipo de métodos: llevan el mismo nombre que la clase que queremos instanciar.
  • mensaje: es el nombre que hemos dado al objeto, podemos usar nombres que sea fácil asociar con la tarea que queremos realizar. Podemos considerarlo como una "variable" que almacenará el objeto (sus variables y métodos). Si necesitamos más instancias de la misma clase usaremos el mismo código pero le ponemos un nombre distinto.
  • = Es el operador que adjudica el contenido de la clase al objeto.
  • new: Es un operador que tiene varias características:
    • Se encuentra presente siempre que creamos una instancia de una clase.
    • Reserva menoria y devuelve una referencia (dirección) al objeto creado que permite localizar en la memoria al objeto creado. La dirección puede ser asignada a una variable que tenga el tipo apropiado.
      • Los atributos que contiene el objeto según se han definido en la clase. Un atributo en realidad es una variable, solo que en los objetos instanciados se denominan atributos.
      • Un constructor puede incluir parámetros. Los parámetros (las variables de la clase). Irian aquí ClaseSecundaria mensaje = new ClaseSecundaria(parámetros o variables de la clase); ??? pendiente de verificar, no confundir con los parametros de la sobrecarga de metodos) El constructor puede recibir cualquier número de argumentos parametros y de cualquier tipo, como cualquier otro método ??? ver como se entiende esa afirmación con algun ejemplo.
  • ClaseSecundaria(); nuevamente el nombre de la clase que queremos instanciar
  • El constructor no devuelve ningún valor (en su declaración no se declara ni siquiera void).
  • Las variables (atributos) de instancia deben ser siempre privadas para que no puedan accederse fuera de la clase.
  • Un constructor sólo puede ser llamado por otros constructores. Super y this tienen algo que ver, ampliaré mas adelante.
Notas:
  • Los tres conceptos (objeto, instancia, constructor) están relacionados. Separarlos es por organización pero para explicarlos verás que están presentes los tres conceptos.
  • Como verás, hacer objetos de instancias de clase y usar constructores,no es algo excepcional en java, sino totalmente cotidiano en la realización de aplicaciones.
  • Para ampliar o verificar información, aclarar dudas, ver nuevas formas de usarlos, etc. puedes buscar información a través de algún buscador.


Ejemplos instancias

2.2.2.4.- Ejemplos de clases instanciadas y metodos de instancia
En la aplicación "ClasesMetodosInstancias" hay ejemplos de ficheros que utilizan clases instanciadas. Y por supuesto de métodos de instancia. En esta captura vemos el contenido de la aplicación. Son varios packages, los enmarcados en rojo:

Nota:
Actualizar la captura
nb7-91d.gif
es antigua

En ella vemos los ficheros que encontraremos en cada package y que explicamos en esta página en los siguientes apartados. También hemos dispuesto enlaces a páginas de este mismo sitio con ejemplos interesantes donde podremos ver capturas de código y explicación de los detalles más importantes de aplicaciones con clases, métodos, objetos, constructores, instancias, declaracion de variables, etc:

2.2.2.4.1.- Ejemplos Package "cInstancias1Ejemplo"
2.2.2.4.1.1.- "FicheroDosClases1.java" ejemplo de instancia muy básico pero interesante.
2.2.2.4.1.2.- "FicheroDosClases2.java" modo texto (Lo hemos explicado en el punto "2.2.2.2.-").
2.2.2.4.1.3.- "FicheroDosClases2.java" Variante del ejemplo 2.2.2.2

Nota:
  • El fichero "FicheroDosClases2.java" lo hemos explicado en el punto "2.2.2.2.- Declaración y llamada de métodos de instancia" con dos clases en un mismo fichero.
  • También contiene otros dos ficheros que con ligeras diferencias obtiene el mismo resultado, puede ser interesante para conocer otras formas de utilizar código.Son ejemplos muy sencillos que pueden verse en la descarga del final de la página.

2.2.2.4.2.- Ejemplos del package "cInstancias2Suma", añadir argumentos

Package cInstancias2Suma Añadir argumentos
Estamos aqui:
nb71-20.gif
En realidad son dos ejercicios que comparte la misma clase instanciada. Interesante porque puede ayudar a conocer sobre las variables de los argumentos.
  • Hay una clase principal en modo texto y otra en modo gráfico
  • Ambas realizan una instancia de la clase secundaria que contendrá los métodos instanciados.
  • También es interesante hacer pruebas con el código para añadir arfumentos al metodo instanciado.
    • He comentado líneas que añaden un argumento mas para que recoja el valor de la variable "suma" que contiene la suma de los dos sumandos. Como verás los dos sumandos se devuelven a la clase principal a traves de "return (sumando1 + sumando2);". Si comentas líneas y descomentas otras podrás hacer que devuelva asi: "return (suma);"
    • Esto puede ayudar e entender mejor como funcionan los argmentos y a crearlos para nuestras aplicaciones.
    • En las capturas verás marcas de colores (azules= comentar, verdes= descomentar) que te ayudaran. Tranquilo porque apenas cambies algo en un fichero saldrán errores en los otros dos, pero desaparecen cuando los tres esten cambiados correctamente.

2.2.2.4.2.2.- El fichero "MainTexto.java"
Esta es su captura:
nb71-21.gif
Vemos:
La clase en modo texto "MainTexto" tiene dos instancias:
  • Una a la clase"BufferedReader2 de la API de java que permite introducir datos por el teclado. Su declaracion es peculiar y estoy buscando mas información acerca de ella.
  • Otra que instancia la clase secundaria "RealizaSuma" .
  • Tambien vemos la llamada a la instancia de la clase de ambos métodos donde vemos un argumento con dos variables
  • Y la ventana Output con los datos de salida.

2.2.2.4.2.1.- El fichero "MainGrafico.java"
Esta es la captura de parte de su código:
nb71-22.gif
Vemos el constructor de la instancia de la clase secundaria. Observa que:
  • En la clase MainTexto el nombre del objeto instanciado era "objeto"
  • En la clase MainGrafico el nombre del objeto instanciado es "resultado"
  • En realidad el nombre podria ser cualquier otro, solo que habría que usarlo en las llamadas de cada clase.
  • Lo destaco porque si ponemos el mismo nombre a los dos objetos instanciados daría error. No se pueden crear en una aplicación objetos instanciados con el mismo nombre.

Y esta es otra captura con el código del botón que hay que pulsar para que nos de el resultado:
nb71-23.gif
Vemos:
  • Carga las variables sumandoA y sumandoB desde jTextField
  • Como son variables de tipo String hay que convertirlas a enteros, int.
  • try evalúa si la conversión se realiza bien, es decir si los caracteres introducidos son números. Si son caracteres se produce un error, try evita que se interrumpa el funcionamiento del programa y pasa el control a catch
  • catch detecta que hay datos introducidos que son caracteres alfabéticos, avisa del error, borra los datos introducidos en jTextField y espera a que introduzcamos otros correctamente.
  • Vemos que hay dos llamadas (exactamente iguales) a la clase instanciada.
    • Una imprimira en la ventana otput el resultado
    • Otra en jLabel3 en el frame.

Esta es la ventana de salida en modo gráfico (al pulsar el botón se muestra el resultado y se borran los jTextField):
nb71-24.gif

2.2.2.4.2.3.- El fichero "RealizaSuma.java"
Este fichero tiene la clase que hay que instanciar, esta es su captura:
nb71-25.gif

  • Recuerda que comentando unas lineas y descomentando otras puedes hacer que la variable 'suma' se añada a los argumentos del metodo de instancia "suma".
  • O cambiar el nombre a las variables del argumento
  • Borrar alguna variable o añadir más
  • Viendo como la aplicación se comporta ante cada cambio ayuda a entender mejor como funcionan las variables del argumento.

2.2.2.4.3.- Ejemplos del package "cInstancias3Multiplicacion".
También contiene dos ejercicios. Interesante porque dos ficheros con clase principal y método main (uno en modo texto y otro en modo gráfico) comparten el fichero con la clase instanciada que contiene los métodos.

Estamos aqui:
nb7-91e.gif

2.2.2.4.3.1.- El fichero "MultiplicacionMain.java", Clase principal en modo texto
Este fichero es el que contiene la clase principal en modo texto.
  • Contiene también una instancia de la clase secundaria "MultiplicacionMetodo"
  • Luego veremos que esta clase secundaria también es instanciada por la clase "MultiplicacionJFrame" que esta realizada en modo gráfico

Esta es la captura de su listado:
nb71-08.gif

Vemos:
  • El nombre del paquete (package), "cInstancias3Multiplicacion"
  • La clase principal
  • El método main, que hace que la clase sea ejecutable.
  • He marcado el codigo del método constructor "MultiplicacionMetodo generaRND= new MultiplicacionMetodo();" de la clase del fichero que contiene los métodos (MultiplicacionMetodo();) .Para acceder a ella buscando el valor de las variables utilizaremos el nombre de la instancia creada: 'generaRND'
  • El constructor de la instancia está dentro del método main, en modo texto parece que es el lugar adecuado. Luego veremos que en modo gráfico la disposición del código varia
  • En este caso las variables de la clase secundaria guardan el valor que se genera en cada método y lo devuelven a la variable correspondiente de la clase principal, de acuerdo a la invocación de cada método que hacemos desde la clase principal. En este caso las lineas 8, 9, 10 que nos devuelven el valor del multiplicando, multiplicador y producto. En ellas vemos la llamada o invocación a cada uno de los métodos usando el nombre de la instancia "generaRND", punto y nombre del método correspondiente. También el código print para mostrar los valores obtenidos con cada invocación en la ventana Output.
  • Observa que se imprime directamente el valor obtenido en la invocacion de cada método. También podría adjudicarse a una variable la invocación de manera que utilizariamos esa variable para mostrar el resultado. Algo asi yas lo hemos visto en ???????????
  • Observa que los datos se muestran en la clase principal. Aunque también podrian mostrarse desde el método instanciado de la clase secundaria.
  • Esta es la clase que hay que ejecutar, llamará a la clase de los métodos a través de la instancia que hemos creado.
  • La salida de datos en la ventana Output.


2.2.2.4.3.2.- El fichero "MultiplicaciónMetodo.java", Clase secundaria, interesante, posee una instancia de la API

Esta es la captura del segundo fichero "MultiplicaciónMetodo" que cotiene la clase secundaria que hemos instanciado:
nb71-09.gif

Entiendo que este método es muy interesante porque reune cosas que hemos visto anteriormente por separado:
  • Recibe a través de un argumento un valor de la clase principal:
    • en realidad lo recibe de la clase principal realizada en modo gráfico que veremos a continuación. Lo guarda en la variable "digitos".
    • No recibe argumento de la clase principal realizada en modo texto, toma el valor por defecto de "multiplicando = (int) (rnd.nextDouble() * 10.0);"
  • Devuelve a la clase principal los valores generados aleatoriamente para las variables multiplicando y multiplicador de la clase secundaria.
  • Dentro de la clase secundaria hay un constructor de una clase de la API "Random rnd = new Random();" (esto es nuevo, habiamos visto algo similar pero en la clase principal en el fichero MainTexto.java del package anterior). Muy interesante.
    • Esta es una clase secundaria
    • Importa la clase Random: import java.util.Random; que pertenece a la API de java
    • Interesante de nuevo: posee un constructor "Random rnd = new Random();" para realizar una instancia de la clase Randon. El nombre del objeto creado, instancia de la clase Random se llama "rnd" (podría darsele cualquier otro nombre que pudiera interesar al programador) y sirve para generar números aleatorios desde las unidades a los millares según la variable "digitos".
    • Vemos que llamamos a la instancia como hemos visto en otras ocasiones: rnd.nextDouble() nombre de la instancia, punto y metodo ("nextDouble" es un método de la clase Random de la API de java).
  • Vemos:
    • El metodo "public int digitosn(int leoDigitos){" lleva un argumento.
      • En modo texto no se recibe ningún dato. Se ejecuta la línea "multiplicando = (int) (rnd.nextDouble() * 10.0);" que genera por defecto números de un dígito, del 1 al 9. Podemos retocar esta línea para que por defecto genere números desde las unidades hasta los millares (o más grandes si queremos probarlo).
      • En modo gráfico le permite recibir un dato de la clase principal, el que selecionamos desde el menu. En este caso es un número del 1 al 4 que sirve para indicar al objerto instanciado "rnd" si el número generado tendrá hasta las unidades, decenas, centenas o millares.
    • Interesante:
      • Aunque utiliza return, para devolver un valor, en realidad no ha hecho ningún cálculo con el dato recibido, asi que devuelve el mismo número.
      • Como en la clase principal no lo necesitamos no hay código para recogerlo, asi que es un return "perdido", pero hay que ponerlo, si no da error.
      • Pero ha ayudado a generar el correspondiente multiplicando con desde 1 a 4 digitos según la condicion if.
  • Y también vemos:
    • El multiplicando, multiplicador y producto no han recibido ningún valor de la clase principal, la verdad es que no lo necesitan pues el valor de esas variables se genera de manera aleatoria en sus correspondientes métodos de instancia de la clase secundaria,
    • También utilizan return para devolver el dato pero ahora devuelven el valor que han adquirido cada variable en su correspondiente método a la clase principal (de donde han sido invocados) y lo muestran en la pantalla en modo texto (y en modo gráfico como veremos en el ejemplo siguiente).
    • Dos métodos multiplicandom() y multiplicadorm() que generan un número aleatorio y lo devuelven a la clase principal (return).
    • Observa el método multiplicandom().
      • Dentro está la línea 17 "multiplicando = (int) (rnd.nextDouble() * 10.0); por defecto genera un número de solo un dígito al ejecutar el fichero, es la linea que se ejecuta siempre cuando los métodos son invocados por la clase en modo texto "MultiplicacionMain" (vaya, ya lo habia comentado antes).
      • Su esta clase es instanciada e invocada por la clase principal en modo gráfico "MultiplicacionJFrame" genera un número según el valor que le indiquemos el menú y, según la condición if de las líneas 18 a 21:
        • 1 dígito genera hasta las unidades
        • 2 dígitos hasta las decenas
        • 3 dígitos hasta las centenas
        • 4 dígitos hasta las unidades de millar.
        • Podrian añadirse decenas de millar, centenas de millar...
    • Un método que proporciona el producto previa multiplicación del multiplicando y multiplicador
    • El resultado en modo texto que se imprime desde la clase principal (Output). En modo grafico se veria en la pantalla del frame
    • Así mismo podría ponerse una condición para evitar mostrar en las:
      • unidades, evite el 0
      • decenas, evite números del 0 al 9
      • centenas, evite números del 0 al 99
      • millares, evite números del 0 al 999.
      • Y evitar la aparición del '0' en el multiplicador.

Probarlo es la mejor manera de ver su funcionamiento. Puedes descargarlo al final de la página en Descargas

2.2.2.4.3.4.- El fichero "MultiplicacionJFrame.java". Clase en modo gráfico
Ahora veremos el fichero con la clase principal en modo gráfico que crea su propia instancia de la clase secundaria que se encuentra en el fichero MultiplicacionMetodo.java (la misma usada en el ejemplo anterior, por cierto que no pueden tener el mismo nombre si ejecutamos conjuntamente ambas clases principales).

Utilizando NetBeans crearé un fichero con un jFrame con una clase y el preceptivo método main para hacerlo en modo gráfico (ver el punto "23.- Crear proyecto, package y ficheros para una aplicación NetBeans" de la página 04.5.- Como hacer... donde se da información sobre como crear proyectos y ficheros en NetBeans).

Al jFrame le añadiré un menú de cuatro opciones. Utilizaré el mismo fichero que ya tiene la la clase secundaria donde están los métodos (ver captura, he marcado en azul los dos ficheros que usaré ahora).

En las dos capturas siguientes podemos ver los cambios realizados en el listado y una captura del aspecto que tiene el resultado:
nb71-07.gif

Vemos:
  • Sobre el constructor "MultiplicacionMetodo generaRND = new MultiplicacionMetodo();.crea un objeto de la clase secundaria que he llamado "generaRND" , es el mismo nombre que usé para la instancia en modo texto. En realidad podría darse otro nombre a gusto del programador. En principio parece que no interfiere si ejecutamos las clases principales al mismo tiempo.
  • La declaración del constructor y las variables no se hace ahora dentro del metodo main.
  • Hay un método nuevo que se genera por defecto "public MultiplicacionJFrame()" dentro de él he colocado la llamada al método "leerNumeros();" que está en la misma clase.
  • También hay tres llamadas a métodos que están en la clase secundaria y devuelven el valor generado/calculado de las variables. Vemos que la llamada contiene el nombre de la instancia y el del método correspondiente de la clase secundaria. Ya hemos explicado sobre esto en anteriores ejercicios.

Esta captura es continuación de la anterior, vemos el código que he añadido para el caso de seleccionar cada opción del menu.
nb71-10.gif

Lo que vemos es el código para las cuatro opciones que he creado en el menu.
Cada opcion:
  • Envía a la instancia de la clase secundaria un número con el código "generaRND.digitosn(2);" en este caso el 2.
  • El número es adjudicado a la variable dígitos del método "public int digitosn(int leoDigitos){"
  • Una vez recibido ese número sirve para que la clase secundaria en su método "multiplicandom()" sepa cuantos digitos debe tener el número aleatorio que genera el multiplicando.
  • Después llama al metodo "leerNumeros();" donde recibe los números generados aleatoriamente y su producto y los muestra en el jFrame.

Este es el resultado según el número de dígitos que hemos seleccionado en el multiplicando:
Metodos09.gif

Notas:
  • La clase secundaria ya la hemos explicado más arriba para la clase principal en modo texto.
  • Esta aplicación no es para realizar actividades de multiplicaciones. Sirve como ejemplo de uso de métodos, variables y clases. En este caso cuando utilizamos dos ficheros, uno con la clase principal y otro con una clase secundaria con los métodos de instancia.
  • Interesante porque así podemos reutilizar código de la clase de los métodos o en general para solucionar un problema similar de cualquier otra aplicación.

En este caso:
  • La aplicación se llama-->cInstancias3Multiplicacion;
  • El fichero con la clase main en modo texto se llama--> MultiplicacionMain.java
  • El fichero con la clase main en modo gráfico se llama-->MultiplicacionJFrame.java
  • El fichero que contiene la clase de los métodos se llama-->MultiplicacionMetodo.java, es una clase que es instanciada por cada uno de los ficheros con clase principal. Interesante porque pueden funcionar los dos a la vez ya que cada fichero principal ha creado su propia instancia de clase con sus métodos de instancia, asi que acceden a la instancia de la clase secundaria que cada uno a creado para generar los números alatorios.

2.2.2.4.4.- Ejemplos del Package cInstancias4Ejemplos1.
Estamos aquí:
nb71-11.gif
2.2.2.4.4.1.- El fichero "cArgumentos1Texto.java".
Es un solo fichero, contiene dos clases, la llamada al método y el método utilizan argumentos para comunicar los valores de sus variables.

Muy interesante.Contiene
  • Una instancia de una clase de la API de java
  • Una instancia de una clase secundaria, clase primaria y secundaria en un mismo fichero
  • Ejemplo de uso de argumentos en un método y en su invocación
  • Uso de variables de tipo String e int en agumentos de un metodo
  • Ejemplo de uso de If

Ya hemos visto ejercicios que utilizan argumentos en sus métodos. Aquí lo destaco como un ejercicio para hacer pruebas acerca de los argumentos de métodos y su invocación desde la clase principal. Creo que "jugar" con él, hacer pruebas, cambiar nombres a variables, cambiar el tipo de las variables... puede ayudar a entender como funcionan los métodos con argumentos .

Esta es parte de la captura del código:
nb71-12.gif
Vemos:
  • El nombre del package
  • Hemos importado una clase de la API de java (Scanner)
  • La clase principal y dentro el método main con:
    • Declaración de dos constructores
      • Uno instancia la clase de la API de java importada
      • Otro para instanciar la clase secundaria.
    • Vemos líneas de código que indican el dato que necesitan y luego el código que permite introducir el dato, vemos que para ello se usa la instancia de la clase Scanner de la API de java. Puede aceptar distintos tipos de declaración de variables. No me extiendo más porque con un buscador es fácil ampliar información sobre esta API y sus métodos.
  • La invocación con argumentos al método de la clase secundaria.
  • Las variables se declaran donde se van a usar. Interesante que se declaran junto a su tipo. Como ejemplo es válido, pero es mejor declarar los tipos y las variables todas juntas al principio de la clase.
  • Vemos la línea de declaración de los argumentos del método instanciado, su tipo se incluye por imperativo de programación. Vemos que las variables deben conservar el orden tanto en la invocación como en el método aunque el nombre puede cambiar o ser completamente distinto.

Básicamente la clase principal sirve para introducir datos:
  • Si queremos calcular la superficie de un triángulo o un rectángulo
  • La base y la altura

Esta es la captura de la clase secundaria:
nb71-13.gif
Interesante:
a) Sobre los argumentos
  • En la clase principal las variables y su tipo se declaran en el listado. En la llamada a la clase secundaria, en su argumento, solo se escribe el nombre de las variables. En cambio en los argumentos del método de instancia debe declararse el tipo junto al nombre de la variable (imperativo de programación)
  • El orden de colocacion de las variables en el argumento de la llamada y del metodo de instanca debe ser el mismo

b) Sobre el tipo de las variables
  • Hasta donde he podido ver el método puede devolver con return solo el valor de una variable o el valor del resultado de una operación con variables.
  • En el argumento puede haber variables de cualquier tipo, he probado con int, String y double, supongo que con los demás tipos también se podrá.
  • Pero con return solo puedo devolver el contenido de una variable. Esto significa que:
    • Hay que indicar en la declaración del metódo el tipo de variable que devolverá. En el codigo usado en el ejemplo hemos declarado que la variable a devolver sera de tipo int: "public int calcularSuma(int baseM, int alturaM, String textoM, int superficieM) {" , en este caso he seleccionado que devuelva la variable "superficieM" (return superficieM;) que es la que necesito para mostrar el resultado del cálculo en la clase principal. Pero podría pedir que devolviera otra variable cualquiera de tipo int. Si en la declaracion del método de instancia indicamos double, String... solo podra devolver la variable que indiquemos y que tenga el tipo declarado.
    • Ha hecho pruebas y puede devolver cualquiera de las variables declaradas en el argumento.
    • Pero lo que interesa es devolver aquella variable que es el resultado de un cálculo o una respuesta realizado dentro del método de instancia.
c) Sobre la clase donde mostrar los resulados:
  • Hemos indicado en ejercicios anteriores que los resultados obtenidos y los valores de las variables deben mostrarse en la clase principal. Aquí vemos que las variables introducidas por el teclado se muestran en el método de instancia y el valor de los cálculos realizados se devuelve a la clase pincipal donde se imprime.
  • En mi opinión es mejor mostrar el contenido de las variables y la respuesta relevantes del ejercicio en la clase principal, cosa que también podría hacerse en este caso.

d) Sobre el bucle if
  • Por teclado nos pide que escribamos o "triangulo" o "rectangulo". Esto sirve para que
    • El primer if compruebe si hemos escrito "triangulo",
    • si no hemos escrito triangulo el segundo if comprueba si hemos escrito "rectangulo"
    • y si no es asi, la sentencia else hace que se muestre un mensaje indicando que debemos de escribir una de las dos palabras y no realiza ningún cálculo.
  • En caso de que hayamos escrito correctamente una de las palabras realiza el cálculo y llega hasta la línea de "return superficieM" que devuelve su valor a la clase principal.
  • Interesante la función (método) equals que sirve para comparar dos string ( he probado con el operador == y no salía, se encuantra información sobre ella facilmente en internet).
e) Es mejor "jugar" un rato con este código cambiando en los argumentos los nombres de variables, sus tipos, borrando o añadiendo alguna, realizar cálculos de nuevas figuras geométricas, etc. Conocer bien como funcionan los variables y sus tipos en los argumentos de los métodos de instancia y en su invocación ayudará a entender mejor los métodos sobrecargados.

2.2.2.4.4.2.- El fichero "Principal.java", Dos clases, llamada a clase principal y secundaria
No pongo captura en un ejercicio muy sencillo que puede probarse bajandolo al final de la página en Descargas

Mas instancias
2.2.2.4.5.- Ejemplos del package "cInstancias5Calculo". Calcula la seperficie de figuras geométricas
Con lo que hemos visto hasta ahora sobre métodos de instancia creo que se puede tener una idea clara de como crearlos y utilizarlos.
Pero me ha parecido interesante nuevos ejemplos con cosas nuevas. En este caso lo que encuentro interesante es:
  • Utilizamos variables de tipo double
  • El valor de una variable de la clase principal puede ser enviado al método de instancia a través de los argumentos de su llamada para utilizarlo en realizar cálculos cuyo resultado será devuelto a la clase principal.
  • Volvemos a ver mas ejemplos de argumentos de métodos de instancia.

Estamos aquí:
nb71-27.gif

2.2.2.4.5.1.- El fichero "CalculoMain.java", Clase principal, calcula el área de algunas figuras geométricas
Esta es la captura del código de la clase principal:
nb71-04.gif
Observamos las variables:
  • Todas estan definidas a double para poder trabajar con decimales.
  • Algunas tienen definidos valores. Esto es interesante porque la llamada al método de instancia también envia este valor al método de instancia para que sea utilizado en el.

Vemos que hay dos constructores de instancias
  • Uno de la clase secundaria que es la que contiene los métodos de instancia que realizarán los cálculos.
  • Otra de la clase "DecimalFormat" que he tenido que importar con "import java.text.DecimalFormat;". Esta clase lo que permite es dar formato a los números de la respuesta de manera que muestren solo dos decimales.

La llamada a los métodos de instancia, observamos sus argumentos:

  • Contienen las variables cuyos valores es necesario utilizar en cada método instanciado.
  • Hay tres llamadas y cada una tiene una variable que recibe el resulado del cálculo realizado en su correspondiente método de instancia.
  • Cada llamada tiene los argumentos que necesita para:
    • enviar valores de las variables definidas en la clase principal al metodo correspondiente
    • recibir en una variable del argumento el valor de la respuesta del calculo realizado.
    • No tengo claro como se decide el valor de la variable del argumento que pasa a la variable de la llamada. Ha si, es porque la variable se ha definido en return en el metodo de instancia y por su posicion en el argumento (de la llamada y del metodo) es el valor que toma la variable de la llamada al metodo.?? Bien, yo al menos lo entiendo.

Sobre el orden dispuesto de las variables del argumento:
  • Hasta donde he podido ver el orden de las variables en el método de instancia y en su llamada debe ser el mismo.Los argumentos reciben los valores, no identifican la variable, asi que si cambiamos el orden en que hemos definido los argumentos en el método de instancia podemos recibir resultados inesperados si no cambiamos tambien el orden en la llamada al método.
  • Como hemos visto el nombre de las variables del argumento de un método sobrecargado puede ser distinto en el argumento de su invocación. Esto es porque lo que reciben y/o pasan es el valor de la variable, por eso es tan importante también el orden de colocación de las variables en los argumentos

2.2.2.4.5.2.- El fichero "Calculos.java", clase secundaria. Interesante los argumentos de los métodos de instancia
Esta es la captura de la clase secundaria. En la clase principal hemos visto su constructor que creara un objeto instanciado de la clase secundaria con el nombre "area":
nb71-05.gif

Observamos:
La clase secundaria
Los tres métodos de instancia
  • Sobre el tipo de las variables (double):
    • En la clase principal el tipo de variables y su nombre se define al principio de la clase
    • En la clase secundaria el tipo de las variables y las variables está definido en la propia declaración del método, en sus argumentos.
    • En la clase secundaria podria ser necesario utilizar variables nuevas, que no sean usadas en el argumento) para guardar transitoriamente datos de calculos en sus metodos. Entonces podrian definirse tambien al principio de la clase secundaria su tipo y nombre.

  • Sobre el nombre de las variables:
    • En la clase principal, en la llamada a los métodos sobrecargados hemos usado los nombres de las variables con que las hemos definido.
    • En la clase secundaria los nombres pueden cambiar, no es necesario usar los mismos aunque si conservar el mismo orden y tipo.

  • Sobre el orden de colocación de las variables en los argumentos
    • Tanto en los argumentos de la llamada a un método sobrecargado como en los argumentos de método invocado, las variables deben estar en el mismo orden y cada una debe ser del mismo tipo. En realidad los valores se reciben en el mismo orden.
    • He marcado en rojo los argumentos del primer método sobrecargado. En él, la primera variable es la que guarda la superficie, la segunda es la altura y la tercera la base. Este orden es el mismo que debe usarse tanto en el argumento de llamada como en el argumento del método sobrecargado.

  • Sobre la salida de datos, ventana Output
    • Vemos que hay dos series de datos.
    • Uno muestra los resultados desde el propio metodo de instancia: el resultado contiene un número alto de decimales. Es el resultado original de los cálculos realizados.
    • Otro procede de la clase principal donde hemos utilizado la clase "DecimalFormat" que permite seleccionar cuantos decimales queremos mostrar. En este caso dos.

===============================
2.2.2.4.6.- El package "cInstancias6Adivina2"

Estamos aqui:
nb71-28.gif
revisando
2.2.2.4.6.1.- El fichero "AdivinaMiNumero.java" , El juego adivina mi número version2
Tanto la versión1 del juego, que hemos visto mas arriba, como esta muestran la misma pantalla de juego y jugamos de la misma manera.

Diferencias
Esta versión utiliza tres ficheros:
  • Un fichero contiene la clase principal, está realizado en modo gráfico
  • Dos ficheros cada uno con una clase secundaria, ambos será necesario instanciarlos por la clase principal, su código contiene métodos que sirven para:
    • Generar un número aleatorio (del 1 al 100): GenerarNumAleatorio
    • Para dar avisos de ayuda y de acierto: MetodoAvisos
  • Interesante: usamos argumentos con dos tipos de variables, int y string

Esta es una captura de parte del código de la clase principal:
nb7-99b.gif

En la captura vemos:
  • La definición de las variables
  • Los dos constructores que crean las instancias.
    • aleatorio: Instancia un objeto de la clase GenerarNumAleatorio con sus métodos y variables. Este objeto lo que hace es generar un número aleatorio del 1 al 100 que deberá ser acertado por el jugador. Es utilizado en el método "numeroAleatorio()"
      Observar la llamada: numAleatorio= aleatorio.numero(numAleatorio);
      • numAleatorio: Es una variable, guardará un número generado aleatoriamente en la clase secundaria "GenerarNumAleatorio" que tiene un solo método: "numero".
      • aleatorio.numero: es la ruta, instancia y método de instancia
      • (numAleatorio) Aunque se llama igual que la variable que guardará el número, esta variable es la que recibe el número generado en el método "numero". Puede llevar cualquier otro nombre. He usado el mismo porque no perjudica el funcionamiento del programa y por ahorrar definir una nueva variable.
      • Esta variable es la que contiene el número que debe acertar el jugador. Tambien hace de argumento. La he utilizado durante la programación del juego para hacer pruebas de funcionamiento del codigo, se muestra en la jLabel2, aunque cuando ya funciona la he puesto a false para que no se mueste en el jframe, si quieres hacer pruebas puedes ponerla a true.
    • aviso: Esta instancia de la clase "MetodoAvisos" la he utilizado para mostrar dos métodos de instancia. Estas son las llamadas:
      • aciertos = aviso.darAviso(tuNumero2, numAleatorio, aciertos);
      • mensaje = aviso.darAviso(mensaje, tuNumero2, numAleatorio);
      • Vemos que las variables de los argumentos son distintas
      • La variable "aciertos" es de tipo int, recibe el número de aciertos del jugador. Para calcularlo el método de instancia necesita los valores de las variables del argumento.
      • La variable "mensaje" es de tipo String, recibe una cadena de caracteres. La cadena de caracteres puede contener tres mensajes distintos. Para calcular cual mensaje va a recibir necesitamos el contenido de las variables de los argumentos.
      • Una vez recibido el mensaje
        • lo evalua
        • y asigna un color al al texto que lo mostrara en pantalla dentro de la etiqueta jLabel.
        • lo muestra
      • Es un poco rebuscado, pero no he encontrado otra forma mejor de modificar el color del texto de cada mensaje. En las propiedades del jLabel puede definirse un color pero para establecer más colores según la respuesta hay que hacerlo a través de código.

Esta captura es continuación de la anterior donde vemos el método "compara" con todo su código
nb71-01.gif
  • Veamos primero la llamada al método de instancia "aviso". En la captura siguiente podemos ver el método "darAviso", lo que hace es aumentar el valor de la variable mAciertos en una unidad dada vez que el jugador acierta en número aleatorio. Los argumentos permiten que este método disponga de los valores de las variables tuNumero y numeroAleatorio para compararlos, si son iguales aumenta uno. También permite disponer de la variable mAciertos que es la que devuelve el número de aciertos al método de llamada donde lo muestra en la etiqueta jLabel6.
  • Veamos ahora el llamada al metodo de instancia "mensaje". En la captura siguiente podemos ver el metodo darAviso (segundo método de instancia). Este método lo que hace es comparar de nuevo las variables 'tuNumero' y 'numeroAleatorio', pero esta vez adjudica a la variamle mensaje un contenido distinto según la comparación efectuada a través de los if. El contenido del mensaje es importante pues permite imprimir y dar color al texto del mensaje generado en el método.

2.2.2.4.6.2.- El fichero "GenerarNumAleatorio.java"
En esta captura vemos la clase con el método de instancia usado:
nb71-02.gif
  • La variable del argumento int aleatorio , hay que definir el tipo y el nombre de la variable en el argumento del método.
  • He marcado en rojo el código que genera el número aleatorio
  • Se imprime en modo texto el número aleatorio generado, hay que comentar esta línea para no dar pistas al jugador.
  • return nAleatorio: devuelve el número aleatorio a la clase donde se hizo la llamada. En este caso puede mostrarlo en la pantalla de juego en la etiqueta jLabel2. Serviria para ayudar al programador, podemos verlo poniendo a true el valor de la etiqueta.

Aqui vemos un ejemplo de metodos sobrecargados (esto hay que ampliarlo)
nb71-03.gif

3.- Variables

a) En esta página encuentras información sobre las variables: http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Variables

b) Clases de variables
  • De instancia: las hemos visto en las clases instanciadas y métodos de instancia (¡ y sin saberlo ! ). Se usan para guardar los valores de los atributos del argumento de un método y de su llamada o invocación.
  • De clase: Las variables de clase son variables cuyos valores son los mismos para la clase y para todas sus instancias y en consecuencia para sus métodos de instancia. Para indicar que una variable es una variable de clase se utiliza la palabra clave static en la declaración de la variables: static tipoVariable nombreVariable;
  • Locales: Son las que se se definen y usan dentro de los métodos

c) Generalidades:
  • Las variables deben declararse de manera obligatoria. Según la clase de la variable se declaran al principio de la clase o al principio del método donde las vamos a usar
  • Para declaralas debemos indicar su tipo (String, int, double,etc.) y su nombre, puede ser elegido por el programador en función de los valores que vaya a guarda para recordar mejor en que la usamos.
  • Al utilizarlas en otras partes del programa solo usar su nombre
  • Tambien pueden declararse con un valor inicial: "int a=5;"
  • Podemos usar el modificador "static", es opcional:
    • Indica que puede ser usada por los objetos y métodos que la clase tenga dentro.
    • Puede ser utilizada por otras clases pero entonces es necesario llamarlas con el nombre de la clase a que petenecen y el nombre de la variable.
    • No es necesario que haya instancias de una clase para usarla, pero si las hay todas las instancias compartiran la variable static.
    • Para invocarlas hay que utilizar el nombre de la clase en que está definida, el operador punto y el nombre de la variable estática.
  • El modificador public/private
    • public indica que puede ser usada por todas las clases
    • El modificador private solo puede ser usada dentro de su propia clase
  • Primitivas, que pueden ser:
    • De tipo entero
    • De tipo real o de coma flotante
    • De tipo lógico o booleanas
    • De tipo char o de carácter
    • referenciadas

  • Casting o transformaciones de tipo ??

=

http://www.webtaller.com/construccion/lenguajes/java/lecciones/variables-java.php
En Java la escritura de una variable está compuesta por tres partes: modificadores, tipo e indentificadores.
Los modificadores son una opción y son los que establecen el acceso a las variables, es decir, a los public particulares y protegidos que vimos en el capítulo anterior. Éstos se llaman modificadores de acceso y los hay estáticos, sincronizados y finales. No es importante ponerlos en órden, aunque sí es importante utilizar siempre el mismo órden para que sea legible el código. Estátic también lo vimos: nos permite escribir atributos y métodos constantes que se pueden invocar incluso antes de que un objeto se escriba. Final, en cambio, quiere decir que, cuando se utiliza un valor, éste se puede unir sólo una vez a un campo porque es también una constante. El modificador sincronizado lo dejaremos de lado: basta con indicar que sirve para decir que a un método, en el caso de una multiprogramación (con los thread), se puede acceder a través de una exclusión múltiple, es decir, un thread a la vez.
Los identificadores pueden ser uno o más, están separados por una coma y son nombres que tienen variables. Por ejemplo, la escritura de X en el ejemplo anterior se convertirá en:

==



4.- Modificadores

4.- Modificadores

(Pendientes de redactar, completar información y ejemplos)
Los modificadores son palabras reservadas que se colocan al declarar clases, métodos y variables:

Este es un guión de lo que veremos .
4.1.- Modificadores de acceso (o de visibilidad) public, private, protected y default (incompatibles)
4.2.- Modificadores de contenidos: static, final, abstract. (compatibles)
4.3.- Mecanismos de sincronización: syncrhonized.
4.4.- Otros: strictfp, volatile, transient ???

Hay numerosas páginas donde puede encontrarse información. Y parece mas complejo de lo que pensaba. Encuentro muchas posibilidades de uso de modificadores para acceder :
  • Puede estar en el mismo package o en distinto package
  • En la misma clase, en otra clase o en otro package
  • Pueden afectar a una clase principal, a metodos, a variables
  • No afectan a las clases contenedoras??? (creo, por ahora) pero si a las internas
  • En algunos casos puede esta presente la herencia??
  • Extrañamente si no accede da error e interrumpe la ejecución. Quizá con un try-cath pueda evitarse (la interrupción, no el error).
  • En algunos ejemplos encuentro la posibilidad de devolver un valor a la clase principal con 'return'
  • En las definiciones habla de miembos, parece que uno intenta a acceder a otro pero no se sabe:
    • si el que lo intenta es un package, una clase un método
    • si el que tiene el dato es un package, una clase un método
    • si solo accede
    • si interviene en algún manejo o elaboración de información
    • Si recibe algún dato devuelto como respuesta al tratamiento efectuado en la clase, metodo... destino

Los modificadores se colocan en las c??
permitir el acceso de otras clase a las clases metodos y variables que hemos declarado,.??

4.1.- Modificadores de acceso (o de visibilidad): public, private, protected y default

Nota:
Por ahora este apartado tiene un nivel muy básico y posiblemente con discrepancias, lagunas e incoherencias. Estoy trabajado duramente para mejorarlo.

Los modificadores de acceso:
  • Son incompatibles entre sí de manera que si lo declaramos en una clase (u otro objeto) solo podrá llevar uno de ellos o ninguno (default)
  • Se utilizan?? en:
    • clases
    • metodos
    • variables
  • Para: permitir, evitar la comunicacion de otros elementos clases (del propio package o de otros packages de la aplicacion), metodos con los definidos con modificadores.
  • Para permitir, evitar la comunicacion de otras clases y metodos con el definido con el modificador
  • Si al declararlos no se indica modificador se utiliza el nivel de acceso por defecto (default, no es necesario declararlo asi, solo dejarlo sin modificador).
  • No queda claro Entonces el elemento puede ser accedido desde las clases del mismo paquete?? de otros paquetes??, de otros metodos??(no queda claro desde donde no se puede (package)

4.1.1 Public

Cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instacia públicos.
El modificador public indica que desde cualquier clase por muy lejana y ajena que sea (del mismo o de otros package) podemos aceder al elemento (clase, metodo, variable) que hemos declarado con él.

Notas interesantes:
  • Hasta donde he visto no se podría acceder a un elemento público desde otra aplicación??? (pero no lo tengo claro).
  • Interesante porque esto ayuda a acotar el campo de los modificadores públicos: El modificador debemos utilizarlo, o solo podemos usarlo, en clases o métodos de instancia.
  • Interesante: Si invocamos un método de una instancia de clase pues eso, solo accedemos a ese método. Si necesitamas invocar mas métodos hay que hacer invocaciones, llamadas, para cada uno. Por supuesto declarados como public.
  • En ocasiones se llama atributo al elemento (clase, método, variable) definido con el modificador. Interpreto que no es un concepto distinto a los que indico entre paréntesis
  • Otra nota interesante: No es muy habitual declarar atributos públicos (public). Supongo que porque si siempre declaramos public todos los demás elementos compartiran variables y por error podemos hacer un tratamiento previo del contenido de una variable que luego usaremos en un cálculo final lo que puede arrojar resultados inesperadoe e inservibles.

Otras notas:
  • Entiendo que la clase está declarada con public y dentro de ella el método también está declarado con public, dentro del método las variables del método también son public y dentro de la clase las variables de la clase también son public.
  • Si ocurre que dentro de la clase hay métodos públicos y no públicos solo se podrá acceder a los métodos públicos y dentro de los metodos públicos solo a las variables definidas como públicas. A las que no esten definidas como publicas no se podra acceder. (No veo ahora como hacer un ejemplo pero lo intentaré en cuanto pueda) . Se entiende que una invocación desde una clase a otra se hace a la que está declarada como publica y dentro de ella al método publico (por supuesto si se invoca a una clase no publica da error y tambin si el método es no público).
  • Parece que no tiene lógica definir dentro de una clase no pública un método como público o variables de la clase como públicas.
  • Igualmente, dentro de un método no público no tendría sentido definir variables públicas
  • Hasta donde he visto este sistema de atributos es muy rígido y va en una dirrección (de mayor a menor: package-->clase-->método-->variable??. Así que la clase realiza una tarea, los métodos la suya pero no devuelven nada a la clase que los llama asi que solo se puede:
    • ejecutar lo que tiene la clase y mostrar la tarea realizada
    • ejecutar los métodos invocados y mostrar la tarea que realizan
    • no hay interación a la inversa: la clase o los metodos de la clase invocada muestra su contenido pero no devuelven nada a la clase que les llama.
    • Segun lo entiendo esto puede servir para programas donde lon sismos metodos imprimen el resultado (esto es cuando trabajamos en modo texto. En modo grafico habria ue devolver a la clase principal donde se ha definido el frame y sus objeos para mostrar resultados a traves de el (y también introducir datos, etc.)

Otras notas (con dudas???):
  • Si vamos a llamar una clase desde otras clases del mismo package también se declaran a public
  • Dentro de una clase (por defecto, que no será llamada desde otra clase) no hace falta declarar como public los métodos y variables (haré pruebas), por defecto se puede acceder.
  • Demasiados casos, dmasiadas posibilidades para hacer ejemplos de todos. Parece que hay que interpretar con lógica las posibilidades de los modificadores en cada situación. Quizá los ejemplos, con ligeras modificaciones puedan servir al interesado para hacer sus propias comprobaciones.

Veamos el siguiente ejemplo (basado en esta fuente: http://sekthdroid.wordpress.com/2012/09/24/modificador-de-acceso-private-y-public-en-java/).
Esta es la captura de la clase principal:
nb71-44.gif
Vemos que:
  • A la izquierda en la ventana Projects he marcado los packages que contienen las clases del ejemplo
  • La clase principal está en el paquete 'fModificadores1Public'.
  • Como vemos está definida con el modificador 'public', pero si se elimina sigue funcionando bien
  • Para comunicar ambas clases es necesario importar el paquete 'fModificadores0Prueba' que es donde está la clase (secundaria) con la que queremos establecer comunicación. Hay que hacerlo porque asi :
    • Este es un ejemplo de importar paquete: import fModificadores0Prueba.*; El asterisco indica que importara todas las clases
    • Podemos importar todas las clases del paquete. Si el paquete tiene varias clases usaremos, por ejemplo, la clase que definamos en la instania. Pero también:
      • Podemos importar una clase. Este es un ejemplo de importar una clase:
        • import Java.Util.*; (todas las clases)
          import Java.Util.Vector; (solo la clase Vector). Esta forma es mas eficiente porque solo importa la clase concreta que necesitamos. Esto puede hacerse si es una o pocas clases las que necesitamos importar del paquete.
        • En el caso del ejemplo he probado con "import fModificadores0Prueba.Ayuda1Public;" y funciona correctamente.
      • Podemos importar métodos?? (buscando ejemplo)
    • Cuando importamos un package, clase o metodo?? se conservan los modificadores con que se declaró: public, private, default
  • Hemos hecho una instancia utilizando un constructor de clase secundaria (subclase), a laqu queremos acceder y hemos declarado como public.
  • Una vez instanciada la invocamos, en realidad invocamos al método que posee: 'publica1.recibe();'
  • El resultado de la ejecución lo vemos en la ventana de salida Output.

Y esta es la captura de la clase secundaria:
nb71-45.gif
Vemos:
  • El código utilizado no tiene nada especial como vemos
  • Parece claro que el modidficador public funciona con:
    • Clases: La clase secundaria debe llevar el modificador 'public', si lo eliminamos no comparte con el resto de clases y se produce un error: la instancia declarada en la clase principal no encuentra el nombre de la clase secundaria.
    • Métodos: El método también debe estar declarado a public, si lo eliminamos la invocación que hacemos sobre él desde la clase principal no lo encuentra y da error.
    • El error aparece subrayado en sojo en la clase principal, en la invocación.
  • He declarado varias variables con distintos modificadores. Pensaba que alguno (protected) impediría compartir la variable o daría error, pues no, funcionan bien. Bueno, en realidad funciona bien la ejecución, pero la declaración o no declaración del modificador public en la variable deberia??? producir algún efecto.
  • He utilizado varios tipos para declarar variables, también funcionan bien.
  • Recordar que el el package que contiene esta clase ha sido importado por la clase principal que está en otro pakcage.

Parece que es un ejemplo muy sencillo y básicamente sirve para introducirnos en como usar el modificador public cuando utilizamos métodos, clases y variables??. A unque genera muchas dudas, seguramente aclararemos algunas en ejercicios con otros ejemplos:
  • Parece un ejemplo muy rígido.
  • En realidad no se comparten valores de variables (la clase principal no envía ningún valor a la clase secundaria y la clase secundaria o su método tampoco envian ningún valor a la clase principal. Posiblemente se pueda y en cuanto encuentre o haga un ejemplo lo pongo aquí.
  • ¿Qué hemos echo?: poner en comunicación dos clases?? ¿Acceder a los datos de la clase secundaria?? . En realidad hacer que la clase principal llame a la secundaria que ejecuta el método que contiene, pero las variables y métodos no devuelven ningún dato, ni cálculo, ni valor de variable a la clase principal.
  • Está claro que si podemos comunicar clases de distinos packages también dentro del mismo package.
  • Lo que no queda claro es el uso del modificador public o restricted en las variables. ¿¿??
  • Tampoco queda claro si podría hacerse entre clases de aplicaciones distintas?? o siempre dentro de los packages que pueda tener una misma aplicación?. .

4.1.2.- private

Indica que las variables y métodos de instancia privados sólo pueden acceder al atributo desde dentro de la propia clase o sólo puede invocarse el método desde otro método de la clase.
El atributo estará "oculto" para cualquier otra zona de código fuera de la clase en la que está declarado el atributo. Es lo opuesto a lo que permite public. Private permite una accesibilidad total desde cualquier método de la clase, pero no desde fuera de esta

Notas:
  • Parece que también deben usarse a través de instancias
  • No funciona cuando hacemos una llamada a un método de una instancia de una clase (secundaria) como el caso del ejemplo anterior, private no permite el acceso, en realidad la llamada al método (o la clase) instanciada no encuentra el método invocado.
  • Si funciona en una instancia de la clase principal
  • También funciona en una clase principal sin instanciar??? (entiendo que es una clase con metodo main)
  • Solo se puede acceder a las variables (o los metodos) desde el código de la propia clase
  • Creo que no lo entiendo. Bien solo sirve para ejecutar el método y mostrar el resultado en pantalla, lo mas cotidiano del mundo.


Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase. No son accesibles desde las subclases. Haber, vamos a liarnos, entonces que significa, que en una subclase no puedo definir metodos y variables private que solo se van a usar en la propia subclase. Raro??? vere si pruebo como funciona en algun ejemplo.

Private es el modificador más restrictivo y específica que los elementos que lo utilizan (clases, métodos, variables?? sólo pueden ser accedidos (invocados si es método) desde la clase en la que se encuentran. Pero a ver: entonces no puede usarse en la propia subclase, es lo mismo que digo en el parrafo anterior: haré pruebas

Interesante: este modificador sólo puede utilizarse sobre los miembros de una clase (metodos y variables) y sobre interfaces y clases internas, no sobre clases (contenedora de clases internas) o interfaces de primer nivel, dado que esto no tendría sentido (veré de hacer/encontrar algun ejemplo).
Ni idea, se lo que son clase principal o superclases y clase secundaria o subclase y ya hemos comentado sobre ello. Tambien conocemos las clases contenedoras y las clases internas, no se entiende lo de la clase contenedora ¿y si es un método o variables que pertenecen a la clase contenedora??? Ahora, eso si, lo de interface de primer nivel, ni idea de que es, como funciona y cuando se usa (y de segundo nivel tampoco -si los hay??-).

Es importante destacar también que private convierte los elementos en privados para otras clases, no para otras instancias de la misma clase. Es decir, un objeto (instancia) de una determinada clase puede acceder a los miembros privados de otro objeto (instancia) de la misma clase (entiendo que instancias distintas de una misma clase pueden compartir métodos y variables -veré de encontrar un ejemplo). Parce que no tiene sentido ya que las instancias de una misma clase son iguales, aunque tienen nombre, variable de nombre distinto. Quiza para el caso que una instancia ha realizado un tratamiento de información y las demás instancias podrian disponer del resultado, pero tampoco le veo sentido buscare/aré ejemplo). Ah, no, posiblemente se rfiere a dos instancias de la misma clase pero de métodos distintos???:

Para una prueba de private podemos utilizar el ejemplo anterior, cambiamos a private el metodo 'recibe()' y ya es imposible la comunicación. Marca error en el código y si ejecutamos obtenemos este error:

Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - recibe() has private access in fModificadores0Prueba.Ayuda1Public at fModificadores1Public.Modificadores1Public.main(Modificadores1Public.java:9)
Java Result: 1

Esta es la captura de un ejemplo con private:
nb71-46.gif
Observamos:
  • Es el mismo código de la clase secundaria del ejemplo anterior al que he nombado como 'Ayuda2Public'
  • Para poder ejecutarlo le he añadido el método main
  • El método está definido como private, solo se puede acceder a él desde la propia clase.
  • Si borramos private también se puede acceder desde la propia clase (normal por supuesto, no es ningún fallo, funciona con el modificador por defecto (default, no se escribe).
  • Ya hemos visto como en el ejemplo del modificador public, si a este metodo 'recive' le ponemos el modificador private daba el error que hemos indicado mas arriba.
  • Si jecutamos este fichero desde su propio metodo main funciona correctamente como hemos dicho.
  • Si alguien quiere acceder a él desde otra clase como por ejemplo esta que es una modificación de la clase principal del ejemplo anterior:
  • nb71-47.gif
  • Da error al no encontrar accesible (public) la clase que invocamos.
  • Aunque la clase Ayuda2Public que instanciamos tiene también método main no interfiere en la instancia e invocación de la clase.
  • Tenemos dos llamadas: una desde fuera de la clase, no puede acceder y otra desde dentro de la clase que si accede. En ambos casos el modificador private esta presente no permitiendo, permitiendo el acceso.

Cuando usar public o private:
  • Una variable que solo debe ser leida pero que para asignarle un valor necesita pasar por un proceso de validación (¿que?), conviene ponerla como privada.
  • Hay variables que deben ser declaradas como públicas (veré si amplio esto)
  • La variable que sea declarada en una clase deberia ser privada si solo se va a usar en ella salvo justificación de fuerza mayor (nada, veré de buscar ejemplo o ampliar)

4.1.3.- protected
a) Sólo las subclases de la clase y nadie más puede acceder a las variables y métodos de instancia protegidos.

b) En este caso se permitirá acceder al atributo (a la variales ¿tanbien de una clase y de un metodo?) desde cualquier subclase (o clase secundarialo- veremos más adelante al estudiar la herencia) de la clase en la que se encuentre declarado el atributo, y también desde las clases del mismo paquete.

Viene muy bien explicado aqui: http://sekthdroid.wordpress.com/2012/09/25/modificador-de-acceso-protected-y-default-en-java/

a) Vamos a trabajar con el ejemplo que ya hemos usado:
  • nb71-48.gif
    • Vemos que hay dos packages( ya sé, protected solo se puede usar en clase del mismo package, es para ver que no se puede acceder).
    • Los ficheros que ya conocemos y usaremos ahora estan marcados.
b) Vamos al fichero Ayuda1Public.java, lo abrimos y:
  • Vamos al metodo 'recibe()'.
    • Vemos que está definido a public:public void recibe() {
    • Ese modificador es el que tendremos que cambiar
  • Este ejercicio funciona correctamente como vimos cuando lo explicamos para el modificador public.
  • Ahora haremos cambios:
    • Quitamos el modificador, en realidad lo dejamos a default. Vemos que:
      • si ejecutamos da un error
      • si miramos la clase principal 'Modificadores1Public' vemos que en la invocación el metodo aparece subrayado. Indica que no encuentra el método 'recibe'.
    • Ponemos el modificador protected y vemos que ocurre lo mismo que en default.
  • En realidad el resultado obtenido era el esperado. Esto es asi porque protected sirve para usarlo dentro del mismo paquete. Y en el ejemplo lo estamos usando en dos paquetes distintos, asi que imposible, no pueden cominicarse
b) Ahora vamos a repetir el mismo ejercicio pero con ambos ficheros dentro del mismo package. Bien, en realidad utilizaré un fichero con nombre nuevo y mismo codigo para que pueda guardarlo sin interferir con el existente.
  • La clase principal permanece en el mismo pakage:
    • Le hemos hecho algunos cambios que vemos en la captura:
    • nb71-49.gif
    • Los cambios han servido para mantener en el mismo package los ficheros que vamos a utilizar y para que no coincidan con los que ya hay.
  • La clase secundaria está ahora en el mismo package. Este es su captura:
nb71-50.gif
Observamos:
  • Ambos ficheros (y clases) se encuentran en el mismo package
  • Hay pequeños cambios en los nombres de los ficheros (y clases ) para evitar repeticiones dentro del package.
  • El código realiza la misma tarea.
  • Utlizando los modificadores:
    • public: la aplicación funciona correctamente. Public sirve para comunicar:
      • Clases que están en packages distintos
      • Clases que están en el mismo package
    • default: No hay que escribirlo, solo eliminar 'public' o el modificador que posea la declaración del método
      • Funciona correctamente.
      • Era de esperar porque están en el mismo package ???
    • protected: Escribimos este modificador y:
      • Funciona correctamente.
      • Es que es para eso para lo que esta pensado: comunicar dos clases dentro del mismo package.
    • Pero resulta interesante ver que aunque ambos modificadores (protected y default) funcionen hay diferencias entre ellos:
      • Protected
        • Puede acceder a clases principales y subclases??, (serán clases secundarias?) en el mismo package.
        • Pero también puede acceder a clases principales y clases secundarias que estén en packages distintos utilizando la herencia (en cuanto lo tenga pongo un ejemplo). Veremos que la herencia usa la palabra reservada extends para indicar la herencia en la declaración de clases.
        • Protected como pivate no puede utilizarse en clases o interfaces internas.
        • Interesante sobre la herencia, si tenemos una clase padre:
          • la clase hijo puede heredar si tiene clases, campos??, variables??, metodos definidos como protected en la clase padre
          • Pero no puede acceder a los campos/metodos definidos con 'private' en la clase padre
          • ¿Y default?: segun hemos indicado no puede utilizar en la herencia, solo en el mismo package, asi que no.
      • default:
        • Solo permite la comunicación si ambos, la super clase y la subclase (clase principal y clase secundaria) se encuentran en el mismo package.
        • no admite la herencia.

4.1.4.- default:

4.1.5.- friendly (sin declaración específica)En variables y métodos
Por defecto, si no se especifica el control de acceso, las variables y métodos de instancia se declaran friendly (amigas), lo que significa que son accesibles por todos los objetos dentro del mismo paquete, pero no por los externos al paquete. Es lo mismo que protected. ¿No será lo mismo que default?, pues parece que no.

4.2.- Modificadores de clases y métodos: STATIC, FINAL, ABSTRACT.

Estos modificadores pueden aplicarse a métodos y atributos (que para mi es equivalente a las variables)
Estos modificadores son compatibles con los modificadores de acceso que hemos visto en el punto anterior: 'static', 'public/private' y 'final'.

4.2.1.- static
Interesante:
"Un atributo de una clase se puede modificar con la palabra reservada static para indicar que este atributo no pertenece a las instancias de la clase si no a la propia clase, esto quiere decir que si tenemos varias instancias de una misma clase, cada una de ellas no tendrán una copia propia de ese atributo, si no que todas estas instancias compartirán una misma copia del atributo, a los atributos definidos como static, se les suele llamar atributos de la clase".
Interesante como digo, si instanciamos una clase varias veces cada instancia compartira una misma copia de la variable definida a static

Interesante, lo mismo explicado con otras palabras:
  • El modificador static sirve para crear miembros (metodos y variables) que pertenecen a la clase, y no a una instancia de la clase.
  • Por eso no es necesario crear un objeto de la clase (o instanciar la clase) para poder acceder a estos atributos y métodos.
  • Este es el motivo por el cual es obligatorio que main se declare como static; de esta forma no tenemos que ofrecer un constructor vacío para la clase que contiene el método, o indicar de alguna forma a la máquina virtual cómo instanciar la clase.

Notas:
  • No se usa en la declaración de una clase pincipal, secundaria o contenedora. Da error si se hace (modifier static not allowed here).
  • Sí se usa en la declaración de una clase interna:
    • si no se declaran como static podemos crear instancias dentro de la clase contenedora. En este caso la instancia de la clase interna dependen de la contenedora.
    • Si la declaramos como static, que es lo normal o recomendado podemos crear instancias de la propia clase interna sin necesidad de acceder a ella a través de la clase contenedora.
    • Las clases internas se explican aqui: 04.4.- Clases internas y herencia en las clases).
  • Sí se usa como modificador en los métodos y en las variables (atributos como les llama el temario ahora)
    • Las variables (atributos) que no usan un método static:
      • Si se declaran en la clase no necesitan static, aunque si se declaran como static no se produce error.
      • Si se declaran en el método tampoco necesitan static.
      • En el ejemplo: el método metodo();
    • Las variables que se van a usar en un método declarado como static. Un método declarado como Static es un método estático.
      • Si se declaran en la clase necesitan declararse con static
      • Si se declaran dentro del método no necesitan static
      • En el ejemplo el método main (que siempre se declara como static), por eso las variables declaradas en la clase que sean usadas en el metodo main, para imprimir un resultado o dato deben ser declaradas como estatic. Si no se produce un error y muestra el célebre mensaje "non-static variable cadena1main cannot be referenced from a static context".
    • Puede estar como pública o como privada ?la clase o el metodo o la variable???.
    • Si está marcada como pública, se puede acceder desde fuera de la clase, sin necesidad de una instancia de la clase
    • Desde fuera de la clase se puede acceder a una variable static si no se marca como private (que es lo habitual).
    • Con los métodos estáticos no se puede utilizar el puntero this, ya que no se necesitan instancias
    • Los métodos estáticos, sólo pueden acceder a sus propios argumentos y a las variables estáticas.

Esta es la captura del ejemplo que he preparado, puede descargarse al final de la página.
nb71-43.gif

Está pensado para hacer cambios quitando y añadiendo el modificador static en:
  • las variables declaradas:
    • en la clase principal
    • en el metodo metodo();
    • en el metodo main();
  • añadir static a:
    • la clase principal (da error)
    • el método metodo();
    • quitarselo al método main (da error)
  • Añadir mas variables en la clase o en los métodos
  • Las combinaciones para hacer pruebas no acaban aquí. Lo interesante es probar y ver el resultado de cada prueba. Así seguro conseguiremos mas información sobre como funciona el modificador static.

4.2.2.- final
Indica que una variable, método o clase no se va a modificar, lo cuál puede ser útil para añadir más semántica??, por cuestiones de rendimiento??, y para detectar errores.
  • Si una variable se marca como final, no se podrá asignar un nuevo valor a la variable,se convierte en una constante. Si se intenta cambiar el valor de cualquier variable final,se produce un error..
  • Si una clase se marca como final, no se podrá extender la clase (no se puede heradar de ella), no puede tener subclases.
  • Si es un método el que se declara como final, no se podrá sobreescribir (todvia no he visto que es un metodo sobnreascrirto salvo que tenga otro nombre tambien).
  • Los métodos marcados como estáticos o privados son finales automáticamente.
  • Algo muy a tener en cuenta a la hora de utilizar este modificador es que si es un objeto lo hemos marcado como final, esto no nos impedirá modificar el objeto en sí, sino tan sólo usar el operador de asignación para cambiar la referencia.
  • Una variable con modificadores static y final sería lo más cercano en Java a las constantes de otros lenguajes de programación.

4.2.3.- abstract
Fuente interesante: http://www.arrakis.es/~abelp/ApuntesJava/ClasesAbstractas.htm
Otra: http://devel.no-ip.org/programming/languages/java/tutorial/java/iandi/abstract.html
Ejemplo interesante que funciona: http://www.slideshare.net/jcalmeida2/clases-abstractas-e-interfaces-en-java-15719490
Muy interesante por lo que dice sobre métodos abstractos: http://hopzone.com.es/KIMERAWEB/java/tema30.php
otra: http://314159bits.wordpress.com/2009/11/09/clases-abstractas-en-java/


  • Una clase abstracta es una clase de la que no se puede crear objetos, o sea no se pueden instanciar. He probado y solo con hacer el constructor para la instancia da el error "<la clase> is abstract; cannot be instantiated". A si que ya lo sabemos no merece la pena ni hacer la prueba. Pensé en otras posibilidades pero desisto de hacer mas pruebas.
  • En esta captura vemos la declaración de una clase abstracta (la he marcado en azul. También vemos su método):
ec01-12.gif
  • Observamos:
    • La clase abstracta se declara en una clase secundaria (no sé exactamente si procede ese nombre o mejor subclase, hija...) es decir nunca en una clase principal (las que tienen el método main)
    • Dentro debe ir su método que como vemos debe declararse sin el cuerpo de la clase (sin las llaves y sin el código que llevan entre ellas).
    • Clase y método deben llevar el modificador abstract.
    • En el fichero donde situamos la clase abstracta, en este caso "ClaseAbstracta.java" pueden ir otras clases (secundarias, tampoco llevan main) que podrán ser instanciadas (lo veremos a continuación), y en consecuencia acceder a sus métodos, como veremos un poco mas adelante. Es posible que tambien puedan ir en otros ficheros (Haré la prueba más adelante aunque quiza al ser extends, usan la herencia, deban ir todas dentro del mismo fichero de la clase abstracta).
      • Creo que existe una convencion para nombrar métodos abstractos, para declararlos y para invocarlos declararlos:
        • getMetodo: uando lo declaramos
        • setMetodo: para invocarlos
        • Parece que esto hace mas facil la identificacion y cual es el origen del metodo, pero si no se usan funciona bien.
      • Estas clases tiene un metodo con return, esto significan que devuelven un valor a la clase principal (luego veremos como se instancia la clase y se invoca el método desde la clase main).
      • En este caso devuelven una cadena que es el valor definido en las variables para cada una.
      • Pero podrian devolver un numero int, double...
      • Y también puede devolver el resultado de una operación. Si definimos en una/cada clase dos o mas variables numéricas podríamos realizar un cálculo y devolver el resultado a la clase principal.
      • Ese método es el que devuelve el cálculo efectuado, en realidad este método es un objeto . Ese objeto se extiende en las demás clases no abstractas (que están en el mismo fichero que la abstracta, en clases que debemos?? llamar subclases) que lo llaman con parámetros o datos distintos según lo definido en cada clase (algo similar e redactado en otro punto).
      • Con return solo podemos devolver un valor a la clase principal.
      • También podemos usar argumentos. Esto viene bien explicado en esta misma página en el punto 2.2.2.4.3.2.- El fichero "MultiplicaciónMetodo.java" y siguientes. A través de los argumentos, en la invocación desde la clase principal, podemos enviar varios valores de variables a la instancia de la clase secundaria (o subclase). En ella, en sus métodos podemos tratarlos y esta nos devuelve el resultrado a la clase principal donde podemos mostrarlo en la ventana de salida output:
        • Devolver a la clase principal los calculos o datos obtenidos es importante porque en modo gráfico es donde está la inteface (formulario y objetos como jlavel, jtext...) de la aplicación y donde introducimos datos y nos mostrará el resultado.
        • En modo texto los datos pueden mostrarse en l propio metodo quegenera la respuesta con un "println".
      • Quiero decir que este ejemplo es muy sencillo, pero puede hacerse mas complejo en función de las necesidades de la aplicación.
      • El ejemplo como vemos lo que hace es devolver a la clase principal los valores de las variables definidas en las clases secunarias (subclases).
        • El método abstracto "abstract String plantas();" define un objeto general que funciona como padre: plantas
        • Las clases definen objetos hijos. Heredan del padre pero tienen propiedades propias definidas en cada uno. En este caso solo le damos el nombre margarita y pino.
        • Tambien podria definirse mas clases que heredarán de margarita o pino para definir: altura, color de la flor, fruta... mejor lo vemos en la herencia(ver pagina en breve tendre la herencia)

  • Esta es la captura de la clase principal:
  • ec01-13.gif
  • Vemos:
    • Aqui no tenemos que declara nada como abstract
    • Como hay dos clases hijas en el fichero "ClaseAbstracta.java" aqui:
      • Las instanciamos (marca verde)
      • Hacemos una llamada o invocación al metodo de cada una (flecha amarilla)
      • Nos devolverá un valor
      • Lo mostramos a través de las sentencias println.
      • Vemos el resultado en la ventana de salida output.
      • Tambien podriamos enviar variables a los metodos instanciados para que realizaran un calculo y devolvieran el resultado. para ello, como hemos comentado hay que usar argumentos.

Despues de este ejemplo parece que queda mas claro, asi que vamos a seleccionar ideas encontradas en internet sobre clases abstractas que sean realmente interesantes o clarificadoras:

Herencia (veremos mas en la herencia- pendiente)

  • Las clases hijas heredan de la clase padre:
    • Reutilizamos el código
    • Las clases hijas serán las encargadas de agregar la funcionalidad a los métodos abstractos.

Ventajas de su uso:
  • Evitan que los usuarios de la clase puedan crear objetos de la misma, se prrouce un error
  • En segundo lugar, permiten crear interfaces (lo de interfces lo tengo que explicar aparte) que luego deben ser implementados por las clases que hereden de la clase abstracta. Es evidente que una clase abstracta, al no poder ser instanciada, no tiene sentido hasta que una serie de clases que heredan de ella la implementan completamente y le dan un significado a todos sus métodos.

Este modificador abstract se utiliza para declarar:
  • Clases abstratas: Una clase abstracta es una clase que se declara como abstracta. Puede llevar o no un método abstracto???. Si una clase tiene un método abstracto la clase debe ser declarada como abstracta.
  • Métodos abstractos: Un método abstracto es un método declarado en una clase para el cual esa clase no proporciona la implementación (es decir, sin el bloque de código encerrado entre {} y acabado en ";" ) sino que la implementación vendrá dada por las clases que extiendan la clase actual, las clases que hereden de la clase actual.
  • Parece que cuando hablamos de clases abstractas para ellas se utiizan también nombres específicos:
    • La clase derivada (¿será la que tiene el método main?) se declara e implementa de forma normal??, como cualquier otra.
    • La clase base (no se si es la que lleva el modificador astract) declara e implementa los métodos abstractos de la clase base
  • Una clase abstracta puede contener métodos concretos que tienen implementación, y métodos abstractos que deben ser implementados en la subclase (Parece que en cada página que consulto nombran la clase abstracta y principal de una manera distinta mejor nos guiamos por como lo explique en la captura del ejemplo de clase abstracta).
  • Todos los métodos en una interfaz (vea la sección de Interfaces) son implícitamente abstractos, así que el modificador abstract no se usa con métodos de interfaz (podría hacerse—simplemente no es necesario).
  • La clase abstracta puede llevar modficadores static y métodos static (mas abajo, tomado de otra página encontré que los métodos no pueden ser static???). Puede usar estos miembros estáticos con una referencia de clase—por ejemplo, AbstractClass.staticMethod()—como lo haría con cualquier otra clase???.
  • Todas las subclases (vale, parece que tenemos en el fichero la clase abstracta y las demas clases que coloquemos en él seran subclases) que hereden de una clase abstracta tendrán que redefinir los métodos abstractos dándoles una implementación (si, porque cada método es distinto hace una tarea distinta). En el caso de que no implementen alguno de esos métodos la clase hija (o sea la subclase de la que estabamos hablando) también será abstracta?? y tendrá que declararse como tal (tanto la clase como los métodos que siguen siendo abstractos), (no se entiende, ¿puede haber dos métodos abstractos en una misma clase?).
  • Un método abstract no pude ser static, ya que no podría ser redefinido por las subclases.( ??? Ah, si porque estatic actúa como convirtiendo una variable en una constante y las constantes son constantes, no se pueden redefinir o si se intenta da error).

Si has visto los comentarios de las capturas de los ejemplos quizá estos textos sean mas legibles:

"La palabra clave abstract indica que no se provee una implementación para un cierto método, sino que la implementación vendrá dada por las clases que extiendan la clase actual. Una clase que tenga uno o más métodos abstract debe declararse como abstract a su vez."

"Una clase abstracta es una clase que tiene al menos un método que no ha sido especificado. Esto evita que se pueda instanciar."

"Una interfaz es un conjunto de definiciones de funciones que en ningún caso estarán implementadas ninguna de ellas."???

"La 1º ( clase abstracta ) se utiliza para definir un tipo BASE de clase, pero que tenga (al menos) un método que difiera para cada uno de sus clases hijas y que necesite ser definido por cada una de ellas.

La 2º ( interfaz ) se utiliza para definir un COMPORTAMIENTO para las clases." Bien, parece que la clase main es la que hace de interfaz???, No creo, vere si encuentrommas sobre interfaz con cles abstractas


4.3.- Mecanismos de sincronización: VOLATILE y SYNCRHONIZED.

Los puntos 4.3 y 4.4 presentan unos modificadores que, hasta donde se, tenen escaso uso.

4.3.1.- Volatile:

"volatile es más simple y más sencillo que synchronized, lo que implica también un mejor rendimiento. Sin embargo, volatile, a diferencia de synchronized, no proporciona atomicidad (que o se ejecuten todos los pasos o ninguno), lo que puede hacer que sea más complicado de utilizar.
Una operación como el incremento, por ejemplo, no es atómica. El operador de incremento se divide en realidad en 3 instrucciones distintas (primero se lee la variable, después se incrementa, y por último se actualiza el valor) por lo que algo como lo siguiente podría causarnos problemas a pesar de que la variable sea volatile:
+ expand source"

4.3.2.- Syncrhonized

"En caso de que necesitemos atomicidad podemos recurrir a synchronized o a cosas más avanzadas, como las clases del API java.util.concurrent de Java 5.
synchronized se diferencia de volatile entre otras cosas en que este modificador se utiliza sobre bloques de código y métodos, y no sobre variables. Al utilizar synchronized sobre un bloque se añade entre paréntesis una referencia a un objeto que utilizaremos a modo de lock.
+ expand source"

4.4.- Otras

4.4.1.-strictfp
"strictfp es un modificador de lo más esotérico, muy poco utilizado y conocido cuyo nombre procede de strict floating point, o punto flotante estricto.
Su uso sobre una clase, interfaz o método sirve para mejorar su portabilidad haciendo que los cálculos con números flotantes se restrinjan a los tamaños definidos por el estándar de punto flotante de la IEEE (float y double), en lugar de aprovechar toda la precisión que la plataforma en la que estemos corriendo el programa pudiera ofrecernos.
No es aconsejable su uso a menos que sea estrictamente necesario.
Tampoco está permitida una clase abstracta con strictfp."


===EN REDACCIÓN===
2.2.2.5.- Metodos Get y Set

c) get y set:
  • get--> obtener, recibir: Leemos el dato que esta guardado en la variable
  • set-->guardar,entregar, poner: Guardamos un dato en cada variable

Los metodos put??? y get lo veremos mas adelante, repetire solo con atributos??
fuente:
http://es.answers.yahoo.com/question/index?qid=20120827211822AA2kXZE
En las clases existen varios tipos de variables pero los metodos set y get se centran en las variables privadas, las variables privadas no pueden ser modificadas desde fuera de la clase a la que pertenecen, ahi es donde entran los metodos get y set, el metodo get se usa cuando quieres saber cual es el valor que tiene una variable privada de otra clase, el metodo set es para establecer un valor en una variable privada de otra clase.

son como prefijos, no existen metodos de esas palabras pero son indicadores para el programador o la persna que hace el mantenimiento, de lo que pretendemosd hacer para mostrar o modificar variables de clases privadas. En las clases publicas parece que no son necesarias porque cualquier otra clase puede obtenerlas y modificarlas, en las crases privadas pueden usarse o no, usarlas hace que el codigo sea mas legible.
Paece que hay prefijos set y get en algunas funciones o metodos donde es obligatorio porque es el nombre java del método.

parece que es una convencion, cuando tenemos necesidad de tomar o guardar valore de variables se suele poner get o set aunque si no se pone el metodo hace lo mismo.??
dan informacion que puede ser útil: que usamos clases privadas y entre ellas travasamos valores de variables y cuando la obtenemos o cuando las modificamos.

get: mostrar el dato que tiene la variable de una clase privada??
set: modificar o dar un nuevo valor a una variable .
interesante: http://www.ehowenespanol.com/metodo-get-set-java-sobre_165891/
http://robertoleiva.tripod.com/expo.htm
===


2.2.2.6.- El operador this
Un constructor puede llamar a otro constructor se usa this.
Si se puede, pero no tienes que decirle el nombre del constructor, sino que debes usar la palabra this...

this llama al constructor que encaje con la lista de parámetros que le des, y luego continua con las demás instrucciones del constructor...

2.2.2.7.- Clases abstractas
Fuente: http://es.answers.yahoo.com/question/index?qid=20090504095350AADeoFi
Una clase abstracta no puede ser instanciada, puede tener un constructor que es invocado automaticamente cuando se instancia una subclase, por lo tanto, puedes tener metodos concretos (no abstractos y con codigo) constructores, atributos, metodos, lo que quieras, pero no podras instanciar la clase, todos esas caracteristicas que implementa la clase abstracta, las usara las clases hijas, por ejemplo

Las clases abstractas significa que debe ser heredada.
=============================0
,

=

  • Si lo declaramos con algún modificador de acceso el elemento presenta restricciones o posibilidades de acceso de distinto tipo. El objeto declarado con un:
    • entre packages: clases de un package pueden cceder a una clase.
    • entre clases de un package
    • entre clases de un package y los metodos que contiene
    • entre clases y subclases (principal y secundaria) de un package
    • entre las clases de un package y los metodos que contiene
    • entre las clases y los metodos que contiene
    • entre los metodos de una clase
    • entre los medodos y las variables definidas en cada metodo
    • entre las variables de un metodo
    • ???

============





7.- Descargas

He preferido crear el proyecto "ClasesMetodosInstancias"con todas las aplicaciones que se explican en esta página. A algunos packages y ficheros he tenido que cambiarles el nombre. Espero que esta captura te ayude a localizarlos. Los packages estan ordenados en la misma secuencia en que aparecen es esta página.

nb7-97.gif
Contenidos de los Packages (pendiente de terminar)
  • a1Clases1:Declaración de clases
  • bMetodos1Mutiplicacion: Ejemplo 1, Ejemplo 2 Ejemplo3, ejemplos sencillos en modo texto.
  • bMetodos2Adivina1:Ejemplo 4. Interesante, contiene el juego "Adivina mi número" en modo gráfico. Es la versión 1. Tiene dos métodos dentro de la clase principal.
  • cInstancias1Ejemplo5: Ejemplo5, sencillo código en modo texto con dos clases (principal y secundaria) en el mismo fichero que:
    • Utiliza un constructor
    • Crea una instancia que genéra un objeto de la clase secundaria
  • cInstancias2Suma: Son dos ficheros con clase principal (uno en modo texto y otro en modo gráfico) que comparten el mismo método en otro fichero y clase. También usan constructor y crean instancia de un objeto.
  • cInstancias3Multiplicacion: Contiene dos ejemplos que realizan una multiplicación. Ambos comparten el mismo fichero con la clase instanciada y sus métodos de instancia.
    • MultiplicacionMain, Modo texto
    • MultiplicaconJFrame, modo grafico:
    • Fichero compartido: MultiplicacionMetodo Es instanciado por ambos ficheros anteriores.
cInstancias4Suma1: mejor borrarlo, repite lo sabido
dIstancia5Calculo: Usa una clase principal y una secundaria. Modo texto
dInstancia6Adivina2: Interesante. El juego Adivina mi numero ahora con clase principal y dos clases secundarias.Modo grafico

dSobrecarga1Ejemplo: pendiente

eGetSet1Trianfulo: pendiente
Puedes descargarla de aqui:
Última actualización 12-10-2013
Regularmente haré correcciones o añadiré packages hasta que termine la página asi que si vuelves a visitarme en unos dias seguro habrá cosas nuevas.

ara declarar un método necesitamos:
  • Su declaración: por ejemplo public static void metodomul(){}
  • Su cuerpo, es el codigo que colocamos entre las llaves de apertura y cierre y en el definimos la tarea que queremos que haga.