Final Progra

Escuela superior politécnica de Chimborazo
Facultad de informática y electrónica
Escuela de ingeniería en electrónica y control de redes industriales
APUNTES DE LENGUAJE DE PROGRACION II
Estudiante:
José Emilio Mullo
Docente:
Ms. Fernando Mejía Peñafiel.
Riobamba- Ecuador
2017
FUNDAMENTOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS (POO)
METODOLOGIA PARA EL DESARROLLO DE SW

Antes, lo que se hacía era programar y corregir los requerimientos que pedía un usuario no estaba
administrada o gestionada de ningún modo.
Lo que se hacía era ir corrigiendo a medida que surgía los errores tantos lógicos como los que el usuario lo
pedía.
Definición. La metodología para el desarrollo de software es un modo sistemático de realizar, gestionar y

administrar un proyecto para llevarlo a cabo con altas posibilidades de éxito.
CLASIFICACIÓN DE LAS METODOLOGÍAS

Existen dos metodologías que tienen analogía en la práctica con los paradigmas de programación.
 Metodología estructurada
 Metodología orientada a objetos
Metodología Estructurada
Definición. La orientación de esta metodología se dirige hacia los procesos que intervienen en el sistema a
desarrollar, es decir, cada función a realizar por el sistema se descompone en pequeños módulos individuales.
Es más fácil resolver problemas pequeños, y luego unir cada una de las soluciones, que abordar un problema
grande.
Metodología orientada a objetos
Definición. A diferencia de la metodología estructurada, ésta no comprende los procesos como funciones
sino que arma módulos basados en componentes, es decir, cada componente es independiente del otro. Esto
nos permite que el código sea reutilizable. Es más fácil de mantener porque los cambios están localizados en
cada uno de estos componentes.
CICLO DE VIDA
Describe la vida de un producto de software desde su definición, pasando por su diseño, implementación,
verificación, validación, entrega, y hasta su operación y mantenimiento.
¿por qué es necesario un método para desarrollar software?
Por lo complejo que resulta desarrollar software

¿qué aporta un método?
Casos de Uso, Plantillas de Documentos, UML:

Diagramas de Clases, de Casos de Uso, de
Actividades, de Secuencia, etcétera.
Grafos de navegación, lenguajes de programación, bibliotecas, armazones de aplicación (frameworks), entornos
integrados de desarrollo (IDEs), armazones de pruebas, etcétera.
Software de gestión, herramientas de gestión, etcétera
¿proceso?
Un proceso define quien está haciendo qué, cuándo y cómo lograr cierta meta.
The three “Amigos”
Un proceso es "una serie de pasos que involucra actividades, restricciones y recursos que producen una salida
de algún tipo"
Pfleeger
¿modelo de proceso?
Los "procesos de desarrollo de software" poseen reglas preestablecidas, y deben
ser aplicados en la creación del software de mediano y gran porte, ya que en caso
contrario lo más seguro es que el proyecto o no logre concluir o termine sin cumplir los objetivos previstos, y
con variedad de fallos inaceptables (fracasan, en pocas palabras).
Un modelo de proceso de software es una representación abstracta de un proceso

de software.
Características de modelo de proceso.

CICLO DE VIDA / CICLO DE DESARROLLO (LO QUE USUALMENTE PASA, Y NO DEBE PASAR)
 Proceso en cascada
Ventajas.
Desventajas.
MODELO EN V
PROCESO EN CASCADA
PROCESO / MODELO EN ESPIRAL
En general se puede asociar cada giro a una fase del proceso de desarrollo. Ej. 1er
giro: objetivos, alternativas restricciones; 2do giro: especificación de requisitos; 3er
giro: diseño; 4to giro: implementación, etcétera.
Modelo de Riesgos o de Espiral
PROCESOS ITERATIVOS INCREMENTALES
MODELO ITERATIVO
Cada iteración refina lo realizado en la iteración anterior. De esta forma se produce
una dinámica en la que se van mejorando los productos (entregables) obtenidos en la
iteración anterior.
Eventualmente se realizarán todas las iteraciones planificadas, o se llegará al nivel de
refinamiento deseado.
MODELO ITERATIVO-INCREMENTAL
WHITE WATCH, ¿ITERATIVO O INCREMENTAL?
PROCESOS EVOLUTIVOS Y BASADOS EN PROTOTIPOS
Modelos Evolutivos
La definición y especificación de requerimientos y el desarrollo de software es un

proceso evolutivo que demanda la experimentación previa con algún componente (o la
totalidad) del Sistema Programado (Ej. Interfaz U-S, función o subsistema)
antes de desarrollar la totalidad del sistema.
MODELOS BASADOS EN PROTOTIPOS
MODELOS BASADOS EN PROTOTIPOS (NO DESECHABLE)

CONCEPTOS FUNDAMENTALES Y CARACTERÍSTICAS DE POO
 La POO es una técnica para desarrollar soluciones computacionales utilizando componentes de

software (objetos de software).
 La POO se basa en el modelo objeto donde el elemento principal es el objeto, el cual es una unidad
que contiene todas sus características y comportamientos en sí misma, lo cual lo hace como un todo
independiente pero que se interrelaciona con objetos de su misma clase o de otras clases, como
sucede en el mundo real.
PROGRAMACIÓN ESTRUCTURADA PROGRAMACIÓN ORIENTADA A OBJETOS
Los programas son más fáciles de entender Es más moderna
Puede ser leído en secuencia Incluye datos y procedimientos en una clase
La estructura del programa es más clara puesto que Los procedimientos están separados y sin relación
las instrucciones están mas relacionadas
El seguimiento de los fallos o errores del programa No es tan rápido encontrar fallas ya que su
se facilita debido a su estructura mas sencilla estructura no es muy sencilla
Los programas son más sencillos de codificar Los programas no son tan sencillos de codificar
Están orientados a acciones Encapsula datos (atributos y métodos) en objetos
que están relacionados entre si.
La unidad de programación es la función La unidad de programación es la clase
A los bloques de código se le conoce como funciones. El código y los datos están fusionados en algo
Las unidades se les conoce como estructura. invisible: un objeto
Los códigos son fácilmente entendibles dado que Los códigos son más compactos, pero más tardíos
tienen una secuencia (de arriba hacia abajo) en su comprensión dad la lógica usada en relación a
objetos.
VENTAJAS DE LA POO
 Facilita la creación de programas
 Facilita el mantenimiento del software
 Es más fácil crear nuevos tipos objetos a partir de los existentes.
PROGRAMACIÓN ORIENTADA A OBJETOS VS PROGRAMACIÓN ESTRUCTURADA
Diferencia. La POO es una forma especial de programar, más cercana a como expresaríamos las cosas en
la vida real que otros tipos de programación. Con la POO tenemos que aprender a pensar las cosas de una
manera distinta, para escribir nuestros programas en términos de OBJETOS, PROPIEDADES, MÉTODOS y
OTRAS COSAS.
PROGRAMACIÓN ORIENTADA A OBJETO.
Definición. La programación orientada a objetos es otra forma de descomponer problemas. Este nuevo
método de descomposición es la descomposición en objetos; vamos a fijarnos no en lo que hay que hacer en el
problema, sino en cuál es el escenario real del mismo, y vamos a intentar simular ese escenario en nuestro
programa.
CLASE
Definición. Es una plantilla que contiene la descripción general de una colección de objetos. Consta de
atributos y métodos que resumen las características y el comportamiento comunes de un conjunto de objetos.
 La clase es la unidad de modularidad en el EOO. La tendencia natural del individuo es la de clasificar

los objetos según sus características comunes (clase). Por ejemplo, las personas que asisten a la
universidad se pueden clasificar (haciendo abstracción) en estudiante, docente, empleado e
investigador.
 La clase puede definirse como la agrupación o colección de objetos que comparten una estructura
común y un comportamiento común.
Su sintaxis algorítmica es:
Clase <Nombre de la Clase>
…
FClase <Nombre de la Clase>;
OBJETOS
Definición. La creación de un objeto, debe ser indicada explícitamente por el programador, de forma análoga
a como inicializamos las variables con un valor dado, sólo que para los objetos se hace a través de un método
Constructor.
La declaración de una variable de una clase NO crea el objeto.

La asociación siguiente: <Nombre_Clase> <Nombre_Variable>; (por ejemplo, Rectángulo R), no genera o no crea
automáticamente un objeto Rectángulo. Sólo indica que R será una referencia o una variable de objeto de la
clase Rectángulo.
 Son la parte ejecutable de la POO
 Se manejan a través de variables
 Pertenecen a una clase
ATRIBUTO
Definición. Un atributo consta de un nombre y un valor. Cada atributo está asociado a un tipo de dato, que
puede ser simple (entero, real, lógico, carácter, string) o estructurado (arreglo, registro, archivo, lista, etc.)
 Son los datos o variables que caracterizan al objeto y cuyos valores en un momento dado indican su
estado.
 Un atributo es una característica de un objeto. Mediante los atributos se define información oculta
dentro de un objeto, la cual es manipulada solamente por los métodos definidos sobre dicho objeto
Su sintaxis algorítmica es:
<Modo de Acceso> <Tipo de dato> <Nombre del Atributo>;
Los modos de acceso son:
Público: Atributos (o Métodos) que son accesibles fuera de la clase. Pueden ser llamados por cualquier clase,
aun si no está relacionada con ella. Este modo de acceso también se puede representar con el símbolo +
Privado: Atributos (o Métodos) que sólo son accesibles dentro de la implementación de la clase. También se
puede representar con el símbolo –
Protegido: Atributos (o Métodos) que son accesibles para la propia clase y sus clases hijas (subclases).
También se puede representar con el símbolo #.
MÉTODO
Definición. Son las operaciones (acciones o funciones) que se aplican sobre los objetos y que permiten
crearlos, cambiar su estado o consultar el valor de sus atributos.
 Los métodos constituyen la secuencia de acciones que implementan las operaciones sobre los objetos.
La implementación del método no es visible fuera de objeto.
La sintaxis algorítmica de los métodos expresados como funciones y acciones es:
Para funciones se pueden usar cualquiera de estas dos sintaxis:
<Modo de Acceso> Función <Nombre> [(Lista Parámetros)]: <Descripción del Tipo de datos>
Para acciones:
<Modo de Acceso> Acción <Nombre> [(Lista Parámetros)] donde los parámetros son opcionales
CARACTERÍSTICAS GENERALES
 Cada método tiene un nombre, cero o más parámetros (por valor o por referencia) que recibe o
devuelve y un algoritmo con el desarrollo del mismo.
 En particular se destaca el método constructor, que no es más que el método que se ejecuta cuando el
objeto es creado.
Este constructor suele tener el mismo nombre de la clase/ objeto, pero aunque es una práctica común, el
método constructor no necesariamente tiene que llamarse igual a la clase (al menos, no en pseudos-código). Es
un método que recibe cero o más parámetros y lo usual es que inicialicen los valores de los atributos del
objeto.
 En lenguajes como Java y C++ se puede definir más de un método constructor, que normalmente se
diferencian entre sí por la cantidad de parámetros que reciben.
 Los métodos se ejecutan o activan cuando el objeto recibe un mensaje, enviado por un objeto o clase
externo al que lo contiene, o por el mismo objeto de manera local.
CREACIÓN DE OBJETOS Y MÉTODOS CONSTRUCTORES:
 Cada objeto o instancia de una clase debe ser creada explícitamente a través de un método u
operación especial denominado.
 Algunos lenguajes proveen un método constructor por defecto para cada clase y/o permiten la
definición de más de un método constructor.
Definición. Los atributos de un objeto toman valores iniciales dados por el constructor. Por convención el
método constructor tiene el mismo nombre de la clase y no se le asocia un modo de acceso (es público).
MÉTODO DE DESTRUCTORES DE OBJETOS:

 Los objetos que ya no son utilizados en un programa, ocupan inútilmente espacio de memoria, que es
conveniente recuperar en un momento dado.
 Según el lenguaje de programación utilizado esta tarea es dada al programador o es tratada
automáticamente por el procesador o soporte de ejecución del lenguaje.
RELACIONES ENTRE CLASES
Las clases no se construyen para que trabajen de manera aislada, la idea es que ellas se puedan relacionar
entre sí, de manera que puedan compartir atributos y métodos sin necesidad de rescribirlos.
La posibilidad de establecer jerarquías entre las clases es una característica que diferencia esencialmente la
programación orientada a objetos de la programación tradicional, ello debido fundamentalmente a que permite
extender y reutilizar el código
existente sin tener que rescribirlo cada vez que se necesite.
Los cuatro tipos de relaciones entre clases estudiados en este curso serán:
 Herencia (Generalización / Especialización o Es-un)
 Agregación (Todo / Parte o Forma-parte-de)
 Composición (Es parte elemental de)
 Asociación (entre otras, la relación Usa-a)
Relación de Herencia (Generalización / Especialización, Es un)
Definición. Es un tipo de jerarquía de clases, en la que cada subclase contiene los atributos y métodos de una
(herencia simple) o más superclases (herencia múltiple).
 Mediante la herencia las instancias de una clase hija (o subclase) pueden acceder tanto a los atributos
como a los métodos públicos y protegidos de la clase padre (o superclase). Cada subclase o clase hija
en la jerarquía es siempre una extensión (esto es, conjunto estrictamente más grande) de la(s)
superclase(s) o clase(s) padre(s) y además incorporar atributos y métodos propios, que a su vez
serán heredados por sus hijas.
Representación:
En la notación algorítmica: Se coloca el nombre de la clase padre después de la frase Hereda de del
encabezado de la clase y se usan sus atributos y métodos públicos o protegidos.
En el diagrama de clases: La herencia se representa mediante una relación de generalización/especificación,
que se denota de la siguiente forma:
Ejemplo: El siguiente diagrama de clases muestra la relación de Herencia entre la Clase Animal y sus
hijas.
Relación de Agregación (Todo / Parte, Forma parte de)

Definición. Es una relación que representa a los objetos compuestos por otros objetos. Indica Objetos que a
su vez están formados por otros. El objeto en el nivel superior de la jerarquía es el todo y los que están en los
niveles inferiores son sus partes o componentes.
Representación en el Diagrama de Clase
La relación forma parte de, no es más que una asociación, que se denota:
Ejemplo: Objeto Casa descrito en términos de sus componentes
Relación de Composición
Un componente es parte esencial de un elemento. La relación es más fuerte que el caso de agregación, al punto
que, si el componente es eliminado o desaparece, la clase mayor deja de existir.
Representación en el Diagrama de Clases
La relación de composición, se denota de la siguiente forma:
Relación de Asociación («uso», usa, cualquier otra relación)
Definición. Es una asociación que se establece cuando dos clases tienen una dependencia de utilización, es
decir, una clase utiliza atributos y/o métodos de otra para funcionar. Estas dos clases no necesariamente están
en jerarquía, es decir, no necesariamente una es clase padre de la otra, a diferencia de las otras relaciones de
clases.
Representación en el Diagrama de Clases

La relación de uso, se denota con una dependencia estereotipada:
ABSTRACCIÓN
Definición. Es el principio de ignorar aquellos aspectos de un fenómeno observado que no son relevantes, con
el objetivo de concentrarse en aquellos que sí lo son. Una abstracción denota las características esenciales de
un objeto (datos y operaciones), que lo distingue de otras clases de objetos. Decidir el conjunto correcto de
abstracciones de un determinado dominio, es el problema central del diseño orientado a objetos.
 Los mecanismos de abstracción son usados en el EOO para extraer y definir del medio a modelar, sus
características y su comportamiento. Dentro del EOO son muy usados mecanismos de abstracción: la
Generalización, la Agregación y la clasificación.
ENCAPSULAMIENTO (OCULTAMIENTO DE INFORMACIÓN)
Definición. Es la propiedad del EOO que permite ocultar al mundo exterior la representación interna del
objeto. Esto quiere decir que el objeto puede ser utilizado, pero los datos esenciales del mismo no son
conocidos fuera de él.
 La idea central del encapsulamiento es esconder los detalles y mostrar lo relevante. Permite el
ocultamiento de la información separando el aspecto correspondiente a la especificación de la
implementación; de esta forma, distingue el "qué hacer" del "cómo hacer". La especificación es
visible al usuario, mientras que la implementación se le oculta.
 El encapsulamiento en un sistema orientado a objeto se representa en cada clase u objeto, definiendo
sus atributos y métodos con los siguientes modos de acceso:
Público (+) Atributos o Métodos que son accesibles fuera de la clase. Pueden ser llamados por cualquier clase,
aun si no está relacionada con ella.
Privado (-) Atributos o Métodos que solo son accesibles dentro de la implementación de la clase.
Protegido (#): Atributos o Métodos que son accesibles para la propia clase y sus clases hijas (subclases).
 Los atributos y los métodos que son públicos constituyen la interfaz de la clase, es decir, lo que el
mundo exterior conoce de la misma.
 Normalmente lo usual es que se oculten los atributos de la clase y solo sean visibles los métodos,
incluyendo entonces algunos de consulta para ver los valores de los atributos. El método constructor
(Nuevo, New) siempre es Público.
MODULARIDAD
Definición. Es la propiedad que permite tener independencia entre las diferentes partes de un sistema. El
modularidad consiste en dividir un programa en módulos o partes, que pueden ser compilados separadamente,
pero que tienen conexiones con otros módulos.
 En un mismo módulo se suele colocar clases y objetos que guarden una estrecha relación. El sentido
de modularidad está muy relacionado con el ocultamiento de información.
Herencia
Definición. Es el proceso mediante el cual un objeto de una clase adquiere propiedades definidas en otra
clase que lo preceda en una jerarquía de clasificaciones. Permite la definición de un nuevo objeto a partir de
otros, agregando las diferencias entre ellos (Programación Diferencial), evitando repetición de código y
permitiendo la reusabilidad.
 Las clases heredan los datos y métodos de la superclase. Un método heredado puede ser sustituido
por uno propio si ambos tienen el mismo nombre.
 La herencia puede ser simple (cada clase tiene sólo una superclase) o múltiple (cada clase puede
tener asociada varias superclases). La clase Docente y la clase Estudiante heredan las propiedades de
la clase Persona (superclase, herencia simple). La clase Preparador (subclase) hereda propiedades
de la clase Docente y de la clase Estudiante (herencia múltiple).
POLIMORFISMO
Definición. Es una propiedad del EOO que permite que un método tenga múltiples implementaciones, que se
seleccionan en base al tipo objeto indicado al solicitar la ejecución del método.
 El polimorfismo operacional o Sobrecarga operacional permite aplicar operaciones con igual

nombre a diferentes clases o están relacionados en términos de inclusión. En este tipo de
polimorfismo, los métodos son interpretados en el contexto del objeto particular, ya que los métodos
con nombres comunes son implementados de diferente manera dependiendo de cada clase.
Por ejemplo, el área de un cuadrado, rectángulo y círculo, son calculados de manera distinta; sin embargo, en
sus clases respectivas puede existir la implementación del área bajo el nombre común Área. En la práctica y
dependiendo del objeto que llame al método, se usará el código correspondiente.
Ejemplos,
 Superclase: Clase Animal
 Subclases: Clases Mamífero, Ave, Pez
DIAGRAMAS DE CLASES, OBJETOS, SU PRESENTACIÓN EN UML

Ejercicios resueltos en argo UML
Esta clase es echo para la clase de vehículo.
Clase realizado para los tipos de frutas.
Clase creada para escuelas superiores
EJERCICO DE CONSTRUCTORES.
Programa para constructores.

package javaapplication4;
import java.util.*;
public class JavaApplication4 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Scanner ingreso = new Scanner(System.in);
int numero1, numero2, numero3;
System.out.println("Ingrese un numero");
numero1=ingreso.nextInt();
suma s=new suma (numero1, numero2);
System.out.println("La suma:"+s.Total());
}
}
class suma
{
int n1, n2, n3;
public suma(int n1, int n2)
{
this.n1=n1;
this.n2=n2;
}
public int Total()
{
return n1+n2;
}
}
Para tres números
import java.util.*;
/**
*/
int numero1, numero2, numero3;
suma s=new suma (numero1, numero2);
System.out.println("La suma:"+s.Total());
suma s1=new suma (numero1, numero2, numero3);
System.out.println("la suma de los
tres:"+s.total1());
}
}
class suma
{
int n1, n2, n3;
public suma(int n1, int n2)
{
this.n1=n1;
this.n2=n2;
}
public int Total()
{
return n1+n2;
}
public suma(int n1, int n2, int n3 )
{
this.n1=n1;
this.n2=n2;
this.n3=n3;
}
public int total1()
{
return n1+n2+n3;
}
}
Prueba.
PARCIAL II
ENTORNOS DE DESARROLLO INTEGRADO (IDE) Y LENGUAJES DE PROGRAMACIÓN ORIENTADA A OBJETOS

(LPOO)
TIPOS DE DATOS BÁSICOS
Definición. En todos los lenguajes de programación existen tipos de datos básicos con los que se realizarán
las operaciones matemáticas básicas y las operaciones booleanas de verdadero o falso.
OPERADORES Y DELIMITADORES BÁSICOS

NOMBRES DE VARIABLES Y FUNCIONES.
Definición. En Java los nombres de las variables y las funciones siguen ciertas reglas, por ejemplo, la
variable se acostumbra a nombrarlas con todas sus letras en minúsculas, las funciones con la primera
palabra que la identifica en minúsculas y las palabras siguientes con la primera letra en mayúsculas y los
nombres de las Clases de objetos con la primera letra de cada palabra que la define en mayúsculas.
TIPOS DE DATOS
Definición. Definen tipos de datos que devolverán los métodos o los tipos de datos que definirán una
propiedad básica. Estos ya los habíamos visto anteriormente pero ahora los describiremos por el espacio que
ocupan en memoria.
PERMISOS Y DECLARACIÓN DE CLASES, PROPIEDADES O MÉTODOS .
Definición. Definen los permisos a un método o clase de objetos, haciendo visible u oculto un método
propiedad o clase a otras clases de objetos u otros objetos que quieran accederlas .
BUCLES Y TOMAS DE DECISIÓN
Definición. Se utilizan para el control de bucles y tomas de decisión en un programa, se utilizan paréntesis ()
para encerrar las condiciones, y llaves {} para los bloques de datos.
EXCEPCIONES, CONTROL DE ERRORES
Definición. En casi todos los lenguajes de programación existen mecanismos para actuar según sucedan
errores de cualquier tipo, desde accesos al disco hasta división por cero, los cuales de no ser manipulados por
nuestro programa tendrán el comportamiento por defecto de la máquina virtual de java, que es reportarlos
como excepciones y terminar el programa.
SECUENCIAS DE ESCAPE
Definición. Las secuencias de escape son aquellas combinaciones de caracteres que nos permiten insertar
un carácter especial que no es posible tipear con el teclado estándar o que no es posible utilizar porque denota
un trozo de texto, por ejemplo las comillas dobles en el ejemplo hola mundo que están dentro de la función
println.
SALIDA POR PANTALLA Y ENTRADA POR TECLADO
Definición. Para los siguientes ejemplos ya tenemos casi todo discutido, excepto que por cuestiones
educativas sería interesante que el programa no solo contenga los valores que interactuarán almacenados,
sino que también sea posible preguntar al usuario.
System.out
Definición. El objeto System es parte de la biblioteca de Java y es instanciado o fabricado al iniciar la JVM
mucho antes que se comience a ejecutar nuestro programa. Este almacena 3 objetos, son out, in y err.
El objeto out es del tipo o clase Printstream que tiene las siguientes propiedades y métodos importantes, no
listaremos todos:
System.in
Definición. El objeto in que es una propiedad de System es de la clase o tipo InputStream, que también es
parte de la biblioteca de Java. Aquí vemos los métodos que nos interesan.
ARREGLOS (ARRAYS) O VECTORES.

Definición. Los arreglos son como un vector, con varias componentes incluso en programación un arreglo
puede representar una matriz de varias dimensiones.
LA CLASE MATH DE PROCEDIMIENTOS Y CONSTANTES MATEMÁTICAS

A continuación veremos la utilidad de la Clase de la biblioteca más útil, que provee algunas cuantas funciones
matemáticas que usaremos para resolver nuestros problemas.
PROGRAMAS RESUELTOS EN JAVA CON NETBEANS IDE
Ejercicio 1: Suma entre dos números
package ejemplo1;
import java.util.*;
/**
*
* @author FIE
*/
public class Ejemplo1 {
/**
*/
// TODO code application logic here
int numero1,numero2,resultado;
System.out.println("Hola aqui estoy");
System.out.println("Introduce el primer numero:");
numero1 = ingreso.nextInt();
System.out.println("Introduce el segundo numero:");
resultado=numero1+numero2;
System.out.println("La suma de " + numero1 + "+" + numero2 +
"=" + resultado);
}
Ejercicio 2: Resta entre dos números

package ejemplo1;
import java.util.*;
/**
*
* @author FIE
*/
/**
*/
resultado=numero1-numero2;
System.out.println("La resta de " + numero1 + "-" + numero2
+ "=" + resultado);
}
Ejercicio 3: Multiplicación entre dos números

package ejemplo1;
import java.util.*;
/**
*
* @author FIE
*/
/**
*/
resultado=numero1*numero2;
System.out.println("La multiplicacion de " + numero1 + "*" +
numero2 + "=" + resultado);
}
Ejercicio 4: División entre dos números

package ejemplo1;
import java.util.*;
/**
*
* @author FIE
*/
/**
*/
resultado=numero1/numero2;
System.out.println("La division de " + numero1 + "/" +
numero2 + "=" + resultado);
}
Ejercicio 5: Eg
package ejemplo1;
import java.util.*;
/**
*
* @author FIE
*/
/**
*/
int numero1,numero2,numero3,resultado,may;
System.out.println("Introduce el tercer numero:");
resultado=numero1+numero2+numero3;
System.out.println("La suma de " + numero1 + "+" + numero2 +
"+" + numero3 + "=" + resultado);
//el mayor de 3 numeros
if(numero1<numero2){
may=numero2;
}
else{
may=numero1;
}
if(may<numero3){
may=numero3;
}
System.out.println("El mayor es: " + may);
}
EJERCICIOS CON BUCLES DE REPETICIÓN.

Realizar un menú con cuatro opciones
package menus;
import java.util.*;
public class Menus {
/**
*/
Scanner entrada = new Scanner(System.in);
int opcion;
System.out.println("Bienvenido a mi Menu");
System.out.println("------------------------");
System.out.println("1.Calcular los n Pares");
System.out.println("2.Calcular el area de un cuadradp");
System.out.println("3.Factorial de un numero
Ingresado");
System.out.println("4. finalizar");
System.out.print("Elija la opcion:");
opcion = entrada.nextInt();
switch (opcion) {
case 1:
System.out.println("Ha seleccionado calcular los
n Pares...");
int i=1,n,a;
System.out.println("Ingrese cuantos numeros
pares desea visualizar: ");
n=entrada.nextInt();
while(i<=n){
a=i*2;
i=i+1;
System.out.println(a);
}
break;
case 2:
System.out.println("Ha seleccionado Calcular el
area de un cuadradp...");
int base;
int haltura;
double areaCuadrado;
System.out.print("Cual es la base?");
base = entrada.nextInt();
System.out.print("Cual es la haltura?");
haltura = entrada.nextInt();
areaCuadrado = base*haltura;
System.out.printf("El area del cuadrado es
%f\n", areaCuadrado);
break;
case 3:
System.out.println("Ha seleccionado Factorial de
un numero Ingresado ...");
int num;
int acum;
System.out.println("Ingrese un numero:");
num=entrada.nextInt();
acum=1;
for(int j=1;j<=num;j++){
acum=acum*j;
}
System.out.println("La respuesta es:");
System.out.println(acum);
break;
case 4:
default:
System.out.println("Ha seleccionado terminar");
}
}
}
PRUEVA
UNA BASE ELEVADO A UN EXPONENTE A TRAVES DE SUMAS SUCESIVAS

package poter;
import java.util.*;
public class Poter {
/**
*/
Scanner op = new Scanner(System.in);
int i, base,expo, acum;
System.out.println("Ingrese la base:");
base=op.nextInt();
System.out.println("Ingrese un exponente:");
expo=op.nextInt();
acum=1;
for(i=1;i<=expo;i++){
acum=acum*base;
}
}
PRUEVA
Realizar un programa que permita ingresar una nota, si la nota

es igual a 10 visualizar matrícula de honor, si es mayor que o
igual a 9 sobresaliente, si es mayor que o igual a 7 notable, si
es mayor que o igual a 5 aprobado y menor que 5 suspenso
import java.util.*;
/**
*
* @author FIE
*/
/**
*/
int nota;
System.out.println("Introduzca una nota:");
nota = ingreso.nextInt();
if(nota==10)
{
System.out.println("Matricula de Honor");
}
else if(nota>=9 && nota<10)
{
System.out.println("Sobresaliente");
}
{
System.out.println("Notable");
}
{
System.out.println("Aprobado");
}
else if(nota<5)
{
System.out.println("Suspenso");
}
}
}
Realizar un programa que permita saber si una persona es

soltera, viuda, casada, divorciada o union libre
import java.util.Scanner;
/**
*
* @author FIE
*/
/**
*/
Scanner sc = new Scanner(System.in);
String cadena;
System.out.println("Introduce tu nombre:");
cadena= sc.nextLine();
System.out.println("MENU");
System.out.println("s = Soltero");
System.out.println("c = Casado");
System.out.println("d = Divorciado");
System.out.println("v = Viudo");
System.out.println("u = Union Libre");
Scanner lec = new Scanner(System.in);
char estado;
System.out.println("Elige una letra: ");
estado=lec.next().charAt(0);
switch(estado)
{
case 's':
System.out.println("Sr " + cadena + " Su estado
civil es Soltero");
break;
case 'c':
civil es Casado");
break;
case 'd':
civil es Divorciado");
break;
case 'v':
civil es Viudo");
break;
case 'u':
civil es Unión libre");
break;
default:
System.out.println("Opcion Incorrecta");
}
}
REALIZAR UN PROGRAMA QUE OBTENGA LOS N NÚMEROS PARES
package par;
import java.util.*;
public class Par {
/**
*/
int i=1,n,a;
System.out.println("Ingrese cuantos numeros pares desea
visualizar: ");
n=op.nextInt();
while(i<=n){
a=i*2;
i=i+1;
}
}
}
PRUEVA
REALIZAR UN PROGRAMA QUE OBTENGA LOS N PRIMEROS NUMEROS PRIMOS

package primos;
/**
*
* @author jose
*/
public class Primos {
/**
*/
Scanner sc=new Scanner(System.in);
int num,i,n=4,cont=2;
String cad="";
System.out.println("ingrese un numero");
num=sc.nextInt();
if(num>2){
cad="2 - 3";
while(cont<num){
i=2;
while(i<=n){
if(i==n){
cad=cad+" - "+n;
cont=cont+1;
}else{
if(n % i==0){
i=n;
}
}
i=i+1;
}
n=n+1;
}
System.out.println(cad);
}else{
if(num>0){
if(num==1){
System.out.println("es primo 2");
}else{
System.out.println("es primo 2, 3");
}
}else{
System.out.println("ingresa numeros positivos");
}
}
}
}
PRUEVA
UNA BASE ELEVADO A UN EXPONENTE A TRAVES DE SUMAS SUCESIVAS

package poter;
import java.util.*;
public class Poter {
/**
*/
int i, base,expo, acum;
System.out.println("Ingrese la base:");
base=op.nextInt();
System.out.println("Ingrese un exponente:");
expo=op.nextInt();
acum=1;
for(i=1;i<=expo;i++){
acum=acum*base;
}
}
PRUEVA
FACTORIAL DE UN NUMERO A TRAVES DE SUMAS SUCESIVAS
package factorial;
import java.util.*;
public class Factorial {
/**
*/
int num,acum,i;
System.out.println("Ingrese un numero:");
num=op.nextInt();
acum=1;
for(i=1;i<=num;i++){
acum=acum*i;
}
}
}
LIBRE (UD PUEDE REALIZAR CUALQUIER EJERCICIO)
import java.util.*;
/**
*/
int nota;
System.out.println("Introduzca una nota:");
nota = ingreso.nextInt();
if(nota==10)
{
System.out.println("Matricula de Honor");
}
{
System.out.println("Sobresaliente");
}
{
System.out.println("Notable");
}
{
System.out.println("Aprobado");
}
else if(nota<5)
{
System.out.println("Suspenso");
}
}
EJERCICIO DE MATRISES Y VECTORES

Realizar un programa que permita ingresar en un vector los días
que tiene cada mes del año 2016.
package vectores;
import java.util.*;
/**
*
* @author FIE
*/
public class Vectores {
/**
*/
System.out.println("Programa 1 vectores: ");
System.out.println("Programa que indica los dias que
tiene cada mes del año 2016");
int Mes[];
Mes=new int[12];
Mes[0]=31;
Mes[1]=28;
Mes[2]=31;
Mes[3]=30;
Mes[4]=31;
Mes[5]=30;
Mes[6]=31;
Mes[7]=31;
Mes[8]=30;
Mes[9]=31;
Mes[10]=30;
Mes[11]=31;
System.out.println("Los dias de Enero son : " + Mes[0]);
System.out.println("Los dias de Febrero son : " +
Mes[1]);
System.out.println("Los dias de Marzo son : " + Mes[2]);
System.out.println("Los dias de Abril son : " + Mes[3]);
System.out.println("Los dias de Mayo son : " + Mes[4]);
System.out.println("Los dias de Junio son : " + Mes[5]);
System.out.println("Los dias de Julio son : " + Mes[6]);
System.out.println("Los dias de Agosto son : " +
Mes[7]);
System.out.println("Los dias de Septiembre son : " +
Mes[8]);
System.out.println("Los dias de Octubre son : " +
Mes[9]);
System.out.println("Los dias de Noviembre son : " +
Mes[10]);
System.out.println("Los dias de Diciembre son : " +
Mes[11]);
}
}
Realizar un programa que permita ingresar N numeros en un
vector y los ordene de mayor a menor.
import java.io.*;
public class mayoramenor {
public static void main(String[]args)throws IOException{
int i,n;
BufferedReader br;
br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Cuantos numeros va a ingresar

:");
n=Integer.parseInt(br.readLine());
System.out.println("Usted ingresara " + n + "
numeros");
int datos[]= new int[n];
System.out.println("Ingrese los numeros :" );
for(i=0;i<n;i++){
datos[i]=Integer.parseInt(br.readLine()); }
for(i=0;i<n-1;i++)
{
int min=i;
for(int j=i+1;j<n;j++) {
if(datos[j]<datos[min]) {
min=j;}
}
if(i!=min){
int aux =datos[i];
datos[i]=datos[min];
datos[min] = aux;
}
}
System.out.println("Los numeros de mayor a menor son
:");
for(int k=n; k>0;k--)
System.out.print(datos[k] + " ");

}
}
Realizar un programa que permita sumar dos vectores de N

elementos ingresados y se obtenga en otro vector.
public class Suma {
Scanner leer = new Scanner(System.in);
//variables que seran el tamaño de los vectores
int v1,v2,v3;
System.out.print("Ingrese tamaño del vector 1:");
v1 = leer.nextInt();
//creamos el primer vector con tamaño del usuario
int vec1[] = new int[v1];
//recorremos vector para llenarlo
for(int i1=0; i1<vec1.length; i1++){
System.out.print("\nIngrese Numero Entero de la
Posicion"+" " +i1+":");
vec1[i1]=leer.nextInt();
}
System.out.print("\nIngrese tamaño del vector 2:");
v2 = leer.nextInt();
//creamos el segundo vector con tamaño del usuario
int vec2[] = new int[v2];
//recorremos vector para llenarlo
System.out.print("\nIngrese Numero Entero de la
Posicion"+" " +i2+":");
vec2[i2]=leer.nextInt();
}
//determinamos cual vector de los 2 es mas grande
//para que el vector 3 tenga el tamaño del mas grande
v3=v1;
if (v2 > v1)
v3=v2;
//declaramos vector 3
int[] vec3 = new int[v3];
//recorremos vector 3 para hacer la suma
int valv1 = 0;
if (vec1.length > i3){
valv1 = vec1[i3];
}
int valv2 = 0;
if (vec2.length > i3){
valv2 = vec2[i3];
}
//hacemos la suma de las posiciones de los vectores
1 y 2
//en las posiciones del vector 3
vec3[i3]=valv1+valv2;
System.out.println("\nLa Suma de la Posicion"+"
"+i3+" "+ "es:"+vec3[i3]);
}
}
Ingresar en un vector los N primeros números pares y en otro los

N primeros números impares, visualizar solamente en otro vector
solo los de las posiciones pares.
package visualizar;
public class visualizar {
int b[]=new int[10];
int a[]=new int[10];
int i,j,n;
Scanner s = new Scanner(System.in);
n=s.nextInt();
for(i=1;i<=n;i++){
System.out.print("elemento del vector "+i+": \n" );
System.out.print((a[i]=2*i)+"\n");
}
for(i=1;i<=n;i++){
System.out.print("elemento del vector "+i+": \n");
System.out.print( (b[i]=(2*i)-1)+"\n");
}
for(i=1;i<=n;i++){
if(i%2==0){
System.out.print("\na"+a[i]);
}
else{
System.out.print("\n"+b[i]);
}
}
}
Realizar un programa de multiplicación por sumas sucesivas.

package multilicacionpor.sumas.susecivas;
import java.util.*;
public class MultilicacionporSumasSusecivas {
/**
*/
int a, b, s=0;
System.out.print("ingresa el valor: ");
a = entrada.nextInt();
System.out.print("ingresa el valor : ");
b = entrada.nextInt();
for(int i=1;i<=b;i++)
{
s=s+a;
}
System.out.println("el resultado es:" + s);
}
}
PRUEBA
Realice un programa que resuelva exponente por sumas sucesivas

package exponente.por.sumas.sucecivas;
import java.util.*;
public class ExponentePorSumasSucecivas {
/**
*/
int a, b, s=0, p;
System.out.print("ingresa el valor de la base ");
a = entrada.nextInt();
System.out.print("ingresa el valor del esponente ");
b = entrada.nextInt();
p=a;
for(int i=1;i<b;i++)
{
s=0;
for(int j=1;j<=p;j++)
{
s=s+a;
}
a=s;
}
}
}
PRUEBA
MENU CON 4 OPCIONES.

package Menu;
public class Menu {
int n,p,t=0,i;
int nu,pi = 0,i = 0;
int in;
int jn = 0;
int nn;
int an[]=new int[100];
int aux = 0;
Pares[] pm= new Npares[100];
vector[] vec= new vector[100];
do{
System.out.println("-------------------MENU-------------
---");
System.out.println("1.Suma");
System.out.println("2.N Primeros Números pares");
System.out.println("3. Ordenar un vector de N
Elementos");
System.out.println("4. Salir");
System.out.println("Insertar opcion: ");
n=op.nextInt();
switch (n) {
case 1:
System.out.println("Ingrese el Primer número: ");
int x = op.nextInt();
System.out.println("Ingrese el Segundo número: ");
int y = op.nextInt();
Sumar r = new Sumar();
System.out.println("la suma de " + x + " +" + y + "
es = ");
System.out.println(r.resultado(x, y));
break;
case 2:
for(i=1;i<=1;i++){
System.out.print("Ingresar cantidad de
números pares a ver: ");
nu=op.nextInt();
pm[i]= new Npares();
pm[i].iNpares(nu, pi, i);
}
for(i=1;i<=1;i++){
System.out.print(" "+pm[i].Calcularpares()+" ");
}
break;
case 3:
for(i=1;i<=1;i++){
System.out.print("Ingrese la dimension del
vector: ");
nn=op.nextInt();
System.out.printf("ingreso del vector: \n");
for(in=1;in<=nn;in++){
System.out.printf("elemento ["+in+"]:
");
an[in]=op.nextInt();
}
vec[i]= new vector();
vec[i].vector(in, jn, nn, an, aux);
}
for(i=1;i<=1;i++){
System.out.print("\nOrdenar"+i+"\n");
System.out.print((vec[k].ordenar())+"\n");
}
break;
case 4:
System.out.print(" Salir ");
break;
default:
break;
}
}while(n<4);
}
}
class Sumar{
public int resultado(int x,int y){
return x+y;
}
}
class Npares{
int nu;
int pi;
int i;
public void iPares(int nu, int pi, int i) {

this.nu = nu;
this.pi = pi;
this.i = i;
}
public String Calcularpares(){
for(i=1;i<=nu;i++){
pi=2*i;
System.out.print(" "+pi+" ");
}
return " \n";
}
}
class vector{
int in;
int jn;
int nn;
int an[];
int aux;
public vector() {
}
public void vector(int in, int jn, int nn, int[] an, int
aux) {
this.in = in;
this.jn = jn;
this.nn = nn;
this.an = an;
this.aux=aux;
}
public int[] ordenar(){
for(in=1;in<nn;in++){
for(jn=1;jn<nn;jn++){
if(an[jn+1]<an[jn]){
aux=an[jn+1];
an[jn+1]=an[jn];
an[jn]=aux;
}
}
}
System.out.print("ascendente: \n");
for(in=1;in<=nn;in++){
System.out.print(an[in]+" ");
}
System.out.print("\ndescendente: \n");
for(in=nn;in>0;in--){
System.out.print(an[in]+" ");
}
return an;
}
}
EJERCICIOS ECHOS CON BUTON

/*
* To change this license header, choose License Headers in
Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
import java.sql.DriverManager;
import java.sql.*;
import javax.swing.JOptionPane;
/**
*
* @author FIE
*/
public class Form1 extends javax.swing.JFrame {
/**
* Creates new form Form1
*/
public Form1() {
initComponents();
limpiar();
bloquear();
}
void limpiar(){
txtCodigo.setText("");
txtNombre.setText("");
txtDir.setText("");
}
void bloquear(){
txtCodigo.setEnabled(false);
txtNombre.setEnabled(false);
txtDir.setEnabled(false);
btnNuevo.setEnabled(true);
btnGuardar.setEnabled(false);
btnCancelar.setEnabled(false);
}
void desbloquear(){
txtCodigo.setEnabled(true);
txtNombre.setEnabled(true);
txtDir.setEnabled(true);
btnNuevo.setEnabled(false);
btnGuardar.setEnabled(true);
btnCancelar.setEnabled(true);
}
/**
* This method is called from within the constructor to
initialize the form.
* WARNING: Do NOT modify this code. The content of this
method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated
Code">
private void initComponents() {
jLabel1 = new javax.swing.JLabel();

btnNuevo = new javax.swing.JButton();
btnGuardar = new javax.swing.JButton();
txtCodigo = new javax.swing.JTextField();
txtNombre = new javax.swing.JTextField();
txtDir = new javax.swing.JTextField();
btnCancelar = new javax.swing.JButton();
btnSalir = new javax.swing.JButton();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLO
SE);
jLabel1.setText("CODIGO");
jLabel1.setName("txtCodigo"); // NOI18N
jLabel2.setText("NOMBRE");
jLabel2.setName("txtNombre"); // NOI18N
jLabel3.setText("DIRECCION");
jLabel3.setName("txtDireccion"); // NOI18N
btnNuevo.setText("NUEVO");
btnNuevo.setName("btnNuevo"); // NOI18N
btnNuevo.addActionListener(new
java.awt.event.ActionListener() {
public void
actionPerformed(java.awt.event.ActionEvent evt) {
btnNuevoActionPerformed(evt);
}
});
btnGuardar.setText("GUARDAR");
btnGuardar.setName("btnGuardar"); // NOI18N
btnGuardar.addActionListener(new
public void
btnGuardarActionPerformed(evt);
}
});
btnCancelar.setText("CANCELAR");
btnCancelar.setName("btnCancelar"); // NOI18N
btnCancelar.addActionListener(new
public void
btnCancelarActionPerformed(evt);
}
});
btnSalir.setText("SALIR");
btnSalir.addActionListener(new
public void
btnSalirActionPerformed(evt);
}
});
javax.swing.GroupLayout layout = new

javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEA
DING)
.addGroup(layout.createSequentialGroup()
.addGap(37, 37, 37)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Ali
gnment.LEADING)
gnment.TRAILING)
.addComponent(jLabel2)
.addComponent(jLabel1))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELA
TED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
gnment.LEADING, false)
.addComponent(txtNombre,
javax.swing.GroupLayout.Alignment.TRAILING)
.addComponent(txtDir,
javax.swing.GroupLayout.PREFERRED_SIZE, 198,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(txtCodigo,
javax.swing.GroupLayout.Alignment.TRAILING))
.addGap(45, 45, 45))
.addContainerGap()
.addComponent(btnNuevo)
.addGap(18, 18, 18)
.addComponent(btnGuardar)
.addGap(18, 18, 18)
.addComponent(btnCancelar)
.addGap(18, 18, 18)
.addComponent(btnSalir)
.addGap(0, 0, Short.MAX_VALUE))
);
layout.setVerticalGroup(
DING)
.addGap(12, 12, 12)
gnment.BASELINE)
.addComponent(jLabel1,
javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE,
javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(11, 11, 11)
gnment.BASELINE)
TED)
gnment.BASELINE)
TED, 138, Short.MAX_VALUE)
gnment.BASELINE)
.addComponent(btnSalir))
.addGap(44, 44, 44))
);
pack();
}// </editor-fold>
private void
btnNuevoActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
limpiar();
desbloquear();
}
private void
btnSalirActionPerformed(java.awt.event.ActionEvent evt) {
this.dispose();
}
private void
btnGuardarActionPerformed(java.awt.event.ActionEvent evt) {
bloquear();
try{
Class.forName("com.mysql.jdbc.Driver");
Connection
con=DriverManager.getConnection("jdbc:mysql://127.0.0.1/Prueba",
"root","");
String Cod,Nom,Dir;
Cod=txtCodigo.getText();
Nom=txtNombre.getText();
Dir=txtDir.getText();
String Sql1="";
Sql1="INSERT INTO
Empleados(Codigo,Nombre,Dir)VALUES(?,?,?)";
PreparedStatement psd=con.prepareStatement(Sql1);
psd.setString(1,Cod);
psd.setString(2,Nom);
psd.setString(3,Dir);
int n=psd.executeUpdate();
if(n>0){
JOptionPane.showMessageDialog(null,"Registro
Almacenado con exito");
}
}
catch(SQLException ex){
System.out.println("Error de MYSQL");
}
catch(Exception e){
System.out.println("Error
Inesperado"+e.getMessage());
}
}
private void
btnCancelarActionPerformed(java.awt.event.ActionEvent evt) {
limpiar();
bloquear();
}
/**
*/
public static void main(String args[]) {
/* Set the Nimbus look and feel */
//<editor-fold defaultstate="collapsed" desc=" Look and
feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not available,
stay with the default look and feel.
* For details see
http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/p
laf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Form1.class.getName()).log(ja
va.util.logging.Level.SEVERE, null, ex);
} catch (InstantiationException ex) {
} catch (IllegalAccessException ex) {
} catch (javax.swing.UnsupportedLookAndFeelException ex)
{
}
//</editor-fold>
/* Create and display the form */

java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Form1().setVisible(true);
}
});
}
// Variables declaration - do not modify

private javax.swing.JButton btnCancelar;
private javax.swing.JButton btnGuardar;
private javax.swing.JButton btnNuevo;
private javax.swing.JButton btnSalir;
private javax.swing.JLabel jLabel1;
private javax.swing.JTextField txtCodigo;
private javax.swing.JTextField txtDir;
private javax.swing.JTextField txtNombre;
// End of variables declaration
}
EJERCICIOS DE CONTRUCTORES Y HERENCIAS
Realizar menú con 4 opciones
1. Sumar.
2. N pares (2 constructor).
3. Potencia suma sucesivas (3 constructor).
4. Salir.
package examen;
public class Examen {
/**
*/
int n,p,t=0,i;
int a, b, s=0;
i = 0;
int aux = 0;
do
{
System.out.println("-------------------MENU-------------
---");
System.out.println("1.Sumar");
System.out.println("2.N Primeros Números pares");
System.out.println("3. Potencia por sumas susesivas");
System.out.println("4. Salir");
System.out.println("Insertar opcion: ");
n=op.nextInt();
switch (n)
{
case 1:
System.out.println("Ingrese el Primer número: ");
int x = op.nextInt();
System.out.println("Ingrese el Segundo número:
");
int y = op.nextInt();
Sumar r = new Sumar();
System.out.println("la suma de " + x + " +" + y +
" es = ");
System.out.println(r.resultado(x, y));
break;
case 2:
System.out.println("Ingrese cuantos numeros pares
desea visualizar: ");
n=op.nextInt();
while(i<=n)
{
a=i*2;
i=i+1;
}
break;
case 3:
System.out.print("ingresa el valor de la base ");
a = op.nextInt();
System.out.print("ingresa el valor del esponente
");
b = op.nextInt();
p=a;
for( i=1;i<b;i++)
{
s=0;
{
s=s+a;
}
a=s;
}
break;
case 4:
System.out.print(" Salir ");
break;
default:
break;
}
}while(n<4);
}
}
class Sumar{
public int resultado(int x,int y){
return x+y;
}
}
class Npares{
int i;
int n;
int a;
public void iPares(int i, int n, int a)
{
this.i = i;
this.n = n;
this.a = a;
}
public String Calcularpares(){
for(i=1;i<=n;i++){
a=2*i;
System.out.print(" "+a+" ");
}
return " \n";
}
}
class Nexponent{
int a;
int b;
int s=0;
int p;
public void iExponente(int a, int b, int s, int p){
this.a = a;
this.b = b;
this.s = s;
this.p = p;
}
public String Calcularpoter(){
return " \n";
}
public String Calcularpotencia(){
for(int i=1;i<b;i++)
{
s=0;
{
s=s+a;
}
a=s;
}
System.out.println("" + s + "");
return " \n";
}
}
Prueba de escritorio.
Prueba en java de linias de código.

Herencia auto
package carro;
public class Carro {
/**
*/
Herencia op =new Herencia();
op.arrancarHerencia();
op.conduciHerencia();
System.out.println("El radio es:"+op.tamaño);

System.out.println("El peso es:"+op.peso);
float r,p;
r=op.peso;
p=op.tamaño;
System.out.println("El tamaño es:"+r);
System.out.println("El peso es:"+p);
Herenciaautomil op1=new Herenciaautomil();
op1.uso();
Herenciacamioneta op2=new Herenciacamioneta();
op2.uso1();
public class Herencia {

float tamaño;
float peso;
String ruedas;
String Puertas;
String modelo;
String aceleracion;
public Herencia(){
tamaño=300;
peso=5000;
}
public Herencia(float tamaño,float peso)
{
this.tamaño=tamaño;
this.peso=peso;
}
public void conduciHerencia()
{
System.out.println("Usted conduce auto");
}
public void arrancarHerencia()
{
System.out.println("Usted sabe arancar carro");
}
public void vertamaño()
{
System.out.println("El Tamaño es:"+tamaño);
}
public void verpeso()
{
System.out.println("El peso es:"+peso);
}
}
class Herenciaautomil extends Herencia
{
public Herenciaautomil()
{
this.modelo="Mazda";
this.ruedas="Generii";
}
public void uso()
{
System.out.println("acabas de conducir Mazda BTU 500");
System.out.println("Las llantas de este automovil era de
marca Generii");
}
}
class Herenciacamioneta extends Herencia
{
public Herenciacamioneta()
{
this.modelo="Toyota";
this.Puertas="Dos";
this.aceleracion="Minimo 20, Maximo 100";

}
public void uso1()
{
System.out.println("Acabas de conducir una Toyota 200");
System.out.println("Puedes ingresarpor las dos
puertas");
System.out.println("Estas acelerando 40Km por hora tenga
cuidado");
}
MÉTODOS PARA ORDENAR LISTAS

Método de la burbuja o Método de Ordenación por Selección
Definición. Este método es antiguo y obsoleto, pero sirve para aprender, por su simpleza y porque para
pocos elementos no consume muchos recursos, la idea es la siguiente: tenemos una lista de datos
desordenada y comparamos los dos primeros y sólo esos dos los ordenamos de mayor a menor, el paso
siguiente es comparar el que sigue con el anterior y así sucesivamente hasta llegar al final, si contamos las
comparaciones, fueron el total de los datos de la lista, menos una porque son de dos en dos .
Método QuickSort Recursivo
Definición. Este método para ordenar, es recursivo, si entendimos el ejemplo anterior, pudimos ver que la
ejecución del algoritmo era secuencial, es decir 1 sola función hizo todo el trabajo en sí misma.
Este algoritmo implementa la división en dos grupos del arreglo a ordenar y por lo tanto la misma operación se
realiza con cada subgrupo que a su vez se vuelve a dividir, y como es la misma operación se llama a la misma
función varias veces.
COMPONENTES Y DISEÑO
La clase principal AWT se llama Component. Las subclases de Componentrepresentan los elementos gráficos de
la interface del usuario (excepto los menús que, inexplicablemente, descienden de otra
clase MenuComponent). Component es una clase abstracta, esto es, que solo se pueden crear objetos
pertenecientes a sus subclases y no al ella misma. Las subclases que representan los elementos comunes GUI
son: Button, Checkbox, Choice, Label, List, Scrollbar, TextArea, y TextField.
Los objetos de estas clases tienen comportamientos predefinidos. En la mayor parte de ocasiones, todo lo que
tiene que hacer es añadirlos a su programa y ellos se encargan de todo. Cuando el usuario interactua con uno de
estos componentes y se requiere alguna acción, los componentes generan eventos que el programa puede
detectar y reaccionar convenientemente. Hay también una subclase Canvas que representa un área rectangular
que puede ser usada para presentar imágenes.
Estos componentes predefinidos se explican en el siguiente articulo, y los eventos que generan están
desarrollados en el posterior. En esta, quiero concentrarme en lo que significa “añadir componentes a su
programa”. Por esto, necesita entender la clase Container y sus subclases.
Un contenedor (container), en este contexto, es un componente que puede contener otros componentes. Observe
que Container es una subclase de Component. La clase Containerigual que la Component son clases
abstractas. Container directamente tiene dos subclases, Window y Panel. Window representa una ventana
independiente del nivel superior, y que no esta contenida en ningún otro componente, lo que no significa que se
pueda usar directamente. Tiene dos subclases: Frame que representa la ventana normal que puede tener sus
propias barras de menús, y Dialog que representa las cajas de dialogo que se pueden emplear para interactuar
limitadamente con el usuario.
ENTRADA/SALIDA SIMPLE BASADA EN GUI CON JOPTIONPANE
La clase JOptionPane de Java (paquete javax.swing) proporciona cuadros de diálogo pre empaquetados para
entrada y salida. Estos diálogos se muestran mediante la invocación de los métodos static de JOptionPane.
Convertir objetos String en valores int
Para realizar el cálculo en esta aplicación, debemos convertir los objetos String que el usuario introdujo, en
valores int. El método static parseInt de la clase Integer convierte su argumento String en un valor int.
GENERALIDADES DE LOS COMPONENTES DE SWING
El paquete javax.swing, que se utilizan para crear GUIs en Java. La mayoría de los componentes de Swing son
componentes puros de Java: están escritos, se manipulan y se muestran completamente en Java. Forman parte
de las JFC (Java Foundation Classes); las bibliotecas de Java para el desarrollo de GUIs para múltiples
plataformas. Visite java.sun.com/products/jfc para obtener más información acerca de JFC.
Comparación entre Swing y AWT
En realidad hay dos conjuntos de componentes de GUI en Javas. Antes de introducir a Swing en Java se creaban
a partir de componentes del Abstract Window Toolkit (AWT) en el paquete java.awt.
Cuando una aplicación de Java con una GUI del AWT se ejecuta en distintas plataformas, los componentes de la
GUI de la aplicación se muestran de manera distinta en cada plataforma. Considere una aplicación que muestra
un objeto de tipo Button (paquete java.awt). En una computadora que ejecuta el sistema operativo Microsoft
Windows, el objeto Button tendrá la misma apariencia que los botones en las demás aplicaciones Windows.
Comparación entre componentes de GUI ligeros y pesados

La mayoría de los componentes de Swing no están enlazados a los componentes reales de GUI que soporta la
plataforma subyacente en la cual se ejecuta una aplicación. Dichos componentes de la GUI se conocen como
componentes ligeros. Los componentes de AWT (muchos de los cuales se asemejan a los componentes de
Swing) están enlazados a la plataforma local y se conocen como componentes pesados, ya que dependen del
sistema de ventanas de la plataforma local para determinar su funcionalidad y su apariencia visual.
SUPERCLASES COMUNES DE MUCHOS DE LOS COMPONENTES DE SWING.
La clase Component (paquete java.awt) es una subclase de Object que declara muchos de los atributos y
comportamientos comunes para los componentes de GUI en los paquetes java.awt y javax.swing.
La clase Container (paquete java.awt) es una subclase de Component. Como veremos pronto, los objetos
Component se adjuntan a objetos Container (como las ventanas), de manera que los objetos Component se
puedan organizar y mostrar en la pantalla. Cualquier objeto que sea un Container se puede utilizar para
organizar a otros objetos Component en una GUI. Como un Container es un Component, puede adjuntar objetos
Container a otros objetos Container para ayudar a organizar una GUI.
La clase JComponent (paquete javax.swing) es una subclase de Container. JComponent es la superclase de
todos los componentes ligeros de Swing, y declara los atributos y comportamientos comunes. Debido a que
JComponent es una subclase de Container, todos los componentes ligeros de Swing son también objetos
Container.
Algunas de las características comunes para los componentes ligeros que soporta JComponent son:
 Una apariencia visual adaptable, la cual puede utilizarse para personalizar la apariencia de los
componentes (por ejemplo, para usarlos en plataformas específi cas). En la sección 22.6 veremos un
ejemplo de esto.
 Teclas de método abreviado (llamadas nemónicos) para un acceso directo a los componentes de la GUI
por medio del teclado. En la sección 22.4 veremos un ejemplo de esto.
 Herramientas manejadoras de eventos comunes, para casos en los que varios componentes de la GUI
inician las mismas acciones en una aplicación.
 Breves descripciones del propósito de un componente de la GUI (lo que se conoce como cuadros de
información sobre herramientas o tool tips) que se muestran cuando el cursor del ratón se coloca
sobre el componente durante un breve periodo. En la siguiente sección veremos un ejemplo de esto.
 Soporte para tecnologías de ayuda, como lectores de pantalla Braille para las personas con
impedimentos visuales.
 Soporte para la localización de la interfaz de usuario; es decir, personalizar la interfaz de usuario para
mostrarla en distintos lenguajes y utilizar las convenciones de la cultura local.
MOSTRAR TEXTO E IMÁGENES EN UNA VENTANA
La clase JFrame o una subclase de JFrame. JFrame proporciona los atributos y comportamientos básicos de
una ventana: una barra de título en la parte superior, y botones para minimizar, maximizar y cerrar la ventana.
Como la GUI de una aplicación por lo general es específica para esa aplicación, la mayoría de nuestros ejemplos
consistirán en dos clases: una subclase de JFrame que nos ayuda a demostrar los nuevos conceptos de la GUI y
una clase de aplicación, en la que main crea y muestra la ventana principal de la aplicación.
Algunos componentes de GUI básicos.
CAMPOS DE TEXTO Y UNA INTRODUCCIÓN AL MANEJO DE EVENTOS CON CLASES ANIDADAS

Las GUIs son controladas por eventos. Cuando el usuario interactúa con un componente de la GUI, la interacción
(conocida como un evento) controla el programa para que realice una tarea. Algunos eventos (interacciones del
usuario) comunes que podrían hacer que una aplicación realizara una tarea incluyen el hacer clic en un botón,
escribir en un campo de texto, seleccionar un elemento de un menú, cerrar una ventana y mover el ratón.
El código que realiza una tarea en respuesta a un evento se llama manejador de eventos y al proceso en general
de responder a los eventos se le conoce como manejo de eventos.
En este, presentaremos dos nuevos componentes de GUI que pueden generar eventos: JTextField y
JPasswordField (paquete javax.swing).La clase JTextField extiende a la clase JTextComponent (paquete
javax.swing.text), que proporciona muchas características comunes para los componentes de Swing basados en
texto. La clase JPasswordField extiende a JTextField y agrega varios métodos específi cos para el
procesamiento de contraseñas. Cada uno de estos componentes es un área de una sola línea, en la cual el
usuario puede introducir texto mediante el teclado.
Pasos requeridos para establecer el manejo de eventos para un componente de GUI
Este ejemplo debe mostrar un diálogo de mensaje que contenga el texto de un campo de texto, cuando el usuario
oprime Intro en ese campo de texto. Antes de que una aplicación pueda responder a un evento para un
componente de GUI específico, debemos realizar varios pasos de codificación:
 Crear una clase que represente al manejador de eventos.
 Implementar una interfaz apropiada, conocida como interfaz de escucha de eventos, en la clase del
paso 1.
 Indicar que se debe notificar a un objeto de la clase de los pasos 1 y 2 cuando ocurra el evento. A esto
se le conoce como registrar el manejador de eventos.
Uso de una clase anidada para implementar un manejador de eventos
Todas las clases que hemos visto hasta ahora se conocen como clases de nivel superior; es decir, las clases no
se declararon dentro de otras clases. Java nos permite declarar clases dentro de otras clases; a éstas se les
conoce como clases anidadas. Las clases anidadas pueden ser static o no static. Las clases anidadas no static
se llaman clases internas, y se utilizan con frecuencia para el manejo de eventos.
Detalles del método actionPerformed de la clase ManejadorCampoTexto
En este ejemplo estamos usando el método actionPerformed de un objeto manejador de eventos para manejar
los eventos generados por cuatro campos de texto. Como nos gustaría imprimir en pantalla el nombre de la
variable de instancia de cada campo de texto para fines demostrativos, debemos determinar cuál campo de
texto generó el evento cada vez que se hace una llamada a actionPerformed.
Algunas clases de eventos del paquete java.awt.event.
Algunas interfaces comunes de componentes de escucha de eventos del paquete java.awt.event.
Registro de eventos para el objeto JTextField campoTexto1.
EJERCICIOS CON JOPTION PANEL.

SUMA DE TRES NUMEROS.
package joptions;
public class Joptions {
/**
*/
String primerDato, segundoDato;
String resultado;
int dato1, dato2;
primerDato= JOptionPane.showInputDialog ("Primer dato:

");
segundoDato= JOptionPane.showInputDialog ("Segundo dato:
");
dato1= Integer.parseInt(primerDato);
dato2= Integer.parseInt(segundoDato);
int z = dato1+dato2;
resultado = "";
resultado += "OPERACION DE SUMA\n";
resultado += "\nNum1 "+dato1;
resultado += "\nNum2 "+dato2;
resultado += "\nTotal ";
resultado += z;
JOptionPane.showMessageDialog(null, resultado, "Suma de

2 numeros", JOptionPane.INFORMATION_MESSAGE);
}
PRUEVA DE ESCRITORIO
Realizar un programa que use la función JOptionPane para
ultiplicar una tabla.
package tablajpanel;
public class Tablajpanel {
/**
*/
String primerDato;
String resultado;
int X;
primerDato= JOptionPane.showInputDialog ("Igrese un

numero: ");
X= Integer.parseInt(primerDato);
resultado = "";
resultado += "Tabla de multiplicar\n";
for(int i=1;i<=12;i++)
{
int r=X*i;
resultado += r +"\n";
}
JOptionPane.showMessageDialog(null, resultado, "Tabla de

multiplicar", JOptionPane.INFORMATION_MESSAGE);
}
}
PRUEVA DE ESCRITORIO
Saludo desde una clase a la función main

package uso.de.clase;
public class UsoDeClase {
/**
*/
Auto m = new Auto();
int a;
m.Saludo();
Saludo();
a= Suma(2,4);
a=m.Suma(2,4);
}
public static void Saludo()

{
System.out.println("Saludo desde la funcion main");
}
public static int Suma(int x, int y){
return x+y;
}
}
class Auto {
public void Saludo()
{
System.out.println("Saludo desde la clase");
}
public int Suma(int x, int y){
return x+y;
}
}
Prueba de escritorio.
Diseñar calculadora con JOption panel en java y también con

JFrame
package calculator;
public class Calculator {
/**
*/
boolean seguir = true;
while(seguir)
{
String opcion =
JOptionPane.showInputDialog( "Bienvenido a mi
calculadora:\n1-Suma\n2-Resta\n3-Multiplicacion\n4-Division\n0-
Salir\nPon tu opcion:");
switch(opcion)
{
case "1":
int
suma=Integer.parseInt(JOptionPane.showInputDialog( "Introduzca
el primer
entero"))+Integer.parseInt(JOptionPane.showInputDialog(
"Introduzca el segundo entero"));
JOptionPane.showMessageDialog(null, "La suma es "+
suma, "Suma de dos enteros", JOptionPane.PLAIN_MESSAGE);
break;
case "2":
int
resta=Integer.parseInt(JOptionPane.showInputDialog( "Introduzca
el primer entero"))-
Integer.parseInt(JOptionPane.showInputDialog( "Introduzca el
segundo entero"));
JOptionPane.showMessageDialog(null, "La resta es "+
resta, "Resta de dos enteros", JOptionPane.PLAIN_MESSAGE);
break;
case "3":
int mult =
primer entero"))*Integer.parseInt(JOptionPane.showInputDialog(
JOptionPane.showMessageDialog(null, "La
multiplicacion es "+ mult, "Multiplicacion de dos enteros",
JOptionPane.PLAIN_MESSAGE);
break;
case "4":
double div =
primer entero"))/Integer.parseInt(JOptionPane.showInputDialog(
JOptionPane.showMessageDialog(null, "La division es
"+ div, "Division de dos enteros", JOptionPane.PLAIN_MESSAGE);
break;
default:
seguir=false;
break;
}
}
}
}
Prueba de escritorio
Esto ejecuta hasta que te introduzcas un número cero

Programa con Eventos
public class cal extends javax.swing.JFrame {
private static final long serialVersionUID = 1L;

int a,b,c,m;
public cal() {
initComponents();
}
Code">

dato1 = new javax.swing.JTextField();
dato2 = new javax.swing.JTextField();
resultado = new javax.swing.JLabel();
suma = new javax.swing.JButton();
resta = new javax.swing.JButton();
multiplicacion = new javax.swing.JButton();
division = new javax.swing.JButton();
borrar = new javax.swing.JButton();
memoria = new javax.swing.JButton();
SE);
jLabel1.setFont(new java.awt.Font("Tahoma", 0, 24)); //

NOI18N
jLabel1.setForeground(new java.awt.Color(51, 51, 255));
jLabel1.setText("calculadora");
resultado.setFont(new java.awt.Font("Tahoma", 0, 48));

// NOI18N
resultado.setForeground(new java.awt.Color(0, 0, 255));
suma.setText("+");
suma.addActionListener(new
public void
sumaActionPerformed(evt);
}
});
resta.setText("-");
resta.addActionListener(new
public void
restaActionPerformed(evt);
}
});
multiplicacion.setText("*");
multiplicacion.addActionListener(new
public void
multiplicacionActionPerformed(evt);
}
});
division.setText("/");
division.addActionListener(new
public void
divisionActionPerformed(evt);
}
});
jLabel3.setFont(new java.awt.Font("Tahoma", 0, 24)); //

NOI18N
jLabel3.setForeground(new java.awt.Color(51, 0, 255));
jLabel3.setText("resultado");
borrar.setText("c");
borrar.addActionListener(new
public void
borrarActionPerformed(evt);
}
});
memoria.setText("m");
memoria.addActionListener(new
public void
memoriaActionPerformed(evt);
}
});

DING)
.addGap(29, 29, 29)
.addContainerGap(105, Short.MAX_VALUE))
.addContainerGap()
gnment.LEADING)
.addGap(10, 10, 10)
gnment.TRAILING)
.addComponent(resultado,
javax.swing.GroupLayout.Alignment.LEADING,
javax.swing.GroupLayout.DEFAULT_SIZE, 182, Short.MAX_VALUE)
.addComponent(dato1,
javax.swing.GroupLayout.DEFAULT_SIZE, 182, Short.MAX_VALUE))
.addGap(8, 8, 8)
gnment.LEADING)
.addComponent(memoria,
javax.swing.GroupLayout.Alignment.TRAILING,
.addComponent(borrar, 0, 0,
Short.MAX_VALUE)))
.addComponent(suma,
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRE
LATED)
.addComponent(resta,
LATED)
.addComponent(multiplicacion,
LATED)
.addComponent(division,
javax.swing.GroupLayout.PREFERRED_SIZE)))
.addContainerGap())
);
DING)
.addGap(23, 23, 23)
LATED)
gnment.LEADING)
LATED)
gnment.BASELINE)
.addComponent(memoria))
TED)
.addGap(9, 9, 9)
.addComponent(resultado,
.addComponent(borrar))
.addGap(33, 33, 33)
gnment.BASELINE)
.addComponent(suma)
.addComponent(resta)
.addComponent(multiplicacion)
.addComponent(division))
.addContainerGap(27, Short.MAX_VALUE))
);
pack();
}// </editor-fold>
private void sumaActionPerformed(java.awt.event.ActionEvent

evt)
{
a = Integer.parseInt(dato1.getText());
b = Integer.parseInt(dato2.getText());
c = a+b;
resultado.setText(Integer.toString(c));
m = a+b;
resultado.setText(Integer.toString(m));
}
private void restaActionPerformed(java.awt.event.ActionEvent

evt)
{
c= a-b;
m = a-b;
}
private void
multiplicacionActionPerformed(java.awt.event.ActionEvent evt)
{
c = a*b;
m = a*b;
}
private void
divisionActionPerformed(java.awt.event.ActionEvent evt)
{
c = a/b;
m = a/b;
}
private void
borrarActionPerformed(java.awt.event.ActionEvent evt)
{
dato1.setText(null);
dato2.setText(null);
resultado.setText(null);
}
private void
memoriaActionPerformed(java.awt.event.ActionEvent evt)
{
resultado.setText(Integer.toString(a));
resultado.setText(Integer.toString(b));
resultado.setText(Integer.toString(a+b));
resultado.setText(Integer.toString(a-b));
resultado.setText(Integer.toString(a*b));
resultado.setText(Integer.toString(a/b));
dato1.setText(Integer.toString(a));
dato2.setText(Integer.toString(b));
}
/**
*/
java.awt.EventQueue.invokeLater(() -> {
new cal().setVisible(true);
});
}
// Variable de declaracion no modificable

private javax.swing.JButton borrar;
private javax.swing.JTextField dato1;
private javax.swing.JTextField dato2;
private javax.swing.JButton division;
private javax.swing.JButton memoria;
private javax.swing.JButton multiplicacion;
private javax.swing.JButton resta;
private javax.swing.JLabel resultado;
private javax.swing.JButton suma;
// Terminal de declaracio de Variable
}
Prueba de escritorio
GRAFICADORA DE FIGURAS.
import java.awt.Color;
import java.awt.Graphics;
/*
Project Properties.
*/
/**
*
* @author FIE
*/
public class figuras extends javax.swing.JFrame {
/**
* Creates new form figuras
*/
public figuras() {
initComponents();
this.getContentPane().setBackground(Color.white);
//FONDO DE COLOR BLANCO
this.setLocationRelativeTo(null); //CENTRADO EL
FRAME EN LA PANTALLA
/**
* WARNING: Do NOT modify this code. The content of
this method is always
*/
//METODO PAINT
public void paint(Graphics g) //AÑADIR LA LIBRERIA
DE GRAFICOS
{
super.paint(g); //LLAMA A LA FUNCION GRAFICA
QUE QUIEROP LA VARIABLE g
g.drawLine(50, 150, 390, 150); //HOROZONTAL
DEL (50,150) HASTA EL (390,150)
g.drawLine(150, 50, 150, 350); //EJE VERTICAL
DEL (150, 50) AL (150, 350)
}
//METODO GRAFICAR
public void graficar()
{
int dn,y1=160,x2=160;
String figura;
if(this.jtxtdiametro.getText().equals(""))
//PARA VER SI ESTA VACIO
{
JOptionPane.showMessageDialog(null,"Ingrese
diametro");
this.jtxtdiametro.requestFocus();
//VUELVE AL CUADRO DE DIAMETRO PARA LE VALOR QUE QUIERES
}
else
{
dn=Integer.parseInt(this.jtxtdiametro.getText()); //TOMA
EL VALOR DEL CUADRO Y LO PASA A ENTERO
figura=this.jComboBox1.getSelectedItem().toString();
//PARA SABER QUE FIGUA GRAFICAR
Graphics g=getGraphics(); //IMPORTA
LA CLASE GRAFICA, INSTANCIANDO DE LA CLASE GRAPHICS UN
OBJETO(ESTE ES G)
for(int i=150;i<350;i+=10) //GRAFICA
DE 8 EN OCHO
{
g.drawLine(148,i,152,i); //grafica
puntos en los ejes
g.drawLine(i,148,i,152);
}
switch(figura)
{
case "circulo":
g.setColor(Color.red);
g.drawOval(150, 150, dn, dn);
break;
case "cuadrado":
g.setColor(Color.green);
g.drawRect(150, 200, dn, dn);
break;
case "rectangulo":
g.setColor(Color.cyan);
g.drawRect(200, 150, (dn), (dn+100));
break;
case "triangulo":
g.setColor(Color.blue);
y1=y1+dn;
x2=x2+dn;
g.drawLine(150, y1, x2, 150);
break;
}
}
// <editor-fold defaultstate="collapsed"
desc="Generated Code">
jfigura = new javax.swing.JLabel();

jButtonlimpiar = new javax.swing.JButton();
jButtonvista = new javax.swing.JButton();
jComboBox1 = new javax.swing.JComboBox<>();
jtxtdiametro = new javax.swing.JTextField();
jfigura1 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_O
N_CLOSE);
jfigura.setText("FIGURA");
jButtonlimpiar.setText("LIMPIAR");
jButtonlimpiar.addActionListener(new
public void
jButtonlimpiarActionPerformed(evt);
}
});
jButtonvista.setText("VISTA PREVIA");
jButtonvista.addActionListener(new
public void
jButtonvistaActionPerformed(evt);
}
});
jComboBox1.setModel(new
javax.swing.DefaultComboBoxModel<>(new String[] {
"cuadrado", "rectangulo", "circulo", "triangulo" }));
jComboBox1.addActionListener(new
public void
jComboBox1ActionPerformed(evt);
}
});
jtxtdiametro.addActionListener(new
public void
jtxtdiametroActionPerformed(evt);
}
});
jfigura1.setText("Diametro");

layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGap(76, 328, Short.MAX_VALUE)
.addGroup(layout.createParallelGroup(javax.swing.GroupLayou
t.Alignment.LEADING)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()
.addComponent(jButtonlimpiar)
.addGap(29, 29, 29))
.addComponent(jButtonvista)
.addGap(16, 16, 16))
t.Alignment.TRAILING)
.addComponent(jfigura)
.addComponent(jfigura1))
.addGap(18, 18, 18)
t.Alignment.LEADING)
.addComponent(jtxtdiametro,
.addComponent(jComboBox1,
.addGap(10, 10, 10))))
);
layout.createParallelGroup(javax.swing.GroupLayout.Alignmen
t.LEADING)
.addGap(32, 32, 32)
t.Alignment.BASELINE)
.addComponent(jfigura)
.addComponent(jComboBox1,
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement
.RELATED)
t.Alignment.BASELINE)
.addComponent(jtxtdiametro,
.addComponent(jfigura1))
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement
.RELATED, 120, Short.MAX_VALUE)
.addComponent(jButtonvista)
.addGap(18, 18, 18)
.addComponent(jButtonlimpiar)
.addGap(38, 38, 38))
);
pack();
}// </editor-fold>
private void
jComboBox1ActionPerformed(java.awt.event.ActionEvent evt) {
}
private void
jtxtdiametroActionPerformed(java.awt.event.ActionEvent evt)
{
}
private void
jButtonvistaActionPerformed(java.awt.event.ActionEvent evt)
{
graficar(); //LLAMA AL METODO GRAFICAR
}
private void
jButtonlimpiarActionPerformed(java.awt.event.ActionEvent
evt) {
this.jtxtdiametro.setText("");
Graphics g=getGraphics();
super.paint(g);
g.drawLine(50, 150, 390, 150);
g.drawLine(150, 50, 150, 350);
}
/**
*/
//<editor-fold defaultstate="collapsed" desc=" Look
and feel setting code (optional) ">
/* If Nimbus (introduced in Java SE 6) is not
available, stay with the default look and feel.
* For details see
http://download.oracle.com/javase/tutorial/uiswing/lookandf
eel/plaf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info
: javax.swing.UIManager.getInstalledLookAndFeels()) {
break;
}
}
java.util.logging.Logger.getLogger(figuras.class.getName())
.log(java.util.logging.Level.SEVERE, null, ex);
} catch
(javax.swing.UnsupportedLookAndFeelException ex) {
}
//</editor-fold>

public void run() {
new figuras().setVisible(true);
}
});
}

private javax.swing.JButton jButtonlimpiar;
private javax.swing.JButton jButtonvista;
private javax.swing.JComboBox<String> jComboBox1;
private javax.swing.JLabel jfigura;
private javax.swing.JLabel jfigura1;
private javax.swing.JTextField jtxtdiametro;
}
Prueba
LENGUAJE DE MARCAS Y FUNDAMENTOS DE DESARROLLO WEB
Definición. El módulo de Lenguajes de Marca y Sistemas de Gestión de Información se encuentra dentro de

los tres ciclos formativos del catálogo público de Formación Profesional.
 Ciclo Formativo de Grado Superior de Administración de Sistemas Informáticos en Red (Real

Decreto / Regulación andaluza).
 Ciclo Formativo de Grado Superior de Desarrollo de Aplicaciones Multiplataforma (Real

 Ciclo Formativo de Grado Superior de Desarrollo de Aplicaciones Web (Real

HTML
Definición. HTML es el lenguaje con el que se escribe el contenido de las páginas web. Las páginas web
pueden ser vistas por el usuario mediante un tipo de aplicación llamada cliente web o más comúnmente
"navegador".
Sintacis de html
<html> indistintamente si es mayuscula o minuscula y cierra con </html>
<head> cierra </html>
cuerpo <body> cierra </body>
parrrafo <p> cierra parrafo </P>
Que es AwardSpace
AwardSpace.com, es un sitio web que provee alojamiento gratis, así como también de pago, hasta lo más
avanzados que van desde hosting reseller o la compra de un pack Hosting VPS. Con el Easy Starter hosting plan,
podrás adquirir alojamiento totalmente gratuito, es decir que no te cobraran nada por alojar tu página web o
blog, y con especificaciones técnicas que son un poco difícil encontrar hoy en día en algún servidor de
alojamiento gratis.
Que es un dominio
Un dominio de Internet es un nombre único que identifica a un sitio web en Internet.
El propósito principal de los nombres de dominio en Internet y del sistema de nombres de dominio (DNS), es
traducir las direcciones IP de cada nodo activo en la red, a términos memorizables y fáciles de encontrar. Esta
abstracción hace posible que cualquier servicio (de red) pueda moverse de un lugar geográfico a otro en la
Internet, aun cuando el cambio implique que tendrá una dirección IP diferente.1
Sin la ayuda del sistema de nombres de dominio, los usuarios de Internet tendrían que acceder a cada servicio
web utilizando la dirección IP del nodo (por ejemplo, sería necesario utilizar http://192.0.32.10 en vez de
http://example.com). Además, reduciría el número de webs posibles, ya que actualmente es habitual que una
misma dirección IP sea compartida por varios dominios. y no puede ser repetida por otras computadoras que
es el IP.
1.- nos vamos a esta dirección www.awardspace.com
2.- ya en página escogemos la que es gratuita

3.- llenamos los datos
4.-una vez en el sitio damos en instala la cuan no llevara a esta ventana
Llenamos datos pulsando siguiente

Una ves llenado no da el formulario con la información
Modificamos la pagina
Por ultimo obtenemos la id para pode ingresar nuevamente
HTML y CSS
Originalmente, las páginas HTML sólo incluían información sobre sus contenidos de texto e imágenes. Con el
desarrollo del estándar HTML, empezaron a incluir también información sobre el aspecto de sus contenidos:
tipos de letra, colores y márgenes.
La posterior aparición de tecnologías como JavaScript, provocaron que las páginas HTML también incluyeran el
código de las aplicaciones (scripts) que se utilizan para crear páginas web dinámicas.
Incluir en una misma página HTML los contenidos, el diseño y la programación complica en exceso su
mantenimiento. Normalmente, los contenidos y el diseño de la página web son responsabilidad de diferentes
personas, por lo que es adecuado separarlos. CSS es el mecanismo que permite separar los contenidos
definidos mediante XHTML y el aspecto que deben presentar esos contenidos:
Otra ventaja de la separación de los contenidos y su presentación es que los documentos XHTML creados son
más flexibles, ya que se adaptan mejor a las diferentes plataformas: pantallas de ordenador, pantallas de
dispositivos móviles, impresoras y dispositivos utilizados por personas discapacitadas.
De esta forma, utilizando exclusivamente XHTML se crean páginas web "feas" pero correctas. Aplicando CSS, se
pueden crear páginas "bonitas" a partir de las páginas XHTML correctas.
XML
 XML es un subconjunto de SGML(Estándar Generalised Mark-up Language),simplificado y

adaptado a Internet
 XML no es ,como su nombre puede sugerir, un lenguaje de marcado.

 XML es un meta-lenguaje que nos permite definir lenguajes de marcado adecuados a usos
determinados.
Que no es XML
 No es una versión mejorada de HTML
 HTML es una aplicación de SGML por lo tanto de XML
 No es un lenguaje para hacer paginas WEB
 Y sobre todo no es difícil.
Definición Especificación para diseñar lenguajes de marcado, que permite definir etiquetas personalizadas
para descripción y organización de datos.
EJERCICIOS RESUELTOS EN NETBEANS DE PAGINAS WEB.

/*
* To change this license header, choose
License Headers in Project Properties.
* To change this template file, choose
Tools | Templates
*/
package ejercicio;
/**
*
* @author FIE
*/
public class FormInicio extends
javax.swing.JFrame {
/**
* Creates new form FormInicio
*/
public FormInicio() {
initComponents();
//Sirve para centrar en la pantalla
un JFrame
this.setLocationRelativeTo(null);
}
/**
* This method is called from within the
constructor to initialize the form.
* WARNING: Do NOT modify this code. The
content of this method is always
*/
// <editor-fold defaultstate="collapsed"
desc="Generated Code">
jLabelUsuarioImagen = new
javax.swing.JLabel();
jButtonSalir = new
javax.swing.JButton();
jLabelPassword = new
jLabelUsuario = new
jTextFieldUsuario = new
javax.swing.JTextField();
jPasswordField1 = new
javax.swing.JPasswordField();
jButtonIngresar = new
javax.swing.JButton();
jLabelImagenFondo = new
setDefaultCloseOperation(javax.swing.WindowC
onstants.EXIT_ON_CLOSE);
setUndecorated(true);
getContentPane().setLayout(new
org.netbeans.lib.awtextra.AbsoluteLayout());
jLabelUsuarioImagen.setIcon(new
javax.swing.ImageIcon(getClass().getResource
("/ejercicio/Imagenes/Usuario.jpg"))); //
NOI18N
getContentPane().add(jLabelUsuarioImagen,
new
org.netbeans.lib.awtextra.AbsoluteConstraint
s(0, 0, 110, 110));
jButtonSalir.setBackground(new
java.awt.Color(102, 204, 0));
jButtonSalir.setFont(new
java.awt.Font("Yu Gothic", 1, 11)); //
NOI18N
jButtonSalir.setText("Salir");
jButtonSalir.addActionListener(new
public void
actionPerformed(java.awt.event.ActionEvent
evt) {
jButtonSalirActionPerformed(evt);
}
});
getContentPane().add(jButtonSalir,
new
s(420, 250, -1, -1));
jLabelPassword.setFont(new
java.awt.Font("Yu Gothic", 1, 18)); //
NOI18N
jLabelPassword.setForeground(new
java.awt.Color(255, 255, 255));
jLabelPassword.setText("Password:");
getContentPane().add(jLabelPassword,
new
s(70, 190, -1, -1));
jLabelUsuario.setFont(new
java.awt.Font("Yu Gothic UI Semilight", 1,
18)); // NOI18N
jLabelUsuario.setForeground(new
java.awt.Color(255, 255, 255));
jLabelUsuario.setText("Usuario:");
getContentPane().add(jLabelUsuario,
new
s(70, 140, -1, 30));
getContentPane().add(jTextFieldUsuario, new
s(180, 140, 150, 30));
getContentPane().add(jPasswordField1, new
s(180, 190, 90, 30));
jButtonIngresar.setForeground(new
java.awt.Color(0, 0, 204));
jButtonIngresar.setText(">>");
jButtonIngresar.addActionListener(new
public void
actionPerformed(java.awt.event.ActionEvent
evt) {
jButtonIngresarActionPerformed(evt);
}
});
getContentPane().add(jButtonIngresar, new
s(190, 250, -1, -1));
jLabelImagenFondo.setIcon(new
javax.swing.ImageIcon(getClass().getResource
("/ejercicio/Imagenes/Fondo.jpg"))); //
NOI18N
jLabelImagenFondo.setMaximumSize(new
java.awt.Dimension(300, 168));
getContentPane().add(jLabelImagenFondo, new
s(0, 0, 500, 290));
pack();
}// </editor-fold>
private void
jButtonSalirActionPerformed(java.awt.event.A
ctionEvent evt) {
System.exit(0);
}
private void
jButtonIngresarActionPerformed(java.awt.even
t.ActionEvent evt) {
String user1,pass1;
user1="Sebastian";
pass1="1234";
String user2,pass2;
user2=this.jTextFieldUsuario.getText();
pass2=this.jPasswordField1.getText();
if (user1.equals(user2)){
if (pass1.equals(pass2)){
System.out.println("Password
Correcto");
Ventana1 p=new Ventana1();
p.show();
this.setVisible(false);
}
else{
System.out.println("Password
Incorrecto");
}
}
else{
System.out.println("Usuario
Incorrecto");
}
/**
* @param args the command line
arguments
*/
//<editor-fold
defaultstate="collapsed" desc=" Look and
/* If Nimbus (introduced in Java SE
6) is not available, stay with the default
look and feel.
* For details see
http://download.oracle.com/javase/tutorial/u
iswing/lookandfeel/plaf.html
*/
try {
for
(javax.swing.UIManager.LookAndFeelInfo info
:
javax.swing.UIManager.getInstalledLookAndFee
ls()) {
if
("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.ge
tClassName());
break;
}
}
} catch (ClassNotFoundException ex)
{
java.util.logging.Logger.getLogger(FormInici
o.class.getName()).log(java.util.logging.Lev
el.SEVERE, null, ex);
} catch (InstantiationException ex)
{
} catch (IllegalAccessException ex)
{
} catch
(javax.swing.UnsupportedLookAndFeelException
ex) {
}
//</editor-fold>

java.awt.EventQueue.invokeLater(new
Runnable() {
public void run() {
new
FormInicio().setVisible(true);
}
});
}

private javax.swing.JButton
jButtonIngresar;
private javax.swing.JButton
jButtonSalir;
private javax.swing.JLabel
jLabelImagenFondo;
jLabelPassword;
jLabelUsuario;
jLabelUsuarioImagen;
private javax.swing.JPasswordField
jPasswordField1;
private javax.swing.JTextField
jTextFieldUsuario;
}
jose
Inventarios
/*
Project Properties.
*/
import java.sql.DriverManager;
import java.sql.*;
/**
*
* @author FIE
*/
public class Form1 extends javax.swing.JFrame {
/**
* Creates new form Form1
*/
public Form1() {
initComponents();
limpiar();
bloquear();
}
void limpiar(){
txtCodigo.setText("");
txtNombre.setText("");
txtDir.setText("");
}
void bloquear(){
txtCodigo.setEnabled(false);
txtNombre.setEnabled(false);
txtDir.setEnabled(false);
btnNuevo.setEnabled(true);
btnGuardar.setEnabled(false);
btnCancelar.setEnabled(false);
}
void desbloquear(){
txtCodigo.setEnabled(true);
txtNombre.setEnabled(true);
txtDir.setEnabled(true);
btnNuevo.setEnabled(false);
btnGuardar.setEnabled(true);
btnCancelar.setEnabled(true);
}
/**
* WARNING: Do NOT modify this code. The content of this
method is always
*/
Code">

btnNuevo = new javax.swing.JButton();
btnGuardar = new javax.swing.JButton();
txtCodigo = new javax.swing.JTextField();
txtNombre = new javax.swing.JTextField();
txtDir = new javax.swing.JTextField();
btnCancelar = new javax.swing.JButton();
btnSalir = new javax.swing.JButton();
SE);
jLabel1.setText("CODIGO");
jLabel1.setName("txtCodigo"); // NOI18N
jLabel2.setText("NOMBRE");
jLabel2.setName("txtNombre"); // NOI18N
jLabel3.setText("DIRECCION");
jLabel3.setName("txtDireccion"); // NOI18N
btnNuevo.setText("NUEVO");
btnNuevo.setName("btnNuevo"); // NOI18N
btnNuevo.addActionListener(new
public void
btnNuevoActionPerformed(evt);
}
});
btnGuardar.setText("GUARDAR");
btnGuardar.setName("btnGuardar"); // NOI18N
btnGuardar.addActionListener(new
public void
btnGuardarActionPerformed(evt);
}
});
btnCancelar.setText("CANCELAR");
btnCancelar.setName("btnCancelar"); // NOI18N
btnCancelar.addActionListener(new
public void
btnCancelarActionPerformed(evt);
}
});
btnSalir.setText("SALIR");
btnSalir.addActionListener(new
public void
btnSalirActionPerformed(evt);
}
});

DING)
.addGap(37, 37, 37)
gnment.LEADING)
gnment.TRAILING)
TED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
gnment.LEADING, false)
javax.swing.GroupLayout.Alignment.TRAILING)
javax.swing.GroupLayout.Alignment.TRAILING))
.addGap(45, 45, 45))
.addContainerGap()
.addGap(18, 18, 18)
.addGap(18, 18, 18)
.addGap(18, 18, 18)
.addComponent(btnSalir)
.addGap(0, 0, Short.MAX_VALUE))
);
DING)
.addGap(12, 12, 12)
gnment.BASELINE)
.addGap(11, 11, 11)
gnment.BASELINE)
TED)
gnment.BASELINE)
TED, 138, Short.MAX_VALUE)
gnment.BASELINE)
.addComponent(btnSalir))
.addGap(44, 44, 44))
);
pack();
}// </editor-fold>
private void
btnNuevoActionPerformed(java.awt.event.ActionEvent evt) {
limpiar();
desbloquear();
}
private void
btnSalirActionPerformed(java.awt.event.ActionEvent evt) {
this.dispose();
}
private void
btnGuardarActionPerformed(java.awt.event.ActionEvent evt) {
bloquear();
try{
Class.forName("com.mysql.jdbc.Driver");
Connection
con=DriverManager.getConnection("jdbc:mysql://127.0.0.1/Prueba",
"root","");
String Cod,Nom,Dir;
Cod=txtCodigo.getText();
Nom=txtNombre.getText();
Dir=txtDir.getText();
String Sql1="";
Sql1="INSERT INTO
Empleados(Codigo,Nombre,Dir)VALUES(?,?,?)";
PreparedStatement psd=con.prepareStatement(Sql1);
psd.setString(1,Cod);
psd.setString(2,Nom);
psd.setString(3,Dir);
int n=psd.executeUpdate();
if(n>0){
JOptionPane.showMessageDialog(null,"Registro
Almacenado con exito");
}
}
catch(SQLException ex){
System.out.println("Error de MYSQL");
}
catch(Exception e){
System.out.println("Error
Inesperado"+e.getMessage());
}
}
private void
btnCancelarActionPerformed(java.awt.event.ActionEvent evt) {
limpiar();
bloquear();
}
/**
*/
//<editor-fold defaultstate="collapsed" desc=" Look and
/* If Nimbus (introduced in Java SE 6) is not available,
stay with the default look and feel.
* For details see
http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/p
laf.html
*/
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
break;
}
}
} catch (javax.swing.UnsupportedLookAndFeelException ex)
{
}
//</editor-fold>

public void run() {
new Form1().setVisible(true);
}
});
}

private javax.swing.JButton btnCancelar;
private javax.swing.JButton btnGuardar;
private javax.swing.JButton btnNuevo;
private javax.swing.JButton btnSalir;
private javax.swing.JTextField txtCodigo;
private javax.swing.JTextField txtDir;
private javax.swing.JTextField txtNombre;
}

Final Progra

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Final Progra

Cargado por

Copyright:

Formatos disponibles

Escuela superior politécnica de Chimborazo

Facultad de informática y electrónica

Escuela de ingeniería en electrónica y control de redes industriales

APUNTES DE LENGUAJE DE PROGRACION II

METODOLOGIA PARA EL DESARROLLO DE SW

Definición. La metodología para el desarrollo de software es un modo sistemático de realizar, gestionar y

CLASIFICACIÓN DE LAS METODOLOGÍAS

Metodología orientada a objetos

¿por qué es necesario un método para desarrollar software?

Por lo complejo que resulta desarrollar software

Casos de Uso, Plantillas de Documentos, UML:

Un modelo de proceso de software es una representación abstracta de un proceso

Características de modelo de proceso.

La definición y especificación de requerimientos y el desarrollo de software es un

MODELOS BASADOS EN PROTOTIPOS (NO DESECHABLE)

 La POO es una técnica para desarrollar soluciones computacionales utilizando componentes de

 La clase es la unidad de modularidad en el EOO. La tendencia natural del individuo es la de clasificar

La declaración de una variable de una clase NO crea el objeto.

MÉTODO DE DESTRUCTORES DE OBJETOS:

Relación de Agregación (Todo / Parte, Forma parte de)

Ejemplo: Objeto Casa descrito en términos de sus componentes

Relación de Asociación («uso», usa, cualquier otra relación)

Representación en el Diagrama de Clases

 El polimorfismo operacional o Sobrecarga operacional permite aplicar operaciones con igual

DIAGRAMAS DE CLASES, OBJETOS, SU PRESENTACIÓN EN UML

Programa para constructores.

ENTORNOS DE DESARROLLO INTEGRADO (IDE) Y LENGUAJES DE PROGRAMACIÓN ORIENTADA A OBJETOS

OPERADORES Y DELIMITADORES BÁSICOS

BUCLES Y TOMAS DE DECISIÓN

SALIDA POR PANTALLA Y ENTRADA POR TECLADO

ARREGLOS (ARRAYS) O VECTORES.

LA CLASE MATH DE PROCEDIMIENTOS Y CONSTANTES MATEMÁTICAS

Ejercicio 2: Resta entre dos números

Ejercicio 3: Multiplicación entre dos números

Ejercicio 4: División entre dos números

EJERCICIOS CON BUCLES DE REPETICIÓN.

public class Menus {

UNA BASE ELEVADO A UN EXPONENTE A TRAVES DE SUMAS SUCESIVAS

Realizar un programa que permita ingresar una nota, si la nota

Realizar un programa que permita saber si una persona es

REALIZAR UN PROGRAMA QUE OBTENGA LOS N NÚMEROS PARES

public class Par {

REALIZAR UN PROGRAMA QUE OBTENGA LOS N PRIMEROS NUMEROS PRIMOS

UNA BASE ELEVADO A UN EXPONENTE A TRAVES DE SUMAS SUCESIVAS

public class Factorial {

EJERCICIO DE MATRISES Y VECTORES

public class mayoramenor {

public static void main(String[]args)throws IOException{

System.out.println("Cuantos numeros va a ingresar

System.out.print(datos[k] + " ");

Realizar un programa que permita sumar dos vectores de N

Ingresar en un vector los N primeros números pares y en otro los

Realizar un programa de multiplicación por sumas sucesivas.

Realice un programa que resuelva exponente por sumas sucesivas

MENU CON 4 OPCIONES.

public void iPares(int nu, int pi, int i) {

EJERCICIOS ECHOS CON BUTON

jLabel1 = new javax.swing.JLabel();

javax.swing.GroupLayout layout = new

/* Create and display the form */

// Variables declaration - do not modify

Prueba en java de linias de código.

System.out.println("El radio es:"+op.tamaño);