En este capitulo Edu4java trata
sobre :
- Variables Estáticas.
- Métodos Estáticos.
Yo introduciré
un par de cosas mas:
- Concepto de clase, ya que no lo tenía muy claro y me ha ayudado a entender el conjunto del programa un poco mejor.
- Variables tipo doublé.
VARIABLES STATIC.
Empezamos con las variables de tipo
static. Una clase puede tener variables propias
de la clase y no de cada método. Se les llama variables static
o variables de la clase. Las variables static se utilizan
para definir constantes comunes para todos los métodos (u objetos)
de una misma clase o variables que solo tienen sentido para toda la
clase.
Las variables static se crea
anteponiendo la palabra static a su declaración.
Ejemplo:
static
int[]
array
= new
int[5];
static
double
pi
= 3,1416;
Si no se les da
valor en la declaración , las variables de tipo static se
inicializan con los valores por defecto para los tipos primitivos de
las variables (false para boolean, carácter nulo para
char y cero para los tipos numéricos) y con null
si es una referencia.
Las variables
miembro static se crean en el momento en que puedan ser
necesarias:
- cuando se va a crear el primer objeto de la clase.
- en cuando se llama al método static
- o cuando se utiliza una variable static de dicha clase.
Lo importante es que
las variables de tipo static se inicialicen antes que
cualquier método (objeto) de la clase.
METODOS STATIC.
Los métodos static o métodos
de clase al igual que las variables de clase, se aplican a su
clase y no a sus instancias.
Se utiliza de también la palabra
static delante del nombre del método para indicar que es un
método de la clase o método static siguiendo esta
norma:
static valorDeRetorno
nombreDeMetodo ( listaDeArgumentos ) {
cuerpoDelMetodo
}
Para acceder a los métodos de una
misma clase se hace de la siguiente forma:
NonbreDelMetodo(); el nombre
del método seguido de paréntesis
Ejemplo:
calculaElPromedioDelAarray();
CONCEPTO DE CLASE
Aquí voy a añadir o intentar
explicar el Concepto de Clase . Una clase es un a agrupación
de datos (variables o Campos) y de funciones (Métodos) que
operan sobre estos datos.
La definición de Clase de hace así:
[public] class
NombreDeLaClase {
// Definicion
de variables y métodos.
}
La palabra
“public” es opcional, si no la ponemos la clase será de
tipo public por defecto y será visible por las demás clases
del package. Los métodos y variables deben estar definidas
dentro del bloque de la clase (definido por las llaves {} )
Caracteristicas
de una clase:
- Todas la variables y métodos de JAVA deben pertenecer a una clase.
- Si una clase deriva de otra (extends), hereda sus variables y métodos.
- JAVA tiene una jerarquía de clases éstandar de la que pueden derivar las clases que crean los usuarios.
- Una clase solo puede heredar de una clase.
- En un mismo fichero pueden haber varias clases, pero solo una será de tipo public.
- Los métodos de una clase pueden referirse de modo global al objeto de esa clase al que se aplican por medio de la referencia this.
- Si una clase contenida en un fichero no es public, no es necesario que el fichero se llame como la clase.
- Las clases se pueden agrupar en packages, introduciendo una línea al comienzo del fichero de esta forma:
package packageName;
Ejemplo:
package
org.cervinomix.tutorial9;
VARIABLES TIPO DOUBLE:
Las variables de tipo “doublé”
corresponden a :
Números de 8 bytes (unas 15 cifras
decimales equivalentes). De -1.79769313486232E308 a
-4.94065645841247E-324 y de 4.94065645841247E-324 a
1.79769313486232E308.
Pero resumiendo un poco serían
números decimales o fraccionarios, para que nos entendamos.
Aquí os dejo el vídeo de edu4java
que ha realizado un magnifico trabajo con sus vídeo tutoriales.
EJEMPLO
1:
package
org.cervinomix.tutorial9;
import
java.util.Scanner;
public
class
Tutorial9a {
public
static
void
main(String[] args) {
Scanner
scanner = new
Scanner(System.in);
// Crea
una
variable scanner para
leer lo
que
ingresemos
// por
el teclado.
int[]
array = new
int[5];
// Esta
vez
el "array" se
crea
de
diferente
forma
al
// tutorial
anterior. En
el anterior tutorial le
dábamos
// los
valores
ya
definidos:
// int[]
array = {2,3,5,7,1,4,7,3,0,5};
// En
este
tutorial declaramos
y definimos
la
variable de
// la
siguiente
forma:
// tipoVariable
[] nombreVariable = new tipoVariable[numeroDeEspaciosDelArray]
// int[]
array = new int[5];
// Donde
"int[]
array" es
como
se
declara
la
variable array,
// en
este
caso
es
de
tipo
entero.
// Y
"new int[5]"
es
la
manera
de
definirla,
que
significa
que
// el
largo
(length) del
array es
de
5 espacios,
huecos
o cajoneras
// para
que
nos
entendamos.
"new int[]"
de
nuevo
numero
entero
que
// de
que
tipo
es
el numero
que
hay dentro
de
las
cajoneras.
// Pero
los
valores
de
esos
espacios
no están
definidos
todavía
o
// su
valor por
defecto
es
0.
// INGRESA
EL CONTENIDO DEL ARRAY.
for
(int
i = 0; i < array.length;
i++) {
// Con
este
"for" lo que hacemos es pasar por cada una de las
// cajoneras
del "Array" y darle un valor a través de la
// variable
scanner.
System.out.print("Ingresar
array ["+
i + "]:");
// Imprime:
"Ingresar array[nº de la cajonera]"
array[i]
= scanner.nextInt();
// Utilizamos
la variable "scanner" para pedir un numero entero
// por
la consola "scanner.nextInt()" y este número entero
// se
guarda en la posición "i" del array(array[i]) tal y como
vaya
// variando
"i" su valor iremos ingresando los valores de las
// cajoneras
en el array.
}
// SUMA
EL ARRAY
// En
este trozo del programa sumaremos todos los valores del array
// e
imprimiremos el resultado.
System.out.println("Suma");
// Imprimimos
: Suma
int
acumulador = 0;
// Inicializamos
la variable "acumulador" con valor 0.
for
(int
i = 0; i < array.length;
i++) {
// Con
el "for" vamos pasando por cada una de las cajoneras de
// la
variable "array" gracias a la propiedad de las variables
// de
tipo "array.lenght"
acumulador
= acumulador + array[i];
// En
la línea de código anterior sumamos el valor de la
// variable
"acumulador" que esta inicializada a 0 y sumamos
// el
valor de de tipo entero que hay en la posición "array[0]"
// y
le decimos que la suma resultante sea el nuevo valor de
// la
variable "acumulador". Luego vamos sumando los valores
// de
"array[1]" , "array[2]" , "array[3]" ,
etc..
System.out.print("+"
+ array[i]);
// Imprime
el valor de cada una de las posiciones del array[i]
// con
un simbolo mas delante.
}
System.out.println("="
+ acumulador);
// Imprime
el símbolo igual después de la ultima posición del array
// y
el valor final de la variable acumulador que es la suma de
// todos
los valores que hay en las cajoneras del array
// array[0]+array[1]+array[2]+array[3]+array[4]
// CALCULA
EL MÁXIMO DEL ARRAY
System.out.println("Máximo");
int
max = 0;
// definimos
la variable "max" como tipo “Int” (numerous enteros)
// y
la inicializamos con el valor "0" porque en el "for"
no se le
// da
ningun valor y da error.
for
(int
i = 0; i < array.length;
i++) {
// Con
este for volvemos a pasar por cada una de las cajoneras
// del
array gracias a su variable "array.lenght".
if
(array[i] > max) {
// Con
este "if" comparamos el valor de la variable "max"
// col
el valor de cada cajonera del array.
// De
manera que si el valor de array[0] es mayor que "max"
// se
ejecuta lo que hay dentro del "if".
// Ejemplo:
// Si
array[0] es igual a 2, 2 es mayor que 0 (max = 0)
// se
ejecuta lo que hay dentro del "if"
max
= array[i];
// Aquí
lo que pasa es que si entra dentro del bloque
// del
"if" se le da a la variable "max" el valor del
// array[i]
con lo cual “max” es igual al valor de la cajonera
// del
array
// Ejemplo:
// Si
Si array[0] es igual a 2, entra dentro del bloque y se
// le
asigna el valor de 2 a la variable "max".
// Con
el "for" se va pasando por el array y si hay un valor del
// array[i]
mayor que el valor de la variable "max" se le da
// este
valor a "max" hasta pasar por todo el array. Con lo que
// el
valor de "max" seria el de mayor valor(array[i]) del array.
}
}
System.out.println(max);
// Imprime
la variable "max" a la que se le ha asignado el valor
// máximo
contenido en el array
// CALCULA
EL PROMEDIO DEL ARRAY.
System.out.println("Promedio");
// Imprime
"Promedio"
double
promedio = 0;
// Inicializamos
la variable "promedio" con valor cero, para
// que
no nos de error en el "for".
// Aquí
utilizamos una variable de tipo "double" ya que el valor
// resultante
puede ser un decimal.
for
(int
i = 0; i < array.length;
i++) {
// Con
este for volvemos a pasar por cada una de las cajoneras
// del
array gracias a su variable "array.lenght".
promedio
= promedio + array[i];
// Aquí
vamos sumando a "promedio" (inicializado a 0) cada
// uno
de los valores de array[i].
// Ejemplo:
// array
= {1,2,4,6,3}
// ira
sumando la primera vez que pase por el "for"
// sumara
promedio + array[0]
// 0+1
= 1; y le dará el valor 1 a "promedio"
// La
segunda vez sumara promedio + array[1]
// 1
+ 2 = 3
// y
así sucesivamente hasta llegar al final del array
// cuyo
valor será de 16
// promedio
= 16
}
promedio
= promedio / array.length;
// Aquí
dividimos el valor resultante de "promedio" después de
// terminar
el bucle "for" por la longitud del
// array
(array.length), dando como resultado el promedio.
// Ejemplo:
// siguiendo
el ejemplo anterior
// promedio
= promedio / array.length
// promedio
= 16/5 = 3,2
// El
valor resultante es un numero no entero por eso la variable
// debe
ser de tipo "double". Si lo hubiésemos puesto de tipo
// "int"
el valor seria de tipo entero y veríamos que redondea
// al
numero entero mas cercano, en este caso seria el 3
System.out.println(promedio);
// Imprimimos
la variable promedio
}
}
EJEMPLO
2:
En este segundo ejemplo no se
explicara el código de dentro de los métodos, creo que está
bastante claro en el ejemplo anterior. Me limitare a editar la parte
que se refiere a los métodos y como se relacionan.
package
org.cervinomix.tutorial9;
import
java.util.Scanner;
//
EN ESTE TUTORIAL VEREMOS COMO FRACCIONAR UN PROGRAMA CON
//
VARIOS METODOS PARA SIMPLIFICARLO.
public
class
Tutorial9b {
static
Scanner scanner
= new
Scanner(System.in);
static
int[]
array
= new
int[5];
// El
"static" de
las
variables anteriores
dice que
la
variable "scanner"
// y
la
variable "array" van a pertenecer
a la
clase
Tutorial9 directamente.
// De
esta
forma
cualquiera
de
los
métodos
de
la
clase
pueden
// acceder
a estas.
public
static
void
main(String[] args) {
/* En
la
línea
anterior se
puede
ver
lo
siguiente:
// -main:
método
principal
// -void:
quiere
decir
que
el método
al
que
acompaña
no
// devuelve
nada.
// -"static":
quiere
decir
que
el método
"main" pertenece
// a
la
clase
"Tutorial9b".
// -public:
???*/
// LLAMAR
ingresaElContenidoDelArray();
// De
esta
manera
a un
método
un
método
diferente
al
"main"
// dentro
de
la
clase
"tutorial".
// Pulsando
CRTL y pulsando
con
el ratón
nos
lleva
donde
está
escrito
// el
código
de
este
metodo.
sumaDelArray();
calculaElMaximoDelArray();
// No
es
conveniente
usar
acentos
en
los
nombres
de
métodos,
// variables,
etc.
// Ejemplo:
// calculaElMáximoDelArray
<--- NO PONER EL ACENTO
// El
acento
en
Máximo
podría
traer
problemas.
calculaElPromedioDelAarray();
}
private
static
void
calculaElPromedioDelAarray() {
System.out.println("Promedio");
double
promedio = 0;
for
(int
i1 = 0; i1 < array.length;
i1++) {
promedio
= promedio + array[i1];
}
promedio
= promedio / array.length;
System.out.println(promedio);
}
private
static
void
calculaElMaximoDelArray() {
System.out.println("Máximo");
int
max= 0;
for
(int
i = 0; i < array.length;
i++) {
if
(array[i]
> max) {
max
= array[i];
}
}
System.out.println(max);
}
private
static
void
sumaDelArray() {
System.out.println("Suma");
int
acumulador = 0;
for
(int
i = 0; i < array.length;
i++) {
acumulador
= acumulador + array[i];
System.out.print("+"
+ array[i]);
}
System.out.println("="
+ acumulador);
}
private
static
void
ingresaElContenidoDelArray() {
// Este
método
es
void (no devuelbe
nada)
static (que
pertenece
a la
// clase
Tutorial9 y private (LO VEREMOS EN EL SIGUIENTE TUTORIAL).
for
(int
i = 0; i < array.length;
i++) {
// En
la línea anterior "array.length" necesita acceder a la
// variable
"array", para que esta pueda ser accedida por este
// el
método "ingresaElContenidoDelArray" debe estar ubicada
// dentro
de la clase "Tutorial9", pero no dentro del
// metodo
"main". Si estuviera dentro del método "main"
este
// método
(ingresaElContenidoDelArray) no podría acceder a ella.
// para
ello la variable "array" debe ser de tipo "static"
System.out.print("Ingresar
array ["+
i + "]:");
array[i]
= scanner.nextInt();
}
}
}
No hay comentarios:
Publicar un comentario