Introducción A La Programación en Java

Programación I
Introducción a la programación en Java

Contenido Unidad
1. Conceptos básicos de programación y algoritmia.
2. Tipos de datos primitivos.
3. Declaración de los tipos de datos primitivos.
4. Algunas de las secuencias de escape.
5. Tipos de datos por referencia.
6. Variables.
7. Cómo nombrar una variables en Java.
8. Tipos de variables.
9. Constantes.
10. Comentarios de línea y de bloque.
11. Operadores aritméticos.
12. Operadores de igualdad y relacionales.
13. Operadores lógicos.
14. Operadores de incremento y decremento.
Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 2

de programación en Java. Elizcom S.A.S.
Contenido Unidad
15. Prioridad de operadores.
16. Promoción automática y casting.
17. Expresiones aritméticas.
18. Expresiones relacionales.
19. Expresiones lógicas.
20. Programación secuencial.

1. Conceptos básicos de programación y algoritmia
A continuación, aprenderemos los conceptos básicos de programación y
algoritmia:
1. Dato: son lo objetos sobre los que opera una computadora.
2. Información: es el resultado del tratamiento de datos (en cualquiera de sus
formas).
3. Algoritmo: es el conjunto ordenado y finito de pasos o instrucciones que
producen una solución a un problema en específico.
4. Características de un algoritmo:
a. Preciso: indica el orden realizado en cada paso.
b. Definido: si se sigue dos o más veces, se logra el mismo resultado.
c. Finito: tiene un fin, esto es, un número determinado de pasos.
5. Tipo de algoritmos:
a. Cualitativos: son aquellos en los que se describe cada paso utilizando
palabras.
b. Cuantitativos: son aquellos en los que se utilizan cálculos numéricos
para definir los pasos del proceso.

6. Diagrama de flujo: es la representación gráfica de una algoritmo.
7. Pseudocódigo: es una herramienta que facilita la elaboración de
algoritmos en la que las instrucciones se escriben utilizando un lenguaje de
pseudocódigo.
8. Programa: es un conjunto de instrucciones (órdenes) que guían a la
computadora para realizar alguna actividad o resolver un problema.
9. Lenguaje de programación: es el medio a través del cual le comunicamos
a la computadora la secuencia de instrucciones (programa) que debe
ejecutarse para resolver un problema.
10. Análisis del problema: el objetivo es comprender y definir claramente la
naturaleza del problema para poder llegar a una solución óptima, debemos
tener en cuenta lo siguiente:
a. Definición del problema: ¿qué hará el programa que se pretende
construir?
b. Especificaciones de entrada: ¿cuáles serán los datos de entrada?
c. Especificaciones de salida: ¿cuáles son los datos de salida?

11. Diseño de un algoritmo: en esta etapa se determina como hace el
programa la tarea solicitada, en dicha etapa es muy importante comprobar
manualmente el correcto funcionamiento del algoritmo.
12. Codificación del programa: etapa que consiste en escribir la solución del
problema en una serie de instrucciones detalladas, estas se escriben en un
lenguaje de programación.
13. Compilación y ejecución: el código fuente se procede a la etapa de
compilación. Este proceso consiste en verificar la sintaxis de cada
instrucción del programa, si no se han producido errores, el compilador
producirá el llamado al programa objeto o código fuente.
14. Verificación y depuración: en esta etapa se verifica el correcto
funcionamiento del programa con una amplia variedad de datos de entrada,
llamados datos de prueba.
15. Documentación: es una forma de comunicación escrita, esta puede incluir
enunciados, procedimientos, conclusiones, diagramas, etc.

2. Tipos de datos primitivos
En Java, a cada variable o constante se le debe asociar un tipo de dato. El tipo
define el rango de valores que puede tomar mientras el programa se encuentra
en ejecución. Los tipos de datos primitivos permitidos por Java son los enteros
(byte, short, int, long), reales (float, double), tipos de dato caracter (char) y
booleanos (boolean).
● Los tipos de datos enteros representan un intervalo de los números

enteros (sin considerar decimales).
Tipos de Datos Enteros

Nombre Rango de Valores Tamaño en bits
byte -128 a 127 8
short -32768 a 32767 16
int -2147483648 a 2147483647 32
long -9223372036854775808 a 9223372036854775807 64

● Los tipos de datos reales aceptan rangos de valores con parte entera y
parte decimal, los datos soportados son float y double.
Tipos de Datos Reales
float 3,4E-38 a 3,4E38 32
double 1.7E-308 a 1.7E308 64
● El tipo de dato caracter, usa la codificación Unicode. Esta codificación

permite usar los caracteres de todos los idiomas. Se caracteriza porque sus
primero 127 caracteres corresponden a los mismos caracteres del código
ASCII.
Tipos de Datos Reales
char 0 a 65536 (Caracteres alfanuméricos) 16

● Un dato de tipo booleano se caracteriza por tomar únicamente dos valores
true o false.
Tipos de Datos Boolean

Nombre Rango de Valores
boolean true, false

Actividad: Identificar el tipo de dato correspondiente
Identificador Tipo de Dato
Nike Marca () int
Marca: mazda
modelo: 2020
20 CapacidadLibras () String serie: xhab111
precio:20.000.0
2020 Modelo () String
Serie () String
TipoProducto () double
125.900,99 Precio () int
isbn () boolean
Estado () String

edad marca
patrocinador
cantidad
empresa Mazda
valorMonetario 30
carro
dia
carro
temperatura
1.094.988.333
45:00 min
1 a 3 dias
System.out.println(num1 + num2 + nombre); 07/09/2021

3. Declaración de los tipos de datos primitivos
A continuación, en la siguiente tabla se presenta la declaración de cada uno de
los tipos de datos primitivos.
Dato Declaración
byte byte var1=4;
short short var2
int int var3;
long long var4;
float float num1 = 2.7182f;
double double num2 = 2.125d;
char char letra = 'a';

4. Algunas de las secuencias de escape
Caracteres especiales usados con frecuencia.
Carácter Descripción
'\n' Salto de línea.
'\t' Permite un salto al siguiente tope de tabulación.
'\b' Retrocede el cursor en un espacio.
'\' Se usa para mostrar el carácter '.
'\”' Se usa para escribir una comilla doble (“).
'\'' Se usa para escribir una comilla simple (').
'\\' Se usa para mostrar el carácter back-slash (\)

5. Tipos de datos por referencia
Java cuenta con dos tipos de datos: valor y referencia. Cuando se declara una
variable que corresponde a un tipo de dato primitivo, se está haciendo
referencia a una variable por valor, que almacena su contenido en una
estructura denominada pila (stack). Los tipos de datos por referencia,
corresponden a instancias de clases y utilizan un área de memoria llamada
montículo o heap.
Una clase es una plantilla para crear objeto y un objeto es una instancia de
una clase. Las clases envoltorio permiten manipular un tipo de dato primitivo
como un objeto. A continuación, observamos los 8 tipos de datos primitivos con
su correspondiente clase envoltorio son:
byte - Byte float - Float

short - Short double - Double
int - Integer char - Character
long - Long boolean - Boolean

Clase Descripción crear objeto

La clase Integer encierra un dato
Integer Integer dato=new Integer(5);
primitivo (tipo int) en un objeto.
La clase Double encierra un dato

Double primitivo (tipo double) en un Double dato=new Double(5.0);
objeto.
Encierra un tipo de dato primitivo

Character Character c=new Character('A');
de tipo char
Nota: La clase String permite expresar un conjunto de caracteres (cadena).

Para inicializar una cadena se hace uso de comillas dobles.
Ejemplo: String direccion = "Carrera 15 # 10 11";

String nombre = "Juan Jose";

La clase String consta de variados métodos, algunos de ellos, para extracción
de caracteres, comparación y concatenación.

Concatenar es unir dos cadenas, en Java esto se logra con el operador +.
Ejemplo:
String nombre= "Juan Jose";

String direccion= "Carrera 15 # 10 11";
String concatenado = nombre + direccion;
A un String se le puede concatenar cualquier tipo de dato primitivo.
String nombre= "Juan Jose";

int edad= 28;
String ciudad= "Armenia";
String resultado = nombre + " tiene " + edad + " años" + " y vive en " + ciudad;
System.out.println(resultado);

6. Variables
¿Qué es una variable?: Una variable es definida como un espacio o campo (en
inglés, field) en memoria en el cual, se almacena un dato. Como su nombre lo
indica, a una variable se le puede modificar, si se requiere, su valor inicial. Las
variables se utilizan para realizar diversas operaciones o decisiones durante la
ejecución de un programa.
Podemos Podemos declarar las variables en Java de la siguiente manera:
int edad = 30;

valor_variable
int edad = 30;
tipo_dato nombre_variable
30
Memoria de reserva para la variable
RAM

6. Variables
Definición:
● tipo_dato: tipo de datos que se pueden almacenar en esta variable.
● nombre_variable: nombre asignado a la variable.
● valor_variable: es el valor inicial almacenado en la variable.
Ejemplos:
● float interesSimple; Declarando variable float
● int tiempo = 20, velocidad = 2; Declarando e Inicializando la variable
integer
● char var = "h"; Declarando e Inicializando la variable character
● Double precio = 2500; Declarando e Inicializando la variable double
● String mensaje = "hola mundo"; Declarando e Inicializando la variable
String

7. Cómo nombrar una variables en Java
En todo lenguaje de programación es importante tener cierto criterio al
momento de nombrar una variable. Es recomendable seguir las buenas
prácticas de programación que Java propone:
1. Comienza el nombre de la variable siempre con una letra. Nota: nunca
usar acentos.
2. Los nombres de las variables distinguen entre mayúsculas y minúsculas.
3. Usa nombres descriptivos para nombrar tus variables. Nota: Evitar en lo
posible usar abreviaturas o usar nombres poco claros para nombrar las
variables.
4. El nombre de la variable no debe coincidir con alguna palabra reservada de
java. Nota: Ver lista de palabras reservadas [link]
5. Usa el estilo de escritura CamelCase para nombrar tus variables. Nota: El
estilo de escritura CamelCase se refiere a que, si una variable se compone
de más de una palabra, la primer letra de la siguiente palabra se debe
escribir con mayúscula.
6. Si la variable almacena un valor constante, su nombre se escribe
completamente en mayúsculas.

8. Tipos de variables
Hay tres tipos de variables en Java que son:
1. Variables locales
Una variable definida dentro de un bloque, método o constructor se llama
variable local.
● El alcance de estas variables sólo existe dentro del bloque en el que se
declara la variable, es decir, podemos acceder a estas variables solo dentro
de ese bloque.
Ejemplo:
public void edadEstudiante()
{ //variable local edad
int edad = 0;
edad = edad + 5;
System.out.println("La edad del estudiante es : " + edad);
}

2. Variables de instancia
Las variables de instancia son variables no estáticas y se declaran en una clase
fuera de cualquier método, constructor o bloque.
● Como las variables de instancia se declaran en una clase, estas variables
se crean cuando un objeto de la clase se crea y se destruye cuando se
destruye el objeto.
Ejemplo:
import java.io.*;
class Points {
//Estas variables son variables de instancia.
//Estas variables están en una clase y no están dentro de ninguna función/método
int engPoints;
int mathsPoints;
int phyPoints;
}

3. Variables estáticas
Las variables estáticas también se conocen como variables de clase.
● Estas variables se declaran de forma similar a las variables de instancia, la
diferencia es que las variables estáticas se declaran utilizando la palabra
clave dentro de una clase fuera de cualquier constructor o bloque de
métodos.
● A diferencia de las variables de instancia, sólo podemos tener una copia de
una variable estática por clase, independientemente de cuántos objetos
creemos.
● Las variables estáticas se crean al inicio de la ejecución del programa y se
destruyen automáticamente cuando finaliza la ejecución.
Ejemplo: import java.io.*;
class Empleado { //Salario como variable estática
public static double salario;
public static String nombre = "Alex";
}

Variable de instancia VS Variable estática
● Cada objeto tendrá su propia copia de la variable de instancia,
mientras que solo podemos tener una copia de una variable estática por
clase, independientemente de cuántos objetos creemos.
● Los cambios realizados en una variable de instancia utilizando un objeto no
se reflejarán en otros objetos, ya que cada objeto tiene su propia copia de
la variable de instancia. En caso de estática, los cambios se reflejarán en
otros objetos ya que las variables estáticas son comunes a todos los
objetos de una clase.
● Podemos acceder a variables de instancia a través de referencias de
objetos y se puede acceder directamente a las variables estáticas
usando el nombre de clase.
Ejemplo:
class Ejemplo {
public static int a; //variable estática
int b; //variable de instancia
}

9. Constantes
Las constantes pueden usarse para dos objetivos: representar valores
inmutables o para representar el dominio de un atributos.
public final static double PI = 1416;

Representan valores inmutables
public final static double IVA = 0.18;
public final static int CARRO = 1; Representan el dominio de un

public final static int MOTO = 2; atributo

9. Constantes
La palabra clave “final” es un modificador que se puede usar al declarar
variables para evitar cualquier cambio posterior en los valores que inicialmente
se les asignaron.
● Nota: Esto es útil cuando se almacena un valor fijo en un programa
para evitar que se altere accidentalmente.
Las variables creadas para almacenar valores fijos de esta manera se conocen
como “constantes“, y es convencional nombrar constantes con todos los
caracteres en mayúsculas, para distinguirlas de las otras variables.
Ejemplo:
public static void main(String[] args) {
// inicializamos tres constantes enteras
final int CONSTANTE1 = 10;
}

10. Comentarios de línea y de bloque
En java tenemos 3 tipos de comentarios que son:
1. Comentarios de Línea:
Los comentarios de línea nos permite realizar un comentario escrito en la misma
línea, se representa //.
Ejemplo:
public class Example {

System.out.println("Hola Mundo"); //Imprime Hola Mundo en consola
}

2. Comentarios en bloque o multilínea:
Los comentarios en bloque o multilínea nos permite escribir un comentario en
varias líneas. Se inicia con /* y se termina con */.
Ejemplo:

System.out.println("Hola Mundo");
/*Este es un
ejemplo de comentario de
bloque o multilínea*/
}
}

3. Comentarios de documentación (Javadoc):
Los comentarios de documentación son muy semejantes a los comentarios
multilínea. Con la diferencia que se inician con /** y en cada principio de línea
aparecerá un *. Para cerrarlos, se cierran igual que los comentarios de bloques
*/.
Ejemplo:

System.out.println("Hola Mundo");
/** Este es un ejemplo de comentario
* de documentación o también conocido
como comentario Javadoc*/
}
}

11. Operadores aritméticos
Los operadores aritméticos en Java son los operadores que nos permiten
realizar operaciones matemáticas: suma, resta, multiplicación, división y
módulo.
Los operadores aritméticos en Java son:
Operador Descripción
+ operador suma
- operador resta
* operador multiplicación
/ operador división
% operador modulo

11. Operadores aritméticos
Los operadores aritméticos en Java los utilizaremos entre dos literales o
variables y el resultado, normalmente lo asignaremos a una variable o bien lo
evaluamos.
variable = (valor1|variable1) operador (valor2|variable2);
Así podemos tener los siguientes usos en el caso de que queramos asignar su
valor.
suma = 3 + 7; // Retorna 10
resta = 5 - 2; // Retorna 3
multiplicacion = 3 * 2; // Retorna 6
division = 4 / 2; // Retorna 2
resto = 5 % 3; // Retorna 2
Ten en cuenta que pueden ser valores o variables:
suma = var1 + 7; // Sumamos 7 al valor de la variable var1

resta = var1 - 2; // Restamos 2 al valor de la variable var1

12. Operadores de igualdad y relacionales
Los operadores de igualdad y relacionales en Java son aquellos que nos
permiten comparar el contenido de una variable contra otra atendiendo de esta
manera si son variables con un valor igual o distinto o bien si los valores son
mayores o menores.
El listado de operadores de igualdad y relacionales en Java es:
== igual a
!= no igual a
> mayor que
>= mayor o igual que
< menor que
<= menor o igual que

12. Operadores de igualdad y relacionales
● Operadores de Igualdad:
Mediante los operadores de igualdad podemos comprobar si dos valores son
iguales (operador ==) o diferentes (operador !=).
La estructura de los operadores de igualdad es la siguiente:
vble1 == vble2
vble1 != vble2
● Operadores relacionales:
Permiten comprobar si un valor es mayor que vble1 > vble2
(operador >), menor que (operador <), mayor o igual vble1 < vble2
que (>=) y menor o igual que (<=). vble1 >= vble2
vble1 <= vble2
Al final el operador lo valida entre dos valores o
variables con la estructura:

13. Operadores lógicos
En Java disponemos de los operadores lógicos habituales en lenguajes de
programación como son: “es igual”, “es distinto”, menor, menor o igual, mayor,
mayor o igual, and (y), or (o) y not (no). La sintaxis se basa en símbolos como
veremos a continuación y cabe destacar que hay que prestar atención a no
confundir == con = porque implican distintas cosas.
== es igual a
!= es distinto a
<, <=, >, >= Menor, menor o igual, mayor, mayor o igual
&& Operador and (y)
|| Operador or (o)
! Operador not (no)

14. Operadores de incremento y decremento
Java posee el operador incremental unario ++, y el operador decremental unario
--, para incrementar o decrementar el valor de una variable en 1,
respectivamente. A continuación, en la siguiente tabla se describe cada uno de
estos operadores.
Operadores Significado
Incrementa x después de cualquier operación con ella
x++ (post-incremento)
Incrementa x antes de cualquier operación con ella

++x (pre-incremento)
Decrementa x después de cualquier operación con

x-- ella (post-decremento)
Decrementa x antes de cualquier operación con ella

--x (pre-decremento)

Las siguientes expresiones son equivalentes:
Modo normal Modo con operador
x=x+1; x++;
s=s-1; s--;
Los operadores pueden estar antes o después del operando. Por ejemplo:
s = s+1; es igual a:
++s;
s++;

Hay que tener precaución al usar los operadores dentro de una expresión. Si
operador incremento o decremento precede a su operando, java realiza
operaciones de incremento o decremento antes de usar el valor del operando.
Por el contrario, si el operador está luego del operando, java usa el valor del
operador antes de incrementarlo o decrementarlo.
Ejemplo:
Expresión Expresión equivalente Resultado
x = 11; x++; x=11; x = x+1; x = 12;

x = 12; y = ++x; x=12; x = x+1; y = x; y = 13;
x = 10; y = 6 * (++x); x=10; x = x+1; y = 6 *x; y = 66;
x = 10; y = 6 * (x++); x=10; y = 6 *x; x = x+1; y = 60;

15. Prioridad de operadores
Cuando se construyen expresiones es importante tener en consideración, la
prioridad de los operadores. La prioridad define el orden en el que se ejecutan
las operaciones.
() Paréntesis
+, - Operadores de signo (no hace referencia a suma y resta)
++, -- Incremento y decremento
*, /, % Operadores: multiplicación, división y módulo.
+, - Operadores: suma y resta
<, >, <=, >=, ==, != Desigualdades
! Diferente
&&, || Operadores: y , o
= Igual

Si se tiene una expresión, que contiene operadores con la misma prioridad,
Java evalúa la expresión de izquierda a derecha. Si hay paréntesis lo que está
dentro se evalúa primero. Si hay paréntesis internos, lo que está en su interior
se evalúa primero que lo que está en los externos.
Ejemplo: x = (2 + 3) * 8
Por precedencia de operadores, se efectúa primero (2+3) y por último se realiza
el producto, por lo tanto:
x = (2 + 3) * 8
x = (5) * 8
x = 40

A continuación se muestra un segundo caso para la evaluación de la expresión.
x = (2+5+5) + (4+1)
Según la precedencia de los operadores, se debe evaluar primero las

expresiones con paréntesis, estas son (2+5+5) y (4+1), en el caso de (3+5+5),
como se tiene el mismo operador (+) dentro de la expresión, estos operandos,
se evalúan de izquierda a derecha, por lo tanto la forma en que es evaluada la
expresión es:
x = (2+5+5) + (2+1)
x = (7+5) + (3)
x = 12 + 3
x = 15
Actividad: Hallar el valor de z de las siguientes expresiones:

z = 1 + (10+6*6+7) + (18/2) / 3 / 1 + 2
z = 12 / 3 +3 - (10 / 4 * 2 -3) + 8 / 3 + (10-3+5)

Actividad
1. Hallar el valor de X de las siguientes expresiones:
a) 22 + X = 36 b) 16 – X= 9
X=? X=?
c) 11 - X = 4 d) X*4 = 38
X=? X=?

Actividad
2. Dada la expresión realice el despeje de la x:
a) x + 15 = 17 b) (2x – 4) = x + 7
X=? X=?
c) 15x – 10 = (5x – 12)/2 d) 6(x – 6) – 20 = 2(x – 5) – 3

X=? X=?
e) 6(x – 2) – 6 (x – 2) = 3(3x – 4)
X=?

16. Promoción automática y casting
Cuando se calcula una expresión que involucre operandos de tipo byte o short,
Java efectúa una promoción a int. También se debe considerar que si hay un
operador long, la expresión completa se promociona a este tipo de dato. Si un
operador es float, entonces toda la expresión completa se promociona a float.
Igual ocurre si es double. Por ejemplo si se tiene:
byte a = 10, b = 40, j = 100;
int d = a * b / d;
El resultado de a * b se calcula en entero y no en byte , esto ocurre porque tal
operación puede salirse del rango
de los byte. Observe el siguiente ejemplo: byte b = 2, resultado; resultado = b *
6; // No se puede efectuar porque un entero no se puede asignar un byte.
Si se intenta multiplicar un byte b por 6 que es un entero el resultado será un
entero, por tal razón este valor no podría asignarse a un byte. Si se requiere que
el resultado se almacene en un byte, será necesario realizar una conversión
explícita (casting):
byte b = 2, resultado;
resultado = (byte)( b * 6 );

Actividad: Identificar el resultado de las siguientes expresiones
int a=5, b=8, c=7; Opciones de respuesta

double d=3;
int resultado= (a*d)-7*b+4/c; a) -40.57 b) -41
c) -36 d) No corre

double d=3;
int resultado=((int) (a*d))-7*b+3/c; a) -40.57 b) -41
c) -36 d) Ninguna

double d=3;
int resultado=((int) (a*d))-7*b+3%c; a) -40.57 b) -39
c) -38 d) Ninguna

17. Expresiones aritméticas
Este tipo de operadores permite realizar operaciones. Ellos son: + (suma), -
(resta), * (multiplicación), / (división), % (módulo o residuo de la división entera).
Se debe tener en cuenta que en Java entero dividido entre entero da como
resultado otro entero. por ejemplo:
int a = 20;
El programa debería imprimir
int b = 3;
7.66666666667 pero da 7.
double res = ( a + b ) / 3;
Si lo que se desea es conservar estos decimales se pueden aplicar las

siguientes 3 soluciones:
int a = 20;
int a = 20; int a = 20;
int b = 3;
int b = 3; int b = 3;
double auxiliar = a + b;
double res = (( a + b )* 1.0) / 3; double res = ( a + b ) / 3.0;
double res = auxiliar / 3;

18. Expresiones relacionales
Estos operadores dan como resultado un valor de tipo lógico (true o false). Los
operadores lógicos son:
Operador Significado
== (igualdad)
!= (diferente)
> (mayor que)
< (menor que)
>= (mayor o igual)
<= (menor o igual)

18. Expresiones relacionales
1. Si es mayor de edad y salario excede 10350000.
2. Si sexo es Masculino y edad es igual a 25.
3. Si número es par y número es divisible por 100.
4. Si celular está encendido y compartir internet está activo.
5. Si saldo de la tarjeta es igual a $1000000 y pago de seguro es menor
$1000000.

19. Expresiones lógicas
Estos operadores trabajan sobre operandos de tipo lógico para producir un
resultado lógico (false o true). La Tabla 10 presenta los diferentes tipos de
operadores lógicos.
Operador Significado
&& AND
|| OR
! NOT
El operador AND (&&) da como resultado true si los dos operandos son
verdaderos. De lo contrario da como resultado false.
Operando 1 Operador Operando 2 Salida
false && false false
false && true false
true && false false
true && true true

19. Expresiones lógicas
El operador OR (||) da como resultado verdadero cuando al menos uno de sus
operandos es verdadero.
Operando 1 Operador Operando 2 Salida

false || false false
false || true true
true || false true
true || true true
Si la variables está en false, el operador negación cambia el valor de la variable

a true. Si está en true lo vuelve false.

20. Programación secuencial
Las instrucciones de un programa se ejecutan por defecto en orden
secuencial. Esto significa que las instrucciones se ejecutan en secuencia, una
después de otra, en el orden en que aparecen escritas dentro del programa.
Ejemplo:
Inicio Tenemos dos entradas num1 y num2, dos
operaciones: realización de la suma y del
num1 producto de los valores ingresados y dos
salidas, que son los resultados de la suma y
num2 el producto de los valores ingresados.
sum = num1 + num2
producto= num1 * num2
suma, producto
Fin

20. Programación secuencial
En java sería: import java.util.Scanner;

Inicio
num1 Scanner teclado=new Scanner(System.in);
int num1, num2, sum, producto;
num2 System.out.println("Ingrese el primer valor:");
num1=teclado.nextInt();
System.out.println("Ingrese el segundo valor:");
sum = num1 + num2
num2=teclado.nextInt();
sum=num1 + num2;
producto= num1 * num2
producto=num1 * num2;
System.out.println("La suma de los dos valores es:" + sum + '\n');
suma, producto
System.out.println("El producto de los dos valores es:" + producto);
}
Fin

Actividad
1. Escribir un programa que realice la carga del lado de un cuadrado, mostrar
por pantalla el perímetro del mismo.
2. Escribir un programa en el cual se ingresan cuatro números, calcular e
informar la suma de los dos primeros y el producto del tercero y el cuarto.
3. Escribir un programa que lea cuatro valores numéricos e informar su suma
y promedio.
4. Escribir un programa que pida el ingreso del precio de un artículo y la
cantidad que lleva el cliente. Mostrar lo que debe abonar el comprador.

Referencia Bibliográficas
● Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica de

programación en Java. Elizcom S.A.S.

54

Introducción A La Programación en Java

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

Introducción A La Programación en Java

Cargado por

Copyright:

Formatos disponibles

Programación I

Introducción a la programación en Java

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 2

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 3

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 4

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 5

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 6

● Los tipos de datos enteros representan un intervalo de los números

Tipos de Datos Enteros

short -32768 a 32767 16

int -2147483648 a 2147483647 32

long -9223372036854775808 a 9223372036854775807 64

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 7

double 1.7E-308 a 1.7E308 64

● El tipo de dato caracter, usa la codificación Unicode. Esta codificación

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 8

Tipos de Datos Boolean

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 9

125.900,99 Precio () int

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 10

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 11

short short var2

int int var3;

long long var4;

float float num1 = 2.7182f;

double double num2 = 2.125d;

char char letra = 'a';

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 12

'\n' Salto de línea.

'\t' Permite un salto al siguiente tope de tabulación.

'\b' Retrocede el cursor en un espacio.

'\' Se usa para mostrar el carácter '.

'\”' Se usa para escribir una comilla doble (“).

'\'' Se usa para escribir una comilla simple (').

'\\' Se usa para mostrar el carácter back-slash (\)

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 13

byte - Byte ﬂoat - Float

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 14

Clase Descripción crear objeto

La clase Double encierra un dato

Encierra un tipo de dato primitivo

Nota: La clase String permite expresar un conjunto de caracteres (cadena).

Ejemplo: String direccion = "Carrera 15 # 10 11";

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 15

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 16

String nombre= "Juan Jose";

A un String se le puede concatenar cualquier tipo de dato primitivo.

String nombre= "Juan Jose";

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 17

int edad = 30;

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 18

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 19

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 20

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 21

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 22

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 23

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 24

public final static double PI = 1416;

public final static int CARRO = 1; Representan el dominio de un

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 25

Referencia: Cardona, S., Castro, L. y Jaramillo, S. (2017). Lógica 26

public class Example {

public static void main(String[] args) {