Espero este trabajo les sea de mucha ayuda, acontinuación les dejare links de este proyecto.
--Informe del Sistema de Ventas
https://docs.google.com/document/d/18lAihJoF_FSowxqTEvIspCmLqrjSL8gYz-L7bv30yYs/edit#
--Manual de como crear un Jar:
sábado, 12 de diciembre de 2015
SOBRECARGA DE MÉTODOS (overloaded)
Según (Froufe Quintas, 2000), Nos dice que es posible y a menudo deseable crear más de un método con el mismo nombre, pero con listas de parámetros distintas. A esto se le llama sobrecarga de método. Se sobrecarga un método siempre que se crea un método en una clase que ya tiene un método con el mismo nombre.
Ejemplo Desarrollado 01:
Utiliza la sobrecarga de método para sumar 2 y 3 quebrados.
Según (Chata) Algunos métodos en una clase pueden tener el mismo nombre.
Estos métodos deben contar con diferentes argumentos.
El compilador decide que método invocar comparando los argumentos.
Se generara un error si los métodos solo varían en el tipo de retorno.
Ejemplo Desarrollado 02:
Según (García de Jalón, y otros, 2000), Java permite métodos sobrecargados (overloaded), es decir, métodos distintos que tienen el mismo nombre, pero que se diferencian por el número y/o tipo de los argumentos.
A la hora de llamar a un método sobrecargado, Java sigue unas reglas para determinar el método concreto que debe llamar:
- Si existe el método cuyos argumentos se ajustan exactamente al tipo de los argumentos de la llamada (argumentos actuales), se llama ese método.
- Si no existe un método que se ajuste exactamente, se intenta promover los argumentos actuales al tipo inmediatamente superior (por ejemplo char a int, int a long, float a double, etc.) y se llama el método correspondiente.
- Si sólo existen métodos con argumentos de un tipo más restringido (por ejemplo, int en vez de long), el programador debe hacer un cast explícito en la llamada, responsabilizándose de esta manera de lo que pueda ocurrir.
- El valor de retorno no influye en la elección del método sobrecargado. En realidad es imposible saber desde el propio método lo que se va a hacer con él. No es posible crear dos métodos sobrecargados, es decir con el mismo nombre, que sólo difieran en el valor de retorno.
Diferente de la sobrecarga de métodos es la redefinición. Una clase puede redefinir (override) un método heredado de una superclase. Redefinir un método es dar una nueva definición.
En este caso el método debe tener exactamente los mismos argumentos en tipo y número que el método redefinido. Este tema se verá de nuevo al hablar de la herencia.
Ejemplos Propuestos:
De qué manera le darías solución con un Método sobrecargado. Resuélvelo según la teoría.
- Se tiene el objeto Carro, en la que se tiene que crear un método para cambiar Datos como el color y la marca. Pero qué pasaría si queremos cambiar la marca?
- Se quiere un programa que imprima listas de diferentes tipos tales como: Integer, Double y Character.
- Hacer una adición y sustracción tanto de 2 dígitos y 5 dígitos.
- Se tiene un colegio no se sabe quiénes hablan inglés , castellano o quechua, para ello se hace lo siguiente:
- 1 si habla inglés.
- 2,5 si habla castellano, y
- A si habla quechua.
- Mostrar tanto el sueldo semanal y el sueldo por horas. El sueldo semanal es 750$ y el sueldo por horas 50$
Conclusiones y Recomendación
Concluimos que la sobrecarga de métodos utilizada en programación, se utiliza para solucionar problemas iguales pero con diferente retorno o salida, así como lo podemos usar cuando hacemos nuestro código con diferentes métodos que requieren de sobrecarga.
Recomendaría usar sobrecarga de métodos ya que puedes crear un método que me realice diferentes funciones y así trabajar de manera más eficiente.
Bibliografía
- Chata, Á. (s.f.). Fundamentos de Java.
- Froufe Quintas, A. (2000). JAVA 2 Manual de usuario. Editorial Alfaomega-Rama: México.
- García de Jalón, J., Ignacio Rodríguez, J., Iñigo Mingo, Aitor Imaz, Brazález, A., Larzabal, A., . . . García, J. (2000). Aprenda Java como si estuviera en primero. Universidad de Navarra .
Referencia electrónica
lunes, 30 de noviembre de 2015
GREENFOOT
Programar en Greenfoot ha sido un experiencia muy agradable, ya que cada que programábamos podíamos saber si es lo que queríamos lograr al hacer dicho código, esta herramienta permite crear simulaciones y juegos, en dos dimensiones que nos permiten relacionarnos con Java y los conceptos básicos de una Programación Orienta a Objetos asiéndolo así de forma práctica y divertida.
Información Básica :
Greenfoot es un proyecto de software libre y gratuito, desarrollado en la Universidad de Kent (UK), enfocado en principio a jóvenes estudiantes que quieren iniciarse en el mundo de la programación. Existen otras herramientas con objetivos similares, como Scratch o Alice, pero Greenfoot tiene características más avanzadas, como la edición de código fuente en Java, que lo hace más potente e incluso interesante para personas que tienen ya conocimientos en programación. Greenfoot se distribuye gratuitamente con licencia GNU GPL y está disponible para Windows, Mac OS X y Linux.
Aqui les dejo un video Sobre Nuestro Proyecto en este IDE y el enlace al Informe:
https://docs.google.com/document/d/1_g4bsvnTz_Bbg1esYezHIXkurmPPzgDoHtXyyebYbOk/edit
domingo, 22 de noviembre de 2015
INTERFACES GRÁFICAS DE USUARIO.
Las interfaces gráficas de usuario (GUI) ofrecen al usuario ventanas, cuadros de diálogo, barras de herramientas, botones, listas desplegables y muchos otros elementos con los que ya estamos muy acostumbrados a tratar. Las aplicaciones son conducidas por eventos y se desarrollan haciendo uso de las clases que para ello nos ofrece la API de Java.
La interfaz de usuario es la parte del programa que permite al usuario interaccionar con él.
Se pueden ejecutar directamente en un entorno Java
Aplicaciones
Tipos
- Modo de consola
- Interacción mediante teclado
- Interfaz basado en texto
Aplicaciones con interfaz gráfica (GUI)
- Ventanas gráficas para entrada y salida de datos
- Iconos
- Dispositivos de entrada (p.ej. ratón, teclado)
- Interacción directa
Applets
Pequeñas aplicaciones que se ejecutan dentro de un navegador (o en el visualizador de applets - Appletviewer)
- Interfaz gráfica
- Limitaciones por motivos de seguridad
Componentes GUI (widgets)
Objetos visuales del interfaz.
Un programa grafico es un conjunto de componentes anidados.
- Ventanas, contenedores, menús, barras, botones, campos de textos, etc.
Disposición (layout)
como se colocan los componentes para lograr un GUI cómodo de utilizar.Layaout managers: gestionan la organización de los componentes gráficos
de la interfaz.
Eventos: Interactividad, respuesta a la entrada del usuario
Desplazamiento del ratón, selección en un menú, botón pulsado, etc.
Creación de gráficos y texto – Clase Graphics
- Define fuentes, pinta textos.
- Para dibujo de líneas, figuras, coloreado
Abstract windowing toolkit (AWT)
“Look & Feel” dependiente de la plataforma
- La apariencia de ventanas menúes, etc. Es distinta en Windows, Mac, Motif, y otros sistemas.
Funcionalidad independiente de la plataforma
Básico y experimental.
Estándar hasta la versión JDK 1.1.5
Swing / Java Foundation Class (desde JDK 1.1.5)
Look & Feel y funcionalidad independiente de la plataforma.
Desarrollado 100% en Java.
Portable: si se elige un look&feel soportado por Swing (o se programa uno)
puede asegurarse que la GUI se verá igual en cualquier plataforma.
Mucho más completo que AWT
Contenedores.
Contienen otros componentes (u otros contenedores).
- Estos componentes se tienen que añadir al contenedor y para ciertas operaciones se pueden tratar como un todo.
- Mediante un gestor de diseño controlan la disposición (layout) de estos componentes en la pantalla. • Ejemplo: Panel, Frame, Applet.
Lienzo (clase Canvas)
Superficie simple de dibujo.
Componentes de interfaz de usuario.
Botones, listas, menús, casillas de verificación, campos de texto, etc.
Componentes de construcción de ventanas.
Ventanas, marcos, barras de menús, cuadros de diálogo
Panel.
Sirve para colocar botones, etiquetas, etc.
No existe sin una ventana que lo albergue
Un applet es un panel
Window.
Sirve para crear nuevas ventanas independientes.
Ventanas gestionadas por el administrador de ventanas de la plataforma (Windows, Motif, Mac, etc.).
Normalmente se usan dos tipos de ventanas:
- Frame: ventana donde se pueden colocar menús
- Dialog: ventana para comunicarse con el usuario
- Se usan para colocar botones, etiquetas, etc.
- Cumple la misma función que un panel, pero en una ventana independiente
miércoles, 18 de noviembre de 2015
EXCEPCIONES
EXCEPCIONES
A veces al momento de compilar un programa, el compilador nos muestra este tipo
de mensaje como el que vamos a mostrar en la siguiente imagen.
Descuiden que este tipo de mensaje quiere decir que hay un error de sintaxis o lógico.
Para que no nos salgan este tipo de mensajes lo que vamos a utilizar son EXCEPCIONES.
Las Excepciones son como un tipo de controlador de errores, es decir, van a controlar
los errores que contienen un programa, pero para ello vamos a necesitar la estructura “try - catch” quien va a ser el que controle nuestros errores.
A continuación mostraremos los tipos de errores que hay:
<>br
A continuación veremos un ejemplo de EXCEPCIONES.
package practica8;
import javax.swing.JOptionPane;
/**
*
* @author Jhosep A. Cerna S
*/
public class Error
{
public static void main(String[] args)
{
String cad_num;
int numero;
boolean val;
//hacemos un do-while para que vuelva a ingresar un numero
do{
try{
cad_num=JOptionPane.showInputDialog(null,"Ingrese un numero para ser sumado con 6","Manejo del try-catch",JOptionPane.QUESTION_MESSAGE);
numero=Integer.parseInt(cad_num);
numero+=6;
JOptionPane.showMessageDialog(null,"Bien, el reusltado de 6 + "+cad_num+" = "+numero,"Mensaje",JOptionPane.INFORMATION_MESSAGE);
val=false;
}
catch(NumberFormatException nfe)
{
JOptionPane.showMessageDialog(null,"Ha ingresado una letra\npor favor ingrese un numero","Error",JOptionPane.ERROR_MESSAGE);
val=true;
}
}while(val);
}
}
ARCHIVO DE TEXTO
Son formatos exclusivamente por texto, es decir caracteres. Su extensión .TXT , no requieren ser interpretados para leerse.
Para crear un archivo se instancia File, nos permite crear un ruta especifica.
El FileReader, nos permite leer el archivo.
El FileWriter, se usa para escribir en el archivo.
El BufferReader, permite leer línea por línea todos los elementos.
Bueno aquí pueden ver el siguiente código:
Para crear un archivo se instancia File, nos permite crear un ruta especifica.
El FileReader, nos permite leer el archivo.
El FileWriter, se usa para escribir en el archivo.
El BufferReader, permite leer línea por línea todos los elementos.
Bueno aquí pueden ver el siguiente código:
import java.io.*;
public class Archivo_Plano {
private File f;
public void crear_archivo(){
try {
f=new File("archivos/Secretitos.txt");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
public void escribir_archivo(){
try {
FileWriter fr = new FileWriter(f);
fr.write("Este es mi archivo plano");
fr.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
public void leer_archivo(){
try {
FileReader fr=new FileReader(f);
BufferedReader br=new BufferedReader(fr);//lo que hace el buffer el llere los datos uno por uno
String linea=null;//va leer las lineas d emi archivo
while ((linea=br.readLine())!=null) {
System.out.println(linea);
}
br.close();
fr.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
CLASES, OBJETOS Y MAS . . .
Es un estilo de programación en que
cada programa es visto como un objeto, se forma por una serie de componentes,
auto contenidos que cooperan para realizar las acciones de la aplicación
completa.
La programación orientada a objetos (P.O.O) es un enfoque de programación de los más populares y viene teniendo gran aceptación en el desarrollo de proyectos de software.
- OBJETO: Es la entidad provista de un conjunto de propiedades o atributos
(datos) y de comportamiento o funcionalidad (métodos). Corresponden a los
objetos reales del mundo que nos rodea, o a objetos internos del sistema
(del programa). Es una instancia a una clase.
- CLASES: Son definiciones de las propiedades y comportamiento de un tipo de
objeto concreto. La instanciación es la lectura de estas definiciones y la
creación de un objeto a partir de ellas.
- MÉTODOS: Es un algoritmo asociado a un objeto (o a una clase de objetos),
cuya ejecución se desencadena tras la recepción de un "mensaje".
Desde el punto de vista del comportamiento, es lo que el objeto puede
hacer. Un método puede producir un cambio en las propiedades del objeto, o
la generación de un "evento" con un nuevo mensaje para otro
objeto del sistema.
- ATRIBUTOS: Es contenedor de un tipo de datos asociados a un objeto (o a una
clase de objetos), que hace los datos visibles desde fuera del objeto y
esto se define como sus características predeterminadas, y cuyo valor puede
ser alterado por la ejecución de algún método.
PROPIEDADES
O CARACTERÍSTICAS DE LA P.O.O
- HERENCIA: Es una propiedad esencial de la Programación Orientada a Objetos que
consiste en la creación de nuevas clases a partir de otras ya existentes.
Este término ha sido prestado de la Biología donde afirmamos que un niño
tiene la cara de su padre, que ha heredado ciertas facetas físicas o del
comportamiento de sus progenitores. La herencia permite crear una
clase (clase derivada) a partir de otras ya existentes, y ésta tendrá
todos los atributos y los métodos de su “superclase” (clase base), y
además se le podrán añadir otros atributos y métodos propios.
- POLIMORFISMO: Es la capacidad de
tener métodos con el mismo nombre, con comportamientos diferentes
conocidos como la sobre escritura de métodos y la sobrecarga de
operadores.
- ENCAPSULAMIENTO: Es
una característica de la programación orientada a objetos. Cada objeto
está aislado del exterior, es un módulo natural, y la aplicación entera se
reduce a un agregado o rompecabezas de objetos. El aislamiento protege a
los datos asociados a un objeto contra su modificación por quien no tenga
derecho a acceder a ellos.
- ABSTRACCIÓN: Definamos como la "acción de aislar mentalmente o considerar por separado las
cualidades de un objeto, considerar un objeto en su esencia, es decir,
a través de la abstracción conseguimos extraer las cualidades
principales sin detenernos en los detalles. La
abstracción es una herramienta muy potente en programación, pues reduce
considerablemente el trabajo de implementación y aumenta la portabilidad
del código.
martes, 17 de noviembre de 2015
BUCLES
Existen cuatro tipos de bucles (Loop) en Java:
Ejemplo de uso de del bucle wile:
Un ejemplo claro de un bucle que no sabemos cuántas veces se va a ejecutar es cuando le pedimos al usuario que introduzca algo por teclado, porque se puede equivocar o introducirlo mal porque le apetezca.
Ejemplo de uso del do…while.
El bucle for sirve para ejecutar un código un número conocido de veces, por ejemplo recorrer un array o cualquier otro tipo de colección o simplemente ejecutar el código un número concreto de veces. En java hay dos posibles tipos de bucle for: El más habitual es en el que se establece el numero desde el que va a empezar el bucle, hasta cuándo se va a seguir ejecutando el bucle y finalmente el modo en el que se actualiza el contador del bucle, que aunque habitualmente lo que se hace es incrementar en una unidad el contador esto no tiene que ser obligatoriamente así.
Este bucle se introdujo con la llegada de java 5 este se utiliza para el manejo de arrays.
Expresión: Esta se evalúa como el array que se tiene que recorrer. La expresión puede ser una variable de tipo array o una llamada al método que devuelve un array.
Ejemplo.
- El bucle while.
- El bucle do...while.
- El bucle for.
- El bucle for mejorado.
El bucle While
Un bucle while es una estructura de control que le permite repetir una tarea un número determinado de veces. while(expresion_booleana) while(expresion_booleana)
{
//Bloque de código
}
Cuando se ejecuta, si el resultado expresión booleana es cierto, entonces se ejecutarán las acciones dentro del bucle. Esto continuará siempre y cuando el resultado de la expresión es verdadera. Cuando la expresión se prueba y el resultado es falso, el cuerpo del bucle se omitirá y la primera sentencia después del bucle while se ejecutará.Ejemplo de uso de del bucle wile:
Un ejemplo claro de un bucle que no sabemos cuántas veces se va a ejecutar es cuando le pedimos al usuario que introduzca algo por teclado, porque se puede equivocar o introducirlo mal porque le apetezca.
Public int leeNumero()
{
Scanner sc= new Scanner(System.in);
int numero = -1;
while(numero<=0)
{
System.out.print(“introduce el numero positivo”);
Numero= sc nextInt();
}
Sc.close();
Return numero;
}
Un bucle do...while es similar a un bucle while, excepto que este está garantizando ejecutar al menos una vez el bloque de código.
do{
//Bloque de código
} while(expresion_booleana)
Aquí se observa que la expresion_booleana aparece al final del bucle, por lo que las instrucciones del bucle ejecutar una vez antes de que el booleano es probado. Si la expresión booleana es verdadera, el flujo de control vuelve al do, y las instrucciones del bucle se vuelven a ejecutar. Este proceso se repite hasta que la expresión booleana es falsa.Ejemplo de uso del do…while.
public class Bucles{
public static void main(String args[]){
int x = 20;
do{
System.out.print("valor de x : " + x );
x++;
System.out.print("\n");
}while( x < 30 );
}
}
Si ejecutamos el código anterior obtenemos el siguiente resultado:
valor de x : 20 valor de x : 21 valor de x : 22 valor de x : 23 valor de x : 24 valor de x : 25 valor de x : 26 valor de x : 27 valor de x : 28 valor de x : 29
El bucle for.
El bucle for sirve para ejecutar un código un número conocido de veces, por ejemplo recorrer un array o cualquier otro tipo de colección o simplemente ejecutar el código un número concreto de veces. En java hay dos posibles tipos de bucle for: El más habitual es en el que se establece el numero desde el que va a empezar el bucle, hasta cuándo se va a seguir ejecutando el bucle y finalmente el modo en el que se actualiza el contador del bucle, que aunque habitualmente lo que se hace es incrementar en una unidad el contador esto no tiene que ser obligatoriamente así.
for(inicializacion; expresion_booleana; actualizacion){
//Bloque de código
}
Un ejemplo.
public class Bucles {
public static void main(String args[]) {
for(int x = 20; x < 30; x++) {
System.out.print("valor de x : " + x );
System.out.print("\n");
}
}
}
Si ejecutamos nos debe de salir lo siguiente:
valor de x : 20 valor de x : 21 valor de x : 22 valor de x : 23 valor de x : 24 valor de x : 25 valor de x : 26 valor de x : 27 valor de x : 28 valor de x : 29La etapa de inicialización se ejecuta en primer lugar, y sólo una vez. Este paso le permite declarar e inicializar las variables de control del bucle. A continuación, se evalúa la expresion_booleana. Si bien es cierto, se ejecuta el cuerpo del bucle. Si es falsa, el cuerpo del bucle no se ejecuta y el flujo de control salta a la siguiente instrucción más allá del bucle for. Después de que el cuerpo del bucle se ejecuta para el flujo de control salta de nuevo a la instrucción de actualización. Esta declaración le permite actualizar las variables de control del bucle.
El for mejorado.
Este bucle se introdujo con la llegada de java 5 este se utiliza para el manejo de arrays.
for(declaracion : expresion)
{
//Bloque de código
}
Declaración: La variable de bloque recién declarado, que es de un tipo compatible con los elementos del array que está accediendo. La variable estará disponible dentro del bloque para y su valor sería el mismo que el elemento dentro del array.Expresión: Esta se evalúa como el array que se tiene que recorrer. La expresión puede ser una variable de tipo array o una llamada al método que devuelve un array.
Ejemplo.
public class Bucles {
public static void main(String args[]){
String [] empleados = {"Carlos", "Oscar", "Jony", “Alberto”, “Ramses”};
for(String nombre : empleados) {
System.out.print(nombre);
System.out.print(",");
}
}
}
Si ejecutamos nos debe de salir lo siguiente:
Carlos, Oscar, Jony, Alberto, Ramses,
POLIMORFISMO
Sobre-Carga
Es una parte del concepto de Polimorfismo, esto permite declarar métodos que se llamen igual pero que
reciban parámetros diferentes (no pueden haber 2 métodos con el mismo nombre y los mismos parámetros),
por esta razón lo que define a que método se ingresa, son los argumentos que se envían como parámetros.
public class Hijo
{
//Esto es Sobrecarga de Métodos
public void sumar(int a,int b)
{
int suma;
suma=a+b;
System.out.println("La suma es: "+suma);
}
public void sumar(int a,int b,int c)
{
int suma;
suma=a+b+c;
System.out.println("La suma es: "+suma);
}
public void sumar(double a,double b)
{
double suma;
suma=a+b;
System.out.println("La suma es: "+suma);
}
public static void main(String[] args)
{
Hijo h1=new Hijo();
h1.sumar(3.2, 5.1);
h1.sumar(5, 1);
h1.sumar(4, 5, 6);
}
}
Sobre-Escritura
Es la forma por la cual una clase que hereda puede re-definir los métodos de su clase Padre, de esta manera
puede crear nuevos métodos con el mismo nombre de su superClase, es decir, si tengo una clase Padre con el
método "ingresar()" yo puedo crear en la clase Hija un método que también se llame "ingresar()" pero implementándolo
según lo que necesite.
public class Instrumento
{
public String tipo;
public void tocar()
{
System.out.println("Tocar un Instrumento");
}
}
class Guitarra extends Instrumento
{
@Override
public void tocar()
{
//aca llamo al metodo de la clase Instrumento
super.tocar();
System.out.println("Tocar La Guitarra");
}
public static void main(String[] args)
{
Guitarra g1=new Guitarra();
g1.tocar();
}
}
HERENCIA
Es una de las propiedades mas importantes en Programación Orientada a Objetos por
que permite a una clase Padre compartir la misma estructura de datos (Variables) y
comportamiento (Métodos) a otra clase Hija.
La herencia minimiza la necesidad de duplicar código.
class Papito
{
private String color,tipcabello,ojos;
public Papito(String color, String tipcabello, String ojos) {
this.color = color;
this.tipcabello = tipcabello;
this.ojos = ojos;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getTipcabello() {
return tipcabello;
}
public void setTipcabello(String tipcabello) {
this.tipcabello = tipcabello;
}
public String getOjos() {
return ojos;
}
public void setOjos(String ojos) {
this.ojos = ojos;
}
}
public class Hijo extends Papito
{
String name;
public Hijo(String color, String tipcabello, String ojos,String name)
{
super(color,tipcabello,ojos);
this.name = name;
}
public void mostrar()
{
System.out.println(name+"= A heredado lo sgte:"+"\n"+getColor()+"\n"+getOjos()+"\n"+getTipcabello());
}
public static void main(String[] args)
{
Hijo h1=new Hijo("Moreno","Crespo","Gato","Lucho");
h1.mostrar();
}
}
miércoles, 11 de noviembre de 2015
IF-ELSE,Switch
Las sentencia if nos permite elegir si se ejecuta o no las instrucciones dadas, es una expresión que debe ser evaluada.
if(expresión)
sentencia
Pero,y si queremos ejecutar la sentensia falsa, para esto usamos la sentencia else
por ejemplo: Dependiendo de que el usuario pulse el boton de OK o el botón de Cancelar en una ventana de alarma. De esta forma se capturaria todo.
/*Respuesta dependiente del boton que haya pulsado el usuario
Ok o Cancel*/
if(respuesta == Ok){
. . .
//Codigo para la accion Ok
. . .
}else{
. . .
//Codigo para la acción Cancel
. . .
}
La sentencia Switch permite seleccionar entre multiples alternativas posibles, la expresión del switch es una variable int o char, puede tomar los valores , entre otros.
switch (opcion)
{
caso 1:
descuento = 10;
break;
caso 2:
te descuento = 5;
break;
default:
descuento = 0;
break;
}
miércoles, 28 de octubre de 2015
ARRAYLIST
Bueno ArrayList nos servirá para almacenar valores, podemos ingresar sin restrigciones de Tamaño.
Tenemos los siguientes métodos:
Bueno pasaremos a ver el siguiente ejemplo:
- add() es un método para agregar.
- size() es un método para el tamaño del ArrayList.
- get() es un método para mostrar.
- set() es un método para modificar.
- remove() es un método para eliminar.
Bueno pasaremos a ver el siguiente ejemplo:
import java.util.ArrayList;
public class ArrayList_Ejem {
public static void main(String[] args) {
ArrayList lis= Lista_Nombres();
for(int i=0;i < lis.size();i++){
System.out.println(" "+lis.get(i));
}
}
public static ArrayList Lista_Nombres(){
ArrayList lista=new ArrayList();
lista.add("Juan");
lista.add('R');
lista.add(1);
lista.add(00.2);
for (int i = 0; i < lista.size(); i++) {
lista.get(i);
}
return lista;
}
}
martes, 27 de octubre de 2015
INTERFACE
INTERFACE
Es una super clase al igual que las clases abstractas pero en este caso
puede o no tener métodos abstractos y tiene una característica muy común que
cuando instancias una variable automáticamente esta sera una constante y ya
no sera necesario poner la palabra "final".
Al hablar de INTERFACE hablamos de "Herencia Múltiple" que quiere decir eso, que
al crear varias INTERFACE podemos heredar todos sus atributos y métodos que
contengan esas INTERFACE, pero para poder heredar sus atributos y métodos
necesitaremos una palabrita reservada de java que se llama "implements".
En conclusión :
Veamos el siguiente Ejemplo de INTERFACE:
interface Privada
{
public String a="A";
public abstract void AA();
}
interface Publica
{
public char y='Z';
public abstract void CC();
}
interface Universidad
{
public int x=10;
public abstract void BB();
}
public class Interfeis implements Privada,Publica,Universidad
{
@Override
public void AA()
{
System.out.println(a);
System.out.println("Privada");
}
@Override
public void BB()
{
System.out.println(x);
System.out.println("Universidad");
}
@Override
public void CC()
{
System.out.println(y);
System.out.println("Publicas");
}
public static void main(String[] args)
{
Interfeis it=new Interfeis();
it.AA();
System.out.println("****************");
it.BB();
System.out.println("****************");
it.CC();
}
}
sábado, 17 de octubre de 2015
CLASES ABSTRACTAS
Es una de los principios de la programación Orientada a Objetos que sirve para modelar objetos de alto nivel, no contienen código, sino solo declaraciones. Todos sus métodos deben existir en sus clases hijas. Una clase abstracta no puede ser instanciada (Crear un objeto a partir de ella).
Métodos abstractos
Estos métodos son parte de clases abstractas
Un método abstracto debe ser redefinido en las subclases.
Cada subclase puede definir el método de manera diferente.
Las clases abstractas pueden contener métodos que no son abstractos.
class c1 extends Padre
{
@Override
public String Estudio()
{
System.out.println("SISTEMAS");
return "";
}
}
class c2 extends Padre
{
@Override
public String Estudio()
{
System.out.println("CONTABILIDAD");
return "";
}
}
class c3 extends Padre
{
@Override
public String Estudio()
{
System.out.println("ADMINISTRACIÓN");
return "";
}
}
public abstract class Padre
{
public abstract String Estudio();
}
class man_Padre
{
public static void main(String[] args)
{
c1 hijo1=new c1();
c2 hijo2=new c2();
c3 hijo3=new c3();
hijo1.Estudio();
hijo2.Estudio();
hijo3.Estudio();
}
}
lunes, 12 de octubre de 2015
Examen Resuelto
Pregunta numero 1°
Clase Cuenta
Pregunta Numero 2°
Clase Fecha
Clase Libro
Clase Lugar
Clase Persona
Clase Principal Libro
Pregunta numero 3°
Clase Cancion
Clase CD
Clase Principal CD
Clase Cuenta
package Pregunta1;
public class Cuenta {
long numero_de_cuenta;
float DNI;
float saldo_actual;
float interes_anual;
public Cuenta(long numero_de_cuenta, float DNI, float saldo_actual, float interes_anual) {
this.numero_de_cuenta = numero_de_cuenta;
this.DNI = DNI;
this.saldo_actual = saldo_actual;
this.interes_anual = interes_anual;
}
public Cuenta(float DNI, float saldo_actual, float interes_anual) {
this.DNI = DNI;
this.saldo_actual = saldo_actual;
this.interes_anual = interes_anual;
}
public long getNumero_de_cuenta() {
return numero_de_cuenta;
}
public void setNumero_de_cuenta(long numero_de_cuenta) {
this.numero_de_cuenta = numero_de_cuenta;
}
public float getDNI() {
return DNI;
}
public void setDNI(float DNI) {
this.DNI = DNI;
}
public float getSaldo_actual() {
return saldo_actual;
}
public void setSaldo_actual(float saldo_actual) {
this.saldo_actual = saldo_actual;
}
public float getInteres_anual() {
return interes_anual;
}
public void setInteres_anual(float interes_anual) {
this.interes_anual = interes_anual;
}
public float actualizarSaldo(){
float saldo_nuevo;
saldo_nuevo=this.saldo_actual+(this.saldo_actual*((this.interes_anual/100)/365));
return saldo_nuevo;
}
public float ingresar(float cant_ingresada){
float nuevo_monto;
nuevo_monto=this.saldo_actual+cant_ingresada;
return nuevo_monto;
}
public float retirar(float cant_retiro){
float nuevo_monto=0;
if(this.saldo_actual>=cant_retiro){
nuevo_monto=this.saldo_actual-cant_retiro;
}else{
System.out.println("No hay saldo suficiente en su cuenta!!");
}
return nuevo_monto;
}
}
Clase Principal_Cuenta
package Pregunta1;
import java.util.Scanner;
public class Principal_Cuenta {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
Cuenta c1=new Cuenta(2105056, 73660590, 512, 25);
System.out.println("Ingrese el monto que desea agregar a su cuenta: ");
float monto=sc.nextFloat();
System.out.println("El nuevo saldo en su cuenta es: "+c1.ingresar(monto)+" soles");
}
}
Pregunta Numero 2°
Clase Fecha
package Pregunta2;
public class Fecha {
String día_semana;
int dia_mes;
String mes;
int anio;
public Fecha(String día_semana, int dia_mes, String mes, int anio) {
this.día_semana = día_semana;
this.dia_mes = dia_mes;
this.mes = mes;
this.anio = anio;
}
public String getDía_semana() {
return día_semana;
}
public void setDía_semana(String día_semana) {
this.día_semana = día_semana;
}
public int getDia_mes() {
return dia_mes;
}
public void setDia_mes(int dia_mes) {
this.dia_mes = dia_mes;
}
public String getMes() {
return mes;
}
public void setMes(String mes) {
this.mes = mes;
}
public int getAnio() {
return anio;
}
public void setAnio(int anio) {
this.anio = anio;
}
}
Clase Libro
package Pregunta2;
import java.util.*;
public class Libro {
String titulo="Introduccion to Java Programing";
Persona autor;
String ISBN="0-13-031997-X";
int paginas=784;
String edicion="3a. Edicion";
String editorial="Prentice-Hall";
Lugar lugar;
Fecha fecha_edicion;
public Libro() {
}
public Libro(String titulo, Persona autor, String ISBN, int paginas, String edicion, String editorial, Lugar lugar, Fecha fecha_edicion) {
this.titulo = titulo;
this.autor = autor;
this.ISBN = ISBN;
this.paginas = paginas;
this.edicion = edicion;
this.editorial = editorial;
this.lugar = lugar;
this.fecha_edicion = fecha_edicion;
}
public String getTitulo() {
return titulo;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public Persona getAutor() {
return autor;
}
public void setAutor(Persona autor) {
this.autor = autor;
}
public String getISBN() {
return ISBN;
}
public void setISBN(String ISBN) {
this.ISBN = ISBN;
}
public int getPaginas() {
return paginas;
}
public void setPaginas(int paginas) {
this.paginas = paginas;
}
public String getEdicion() {
return edicion;
}
public void setEdicion(String edicion) {
this.edicion = edicion;
}
public String getEditorial() {
return editorial;
}
public void setEditorial(String editorial) {
this.editorial = editorial;
}
public Lugar getLugar() {
return lugar;
}
public void setLugar(Lugar lugar) {
this.lugar = lugar;
}
public Fecha getFecha_edicion() {
return fecha_edicion;
}
public void setFecha_edicion(Fecha fecha_edicion) {
this.fecha_edicion = fecha_edicion;
}
public void leer(Persona p, Lugar l, Fecha f){
Scanner sc=new Scanner(System.in);
System.out.println("INGRESE LOS DATOS DEL LIBRO");
System.out.println("Titulo: ");
this.titulo=sc.nextLine();
System.out.println("Datos del autor ");
System.out.println("Nombre: ");
p.nombre=sc.nextLine();
System.out.println("Apellido: ");
p.apellido=sc.nextLine();
System.out.println("ISBN del libro: ");
this.ISBN=sc.nextLine();
System.out.println("Paginas: ");
this.paginas=sc.nextInt();
System.out.println("Edicion: ");
this.edicion=sc.nextLine();
System.out.println("Editorial: ");
this.editorial=sc.nextLine();
System.out.println("Lugar ");
System.out.println("Ciudad: ");
l.ciudad=sc.nextLine();
System.out.println("Pais: ");
l.pais=sc.nextLine();
System.out.println("Fecha de edicion ");
System.out.println("Dia de la semana: ");
f.día_semana=sc.nextLine();
System.out.println("Dia del mes: ");
f.dia_mes=sc.nextInt();
System.out.println("Mes: ");
f.mes=sc.nextLine();
System.out.println("Año: ");
f.anio=sc.nextInt();
}
public void mostrar_autor(){
System.out.println(""+this.autor.nombre+", "+this.autor.apellido);
}
public void mostrar(Persona p,Lugar l, Fecha f){
System.out.print("Titulo: "+this.titulo+" "+this.edicion);
System.out.print("\nAutor: "+p.nombre+", "+p.apellido);
System.out.print("\nISBN: "+this.ISBN+" "+this.editorial+", "+l.ciudad+" ("+l.pais+"), "+f.día_semana+" "+f.dia_mes+" de "+f.mes+" de "+f.anio);
System.out.print("\n"+this.paginas+" páginas");
}
}
Clase Lugar
package Pregunta2;
public class Lugar {
String ciudad;
String pais;
public Lugar(String ciudad, String pais) {
this.ciudad = ciudad;
this.pais = pais;
}
public String getCiudad() {
return ciudad;
}
public void setCiudad(String ciudad) {
this.ciudad = ciudad;
}
public String getPais() {
return pais;
}
public void setPais(String pais) {
this.pais = pais;
}
}
Clase Persona
package Pregunta2;
public class Persona {
String nombre;
String apellido;
public Persona(String nombre, String apellido) {
this.nombre = nombre;
this.apellido = apellido;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApellido() {
return apellido;
}
public void setApellido(String apellido) {
this.apellido = apellido;
}
}
Clase Principal Libro
package Pregunta2;
public class Principal_Libro {
public static void main(String[] args) {
Fecha f1=new Fecha("viernes", 16, "noviembre", 2001);
Lugar u1=new Lugar("New Jersey", "USA");
Persona p1= new Persona("Liang","y.Daniel");
Libro l1=new Libro();
// l1.leer(p1, u1, f1);
l1.mostrar(p1, u1, f1);
}
}
Pregunta numero 3°
Clase Cancion
package Pregunta3;
public class Cancion {
String nombre;
int duracion;
String autor;
public Cancion(String nombre, int duracion, String autor) {
this.nombre = nombre;
this.duracion = duracion;
this.autor = autor;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getDuracion() {
return duracion;
}
public void setDuracion(int duracion) {
this.duracion = duracion;
}
public String getAutor() {
return autor;
}
public void setAutor(String autor) {
this.autor = autor;
}
public void mostrar(){
System.out.println("Nombre: "+this.nombre);
System.out.println("Duracion: "+this.duracion);
System.out.println("Autor: "+this.autor);
}
}
Clase CD
package Pregunta3;
import java.util.ArrayList;
public class CD {
int contador = 0;
int tamaño_maximo = 20;
ArrayList canciones;
public CD() {
canciones = new ArrayList(tamaño_maximo);
}
public int numeroCanciones() {
return canciones.size();
}
public Cancion dameCancion(int i) {
return (Cancion) canciones.get(i);
}
public void grabaCancion(int i, Cancion c) {
canciones.set(i, c);
}
public void agrega(Cancion c) {
canciones.add(c);
}
public void elimina(int i) {
canciones.remove(i);
}
public void graba_Cancion(String nombre_cancion, Cancion c) {
int estado = 0;
for (int i = 0; i < this.numeroCanciones(); i++) {
if (dameCancion(i).nombre.equals(nombre_cancion)) {
estado = 1;
grabaCancion(i, c);
}
}
if (estado == 0) {
System.out.println("Cancion no encontrada!!");
}
}
public void eliminar_Cancion(String nombre_cancion, Cancion c) {
int estado = 0;
for (int i = 0; i < this.numeroCanciones(); i++) {
if (dameCancion(i).equals(nombre_cancion)) {
estado = 1;
canciones.remove(c);
}
}
if (estado == 0) {
System.out.println("Cancion no encontrada");
}
}
}
Clase Principal CD
package Pregunta3;
import java.util.Scanner;
public class Principal_CD {
public static void main(String[] args) {
Cancion c1=new Cancion("Basta ya",3,"Olga Tañón");
Cancion c2=new Cancion("Perdón",5,"Camila");
Cancion c3=new Cancion("Aire soy",4,"Ximena y Miguel");
CD cd= new CD();
cd.agrega(c1);
cd.agrega(c2);
cd.agrega(c3);
System.out.println("Número de canciones: "+cd.numeroCanciones());
for(int i=0;i
La Clase Lectura (BufferStreamReader - BufferedReader)
CLASE LECTURA (FilterInputStream - BufferStreamReader)
LA CLASE LECTURA (InputStreamReader - BufferedReader)
LA CLASE LECTURA (InputStreamReader - BufferedReader)
Nota: Esta con todas sus restricciones.
import java.io.*;
public class Lectura
{
InputStreamReader conv= new InputStreamReader(System.in);
BufferedReader entrada=new BufferedReader(conv);
private boolean valor;
public String Cadenas() throws IOException
{
String cad="";
try{
cad=entrada.readLine();
}catch(IOException io)
{
System.out.println("Error");
}
return cad;
}
public int Enteros() throws IOException
{
int naturales=0;
do{
valor=false;
try{
naturales=Integer.parseInt(entrada.readLine());
}catch(NumberFormatException nfe)
{
System.out.println("Error ingrese un numero entero");
valor=true;
}
}while(valor);
return naturales;
}
public float Flotantes() throws IOException
{
float reales= 0.0f;
do{
valor=false;
try{
reales=Float.parseFloat(entrada.readLine());
}catch(NumberFormatException nfe)
{
System.out.println("Error ingrese un numero decimal");
valor=true;
}
}while(valor);
return reales;
}
public long Longs() throws IOException
{
long entegrandes= 0;
do{
valor=false;
try{
entegrandes=Long.parseLong(entrada.readLine());
}catch(NumberFormatException nfe)
{
System.out.println("Error ingrese un numero entero");
valor=true;
}
}while(valor);
return entegrandes;
}
public double Doubles() throws IOException
{
double numlargos=0.0f;
do{
valor=false;
try{
numlargos=Double.parseDouble(entrada.readLine());
}catch(NumberFormatException nfe)
{
System.out.println("Error ingrese un numero decimal");
valor=true;
}
}while(valor);
return numlargos;
}
}
ESTO ES LA CLASE MANEJO DE LECTURA
import java.io.IOException;
public class manLectures
{
//la palabra static sirve para poder verlos en un void main
//si lo declaro en la clase sin static saldra error
//es por eso la palabra static.
public static void main(String[] args) throws IOException
{
Lectura lec=new Lectura();
String name,direccion,ape,cod;
int a,b,c,suma;
double sue;
//si ingresan un numero decimal a un int
//lo que va a ser es que vuelvan a ingresar
//un numero entero de tipo int, y eso solo es para
//los numeros, pero para una cadena si puedes ingresar
//numeros y letras
System.out.println("Ingrese su nombre: ");
name=lec.Cadenas();
System.out.println("Ingrese su Apellido: ");
ape=lec.Cadenas();
System.out.println("Ingrese su Dirección: ");
direccion=lec.Cadenas();
System.out.println("Ingrese su Codigo: ");
cod=lec.Cadenas();
System.out.println("Ingrese su primer numero");
a=lec.Enteros();
System.out.println("Ingrese su segundo numero");
b=lec.Enteros();
System.out.println("Ingrese su tercero numero");
c=lec.Enteros();
System.out.println("Ingrese su sueldo mensual");
sue=lec.Doubles();
System.out.println("**************************");
System.out.println("Su Nombre: "+name);
System.out.println("Su Apellido: "+ape);
System.out.println("Su Direccion: "+direccion);
System.out.println("Su Codigo: "+cod);
suma=a+b+c;
System.out.println("La suma es: "+suma);
System.out.println("Su sueldo mensual es: "+sue);
}
}
LA SUCESIÓN DE FIBONACCI
También conocida como secuencia de Fibonacci o incorrectamente como serie de Fibonacci, esta en si es una sucesión matemática infinita.
Consta de una Serie de números naturales que se suman de a 2, a partir de 0 y 1.
Básicamente, la sucesión de Fibonacci se realiza sumando siempre los ultimos 2 numeros,
(Todos los números presentes en la sucesión se llaman números de fibonacci) de la siguiente manera:
0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , . . .
Siendo así: ( 0 + 1 = 1 , 1 + 1 = 2, 1 + 2 = 3 , .... , 13 + 21 = 34 ... ) Así sucesivamente, hasta el infinito.
Aquí les dejamos el siguiente Video de como hacer una Sucesión de Fibonacci en Java.
Consta de una Serie de números naturales que se suman de a 2, a partir de 0 y 1.
Básicamente, la sucesión de Fibonacci se realiza sumando siempre los ultimos 2 numeros,
(Todos los números presentes en la sucesión se llaman números de fibonacci) de la siguiente manera:
0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , . . .
Siendo así: ( 0 + 1 = 1 , 1 + 1 = 2, 1 + 2 = 3 , .... , 13 + 21 = 34 ... ) Así sucesivamente, hasta el infinito.
Aquí les dejamos el siguiente Video de como hacer una Sucesión de Fibonacci en Java.
viernes, 9 de octubre de 2015
PARADIGMAS DE PROGRAMACIÓN
Entendemos como paradigma a la creación y explicación de modelos en el caso de programación tenemos técnicas que con el paso del tiempo han creado distintos tipos de programaciones singulares por su forma de desarrollar aplicaciones, programas, etc. En este articulo conoceremos aquellos paradigmas:
1. Programación Imperativa
La implementación de hardware de la
mayoría de computadores es imperativa; prácticamente todo el hardware de los
computadores está diseñado para ejecutar código de máquina, que es nativo al
computador, escrito en una forma imperativa. Esto se debe a que el hardware de los
computadores implementa el paradigma de las Máquinas de Turing. Desde esta
perspectiva de bajo nivel, el estilo del programa está definido por los
contenidos de la memoria, y las sentencias son instrucciones en el lenguaje de
máquina nativo del computador (por ejemplo el lenguaje ensamblador).
Los lenguajes imperativos de alto nivel
usan variables y sentencias más complejas, pero aún siguen el mismo paradigma.
Las recetas y las listas de revisión de procesos, a pesar de no ser programas
de computadora, son también conceptos familiares similares en estilo a la
programación imperativa; donde ada paso es una instrucción.
Son aquellos cuyos valores son atómicos
y están formados por elementos en un caso especial.
Dentro de esta se encuentra:
- La programación orientada a objetos: Está basada en el imperativo, pero encapsula elementos denominados objetos que incluyen tanto variables como funciones. Está representado por C++ o el Java, pero el más representativo sería el Smalltalk que está completamente orientado a objetos
- Programación dinámica: Está definida como el proceso de romper problemas en partes pequeñas para analizarlos y resolverlos de forma más óptima, busca resolver problemas en O(n) sin usar por tanto métodos recursivos. Este paradigma está más basado en el modo de realizar los algoritmos, por lo que se puede usar con cualquier lenguaje imperativo.
2. Programación Declarativa
La Programación Declarativa, en
contraposición a la programación imperativa es un paradigma de programación que
está basado en el desarrollo de programas especificando o
"declarando" un conjunto de condiciones, proposiciones, afirmaciones,
restricciones, ecuaciones o transformaciones que describen el problema y
detallan su solución. La solución es obtenida mediante mecanismos internos de
control, sin especificar exactamente cómo encontrarla (tan sólo se le indica a
la computadora qué es lo que se desea obtener o qué es lo que se está
buscando). No existen asignaciones destructivas, y las variables son utilizadas
con transparencia referencial.
Dentro de esta se encuentra:
- Programación funcional: Basada en la definición los predicados y es de corte más matemático, está representado por Scheme (una variante de Lisp) o Haskell.
- Programación lógica: Basado en la definición de relaciones lógicas, está representado por Prolog.
- Programación con restricciones: Similar a la lógica usando ecuaciones. Casi todos los lenguajes son variantes del Prolog.
3. Programación Multiparadigma
Un lenguaje de programación Multiparadigma es el que soporta más de un paradigma de programación. Según lo
describe Bjarne Stroustrup, permiten crear “programas usando más de un estilo
de programación”.
El objetivo en el diseño de estos
lenguajes es permitir a los programadores utilizar el mejor paradigma para cada
trabajo, admitiendo que ninguno resuelve todos los problemas de la forma más
fácil y eficiente posible.
Por ejemplo, lenguajes de programación
como C++, Genie, Delphi, Visual Basic o PHP, combinan el paradigma imperativo
con la orientación a objetos. Incluso existen lenguajes multiparadigma que
permiten la mezcla de forma natural, como en el caso de Oz, que tiene
subconjuntos (particularidad de los lenguajes lógicos), y otras características
propias de lenguajes de programación funcional y de orientación a objetos. Otro
ejemplo son los lenguajes como Scheme (paradigma funcional) o Prolog (paradigma
lógico), que cuentan con estructuras repetitivas, propias del paradigma
imperativo.
4. Lenguaje especifico de Dominio
En desarrollo de software e ingeniería
de dominio, un lenguaje específico del dominio (en inglés Domain Specific Language,
DSL), es un lenguaje de programación o especificación dedicado a resolver un
problema en particular, representar un problema específico y proveer una
técnica para solucionar una situación particular. El concepto no es nuevo pero
se ha vuelto más popular debido al aumento del uso de modelaje específico del
dominio.1
Ejemplos de lenguajes específicos del
lenguaje incluyen, Logo para niños, Verilog y VHSIC, R y S para estadísticas,
Mata para programación matricial, Mathematica y Máxima para matemáticas,
fórmulas de hojas de cálculo y macros, SQL para consultas a bases de datos
relacionales, Yacc para crear parseadores, expresiones regulares para crear
análisis léxico, Generic Eclipse Modeling System para crear lenguajes con el
objetivo de diagramar, Csound un lenguaje para síntesis digital, y los
lenguajes de entrada de GraphViz y GrGen, paquetes de software usados para
graficar y reescribir gráficas.
Lo opuesto es:
- Un lenguaje de programación de propósito general, como por ejemplo C o Java.
- Un lenguaje de modelaje de propósito general como UML.
Crear un lenguaje específico del dominio (con software que lo soporte) vale la pena cuando permite que un tipo particular de problemas o soluciones puedan ser expresadas más claramente que con otros lenguajes existentes, y el tipo de problema en cuestión reaparece lo suficiente. La programación orientada a lenguajes considera la creación de lenguajes específicos para expresar problemas una parte estándar para el proceso de solucionar el problema.
Suscribirse a:
Comentarios (Atom)