Unidad1
79
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA INSTITUTO TECNOLÓGICO DE SALINA CRUZ MATERIA FUNDAMENTOS DE PROGRAMACION UNIDAD: UNIDAD 1 FUNDAMENTOS DEL LENGUAJE PROFESORA SUSANA MONICA ROMAN NAJERA ALUMNO MARTINEZ MATEO ERIC RANDY CARRERA ING. EN TIC´S SEMESTRE 2 E2 SALINA CRUZ OAXACA
-
Upload
eric-m -
Category
Engineering
-
view
281 -
download
0
description
Transcript of Unidad1
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
MATERIA
FUNDAMENTOS DE PROGRAMACION
UNIDAD:
UNIDAD 1 FUNDAMENTOS DEL LENGUAJE
PROFESORA
SUSANA MONICA ROMAN NAJERA
ALUMNO
MARTINEZ MATEO ERIC RANDY
CARRERA
ING. EN TIC´S
SEMESTRE
2 E2
SALINA CRUZ OAXACA
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
PROGRAMACIÓN ORIENTADA A OBJETOS
ING. EN TIC`S
Nº de Unidad: 1
Nº de Práctica: Uno
Alumno: Eric Randy Martínez Mateo
Fecha: 25/Febrero/2014
Procedimientos:
Abrimos el programa eclipse, con el que vamos a programar nuestra practica 1,
ya que nos abrió el programa tenemos que crear un nuevo proyecto.
Nos aparecerá una venta, en categorías seleccionamos java y en proyecto seleccionamos java aplicación, y le damos next.
Después de darle next, nos aparecerá otra ventana y le damos un nombre a
nuestro proyecto, yo lo llame Uno, ya que lo nombren le dan finish.
Ya que creamos nuestro proyecto, escribiremos el código que me proporciono la M.C. Susana y lo escribimos.
Public class Uno{
Public static void main(String[]args){
System.out.println(“Hola Mundo”);
System.out.println(“Soy tu Nombre”);
}
}
Presionamos la tecla f6 de nuestro teclado y nos mostrara el resultado de
nuestro código que será hola mundo soy Randy
Conclusión:
La programación que realice fue para la materia de fundamentos de
programación los códigos no lo proporciono la M.C Susana Mónica con el fin de
que lo programáramos en el lenguaje de programación que eligiéramos, que en
este caso lo realice en NedBeans, realice esta programación sin buscar ayuda
en internet, con lo que he aprendido en programación pude realizar esta
práctica.
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
PROGRAMACIÓN ORIENTADA A OBJETOS
ING. EN TIC`S
Nº de Unidad: 2
Nº de Práctica: Dos
Alumno: Eric Randy Martínez Mateo
Fecha: 25/Febrero/2014
Procedimientos:
Abrimos el programa eclipse, con el que vamos a programar nuestra practica 2,
ya que nos abrió el programa tenemos que crear un nuevo proyecto.
Nos aparecerá una venta, en categorías seleccionamos java y en proyecto seleccionamos java aplicación, y le damos next.
Después de darle next, nos aparecerá otra ventana y le damos un nombre a
nuestro proyecto, yo lo llame Dos, ya que lo nombren le dan finish.
Ya que creamos nuestro proyecto, escribiremos el código que me proporciono la M.C. Susana y lo escribimos.
Public class Dos{
public static void main(String[] args) {
Scanner Teclado=new Scanner(System.in);
System.out.println("Programa recibe el primer nombre"+
"Por el usuario y ordena alfabeticamente");
System.out.println("Ingrese el primer nombre");
String Nombre1=Teclado.nextLine();
System.out.println("Introduce el apellido paterno");
String Apellidopa1=Teclado.nextLine();
System.out.println("Ingrese el segundo nombre");
String Nombre2=Teclado.nextLine();
System.out.println("Introduce el apellido paterno");
String Apellidopa2=Teclado.nextLine();
String Nombrecompleto1=Apellidopa1+Nombre1;
String Nombrecompleto2=Apellidopa2+Nombre2;
int Resultado=Nombrecompleto1.
compareTo(Nombrecompleto2);
if(resultado<0);
{
String ordenado1=Apellidopa1+""+Nombre1;
String ordenado2=Apellidopa2+""+Nombre2;
System.out.println(ordenado1);
System.out.println(ordenado2);
}
if(resultado>0){
String ordenado1=Apellidopa2+""+Nombre2;
String ordenado2=Apellidopa1+""+Nombre1;
System.out.println(ordenado2);
System.out.println(ordenado1);
}
}
Presionamos la tecla f6 de nuestro teclado para correr el proyecto, nos pedirá
que ingresemos un nombre yo escribí mi primer nombre Eric y le di enter me
pidió mi apellido paterno y escribí Martínez, me volvió a pedir que ingresara un
nombre y escribí mi segundo nombre Randy y le di enter me pidió mi apellido
paterno y le escribí mi otro apellido Mateo y presione la tecla enter y me ordeno
mi nombre Eric con mi primer apellido Martínez y abajo apareció mi segundo
nombre Randy con mi segundo apellido Mateo.
Conclusiones:
Este es la practica 2 de programación realizada en netbeans, para la materia
de fundamentos de programación los códigos no lo proporciono la M.C Susana
Mónica con el fin de que lo programáramos en el lenguaje de programación
que eligiéramos, realice esta programación sin buscar ayuda en internet, con lo
que he aprendido en programación pude realizar esta práctica.
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
MATERIA
FUNDAMENTOS DE PROGRAMACION
TEMA
MAPA CONCEPTUAL UNIDA1
PROFESORA
SUSANA MONICA ROMAN NAJERA
ALUMNO
MARTINEZ MATEO ERIC RANDY
CARRERA
ING. EN TIC´S
SEMESTRE
2 E2
SALINA CRUZ OAXACA
Unidad 1 fundamentos de lenguaje
Palabras
reservadas Comentarios Tipos de datos Variables Constantes Operadores Sentencias
Estructuras de
control
Enteros
Reales
Caracteres
bolean
Básicos:+,-,*,/
Lógicos:!,==,!=,
<,>,>=,<=,
Son
identificadores
predefinidos
que tienen un
significado
para el
compilador.
Es un valor
que no puede
ser alterado
durante la
ejecución de
un programa.
Son
instrucciones a
seguir.
Determinan
las secuencias
de ejecución
de las
sentencias de
un programa
//comentario
de línea
/*comentario
de bloque*/
Se le asocia
con una
proporción de
memoria, en el
que se guarda
un valor
asignado a
dicha variable.
Abstract
Assert
Boolean
Break
Byte
case
El valor de pi
es una
constante por
que no se
puede
cambiar.
Es un símbolo
especial que
indica al
compilador que
debe efectuar una
operación
matemática o
lógica.
Expresiones de asignación
Cualquier uso de code
Invocaciones de métodos
Condicional: if,
doble if,
multiple if,
repetitiva,
while, do
while, for
Sintaxis de
inicialización:
Inti;
I=0;
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
MATERIA
FUNDAMENTOS DE PROGRAMACION
TEMA
GUÍA DE ECLIPSE, BLUEJ Y NET BEANS
PROFESORA
SUSANA MONICA ROMAN NAJERA
ALUMNO
MARTINEZ MATEO ERIC RANDY
CARRERA
ING. EN TIC´S
SEMESTRE
2 E2
SALINA CRUZ OAXACA
ÍNDICE
INTRODUCCIÓN: ................................................................................................................ 22
Programando en eclipse ................................................................................................................ 23
............................................................................................................................................................ 23
Instalación de eclipse: .................................................................................................................... 24
Proyecto eclipse: ............................................................................................................................. 27
Pasos para programar en eclipse ................................................................................................. 27
Programando en BlueJ ...................................................................................................................... 32
Entorno de desarrollo bluej ................................................................................................................ 33
Instalación de bluej ............................................................................................................................. 33
NedBeans......................................................................................................................................... 39
Instalar NedBeans .......................................................................................................................... 40
Programando con NedBeans ........................................................................................................ 42
........................................................................................................................................................... 46
Conclusion: ................................................................................................................................ 49
Otras fuentes consultadas: ............................................................................................... 50
Introducción:
Esta es una guía para la instalación del software eclipse, bluej y nedbeans que
les servirá a los futuros ingenieros en TIC`S en la programación, este trabajo está
elaborado con el fin de que el estudiante instale el software eclipse y aprenda a
programar en ella con este pequeño tutorial, que está elaborado con información
recopilado de distintas páginas web y archivos PDF etc.
En este trabajo hablare de 3 software de programación y elaboraremos programaciones simple, como una pequeña introducción a la programación, también para comparar los programas de programación para ver cual se nos facilita más para programar. El software de eclipse a mi parecer, tiene diversas herramientas para programar y es muy útil también para los que apenas empiezan a programar o que no han programado antes. Esperando que este material sea de apoyo para solución de problemas a compañeros estudiantes y al que requiera información. Este tutorial trata de mostrar las ventajas de utilizar Eclipse, bluej, nedbeans para programar Java. Sirve como una guía detallada para usuarios novatos. No es necesario un conocimiento avanzado o específico de Java para poder seguir este tutorial. En unos pocos minutos, será capaz de dominar las técnicas principales de Eclipse, lo que acelerará la programación e incrementará la productividad. El único requisito que debe cumplirse antes de comenzar este tutorial es tener
instalada cualquier versión de Eclipse, junto con una máquina virtual de Java.
Programando en eclipse
Instalación de eclipse:
Lo primero que tenemos que hacer es descargar el programa eclipse de 32 o 64
bits dependiendo de su ordenador, lo pueden descargar de la página oficial de
eclipse o de cualquier página web.
Descomprimen la carpeta eclipse ya que adentro nos viene el software de dicho
programa.
Una vez extraído entramos a la carpeta e instalamos eclipse.exe
Creamos una carpeta en la unidad (c) del disco dura para guardar los trabajos
que realizaremos con eclipse.
Y seguimos las instrucciones que nos aparezcan en la pantalla. Antes de dar click
en ok buscamos la carpeta creada especialmente para los trabajos de eclipse la
seleccionamos y ahora si le damos ok.
Automáticamente se nos abrirá una ventana dándonos la bienvenida a eclipse,
nos aparecerá un logo de eclipse y arriba del logo nos dice welcome y la
cerramos la ventanita de welcome.
Y ya está instalado nuestro programa y listo para usarse.
Proyecto eclipse:
En el entorno de desarrollo Eclipse todo archivo se almacena dentro de un proyecto. Esto quiere decir que todo documento, carpeta, archivo de código fuente (.java) y código compilado (.class) tiene que estar contenido dentro de un proyecto. Así pues, el primer paso antes de usar Eclipse para programar en Java es comprender la estructura de proyectos de Eclipse.
Pasos para programar en eclipse
El eclipse es un entorno de trabajo profesional, por lo que en un principio puede parecer complejo el desarrollo de nuestros primeros programas. Todo programa en eclipse requiere la creación de un “Proyecto”, para esto debemos seleccionar desde menú de opciones:
Ahora aparece el dialogo donde debemos definir el nombre de nuestro proyecto
En el campo de texto “Project name” ingresamos como nombre: proyecto x y
dejamos todas las otras opciones del dialogo con los valores por defecto.
Presionamos el botón “finish”. Ahora en la ventana de package” aparece el
proyecto de acabamos de crear.
Como segundo paso veremos que todo programa en java requiere como mínimo
una clase. Para crear una clase debemos seleccionar desde menú de opciones.
En el dialogo que aparece debemos definir el nombre de la clase (lo llamaremos
clase 1) los otros datos del dialogo lo dejamos con los valores por defecto.
Luego de dar click en finish tenemos el archivo donde podemos codificar nuestro
primer programa.
Más adelante veremos los archivos que se crean en un proyecto, ahora nos
dedicaremos a codificar nuestro programa. En la ventana de edición ya tenemos
el esqueleto de una clase de java que el entorno eclipse nos creó
automáticamente.
Todo programa en Java debe definir la función main. Esta función la debemos codificar dentro de la clase: "Clase1". Procedemos a tipear lo siguiente:
Como último paso debemos compilar y ejecutar el programa, esto lo podemos
hacer desde menú de opciones o presionando la tecla F11
Si no hay errores en la codificación debemos ver el resultado de la ejecución en
una ventana del eclipse llamada “console” que aparece en la parte inferior.
Lo más importante es que queden claro los pasos que debemos dar para crear un
proyecto java. Como vimos en este pequeño ejemplo más adelante
programaremos un programa con más dificultad.
Programando en BlueJ
Entorno de desarrollo bluej
BlueJ es un sencillo entorno de programación exclusivamente diseñado para la enseñanza y el aprendizaje de Java. Se trata de un proyecto nacido en el seno de un grupo de investigación universitario integrado por miembros británicos y australianos. Por sus novedosas características, en poco tiempo BlueJ alcanzó una gran popularidad en entornos docentes.
Instalación de bluej
Para la instalación de bluej, lo primero que necesitamos hacer es descargar el
programa de su página oficial y descargamos el software de 32 o 64 bits
dependiendo de su computadora. Una vez que ya lo allá descargado le damos
doble clik y lo instalamos.
Le damos clik en ejecutar y seguimos las instrucciones que se nos indique.
Una vez que allá terminado la instalación abrimos el programa y nos aparecerá
una ventana donde procederemos a trabajar.
Área del archivo del proyecto
Barra indicadora de ejecución del programa
Área del banco de objetos
Pasos para ejecutar un programa
Los primero que vamos hacer es dar clik en Project, open Project, nos va
aparecer una ventana y nombramos nuestra carpeta y le damos clik en créate.
Ahora crearemos una clase para esto le damos clik en new class nos aparecerá
una ventana y llamare a mi clase Randy y le damos ok y nos tiene que aparecer
nuestra clase.
Hacemos doble clik en la clase, abrirá un editor mostrando un código por defecto,
borra el código y escribe el código que mostrare a continuación.
public static void main (String [] args) { System.out.print("el grupo de tic`s E2..."); System.out.print("es el mejor..."); System.out.println("que el E1"); System.out.println(""); System.out.println("si es el mejor..."); } }
Ya que pegamos el nuevo código le damos clik en compile.
Código que vamos a borrar
Le damos clik derecho a nuestra clase y saldrá un menú y le damos clik en el inciso void main (string[]args) nos saldrá una ventana y le damos clik en ok. Nos va a salir una nueva ventana mostrándonos el resultado final de nuestro código que hemos generado.
Código que pegamos
Y el resultado final se mostrara en la ventana, la programación en bluej no es tan complicada y si siguen practicando será mucho más sencillo.
NedBeans
Instalar NedBeans
Descargamos NedBeans de su página oficial le damos doble clik y empezará a
instalarse.
Seguimos las instrucciones de instalación y aceptamos los términos de licencia,
automáticamente procederá a instalarse.
La instalación es un poco tardado, una vez que se terminó de instalar abrimos
nedbeans para empezar a programar.
Nedbeans le encontré parecido a eclipse, una vez que ya se abrió nos saldrá una
ventana así como la que se muestra a continuación y ahora si empezaremos a
programar.
Programando con NedBeans
Para empezar programar, tenemos que abrir el programa de nedbeans, le damos
clik en file y seleccionamos la opción new Project.
Ahora le asignamos un nombre a nuestro proyecto. Yo le he llamado bienvenido al grupo de tic`s E2. Y le damos clik en finish
Luego de esto le damos clic en Finish. Con esto habremos creado nuestro proyecto. Ahora nos fijamos en la sección de la izquierda, nos aparecerá un árbol desplegable con nuestro proyecto. Desplegamos el contenido y encontramos Source Packages y Library.
Ahora, dentro de Source Packages encontraremos biembenidos.al.grupo.de.tic.s.e2
Le damos clic derecho a biembenidos.al.grupo.de.tic.s.e2,
Luego en “New” y buscamos la opción java pockage.
Creamos un nuevo paquete llamado clases.Ahora, de nuevo en el árbol
desplegable. En el nuevo paquete llamado Clases damos clic derecho, “New”,
“JFrameForm”. Creamos un nuevo JForm llamado “Window”. Le damos clic en
“Finish”.
Nos aparecerá un cuadro en blanco. Este cuadro se conoce como JFrame y es el
lienzo para iniciar la creación de un programa.
En la parte de la derecha encontraremos la Paleta o Palette. Desplegamos Swing Controls y buscamos la opción que dice “Button” o “Boton”. Lo seleccionamos y lo arrastramos al JFrame. Con esto habremos agregado un botón a nuestro programa.
Arrastramos button al centro del área del trabajo y hemos agregado un botón.
Ahora buscamos la opción llamada “Label” y la arrastramos al Frame. Le damos clic derecho al botón que agregamos y le damos clic a “editar texto” o “Edit Text”. Escribimos “Aceptar”. Ahora hacemos lo mismo con el Label, esta vez lo llamaremos “Mensaje”.
Esta será la interfaz de nuestra primera aplicación. En la sección de la derecha, en Propiedades, es posible cambiar la fuente, el tipo de letra, el tamaño, etc. Ahora procederemos a programar el comportamiento de nuestra aplicación. Para ello, hacemos clic derecho en el botón que colocamos y vamos a Eventos/Events, Acciones/Action, actionPerformed.
Se nos abrirá una ventana de códigos en la cual designaremos el comportamiento del botón que colocamos en el Frame. Eliminamos el mensaje que nos aparece por default (“// TODO add your handling code here:”) y escribimos lo siguiente:
jLabel1.setText("hola mundo");
Explicaré lo que esto significa: jLabel1 es el nombre del label que colocamos, el mismo al que le escribimos “Mensaje”. Con el comando setText() establecemos cualquier texto que deseemos. El texto que vayamos a designar debe colocarse entre comillas. Luego que hemos escrito esto, podemos proceder a probar nuestro programa. Ejecutamos el programa presionando F6 y nos aparecerá una ventana con un botón y la inscripción “Mensaje”. Al hacer clik en el botón “Aceptar” vemos que donde decía “hola mundo”.
Remplazaremos este código por
el que se muestra en la parte
superior de esta imagen
Nos tiene que quedar
así
Este es el principio básico de cualquier tipo de aplicación. Y ya hemos
programado en nedbeans.
Conclusión:
La programación en eclipse que realizamos con ayuda de esta guía elaborada
con la ayuda de páginas web analizadas y recopiladas para reunir la información
suficiente, y terminando este material con mis palabras y capturas de pantalla que
realice, esperando que este material les haya servido de apoyo o de guía no solo
para programar también para resolver alguna duda a los compañeros estudiantes.
En esta guía trato de mostrar cómo se trabaja con el software eclipse, bluej,
nedbeans, que son un lenguaje de programación con entorno a java, eclipse tiene
herramientas que nos ayudaran a programar, además de ser un poco fácil de
utilizar para los que apenas empezamos a programar.
Es esta guida se muestran 3 software diferentes para programar, todas con
entorno a java, tratando de explicar cómo se programa en cada uno de los
programas, cuál de los tres tiene herramientas que nos van a servir como futuros
programadores también trato de ver que programa es más fácil de utilizar para los
que apenas empiezan con la programación, tratando de mostrar que programa es
más comprensible y con herramientas básicas.
Otras fuentes consultadas:
Slideshares, Antonio Jesús Espejo fecha 11/04/2011, en línea, fecha 9/02/2014 disponible en:
http://www.slideshare.net/ponchomarin17/java-con-eclipse
Programar con eclipse, sin fecha, en línea, fecha 9/02/2014 disponible en:
http://www.javaya.com.ar/detalleconcepto.php?codigo=76&inicio=
Jarroba, Reiman y Richard, fecha 2014, en line fecha 9/02/2014 disponible en:
http://jarroba.com/instalar-bien-eclipse-un-ide-de-muchos/
Instalación de eclipse, sin fecha, en línea fecha 9/02/2014 disponible en:
http://www.javaya.com.ar/detalleconcepto.php?codigo=75&inicio=0
PDF. Introducción a eclipse, fuera de línea 9/02/2014 disponible en:
http://dis.um.es/~bmoros/privado/bibliografia/tutorial%20eclipse%20para%20novatos%20java%20(Pollino).pdf
Programar en java, Sergio Marcilla, sin fecha, en línea 9/02/2014 disponible en:
http://programarenjava.com/crear-una-clase-programar-en-java-con-eclipse/
youtube, fecha 29/05/2007, en línea fehca 11/02/2014, disponible en: http://www.youtube.com/watch?v=WuG55cFndGg
Programa en Java con NetBeans fecha 28/06/2013, en línea fecha 11/02/2014 disponible en:
http://panamahitek.com/como-crear-nuestro-primer-programa-en-java-con-netbeans/
ediasa 5/05/201, línea fecha 11/02/2014 disponible en: http://www.ediasa.es/otros/9039-programacion-orientada-a-objetos-con-java-usando-bluej.html
PDF. Fuera de línea, fecha/ 11/02/2014, disponible en:
http://www.bluej.org/tutorial/tutorial-spanish-201.pdf
Bluej software disponible en:
http://www.bluej.org/
Nedbeans software disponible en:
https://netbeans.org/
Eclipse software disponible en:
http://www.eclipse.org/downloads/
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
MATERIA
FUNDAMENTOS DE PROGRAMACION
TEMA
PROFESORA
SUSANA MONICA ROMAN NAJERA
ALUMNO
MARTINEZ MATEO ERIC RANDY
CARRERA
ING. EN TIC´S
SEMESTRE
2 E2
SALINA CRUZ OAXACA
Tabla de contenido
SENTENCIAS ............................................................................................................................. 53
Operadores ............................................................................................................................................ 55
Otras fuentes consultadas ...................................................................................................................... 59
Sentencias
Sentencia IF-ELSE
Su funcionamiento es idéntico al que se les da en los otros lenguajes de
programación.Ejemplo:
if ( Edad > 200 )
{
System.out.println("La edad digitada sobrepasa el límite");
......
}
else
if ( Edad < 0 )
{
System.out.println("La edad digitada es menor que cero");
.......
}
else
{
System.out.println("Edad registrada");
......
} Sentencia SWITCH-CASE
Su funcionamiento es igual al de su equivalente en C++. Ejemplo:
switch ( Estado )
{
case 0:
System.out.println("Estado OK ");
......
break;
case 1:
{
System.out.println("Estado EN ACTUALIZACIÓN");
.....
}
break;
case 2:
System.out.println("Estado ERROR DE CALCULO");
return;
......
default :
System.out.println("Estado NO CONOCIDO");
.....
}
Las sentencias son, a grandes rasgos, equivalentes a las oraciones del
lenguaje natural. Instrucciones a seguir, Una sentencia forma una unidad de
ejecución completa. Los siguientes tipos de expresiones se pueden convertir en
sentencia si se terminan con punto y coma (;).
Expresiones de asignación Cualquier uso de code>++ o -- Invocaciones de métodos Expresiones de creación de objetos
Este tipo de sentencias se llaman sentencias de expresión. Veamos algunos
ejemplos de sentencias de expresión.
unValor = 8933.234; // sentencia de asignación unValor++; // sentencia de incremento System.out.println("¡Hola Mundo!"); // sentencia de invicación de método
Bicycle miBici = new Bicycle(); // sentencia de creación de objeto Hay dos otros tipos de sentencias además de las de expresión: sentencias de
declaración y sentencias de control de flujo. Una sentencia de
declaración declara una variable. Ya hemos visto muchos ejemplos de
sentencias de declaración:
double unValor = 8933.234; //sentencia de declaración Finalmente, las sentencias de control de flujo regulan el orden en el que se ejecutan las sentencias. Aprenderá más acerca de las sentencias de control de flujo en la siguiente sección, Sentencias de control de flujo.
Operadores
OPERADORES ARITMETICOS
Un operador es un símbolo especial que indica al compilador que debe efectuar una operación matemática o lógica.
Java reconoce los siguientes operadores aritméticos:
Operador Operación
+ Suma
- Resta
* Multiplicación
/ División
% Residuo o Módulo
Reglas para Orden de Operaciones 1. Resolver paréntesis, u otros símbolos. ( ) [ ] { } 2. Resolver exponentes o raíces. 3. Multiplicación y división de izquierda a derecha. 4. Suma y resta de izquierda a derecha.
Ejemplo: 2 + 7 · 8 / 2
2 + 56 / 2 [Se multiplicó 7 · 8] 2 + 28 [Se dividió 56 / 2] 30 [Se sumó 28 + 2]
1) 4*2(3+6)/3= 4*2(9)/3= 8(9)/3=72/3=24
2) 3+(2+3)^2-6/2=3+(5)^2-6/2=3+25-6/2=3+25-3=28-3=25
3) 4[1-(5-11)/3]=4[1-(-6)/3]=4[1-2]=4[3]=12
4) 2{6-2(9-4)/5+1}=2{6-2(5)/5+1}=2{6-10/5+1}=2{6-2+1}=2{4+1}=2{5}=10
5) 3 { 42 – ( -3 + 1) / 2}=3{42-(-2)/2}=3{16-(-2)/2}=3{16—1}=3{17}=51
6) 4 { 5 – [ 6 + ( 2 + -4)^2 / 2 + 8] }=4{5-[6+(-2)^2/2+8]}=4{5-[6+4/2+8]}=4{5-
[6+2+8]}=4{5-[8+8]}=4{5-16}=4{-11}=-44
7) {2 [(2 + 3 – 5)^2={2[(0)^2=2 8) 7+5*2+3 (3*3)=7+5*2+3(9)=7+10+3(9)=20(9)=180
9) (60*2/4) (9+1) (4^2-2) =(30)(10)(14)=4200
10) (5*12)^2 + 16 – (16-4*3) / 6 =(60)^2+16-(-4)/6=3600+64/6=610.6666
OPERADORES JAVA UNITARIOS.
Los operadores unitarios en java son:
– + signos negativo y positivo
++ -- incremento y decremento
~ complemento a 1
! NOT. Negación
Estos operadores afectan a un solo operando.
El operador ++ (operador incremento) incrementa en 1 el valor de la variable.
Ejemplo de operador incremento:
int i = 1;
i++; // Esta instrucción incrementa en 1 la variable i. // Es lo mismo que hacer i = i + 1; i toma el valor 2
El operador –- (operador decremento) decrementa en 1 el valor de la
variable.
Ejemplo de operador decremento:
int i = 1;
i--; // decrementa en 1 la variable i.
// Es lo mismo que hacer i = i - 1; i toma el valor 0
Los operadores incremento y decremento pueden utilizarse como
prefijo o sufijo, es decir, pueden aparecer antes o después de la
variable.
Por ejemplo:
i = 5;
i++; // i vale ahora 6
++i; // i vale ahora 7
Cuando estos operadores intervienen en una expresión, si preceden al operando (++i), el valor se modificará antes de que se evalúe la
expresión a la que pertenece.
En cambio, si el operador sigue al operando (i++), entonces el valor del operando se modificará después de evaluar la expresión a la que
pertenece.
Por ejemplo:
int x, i = 3;
x = i++;
En esta asignación a x se le asigna el valor 3 y a continuación i se
incrementa, por lo tanto, después de ejecutarla:
x contiene 3, i contiene 4.
Si las instrucciones son:
int x, i = 3;
x = ++i;
En esta instrucción primero se incrementa i y el resultado se asigna a
x. Por lo tanto, después de ejecutarla:
x contiene 4, i contiene 4.
Otro ejemplo:
int i = 1;
System.out.println(i);
System.out.println (++i);
System.out.println (i);
Estas instrucciones mostrarían por pantalla:
1
2
2
En cambio, si se cambia la posición del operador:
int i = 1;
System.out.println(i);
System.out.println (i++);
System.out.println (i);
Estas instrucciones mostrarían por pantalla:
1
1
2
El operador complemento a 1 ~ cambia de valor todos los bits del
operando (cambia unos por ceros y ceros por unos). Solo puede usarse con datos de tipo entero. El carácter ~ es el ASCII 126.
Por ejemplo:
int a = 1, b = 0, c = 0;
c = ~a;
Otras fuentes consultadas Oocities, 10/2009, en línea, consultada el 20/02/2014, disponible en:
http://www.oocities.org/es/carolyarenas/ihai/sentencias.htm
codexion, 2008, en línea, consultada el 20/02/2014, disponible en:
http://www.codexion.com/tutorialesjava/java/nutsandbolts/expressions.html
wikibooks, 11/10/2010,en línea, consultada el 20/02/2014, disponible en:
http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Sentencia_break
programación java, sin fecha, en línea, consultada el 20/02/2014, disponible en:
http://puntocomnoesunlenguaje.blogspot.mx/2012/04/operadores.html
programación fácil, sin fecha, en línea, consultada el 20/02/2014, disponible en:
http://www.programacionfacil.com/java/operadores_aritmeticos
CREMC, 7/2002, en línea, consultada el 20/02/2014, disponible en:
http://ponce.inter.edu/cremc/operacion.html
APR aprende a programar, 2006, en línea, consultada el 20/02/2014, disponible en:
http://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=268:
operadores-matematicos-en-programacion-prelacion-ejemplos-y-ejercicio-resuelto-
cu00131a&catid=28:curso-bases-programacion-nivel-i&Itemid=59
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
MATERIA
FUNDAMENTOS DE PROGRAMACION
TEMA
TAREA DE LA UNIDAD1
PROFESORA
SUSANA MONICA ROMAN NAJERA
ALUMNO
MARTINEZ MATEO ERIC RANDY
CARRERA
ING. EN TIC´S
SEMESTRE
2 E2
SALINA CRUZ OAXACA
ÍNDICE
COMENTARIO DE LÍNEA Y BLOQUE 62
Variables y sintaxis ......................................................................................................................... 64
Tipos de datos primitivos ................................................................................................................... 66
Otras fuentes consultadas ............................................................................................................. 68
Comentario de línea y bloque
//Código 1
/* Descripción: Aplicación que sirve para multiplicar dos números enteros Fecha Creación: 01/10/2003 Llamada: java Multiplica <numero1> <numero2> Donde <numero1> y <numero2> deben ser números enteros */ class Multiplica { // Nombre de la clase public static void main(String [ ] args) { // Si no se le han indicado dos argumentos if (args.length != 2) { System.out.println(-Número de parámetros erróneo"); // Mensaje de error // El número de parámetros es de dos } else { /* Como posible mejora sería interesante comprobar que los parámetros son numéricos para evitar errores de ejecución Código 2 */ int a = Integer.valueOf(args[0]).intValue(); // Primer parámetro int b = Integer.valueOf(args[1]).intValue(); // Segundo parámetro // Mostramos el resultado de la multiplicación System.out.println(args[0] + "*" + args[1] + "=" + new Integer(a*b).toString()); } } } Ejemplos2 //comentario de línea //ficero DemoComentario.java /**este un comentario para documentación para tu proyecto*/ Public class DemoComentario{
Public static void main(String []args){//comienzo de la clase /*esto es un comentario de varias lineas*/ System.out.println(“prueba de los diferentes tipos de comentario en java”); } }//fin de la clase Ejemplo 3 /*
*este es el primer programa en un IDE del curso java
*creado el 19/02/2014
*aprenderaprogramar.com
*/
//a continuación el código del programa
Public class ejemplo{
Public stactic void main(string[] arg) {
System.out.println(“hola java”);// usamos esta sintaxis para mostrar mensajes por pantalla
}
}
Variables y sintaxis
A veces es conveniente poder tener nombres de variables variables. Es decir, un nombre de variable que se puede configurar y utilizar de forma dinámica. Una variable normal se establece con una sentencia como:
<? Php
$ a = "hola" ;
?>
Una variable variable toma el valor de una variable y lo trata como el nombre de una variable. En el ejemplo anterior, hola , se puede utilizar como el nombre de una variable utilizando dos signos de dólar.es decir,
<? Php
$ $ a = "mundo" ;
?>
En este punto, dos variables se han definido y almacenado en el árbol de símbolos de PHP: $ a , que contiene "hola" y $ hola que contiene "world". Por lo tanto, esta declaración:
<? Php
echo " $ a $ { $ a } " ;
?>
Produce el mismo resultado que:
<? Php
echo " $ a $ hola " ;
?>
Es decir, ambas producen: hello world .
Para usar variables con matrices, hay que resolver un problema de ambigüedad. Es decir, si se escribe $ $ a [1] el intérprete necesita saber si nos referimos a utilizar $ a [1] como una variable, o si quería $ $ a como variable y luego los botones [1] Índice de esa variable. La sintaxis para resolver esta ambigüedad es: $ {$ a [1]} para el primer caso y $ {$ a} [1] para el segundo.
Las propiedades de clase también se puede acceder utilizando nombres de propiedades variables. El nombre de la propiedad variable se resuelve en el ámbito desde el que se realiza la llamada. Por ejemplo, si usted tiene una
expresión como $ foo-> $ bar, el ámbito local, que será examinado por $bar y su valor se utiliza como el nombre de la propiedad de $foo . Esto también es cierto si $bar es un acceso a una matriz.
Las llaves también se pueden utilizar, para delimitar claramente el nombre de la propiedad. Ellos son más útiles cuando se accede a los valores dentro de una propiedad que contiene una matriz, cuando el nombre de la propiedad se hace de piezas múltiple, o cuando el nombre de la propiedad contiene caracteres que no son de otra manera válida (por ejemplo, de json_decode () o SimpleXML ).
Ejemplo # 1 Ejemplo de la propiedad Variable
? <Php
clase foo {
var $ bar = 'Estoy bar.' ;
var $ matriz = array ( 'Yo soy A.' , 'Yo soy B.' , 'Yo soy
C' );
var $ r = ' . Estoy r ' ;
}
$ foo = new foo ();
$ bar = 'bar' ;
$ baz = array ( 'foo' , 'bar' , 'baz' , 'quux' );
echo $ foo -> $ bar . "\ n" ;
echo $ foo -> $ baz [ 1 .] "\ n" ;
$ inicio = 'b' ;
$ end = 'ar' ;
echo $ foo -> { $ inicio . $ end }. "\ n" ;
$ arr = 'arr' ;
echo $ foo -> $ matriz [ 1 ]. "\ n" ;
echo $ foo -> { $ matriz } [ 1 ]. "\ n" ;
?>
El resultado del ejemplo sería:
Soy bar.
Soy bar
Soy bar.
Estoy r.
Estoy B
Tipos de datos primitivos
Java requiere que todas las variables tengan un tipo antes de que se puedan usar en un programa. Por esta razón, se dice que java es un lenguaje de tipos estrictos. Los tipos de datos se dividen en cuatro categorías: Categoría tipos de datos primitivos. Lógicos boolean Texto char Enteros byte, short, int y long Punto flotante double y float Dando un total de ocho tipos de datos primitivos: Tipo bits rango Bo9olean 1 true o false Char 16 carácter de Unicode de ´/u0000´ a ´/uFFFF´ Byte 8 entero con signo de -128 a +127 Short 16 entero con signo de -2,147,483,648 a +2,147,483,647 Long 64 entero con signo de -9,223,372,036,854,775,808 a +9,223,372,036,854,775,807 Float 32 punto flotante de -3.40292347E+38 a +3.40292347E+38 Doublé 64 punto flotante de -1,79769313486231570E+308 a +1,79769313486231570E+308 Cada uno de los tipos de datos de la tabla anterior se lista junto con su tamaño de bits (cada byte tiene 8 bits) y su intervalo de valores. Como los diseñadores de java querían que fuera portátil, decidieron utilizar estándares internacionalmente reconocidos para los formatos tantos de caracteres (Unicode) como de números de punto flotante (IEEE754)
Los tipos de datos hacen referencia al tipo de información que se trabaja, donde la
unidad mínima de almacenamiento es el dato, también se puede considerar como
el rango de valores que puede tomar una variable durante la ejecución del
programa.
Otras fuentes consultadas
Programación de java desde cero. 25/octubre/2007, en línea, 19/02/2014 http://desarrollador-unt.blogspot.mx/2007/10/tipos-de-comentarios-en-java.html aprende a programar.com,2006, en línea, 19/02/2014
http://www.aprenderaprogramar.com/index.php?option=com_content&id=407:comentarios-en-el-codigo-de-programacion-java-concepto-de-bloque-de-codigo-cu00618b&Itemid=188 Comentario en java, 17/diciembre/2006, en línea, 19/02/2014
http://lineadecodigo.com/java/comentarios-en-java/ php, sin fecha, en línea, 19/02/2014 http://www.php.net/manual/en/language.variables.variable.php galeón.com, sin fecha, en línea, 19/02/2014 http://www.galeon.com/proyecttwo/tipos_de_datos_primitivos.htm
codexexempla.org,2007, en línea, 19/02/2014
http://www.codexexempla.org/curso/curso_4_2_a.php
declaración de variables,2008,en línea, 19/02/2014
http://msdn.microsoft.com/es-es/library/ms225549(v=vs.90).aspx
DIRECCIÓN GENERAL DE EDUCACIÓN SUPERIOR TECNOLÓGICA
INSTITUTO TECNOLÓGICO DE SALINA CRUZ
MATERIA
FUNDAMENTOS DE PROGRAMACION
TEMA
ESTRUCTURAS DE CONTROL
PROFESORA
SUSANA MONICA ROMAN NAJERA
ALUMNO
MARTINEZ MATEO ERIC RANDY
CARRERA
ING. EN TIC´S
SEMESTRE
2 E2
SALINA CRUZ OAXACA
INTRODUCCIÓN: ......................................................................................................................... 1
Estructuras de control: ........................................................................................................................... 1
ESTRUCTURA SECUENCIAL................................................................................................................. 2
ESTRUCTURA CONDICIONAL, ALTERNATIVA O SELECTIVA ....................................................... 3
Estructura de control repetitiva ............................................................................................................ 7
Conclusión: ................................................................................................................................................... 8
Otras fuentes consultadas: .................................................................................................................... 8
Introducción:
Los programas definidos hasta este punto se ejecutan de modo secuencial, es decir, una sentencia después de otra. La ejecución comienza con la primera sentencia del programa y prosigue hasta la última sentencia, cada una de las cuales se ejecuta una sola vez. Esta forma de programación es adecuada para programas sencillos. Sin embargo, para la resolución de problemas de tipo general se necesita la capacidad de controlar cuáles son las sentencias que se ejecutan, y en qué momentos. Las estructuras de control o construcciones de control controlan la secuencia o flujo de ejecución de las sentencias. Las estructuras de control se dividen en tres grandes categorías en función del flujo de ejecución: secuencia, selección e iteración.
Estructuras de control:
Las estructuras de control determinan la secuencia de ejecución de las sentencias de un programa.
Las estructuras de control se dividen en tres categorías: Secuencial Condicional o Selectiva Iterativa o Repetitiva.
Con las estructuras de control se puede:
De acuerdo a una condición, ejecutar un grupo u otro de sentencias (If-Then-Else)
De acuerdo al valor de una variable, ejecutar un grupo u otro de sentencias (Select-Case)
Ejecutar un grupo de sentencias mientras se cumpla una condición (Do-While)
Ejecutar un grupo de sentencias hasta que se cumpla una condición (Do-Until)
Ejecutar un grupo de sentencias un número determinado de veces (For-Next)
Todas las estructuras de control tienen un único punto de entrada y un único punto de salida. Las estructuras de control se puede clasificar en: secuenciales, iterativas y de control avanzadas. Esto es una de las cosas que permite que la programación se rija por los principios de la programación estructurada.
Los lenguajes de programación modernos tienen estructuras de control similares. Básicamente lo que varía entre las estructuras de control de los diferentes lenguajes es su sintaxis, cada lenguaje tiene una sintaxis propia para expresar la estructura.
Otros lenguajes ofrecen estructuras diferentes, como por ejemplo los comandos guardados.
ESTRUCTURA SECUENCIAL El orden en que se ejecutan por defecto las sentencias de un programa es secuencial. Esto significa que las sentencias se ejecutan en secuencia, una después de otra, en el orden en que aparecen escritas dentro del programa. La estructura secuencial está formada por una sucesión de instrucciones que se ejecutan en orden una a continuación de la otra. Cada una de las instrucciones están separadas por el carácter punto y coma (;). Las instrucciones se suelen agrupar en bloques. El bloque de sentencias se define por el carácter llave de apertura ({) para marcar el inicio del mismo, y el carácter llave de cierre (}) para marcar el final. Ejemplo: { instrucción 1; instrucción 2; instrucción 3; } En Java si el bloque de sentencias está constituido por una única sentencia no es obligatorio el uso de las llaves de apertura y cierre ({ }), aunque sí recomendable. Ejemplo de programa Java con estructura secuencial: Programa que lee dos números por teclado y los muestra por pantalla.
/* Programa que lea dos números por teclado y los muestre por pantalla. */ import java.util.*; public class Main { public static void main(String[] args){ //declaración de variables int n1, n2; Scanner sc = new Scanner(System.in); //leer el primer número System.out.println("Introduce un número entero: "); n1 = sc.nextInt(); //lee un entero por teclado //leer el segundo número System.out.println("Introduce otro número entero: "); n2 = sc.nextInt(); //lee un entero por teclado //mostrar resultado System.out.println("Ha introducido los números: " + n1 + " y " + n2); } } Ejemplo de programa Java con estructura secuencial: Programa que lee dos números de tipo double por teclado y calcula y muestra por pantalla su suma, resta y multiplicación. /* * Programa que lee dos números de tipo double por teclado * y muestra su suma, resta y multiplicación. */ import java.util.*; public class Main { public static void main(String[] args){ Scanner sc = new Scanner(System.in); double numero1, numero2; System.out.println("Introduce el primer número:"); numero1 = sc.nextDouble(); System.out.println("Introduce el segundo número:"); numero2 = sc.nextDouble(); System.out.println("Números introducido: " + numero1 + " " + numero2); System.out.println (numero1 + " + " + numero2 + " = " + (numero1+numero2)); System.out.println (numero1 + " - " + numero2 + " = " + (numero1-numero2)); System.out.println (numero1 + " * " + numero2 + " = " + numero1*numero2); } } Para modificar el orden de ejecución de las instrucciones de un programa Java se utilizan las estructuras condicionales y repetitivas.
ESTRUCTURA CONDICIONAL, ALTERNATIVA O SELECTIVA
La estructura condicional determina si se ejecutan unas instrucciones u otras según se cumpla o no una determinada condición.
En java la estructura condicional se implementa mediante: - Instrucción if. - Instrucción switch. - Operador condicional ? :
INSTRUCCION if
Puede ser del tipo: - Condicional simple: if - Condicional doble: if ... else ... - Condicional múltiple: if .. else if .. La condición debe ser una expresión booleana es decir debe dar como resultado un valor booleano (true o false). Condicional simple: se evalúa la condición y si ésta se cumple se ejecuta una determinada acción o grupo de acciones. En caso contrario se saltan dicho grupo de acciones. if(expresión_booleana){ instrucción 1 Instrucción 2 ....... } Si el bloque de instrucciones tiene una sola instrucción no es necesario escribir las llaves { } aunque para evitar confusiones se recomienda escribir las llaves siempre. Ejemplo de programa Java con estructura condicional: Programa que pide por teclado la nota obtenida por un alumno y muestra un mensaje si el alumno ha aprobado.
/* * Programa que pide una nota por teclado y muestra un mensaje si la nota es * mayor o igual que 5 */ import java.util.*; public class Ejemplo0If { public static void main( String[] args ){ Scanner sc = new Scanner( System.in ); System.out.print("Nota: "); int nota = sc.nextInt(); if (nota >= 5 ){ System.out.println("Enorabuena!!"); System.out.println("Has aprobado"); } } } Condicional doble: Se evalúa la condición y si ésta se cumple se ejecuta una determinada instrucción o grupo de instrucciones. Si no se cumple se ejecuta otra instrucción o grupo de instrucciones. if(expresión booleana){ instrucciones 1 }
else{ instrucciones 2 } Ejemplo de programa Java que contiene una estructura condicional doble: Programa que lee la nota de un alumno y muestra si el alumno ha aprobado o no. /* * Programa que pide una nota por teclado y muestra si se ha aprobado o no */ import java.util.*; public class Ejemplo0If { public static void main( String[] args ){ Scanner sc = new Scanner( System.in ); System.out.print("Nota: "); int nota = sc.nextInt(); if (nota >= 5 ){ System.out.println("Enorabuena!!"); System.out.println("Has aprobado"); } else System.out.println("Lo Siento, has suspendido"); } } Otro ejemplo de programa Java que contiene una estructura condicional doble: Calcular si un número es par. El programa lee un número por teclado y muestra un mensaje indicando si es par o impar. /* * programa que pide un número por teclado y calcula si es par o impar */ import java.util.*; public class EjemploIf { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int num; System.out.println("Introduzca numero: "); num = sc.nextInt(); if ((num%2)==0) System.out.println("PAR"); else System.out.println("IMPAR"); } } Condicional múltiple: Se obtiene anidando sentencias if ... else. Permite construir estructuras de selección más complejas. if (expresion_booleana1)
instruccion1; else if (expresion_booleana2)
instruccion2; else
instruccion3; Cada else se corresponde con el if más próximo que no haya sido emparejado. Una vez que se ejecuta un bloque de instrucciones, la ejecución continúa en la siguiente instrucción que aparezca después de las sentencias if .. else anidadas. Ejemplo de programa Java que contiene una estructura condicional múltiple: Programa que lee una hora (número entero) y muestra un mensaje según la hora introducida. /* * Programa que muestra un saludo distinto según la hora introducida */ import java.util.*; public class Ejemplo2If { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int hora; System.out.println("Introduzca una hora (un valor entero): "); hora = sc.nextInt(); if (hora >= 0 && hora < 12) System.out.println("Buenos días"); else if (hora >= 12 && hora < 21) System.out.println("Buenas tardes"); else if (hora >= 21 && hora < 24) System.out.println("Buenas noches"); else System.out.println("Hora no válida"); } } Ejemplo de programa Java que contiene una estructura condicional múltiple: Programa que lee una nota (número entero entre 0 y 10) y muestra la calificación equivalente en forma de texto. /* * Programa que lee una nota y escribe la calificación correspondiente */ import java.util.*; public class Ejemplo3If { public static void main(String[] args) { Scanner sc = new Scanner(System.in); double nota; System.out.println("Introduzca una nota entre 0 y 10: "); nota = sc.nextDouble(); System.out.println("La calificación del alumno es "); if(nota < 0 || nota > 10) System.out.println("Nota no válida"); else if(nota==10) System.out.println("Matrícula de Honor"); else if (nota >= 9) System.out.println("Sobresaliente"); else if (nota >= 7) System.out.println("Notable");
else if (nota >= 6) System.out.println("Bien"); else if (nota >= 5) System.out.println("Suficiente"); else System.out.println("Suspenso"); } }
Comparar String en Java Para comparar el contenido de dos Strings en Java se usa el método equals: if ((cadena1.equals(cadena2)) En caso de que una cadena coincida exactamente con una constante se puede usar == String nombre = "Lucas"; if (nombre == "Lucas") Para comparar Strings en el orden alfabético se usa el método compare To if (cadena1.compareTo(cadena2) < 0) // cadena1 antes que cadena2 if (cadena1.compareTo(cadena2) > 0) // cadena1 después que cadena2 if (cadena1.compareTo(cadena2) == 0) // cadena1 igual que cadena2
Estructura de control repetitiva
Las estructuras de control repetitivas son aquellas en las que una sentencia o grupos de sentencias se repiten muchas veces. Este conjunto de sentencias se denomina bucle (loop). En este capítulo se introducen las estructuras de control repetitivas disponibles en el lenguaje turbo pascal; asimismo se describen un conjunto de técnicas para diseñar algoritmos y programas que utilicen bucles.
Bucle
Una estructura de control que permite la recepción de una serie determinada de sentencias se denominan bucle (lazo o ciclo).
El cuerpo del bucle contiene las sentencias que se repiten. Pascal proporciona tres estructuras o sentencias de control para especificar la repetición: while, repeat y for.
LA SENTENCIA WHILE
La estructura repetitiva while (mientras) es aquella en la que el número de interacciones no se conoce por anticipado y el cuerpo del bucle se repite mientras se cumple una determinada condición. Por esta razón, a estos bucles se les denomina bucles condicionales.
LA SENTENCIA REPEAT
Una variable de la sentencia while es la sentencia repeat. Una de las características de los bucles while-do es que la condición se valúa al principio de cada iteración, si la condición es falsa cuando las sentencia comienza, entonces el bucle no se ejecuta nunca.
Esta sentencia tiene una condicional que se repite hasta que dicha condición se haga verdadera esta condición se denomina repeat-until.
LA SENTENCIA FOR
La sentencia for nos sirve ya que con ella se puede ejecutar un bucle que se repita determinado número de veces.
Esta sentencia requiere que conozcamos el número de veces que se desea ejecutar la sentencia del interior del bucle. Si no se conoce de antemano el número de repeticiones es mejor utilizar la sentencia while o repeat.
Conclusión:
Las estructuras de control en conclusión para resolver un pseudocódigo de programación se debe tomar en cuenta las siguientes recomendaciones al momento de seleccionar una estructura de control. Para ejecutar un grupo de sentencias mientras exista una condición se debe utilizar una estructura:(do-while) para ejecutar un grupo de sentencias exista una condición se debe utilizar la estructura:(do-until) para ejecutar un grupo de sentencias un número determinado de veces se debe utilizar la estructura : (for-next) en conclusión podemos decir wque la estructuras de control son de gran ayuda al momento de solucionar problemas informáticos ya q1ue con facilidad de interpretación y de manejo al momento de utilizarlas en los pseudocódigos y nos ahorramos tiempo.
Otras fuentes consultadas:
Wikipedia fecha 24/01/2014. En línea. Fecha 9/02/2014. Disponible en:
http://es.wikipedia.org/wiki/Estructuras_de_control
slideshare fecha 07/08/2014. En linea. Fecha 9/02/2014. Disponible en:
http://www.slideshare.net/ivan1523/estructuras-de-control-8794280
programación java sin fecha. En línea. Fecha 9/02/2014. Disponible en:
http://puntocomnoesunlenguaje.blogspot.mx/2012/04/estructuras-de-control.html
curso de java fecha 2009. En línea. Fecha 9/02/2014. Disponible en:
http://www.cursodejava.com.mx/cursodejava121.html
wikilibros fecha 28/10/2009. En línea. Fecha 9/02/2014. Disponible en:
http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Estructuras_de_control
