Universidad Abierta y a Distancia de México

Ingeniería en Desarrollo de Software

Programación Orientada a Objetos 1

Unidad 2. Métodos y estructuras de control

Actividad 1. Tipos de variables y constantes

Docente en Línea: Claudia Erika González Gómez

Elaborado por:
Ricardo García López
Matrícula: ES172008251
Grupo: DS-DPO1-1901-B2-008
2º Semestre
Bloque 2

Iztapalapa, CDMX a 26 de abril de 2019

 Actividad 1. Tipos de variables y constantes

Objetivo:
Reflexionar acerca de las diferencias existentes entre la programación estructurada y
la programación orientada a objetos (POO).

Instrucciones / Descripción de la actividad:

1. Realiza un mapa mental donde se identifiquen las diferencias que existen entre
variables y constantes, así como los tipos de variables que utiliza la POO. El archivo
se entregará en PDF.
2. Posteriormente realiza un ejemplo de la aplicación en Java (Netbeans) que utilice 4
variables de diferentes tipos y aplica una constante. Posteriormente explica las
líneas de código que utilizaste.
3. Integra el resultado de tu investigación al documento donde realizaste el mapa
mental, agrega carátula y los datos de identificación completos, posteriormente
guarda tu actividad con el nombre DPO1_U2_A1_XXYZ. Sustituye las XX por las
dos primeras letras de tu primer nombre, la Y por tu primer apellido y la Z por tu
segundo apellido.
4. Ingresa al Foro y responde al tema abierto “diferencia entre variables primitivas
y variables referenciadas” y redacta en el cuadro de texto una breve reseña de tu
actividad no mayor a cinco renglones y a continuación adjunta tu archivo para
enviarlo a tus compañeros y a tu docente en línea. Al finalizar da clic en enviar.
5. Ingresa a la participación de por lo menos de dos de tus compañeros, analiza su
actividad e identifica al menos una semejanza y una diferencia con la actividad que
realizaste y realiza una aportación mencionando la semejanza y diferencia.
6. Como parte de una segunda participación, redacta tus conclusiones
considerando las ventajas, desventajas, características y aplicaciones de las
variables y constantes.
7. Recuerda consultar la Rúbrica general de participación en foros, y seguir las líneas
de discusión planteadas por tu Docente en línea.
8. Espera y atiende la retroalimentación correspondiente y las indicaciones de tu
docente en línea.
 Actividad 1. Tipos de variables y constantes
Contenido
Actividad 1. Tipos de variables y constantes ...................................................................................................................................
Introducción ..........................................................................................................................................................................................
Exposición / Contenido ......................................................................................................................................................................
Conclusiones ........................................................................................................................................................................................
Referencias............................................................................................................................................................................................

Introducción
En cualquier lenguaje de programación se hace ingresa, almacena y gestiona información. Esta información
son los datos sobre los que el programa trabajará y deben almacenarse temporalmente en la memoria del
ordenador. Esta información se divide comúnmente en dos tipos que son las variables y las constantes. Las
constantes son representaciones de información que tienen un valor fijo durante la ejecución del programa y
pueden ser cualquier tipo de datos como un dígito, un número, una letra, un símbolo, una o varias palabras,
una frase, un enunciado, un párrafo, etc. Por ejemplo, “777”, “π”(pi), “¡Peligro!”, “esta oración es inmodificable,
salvo que le quiten el termino final en el principio de la declaración de la variable”. Por otra parte, están las
variables que son contenedores de información en los que es posible cambiar su valor durante la ejecución
del programa. El lenguaje de programación java maneja 2 clasificaciones de Variables que son: Las
Variables Primitivas y las Variables Referenciadas.
Exposición / Contenido
1. Realiza un mapa mental donde se identifiquen las diferencias que existen entre variables y constantes, así como los tipos de variables
que utiliza la POO. El archivo se entregará en PDF.

Se declaran de la siguiente
forma:
Tipo +Nombre+Valor(opcional)
Float Atvio (=50);
En conjunto son lo que se
denomina "datos".
Espacio de la memoria Variables primitivas. Son También se les puede agregar
que puede guardar un aquellas que no son objetos, no un modificador de visibilidad:
valor y luego puede conllevan método alguno y no public, private o protected
guardar otro valor. necesitan ser invocadas. private Float Atvio (=50);

Variables
Java maneja dos
O modificador de acceso:
clasificaciones de
variables: static
Para crear atributos estáticos de
a) Variables primitivas la clase
DIFERENCIA ENTRE b) Variables referenciadas
VARIABLES Y
CONSTANTES Variables referenciadas. Se declaran de la siguiente
Necesitan una invocación para forma:
ser creadas debido a que están
TipoReferencia+Nombre
asociadas a un objeto, o son la
instancia de una clase. String variableObjeto;

Se declaran igual que una

variable, anteponiendo la
palabra Final:
Espacio de la memoria
que guarda un valor y ya Final Float Atvio=50;
Sólo existe un tipo de
Constantes no se puede modificar
constante
(salvo al modificar su Diferencia Static y Final
declaración).
Static crea atributos
ESTATICOS de la clase
Final crea constantes
2. Posteriormente realiza un ejemplo de la aplicación en Java (Netbeans) que utilice 4
variables de diferentes tipos y aplica una constante. Posteriormente explica las líneas de
código que utilizaste.
Emplee 3 variables referenciadas del tipo Scanner, 3 variables primitivas de tipo float y una
de tipo integer, más una constante

package dpo1;

import java.util.Scanner;

class Main {

//Variables referenciadas
private static Scanner peso;
private static Scanner altura;
private static Scanner puntaje;

public static void main(String[] args)

{
//Variables primitivas
float IMC, Kg, metro;
int FCQTr;

//Constante
final int Días_sesiones=12;

//Se crea una variable referenciada (peso) que después se guarda en una variable
primitiva (Kg)
System.out.println("Ingresa el peso (en kilogramos)");
peso = new Scanner(System.in);
Kg = peso.nextFloat();

//Se crea una variable referenciada (altura) que después se guarda en una variable
primitiva (metro)
System.out.println("Ingresa la altura (en metros)");
altura = new Scanner(System.in);
metro = altura.nextFloat();

//Se realizan cálculos con variables primitivas (Kg, metro) para dar origen a una
nueva variable primitiva (IMC)
IMC = (Kg/(metro*metro));
System.out.println("El IMC del paciente es "+IMC);

//Se realiza un balance decisional y establecen categorías mediante la sentencia

IF-ELSE y la variable primitiva calculada (IMC)
if(IMC>=25 && IMC<=29.9)
{
System.out.println("El IMC del paciente indica que padece sobrepeso");
}
else
{
if(IMC>=30 && IMC<=34.9)
{
System.out.println("El IMC del paciente indica que padece obesidad grado 1");
}
else
{
 if(IMC>=35 && IMC<=39.9)
{
System.out.println("El IMC del paciente indica que padece obesidad grado
2");
}
else
{
System.out.println("El paciente no es apto para esta investigación");
}
}
}

//Se crea una variable referenciada (puntaje) que después se guarda en una variable
primitiva (FCQTr)
System.out.println("Ingresa el puntaje obtenido en la prueba FCQ-T-r ");
puntaje = new Scanner(System.in);
FCQTr = puntaje.nextInt();

//Se realiza un balance decisional y establecen categorías mediante la sentencia

IF-ELSE y la variable primitiva calculada (FCQTr)
if(FCQTr>40)
{
System.out.println("La prueba indica que el paciente padece de food craving");
}
else
{
System.out.println("El paciente no es apto para esta investigación");
}

//Se realiza un balance decisional y establecen categorías mediante la sentencia

IF-ELSE y la variables primitivas: FCQTr e IMC
if(FCQTr>40 && ((IMC>=25 && IMC<=29.9 )||(IMC>=30 && IMC<=34.9)||(IMC>=35 &&
IMC<=39.9)))
{
System.out.println("El paciente es apto para esta investigación");

//Se emplea una constante para establecer el número de sesiones y que no sea
modificable
System.out.println("El número de sesiones dentro de esta investigación son: "+
Días_sesiones);
}
else
{
System.out.println("El paciente no es apto para esta investigación");
}
}

}
Conclusiones (Opinión personal)
Básicamente, tanto las variables como las constantes conllevan semejante declaración, sin embargo, suele
diferir en algunos aspectos. Partiendo de la declaración de una variable primitiva que es
TipoPrimitiva+Nombre+Valor(Opcional);
Por ejemplo:
Float Calificación (=100);
La diferencia con una variable referecianda (o de objeto) es que en su declaración conlleva un
TipoReferencia como tipos de la biblioteca estándar de Java (String, Scanner, TreeSet, ArrayList, etc.),
definidos por el usuario, arrays y tipo envoltorio (o wrapper como: Byte, Short, Integer, Long, Float, Double,
Character o Boolean). Por tanto, queda de la siguiente forma:
TipoReferencia(o de objeto)+Nombre;
Por ejemplo:
String DiscursoSuicida;
Por último, la diferencia con una constante, es que se antepone la palabra Final quedando de la siguiente
forma:
Final+TipoPrimitiva o Referencia+Nombre+Valor;
Por ejemplo:
Final Float Calificación (=100);
Final String Boolean=True;
Ningun tipo de dato es mejor o peor que los demás, ya que su aplicación depende del problema que se
quiera resolver mediante un software específico. Por ejemplo, cuando se quiera utilizar valores constantes
(por ejemplo, π(Pi)) entonces se tendrá que emplear la declaración de una constante; cuando se quieran
utilizar variables primitivas para cálculos numéricos (por ejemplo, base, altura, peso, etc.) se tendrá que
realizar una declaración de variable primitiva; y cuando se necesiten emplear variables referenciadas (por
ejemplo, scanner, array y double) pues procede con una declaración de variable referenciada.
En todo caso, enseguida dejo una imagen que ejemplifica la división entre variables primitivas y
referenciadas.
Referencias
Joyanes A., L. (2008). Fundamentos de Programación: Algoritmos, estructura de datos y objetos (4° ed.).
España: McGraw-Hill Education.
García H., E. (2013. 23 de mayo). Literales en Java. Variables y constantes en Java. Programación Java.
Recuperado el día 26 de abril de 2019 de la URL,
https://puntocomnoesunlenguaje.blogspot.com/2012/04/literales-variables-y-constantes.html
Joyanes A., L. & Zahonero M., I. (2014). Programación en C, C++, Java y UML (2° ed.) México: McGraw-Hill
Education.
Joyanes A., L. & Zahonero M., I. (2011). Programación en Java y UML. México: McGraw-Hill Education.
UnADM (s.f.). Programación Orientada a Objetos 1. Unidad 2. Métodos y estructuras de control [en línea].
Recuperado el día 26 de abril de 2019 de la URL,
https://unadmexico.blackboard.com/bbcswebdav/institution/DCEIT/Bloque2/DS/02/DPO1/U2/Unidad_2_
Metodos_y_estructuras_de_control.pdf