programacion

Programación I
Como crear una clase en NetBeans
En la interfaz de NetBeans nos dirigimos a New File
También podemos acceder mediante el comando Ctrl+N
En este icono encontramos todas las
herramientas necesarias para
crear cualquier tipo de proyecto

Programación I
Saldrá esta venta y seleccionamos la categoría Java
Esta categoría contiene las
diferentes herramientas
para construir un proyecto
java

Programación I
Seleccionamos el tipo de archivo, en este caso Java Class, click en Next
Este tipo de archivo
es el necesario para
crear una clase
Click en Next

Programación I
Vamos a hacer una clase donde estarán los método para calcular el factorial
de un numero
Seleccionamos el nombre de la clase

Programación I
Nombre del proyecto
Nombre del proyecto

Programación I
Nombre del paquete que contendrá la clase; es importante verificar antes de seguir
Nombre del paquete

Programación I
Verificamos la ruta
Por defecto NetBeans las
crea en esta dirección donde
se almacenara la clase
C:UsersusuarioDocumentsNetBeansProjectsJavaFactorialsrcnewpackage
CCalcularFactorial.java
Finalizar

Programación I
Como crear una clase en JCreator
En la interfaz de JCreator nos dirigimos a File
Esta pestaña contiene varias opciones como abrir, crear, guardar proyectos,
clases, espacios de trabajo.

Programación I
Seleccionamos File para entrar al
proceso de creación de una clase
La opción New tiene la opción de crear
un proyecto, archivo o espacio de trabajo

Programación I
Seleccionamos la categoría
Java Classes, que contiene
varios tipos de clases java
Seleccionamos Java Class,
que es la que nos interesa
Next para continuar

Esta clase contendrá los métodos para leer un numero entero
Programación I
Seleccionamos un nombre
para la clase

Programación I
En esta casilla se muestra la ruta
que manualmente debe ser
especificada
Finish para terminar
Damos click en este icono
y seleccionamos la ruta
C:UsersUserDocumentsCarpetaCLeerEnt

Programación I
Como crear un proyecto en NetBeans
Vamos a crear un programa en Netbeans que permita calcular
1. Área del Triangulo
2. Calcular la ecuación cuadrática
3. Factorial de un numero
4. Operaciones (ingresar tres numero, multiplicarlos y sumarlos, mostrar
el resultado de la multiplicación menos la suma)

Programación I
Nos dirigimos a File
Esta pestaña contiene las principales opciones
Como: abrir, guardar o crear proyectos, importar,
exportar

Programación I
Seleccionamos New Project
También podemos acceder con
El comando Ctrl+Mayús+N

Programación I
Seleccionamos este tipo
de categoría ya que contiene
las herramientas para crear
un proyecto

Programación I
Seleccionamos, en este caso,
Java Application que la necesaria
para crear un proyecto
Click en Next

Programación I
para el proyecto

Programación I
Ruta de del proyecto
NetBeans la crea por defecto
en C:UsersUserDocumentsNetBeansProjectsJavaMenu
También podemos especificar
la ruta dando click en Browser

Programación I
Desactivamos la
opción Crear Clase Principal,
mas adelante la crearemos
Click en Finish

Después de crear el proyecto, procedemos a crear el paquete, que contendrá las clases
Programación I
En la parte izquierda aparece
el proyecto que hemos creado
Abrimos las opciones que tiene el proyecto
Dando click en el símbolo +

Programación I
Después abrimos al
opción Source Packages
A la carpeta Source Packages le
corresponde esta dirección
C:UsersUserDocumentsNetBeansProjectsJavaMenusrc

Programación I
En <default package> damos
Click derecho

Programación I
Nos situamos en New
Donde encontramos varias
herramientas como crear diferentes
tipos de clases, interfaces, paquetes

Programación I
Click en Java Package…

Programación I
para el paquete
Aquí esta el nombre del proyecto
Donde el paquete será creado
Verificamos que este correcto
Click en Finish

C:UsersUserDocumentsNetBeansProjectsJavaMenusrcProyecto1
Programación I
Esta es la ruta donde será creado el paquete
Click en Finish

Programación I
Después de crear el nuevo paquete, creamos la clase que contendrá
los métodos para leer cualquier tipo de dato
Nos situamos en el paquete
Y damos click derecho

Programación I
Seleccionamos New
Después Java Class…

Programación I
Clase CLeerTodo
Damos nombre a la clase
En este caso CLeerTodo
Ruta donde será creada la clase
C:UsersUserDocumentsNetBeansProjectsJavaApplication2srcnewpackageCLeerTodo.java
Terminamos dando click en Finish

Programación I
Clase CLeerTodo
En la clase CLeerTodo creamos dos métodos que permitan leer datos de
tipo entero y real.
package proyecto1;
import java.io.*; // Entrada/Salida. Clases que definen distintos flujos de datos
public class CLeerTodo
{ //Inicio de la clase
//Aqui se crean los atributos o variables de la clase
//También métodos o funciones de la clase y en este caso necesitamos 2
// metodos que permitan leer datos de tipo entero y real
public float LeerFlotante(String Mensaje) throws IOException //Se crea el metodo LeerReal con parametros
{ //String Mensaje
float Real; //se crea una variable de tipo float
BufferedReader Leer = new BufferedReader(new InputStreamReader(System.in));
System.out.println(Mensaje); //muestra el dato que se ingreso en la variable Mensaje de tipo String
Real = Float.parseFloat(Leer.readLine()); //Lee el dato y lo asigna a la variable Real
return(Real); //Devuelve la variable Real
}

Programación I
Clase CLeerTodo
//Metodo que permite leer datos de tipo entero
public int LeerEntero(String Mensaje) throws IOException //Se crea el metodo LeerEntero con el parametro
{ //String Mensaje
int Entero; //se crea una variable de tipo entero
BufferedReader Leer = new BufferedReader(new InputStreamReader(System.in));
System.out.println(Mensaje); //muestra el dato que se ingreso en la variable Mensaje de tipo String
Entero = Integer.parse.int(Leer.readLine()); //Lee el dato y lo asigna a la variable Entero
return(Entero); //Devuelve la variable Entero
}//Fin del metodo LeerEntero
}//Fin de la clase CLeerTodo

En el mismo paquete se crea
la clase CAreaTriangulo
Programación I
Clase CAreaTriangulo
1. Área del Triangulo
En el mismo paquete creamos otra clase que contendrá los métodos para calcular el área
un triangulo la nombraremos como CAreaTriangulo.
en este caso CAreaTriangulo

Programación I
package proyecto1;
import java.io.*;
public class CAreaTriangulo //Se crea la clase
{ //inicio de la clase
float Base, Altura; //Se crean dos atributos de tipo real
CLeerTodo Todo; //Se crea un atributo de tipo CLeerTodo
public CAreaTriangulo() //Se crea el constructor, que tiene como objetivo inicializar los
{ Base=0; //atributos Nota:Debe llevar el mismo nombre de la clase
Altura=0;
Todo = new CLeerTodo();
}
public CLeerTodo getTodo() //Método get de tipo CLeerTodo que retorna un dato del
{ //mismo tipo de la clase CLeerTodo
return(Todo);
}

Programación I
public float getBase() //Método get que retorna el atributo Base de tipo float
{
return Base;
}
public void setBase(float Base) { //Método set con parámetro que se asigna al
this.Base = Base; //atributo Base
}
public float getAltura() { //Método get que retorna el atributo Altura de tipo float
return Altura;
}
public void setAltura(float Altura) { //Método set con parámetro que se asigna al
this.Altura = Altura; //atributo Altura
}
public float CalcularArea(){ //Método que calcula el área del triangulo y la
return(getBase()*getAltura()/2); //retorna de tipo float
}

Programación I
public void Triangulo ()throws IOException
{
//se muestra este mensaje indicando la clase en la que se encuentra
System.out.println("Calcular el Área de un Triangulo");
//Se crea el objeto así: Clase Nombre_del_objeto = new Constructor_de_la_clase
CAreaTriangulo AreaTriangulo = new CAreaTriangulo();
//Por medio del objeto se llaman los métodos de la clase
AreaTriangulo.setBase(AreaTriangulo.getTodo().LeerFlotante("Ingrese la base"));
AreaTriangulo.setAltura(AreaTriangulo.getTodo().LeerFlotante("Ingrese la altura"));
//Se llama el método CalcularArea y se muestra en pantalla en resultado
System.out.println("El area es: "+AreaTriangulo.CalcularArea());
}
}//Fin de la clase CAreaTriangulo

la clase CCuadratica
Programación I
Clase CCuadratica
2. Calcular ecuación cuadrática
−푏± 푏2−4푎푐
푥 =
2푎
Creamos una clase y la llamamos CCuadratica
en este caso CCuadratica

Programación I
Clase CCuadratica
package proyecto1;
import java.io.*;
public class CCuadratica //Clase
{
float a,b,c; //Se crean 3 tributos , que son los de la formula cuadrática
CLeerTodo Todo; //Se crea un atributo de tipo CLeerTodo para
//leer cualquier dato
public CCuadratica() //Se crea el constructor, que tiene como objetivo inicializar los
{ //atributos
a=0; Nota: El constructor debe llevar el mismo nombre de la clase
b=0;
c=0;
}
public CLeerTodo getTodo() //Método get que permite acceder a los métodos de la clase
{ //CLeerTodo
return(Todo);
}

Programación I
Clase CCuadratica
public float getA() //Método get que retorna el atributo a
{
return a;
}
public void setA(float a) //Método set que permite ingresar el atributo a
{
this.a = a;
}
public float getB() //Método get que retorna el atributo b
{
return b;
}
public void setB(float b) {{ //Método set que permite ingresar el atributo b
this.b = b;
}
public float getC() { //Método get que retorna el atributo c
return c;
}

Programación I
Clase CCuadratica
{
return a;
}
{
this.a = a;
}
public float getB() //Método get que retorna el atributo b
{
return b;
}
public void setB(float b) //Método set que permite ingresar el atributo b
{
this.b = b;
}
public float getC() //Método get que retorna el atributo c
{
return c;
}

Programación I
Clase CCuadratica
public void setC(float c) //Método set que permite ingresar el atributo c
{
this.c = c;
}
public double CalcularX1() //Método que calcula el valor de X1 y lo retorna
{
double R, P = getB(), P2 = (4*getA()*getC());
P=Math.pow(P,2);
R = P-P2;
return((-getB()+(Math.pow(R,0.5)))/2*getA());
}
public double CalcularX2() //Método que calcula el valor de X2 y lo retorna
{
double R, P = getB(), P2 = (4*getA()*getC());
P=Math.pow(P,2);
R = P-P2;
return((-getB()-(Math.pow(R,0.5)))/2*getA());
}

Programación I
Clase CCuadratica
public void Cuadratica()throws IOException //Método que calcula la cuadrática
{
System.out.print("Calcular Cuadratica");
CCuadratica Cuadratica = new CCuadratica(); //Se crea el objeto
Cuadratica.setA(Cuadratica.getTodo().LeerFlotante("Ingrese a: ")); //Se pide el valor de a
Cuadratica.setB(Cuadratica.getTodo().LeerFlotante("Ingrese b: ")); //Se pide el valor de b
Cuadratica.setC(Cuadratica.getTodo().LeerFlotante("Ingrese c: ")); //Se pide el valor de c
System.out.println("X1: "+Cuadratica.CalcularX1()); //Se calcula X1, invocando el método por
//medio del objeto y se muestra
} System.out.println("X2: "+Cuadratica.CalcularX2()); //Se calcula X2, invocando el método por
//medio del objeto y se muestra
}//fin de la clase

la clase CFactorial
Programación I
Clase CFactorial
3. Factorial de un numero
Creamos una clase y la llamamos CFactorial
en este caso CFactorial

Programación I
Clase CFactorial
package proyecto1;
import java.io.*;
public class CFactorial //Se crea la clase
{
int Num; //Se crea un atributo de tipo entero
CLeerTodo Todo; //Se crea un atributo de tipo CLeerEntero
public CFactorial() //Constructor
{
Num=0;
}
public CLeerTodo getTodo() //Método get que permite acceder a los métodos de la clase CLeerTodo
{
return(Todo);
}
public int getNum() //Método get que retorna el atributo Num
{
return Num;
}
public void setNum(int Num) //Método set que permite ingresar el atributo Num
{
this.Num = Num;
}

Programación I
Clase CFactorial
public int CalcularFactorial(int F) //Método que permite calcular el factorial de un numero
{ //y después lo retorna
int Factorial=1;
for (int i=1; i<=F; i++){
Factorial*=i;
}
return(Factorial);
}
public void Factorial ()throws IOException
{
System.out.println("Calcular Factorial");
CFactorial Factorial = new CFactorial(); //Se crea el objeto
int f = Factorial.getTodo().LeerEntero("Ingrese numero"); //Se pide un numero
System.out.println(f+"!= "+Factorial.CalcularFactorial(f)); //Se invoca el método que calcula
//el factorial por medio del objeto y se
} //muestra
}//Fin de la clase

la clase COperaciones
Programación I
Clase COperaciones
4. Operaciones ( ingresar tres numero, multiplicarlos y sumarlos, mostrar
el resultado de la multiplicación menos la suma)
en este caso COperaciones

Programación I
Ejercicio aplicando clases y métodos
package proyecto1;
import java.io.*;
public class Coperaciones //Se crea la clase
{
float a,b,c; //Se crean tres atributos de tipo float
CLeerTodo Todo; //Se crea un atributo de tipo CLeerTodo
public COperaciones() //Constructor
{
a=0;
b=0;
c=0;
}
public CLeerTodo getTodo() //Método get que permite acceder a los método de CLeerTodo
{
return(Todo);
}
{
return a;
}
{
this.a = a;
}

Programación I
public float getB() //Método que retorna el atributo b
{
return b;
}
public void setB(float b) //Método que permite ingresar el atributo b
{
this.b = b;
}
public float getC() //Método que retorna el atributo c
{
return c;
}
public void setC(float c) //Método que permite ingresar el atributo c
{
this.c = c;
}

Programación I
public static void Operaciones ()throws IOException //Metodo que hace las operaciones
{
System.out.println("Operaciones con numeros");
float Suma, Multiplicacion; //variables para guardar la suma y la multiplicación
COperaciones Numero = new COperaciones(); //Se crea el objeto
//Se piden tres numeros
Numero.setA(Numero.getTodo().LeerFlotante("Ingrese primer numero"));
Numero.setB(Numero.getTodo().LeerFlotante("Ingrese segundo numero"));
Numero.setC(Numero.getTodo().LeerFlotante("Ingrese tercer numero"));
//Se guarda la suma y la multiplicación de todos los números en variables diferentes
Suma = (Numero.getA()+Numero.getB()+Numero.getC());
Multiplicacion = (Numero.getA()*Numero.getB()*Numero.getC());
//Muestra en pantalla el resultado de la resta de la multiplicación con la suma
System.out.println("Resultado: "+(Multiplicacion-Suma));
}
}//Fin de la clase

la clase COpciones
Programación I
Creamos una clase que contendrá el menú de opciones que aparecerá en pantalla
en este caso COpciones

Programación I
package proyecto1;
import java.io.*;
public class COpciones //Se crea la clase
{
public void PintarMenu(){ //Metodo que imprime el menu
System.out.println(" Menu ");
System.out.println("1. Area del Triangulo");
System.out.println("2. Cuadratica");
System.out.println("3. Factorial");
System.out.println("4. Operaciones");
System.out.println("5. Finalizar");
}
}

la clase CMenu
Programación I
Clase CMenu
Creamos una clase que contendrá la clase principal para poder que el programa funcione
en este caso CMenu

Programación I
Clase CMenu
package newpackage;
import java.io.*;
public class CMenu {
COpciones MiMenu; //Se crean los atributos de tipo de la clase a la cual
CAreaTriangulo MiTriangulo; //se quiere acceder para utilizar sus metodos
CCuadratica MiCuadratica;
CFactorial MiFactorial;
COperaciones MisNumeros;
public CMenu(){ //Costructor. Nota: Debe llevar el mismo nombre de la clase
MiMenu = new COpciones();
MiTriangulo = new CAreaTriangulo();
MiCuadratica = new CCuadratica();
MiFactorial = new CFactorial();
MisNumeros = new COperaiones();
}

Programación I
Clase CMenu
//Metodos que permiten acceder a las clases y a sus funciones
public COpciones getMiMenu()
{
return(MiMenu);
}
public CAreaTriangulo getMiTriangulo()
{
return(MiTriangulo);
}
public CCuadratica getMiCuadratica(){
return(MiCuadratica);
}
public CFactorial getMiFactorial(){
return(MiFactorial);
}
public COperaciones getMisNumeros(){
return(MisNumeros);
}

Programación I
Clase CMenu
public void EjecutarOpcion(int Op) throws IOException{ //Método que evalúa la
//opción
switch (Op){ //Función switch que permite elegir según la opción unas acciones
case 1:
this.getMiTriangulo().Triangulo()); //si Op=1, se calcula el área de un triangulo
break;
case 2:
this.getMiCuadratica().Cuadratica()); //si Op=2, se calcula la ec.cuadratica
break;
case 3:
this.getMiFactorial().Factorial()); //si Op=3, Se calcula el factorial de un numero
break;
case 4:
this.getMisNumeros().Operaciones()); //si Op=4, se realizan las operaciones
break; //indicadas en la clase
case 5:
System.out.println("Gracias por utilizar este programa");
break; //Si Op=5, se sale del programa
}
}

Programación I
Clase CMenu - Clase Principal
public static void main(String [] args) throws IOException
{
CMenu Menu = new CMenu(); //Se crea el objeto
int Opcion = 0; //Variable donde se guardara la opción
//ciclo do.while, que permite realizar una acción dependiendo de la opción
do{
Menu.getMiMenu().PintarMenu(); //Se invoca y se imprime el menú
Menu.getMiCuadratica().getTodo().LeerEntero("Ingrese opción"); //Se pide la opción
Menu.EjecutarOpcion(Opcion); //Se evalúa la opción y muestra el resultado
}
while(Opcion!=5); //Este ciclo se hará mientras que la opción sea diferente de 5
}//Fin de la clase principal
}//Fin de la clase

Programación I
Como crear un proyecto en JCreator
En la interfaz de JCreator nos dirigimos a File
Esta pestaña contiene varias opciones como abrir o guardar proyectos,
crear proyectos, clases, espacios de trabajo

Programación I
En la interfaz de NetBeans nos dirigimos a New File
Seleccionamos New y después Project
o también por comando Ctrl+Shift+N

Programación I
Seleccionamos Basic Java Application
Next para continuar

Programación I
para el proyecto
En estas tres casillas esta
La ruta del proyecto
Damos click en Finish

Programación I
Esperamos a que cree el proyecto
Damos click en Finish
para terminar

Programación I
Este es el proyecto finalizado en JCreator

programacion

Más contenido relacionado

Similar a programacion (20)

Último (20)

programacion