Métodos declaración, mensajes, pasos

parámetros, retorno de valores.

Los métodos o funciones miembro se definen dentro de la clase a la que pertenecen y
constituyen la interfaz o forma de acceder a la estructura interna de los objetos es
decir a los datos privados.
Los métodos definen cual son las operaciones que se pueden realizar con los
atributos de los objetos de la clase. 
La ejecución de un programa orientado a objetos consiste, en recibir, interpretar y
responder unos objetos a los mensajes que envían otros objetos.
En P.O.O. un mensaje está asociado siempre con un método, de manera que cuando
un objeto recibe un mensaje la respuesta a ese mensaje es ejecutar el método
asociado.
Para que se pueda hacer una llamada a un método éste tiene que estar definido:

Definición de un método
[modificadores] tipo nombreMétodo ([ Tipo1 Parámetro1, Tipo2
Parámetro2, ...])  //Declaración o cabecera del método 
{  
Definición de variables locales;   //Sólo accesibles desde la función 
Sentencias;                                                                                                                               Cuerpo
del método. 

[return [(] expresión [)]];  // Puede  no ser la última y puede aparecer más de una vez en la función. 
}
Declaración o cabecera:
 Modo de acceso: Especifica el tipo de acceso permitido indicando que
usuarios de la clase podrán acceder a ese método, los métodos son la única forma de
acceso a los atributos privados. Por defecto los métodos tienen protección paquete,
es decir son accesibles desde cualquier clase que pertenezca al mismo paquete.
Todas las clases de un mismo fichero .java pertenecen a un mismo paquete.

o  public: Accesible desde cualquier otra clase.
o package: Accesible sólo desde el mismo paquete.
o protected: Se comporta como un método público para los métodos del
mismo paquete o de las subclases y para el resto como un método privado.
o private: Sólo accesible a través de métodos de la propia clase.
  Tipo del valor de retorno: Un método puede devolver un valor a quien lo
llama o no devolver nada. El valor devuelto por un método puede ser de un tipo
primitivo de datos o una referencia, pero nunca  puede devolver más de un
valor. El valor de retorno nunca puede ser un objeto de una superclase, sí
de la misma clase o de una subclase. Si el método no devuelve nada el tipo
devuelto por el método es el tipo void.
 Nombre: Por convenio, los nombres de los métodos comienzan con
minúscula. Si el nombre del método es un nombre compuesto cada nueva
palabra empieza con mayúsculas. Los nombres de los métodos suelen ser
verbos.
Ejemplo:    calcularPerimetro                     pintar               finalizar
 Posible lista de parámetros, la lista de parámetros formales es opcional, la
función podría no tenerlos, en caso de que los haya se trata de variables
locales (sólo accesibles y visibles desde el propio método) separadas por
comas de las que se debe de especificar el tipo y nombre de cada una, se
inicializan en la llamada recibiendo los valores especificados por los
argumentos de la llamada. Aunque la función no lleve parámetros hay que
poner los paréntesis. 
Cuerpo del método:
 Definición de variables locales. Dentro de los métodos se pueden definir
variables que sólo son accesibles dentro del método en donde se han definido. Este
tipo de variables no se inicializan por defecto, y, aunque no se inicialicen en el
momento de su definición se deben de inicializar antes de utilizarlas pues sino el
compilador detecta un error.
 Instrucciones necesarias para realizar determinada tarea.
 La instrucción return devuelve el control de la ejecución al método que hizo la
llamada. Si el método no devuelve nada y se elimina la sentenciareturn la función
termina con la llave final o llave de cierre de la función, en este caso el tipo devuelto
por el método es el tipo void. Si el método retorna un valor, la función no puede ser
del tipo void y la sentencia return además de producir la salida de la función 
especifica el valor de retorno al método que hizo la llamada. En una función puede
haber más de una sentencia return pero sólo se ejecuta una.
 Llamada a un método
 Para que un método se ejecute hay que llamarlo. La llamada o invocación a un
método provoca la ejecución de las instrucciones que lo componen, una vez se
han ejecutado el control de la ejecución vuelve a quien hizo la llamada.
  La llamada al método consta de:
 -  Nombre del método.
 - Posible lista de argumentos, llamados también parámetros
actuales, entre paréntesis y separados por comas.


 Si un método no está definido como static la llamada o invocación al

método hay que hacerla a través de un objeto que pertenezca a la clase
que define el método y se dice que se envía un mensaje al objeto.

 nombreObjeto.nombreMétodo([lista de argumentos])
El método se aplica al objeto de la clase a través del operador punto (.)
En este caso el objeto es siempre el argumento implícito del objeto. Los métodos
pueden tener además argumentos explícitos que son los que van entre paréntesis a
continuación del nombre del método.
Cuando se accede al método de un objeto se interpreta que el objeto ha recibido un
mensaje y el objeto responde al mensaje ejecutando el método. Los mensajes que
puede recibir un objeto se corresponden con el nombre de los métodos de su clase.
Si el método devuelve un valor, la llamada a la función debe de formar parte de una
expresión que recoja el valor retornado por la función.
Métodos de clase o métodos static. 
Son métodos que no tienen como finalidad actuar sobre los atributos privados de los
objetos. Se trata de un bloque de sentencias que se agrupan bajo un mismo nombre
por tener alguna relación lógica que las encamina a realizar una tarea específica.  
Se aplican en general donde se necesiten, al no actuar sobre objetos, no pueden
acceder a un miembro no static, los objetos no son el argumento implícito en la
llamada, (no actúan sobre objetos concretos a través del operador punto (.), pero
pueden recibir objetos de su clase como argumentos explícitos). Un miembro static
si puede ser accedido a través de métodos no static.
IMPORTANTE
- Los métodos static no pueden acceder a variables ni llamar a métodos no
static.
- Los métodos y variables static si pueden ser accedidos o llamados desde 
miembros no static.
Los métodos estáticos se crean anteponiendo al nombre del método la palabra static.
Si se define un método como estáticoes posible llamarlo sin crear un objeto. Como
ocurre con los campos, para invocar un método estático hay dos posibilidades:
•   Invocarlo directamente a través del nombre de la clase a la que pertenece.
•   Invocarlo a través de un objeto de la clase previamente creado.
Pero en la llamada se suele utilizar el nombre de la clase en lugar del nombre de un
objeto de la clase.
Esta es la razón por la que el método main es static, para que pueda ser invocado
aunque no exista un objeto de la clase
Los métodos y variables de clase es lo más parecido que tiene Java a las funciones y
variables globales de C/C++.
El método main

Toda aplicación Java ha de tener un método main y sólo uno, es el punto de entrada

y salida de la aplicación, es public, static y no devuelve nada. Generalmente en una
clase se definirá más de un método. Cuando tras compilar la clase se ejecuta, Java
busca el método llamado main y comienza ejecutando el programa desde él. Si no
existe el método mainse produce un error.
Cuando una clase contiene varios métodos, el método mainsuele ser el último en
describirse
Paso de parámetros a una función o método. 
Los parámetros de una función son variables locales que se inicializan en el
momento de la llamada al método. Fuera de la función no se conocen y no pueden ser
accedidas. Se crean al entrar en la función y se destruyen al salir de ella.
El paso de parámetros o argumentos a las funciones se puede hacer de dos formas:
-         Paso por valor
-         Paso por  referencia 
Paso por valor
Los parámetros de la función reciben una copia del valor de los argumentos de la
llamada.
Las modificaciones que se hagan sobre los parámetros formales no afectan al valor
de los parámetros actuales.
Es el único modo de pasar las variables de los tipos básicos o primitivos.
Paso por dirección o referencia

Los parámetros formales reciben una copia de la referencia a un objeto. Los

parámetros formales serán por tanto de  tipo referenciado.
Es la forma de pasar los objetos a las funciones y la única forma de poder
modificar dentro de un método una variable de tipo primitivo es incluyéndola
como variable miembro de una clase y pasar como argumento una referencia a un
objeto de dicha clase.
El método actua directamente sobre el objeto, si modifica sus datos una vez termine la
ejecución del método los objetos quedan modificados.  
Con este paso de parámetros se permite, de una forma implícita, que una función
devuelva más de un valor a la función que la llama.

constructores y destructores declaración

,uso y aplicaciones
Para crear un objeto se necesita reservar suficiente espacio en memoria e inicializar
los valores de los campos que representan el estado del objeto. Este trabajo es
realizado por un tipo especial de método denominado constructor.

Constructor
Un método constructor de una clase es un método especial que: tiene el mismo
nombre que la clase y  no tiene tipo de retorno.  La sintaxis para la declaración de un
método constructor es:

[atributos] [modificadores] <identificador> ( [parámetros] ) [inicializador]

{
// Cuerpo del constructor.
}
Donde: atributos (opcional) es información declarativa adicional, modificadores
(opcional) se restringen a extern y a los modificadores de acceso, identificador es el
nombre del método constructor (igual al nombre de la clase), parámetros (opcional) es
la lista de parámetros pasados al constructor, inicializador (opcional). Con el
inicializador, el constructor invoca previamente a otro constructor.
El inicializador puede ser uno de los siguientes: base([listaDeParámetros])
this([listaDeParámetros])
Cuerpo del constructor es el bloque de programa que contiene las instrucciones para
inicializar la instancia de clase (objeto).
Destructor
La sintaxis para declarar un destructor es:
[Atributos] ~ <Identificador> ( ) 
{
// Cuerpo del destructor.
}
Una clase solamente puede tener un destructor. Los destructores no pueden
heredarse o sobrecargarse, los destructores no pueden invocarse, sino que son
invocados automáticamente, un destructor no acepta modificadores ni parámetros, por
ejemplo, la siguiente es una declaración de un destructor para la clase Figura:
~ Figura()
{
// Instrucciones para limpiar.
}
La destrucción por defecto: Recogida de basura

El intérprete de Java posee un sistema de recogida de basura, que por lo general

permite que no nos preocupemos de liberar la memoria asignada explícitamente.
El recolector de basura será el encargado de liberar una zona de memoria dinámica
que había sido reservada mediante el operador new, cuando el objeto ya no va a ser
utilizado más durante el programa (por ejemplo, sale del ámbito de utilización, o no es
referenciado nuevamente).
El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que
ya no estén referenciados.
La destrucción personalizada: finalize

A veces una clase mantiene un recurso que no es de Java como un descriptor de

archivo o un tipo de letra del sistema de ventanas. En este caso sería acertado el
utilizar la finalización explícita, para asegurar que dicho recurso se libera. Esto se
hace mediante la destrucción personalizada, un sistema similar a los destructores de
C++.
Para especificar una destrucción personalizada se añade un método a la clase con el
nombre finalize.

SOBRE CARGA DE METODOS

La sobrecarga de métodos consiste en poner varios métodos con el mismo nombre en la misma
clase, pero siempre que su lista de argumentos sea distinta. Ojo, repito, siempre que su lista de
argumentos sea distinta, es decir, no puede haber dos métodos que se llamen igual con la
misma lista de argumentos, aunque devuelvan datos de distinto tipo. El compilador sabría a
cuál de todas las sobrecargas nos referimos por los argumentos que se le pasen en la
llamada, pero no sería capaz de determinar cuál de ellas debe ejecutar si tienen la misma
lista de argumentos. Por ejemplo, no podríamos sobrecargar el método NuevoIngreso de este
modo:
 
public int NuevoIngreso(double cantidad) //Error. No se puede sobrecargar
así
{...}
 
A pesar de devolver un valor int en lugar de un bool, su lista de argumentos es idéntica, por lo que
el compilador avisaría de un error. Sin embargo, sí podríamos sobrecargalo de estos modos:
 
public bool NuevoIngreso(single cant)
{...}
 
public int NuevoIngreso(double cantidad, double argumento2)
{...}
 
public int NuevoIngreso(single cantidad, double argumento2)
{...}
 
Cada sobrecarga tiene marcado en negrilla el elemento que la hace diferente de las demás. Y así
hasta hartarnos de añadir sobrecargas. Hay un detalle que también es importante y que no quiero
pasar por alto: lo que diferencia las listas de argumentos de las diferentes sobrecargas no es
el nombre de las variables, sino el tipo de cada una de ellas. Por ejemplo, la siguiente
sobrecarga tampoco sería válida:
 
public bool NuevoIngreso(double num) //Error. No se puede sobrecargar así
{...}
 
A pesar de que el argumento tiene un nombre distinto (num en lugar de cantidad), es del mismo
tipo que el del método del ejemplo, por lo que el compilador tampoco sabría cuál de las dos
sobrecargas ejecutar.
 
Bueno, supongo que ahora vendrá la pregunta: ¿Cuál de todas las sobrecargas válidas ejecutará si
efectúo la siguiente llamada?
 
MisCuentas.NuevoIngreso(200.53);
 
Efectivamente, aquí podría haber dudas, ya que el número 200.53 puede ser tanto double, como
single. Para números decimales, el compilador ejecutará la sobrecarga con el argumento de tipo
double. En el caso de números enteros, el compilador ejecutará la sobrecarga cuyo argumento
mejor se adapte con el menor consumo de recursos (int, uint, long y unlong, por este orden). Y
ahora vendrá la otra pregunta: ¿y si yo quiero que, a pesar de todo, se ejecute la sobrecarga con el
argumento de tipo single? Bien, en ese caso tendríamos que añadir un sufijo al número para
indicarle al compilador cuál es el tipo de dato que debe aplicar para el argumento:
 
MisCuentas.NuevoIngreso(200.53F);
 
Los sufijos para literales de los distintos tipos de datos numéricos son los siguientes:
 
L (mayúscula o minúscula): long ó ulong, por este orden;
U (mayúscula o minúscula): int ó uint, por este orden;
UL ó LU (independientemente de que esté en mayúsuculas o minúsculas): ulong;
F (mayúscula o minúscula): single;
D (mayúscula o minúscula): double;
M (mayúscula o minúscula): decimal;

Sobrecarga de operadores: Concepto y utilidad, operadores Unarios

y Binarios.

La sobrecarga de operadores es la capacidad para transformar los operadores de un lenguaje como

por ejemplo el +, -, etc, cuando se dice transformar se refiere a que los operandos que entran en
juego no tienen que ser los que admite el lenguaje por defecto. Mediante esta técnica podemos
sumar dos objetos creados por nosotros o un objeto y un entero, en vez de limitarnos a sumar
números enteros o reales, por ejemplo.
La sobrecarga de operadores ya era posible en c++ y en otros lenguajes, pero sorprendentemente
java no lo incorpora, así que podemos decir que esta característica es una ventaja de c# respecto a
java, aunque mucha gente, esta posibilidad, no lo considera una ventaja porque complica el código.

A la hora de hablar de operadores vamos a distinguir entre dos tipos, los unarios y los binarios. Los
unarios son aquellos que solo requieren un operando, por ejemplo a++, en este caso el operando es
'a' y el operador '++'. Los operadores binarios son aquellos que necesitan dos operadores, por
ejemplo a+c , ahora el operador es '+' y los operandos 'a' y 'c'. Es importante esta distinción ya que
la programación se hará de forma diferente.

Los operadores que podemos sobrecargar son los unarios, +, -, !, ~, ++, --; y los binarios +, -, *, /,
%, &, |, ^, <<, >>. Es importante decir que los operadores de comparación, ==, !=, <, >, <=, >=, se
pueden sobrecargar pero con la condición que siempre se sobrecargue el complementario, es decir,
si sobrecargamos el == debemos sobrecargar el !=

Operadores Unarios

En esta sección se verá cómo sobrecargar los operadores unarios, es decir aquellos que toman un
solo operando, como por ejemplo a++. El prototipo de los métodos que van a sobrecargar
operadores unarios será:
public static Operando operator++(Operando a)
 Como antes sustituyendo el ++ por cualquier operador unario. El ejemplo dentro de nuestra clase
de números complejos sería:

public static ComplexNum operator++(ComplexNum a) 

         {
         
           float auximg = a.Img;
           float auxreal = a.Real;
         
           return new ComplexNum(++auxreal, ++auximg);
         }

Operadores binarios

Para empezar vamos a sobrecargar el operador suma('+') para que al sumar dos objetos de la clase
ComplexNum, es decir dos números complejos obtengamos un número complejo que será la suma
de ambas partes. Cabe destacar que los prototipos para sobrecargar operadores serán:
public static Operando operator+(Operando a, Operando b)
Este es el prototipo para el operador +, el resto de operadores binarios van a seguir el mismo patrón.
Por tanto el código del método de sobrecarga será el siguiente:

public static ComplexNum operator+(ComplexNum a, ComplexNum b) 

         {
           return new ComplexNum(a.Real + b.Real, a.Img + b.Img);
         }

Este método sobrecarga el operador suma para que podamos sumar dos números
complejos. Un dato a tener en cuenta es que los métodos que sobrecargan operadores
deben ser static. Como se ve en el código los operandos son 'a' y 'b', que se reciben como
parámetro y el resultado de la operación es otro número complejo que es el que retorna el
método. Por tanto se limita a crear un nuevo número complejo con ambas partes
operadas. De la misma forma podemos crear la sobrecarga del operador resta('-') para
que lleve a cabo la misma función:

public static ComplexNum operator-(ComplexNum a, ComplexNum b) 

         {
           return new ComplexNum(a.Real - b.Real, a.Img - b.Img);
         }

Como vemos el método es idéntico solo que sustituyendo los + por -. En este caso el
trabajo que hacemos dentro del método es trivial pero podría ser tan complejo como se
quisiera.

Herencia.
La herencia en java

Java permite el empleo de la herencia, característica muy potente que permite definir una clase
tomando como base a otra clase ya existente. Esto es una de las bases de la reutilización de código,
en lugar de copiar y pegar.

En java, como ya vimos la herencia se especifica agregando la claúsula extends después del nombre
de la clase. En la claúsula extends indicaremos el nombre de la clase base de la cuál queremos
heredar.
Al heredar de una clase base, heredaremos tanto los atributos como los métodos, mientras que los
constructores son utilizados, pero no heredados.

Ejemplo :

Clase Base
package ejemploherencia;

public class Main {

    public String dueño;
    protected int puerta;
    protected int ruedas;

    protected void caracteristicas(){

        System.out.print(" Es deporitvo");
    }  
    public static void main(String[] args) {
      boolean acceso=true;
      auto obj=new auto(acceso);
        obj.tipo();
    }
}

Clase auto

package ejemploherencia;

public class auto extends Main {

    private boolean descapotable;
    public auto(boolean acceso){
        descapotable=acceso;
    }

public void tipo(){

    if(descapotable){
        caracteristicas();

   }
    else
        System.out.print("no es deportivo");