Bucles determinados
Son
aquellos que sabemos de antemano cuantas veces se repetirá
·
For
·
For-each
For
Sintaxis
For (inicio bucle; condición; contador bucle) {
código….
}
|
Inicio bucle: Normalmente la iniciaremos con una
variable a la que le daremos valor en ese momento, este tipo variables para
identificarlas mejor podemos llamarlas i,j,z…
Condición: Es aquello que tiene que cumplirse para
que continúe ejecutándose el bucle.
Contador bucle: Forma de incrementar o decrecer
Ejemplo: Crearemos un número aleatorio de veces que se
repetirá nuestro nombre en la ventana de inmediato.
public class Practica15_Bucles_determinados_For {
public static void main(String[] args) {
int numero=(int)(Math.random()*10);
String nombre="david";
for(int i=0; i<numero ;i++ ) {
System.out.println(nombre);
}
System.out.print("el nombre se ha repetido "+numero+" veces ");
}
}
Ejemplo2: Aparecerá una
ventana emergente que nos pedirá nuestro correo electrónico, Cuando lo
introduzcamos valorará en primer lugar si el char @ está en el mail introducido
y por otra parte si hemos puesto un punto.
import javax.swing.JOptionPane;
public class Practica16_Bucles_determinado_for2 {
public static void main(String[] args) {
boolean arroba=false;
boolean Punto=false;
int Contador_arrobas=0;
int Contador_punto=0;
String mail= JOptionPane.showInputDialog("introduce tu email");
for (int i = 0 ; i< mail.length();i++) {
if (mail.charAt(i)=='@') {
Contador_arrobas++;
arroba= true;
}
if (mail.charAt(i)=='.') {
Contador_punto++;
Punto=true;
}
}
if (arroba==true && Punto==true && Contador_arrobas ==1 && Contador_punto ==1) {System.out.println("Correo correcto");}
else if (arroba==false || Contador_arrobas >1 || Punto==false || Contador_punto>1 ) {System.out.println("intentalo otra vez Sam");}
}
}
Ejemplo3:
Existe una propiedad del
objeto array lenght que nos indica
la longitud de una matriz y nos resulta muy útil para recorrer un array.
public class Practica19_Bucles_determinados_for5_arrays_length
public static void main(String[] args) {
int[]array= {10,20,30,50,60,-658,1,2,3,4,5,6,-1,-2,-3,-4,-5,-6,-7,-8,-9};
for (int i=0; i<array.length ;i++) {
System.out.println("en posició "+i+" esta el numero "+array[i]);
}
}
}
MATRICES
(ARRAYS O ARREGLOS)
Una
matriz es una estructura de datos que nos permite almacenar una gran cantidad
de valores del mismo tipo. El tamaño que va a tener el array lo determinaremos
en el inicio.
SINTAXIS
Int
|
[]
nombre_array=new
|
Int
|
[número
valores almacemados]
|
Long
|
Long
|
||
Short
|
short
|
||
Doublé
|
double
|
Ejmplo. Declaramos una
matriz de elementos que sean números
enteros.
3
|
6
|
8
|
10
|
20
|
Posición
0
|
Posición
1
|
Posición
2
|
Posición
3
|
Posición
5
|
La declaramos:
Int[] array = new int [5];
Ahora la iniciaremos
(cargar los datos). Siempre la iniciaremos desde 0, por lo que un array de 5
posiones irá del 0 la 4.
Array [0]= 3;
Array [1]= 6;
Array [2]= 8;
Array [3]= 10;
Array [4]= 20;
También la podríamos
declarar en línea.
Int[] array = {3,8,10,20};
BUCLE FOR EACH
Es un método más tapido para recorrer un bucle.
SINTAXIS
For (
|
String
|
Variable : variable a recorrer){código…}
|
Int
|
||
Long
|
Ejmplo 1:
public class Practica20_Bucles_determinado_ForEach {
public static void main(String[] args) {
String []dias_semana=new String[7];
int contador =0;
for (int i=0;i<dias_semana.length;i++) { dias_semana[i]
=JOptionPane.showInputDialog("dime el
dia "+ (i+1));
}
for (String j:dias_semana) {
contador++;
System.out.println(" el dia de la
semana "+contador + " es "+j);
}
MATRICES
BIDIMENSIONALES
Para conseguir un array en dos dimensiones introduciremos un
array dentro de otro. Para encontrar una semejanza pensemos en una tabla.
0,0
|
1,0
|
2.0
|
3.0
|
0.1
|
1.1
|
2.1
|
3.1
|
0.2
|
1.2
|
2.2
|
3.2
|
Este array lo declararíamos de la siguiente manera:
Int [ ] []array =
new int [numero columnas][numero filas];
Int [ ] [ ] array = new int [4][3];
Otra forma es hacerlo in line:
Int [ ] []array = { {10,5,63,90,2,3} , {1,93,58,20,58} {10,15,20,30,40,50,60} , {1,2,3,4,5,6,7,8}};
Ejmplo 1:
En el siguiente ejercicio crearemos un array en dos
dimensiones que rellenaremos con números aleatorios e imprimiremos en la
ventana de inmediato. Para poderlo realizar necesitaremos crear un bucle for
anidado (un for dentro de otro).
public class Practica21_Matrices_Bidimensionales {
public static void main(String[] args) {
int[][] array=new int [4][5];
for (int i =0; i<4;i++) {
for (int j=0;j<5;j++) {
array[i][j]= (int)(Math.round((Math.random()*100)));
System.out.println("En la posición( "+ i +"
, "+j+ ") : " + array[i][j]);
}
System.out.print("\n");
}
}
}
Ejemplo2:
En este caso crearemos registro de forma
aleatoria (Math.random) y los imprimiremos en la venta de inmediato, pero en
esta ocasión utilizaremos un bucle for each.
public class Practica23_Matrices_Bidimensionales_forEach
{
public static void main(String[] args) {
int matriz [][]=new int [5][10];
for (int [] TodaLAmatriz:matriz) {
System.out.println("");
for (int posicion_actual:TodaLAmatriz) {
posicion_actual =(int)Math.round((Math.random()*100));
System.out.print(posicion_actual +" "); }
}
}
}
Ejemplo3:
En el siguiente caso tenemos una tabla de exceel en la que existen
una serie de interés que cargan sobre unos capitales iniciales, generando
incrementos sobre capital.
10%
|
11%
|
12%
|
13%
|
14%
|
15%
|
10000,00
|
10000,00
|
10000,00
|
10000,00
|
10000,00
|
10000,00
|
11000,00
|
11100,00
|
11200,00
|
11300,00
|
11400,00
|
11500,00
|
12100,00
|
12321,00
|
12544,00
|
12769,00
|
12996,00
|
13225,00
|
13310,00
|
13676,31
|
14049,28
|
14428,97
|
14815,44
|
15208,75
|
14641,00
|
15180,70
|
15735,19
|
16304,74
|
16889,60
|
17490,06
|
public class Practica24_Matrices_Bidimensionales_forEach2 {
public static void main(String[] args) {
double acumulado, interes=0.1;
double[][] saldo= new double [6][5];
for (int i=0; i<6;i++) {
saldo[i][0]=10000;
acumulado=10000;
for (int j=1;j<5;j++) {
acumulado=acumulado+(acumulado*interes);
saldo[i][j]=acumulado;
}
interes=interes+0.01;
}
for(double[] TodalaMatriz:saldo) {
System.out.print(" ");
for (double posicionActual:TodalaMatriz) {
System.out.printf("%1.2f",posicionActual);
System.out.print(" ");
}
System.out.println(" ");
}
}
}
POO
POO
surgen entre las décadas de los 60/70 y
son las siglas de Programación Orientada a Objetos que viene del Inglés
OOP (Object Oriented Programming). Es un paradigma informático que en su
momento revolucionó la forma de programar, anteriormente la programación estaba
orientada a procedimientos (Fortran, Cobol, Basic, etc), esto generaba una
serie de problemas:
·
El código era muy largo
·
En caso de error era muy complejo de
solucionarlo por otro programador, porque era fácil acabar creando código
espagueti (instrucciones como go to o go sub hacían que el programa saltara
constante mente de un lado a otro).
·
Si existía un error el programa se caía.
·
Era muy complicado reutilizar un programa para
otro que fuera parecido.
Para resolver
todos estos problemas se generó POO. El programa que creamos se subdivide en
pequeños programas u objetos (módulos o clases), independientes que al final se
unen formando un todo (modularización). Cada
objeto va a tener una serie de
características (un estado, unas
propiedades o atributos y un
comportamiento).
Esto nos
facilita mucho las cosas, ¿para qué sirve dividir el programa en objetos?:
·
Si un objeto se cae el resto del programa puede
seguir funcionando, debido a la modularización del programa.
·
Es más fácil detectar en que parte del programa
está fallando ya que iremos directamente al objeto que falla. Tratamiento de
excepciones.
·
Podemos reutilizar cada uno de nuestros objetos
en un nuevo programa (herencia).
·
Encapsulamiento los objetos son completamente
independientes, se comunican entre sí en un punto determinado pero no tiene por
qué depender del resto.
Un objeto tendrá una serie de características:
Un estado:
Como se encuentra en este justo momento (Activo, inactivo; encendido, pagado;
incrementar, decrecer, estático, dinámico…)
Unas propiedades
o atributos: Características del objeto (Color, peso, altura…)
Un comportamiento
o método: ¿Qué puede hacer? (Sumar, restar, dividir, encender, apagar).
Clase:
Modelo donde se redactan las características comunes de un grupo de objetos.
Arrancando con esa base se pueden construir diferentes objetos.
o
Ejm. El tronco de un árbol: todos los
arboles tienen un tronco como base.
§ A
partir de esto existen diferentes objetos: Naranjo, olivo, abedul, pino….
Objeto:
Ejemplar perteneciente a una clase y pose una serie de propiedades y comportamientos.
o
Propiedades (atributos): valor, color,
posición…
o
Comportamientos ¿Qué es capaz de
hacer? : sumar, restar, multiplicar, cambiar de color, modificar su posición en
el espacio, encender, apagar….
Nosotros podremos acceder a las propiedades y comportamiento desde
(pseudocódigo).
Ø Propiedades
o atributos: Son las Variables o constantes que tiene una clase. Para acceder a
las propiedades y modificarlas utilizamos la nomenclatura del punto ( nombre_objeto . propiedad = Valor)
o
Arbol.color=”amarrilo”;
o
Arbol.Altura=2000;
o
Arbol.ancho=50;
Ø Comportamiento
o método: Para acceder a los comportamientos y modificarlas utilizamos la nomenclatura del punto ( nombre_objeto .
método () ).
o
Arbol.Flexividad();
o
Arbol.Crecimineto();
o
Arbol.Enraizamiento();
Ejemplar de clase. Instancia de clase.
Ejemplarizar una clase. Instanciar una clase: Hacer una llamada a una clase
para poderla utilizar.
Ejemplo.
1º.
Crearemos una clase llamada árbol.
package poo_arbol;
public class arbol {
// ATRIBUTOS
int alto,ancho;
String copa,colorHoja;
//le daremos
valor a cada una de las propiedades
COMPORTAMIENTOS O MÉTODOS
public arbol() {
alto = 1500; ancho=50; copa = "redonda" ; colorHoja = "verde";
}
}
2º. Ahora utilizaremos la
Clase árbol para construir el Naranjo.
public class Arbol_Naranjo {
public static void main(String[] args) {
/* Instanciar
una clase. Ejemplar de clase:
* realizamos una llamada al
arbol que es la matriz con una
serie de valores
* prederterminados ya por
nostros y que ahora podemos utilizar o modificar.
*/
arbol Naranjo = new arbol();
System.out.println
("UN NARANJO TIENE: \n\n"
+ "De color de hoja: " + Naranjo.colorHoja + "\n"
+ "con una
altura de: " + Naranjo.alto + "\n"
+ "su
tronco tiene una circunferencia de:
" + Naranjo.ancho + "\n"
+ "Su
compa es :
" + Naranjo.copa + "\n"
);
}
}
Modularización:
Dividir un programa en módulos o ficheros (clases). Cuando construimos un
programa necesitaremos como mínimo dos clases. Siempre existirá una clase
principal donde estará el método main que es en la que se ejecuta el programa. En el
instanciaremos el resto de
clases.
Encapsulamiento/encapsulación:
Es proteger las propiedades o atributos en nuestro caso sería la clase árbol (alto,ancho,copa,colorHoja).
Para ello pondremos el modificador de acceso private delante de las variables. Así evitaremos que
las propiedades o atributos puedan ser modificados en otra clase.
Ejm.
package poo_arbol;
public class arbol {
// ATRIBUTOS
LOS ENCAPSULAMOS CON PRIVATE
private int alto,ancho;
private String copa,colorHoja;
//METODO
CONSTRUCTOR en el que le
damos valor a nuestras variables
public arbol() { alto = 1500; ancho=50; copa = "redonda" ; colorHoja = "verde"; }
}
Métodos: Es la forma que tiene de
comunicarse las clases entre sí, los
conectores.
o
Método
Gettes del inglés get (obtener): Devuelve o capta el
valor de una propiedad sin modificarlo.
§ Public int/String… variable (){return + código
;}
o
Método
Setters del inglés set (establecer): Define o
establece el valor de una propiedad.
§ Public void variable (){codigo}
La palabra void
indica que el método no devuelve ningún valor.
Ejm.
package poo_arbol;
public class arbol {
// ATRIBUTOS
LOS ENCAPSULAMOS CON PRIVATE
private int alto,ancho;
private String copa,colorHoja;
private int oscilacion,absorcion_agua;
private boolean es_de_secano,Es_de_Humedal;
//CONSTRUCTOR
EN EL QUE LE DAMOS VALOR A NUESTRAS VARIABLES
public arbol() { alto = 1500; ancho=50; copa = "redonda" ; colorHoja = "verde"; }
// METODO
GETTER: permite mostrar
public int r_alto() {return alto;} //método getter
public int r_ancho() {return ancho;} // método getter
public String r_copa() {return copa;} // método
getter
public String r_colorHoja() {return colorHoja;} // metodo getter
// METODO
SETTER: modifica valores de las variables
public void setter_oscilacion() {oscilacion=20;}
public void setter_absorcion() {absorcion_agua=50;}
public void setter_es_de_secano() {es_de_secano=true;}
public void setter_Es_de_Humedal() {Es_de_Humedal=false;}
}
AHORA
EN EL METODO MAIN REALIZAREMOS LA ACCIÓN
package poo_arbol;
public class Arbol_Naranjo {
public static void main(String[] args) {
/* instanciar
una clase. ejemplar de clase:
* realizamos una llamada al
arbol que es la matriz con una
serie de valores
* prederterminados ya por
nostros y que ahora podemos utilizar o modificar.
*/
arbol Naranjo = new arbol();
System.out.println
("UN NARANJO TIENE: \n\n"
+ "De
color de hoja:
" + Naranjo.r_colorHoja() + "\n"
+ "con una
altura de: " + Naranjo.r_alto() + "\n"
+ "su
tronco tiene una circunferencia de:
" + Naranjo.r_ancho () + "\n"
+ "Su
compa es :
" + Naranjo.r_copa () +
"\n"
);
}
Ejemplo 2
Crearemos
la clase cliente y posterior mente desde el método generamos setter y getter
para posteriormente llamarlos desde nuestro método main.
public CLIENTE() { Nombre= ""; Apellido_1=""; Apellido_2="";DNI="";correo="";telefono=0;}
//SETTER
set establecer
public void set_Nombre(){Nombre =JOptionPane.showInputDialog("NOMBRE");}
public void set_Apellido_1(){Apellido_1 = JOptionPane.showInputDialog("PRIMER APELLIDO");}
public void set_Apellido_2(){Apellido_2 =JOptionPane.showInputDialog("SEGUNDO APELLIDO");}
public void set_DNI() { DNI =JOptionPane.showInputDialog("DNI");}
public void set_correo(){correo=JOptionPane.showInputDialog("CORREO");}
public void set_telefono(){telefono Integer.parseInt(JOptionPane.showInputDialog("TELEFONO"));}
// GETTER get
obtener
public String get_Nombre() { return Nombre;}
public String get_Apellido_1() { return Apellido_1;}
public String get_Apellido_2() { return Apellido_2;}
public String get_DNI() { return DNI;}
public String get_correro() { return correo;}
public int get_telefono() { return telefono;}
}
AHORA
EN EL METODO MAIN REALIZAREMOS LA ACCIÓN
package BBD_Clientes;
public class Insertar_clientes {
public static void main(String[] args) {
//LLAMADA AL CONSTRUCTOR
(INSTANCIAR)
CLIENTE uno = new CLIENTE();
//LLAMAMOS
AL METODO setter set establecer , para dar valor
uno.set_Nombre();
uno.set_Apellido_1();
uno.set_Apellido_2();
uno.set_DNI();
uno.set_telefono();
uno.set_correo();
//llamamos
al método GETTERS get obtener, para ver el
valor.
System.out.println(uno.get_Nombre());
System.out.println(uno.get_Apellido_1());
System.out.println(uno.get_Apellido_2());
System.out.println(uno.get_DNI());
System.out.println(uno.get_telefono());
System.out.println(uno.get_correro());
}
Paso
por parámetros: Variable que declaramos dentro de
los paréntesis del método Setters (set establecer) para que cuando lo
instanciemos nos requiera un valor de un tipo.
public void Variable_setter
(String nueva_variable)
{ variable_Setter = nueva_variable;}
ejemplo.
public class CLIENTE {
private String Nombre, Apellido_1, Apellido_2, DNI, correo;
private int telefono;
//CONSTRUCTOR
public CLIENTE() { Nombre= ""; Apellido_1=""; Apellido_2="";DNI="";correo="";telefono=0;}
// SETTERS
set establecer y lo pasamos por parametros
public void set_Nombre(String Nombre_s){ Nombre =Nombre_s;}
public void set_Apellido_1(String Apellido_primero){ Apellido_1 = Apellido_primero;}
public void set_Apellido_2(String
Apellido_segundo) { Apellido_2 =Apellido_segundo;}
public void set_DNI(String dni){ DNI = dni ;}
public void set_correo(String Correo){
correo =Correo;}
public void set_telefono(int Telefono){ telefono =Telefono);}
//GETTERS get
obtener
public String get_Nombre() { return Nombre;}
public String get_Apellido_1() { return Apellido_1;}
public String get_Apellido_2() { return Apellido_2;}
public String get_DNI() { return DNI;}
public String get_correro() { return correo;}
public int get_telefono() { return telefono;}
}
________________________________________________________________
AHORA
EN EL METODO MAIN REALIZAREMOS LA ACCIÓN
package BBD_Clientes;
public class Insertar_clientes {
public static void main(String[] args) {
CLIENTE uno = new CLIENTE(); //LLAMADA
AL CONSTRUCTOR (INSTANCIAR)
//LLAMAMOS
AL METODO setter set establecer , para dar valor y como lo
hemos pasado por parámetros tansolo tenemos que ponerlo en el lugar del
parámetro.
uno.set_Nombre(“david”);
uno.set_Apellido_1("LOPEZ");
uno.set_Apellido_2(“Gozalez”);
uno.set_DNI(“22222222f”);
uno.set_telefono(66666666);
uno.set_correo(“dgim@gg.es”);
//llamamos
al método GETTERS get obtener, para ver el
valor.
System.out.println(uno.get_Nombre());
System.out.println(uno.get_Apellido_1());
System.out.println(uno.get_Apellido_2());
System.out.println(uno.get_DNI());
System.out.println(uno.get_telefono());
System.out.println(uno.get_correro());
}
}
Cuando declaramos una variable
dentro de un setter (set establecer) o getter (get
obtener) y la pasamos por parámetros y la variable del
paramétrica tiene el mismo nombre que la variable de la clase pondremos This. Delante de la variable de clase.
Es importante recordar también que
cuando utilicemos un condicional y tengamos que comparar una variable con un
String nunca utilizaremos ==, en su defecto utilizaremos el método equals (teniendo en cuenta las mayúsculas) o equalsIgnoreCase (no teniendo en cuentas mayúsculas).
Ejm.
if (Si_o_no.equalsIgnoreCase("si"))
{ this.soltero=true;}
if (Si_o_no.equals("NO")) {this.soltero=false;}
Ejm.
package BBD_Clientes;
public class CLIENTE {
private boolean soltero;
//
SETTERS set establecer
public void soltero(String Si_o_no) {
if (Si_o_no.equalsIgnoreCase("si"))
{ this.soltero=true;}
if (Si_o_no.equalsIgnoreCase("NO"))
{this.soltero=false;}
//GETTERS get
obtener
public String soltero(){
if (this.soltero==true) { return "ESTAS SOLTERO REY";}
else {return "buscarle
novia";}
}
}
Herencia: Construir una clase que herede las propiedades y métodos de la clase padre o principal.
ejmplo.
Java.lang.Object
Java.util.Calendar
Java.util.GregorianCalendar.
En este caso la propiedad java.util.GregorianCalendar hereda de java.util.Calendar que a su vez hereda de java.lang.Object. Por lo que java.util.gregorianCalendar tiene las propiedades y métodos de todas ellas.
ejmplo.
Java.lang.Object
Java.util.Calendar
Java.util.GregorianCalendar.
En este caso la propiedad java.util.GregorianCalendar hereda de java.util.Calendar que a su vez hereda de java.lang.Object. Por lo que java.util.gregorianCalendar tiene las propiedades y métodos de todas ellas.
EJEMPLO.
Vamos a tener que hacer un programa en java para tramitar las nóminas
de nuestros empleados:
Generaremos un objeto EMPLEADO
Unas propiedades nombre, sueldo, fecha Alta.
Un método subir sueldo
package poo;
import java.util.*;
public class Uso_empleado {
//
CONSTRUCTOR, PASANDO POR PARAMETROS LOS DATOS (nom,sue,year,mes,dia)
public static void main(String[] args) {
Empleado
empleado1= new Empleado("Perez
Lorenzo",1000, 1980,12,15);
Empleado
empleado2= new Empleado("Felipe
Gonzalez",1100,
1975,05,01);
Empleado
empleado3= new Empleado("Juan Prado",800, 2010,03,30);
//Llamada
a SETTER set establecer
empleado1.subeSueldo(5);
empleado2.subeSueldo(10);
empleado3.subeSueldo(20);
//llamamos
a Geter get obtener
System.out.println("Nombre:
"+empleado1.dame_Nombre()+"
sueldo: "+empleado1.dame_sueldo() + "
Fecha alta:"+empleado1.dame_altaContrato());
System.out.println("Nombre: "+empleado2.dame_Nombre()+" sueldo: "+empleado2.dame_sueldo()+ " Fecha alta:" + empleado2.dame_altaContrato());
System.out.println("Nombre:"+empleado3.dame_Nombre()+"sueldo: "+empleado3.dame_sueldo()+ " Fecha alta:" + empleado3.dame_altaContrato());
}
}
//objeto
Empleado
class Empleado{
//CONSTRUCTOR
PASADO POR PARAMETROS LAS PROPIEDADES
public Empleado(String nom, double sue, int year, int mes, int dia) {
nombre=nom; sueldo=sue ;
GregorianCalendar calendario = new GregorianCalendar(year,mes-1,dia);
altaContrato=calendario.getTime();
}
//getter
get obtener
public String dame_Nombre() { return nombre;}
public double dame_sueldo() {return sueldo;}
public Date dame_altaContrato() {return altaContrato;}
//setter establecer
public void subeSueldo(double porcentaje) { //metodo SUBE SUELDO
double aumento =sueldo*porcentaje/100;
sueldo+=aumento;
}
//creaamos
las variables de clase o propiedades
private String nombre;
private double sueldo;
private Date altaContrato;
}
AHORA VAMOS A HACER LO MISMO CON UN ARRAY Y LO RECORREREMOS CON UN
BUCLE FOR MEJORADO O FOR EACH
Nosotros podemos crear un array utilizando una
clase previamente creada (herencia),
Hasta el momento habíamos visto crear una array
así:
Int
|
[]
nombre_array=new
|
Int
|
[número
valores almacemados];
|
Long
|
Long
|
||
Short
|
Short
|
||
Doublé
|
Doublé
|
Pero
podemos sustituir int, long, short o doublé por nuestra clase Empleado
Clase o
método primitivo
|
[] array= new
|
Clase o
método primitivo
|
[número valores almacemados];
|
EN NUESTRO CASO
|
|||
Empleado
|
[] misEmpleados= new
|
Empleado
|
[3];
|
package poo;
import java.util.*;
public class Uso_empleado {
//
CONSTRUCTOR, PASANDO POR PARAMETROS LOS DATOS (nom,sue,year,mes,dia)
public static void main(String[] args) {
//cremos
un array pero en ligar de : String [] array=
new String[]:lo sustituimos String por la clase
Empleado
Empleado[] misEmpleados= new Empleado [3];
misEmpleados[0]= new Empleado("Perez Lorenzo",1000, 1980,12,15);
misEmpleados[1]= new Empleado("Felipe Gonzalez",1100,1975,05,01);
misEmpleados[2]= new Empleado("Juan Prado",800, 2010,03,30);
// FOR
EACH O FOR MEJORADO
for (Empleado i:misEmpleados) {
// i sustituye
misEmpleados[] y le indica hasta final de array
i.subeSueldo(5);
}
for (Empleado j:misEmpleados) {
// j sustituye
misEmpleados[] y le indica hasta final de array
System.out.println("Nombre: " + j.dame_Nombre()+
" Sueldo:
" +j.dame_sueldo()+ " Fecha Alta "+j.dame_altaContrato())
;
}
}
}
//objeto
Empleado
class Empleado{
//CONSTRUCTOR
PASADO POR PARAMETROS LAS PROPIEDADES
public Empleado(String nom, double sue, int year, int mes, int dia) {
nombre=nom; sueldo=sue ;
GregorianCalendar calendario = new GregorianCalendar(year,mes-1,dia);
altaContrato=calendario.getTime();
}
//getter get obtener
public String dame_Nombre() { return nombre;}
public double dame_sueldo() {return sueldo;}
public Date dame_altaContrato() {return altaContrato;}
//setter establecer
public void subeSueldo(double porcentaje) { //metodo SUBE SUELDO
double aumento =sueldo*porcentaje/100;
sueldo+=aumento;
}
}
//creaamos las variables de clase o propiedades
private String nombre;
private double sueldo;
private Date altaContrato;
}
Uso
del Static: Cada vez que llamamos al constructor estamos
creando una copia de cada una de las variables del objeto de clase (en este ejm EMPLEADOS).
Si lo que deseamos es que una variable del objeto de clase no esté a nuestro
alcance la declararemos como Static.
Usos del this:
public empleados(String nom, String Apellidos) {
public empleados(String nom) { this(nom,"gimenez");}
CREAR
UNA SUB CLASE O CLASE HIJO
CLASS GregorianCalender
La utilizaremos para crear una fecha.
GregorianCalender() nos devolverá la fecha
actual en la zona donde estemos.
GregorianCalender (int year, int month, int dayOfMonth)
reregresa la fecha que le introduzcamos, el mes siempre pondremos mes-1
al venir de un array (enero=0, febrero=1, marzo=2…).
Ejemplo
//objeto
Empleado
class Empleado{
//CONSTRUCTOR
PASADO POR PARAMETROS LAS PROPIEDADES
public Empleado(String nom, double sue, int year, int mes, int dia) {
nombre=nom; sueldo=sue ;
GregorianCalendar calendario = new GregorianCalendar(year,mes-1,dia);
altaContrato=calendario.getTime();
}
//creaamos
las variables de clase o propiedades
private String nombre;
private double sueldo;
private Date altaContrato;
final:
Existen
atributos de clase que una vez llamados por una sub clase se les dará valor y
ya no serán modificados (Nombres, Apellidos, DNI…), Un cliente no puede tener
dos nombres. Estas variables de clase las declararemos como final.
private int Id;
private static int Incremento_id=1;
private final String Apellidos;
private final String nombre;
Uso
del Static: Cada vez que llamamos al constructor estamos
creando una copia de cada una de las variables del objeto de clase (en este ejm EMPLEADOS).
Si lo que deseamos es que una variable del objeto de clase no esté a nuestro
alcance la declararemos como Static.
o
No actúan sobre objetos
o
Nos acceden a campos de ejemplar(variables/constantes
declaradas en la clase), a menos que estas sean también Static.
o
Para llamarlos se utiliza el
nobre_clase.nombre_metodo.
CLASE EMPLEADOS
|
private final String NOMBRE;
private final String APELLIDOS;
private final int Id_Cliente;
|
private Static int Incremento_id;
|
Empleados trabajador1
= new EMPLEADOS ("JUAN","Perez Lopez")
|
Empleados trabajador2
= new EMPLEADOS ("Paco","Palo Largo")
|
Empleados trabajador3
= new EMPLEADOS ("JUAN","Sueño Durmient")
|
private final String NOMBRE;
private final String APELLIDOS;
private final int Id_Cliente;
|
private final String NOMBRE;
private final String APELLIDOS;
private final int Id_Cliente;
|
private final String NOMBRE;
private final String APELLIDOS;
private final int Id_Cliente;
|
JUAN
PEREZ LOPEZ
ID: 001
|
Paco
PALO LARGO
ID: 002
|
Amparo
Sueño Durmient
ID: 003
|
Ejmplo.
Vamos a crear un ejemplo en el que utilizaremos el método static para declarar
una variable que no deseamos que se modifique, porque la utilizaremos para
incrementar un ID.cliente.
package BBD_Clientes;
public class prueva {
public prueva() {
}
public static void main(String[] args) {
empleados
trabajador1= new empleados("paco","Conde Moor");
empleados
trabajador2= new empleados("Lucas", "Grijando
el Grande");
empleados
trabajador3= new empleados("Felipe", "El
Puñetero REy");
empleados
trabajador4= new empleados("Manolo", "manos Tijeras");
System.out.println(trabajador1.return_nombre() +" "+ trabajador1.return_seccion() +" "+trabajador1.return_ID() );
System.out.println(trabajador2.return_nombre() +" "+ trabajador2.return_seccion() +" "+trabajador2.return_ID() );
System.out.println(trabajador3.return_nombre() +" "+ trabajador3.return_seccion() +" "+trabajador3.return_ID() );
System.out.println(trabajador4.return_nombre() +" "+ trabajador4.return_seccion() +" "+trabajador4.return_ID()) ;
}
}
//__________________________________________________________
class empleados{
private int Id;
private static int Incremento_id=1;
private fignal String Apellidos;
private final String nombre;
public empleados(String nom, String Apellidos) {
nombre=nom; this.Apellidos=Apellidos;
Id=Incremento_id;
Incremento_id++; }
//geter
public String return_seccion() {return this.Apellidos; }
public String return_nombre() {return this.nombre;}
public int return_ID() {return Id;}
}
Usos del this:
o
Cuando el parámetro tiene el mismo nombre que la
propiedad de clase para diferenciarlos utilizaremos this.
delante de la propiedad de clase para hacer referencia a esta.
Ejm.
public empleados(String nom, String Apellidos) {
nombre=nom; this.Apellidos=Apellidos;
Id=Incremento_id;
Incremento_id++; }
o
Cuando creamos varios constructores y deseamos
que un parámetro se rellene por defecto.
class empleados{
private final int Id;
private static int Incremento_id=1;
private final String Apellidos;
private final String nombre;
public static int id_siguiente;
// CONSTRUCOR
1º
nombre=nom; this.Apellidos=Apellidos;
Id=Incremento_id;
Incremento_id++;
id_siguiente=Incremento_id;}
//
CONSTRUCTOR 2º
//geter
public String return_seccion() {return this.Apellidos; }
public String return_nombre() {return this.nombre;}
public int return_ID() {return Id;}
CREAR
UNA SUB CLASE O CLASE HIJO
Una clase sub clase heredera
todas las propiedades y métodos de la clase padre o SuperClase. Podrá realizar todas las cosas que su
predecesor más las propiedades y métodos que le creemos en la nueva.
Podríamos tener una clase padre
que sería PROVEEDOR y varias clases hijo o subclase como (Proveedor_algodon,
Proveedor_luz, Proveedor_agua…).
Para crear una SubClase utilizaremos el modificador extends:
public class SuperClase extends SubClase {
public SubClase() {super();……..
//Utilizamos super()para llamar a la
clase padre
}
}
En el
caso de que a la SuperClase o clase
padre tenga parámetros los deberemos pasar cuando la llamemos a la SuperClase
con super().
Ejm.
package BBD_TIENEDA;
public class BBDD {//clase padre o cuperclase
private String Nombre, Apellido1, Apellido2, DNI_NIF;
private int Telefono_contacto;
//CONSTRUCTOR
public BBDD (String nom,String ap1, String
ap2,String DNI_NIF,int Telefono_contacto) {
Nombre=nom;Apellido1=ap1; Apellido2=ap2;
this.DNI_NIF=DNI_NIF;
this.Telefono_contacto=Telefono_contacto; }
// Getter get
obtener
public String getRegresa_datos()
{return "Nombre : "+Nombre + "\n"+
"Apellido: "+ Apellido1 + "\n"+
"Segundo
Apellido: "+Apellido2 + "\n"+
"DNI/NIF: "+this.DNI_NIF+ "\n"+
"Telefono
contato: "+this.Telefono_contacto;}
________________________________________________________________
//sub clase o
clase hijo//
________________________________________________________________
package BBD_TIENEDA;
//creamos la calase PROVEEDORES Y utilizaremos
extends para invocar a la
supercales BBDD
public class PROVEEDORES extends BBDD {
private int Id_proveedor;
private static int Incremoento_id=1;
private final String Nombre_proveedor;
//Pasamos los parámetros de la nueva
clase//
public PROVEEDORES( String nom,
String ap1,
String ap2,
String DNI_NIF,
int Telefono_contacto,
String Nombre_proveedor) {
//LLAMAMOS
A LA CLASE PADRE con super() PASANDOLE LOS PARAMETROS
super(nom, ap1,ap2,DNI_NIF,Telefono_contacto); Id_proveedor=Incremoento_id;Incremoento_id++; this.Nombre_proveedor=Nombre_proveedor;}
public int regresaProveedorId() {return Id_proveedor; } }
________________________________________________________________
//segunda sub
clase o clase hijo de BBDD//
________________________________________________________________
package BBD_TIENEDA;
class CLIENTES extends BBDD {
private int ID_cliente;
private static int Incremoento_id=1;
private String NombreEmpresa;
public CLIENTES ( String nom,
String ap1,
String ap2,
String DNI_NIF,
int Telefono_contacto,
String NombreEmpresa) {
super(nom, ap1, ap2, DNI_NIF,Telefono_contacto);
this.NombreEmpresa=NombreEmpresa; ID_cliente=Incremoento_id;Incremoento_id++; } }
________________________________________________________________
//método MAIN
donde trabajo nuestro programa//
________________________________________________________________
package BBD_TIENEDA;
public class facturador {
public static void main(String[] args) {
//creamos dos arrays Cliente y Proveedor //
CLIENTES[] Cliente = new CLIENTES[10];
PROVEEDORES[]
Proveedor = new PROVEEDORES [10];
//cargamos los datos pasándolos por los parámetros
Cliente [1]= new CLIENTES("DAVID", "GIMENEZ", "PLAZA", "335879R", 111, "COMPRO");
Cliente [2]= new CLIENTES("RODRIGUEZ", "LOPEZ", "DOMENECH", "252598T",112, "RODRIGUEZ
SA");
Proveedor[1]= new PROVEEDORES("MANOLO", "LOLO", "LELE", "000010001R", 114, "LLO
SA");
Proveedor[2]= new PROVEEDORES("DEUDOR", "MUCHO", "SIN PAGAR", "55898879W", 113, "NO
PAGO SL");
System.out.println( Proveedor[1].getRegresa_datos()+ "\n"+ "id Cliente: " +Proveedor[1].regresaProveedorId());
System.out.println( Proveedor[2].getRegresa_datos()+ "\n"+ "id Cliente: " +Proveedor[2].regresaProveedorId());} }
POLIMORFISMO
POLIMORFISMO: El polimorfismo es una relajación del
sistema de tipos, de tal manera que una referencia a una clase (atributo,
parámetro o declaración local o elemento de un vector) acepta direcciones de
objetos de dicha clase y de sus clases derivadas (hijas, nietas…).
Principio de
sustitución: Se puede utilizar un objeto de una sub clase siempre que
el programa espere un objeto de la Superclase. Por lo que un objeto se puede
comportar de diferente manera dependiendo del contexto.
Ejm.
public static void main(String[] args) {
//Aray
Cerdo
Carne [] Cerdo=new Carne[5];
Cerdo[0] = new Carne("Chuletas Aguja", 10.5, 20, 2017, 15, 12, -10, 15);
Cerdo[1] = new Carne ("Panceta", 3.5, 100, 2017, 20, 12, -5, 2);
Cerdo[2] = new Carne ("Chorizo", 5.5, 20, 2017, 01, 12, 2, 1);
Cerdo[3] = new Carne ("Longaniza", 3.5,
50, 2017, 05, 12, 2, 10);
Cerdo[4] = new Carne ("Longanizass", 3.5,
50, 2017, 05, 12, 2, 10);
//aray
Pollo
Carne [] Pollo =new Carne[6];
Pollo[0] = new Carne ("Muslo",3.2,100,2017,20,12,-3,2);
Pollo[1] = new Carne ("Pechuga",3.2,100,2017,20,12,-3,2);
Pollo[2] = new Carne ("Contramuslo",3.2,100,2017,20,12,-3,2);
Pollo[3] = new Carne ("Churrasco",3.2,100,2017,20,12,-3,2);
Pollo[4] = new Carne ("Alitas",3.2,100,2017,20,12,-3,2);
Pollo[5] = new Carne ("Alitasss",3.2,100,2017,20,12,-3,2);
//bucle
for para recorrer array cerdo + pollo y llenar array ArticulosCarne
utilizando POLIMORFISMO o principio SUSTITUCIÓN
Carne [] ArticulosCarne=new Carne[11];
for (int x=0; x<5; x++) {ArticulosCarne[x]= Cerdo[x];}
for (int y=5,x=0;y<11 && x<6;y++,x++){
ArticulosCarne[y]=Pollo[x];
}
Ejercicio completo:
1. UML(unified modeling leguage)
ARTICULOS(String,double, double,int,int,int)
|
- fIdArticulo int
- fDineroInvertido double
- fNombreArticulo String
- sIncrementoId int
- fPCM doublé
- fUnidades double
- fFecha_Compra
Date
- fmes,año,dia int
|
+ PGet_Regresa_id()
+ PGet_Regresa_NombreArticulo()
+ pGet_Regresa_PCM()
+ pGet_Regresa_Uninidades()
+ pGet_Regresa_FechaCompra()
+ pGet_Regresa_Encabezado_datos()
+ pGet_Regresa_Datos_Articulos()
+ pSet_Establece_Stock(int Incremento)
|
Pescado(String,double,doublé,int,
Int,int,double,int,boolean)
|
ARTICULOS(String,double, double ,int ,int,int,int,int)
|
|
super(nom,pcm,uni,year,month,day)
- fTemperatura double
- fTeimpoHastaCaducidad int
- fSalazon_Si_No boolean
- fPVP int
|
super(nom,pcm,uni,year,month,day)
-fTemperatura
double
-fTeimpoHastaCaducidad int
-fPVP double
|
|
Get_Regresa_PVP()
Get_Regresa_Salazon()
Set_Establece_PVP(double)
Set_Establece_Depreciación()
|
Get_regresa_PVP()
Set_Establece_Depreciación()
|
package BBD_ALMACEN;
import java.util.Date;
import java.util.GregorianCalendar;
public class ARTICULOS {
private final int IdArticulo;
private final double DineroInvertido;
private final String NombreArticulo;
private static int IncrementoId=1;
private double PCM; //PRECIO COMPRA MAYORISTA
private double Unidades;
private Date Fecha_Compra;
private final int mes,año,dia;
public ARTICULOS (String nom,double pcm, double uni,int year,int month,int day ) {
NombreArticulo=nom; PCM=pcm; Unidades=uni; año=year; mes=month; dia=day;
DineroInvertido=Unidades*PCM;
// id Statico
IdArticulo=IncrementoId; IncrementoId++;
//
GregorianCalendar para crear variable Date Fecha_Compra
GregorianCalendar
calendario = new GregorianCalendar (año,mes,dia);
Fecha_Compra = calendario.getTime();
}
// GETTER GET
REGRESA
public int Get_Regresa_id() {return IdArticulo;}
public String Get_Regresa_NombreArticulo()
{return NombreArticulo;}
public double Get_Regresa_PCM() {return PCM;}
public double Get_Regresa_Uninidades() {return Unidades;}
public Date
Get_Regresa_FechaCompra() {return Fecha_Compra;}
public String
Get_Regresa_Encabezado_datos(){return
"Id_Articulo "+
"Nombre_Articulo "+
"Precio_compra "+
"Unidades "+
"Fecha_Compra "+
"PVP ";
}
public String Get_Regresa_Datos_Articulos() {return
IdArticulo +" "+
NombreArticulo+" "+
PCM+ " "+
Unidades+" "+
Fecha_Compra; }
//Setter set Establece
public void Set_Establece_Stock(int Incremento) {Unidades=Unidades+Incremento;}
}
_______________________________________________________________
//Clase hijo
Pescado
________________________________________________________________
class Pescado extends ARTICULOS{
private final double Temperatura;
private final int TeimpoHastaCaducidad;
private final boolean Salazon_Si_No;
private int PVP;
public Pescado( String nom, double pcm,
double uni, int year,
int month, int day,
double tem, int TeimpoHastaCaducidad,
boolean Salazon_Si_No) {
super (nom,pcm,uni,year,month,day);
Temperatura=tem;
this.TeimpoHastaCaducidad=TeimpoHastaCaducidad;
this.Salazon_Si_No=Salazon_Si_No;
}
//Getter get obtener
public double Get_Regresa_PVP() {return PVP +Temperatura;}
public boolean Get_Regresa_Salazon() {return Salazon_Si_No;}
//SETTER set establecer
public void Set_Establece_PVP(double incremento) {PVP +=(PVP*incremento);}
public void Set_Establece_Depreciación() {
double TasaDepreciacion=0;
if (TeimpoHastaCaducidad >=15) {
TasaDepreciacion=1;
PVP+=PVP*TeimpoHastaCaducidad;}
if (TeimpoHastaCaducidad >= 10 && TeimpoHastaCaducidad < 15) {
TasaDepreciacion=0.02;
PVP-=PVP*TeimpoHastaCaducidad;}
if (TeimpoHastaCaducidad >= 5 && TeimpoHastaCaducidad < 10) {
TasaDepreciacion=0.25;
PVP-=PVP*TeimpoHastaCaducidad;
}
if (TeimpoHastaCaducidad >= 2 && TeimpoHastaCaducidad < 5) {
TasaDepreciacion=0.50;
PVP-=PVP*TeimpoHastaCaducidad;
}
if (TeimpoHastaCaducidad >= 0 && TeimpoHastaCaducidad < 2){
TasaDepreciacion=0.85;
PVP-=PVP*TeimpoHastaCaducidad;
}
}
}
________________________________________________________________
//clase hijo Carne
________________________________________________________________
class Carne extends ARTICULOS{
private final double Temperatura;
private final int TeimpoHastaCaducidad;
private double PVP;
public Carne(String nom,double pcm, double uni,int year,int month,int day,int tem,int TeimpoHastaCaducidad) {
super(nom,pcm,uni,year,month,day);
Temperatura=tem;
this.TeimpoHastaCaducidad=TeimpoHastaCaducidad;
}
//Getter get obtener
public double Get_regresa_PVP() {return PVP + Temperatura;}
//setter set establecer
public void Set_Establece_Depreciación() {
double TasaDepreciacion=0;
if (TeimpoHastaCaducidad >=20) {
TasaDepreciacion=1;
PVP+=PVP*TeimpoHastaCaducidad;
}
if (TeimpoHastaCaducidad >= 15 && TeimpoHastaCaducidad < 20) {
TasaDepreciacion=0.02;
PVP-=PVP*TeimpoHastaCaducidad;
}
if (TeimpoHastaCaducidad >= 5 && TeimpoHastaCaducidad < 15) {
TasaDepreciacion=0.25;
PVP-=PVP*TeimpoHastaCaducidad;
}
if (TeimpoHastaCaducidad >= 2 && TeimpoHastaCaducidad < 5) {
TasaDepreciacion=0.50;
PVP-=PVP*TeimpoHastaCaducidad;
}
if (TeimpoHastaCaducidad >= 0 && TeimpoHastaCaducidad < 2) { TasaDepreciacion=0.85;
PVP-=PVP*TeimpoHastaCaducidad;
}
}
}
________________________________________________________________
//MÉTODO MAIN (DONSE SE
EJECUTA NUESTRO PROGRAMA//
________________________________________________________________
package BBD_ALMACEN;
public class gestor_Almacen {
public static void main(String[] args) {
//Aray
Cerdo
Carne [] Cerdo=new Carne[5];
Cerdo[0] = new Carne("Chuletas Aguja", 10.5, 20, 2017, 15, 12, -10, 15);
Cerdo[1] = new Carne ("Panceta", 3.5, 100, 2017, 20, 12, -5, 2);
Cerdo[2] = new Carne ("Chorizo", 5.5, 20, 2017, 01, 12, 2, 1);
Cerdo[3] = new Carne ("Longaniza", 3.5,
50, 2017, 05, 12, 2, 10);
Cerdo[4] = new Carne ("Longanizass", 3.5,
50, 2017, 05, 12, 2, 10);
//aray
Pollo
Carne [] Pollo =new Carne[6];
Pollo[0] = new Carne ("Muslo",3.2,100,2017,20,12,-3,2);
Pollo[1] = new Carne ("Pechuga",3.2,100,2017,20,12,-3,2);
Pollo[2] = new Carne ("Contramuslo",3.2,100,2017,20,12,-3,2);
Pollo[3] = new Carne ("Churrasco",3.2,100,2017,20,12,-3,2);
Pollo[4] = new Carne ("Alitas",3.2,100,2017,20,12,-3,2);
Pollo[5] = new Carne ("Alitasss",3.2,100,2017,20,12,-3,2);
//array
cerdo + pollo utilizando POLIMORFISMO o principio
SUSTITUCIÓN
Carne [] ArticulosCarne=new Carne[11];
for (int x=0; x<5; x++) {ArticulosCarne[x]= Cerdo[x];}
for (int y=5,x=0;y<11 && x<6;y++,x++) ArticulosCarne[y]=Pollo[x];}
Pescado[] Tunido =new Pescado[4];
Tunido[0]=new Pescado ("lomos",10,50,2017,01,12,-20,50,true);
Tunido[1]=new Pescado ("Entero",10,50,2017,01,12,-20,50,true);
Tunido[2]=new Pescado ("Medio",10,50,2017,01,12,-20,50,true);
Tunido[3]=new Pescado ("Medio",10,50,2017,01,12,-20,50,true);
System.out.println(Pollo[0].Get_Regresa_Encabezado_datos();
for (Carne j:ArticulosCarne) { j.Set_Establece_Depreciación();
j.Set_Establece_Stock(1000000);
System.out.println(j.Get_Regresa_Datos_Articulos()+
j.Get_regresa_PVP());
}
for (Pescado a:Tunido){a.Set_Establece_Depreciación(); a.Set_Establece_Stock(80000);
a.Set_Establece_PVP(200);
System.out.println(a.Get_Regresa_Datos_Articulos()+
a.Get_Regresa_PVP()+
a.Get_Regresa_Salazon());
}
}
}
REFUNDICIÓN
DE OBJETOS
REFUNDICIÓN
DE OBJETOS
Una refundación en java es modificar el tipo de datos que
tiene una variable. En el siguiente caso Math.random nos facilitaría un double,
pero al realizar una refundación lo convertimos en integer. Ambos son tipos
primitivos de dato.
int aleatorio
=( int)(Math.random ()*100);
Esto mismo lo podemos realizar con los objetos es conocido
como casting.
package BBD_ALMACEN;
public class
gestor_Almacen {
public static void main(String[] args) {
//Aray Articulo donde
inculiremos articulos de pesacado y carne
ARTICULOS [] Articulo=new
ARTICULOS[15];
Articulo[0] = new Carne("Chuletas Aguja", 10.5, 20, 2017, 15, 12, -10, 15);
//realizamos una refundición
al sub objeto carne
Carne
ch_AGUJA=
(Carne) Articulo[0];
//utilizaremos un método
setter de Carne
ch_AGUJA.Set_Establece_Depreciación();
Articulo[1] = new Carne ("Panceta", 3.5, 100, 2017, 20, 12, -5, 2);
Carne
Panceta=(Carne)Articulo[1];
Panceta.Set_Establece_Stock(58555);
Articulo[2] = new Carne ("Chorizo", 5.5, 20, 2017, 01, 12, 2, 1);
Carne
Chorizo= (Carne)Articulo[2];
Chorizo.Set_Establece_Stock(80000000);
Chorizo.Set_Establece_Depreciación();
Articulo[3] = new Carne ("Longaniza", 3.5, 50, 2017, 05, 12, 2, 10);
Carne
Longaniza= (Carne)Articulo[3];
Longaniza.Set_Establece_Stock(80000000);
Longaniza.Set_Establece_Depreciación();
Articulo[4] = new Carne ("Morcilla", 3.5, 50, 2017, 05, 12, 2, 10);
Carne
Morcilla= (Carne)Articulo[4];
Morcilla.Set_Establece_Stock(80000000);
Morcilla.Set_Establece_Depreciación();
Articulo[5]= new Carne("Muslo",3.2,100,2017,20,12,-3,2);
Carne
Muslo= (Carne)Articulo[5];
Muslo.Set_Establece_Stock(80000000);
Muslo.Set_Establece_Depreciación();
Articulo[6]= new Carne ("Pechuga POLLO",3.2,100,2017,20,12,-3,2);
Carne
Pechuga_POLLO= (Carne)Articulo[6];
Pechuga_POLLO.Set_Establece_Stock(3000);
Pechuga_POLLO.Set_Establece_Depreciación();
Articulo[7] = new Carne ("Contramuslo pollo",3.2,100,2017,20,12,-3,2);
Carne Contramuslo_pollo= (Carne)Articulo[7];
Contramuslo_pollo.Set_Establece_Stock(3000);
Contramuslo_pollo.Set_Establece_Depreciación();
Articulo[8]= new Carne ("Churrasco pollo",3.2,100,2017,20,12,-3,2);
Carne
Churrasco_pollo= (Carne)Articulo[8];
Churrasco_pollo.Set_Establece_Stock(3000);
Churrasco_pollo.Set_Establece_Depreciación();
Articulo[9] = new Carne ("Alitas_pollo",3.2,100,2017,20,12,-3,2);
Carne
Alitas_pollo= (Carne)Articulo[9];
Alitas_pollo.Set_Establece_Stock(3000);
Alitas_pollo.Set_Establece_Depreciación();
Articulo[10]= new Carne ("Crestas_pollo",3.2,100,2017,20,12,-3,2);
Carne
Crestas_pollo= (Carne)Articulo[10];
Crestas_pollo.Set_Establece_Stock(3000);
Crestas_pollo.Set_Establece_Depreciación();
//ahora llamamos a la
subclase pescado
Articulo[11]= new Pescado("lomos Bacalado",10,50,2017,01,12,-20,50,true);
//realizamos una refundición
a pesacdo
Pescado
Lomos_Bacalado =(Pescado)Articulo[11];
//ya podemos tulizar
los metodos de pescado
Lomos_Bacalado.Set_Establece_Depreciación();
Lomos_Bacalado.Set_Establece_PVP(2500000);
Lomos_Bacalado.Set_Establece_Stock(20000);
Articulo[12]= new Pescado ("Entero",10,50,2017,01,12,-20,50,true);
Pescado
Entero = (Pescado)Articulo[12];
Entero.Set_Establece_Depreciación();
Entero.Set_Establece_PVP(15000);
Entero.Set_Establece_Stock(250000000);
Articulo[13]= new Pescado ("Medio",10,50,2017,01,12,-20,50,true);
Pescado
Medio =(Pescado)Articulo[13];
Medio.Set_Establece_Depreciación();
Medio.Set_Establece_PVP(888);
Medio.Set_Establece_Stock(100);
Articulo[14]= new Pescado ("Medio2",10,50,2017,01,12,-20,50,true);
Pescado
Medio2 =(Pescado)Articulo[14];
Medio2.Set_Establece_Depreciación();
Medio2.Set_Establece_PVP(888);
Medio2.Set_Establece_Stock(100);
//ahora podemos imprimir
todos los objetos Articulo
for (ARTICULOS a:Articulo) {
System.out.println(a.Get_Regresa_Datos_Articulos()+ a.Get_Regresa_PCM());
}
}
}
CLASS STRING
La clase String se utiliza para almacenar cadena de letras (char) o palabras.
Métodos:
• .Length(): Nos indica el tamaño que tiene una cadena de caracteres.
ejm.
String Nombre = "David"
System.out.Print(Nombre.Length());
Nos imprime en ventana de inmediato:
5
• .charAt(nº posición): Nos regresara la letra que se encuentre en la posición que le indiquemos. Teniendo en cuenta que la posición inicial es la 0.
ejm.
String Nombre = "David"
System.out.println(Nombre.charAT(2);
Nos imprime en ventana de inmediato:
v
• .substring(beginIndex,endIndex): Se utiliza como la función extrae de Exceel. Se compone por dos parámetros: beginIndex (posición inicial) endIndex(posición final.
Ejm.
String Nombre = "David"
System.out.println(Nombre.substring(0,2));
Nos imprime en ventana de inmediato:
Dav
• .equalis(anObject): La utilizaremos para comparar dos variables de tipo String, en ella se tendrá en cuenta tanto mayúsculas como minúsculas. El resultado obtenido sera True o False ( Bolean).
Ejm.
String nom1,nom2;
nom1="David";
nom2="david";
System.out.println(nom1.equalis(nom2));
El resultado sera False al estar una en mayúsculas y otra en minúsculas.
ejm 2.
En el siguiente ejemplo realizaremos una petición de password. El gestor tendrá 3 intentos en caso de no saberla saldrá de nuestro bucle.
String Clave = "David";
String Key="";
byte contador=0;
while(Clave.equals(Key)==false && contador<3){
pass = JOptionPane.showInputDialog("dime un password");
contador++;
System.out.println(contador+" intentos de 3");
• .equalisIgnoreCase(anObject): La utilizaremos para comparar dos variables de tipo String, en ella no se tendrá en cuenta ni mayúsculas ni minúsculas. El resultado obtenido sera True o False ( Bolean).
Ejm.
String nom1,nom2;
nom1="David";
nom2="david";
System.out.println(nom1.equalisIgnoreCase(nom2));
El resultado será True al no tener en cuenta mayúsculas y otra en minúsculas.
• .replace(charsequence target, charsequence replacement): Lo utilizamos para sustituir una cadena de texto por otra. Sustituirá todas las cadenas que coincidan con la cadena buscada. Se compone de dos parámetros:
o charsequence target: cadena Objetivo o cadena buscada.
o charsequence replacement: Cadena por la que remplazamos.
Ejm.
String nombre="Esta casa es una ruina.";
System.out.print(nombre.replace("ruina", "mina"));
Console: Esta casa es una mina.
• replacefirst(string regex, string replacement): Lo utilizamos para sustituir una cadena de texto por otra. Sustituirá solo la primera cadenas que coincidan con la cadena buscada. Se compone de dos parámetros:
o charsequence regex: cadena Objetivo o cadena buscada.
o charsequence replacement: Cadena por la que remplazamos.
String nombre="Esta casa es una ruina.";
System.out.println(nombre.replace("a", "XXXX"));
System.out.println(nombre.replaceFirst("e", "????"));
Console: Esta casa ????s una ruina.
• replaceAll(string regex, string replacement): Lo utilizamos para sustituir una cadena de texto por otra. Sustituirá todas cadenas que coincidan con la cadena buscada. Se compone de dos parámetros:
o charsequence regex: cadena Objetivo o cadena buscada.
o charsequence replacement: Cadena por la que remplazamos.
String nombre="Esta casa es una ruina.";
System.out.println(nombre.replaceAll(" ", "_"));
Console :Esta_casa_es_una_ruina.
No hay comentarios:
Publicar un comentario