Programación 1

Programa, variables, constantes y operadores

¿Dónde vamos a trabajar?
Sistema operativo

Programa base de la computadora.

Las funciones básicas son:

● administrar los recursos del sistema de computación,

● hacer de interfaz entre los dispositivos de hardware y los programas de
usuario,
● organizar los archivos y directorios
 Programa
Conjunto de instrucciones escritas en algún lenguaje de programación. Primero se
diseña el algoritmo para resolver el problema (papel y lápiz) y luego escribimos el
programa en algún lenguaje de programación para ejecutarlo en una computadora.

Los programas de usuario se utilizan para resolver problemas.

Ejemplo: un programa que calcula los cortes en una

maderera para no desperdiciar material
 Programa de usuario

Procesamiento: Serie ordenada de

instrucciones que trabaja con los
Datos de entrada datos de entrada. Implementa un Datos de salida
algoritmo que describe la forma de
solucionar el problema.
● Teclado
● Mouse ● Pantalla
● Cámara ● Impresora
● Micrófono ● Parlantes
● Scanner ● Motor
● Microprocesador
● Sensores (humedad, luz, etc) ● Leds
● Microcontrolador
Lenguajes de programación

Existen una gran cantidad de ellos y en general se los puede clasificar de

bajo nivel o de alto nivel. También existe el lenguaje máquina. ( 0s y 1s)

Más usados: Java, JavaScript, Python, C/C++, PHP, Go, Ruby.

En este curso usaremos uno de alto nivel: JAVA

Es uno de los más usados en la industria

Lenguaje de programación JAVA

Orientado a objetos constituido por:

● Conjunto de instrucciones (println, for, while,...)

○ sumar, restar, mostrar un mensaje,...
● Conjunto de bibliotecas/librerías
● Conjunto de herramientas para el desarrollo de programas:
○ compilador de código binario que comprueba que esté bien escrito
○ generador de documentación JAVADOC
Algunos entornos que pueden usar

VS Code https://code.visualstudio.com/docs/java/java-tutorial

Codiva https://www.codiva.io/ (On Line)

Eclipse https://www.eclipse.org/downloads/
Los programas que vamos a escribir…
Todos los programas que vamos a escribir en Programación 1 tendrán la siguiente estructura:

public class Nombre_del_programa {

public static void main(String[] args) {
Sentencia 1; órdenes que se le da
Sentencia 2; a la computadora
…
Sentencia N; Orden secuencial
}
}
Instrucciones (primer programa)
public class Nombre_del_programa {
public static void main(String[] args) {
Sentencia 1;
for (int i=0;i<10;i++)
Sentencia 2;
resultado=i*i;
…
Sentencia N;
}
}
En Java es obligatorio tener al menos dos bloques delimitados por “Llaves” => {}

1. public class Nombre_del_programa (será el nombre del archivo con extensión java, ej. programa.java)
2. public static void main(String[] args): el método principal que se ejecuta primero
Estructura de un programa
Una única clase que contiene el método main() donde se resuelven los ejercicios.
Ejemplo: Comentarios (no se tienen en cuenta
al momento de la compilación y
// este programa permite resolver los ejercicios del práctico 1 ejecución del programa)
/* Comentario, con inicio y final de marca
* Los comentarios deberían contener sólo
* información relevante para la lectura y
* comprensión del programa.
Nombre de la clase y archivo: sin
*/
public class Practico1 { espacios ni caracteres especiales
public static void main(String[] args) {
System.out.println(“Hola mundo”); Nombre del método
} // fin del método main
} // fin de la clase
Estructura de un programa
● System.out.println: provista por Java para imprimir
(mostrar) un mensaje en la consola
public class Practico1 { ● Lo que escribamos entre “ “ dentro de los () se
public static void main(String[] args) { mostrará textualmente en la consola.
System.out.println(“Hola mundo”); ● El programa siempre comienza a ejecutarse por la
} // fin del método main primera línea del bloque main, continuando por las
} // fin de la clase siguientes en orden secuencial.
● En este caso es la única, así que luego de imprimir por
consola el mensaje Hola mundo, el programa finalizará.

¿Cómo harían para mostrar por consola otro texto debajo de Hola mundo?
Un problema real
Un programa para calcular el área de un rectángulo

Entrada Procesamiento Salida

dato 1: altura 3 cm área = base*altura

área = 12
dato 2: base 4 cm

¿Dónde almacenar estos datos?

Variables
● Sirven para almacenar datos durante la ejecución del programa.
● Son sectores en la memoria de la computadora.
● El valor puede (debería) cambiar durante la ejecución del
programa.

Ejemplo:
int altura=120;
int base=208;
float resultado=base*altura/2;
altura=22;
base=547;
…
Nombre de variables en JAVA

● El nombre es lo que la identifica y permite referenciarla.

● Un nombre comienza por una letra, un carácter de subrayado (_)
o un carácter de peso($). Ojo con los acentos!!!
● No hay límite máximo de caracteres para un nombre de variable.
● Java es case sensitive, se distinguen las mayúsculas de las
minúsculas:
○ casa, CASA y cAsA son tres variables diferentes.
Tipo de una variable
Una variable además del nombre, tiene un tipo que define los valores que
puede almacenar y las operaciones que se pueden realizar con ella.
Dato es todo con lo que opera un programa. Está asociado a una variable y
ésta es la que se manipula para procesarlo.

Ejemplo:
int edad=25;
Dato / Valor
Tipo primitivo Nombre de variable
Tipos
Se dividen en dos grupos:
Tipos primitivos
Declaración de variables
● Toda variable debe declararse antes de ser usada en el código de
un programa en Java.
● En la declaración de una variable debe indicarse el identificador
(nombre) y el tipo de dato asociado.

tipo_de_dato ident_1, ident_2, . . . , ident_n;

Ej: int nro;

double x, y;
int z;
 Ejemplo 1
// Comentario: ejemplo de declaración de variables
public class Clase_1_Ejemplo_1{
public static void main(String[] args) {
// declaración de la variable edad de tipo int, puede tomar valores enteros
int edad;
// declaración de las variables altura y peso de tipo double, pueden tomar
// valores reales
double altura, peso;
// declaración de las variable existe de tipo boolean, puede tomar valores
// booleanos (true o false)
boolean existe;
}
}
 Ejemplo 2
// Comentario: ejemplo de declaración de variables y asignación de valores
public class Clase_1_Ejemplo_2{
public static void main(String[] args) {
//antes de usar variables hay que declararlas
int edad;
double altura, peso;
boolean existe;
//estas variables pueden tomar valores según los tipos declarados
edad = 30;
altura = 1.7;
existe = false;
peso = 75.5;
}
}
 Ejemplo 3
// Comentario: ejemplo de declaración de variables y asignación de valores
public class Clase_1_Ejemplo_3{
public static void main(String[] args) {
int edad;
float peso;
// se puede asignar un valor a una variable en la declaración
boolean existe = true;
int numero=30;
// una variable puede tomar el valor de otra variable de igual tipo
edad = numero;
// 75.5 es un valor double por defecto, esto es conocido como casting
peso = (float) 75.5;
}
}
Salida por consola
● Para imprimir por consola un texto o el valor de una variable se puede utilizar la sentencia
System.out.println() o System.out.print()
● El texto entre doble comillas “ ” a colocar entre los paréntesis de System.out.println() puede
concatenarse con otro texto utilizando +

System.out.println("El valor " + "es: ");

● El texto con el que se va a concatenar puede estar entre doble comillas (otro texto) o puede
ser una variable de cualquier tipo. Para una variable que no sea de tipo texto dentro
System.out.println() se toma su valor y se lo convierte automáticamente en texto.

System.out.println("El valor es: " + entero);

 Ejemplo 4
public class Clase_1_Ejemplo_4{
public static void main(String[] args) {
double altura, peso;
boolean existe;
existe = true;
peso = 75.5;
//imprime dos textos concatenados
System.out.println("El valor de " + "peso es: ");
//imprime el valor de peso convertido en texto
System.out.println(peso);
//imprime un texto concatenado con el valor de peso convertido en texto
System.out.println("El valor de peso es: " + peso);
}
}
 Ejemplo 5
public class Clase_1_Ejemplo_5{
public static void main(String[] args) {
char caracter1;
caracter1 = 'c';
char caracter2;
//una variable caracter2 toma el valor del caracter digito '1'
caracter2 = '1';
//una variable numero toma el valor del numero entero 1
int numero = 1;
System.out.println("El valor de caracter2 es: " + caracter2);
System.out.println("El valor de numero es: " + numero);
}
}
 Constantes
● Constantes o variables finales: también sirven para almacenar datos
pero no pueden modificarse posteriormente.
● Por ejemplo, el número PI y la aceleración de la gravedad G.
● Son similares a las constantes empleadas en otros lenguajes.
● Una vez inicializada su valor no puede ser modificado

Ej:

final double PI = 3.1415926;

final double g = 9.81;
Ejemplo constantes
/**
* Variables y constantes
*/
public class ejemploConstantes {
public static void main(String[] args) {
final double g = 9.81; // constante
double altura;
int edad = 20;
boolean existe = true;
float peso = (float) 56.5; //56.5 es double
char caracter = 'c';
altura = 1.87;
peso = (float) 60.0;
g=9.5; // error!!!
}
}
 Literales
● Un literal es una constante que se puede asignar a una variable.
● Las constantes literales booleanas son false y true.
● Las constantes literales de tipo carácter aparecen entre comillas simples.
Letras mayúsculas (‘A’, ‘B’, ‘C’,...), minúsculas (‘a’, ‘b’, ‘c’,...), signos de
puntuación (‘,’ ‘;’ ‘:’ ...), dígitos, símbolos especiales (‘#’, ‘&’, ‘%’,...)
● y literales que son caracteres de control:
Literal Valor
\b Retroceso o backspace
\t Tabulación
\n Nueva línea (enter)
\f Salto de página
 Ejemplo 6
/* Comentario: uso de literales en la salida por consola
*/
public class Clase_1_Ejemplo_6{
public static void main(String[] args) {
System.out.println ("Hola Mundo. Estoy programando.");
System.out.println ("Hola Mundo. \nEstoy programando.");
System.out.println ("Hola Mundo. \n\tEstoy programando.");
System.out.println ("Hola Mundo. \n\t\tEstoy programando.");
}
}
Palabras reservadas
Palabras que no se pueden usar para nombres de variables ni constantes y
son para otro uso.
Carga de una variable entera por teclado
import java.io.BufferedReader; //biblioteca que contiene operaciones de E/S
import java.io.InputStreamReader; //biblioteca que contiene operaciones de E/S Por ahora
solo vamos a
public class programaCargaUnEntero { usarlas
public static void main(String[] args) {
int entero;
try { //try define un bloque de manejo de posibles excepciones (errores)
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
System.out.println ("Ingrese un valor entero: ");
entero = Integer.valueOf(entrada.readLine());
System.out.println("Entero ingresado : " + entero);
}
catch (Exception exc ) { //se ejecuta si ocurre algún error de lectura
System.out.println( exc ); bloque try-catch, se usa para
} capturar excepciones cuando
} ocurre un error.
}
Ejemplo parte 1/6 Vayamos por partes…

Entrada y salida desde consola, importación de bibliotecas

Una biblioteca es un conjunto de utilitarios que se acceden

mediante sentencias para hacer operaciones predefinidas.

import java.io.BufferedReader;
import java.io.InputStreamReader;

● Carga desde teclado de variables de distinto tipo a través de la

sentencia System.in … entrada = new BufferedReader(new InputStreamReader(System.in));
● Salida/impresión de variables a través de la sentencia
System.out System.out.println ("Ingrese un valor entero: ");
 Ejemplo parte 2/6

Agregar las bibliotecas a utilizar y comenzar a definir las variables

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class programaCargaUnEntero {

public static void main(String[] args){
int entero; Poner nombres representativos
} que nos den una idea de que se
trata el programa o la variable
}
 Ejemplo parte 3/6

Una vez definidas las variables agregar el bloque try-catch para manejo de errores
de ingreso de datos
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class programaCargaUnEntero {

public static void main(String[] args){
int entero;
try { //try define un bloque de manejo de posibles excepciones
}
catch (Exception exc ) { //se ejecuta si ocurre algún error de lectura
System.out.println(exc);
}
}
}
Ejemplo parte 4/6
Crear el buffer donde se almacenarán los datos por teclado hasta que sean
consumidos.
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class programaCargaUnEntero {

public static void main(String[] args){
int entero;
try { //try define un bloque de manejo de posibles excepciones
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
}
catch (Exception exc ) { //se ejecuta si ocurre algún error de lectura
System.out.println(exc);
}
}
}
 Ejemplo parte 5/6
Pedir el ingreso por teclado y consumir el buffer asignando lo ingresado a una variable.
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class programaCargaUnEntero {
public static void main(String[] args){
int entero;
try { //try define un bloque de manejo de posibles excepciones
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
System.out.println ("Ingrese un valor entero: ");
entero = Integer.valueOf(entrada.readLine());
}
catch (Exception exc ) { //se ejecuta si ocurre algún error de lectura
System.out.println(exc);
}
}
}
Ejemplo parte 6/6
Generar la salida del programa por consola
import java.io.BufferedReader;
import java.io.InputStreamReader; Indentar el código para mejor
public class programaCargaUnEntero { legibilidad usando la tecla Tab
public static void main(String[] args){
int entero;
try { //try define un bloque de manejo de posibles excepciones
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
System.out.println ("Ingrese un valor entero: ");
entero = Integer.valueOf(entrada.readLine());
System.out.println ("Entero ingresado: " + entero);
}
catch (Exception exc ) { //se ejecuta si ocurre algún error de lectura
System.out.println(exc);
}
}
}
Cargando más variables de otros tipos
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class programaCargaNVariables { // programa carga más variables
public static void main(String[] args){
String cadenaCaracteres; Poner comentarios en el
float valorFlotante; código para saber lo que hace.
double valorDouble; Es muy fácil olvidarse
int entero; después de un tiempo y de
char unCaracter; codear muchas líneas.
try {
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
// ingresando datos por teclado
System.out.println ("Ingrese una cadena de caracteres: ");
cadenaCaracteres = entrada.readLine();
System.out.println ("Ingrese un valor con decimal (float): ");
valorFlotante = Float.valueOf(entrada.readLine());
System.out.println ("Ingrese un valor con decimal (double): ");
valorDouble = Double.valueOf(entrada.readLine());
 Cargando más variables de otros tipos (cont.)

System.out.println ("Ingrese un valor entero: ");

entero = Integer.valueOf(entrada.readLine());
System.out.println ("Ingrese un caracter: ");
unCaracter = entrada.readLine().charAt(0);
// mostrando por la consola lo que se ingresó
System.out.println("Cadena de caracteres ingresada: " + cadenaCaracteres);
System.out.println("Valor decimal ingresado (float): " + valorFlotante);
System.out.println("Valor decimal ingresado (double): " + valorDouble);
System.out.println("Entero ingresado: " + entero);
System.out.println("Caracter ingresado: " + unCaracter);
}
catch (Exception exc ) {
System.out.println( exc );
}
}
}
¿Qué es un operador?

● Los operadores son símbolos que indican cómo se deben manipular los
operandos.
● Los operadores junto con los operandos forman una expresión

“un operador es un elemento de programa que se aplica a uno o varios

operandos en una expresión o instrucción”
¿Qué es un operador?

● Los operadores son símbolos que indican cómo se deben manipular los
operandos.
● Los operadores junto con los operandos forman una expresión

“un operador es un elemento de programa que se aplica a uno o varios

operandos en una expresión o instrucción”

Por ejemplo:

n1 = 11 - 2 * 4; ¿Cuántos operadores
vemos acá?
¿Qué es un operador?

● Los operadores son símbolos que indican cómo se deben manipular los
operandos.
● Los operadores junto con los operandos forman una expresión

“un operador es un elemento de programa que se aplica a uno o varios

operandos en una expresión o instrucción”

Por ejemplo:

n1 = 11 - 2 * 4; ¿Cuántos operadores
vemos acá?
3 Operadores
Operadores Aritméticos
 Operador de Asignación

public class Operadores {

public static void main(String args[]) {
int i, j;
Le solemos decir “i se vuelve 7” ya que
i = 7; no lo estamos comparando
j = 3;
System.out.println(" Operador suma: i + j= " + (i + j));
System.out.println(" Operador resto: i % j= " + (i % j));
} // fin del método main
} // fin de la clase
 Operador de Concatenación

public class Operadores {

public static void main(String args[]) {
int i, j; Coloca las cadenas de caracteres
i = 7; una al lado de la otra
j = 3;
System.out.println(" Operador suma: i + j= " + (i + j));
System.out.println(" Operador resto: i % j= " + (i % j));
} // fin del método main
} // fin de la clase
Separadores

● Los separadores son fundamentales para cumplir con la sintaxis del lenguaje
de programación y definir prioridades en la ejecución de operadores.
Veamos qué sucede paso a paso
Paso 1: Declaramos las variables i y j de Consola
tipo entero
public class Operadores {
public static void main(String args[]) {
int i, j;
i = 7;
j = 3;
System.out.println(" Operador suma: i + j= " + (i + j));
System.out.println(" Operador resto: i % j= " + (i % j));
} // fin del método main
} // fin de la clase
Veamos qué sucede paso a paso
Paso 2: la variable i ahora pasa a tener Consola
valor 7
public class Operadores {
public static void main(String args[]) {
int i, j;
i = 7;
j = 3;
System.out.println(" Operador suma: i + j= " + (i + j));
System.out.println(" Operador resto: i % j= " + (i % j));
} // fin del método main
} // fin de la clase
Veamos qué sucede paso a paso
Paso 3: la variable j ahora pasa a tener Consola
valor 3
public class Operadores {
public static void main(String args[]) {
int i, j;
i = 7;
j = 3;
System.out.println(" Operador suma: i + j= " + (i + j));
System.out.println(" Operador resto: i % j= " + (i % j));
} // fin del método main
} // fin de la clase
Veamos qué sucede paso a paso
Paso 4: muestra por pantalla lo que está entre Consola
“ ” concatenado con el resultado de i + j
Operador suma: i + j= 10

public class Operadores {

public static void main(String args[]) {
int i, j;
i = 7;
j = 3;
System.out.println(" Operador suma: i + j= " + (i + j));
System.out.println(" Operador resto: i % j= " + (i % j));
} // fin del método main
} // fin de la clase
Veamos qué sucede paso a paso
Paso 5: muestra por pantalla lo que está entre Consola
“ ” concatenado con el resultado de i % j
Operador suma: i + j= 10
Operador resto: i % j= 1
public class Operadores {
public static void main(String args[]) {
int i, j;
i = 7;
j = 3;
System.out.println(" Operador suma: i + j= " + (i + j));
System.out.println(" Operador resto: i % j= " + (i % j));
} // fin del método main
} // fin de la clase
 Consola
Para probar… Operador suma: i + j= ?
Operador resto: i % j= ?
Operador multiplicación: i * j= ?
Operador división: i / j= ?
public class Operadores { Operador resta: i - j= ?
public static void main(String args[]) {
int i, j;
i = 7;
j = 3;
System.out.println(" Operador suma: i + j= " + i + j);
System.out.println(" Operador resto: i % j= " + i % j);
System.out.println(" Operador multiplicación: i * j= " + i * j);
System.out.println(" Operador división: i / j= " + i / j);
System.out.println(" Operador resta: i - j= " + i - j); ¿son todos
correctos?
} // fin del método main
} // fin de la clase
Operadores aritméticos incrementales
Operadores aritméticos incrementales (ejemplo)
Consola
public class Operadores {
public static void main(String args[]) {
int i = 7;
int j = i++;
System.out.println("i vale: " + i);
System.out.println("j vale: " + j);
} // fin del método main
} // fin de la clase
Operadores aritméticos incrementales (ejemplo)
Consola
public class Operadores {
i vale 8
public static void main(String args[]) {
int i = 7;
int j = i++;
System.out.println("i vale: " + i);
System.out.println("j vale: " + j);
} // fin del método main
} // fin de la clase
Operadores aritméticos incrementales (ejemplo)
Consola
public class Operadores {
i vale 8
public static void main(String args[]) { j vale 7
int i = 7;
int j = i++;
System.out.println("i vale: " + i);
System.out.println("j vale: " + j);
} // fin del método main
} // fin de la clase
Operadores aritméticos incrementales (ejemplo)
Consola
public class Operadores {
public static void main(String args[]) {
int i = 7;
int j = ++i;
System.out.println("i vale: " + i);
System.out.println("j vale: " + j);
} // fin del método main
} // fin de la clase
Operadores aritméticos incrementales (ejemplo)
Consola
public class Operadores {
i vale 8
public static void main(String args[]) {
int i = 7;
int j = ++i;
System.out.println("i vale: " + i);
System.out.println("j vale: " + j);
} // fin del método main
} // fin de la clase
Operadores aritméticos incrementales (ejemplo)
Consola
public class Operadores {
i vale 8
public static void main(String args[]) { j vale 8
int i = 7;
int j = ++i;
System.out.println("i vale: " + i);
System.out.println("j vale: " + j);
} // fin del método main
} // fin de la clase
Operadores aritméticos combinados

Ejemplo:
int usuario=25; // usuario vale 25
usuario+=25; // es equivalente a usuario=usuario+25, usuario pasa a valer 50
Operadores aritméticos combinados (ejemplo)

Consola
public class Operadores {
public static void main(String args[]) {
int i = 7;
i+=3;
System.out.println("i vale: " + i);
} // fin del método main
} // fin de la clase
Operadores aritméticos combinados (ejemplo)

Consola
public class Operadores {
i vale 10
public static void main(String args[]) {
int i = 7;
i+=3;
System.out.println("i vale: " + i);
} // fin del método main
} // fin de la clase
Operadores de relación

Comparan dos expresiones y siempre dan como resultado un valor

lógico (true o false)
 Operadores de relación (ejemplo)
Consola

¿i es distinto a j? true
public class Operadores { ¿c1 es menor que c2? false
public static void main(String args[]) {
int i = 7;
int j = 3;
char c1=’g’;
char c2=’a’;
System.out.println("¿i es distinto a j? " + (i!=j));
System.out.println("¿c1 es menor que c2? " + (c1<c2));
} // fin del método main
} // fin de la clase
Operadores de relación (ejemplo)

Consola

public class Operadores {

public static void main(String args[]) {
int i = 7;
int j = 3;
System.out.println("¿i es menor o igual a j? " + (i<=j));
} // fin del método main
} // fin de la clase
Operadores de relación (ejemplo)

Consola

¿i es menor o igual a j? false

public class Operadores {

public static void main(String args[]) {
int i = 7;
int j = 3;
System.out.println("¿i es menor o igual a j? " + (i<=j));
} // fin del método main
} // fin de la clase
Operadores lógicos

Se utilizan entre operadores de relación y siempre dan un resultado

true o false
Operadores lógicos (ejemplo)

Consola

public class Operadores {

public static void main(String args[]) {
int i = 7;
int j = 3;
int k = 3;
System.out.println("¿j es igual a i, o es igual a k? " + ((j==i) || (j==k)));
} // fin del método main
} // fin de la clase
Operadores lógicos (ejemplo)

Consola

¿ j es igual a i, o es igual a k? true

public class Operadores {

public static void main(String args[]) {
int i = 7;
int j = 3;
int k = 3;
System.out.println("¿j es igual a i, o es igual a k? " + ((j==i) || (j==k)));
} // fin del método main
} // fin de la clase
Ejemplo 7
¿Es necesario y
public class Clase_1_Ejemplo_7{ obligatorio resolver
public static void main(String[] args) { ambas partes del
int i, j, k; OR?
boolean resultado;
i = 7;
j = 3;
k = 2;
//(i==j)||(i==k) primero se resuelven los paréntesis (i==j) y
//(i==k), y luego ||. Finalmente el resultado queda en resultado
resultado = (i==j)||(i==k);
System.out.println("Operación: (i==j)||(i==k) " + resultado);
//((i!=j)||(i==k)) primero se resuelven los paréntesis (i!=j) y
//(i==k), y luego ||
System.out.println("Operación: ((i!=j)||(i==k)) " + ((i!=j)||(i==k)));
//((!(i!=j))||(i==k)) primero se resuelven los paréntesis (!(i!=j))
//(i==k), y luego ||. Para resolver (!(i!=j)) primero se resuelve
//(i!=j) y luego se le aplica ! (negación)
System.out.println("Operación: ((!(i!=j))||(i==k)) " + ((!(i!=j))||(i==k)));
}
}
Tablas de verdad

AND OR NOT

A B A*B A B A+B A ￢A

0 0 0 0 0 0 0 1

0 1 0 0 1 1 1 0

1 0 0 1 0 1

1 1 1 1 1 1

0 => false
1 => true
 Algunos tips
● Aplicar buenas prácticas en nuestros programas:
○ Poner nombres representativos a los programas, variables y métodos (se verá más adelante)
○ Indentar el código para que sea más legible (en JAVA no es obligatoria como en Python)
○ Inicializar las variables
○ Poner comentarios breves en el código
● Recordar que el nombre de la clase tiene que ser el mismo nombre del archivo .java que se
está definiendo (incluso respetar mayúsculas y minúsculas)
○ Ejemplo: public class programaNuevo {... } ⇒ el archivo se llamará programaNuevo.java
● Dado que Java es case sensitive prestar atención cuando declaran y luego usan
● Declarar las variables antes de su uso y en una sección que me sea fácil ubicarlas
● Usar tipos acorde a lo que se va a almacenar sin desperdiciar lugar. Cuidado con asignar a
int un char porque no generar error sintáctico sino semántico.
● Siempre que voy a usar valores que no cambian, declarar constantes con su valor