Proyec 1 Departamental

TECNOLOGICO DE ESTUDIOS SUPERIORES
DE ECATEPEC
DIVISION INGENIERIA EN SISTEMAS
COMPUTACIONALES
ACADEMIA DE INGENIERIA APLICADA
PROYECTO 1ER DEPARTAMENTAL

INTEGRANTES:
PROFESORA: Xóchitl Raquel Wong Cohen
GRUPO: 5153
ASIGNATURA: Fundamentos de programación
FECHA DE ENTREGA: 25 de Abril del 2018
1
TECNOLOGICO DE ESTUDIOS SUPERIORES
DE ECATEPEC
DIVISION INGENIERIA EN SISTEMAS
COMPUTACIONALES
ACADEMIA DE INGENIERIA APLICADA
PROYECTO 1ER DEPARTAMENTAL

INTEGRANTES:
 Cervantes Arias Roberto -----------------------
 Doroteo Felipe Edmar -----------------------
 Villagómez Salazar Brandon Alan -----------------------
PROFESORA: Xóchitl Raquel Wong Cohen
GRUPO: 5153
ASIGNATURA: Fundamentos de programación
FECHA DE ENTREGA: 25 de Abril del 2018
2
Índice
Introducción………………………………………………………………….4
Objetivo………………………………………………………………………4
Justificación………………………………………………………………….4
Análisis del problema……………………………………………………….4
Lenguaje de programación………………………………………………...5
1. Java…………………………………………………………………….....6
1.1 Estructura básica del programa……………………………….6-8
1.2 Elementos del lenguaje……………………………………….8-10
1.3 Tipos de dato…………………………………………………10-14
1.3.1 Variables y constantes…………………………………..14-18
1.3.2 Entrada y salida de datos………………………………..18-34
1.4 Errores en tiempo de ejecución……………………………34-35
1.5 Ejecución de un programa………………………………….36-38
2. C++………………………………………………………………………39
2.1 Estructura básica del programa…………………………….39-40
2.2 Elementos del lenguaje……………………………………..40-41
2.3 Tipos de dato…………………………………………………42-43
2.3.1 Variables y constantes…………………………………...44-47
2.4 Errores en tiempo de ejecución………………………………..51
3. Python……………………………………………………………………………….53
3.1 Estructura básica del programa……………………………53-54
3.2 Elementos del lenguaje……………………………………..54.56
3.3 Tipos de dato…………………………………………………….56
3.3.1 Variables y constantes……………………………………56-57
3.4 Errores en tiempo de ejecución………………………………..61
4. Conclusiones……………………………………………………..…63-64
5. referencias………………………………………………………………65
3
Introducción
Los Lenguajes de programación son aplicaciones específicas diseñadas para
crear otras aplicaciones o programas. Son programas para crear programas. Se
basan en un sistema de instrucciones preestablecidas que indican al ordenador lo
que debe realizar Son códigos integrados compuestos por un vocabulario, con una
sintaxis y una semántica que permite elaborar infinitas secuencias válidas de
tareas e instrucciones.Por medio de ello se realizara la elaboración de un reporte
con datos correctos, congruentes y ya previamente investigados con las
características de tres diferentes lenguajes de programación con sus respectivos
conceptos, definiciones y/o ejemplos. Los elementos que se mencionaran son la
estructura básica del programa, elementos de lenguaje, tipos de dato como son
las variables y constantes y entrada y salida de datos, errores en tipo de ejecución
y la ejecución de de un programa.
Objetivo:
Que el alumno conozca y aprenda la definición de los diferentes elementos en los
lenguajes de programación.
Justificación:
Lo que se hace para la realización es hacer una investigación, previa sobre las
estructuras básicas, los tipos de datos, las entradas y salidas, los errores y la
ejecución.
Análisis del problema:

investiga los diferentes tipos de elementos de tres diferentes tipos de lenguaje en
la programación.
4
Lenguaje de programación
A diario interactuamos con distintos tipos de máquinas como celulares, tablets y

computadores. Todos ellos tienen un lenguaje de programación que ayuda a
traducir las órdenes del usuario para que pueda utilizarlos.
Un lenguaje de programación es básicamente un sistema estructurado de

comunicación, similar al humano, el cual nos permite comunicarnos por medio de
signos, ya sean palabras, sonidos o gestos. Refiriéndonos a los aparatos, este
sistema está organizado para que se entiendan entre sí y a su vez interprete las
instrucciones que debe ejecutar.
El término programación se define como un conjunto de instrucciones

consecutivas y ordenadas que llevan a ejecutar una tarea específica. Dichas
instrucciones se denominan “código fuente”, el cual es único para cada lenguaje y
está diseñado para cumplir una función o propósito específico. Usan diferentes
normas o bases para controlar el comportamiento de un dispositivo y también
pueden ser usados para crear programas informáticos. En la actualidad, hay más
de cien lenguajes de programación diferentes, estos se clasifican en dos tipos
principales:
1. Lenguajes de programación de bajo nivel. Son aquellos utilizados para

controlar el hardware (partes tangibles) del aparato y dependen
directamente de la máquina, es decir, que no pueden ser usados en
aparatos diferentes para los que fueron creados. Estos lenguajes son los
que ordenan las operaciones esenciales para el funcionamiento del
dispositivo. También es conocido como código máquina. Su
funcionamiento es complejo, por lo que lo utilizan principalmente los
fabricantes de hardware. Con ellos se pueden programar tareas como
reproducción de audio o video, mostrar imágenes, realizar operaciones
matemáticas, movimiento del puntero, asignación, liberación de
memoria, entre otras.
2. Lenguajes de programación de alto nivel. Estos lenguajes son más

parecidos al humano. No dependen de la máquina y sirven
principalmente para crear programas informáticos que puedan solucionar
distintos tipos de necesidades.
5
1. JAVA (Lenguaje de programación)
¿Qué es el lenguaje de programación JAVA?
Java es un lenguaje de programación de propósito general, concurrente, orientado

a objetos que fue diseñado específicamente para tener tan pocas dependencias
de implementación como fuera posible. Su intención es permitir que los
desarrolladores de aplicaciones escriban el programa una vez y lo ejecuten en
cualquier dispositivo (conocido en inglés como WORA, o "write once, run
anywhere"), lo que quiere decir que el código que es ejecutado en una plataforma
no tiene que ser recompilado para correr en otra. Java es, a partir de 2012, uno de
los lenguajes de programación más populares en uso, particularmente para
aplicaciones de cliente-servidor de web, con unos 10 millones de usuarios
reportados.
El lenguaje de programación Java fue originalmente desarrollado por James

Gosling de Sun Microsystems (la cual fue adquirida por la compañía Oracle) y
publicado en 1995 como un componente fundamental de la plataforma Java de
Sun Microsystems. Su sintaxis deriva en gran medida de C y C++, pero tiene
menos utilidades de bajo nivel que cualquiera de ellos. Las aplicaciones de Java
son generalmente compiladas a bytecode (clase Java) que puede ejecutarse en
cualquier máquina virtual Java (JVM) sin importar la arquitectura de la
computadora subyacente.
1.1 Estructura básica del programa
Toda aplicación de consola en Java contiene una clase principal con un método (o
función) main, al igual que en C++, la función main es lo primero que se ejecuta
cuando se inicia la aplicación desde la línea de comandos. De esta forma
podemos deducir que cualquier llamado, declaración o método que no sea
llamado de manera directa o indirecta desde el método main nunca se ejecutará.
En Java el método main recibe como argumento un arreglo de String. Este arreglo
contiene los argumentos enviados por la línea de comandos para la invocación del
programa.
La estructura básica de un programa desarrollado usando Java es la siguiente:

6
Línea 1: La primer línea de nuestro código ha declarado una clase llamada
"nombre_clase", la cual es publica (public), esto quiere decir que tendrás acceso a
dicha clase, desde cualquier parte del código sin ningún tipo de complicaciones,
ahora, lógicamente tu le podrás poner el nombre que te guste mas, como veras
por la margen que tiene el código, dentro de la clase "nombre_clase" hay otras
líneas, las líneas 2, 3, 4 y 5, esto simplemente le da un poco mas de orden a
nuestro programa, nuestra línea 1, también tiene una llave abriendo "{", esto
quiere decir que todo lo que halla despues de esta llave forma parte de la clase
"nombre_clase" e indica el comienzo de las líneas de sentencia de esta, en este
caso, esta la declaración de la función main()
Línea 2: La línea numero dos contiene la declaración de la función (o metodo)

main, el cual es publica y además hay algo especial, es del tipo void (una función
puede tomar varios valores, entero, decimal, cadena de texto, entre otros) el poner
void, estamos queriendo decir que la función main no retornará nada al finalizar, si
se le pusiera por ejemplo int (entero) entonces al final de la función, esta debería
retornar algún numero o variable de tipo entero. Nuestra línea dos, también tiene
un argumento para la función main, es lo que esta dentro de los parentesis "String
args[]", esto quiere decir que la función main, debe recibir un argumento el cual es
de tipo String y es además un vector, luego hablare de los tipos de datos, no te
preocupes mucho por esto. Finalmente esta la llave abriendo "{",esto quiere decir
que lo que halla despues de esta llave forma parte de las sentencias (lo que
nuestro programa realizará durante su ejecución).
Línea 3: La línea tres contiene el bloque de sentencias, es decir, las líneas de

código que nuestro programa seguirá durante su ejecución, es de notar que cada
sentencia termina con punto y coma ";" para dar un poco de claridad, se entiende
como línea de sentencia, a las líneas de código que en ellas contienen la
declaración de alguna variable, o alguna operación,( suma resta, division, etc) o
cualquier acción, como modificar, asignar, o eliminar algo.
Línea 4: La línea numero cuatro contiene una llave cerrando "}" eso nos indica que
en esta línea termina la ejecución de alguna función (para identificar esta función
que se cierra, sigue la indentacion u seguramente sabrás cual es la que estamos
cerrando) pues bien, habrás notado que la función que esta llave esta cerrando es
la función main(), esto quiere decir que todo lo que halla despues de esta llave
formará parte de la clase "nombre_clase" pero no sera ejecutado ni formará parte
de la función main.
7
Línea 5: La línea cinco, nos indica al igual que la cuatro el final de una función o
en este caso de una clase, esta línea 5 entonces nos indica el final de la clase
"nombre_clase.
1.2 Elementos del lenguaje
Identificadores
Son los nombres que pueden tener las clases, los métodos y las variables y no
pueden contener espacios ni caracteres especiales. Estos nombres deben
respetar ciertas convenciones según la siguiente tabla:
Si el identificador está formado por más de un vocablo, a partir del segundo las
iniciales deben ser mayúsculas. Además, se recomienda que los nombres de las
clases sean sustantivos, los de los métodos verbos y que las variables expresen
con claridad su contenido.
Sentencias
Son las órdenes que se deben ejecutar en el programa y terminan siempre con un
punto y coma:
Por ejemplo:
Bloques de código
Son el principal mecanismo de encapsulamiento y se forman con un grupo de

sentencias y de otros bloques de código delimitados por una llave de apertura y
8
una de cierre (considerados metacaracteres en java, como veremos más
adelante):
{}
Por ejemplo:
Comentarios
Son líneas de texto insertas en el programa para documentarlo y facilitar su

lectura. Los tipos de comentarios más usados son:
Expresiones
Las expresiones son entidades formadas por dos o más miembros separados
entre sí por operadores que los evalúan y los relacionan.
Por ejemplo;
9
Operadores
Los operadores son signos especiales para hacer acciones específicas y son el
mecanismo con el cual los objetos interactúan relacionando los datos y
devolviendo nuevos valores; los mostraremos conforme los necesitemos. Se
clasifican así:
 Aritméticos
 De comparación y lógicos
 De asignación
Metacaracteres
Existen otro tipo de caracteres particulares que sirven para el control y la

significación puntual en las sentencias y los bloques de código:
([{\^-$|]})?*+
Palabras reservadas
Hay un grupo de palabras en Java con las cuales, entre otras cosas, se realizan
las tareas principales, se delimitan los alcances de los objetos, sus datos y sus
métodos, etc. Se pueden clasificar así y las mostraremos también conforme
avancemos:
 Tipos de datos
 Sentencias condicionales
 Sentencias iterativas
 Tratamiento de las excepciones
 Estructura de datos
 Modificadores y control de acceso
1.3 Tipos de dato
REPRESENTACIÓN INTERNA DE LOS DATOS

En el mundo real los datos que manejamos se representan mediante letras,
números, símbolos, imágenes, sonidos, etc.
Esto se conoce como representación externa de los datos.
Pero si queremos introducirlos en un ordenador, todos estos elementos se deben
transformar ó codificar.
10
Un ordenador está compuesto fundamentalmente por circuitos electrónicos
digitales. Los datos circulan por estos circuitos en forma de impulsos eléctricos.
De forma muy simplificada podemos decir que por un circuito pasa o no pasa
corriente y esto lo podemos representar con dos dígitos: 0 y 1.
Todos los datos e información que contiene un ordenador, están representados de
forma interna mediante secuencias de ceros y unos.
Un sistema de representación que utiliza solamente dos símbolos ( 0 , 1 ) se llama
sistema binario.
Por tanto, los datos tal y como los expresamos de forma natural se deben codificar
de forma interna en binario para que puedan ser tratados por el ordenador.
El sistema binario utiliza solamente dos dígitos ( 0 y 1 ) llamados bits.
La palabra bit procede de la unión de las palabras binary digit.
Un bit es la unidad mínima de representación de información.
Utilizando 1 bit podremos solamente representar dos valores posibles: 0, 1.
Utilizando 2 bits podemos representar 4 valores: 00, 01, 10, 11.
Utilizando 3 bits podemos representar 8 valores:
000, 001, 010, 011, 100, 101, 110, 111.
Utilizando 4 bits podemos representar 16 valores:
0000, 0001, 0010, 0011, 0100, 0101, 0110, 0111.
En general, utilizando N bits podremos representar 2N valores.
Ocho bits forman un byte.
El byte es la unidad básica de medida de la información.
Un byte es la cantidad más pequeña de información que el ordenador puede
manejar.
Con un byte se pueden representar 28 = 256 caracteres.
En el interior del ordenador los datos se transmiten y almacenan en grupos de
bytes llamados palabras.
La longitud de palabra depende de cada tipo de ordenador: 8, 16, 32, 64.
TIPOS DE DATOS EN JAVA
Un dato siempre lleva asociado un tipo de dato, que determina el conjunto de
valores que puede tomar.
En Java toda la información que maneja un programa está representada por dos
tipos principales de datos:
a) Datos de tipo básico o primitivo.
b) Referencias a objetos.
Los tipos de datos básicos o primitivos no son objetos y se pueden utilizar
directamente en un programa sin necesidad de crear objetos de este tipo. La
biblioteca Java proporciona clases asociadas a estos tipos que proporcionan
métodos que facilitan su manejo.
Los tipos de datos primitivos que soporta Java son:
11
DATOS NUMÉRICOS ENTEROS
En Java los representan los tipos: byte, short, int, long.
El tipo de dato numérico entero es un subconjunto finito de los números enteros
del mundo real. Pueden ser positivos o negativos.
Ejemplo de declaración de variables enteras:
int a;
byte n1, n2;
short x;
DATOS NUMÉRICOS REALES
En Java los representan los tipos: float, double.
El tipo de dato numérico real es un subconjunto finito de los números reales.
Siempre llevan un punto decimal y también pueden ser positivos o negativos. Los
números reales tienen una parte entera y una parte decimal.
Por ejemplo: 0.08 -54.0001
Ejemplo de declaración de variables reales:
float peso;
12
double longitud;
float altura = 2.5F;
double area = 1.7E4; // equivale a 1.7 * 104
double z = .123; //si la parte entera es 0 se puede omitir
DATOS DE TIPO CARÁCTER
En Java se representa con el tipo char.
Un dato de tipo carácter se utiliza para representar un carácter dentro del rango
\u0000 a \uFFFF (números desde 0 hasta 65535) en Unicode.
En realidad un dato de tipo char contiene un número entero dentro del rango
anterior que representa un carácter.
En Java se utiliza el código Unicode para la representación de caracteres. Este
código actualmente representa los caracteres de la mayoría de idiomas escritos en
todo el mundo.
Los 127 primeros caracteres de Unicode corresponden al código ASCII.
El Código ASCII (American Standard Code for Information Interchange o Código
Estándar Americano para el Intercambio de Información) asigna valores numéricos
a las letras, números, signos de puntuación y algunos otros caracteres especiales.
ASCII incluye 256 códigos divididos en dos conjuntos, estándar y extendido, de
128 cada uno. El conjunto ASCII básico, o estándar, utiliza 7 bits para cada
código, lo que da como resultado 128 códigos de caracteres desde 0 hasta 127.
El conjunto ASCII extendido utiliza 8 bits para cada código, dando como resultado
128 códigos adicionales, numerados desde el 128 hasta el 255.
En el conjunto de caracteres ASCII básico, los primeros 32 valores están
asignados a los códigos de control de comunicaciones y de impresora (caracteres
no imprimibles) empleados para controlar la forma en que la información es
transferida desde una computadora a otra o desde una computadora a una
impresora. En este grupo están los códigos correspondientes a la barra
espaciadora (SP por space), la tecla ENTER de retorno de carro a un nuevo
renglón (CR por carry return), etc. También existen caracteres de control usados
en teleprocesamiento, como ser ACK (Acknowledge - aviso de mensaje recibido),
BEL (bell - aviso por señal sonora), ETX (end of text – fin de texto), STX (start of
text – comienzo de texto), etc.
Los 96 códigos restantes del código básico corresponden a los caracteres
imprimibles y se asignan a los signos de puntuación corrientes, a los dígitos del 0
al 9 y a las letras mayúsculas y minúsculas del alfabeto latino.
Los códigos correspondientes al ASCII extendido, del 128 al 255, se asignan a
aquellos caracteres que no pertenecen al alfabeto anglosajón, por ejemplo, las
vocales con tilde, la ñ, y en general todos los caracteres especiales que utilizan los
distintos lenguajes.
Debido a lo limitado de su tamaño, el código ASCII no es suficiente para

representar caracteres de alfabetos como el Japonés, Chino o árabe. La solución
13
a este problema ha sido crear un código más grande con el que poder representar
cualquier carácter de cualquier idioma: el código Unicode.
El código UNICODE proporciona una única representación numérica para cada
símbolo, independientemente del ordenador, el programa o el lenguaje de
programación que se use.
La codificación Unicode se ha transformado en un estándar adoptado por las
principales empresas de hardware y software. Java utiliza la codificación Unicode.
Ejemplo de declaración de variables de tipo carácter:
char car;
char letra1 = 'z';
char letra = '\u0061'; //código unicode del carácter ‘a’
DATOS DE TIPO LÓGICO
Se representan con el tipo boolean.
Los datos de este tipo sólo pueden contener dos valores: true (verdadero) ó false
(falso).
Ejemplo de declaración de variables lógicas:
boolean primero;
boolean par = false;
Los tipos de datos lógicos son también conocidos como booleanos en honor del
matemático inglés George Bool, que desarrolló la teoría conocida como álgebra de
bool que fue la base para la representación de los circuitos lógicos.
1.3.1 Variables y constantes

Variables Miembro
Una clase en Java puede contener variables y métodos. Las variables pueden ser
tipos primitivos como int, char, etc. Los métodos son funciones.
Por ejemplo, en el siguiente trozo de código podemos observarlo:
public class MiClase {

int i;
public MiClase() {
i = 10;
}
public void Suma_a_i( int j ) {
int suma;
suma = i + j;
}
}
14
La clase MiClase contiene una variable (i) y dos métodos, MiClase() que es el
constructor de la clase y Suma_a_i( int j ).
La declaración de una variable miembro aparece dentro del cuerpo de la clase,

pero fuera del cuerpo de cualquier método de esa clase. Si se declara dentro de
un métodos, será una variable local del método y no una variable miembro de la
clase. En el ejemplo anterior, i es una variable miembro de la clase y suma es una
variable local del método Suma_ a_i().
El tipo de una variable determina los valores que se le pueden asignar y las
operaciones que se pueden realizar con ella.
El nombre de una variable ha de ser un identificador válido en Java. Por convenio,

los programadores Java empiezan los nombres de variables con una letra
minúscula, pero no es imprescindible. Los nombres de las variables han de ser
únicos dentro de la clase y se permite que haya variables y métodos con el mismo
nombre, a diferencia de C++, en donde se produce un error de compilación si se
da este caso.
Para los programadores C++, se pueden señalar algunas diferencias entre Java y
C++ respecto a la sintaxis e interpretación en la declaración de variables miembro
de una clase, como son:
 En los dos lenguajes se permite la declaración de variables miembro

estáticas con una sintaxis parecida, aunque en C++, se deben redeclarar
estas variables fuera de la definición de la clase utilizando el nombre de la
clase, el nombre de la variable y el operador de ámbito
 En los dos lenguajes se permite la utilización de modificadores de acceso a
las variables miembro utilizando las palabras clave public, private y
protected, aunque la sintaxis e interpretación son diferentes en los dos
lenguajes
 Los dos lenguajes reconocen la palabra clave volatile, aunque Java la
ignora
 C++ no reconoce las palabras clave transient y final, utilizadas en la
declaración de variables miembro en Java
Aparte de las diferencias de sintaxis anteriores, Java permite la inicialización de

variables miembro de tipos primitivos en el momento de la declaración y esto no
es posible en C++.
La sintaxis completa de la declaración de una variable miembro de una clase en

Java sería:
[especificador_de_acceso][static][final][transient][volatile]
tipo nombreVariable [= valor_inicial];
15
Ambito de una Variable
Los bloques de sentencias compuestas en Java se delimitan con dos llaves. Las
variables de Java sólo son válidas desde el punto donde están declaradas hasta el
final de la sentencia compuesta que la engloba. Se pueden anidar estas
sentencias compuestas, y cada una puede contener su propio conjunto de
declaraciones de variables locales. Sin embargo, no se puede declarar una
variable con el mismo nombre que una de ámbito exterior.
El siguiente ejemplo intenta declarar dos variables separadas con el mismo

nombre. En C y C++ son distintas, porque están declaradas dentro de ámbitos
diferentes. En Java, esto es ilegal.
class Ambito {
int i = 1; // ámbito exterior
{ // crea un nuevo ámbito
int i = 2; // error de compilación
}
}
Variables de Instancia
La declaración de una variable miembro dentro de la definición de una clase sin

anteponerle la palabra clave static, hace que sea una variable de instancia en
todos los objetos de la clase. El significado de variable de instancia sería, más o
menos, que cualquier objeto instanciado de esa clase contiene su propia copia de
toda variable de instancia. Si se examinara la zona de memoria reservada a cada
objeto de la clase, se encontraría la reserva realizada para todas las variables de
instancia de la clase. En otras palabras, como un objeto es una instancia de una
clase, y como cada objeto tiene su propia copia de un dato miembro particular de
la clase, entonces se puede denominar a ese dato miembro como variable de
instancia.
En Java, se accede a las variables de instancia asociadas a un objeto

determinado utilizando el nombre del objeto, el operador punto (.) y el nombre de
la variable:
miObjeto.miVariableDeInstancia;
En C++, se puede acceder a las variables de instancia de un objeto a través de la

misma sintaxis, pero también utilizando el operador flecha (->), que utiliza como
origen una variable puntero que apunta al objeto:
miVariablePuntero->miVariableDeInstancia;
Variables Estáticas
16
La declaración de un dato miembro de una clase usando static, crea una variable
de clase o variable estática de la clase. El significado de variable estática es que
todas las instancias de la clase (todos los objetos instanciados de la clase)
contienen la mismas variables de clase o estáticas. En otras palabras, en un
momento determinado se puede querer crear una clase en la que el valor de una
variable de instancia sea el mismo (y de hecho sea la misma variable) para todos
los objetos instanciados a partir de esa clase. Es decir, que exista una única copia
de la variable de instancia, entonces es cuando debe usarse la palabra clave
static.
class Documento extends Pagina {

static int version = 10;
}
El valor de la variable version será el mismo para cualquier objeto instanciado de

la clase Documento. Siempre que un objeto instanciado de Documento cambie la
variable version, ésta cambiará para todos los objetos.
En C++, es necesario redeclarar todas las variables estáticas fuera de la definición

de la clase, produciendo una variable pseudo-global, es decir, una variable que es
global en lo que a los objetos de esa clase se refiere.
Si se examinara en este caso la zona de memoria reservada por el sistema para

cada objeto, se encontraría con que todos los objetos comparten la misma zona
de memoria para cada una de las variables estáticas, por ello se llaman también
variables de clase, porque son comunes a la clase, a todos los objetos
instanciados de la clase.
Tanto en Java como en C++, se puede acceder a las variables de clase utilizando
el nombre de la clase y el nombre de la variable, no es necesario instanciar ningún
objeto de la clase para acceder a las variables de clase.
En C++, a las variables de clase se accede utilizando el operador de ámbito junto

con el nombre de la clase y el nombre de la variable:
miVariable::miVariableDeClase;
En Java, a las variables de clase se accede utilizando el nombre de la clase, el

nombre de la variable y el operador punto (.). La siguiente línea de código, ya
archivista, se utiliza para acceder a la variable out de la clase System. En el
proceso, se accede al método println() de la variable de clase que presenta una
cadena en el dispositivo estándar de salida.
System.out.println( "Hola, Mundo" );
17
Es importante recordar que todos los objetos de la clase comparten las mismas
variables de clase, porque si alguno de ellos modifica alguna de esas variables de
clase, quedarán modificadas para todos los objetos de la clase. Esto puede
utilizarse como una forma de comunicación entre objetos.
Constantes
En Java, se utiliza la palabra clave final para indicar que una variable debe
comportarse como si fuese constante, significando con esto que no se permite su
modificación una vez que haya sido declarada e inicializada.
Como es una constante, se le ha de proporcionar un valor en el momento en que

se declare, por ejemplo:
class Elipse {
final float PI = 3.14159;
...
}
Si se intenta modificar el valor de una variable final desde el código de la

aplicación, se generará un error de compilación.
Si se usa la palabra clave final con una variable o clase estática, se pueden crear
constantes de clase, haciendo de esto modo un uso altamente eficiente de la
memoria, porque no se necesitarían múltiples copias de las constantes.
La palabra clave final también se puede aplicar a métodos, significando en este

caso que los métodos no pueden ser sobrescritos.
1.3.2 Entrada y salida de datos
La entrada y salida estándar son flujos de datos que actúan como canales de
comunicación permitiendo la interacción entre un programa y su entorno en el
sistema. En Java podemos tener acceso a estos flujos de datos desde la clase
java.lang.System.
Salida estándar
La salida estándar esta asociada por defecto a la terminal del sistema, es decir
que el resultado de los datos enviados a la salida se observa en pantalla a menos
que su destino sea modificado. Existen dos salidas con diferentes propositos, una
es la propiamente denominada salida estándar la cual se utiliza para la salida
regular de datos, y la otra es la salida estándar de errores la cual se utiliza para la
salida de errores.
18
La salida de datos: System.out
La salida estándar de datos para uso normal (abreviada y en inglés: StdOut) esta
representada por un objeto PrintStream llamado out. La clase PrintStream es una
implementación especial de FilterOutputStream y por lo tanto también de la clase
base OutputStream, de modo que mostrar datos en pantalla es tan sencillo como
referirnos a la variable out e invocar el método void println(String x).
Recordando un ejercicio básico que probablemente todo novato haya echo, aquí
vemos la línea de código que utilizamos para escribir la famosa cadena de texto
“Hola Mundo”:
1...
2System.out.println("Hola Mundo");
3...
La salida:
Hola Mundo
Los métodos print(...) y println(...) son los más usados. De hecho la clase
PrintStream posee estos métodos sobrecargados para todos los datos primitivos
(int, long, etc.) y entonces así puede enviar cualquier tipo de dato como texto hacia
la salida. Los objetos que se quieran imprimir o concadenar serán implícitamente
representados por su implementación del método String toString().
Si miramos la API de PrintStream podemos ver la variedad de métodos para

mostrar datos en pantalla, algunos de estos:
Método Descripción
void print(String s) Escribe un string
void println(String x) Escribe un string y termina la línea.
void println() Termina la línea actual.
void printf(String format, Utiliza un Formatter para poder escribir un String formateado.
Object... args) (Disponible desde J2SE 5.0)
La salida de errores: System.err
Esta es otra salida estándar pero con el fin de ser utilizada para errores (abreviada
y en inglés: StdErr). Al igual que StdOut, también es representada por un objeto
19
PrintStream que en este caso se llama err. Los métodos que podemos invocar
aquí son los mismos vistos anteriormente.
No parece muy útil utilizar out y err si su destino es el mismo, o al menos en el

caso de la consola del sistema donde las dos salidas son representadas con el
mismo color y no notamos diferencia alguna. En cambio en la consola de varios
IDEs como NetBeans o Eclipse la salida de err se ve en un color diferente, por
ejemplo:
1...
2System.out.println("Esta es la salida estandar normal");
3System.err.println("Esta es la salida estandar de errores");
4...
La salida en NetBeans:
Como se puede observar, en el entorno de un IDE como este utilizar las dos
salidas nos puede ayudar a tener un registro mas legible de las actividades del
programa.
Podríamos sacar mas provecho de estas dos salidas si se modifica su destino. Por
ejemplo podríamos guardar los logs de un programa enviando la salida out a un
archivo llamado salida_normal.txt y la salida err a un archivo llamado
salida_error.txt.
Re-definir la salida estándar
Para mostrar como re-definir la salida estándar pondremos en practica el ejemplo

mencionado anteriormente sobre modificar el destino de out y err hacia dos
archivos diferentes.
Una forma de modificar las salidas es utilizando los métodos estáticos void
setOut(PrintStream out) y void setErr(PrintStream err) de la propia clase System.
Necesitamos abrir flujos de datos hacia los nuevos destinos de cada salida, para
cada una se envuelve un objeto FileOutputStream(File file) con un objeto
PrintStream(OutputStream out). Véase:
20
1...
2System.setOut(new PrintStream(new FileOutputStream("salida_normal.txt")));
3System.setErr(new PrintStream(new FileOutputStream("salida_error.txt")));
4
5System.out.println("Esta es la salida estandar normal");
6System.err.println("Esta es la salida estandar de errores");
7
8throw new RuntimeException("Error Fatal");
9...
En el ejemplo anterior se crea el archivo correspondiente para cada tipo de salida.
Otra forma de modificar las salidas estándar es a través de la consola del sistema,
tanto en sistemas Windows como UNIX podemos escribir lo siguiente para un tarro
(.jar):
java -jar archivo.jar > salida_normal.txt 2> salida_error.txt
Ó lo siguiente para una clase (.class):
java MiClase > salida_normal.txt 2> salida_error.txt
En ambos casos lo que estamos haciendo es cambiar primero con “>” la salida
out hacia salida_normal.txt y luego con “2>” la salida err hacia salida_error.txt. En
estos casos esos dos archivos se guardarían en el directorio desde donde se esta
ejecutando este comando en la consola, pero también se podría haber
especificado una ruta absoluta.
Otra cosa practica que puede hacerse desde la consola es bloquear una o incluso
las dos salidas. Para bloquear la salida out escribimos:
java -jar archivo.jar > /null

java MiClase > /null
Ó para bloquear la salida err:
java -jar archivo.jar 2> /null

java MiClase 2> /null
Nota: modificar la salida estándar para un applet es considerada una operación

peligrosa, por lo tanto los navegadores no lo permiten.
21
Entrada estándar
La entrada estándar de datos (abreviada y en inglés: StdIn) esta representada por

un objeto InputStream. La clase InputStream es la clase base en el paquete java.io
para manejar los flujos entrantes de bytes (8-bit). En la mayoría de los casos no
queremos leer directamente en bytes un flujo de datos, sino que esperamos un
formato humano. Aunque en esta ocasión no contaremos desde el principio con
métodos tan prácticos como void println(String x) en el caso de la salida estándar,
veremos como realizar una lectura directamente en bytes, también utilizaremos
implementaciones mas avanzadas de tipo Reader para leer caracteres y luego
tendremos en cuenta las nuevas posibilidades introducidas a partir de J2SE 5.0.
Lectura en bytes
En principio, para leer datos provenientes del teclado de un usuario utilizaremos la

variable in de la clase System y el método int read() de su correspondiente objeto
InputStream. Véase:
1...
2System.out.println("> Introduce un caracter...");
3int in = System.in.read();
4System.out.println("> Has introducido: " + in);
5...
Si introducimos A y pulsamos Intro, la salida:
> Introduce un caracter…

A
> Has introducido: 97
El método int read() de InputStream mantendrá la aplicación bloqueada en espera

de que se introduzca algo en la entrada estándar para poder continuar, el
resultado de presionar A como mayúscula es: 65, si hubiera sido en minúsculas
seria: 97. El método int read() lee concretamente un byte y lo devuelve
representado como un int (número entero) con un valor entre 0 – 255, si la
entrada de datos proviniera desde un archivo se podría obtener también -1 en
caso de que se llegue al EOF (End Of File: fin de un archivo). En nuestro caso el
65 correspondería a la A mayúscula en el formato de caracteres ASCII.
22
Cuando se lee directamente un flujo de bytes sabemos que estamos trabajando
con ASCII, y podríamos hacer una conversión de int a char (un casting) para
obtener el carácter:
1...
3
4int in = System.in.read();
5char c = (char) in;
6
7System.out.println("> Has introducido: " + c);
8...
La salida:

A
> Has introducido: A
Normalmente hacer lo anterior no es lo mas correcto en la mayoría de las

situaciones ya que se debe de tener en cuenta con que formato de caracteres
queremos trabajar, pero dado que se trata solo de leer unos datos introducidos
desde el teclado no nos supone un problema en este momento.
De cualquier forma no nos preocuparemos por hacer conversiones nosotros

mismos, ya que de esto y más se encargaran las implementaciones de la clase
Reader que veremos luego.
Si quisiéramos leer más de un byte podemos intentar con el método int read(byte[]
b), véase:
1 ...
2 System.out.println("> Introduce cinco caracteres...");
3
4 byte[] bufferIn = new byte[5];
5 System.in.read(bufferIn);
6
23
7 for (int i = 0 ; i < bufferIn.length ; i++) {
8 System.out.println("> Has introducido: " + bufferIn[i]);
9 }
10...
Si introducimos A, B, C, D, E y pulsamos Intro, la salida:
> Introduce cinco caracteres…

ABCDE
En este caso si presionamos más teclas seria en vano, como el buffer que
estamos usando es de 5 bytes el espacio de almacenamiento es limitado.
Si introducimos unicamente A, B y C veríamos:

ABC
Los valores 65, 66 y 67 corresponden a las teclas presionadas A, B y C

respectivamente. Pero también obtenemos otros valores por presionar la
tecla Intro en la consola del sistema (en este caso de Windows), el valor 13
representa un CR (Carriage Return: retorno de carro, el fin de una línea) y el valor
10 representa un LF (Line Feed: salto de línea, una nueva línea). Si se ejecuta
desde la consola de un sistema UNIX o en la consola de un IDE solo se obtendrá
el 10 (LF) ya que diferentes sistemas utilizan diferentes formas de terminar una
línea.
Para leer bytes indefinidamente en el próximo ejemplo capturaremos todo lo que

se escriba usando de nuevo int read() pero en un bucle while:
1...
24
2System.out.println("> Introduce lo que quieras...");
3
4int in = 0;
5while (in != -1) {
6in = System.in.read();
8}
9...
Introduciendo cualquier cosa veremos los valores de cada carácter junto a los
valores adicionales de cada pulsación de Intro. El bucle solo se detendrá hasta
recibir el valor -1 que representa un EOF (End Of File: el fin de un archivo) y como
la entrada esta asociada al teclado y no a un archivo lo que haremos es emular un
EOF, en la consola de Windows esto se puede hacer presionando CTRL + Z y en
sistemas UNIX presionando CTRL + D. Si no logras detenerlo simplemente finaliza
el proceso desde el administrador de tareas.
La salida en mi caso:
> Introduce lo que quieras…

A
a
ABCD
escribo algo!
25
^Z
> Has introducido: -1
PrintStreamPrint
Antes de J2SE 5.0 – Lectura de caracteres con clases de tipo Reader
La clase Reader es la clase base en el paquete java.io para manejar los flujos
entrantes de caracteres (16-bit), de esta clase heredan varias clases cuyas
implementaciones se pueden utilizar en combinación con otras clases para
diferentes propósitos. De estas implementaciones tomaremos para combinar con
el InputStream (que representa la entrada estándar) la clase InputStreamReader
que convierte bytes en caracteres. Véase:
1...
3
4InputStreamReader isr = new InputStreamReader(System.in);
5int in = isr.read();
6
8...
Si introducimos A y pulsamos Intro, la salida:

A
26
El método int read() de InputStreamReader mantendrá la aplicación bloqueada en
espera de que se introduzca algo en la entrada estándar para poder continuar, el
resultado de presionar A como mayúscula es: 65, si hubiera sido en minúsculas
seria: 97. Hasta aquí parece lo mismo que utilizar el método int read()
directamente desde InputStream como vimos anteriormente, pero en este caso el
método int read() lee concretamente un carácter y lo devuelve representado como
un int (número entero) con un valor entre 0 – 65535 (notar que el rango es mucho
mayor, esto es Unicode), y -1 en caso de que se llegue al EOF (End Of File: fin de
un archivo).
Como los caracteres ASCII (y también el superset de ASCII ISO Latin 1) están
incluidos en Unicode esperamos el mismo resultado de ambos métodos int read()
siempre que usemos caracteres normales que están cubiertos por el formato
ASCII. Pero ¿porque int read() en InputStreamReader no devuelve directamente el
char?, posiblemente sea para poder devolver el -1 que significa un EOF ya que
este no tiene un carácter que lo represente.
Podemos hacer la conversión de int a char como hicimos antes:
1...
2System.out.println("> Introduce algo...");
3InputStreamReader isr = new InputStreamReader(System.in);
4
5int in = isr.read();
6char c = (char) in;
7
9...
La salida es:
> Introduce algo…

A
La diferencia es que en este caso es mas confiable y adecuado realizar esta

conversión porque estamos trabajando con el rango de caracteres Unicode,
aunque tratando con caracteres normales (como lo es “A”) no notemos ninguna
diferencia.
27
Si quisiéramos leer mas de un carácter podemos intentar con el método int
read(char[] cbuf), véase:
1 ...
2 System.out.println("> Introduce cinco caracteres...");
3
4 InputStreamReader isr = new InputStreamReader(System.in);
5 char[] bufferIn = new char[5];
6 isr.read(bufferIn);
7
8 for (int i = 0 ; i < bufferIn.length ; i++) {
9 System.out.println("> Has introducido: " + bufferIn[i]);
10}
11...
Si introducimos A, B, C, D, E y presionamos Intro, la salida:

ABCDE
> Has introducido: B
> Has introducido: C
> Has introducido: D
> Has introducido: E
En este caso si presionamos más teclas seria en vano, como el buffer que
estamos usando es de 5 bytes el espacio de almacenamiento es limitado.
Lo nuevo aquí es que ahora efectivamente tenemos los caracteres y no sus

representaciones en int. Si introducimos solo ABC veríamos:

ABC
> Has introducido:
28
> Has introducido:
Ya podemos ver los caracteres A, B y C. En este caso los otros valores que
obtenemos por presionar Intro (CR y LF, en Windows) no son visibles como un
carácter, pero el que demuestra su presencia es LF que provoca una nueva línea
en la salida de la consola.
Para leer caracteres indefinidamente en el próximo ejemplo capturaremos todo lo

que se escriba utilizando de nuevo int read() pero en un bucle while, y como el
método int read() aquí también retorna una representación en int para cada
carácter realizaré la conversión de int a char:
1 ...
2 System.out.println("> Introduce lo que quieras...");
3
5 int in = 0;
6
7 while (in != -1) {
8 in = isr.read();
9 char c = (char) in;
11}
12...
Introduciendo cualquier cosa veremos cada carácter, un espacio en blanco (en

Windows) y una nueva línea con cada pulsación de Intro. El bucle solo se
detendrá hasta recibir el valor -1 que representa un EOF (End Of File: el fin de un
archivo), como hicimos anteriormente tenemos que emular un EOF. Si no lo logras
simplemente finaliza el proceso desde el administrador de tareas.
La salida en mi caso:
> Introduce lo que quieras…

A
> Has introducido:
29
> Has introducido:
ABCDE
> Has introducido: D
> Has introducido: E
> Has introducido:
> Has introducido:
escribo algo!
> Has introducido: e
> Has introducido: s
> Has introducido: c
> Has introducido: r
> Has introducido: i
> Has introducido: b
> Has introducido: o
> Has introducido:
> Has introducido: a
> Has introducido: l
> Has introducido: g
> Has introducido: o
> Has introducido: !
> Has introducido:
> Has introducido:^Z
> Has presionado: ?
Notar que el -1 en su conversión a char resulta en el símbolo “?”, esto sucede

cuando una entrada no puede ser representada por el formato de caracteres.
La forma normalmente más cómoda, eficiente y utilizada (al menos de los recursos
que tenemos antes del J2SE 5.0) para leer caracteres desde el teclado es
combinando también otra de las clases que heredan de Reader, se trata de la
clase BufferedReader y utilizar su método String readLine().
Construiremos un objeto InputStreamReader envuelto en un BufferedReader.

Véase:
1 ...
2 System.out.println("> Introduce algo...");
30
3
5 BufferedReader br = new BufferedReader(isr);
6
7 String s = br.readLine();
8
9 System.out.println("> Has introducido: " + s);
10...
La salida es:
> Introduce algo…

Esto es una linea!
> Has introducido: Esto es una linea!
El método String readLine() de BufferedReader mantendrá la aplicación bloqueada

en espera de que se introduzca algo en la entrada estándar para poder continuar,
este método lee líneas de texto hasta que terminen en un LF, CR u ambos. Esta
una forma muy practica de leer y trabajar con strings en Java ya que es cómodo y
adecuado al lenguaje, no obstante si esperamos algún tipo de número debemos
de hacer las conversiones correspondientes, por ejemplo:
1 ...
2 System.out.println("> Introduce algo...");
3
5 BufferedReader br = new BufferedReader(isr);
6
7 String s = br.readLine();
8 int n = Integer.parseInt(s);
9
10System.out.println("> Has escrito: " + n);
11...
31
La salida de este ejemplo seria exactamente igual que el caso anterior, pero por
alguna razón suponiendo que estamos trabajando con números y necesitáramos
hacer algún calculo aritmético no podíamos mantener como String nuestro tipo de
dato obtenido, por eso mediante el método estático int parseInt(String s) de la
clase Integer se convierte nuestro String en int.
Desde J2SE 5.0 – Lectura de caracteres con java.util.Scanner
Desde J2SE 5.0 se introduce la clase Scanner en el paquete de utilidades

java.util. Esta clase toma en cuenta un delimitador para procesar la entrada del
flujo de datos en sub-cadenas, es muy flexible y ya posee una gran variedad de
métodos para diferentes necesidades. Para utilizar esta clase solo tenemos que
construir un objeto Scanner pasándole System.in como argumento, el flujo de
bytes es convertido a caracteres en el formato de caracteres por defecto del
sistema, aunque la clase también posee otros constructores para especificar el
formato de preferencia.
A continuación algunos ejemplos del uso de esta clase:
 Leyendo una línea de texto:
1...
2System.out.println("> Introduce una linea de texto...");
3
4Scanner sc = new Scanner(System.in);
5String s = sc.nextLine();
6
7System.out.println("> Has introducido: " + s);
8...
Salida:
> Introduce una linea de texto…

Hola a todos
> Has introducido: Hola a todos
 Leyendo un número entero:
1...
2System.out.println("> Introduce un numero entero...");
32
3
4Scanner sc = new Scanner(System.in);
5int i = sc.nextInt();
6
7System.out.println("> Has introducido: " + i);
8...
Salida:
> Introduce un numero entero…

14
También hay muchos otros métodos que se pueden utilizar, la clase Scanner es
muy potente y merece su propio tutorial. Pero teniendo en cuenta estos ejemplos
lo que falta es el control de excepciones, sobretodo la excepción
InputMismatchException que siempre es generada cuando un método recibe un
tipo de dato que no puede manejar. Aunque no estemos obligados a tratarla
deberíamos de hacerlo, por ejemplo si esperamos como en el segundo ejemplo un
número entero con int nexInt() pero introducimos un número largo se generaría
esta excepción.
Una forma más correcta de esperar el número entero:
1 ...
2 System.out.println("> Introduce un numero entero...");
3
4 Scanner sc = new Scanner(System.in);
5 int i = -1;
6
7 try {
8 i = sc.nextInt();
9 System.out.println("> Has introducido: " + i);
10} catch (InputMismatchException imme) {
11System.out.println("> El dato ingresado no es valido!");
33
12}
13...
La salida luego de haber ingresado un número largo:
> Introduce un número entero…

111111111111111111111111111111111
> El dato ingresado no es valido!
En general cuando se lee desde la entrada estándar y se pretende obtener algún

dato especifico la clase Scanner puede reemplazar la utilización de
BufferedReader simplificando el trabajo de lectura.
Re-definir la entrada estándar
No es algo habitual, pero se puede re-definir la entrada estándar con el método

estático void setIn(InputStream in) de la clase System.
1.4 Errores en tiempo de ejecución
Los errores en tiempo de ejecución son los que se producen durante la ejecución
del programa. Son los más difíciles de encontrar, no son detectados por el
compilador, ya que son errores de lógica, no de sintaxis. Aunque al compilar un
programa no de errores, el programa puede funcionar incorrectamente y/o a dar
errores durante su ejecución.
Por ejemplo:
• Un programa puede producir resultados erróneos, al equivocarnos (errores

lógicos) al programar el algoritmo (sumar en vez de restar, etc.).
• Un programa puede interrumpirse bruscamente, por ejemplo si tenemos que
hacer una división y el divisor es cero, etc.
Los errores que se pueden producir en la fase de compilación son:

− Errores fatales: Son raros. Indican errores internos del compilador.
Cuando ocurre la compilación se detiene inmediatamente.
− Errores de sintaxis: Son los errores típicos de sintaxis. No detienen la

compilación sino que al finalizar ésta se mostrará la lista con todos los errores
34
encontrados. Algunos errores suelen ser consecuencia de otros cometidos con
anterioridad. Con este tipo de errores no se puede obtener un programa objeto y
por lo tanto tampoco el ejecutable.
− Advertencias o avisos (warnings): Indican que hay líneas de código

sospechosas que a pesar de no infringir ninguna regla sintáctica, el
compilador las encuentra susceptibles de provocar un error. Cuando se detecta un
warning la compilación no se detiene.
Si en un programa fuente sólo se detectan warnings sí que se podrá obtener un

programa objeto, que tras el linkado dará lugar a un programa ejecutable.
Encontrar la causa que los provoca es una labor en ocasiones complicada, razón
por la cual los EID (Entornos Integrados de Desarrollo,) nos proporcionan una
herramienta llamada Depurador que nos ayuda a encontrar los errores lógicos y
demás errores producidos en tiempo de ejecución. Un depurador (debugger), es
un programa diseñado específicamente para la detección, verificación y corrección
de errores. Los depuradores nos permiten trazar el programa (ejecutarlo sentencia
a sentencia) y visualizar el contenido de las variables y direcciones de memoria
durante la ejecución del programa. Además permiten alterar el flujo de ejecución
del mismo, cambiar los valores de las variables e introducir puntos de parada.
35
1.5Ejecución de un programa
Java es un lenguaje que se ejecuta con un intérprete a diferencia de Pascal o C

que se compilan para producir un código ejecutable que luego se ejecuta
independientemente. Para ejecutar un programa escrito en Java deberá:
1. Escribir su programa usando su editor de texto favorito (se sugiere pico o

emacs).
2. Compilar el programa usando javac. Esto producirá un archivo por cada
clase que usted defina. Estos archivos no tendrán código ejecutable sino un
lenguaje intermedio llamado código en bytes (byte-code) que podrá ser
ejecutado con un intérprete como indica al próximo paso.
3. Ejecutar el programa usando java. Qué es exactamente un programa en
Java se discutirá más adelante. Java es un intérprete, es decir, la
traducción a lenguaje de máquina de cada una de las instrucciones del
programa se hace mientras se está ejecutando cada instrucción.
Hola mundo en java
Código
/*
nombres:Cervantes Arias Roberto
Doroteo Felipe Edmar
Villagómez Salazar Brandon Alan
grupo: 5153
fecha: 25 de abril 18
objetivo: tipos de lenguaje
practica: proyecto
*/
package hola.mundo;
/**
36
*
* @author edmar
*/
public class HolaMundo {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
System.out.println("hola mundo");
37
38
2. c++ (Lenguaje de programación)
C++ es un lenguaje de programación, creado a mediados de 1980 por Bjarne

Strousstrup, como extensión del lenguaje C. Este lenguaje abarca tres paradigmas
de la programación:
1. Programación Estructurada
2. Programación Genérica
3. Programación Orientada a Objetos
En la actualidad, C++ es un lenguaje versátil, potente y general. Su éxito entre los
Programadores le ha llevado a ocupar el primer puesto como herramienta de
desarrollo de aplicaciones, ya sea en Windows o GNU Linux, que es el sistema
operativo.

Es aquella que te define el orden de pasos que debe llevar un programa en c++ y
su utilización de cada uno de los comandos.
Directivas de preprocesador
Declaraciones globales (variables globales, funciones,…)
Función main()
{
Secuencia de declaraciones e instrucciones
}
función1 ()
{
}
...
Función ()
{
}
*Directivas del preprocesador

39
Los compiladores de C++ proporcionan bibliotecas de funciones.
Cada biblioteca de funciones tiene asociado un archivo de definición que
se denomina cabecera.
Para utilizar algo de una biblioteca en un programa, hay que colocar al principio
del programa una directiva de preprocesamiento seguida de la cabecera de la
biblioteca entre ángulos.
Instrucciones al compilador antes de que se compile el programa principal
Las directivas más usuales son:
# include
# define
# include <iostream.h>
Indica al compilador que lea las directivas antes de compilar la función principal
*La función main()

Una función C++ es un subprograma que devuelve un valor, un conjunto de
valores o realiza una tarea específica. Todo programa C++ tiene una única
función main() que es el punto inicial de entrada al programa. Si se intenta
declarar dos funciones main() dentro del programa se produce error.
Estructura de un programa C++
#include <iostream.h>
main()
{
…
...
}
Las sentencias escritas entre las llaves se denominan BLOQUE
int main()
{
entrada_datos();
proceso_datos();
return 0;
...
}
Llamadas a otras funciones.
Es la identificación de la estructura de un lenguaje en este caso c++

Los elementos del lenguaje están formados por las palabras reservadas,
operadores, variables, constantes, comentarios y signos de puntuación. La
combinación de todos ellos formará la sintaxis del programa.
Caracteres
40
Los caracteres que se pueden utilizar en la sintaxis del lenguaje.
 abcdefghijklmnopqrstuvwxyz
 ABCDEFGHIJKLMNOPQRSTUVWXYZ
 0123456789
 +-*/=(){}[]<>’”!@-/^&%_:.,;?|
 Espacio y tabulador
Con la combinación de los caracteres podemos formar los identificadores que

representan los nombres de las variables, constantes etc. Estos han de
comenzar por una letra minúscula, mayúscula o por el subrayado bajo. La longitud
puede ser de uno a varios caracteres, no permitiéndose dejar espacios en blanco
ni utilizar caracteres especiales. Para separar un identificador formado por dos
palabras se puede utilizar la barra baja.
N, i, con
K456, var45
Dato_entrada, precio_producto
El c++ es sensible a las letras mayúsculas por lo que dos nombres iguales con
mayúsculas o minúsculas son diferentes.
Consigna es distinto a consigna
Palabras reservadas
asm and and_eq

auto bitand bitor
bool break case
catch char class
compl const const_cast
continue default delete
do double dynamic_cast
else enum explicit
export extern false
float for friend
goto if inline
int long mutable
namespace new not
not_eq operator or
or_eq private protected
public register reinterpret_cast
return short signed
sizeof static static_cast
struct switch template
this throw true
try typedef typeid
typename union unsigned
using virtual void
volatile wchar_t while
xor xor_eq
41
2.3 Tipos de dato
El tipo de dato determina la naturaleza del valor que puede tomar una variable.
Los tipos de datos en C++ se clasifican en primitivos y derivados.
Los tipos de datos primitivos son los que están definidos dentro del lenguaje.
Los tipos de datos derivados se forman a partir de los tipos primitivos.
En este tema veremos los tipos primitivos y en temas siguientes estudiaremos los
tipos derivados.
Los tipos de datos primitivos en C++ son: numéricos enteros, numéricos reales,
tipo lógico y tipo carácter ampliado.
Tipos de datos C++ numéricos enteros

El tipo de dato numérico entero es un subconjunto finito de los números enteros
del mundo real. Pueden ser positivos o negativos.
En C++ los tipos de datos numéricos enteros son los siguientes:
Número de
Tipo de Dato Descripción Rango
bytes típico
Short Entero corto 2 -32768 a 32767
-2147483648 a
int Entero 4
+2147483647
-2147483648 a
Long Entero largo 4
+2147483647
Char Carácter 1 -128 a 127
Con los tipos enteros pueden utilizarse los calificadores signed y unsigned. Estos
calificadores indican si el número tiene signo o no. Si se usan solos, sin indicar el
tipo de dato se asume int.
Por ejemplo, las siguientes declaraciones son equivalentes:
unsigned int x; equivale a: unsigned x;
Usando estos calificadores podemos tener los siguientes tipos enteros:
Número de
Tipo de Dato Descripción Rango
bytes típico
signed short Entero corto 2 -32768 a 32767
unsigned Entero corto sin
2 0 a 65535
short signo
signed int Entero 4 -2147483648 a +2147483647
unsigned int Entero sin signo 4 0 a 4294967295
42
signed long Entero largo 4 -2147483648 a +2147483647
Entero largo sin
unsigned long 4 0 a 4294967295
signo
signed char Carácter 1 -128 a 127
unsigned char Carácter sin signo 1 0 a 255
Podemos ver que los datos enteros de tipo signed son equivalentes a los enteros
sin utilizar el calificador:
signed int a; es equivalente a escribir int a;
Tipos de datos numéricos reales

El tipo de dato numérico real es un subconjunto finito de los números reales.
Pueden ser positivos o negativos.
En C++ los tipos de datos numéricos reales son los siguientes:
Tipo de Número de
Descripción Rango
Dato bytes típico
Real (Número en Positivos: 3.4E-38 a 3.4E38
float 4
coma flotante) Negativos: -3.4E-38 a -3.4E38
Real doble(Número
Positivos: 1.7E-308 a 1.7E308
double en coma flotante de 8
Negativos: -1.7E-308 a -1.7E308
doble precisión)
Positivos: 3.4E-4932 a 1.1E4932
long Negativos: -3.4E-4932 a -
Real doble largo 10
double 1.1E4932
Tipo lógico
Los datos de este tipo sólo pueden contener dos valores: true ó false (verdadero ó
falso).
Si se muestran como enteros, el valor true toma el valor 1 y false el valor 0.
Tipo de Número de
Descripción Rango
Dato bytes típico
bool Dato de tipo lógico 1 0, 1
Tipo carácter extendido
Este tipo se utiliza para representar caracteres UNICODE. Utiliza 2 bytes a
diferencia del tipo char que solo utiliza 1.
Tipo de Número de
Descripción Rango
Dato bytes típico
wchar_
Carácter Unicode 2 0 a 65535
t
43
2.3.1 Variables y constantes
Las variables son altamente imprescindibles al momento de programar, de hecho

sería imposible conseguir una aplicación con una funcionalidad básica sin usar
variables; por esta misma razón es necesario aprender a usarlas bien y lo
tenemos muy fácil, pues su uso es bastante sencillo e intuitivo, tanto para
declararlas como para asignarles valores.
Las variables son posiciones en memoria donde estarán guardados los diferentes
valores que le damos o que toman duranet ejecución los datos que usamos y
normalmente estarán disponibles a lo largo de la ejecución de nuestro programa.
Para asignar valores a una variable en una gran variedad de lenguajes que incluye
a C++ se usa el operador "=" seguido del valor que le daremos a la variable (no
todos usan el "=" para esto). Veamos un ejemplo completo con todos los posibles
usos que le damos a una variable.
#include <iostream>
using namespace std;
int main()
{
char x = 'a'; // Declaramos y asignamos en la misma línea
int num; //Declaramos el entero en una línea

num = 5; //Le asignamos un valor en otra línea
int num2 = 8; //Asignacion y declaracion al tiempo
float numero; //Un numero decimal

numero = 3.5; //Le asignamos un valor al decimal
float res = numero + num2; //Sumamos dos variables y las asignamos a res
//3.5 + 8 = 11.5
res = res + num; //Al valor actual de res le sumamos el valor de num
//11.5 + 5 = 16.5
bool valor = false; //Variable booleana

valor = true; // Pueden ser true o false
res = res*2; //Duplicamos el valor de res 16.5*2 = 33
cout << res << endl; //Mostramos el valor de res por pantalla
return 0;
44
}
En el código anterior hemos visto las multiples formas en que se puede declarar
una variable, cómo asignarle un valor, incluso vimos que es posible asignarle el
valor de una variable a otra, o realizar operaciones entre los valores de variables y
asignar el resultado a una variable nueva, vimos que es posible usar el valor de
una misma variable y cambiar su propio valor (res = res*2).
Ahora hablemos de las constantes en C++.
Constantes en C++, const y #define
Las datos constantes, mal llamadas por algunos "variables constantes" (realmente
no son variables) tienen un valor fijo durante toda la ejecución del programa, es
decir, este valor no cambia ni puede ser cambiado a lo largo de la ejecución de
nuestro programa. Las constantes son muy útiles para especificar el tamaño de un
vector y para algunas otras cosas, como facilidad de uso y confiabilidad del
código. Para declarar una constante, se hace despues de declarar las librerías y
antes de las funciones, la sintaxis es la siguiente: #define nombre_constante valor.
Veamos algunos detalles y luego unos ejemplos sencillos del uso de las
constantes en C++
En C++ se pueden definir constantes de dos forma, ambas válidas para nosotros.
La primera es por medio del comando #define nombre_constante valor y la
segunda es usando la palabra clave const, veamos ahora cada una de estas
formas en detalle.
Uso de #define para declarar constantes en C++
La instrucción #define nos permite declarar constantes (y algunas cosas más) de

una manera rápida y sencilla. Hay que tener en cuenta que al declarar constantes
con #define debemos hacerlo despues de los #include para importar librerías pero
antes de declarar nuestras funciones y demás. Veamos un ejemplo:
Ejemplo de uso de #define en C++ para declarar constantes
#include <iostream>
#define PI 3.1416; //Definimos una constante llamada PI
int main()
{
cout << "Mostrando el valor de PI: " << PI;
45
return 0;
}
Notemos que ha sido bastante fácil, sin embargo no todo es bueno. Realmente al
usar la instrucción #define en C++ no estámos creando una constante realmente,
estamos creando una expresión y por tal motivo hay algunas cosas que se
complican, veamos:
#include <iostream>
#define PI 3.1416; //Definimos una constante llamada PI
int main()
{
cout << "Mostrando el valor de PI: " << PI << endl;
return 0;
}
Si intentamos ejecutar el código anterior obtendremos un error al haber usado el

operador << justo despues de PI, esto sucede porque PI no es tratado
exactamente como una variable cualquiera sino como una expresión, así que
realmente aunque podemos usar #define para declarar constantes no es la mejor
opción.
Veamos ahora cual es realmente la forma más adecuada de declarar constantes

en C++, esto se hace por medio de la instrucción const, veamos:
Uso de const para declarar constantes en C++
La instrucción const nos permite declarar constantes de una manera más

adecuada y acorde. Las constantes declaradas con const poseen un tipo de dato
asociado (como debería ser siempre) y se declaran al interior de nuestro código
como un tipo cualquiera. Veamos un ejemplo:
Ejemplo de uso de const en C++ para declarar constantes
#include <iostream>
int main()
{
46
const float PI = 3.1416; //Definimos una constante llamada PI
return 0;
}
Notemos que de igual forma ha sido bastante fácil y mejor aún ha sido mucho más
intuitivo y sencillo para nosotros. Se puede ver que la declaración es muy similar a
la de una variable cualquiera y que ya no tenemos complicaciones al intentar
añadir la instrucción endl para agregar el salto de línea. Veamos que realmente la
variable no puede cambiar:
#include <iostream>
int main()
{
const float PI = 3.1416; //Definimos una constante llamada PI
PI = 2; //Esto generará un error pues PI es de solo lectura (constante)
return 0;
}
Si intentamos ejecutar el código anterior obtendremos un error al intentar

cambiarle el valor a PI, pues lo hemos definido como una constante y el lenguaje
no nos permitirá cambiarle en ningún momento el valor.
2.3.2Entrada y salida de datos
La entrada y salida de datos en C++ es simple (al menos para los casos más
comunes). Con esto hago una comparación entre C++ y Java, pues leer una
entrada del usuario por teclado en C++ es bastante simple mientras que en Java
implica una serie de conceptos adicionales que la hacen un tanto más complicada.
Por suerte para nosotros en esta sección veremos cómo leer por teclado en C++,
en otras palabras, asignar a una variable el valor que el usuario escriba por el
teclado. Adicional a esto veremos también cómo mostrar texto por pantalla en
C++, es decir, salida de datos.
Vamos a comenzar primero con aprender a mostrar texto por pantalla en C++.
Este orden se debe a que cuando queremos pedirle algún dato al usuario primero
debemos hacerle saber lo que queremos que ingrese y para hacérselo saber
debemos mostrarle un mensaje con las indicaciones, por tal motivo es importante
47
primero saber mostrar texto en pantalla en C++ y luego a leer texto por teclado en
C++.
Salida de texto por pantalla en C++
Mostrar texto por pantalla en C++ es muy simple. Para imprimir una salida de texto
en C++ se hace uso de la instrucción cout<< es importante tener en cuenta que la
instrucción cout siempre va acompañada de << para controlar el flujo de datos que
sale. No te fijes mucho en ellos, solo ten siempre presente que cout viene
acompañado de << para tener cout<< como resultado.
Veamos algunos ejemplos para mostrar texto por pantalla en C++:
Ejemplo 1 de impresión de texto por pantalla en C++
#include "iostream"
int main()
{
//Se muestra un mensaje por pantalla.
cout << "Hola Mundo" << " Desde AAP." << endl;
return 0;
}
El ejemplo que acabas de ver es bastante sencillo, excepto por un detalle. Si

ejecutar este código en tu pantalla aparecerá un mensaje diciendo "Hola Mundo
Desde AAP.". Tal como habrás notado el operador << se usa para concatenar
(unir) dos cadenas de texto por eso el resultado es el obtenido. Luego se usa endl
indicando el final de la línea lo cual crea un salto de línea. No es obligatorio pero
es recomendable.
Ejemplo 2 de impresión de texto por pantalla en C++
#include "iostream"
#include "string"
int main()
{
string salida1 = "Ejemplo de salida"; //El valor de esta variable se mostrará en
pantalla
48
int numero = 2; //Este valor también se mostrará en pantalla.
string salida2 = "Desde AAP."; //Estos valores se concatenarán en una única
salida
//Se concatenan y muestran los valores por pantalla con cout<<

cout << salida1 << " " << numero << ". " << salida2 << endl;
return 0;
}
En este ejemplo de salida por pantalla hemos visto que también es posible usar la
instrucción cout para mostrar en pantalla el valor de las variables así sean
numéricas o cadenas de texto. También vimos que podemos concatenar los
valores de esas variables entre sí y también concatenarlas con otros valores
directamente (espacios, puntos, símbolos, etc.).
Ya tenemos claro cómo mostrar texto por pantalla en C++ ahora haremos uso de
este concepto y veremos cómo leer texto por teclado en C++. Veamos:
Entrada o lectura de datos en C++
Tal como mencioné hace un momento, la lectura de datos en C++ es bastante

simple. Leer datos por teclado en C++ se hace usando el comando cin >> es
importante notar el uso de los dos signos >> que son usados para controlar el flujo
de datos. No te preocupes mucho por ellos, solo ten en cuenta que cada vez que
vaya a usar la instrucción cin debes agregarle >> para quedar con un cin>>. Una
manera muy sencilla de recordar esta instrucción es que in significa entrar y como
estamos programando en C++ le añadimos la letra C al comienzo quedando así
cin>> (sin olvidar los >>).
Veamos unos ejemplos simples para leer datos en C++. Recuerda como dije más
arriba que lo ideal para leer datos es indicarle al usuario qué es lo que esperamos
que ingrese por lo que en estos ejemplos usaremos también lo recién aprendido
(mostrar texto por pantalla).
Ejemplo 1 de lectura de datos en C++
#include "iostream"
#include "string"
int main()
{
49
cout << "Hola! Este es un ejemplo en C++" << "\n" << "Por favor ingrese su
nombre:" << endl; //La instrucción \n es un salto de línea Mostrando los textos
separados
string nombre;//En esta variable estará almacenado el nombre ingresado.

cin >> nombre; //Se lee el nombre
cout << "Bienvenido al sistema " << nombre << ". Gracias por usar nuestra
aplicación" << endl;
return 0;
}
En este ejemplo hemos hecho un pequeño sistema de bienvenida personalizado

para el usuario leyendo el valor por teclado de su nombre. En el comando cin>> se
debe poner, después de >>, el nombre de la variable en la cual se almacenará el
valor que el usuario ingrese. Por tal motivo primero se declaró primero una
variable llamada nombre y luego se uso cin >> nombre indicando que lo que l
usuario ingrese se almacenará en dicha variable.
Ejemplo 2 de lectura de datos en C++
#include "iostream"
#include "string"
int main()
{
cout << "Hola! Aqui podras realizar sumas" << endl;//Mensaje de bienvenida
float numero1, numero2; //Se declaran los números que se sumarán (pueden
ser decimales)
cout << "Por favor ingrese el primer valor: " << endl; //Se pide el primer numero
cin >> numero1; //Se asigna el primer valor a numero1
cout << "Por favor ingrese el segundo valor: " << endl; //Se pide el segundo
numero
cin >> numero2; //Se asigna el segundo valor a numero2
cout << "El resultado de la suma de " << numero1 << " + " << numero2 << " es: "
<< numero1+numero2 << endl; //Se muestra el resultado.
return 0;
}
50
2.4 Errores en tiempo de ejecución
La mejor manera de comunicar y tratar errores lógicos y errores en tiempo de
ejecución es utilizar las excepciones. Esto es especialmente cierto cuando la pila
puede contener varias llamadas de función entre la función que detecta el error y
la función que tiene el contexto para saber cómo tratarlo.
ERRORES EN TIEMPO DE EJECUCIÓN:
Código
/*nombre:cervantes arias roberto
doroteo felipe edmar
villagomez salazar brandon alan
grupo: 5153
fecha: 25 de abril del 2018
objetivo: proyecto
*/
#include <conio.h>
main ()
{
cout<<"hola mundo";
51
getch();
return 0;
}
52
3. Python (Lenguaje de programación)
Python es un lenguaje de programación interpretado cuya filosofía hace hincapié

en una sintaxis que favorezca un código legible.
Se trata de un lenguaje de programación multiparadigma, ya que soporta
orientación a objetos, programación imperativa y, en menor medida, programación
funcional. Es un lenguaje interpretado, usa tipado dinámico y es multiplataforma.
Características:
-Es un lenguaje interpretado
-Tipido dinámico
-Fuertemente tipado
-Multiplataforma
-Orientado a objetos.

Para que tu aplicación Python funcione correctamente y suponiendo que le has
llamado miapp, debe respetar la siguiente estructura básica:
miapp
|
|_____ passenger_wsgi.py
|
|_____ public
|
|_____ tmp
Es decir, tu aplicación debe contener como mínimo un archivo

passenger_wsgi.py, que será la puerta de entrada a tu aplicación.
53
Además, tu aplicación debería contener un directorio llamado public, que será la
ráiz de tu web y donde ubicarás los archivos estáticos de tu aplicación (imagenes,
CSS, JS, ...).
Por último, necesitas un directorio llamado tmp, el cual te permitirá forzar el

reinicio de tu aplicación Python. Para ello tendrías que ejecutar el siguiente
comando desde la línea de comandos:
Los comentarios se utilizan para hacer aclaraciones sobre nuestro código o

sobre el programa. Es muy fácil hacer comentarios en Python. Existen dos tipos
de comentarios en Python:
 comentario de una sola línea. Se utiliza el símbolo #
Según la normativa PEP 8 los comentarios en una sola línea se separan del
código por dos espacios y después del símbolo # un espacio.
x = 22 # Este es un comentario
1 x = 22 # Este es un comentario de una sola línea
 comentario de varias líneas (multi-línea). Se utilizan “””
"""Este es un comentario
de varias líneas"""
1 """Este es un comentario
2 de varias líneas"""
Variables
54
Las variables son espacios donde podemos almacenar datos que son variables.
Pueden ser letras, como una cadena de caracteres, o números. Las variables se
componen de un nombre y el valor.
esta_variable = 99
1 esta_variable = 99
Constantes
Las constantes son como las variables pero se diferencian en que sus datos no
varían.
ESTA_CONSTANTE = 56
1 ESTA_CONSTANTE = 56
Operadores aritméticos en Python
Estos son los operadores aritméticos que utiliza Python:
Símbolo OPERADOR ARITMÉTICO Ejemplo El resultado

+ Suma x = 8 + 2 x es 10
- Resta x = 10 - 7 x es 3
- Negación x = -2 x es -2
* Multiplicación x=9*4 x es 36
** Exponente x = 2 ** 4 x es 16
/ División x = 13.5 / 2 x es 6.75
// División entera x = 13.5 / 2 x es 6.0
% Módulo x = 29 % 2 x es 1
3.3 Tipos de dato
Python para todos. Los tipos de datos en Python pueden ser varios, una variable o
constante puede puede tener datos como:
Cadena de texto (string): variable = “Python para todos”
55
Número entero: variable = 16
Número octal: variable = 016
Número real = 134.45
Número hexadecimal: variable = 0x16
Booleano:
verdadero = true
falso = false
3.3.1Variables y constantes
Muchas veces cuando estamos escribiendo un programa, necesitamos almacenar

valores para su uso posterior, estos valores podrían ser, de tipo texto, numéricos,
boléanos, alfanuméricos, etc. Si los valores que estamos guardando no van a
cambiar en el transcurso del programa, las podemos definir como constantes. En
caso contrario, sino estamos seguros del tratamiento que le vamos a dar a
nuestras variables o los valores almacenados van a cambiar a través del tiempo,
las podemos definir variables.
La forma de definir una variable es la siguiente:
mi_variable = contenido_asignado_a_la_variable
La forma de definir una constante es:
MI_CONSTANTE = contenido_asignado_a_la_variable
Para explicar mejor este tema vamos a usar la consola interactiva de python.
El siguiente ejemplo muestra la forma correcta de definir una variable:
56
La forma incorrecta de definir una variable seria la siguiente:
Al utilizar espacios al definir una variable, el intérprete de python no lo procesaría.
Al utilizar caracteres como por ejemplo $ %&/()=?¿!, tambien generamos error.
Al comenzar una definición de variables con números.
Para trabajar con variables se debe tomar en cuenta que se deben utilizar
nombres descriptivos, si se quiere utilizar mas de una palabra se debe escribir con
guión bajo y finalmente cabe destacar que, la sintaxis correcta para utilizar el
signo ‘=’ es fijarse que siempre respetemos el utilizar un solo espacio después del
signo igual.
Para definir una constante es de la siguiente forma:
Como se observa en la captura de pantalla que se utilizan letras mayúsculas y

además se debe utilizar guión bajo para separar las palabras, las reglas son
parecidas a las variables para no tener errores de sintaxis.
Para imprimir el valor de una variable o constante en pantalla se utiliza la palabra

reservada print
57
3.3.2Entrada y salida de datos
Salida en pantalla
La forma más sencilla de producir una salida en python es utilizar la sentencia
print donde se puede pasar 0, una o más expresiones separadas por coma y ver
el resultado en pantalla de la siguiente manera:
Sentencia print en Python
Lectura de entrada con teclado

Python proporciona dos funciones integradas para leer una entrada estándar de
teclado, estas són:
o raw_input
o input
58
Entrada de datos en Python
La función raw_input
La función raw_input([prompt]) lee una línea de entrada y la devuelve como

cadena, ejemplo:
En este ejemplo verás la creación de un archivo.py (Extensión de Python) y su

ejecución, para eso lo primero que debemos hacer será abrir Genay (IDE que
utilizaré para los ejemplos del curso) y agregamos lo siguiente:
Función raw_input
El archivo lo guardas con el nombre raw_input.py (al agregar la extensión .py se
guardará como un archivo Python) y lo ejecutas con F5 o con
Si todo salió bien la salida en pantalla debería ser la siguiente:
59
Salida en pantalla del archivo raw_input.py
La función input
La función input([prompt]) es igual a la función raw_input excepto que input

asume la entrada como una expresión python válida y nos devuelve el resultado
en pantalla.
Para este ejemplo hacemos lo mismo que en el ejemplo anterior (solo cambiamos
el nombre por input.py):
Función input
Ejecutamos y si todo salió bien deberíamos ver lo siguiente:
60
Salida de la función input
En una futura entrada veremos Entrada/Salida de datos pero utilizando archivos

(que por un tema de orden y de complejidad no fue adherida a esta entrada).
3.4Errores en tiempo de ejecución
Errores de sintaxis
Los errores de sintaxis, también conocidos como errores de interpretación, son

quizás el tipo de queja más común que tenis cuando todavía estás aprendiendo
Python:
>>> while True print('Hola mundo')
File "<stdin>", line 1
while True print('Hola mundo') ^
SyntaxError: invalid syntax
El intérprete repite la línea culpable y muestra una pequeña ‘flecha’ que apunta al
primer lugar donde se detectó el error. Este es causado por (o al menos detectado
en) el símbolo que precede a la flecha: en el ejemplo, el error se detecta en la
función print(), ya que faltan dos puntos (':') antes del mismo. Se muestran el
nombre del archivo y el número de línea para que sepas dónde mirar en caso de
que la entrada venga de un programa.
Print (“Hola Mundo”)
61
>>>Hola Mundo
62
Conclusiones:
CERVANTES ARIAS ROBERTO
Mi conclusión es que hicimos un reporte con tres lenguajes de programación en
cada uno de los lenguajes aprendimos su estructura básica del programa también
supimos cuáles eran los elementos de cada lenguaje que hicimos los tipos de
datos que lleva cada lenguaje sus variables y constantes con sus entradas y
salidas de datos también supimos los errores de tiempo que podemos llegar a
cometer a la hora de ejecutar un programa en cada de los lenguajes que hicimos y
lo más importante que aprendimos fue como ejecutar un programa en el lenguaje
que hicimos cada lenguaje es parecido su ejecución y sus sintaxis pero tienen una
función diferente ya que en cada lenguaje podemos programar distintas cosas y a
lo largo de nuestra carrera nos ayudara mucho y facilitarnos las cosas en un futuro
al igual sobre la materia cuando usted maestra nos deje más programas y los
tengamos que realizar durante el transcurso del semestre en laboratorio o durante
en la clase de teoría.
DOROTEO FELIPE EDMAR
Los lenguajes que hablamos en este proyecto son unos de tanto q existen lo que
significa que hay en gran cantidad, algunos han evolucionado a lo largo del tiempo
y siguen vigentes en el transcurso de muchos años, mientras que otros han sido
operativos durante un período más o menos largo y actualmente no se usan. Dada
esta gran variedad de lenguajes, no se pretende dar una visión de todos, sino una
clasificación en diversos tipos y concretar algunos de ellos. En general un lenguaje
es un método conveniente y sencillo de describir las estructuras de información y
las secuencias de acciones necesarias para ejecutar una tarea concreta.
Finalmente, un lenguaje de programación lo definiremos, como un conjunto de
reglas, símbolos y palabras especiales que permiten construir un programa en
difieren compiladores que a su vez comparten algunas características similares un
contra otros para la elabora ración de un programa es importante saber cada uno
de ellos para poder programar si conflictos.
VILLAGÓMEZ SALAZAR BRANDON ALAN
Los Lenguajes de programación son una herramienta que hoy en día es muy
valorada por la comunidad que se enfoca en las tecnologías. Bien es cierto que los
lenguajes de programación en la actualidad son muy buenas para poder hacer
programas que cumplan funciones ya sean simples o complicadas, y estas nos
brinden ayuda mediante el programa haciendo una función o acción que tenga
como propósito cumplirnos un objetivo.
Hay muchos tipos de lenguajes de programación y cada uno tiene sus distintas
características, estructuras, declaraciones etc. Para mí, los lenguajes de
63
programación nos ayudan mucho. Estudiando sobre estos lenguajes podemos
también hacerles de utilidad para poder laborar de ellos, conseguir trabajo además
de que hoy en día es una de las cosas mejores pagadas en las empresas.
64
Referencias
Weiss, Mark Allen: "Estructuras de datos y algoritmos", Addison-Wesley Iberoamericana,
1995.
https://msdn.microsoft.com/es-es/library/aa287550(v=vs.71).aspx
http://dolivasdudem.udem.edu.ni/wp-content/uploads/2014/03/funciones-de-entrada-y-
salida-de-datos-en-c.pdf
http://dis.um.es/~lopezquesada/documentos/IES_1213/IAW/curso/UT3/ActividadesAlumno
s/1/index.html
https://carloszr.com/python-para-todos-elementos/
https://cybersecuritylaboratory.wordpress.com/2016/08/26/variables-y-constantes-en-
python/
http://www.cursodejava.com.mx/cursodejava116.html
https://paginas.matem.unam.mx/pderbf/images/mprogintc++.pdf
http://gy94bfmv.blogspot.mx/2012/10/estructura-basica-de-un-programa-en-c.html
https://es.slideshare.net/rosbelia/estructura-bsica-de-un-programa-en-c
65

Proyec 1 Departamental

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Proyec 1 Departamental

Enviado por

Direitos autorais:

Formatos disponíveis

TECNOLOGICO DE ESTUDIOS SUPERIORES

PROYECTO 1ER DEPARTAMENTAL

PROFESORA: Xóchitl Raquel Wong Cohen

ASIGNATURA: Fundamentos de programación

FECHA DE ENTREGA: 25 de Abril del 2018

PROYECTO 1ER DEPARTAMENTAL

PROFESORA: Xóchitl Raquel Wong Cohen

ASIGNATURA: Fundamentos de programación

FECHA DE ENTREGA: 25 de Abril del 2018

Análisis del problema:

A diario interactuamos con distintos tipos de máquinas como celulares, tablets y

Un lenguaje de programación es básicamente un sistema estructurado de

El término programación se define como un conjunto de instrucciones

1. Lenguajes de programación de bajo nivel. Son aquellos utilizados para

2. Lenguajes de programación de alto nivel. Estos lenguajes son más

¿Qué es el lenguaje de programación JAVA?

Java es un lenguaje de programación de propósito general, concurrente, orientado

El lenguaje de programación Java fue originalmente desarrollado por James

1.1 Estructura básica del programa

La estructura básica de un programa desarrollado usando Java es la siguiente:

Línea 2: La línea numero dos contiene la declaración de la función (o metodo)

Línea 3: La línea tres contiene el bloque de sentencias, es decir, las líneas de

1.2 Elementos del lenguaje

Son el principal mecanismo de encapsulamiento y se forman con un grupo de

Son líneas de texto insertas en el programa para documentarlo y facilitar su

Existen otro tipo de caracteres particulares que sirven para el control y la

1.3 Tipos de dato

REPRESENTACIÓN INTERNA DE LOS DATOS

Debido a lo limitado de su tamaño, el código ASCII no es suficiente para

1.3.1 Variables y constantes

Por ejemplo, en el siguiente trozo de código podemos observarlo:

public class MiClase {

La declaración de una variable miembro aparece dentro del cuerpo de la clase,

El nombre de una variable ha de ser un identificador válido en Java. Por convenio,

 En los dos lenguajes se permite la declaración de variables miembro

Aparte de las diferencias de sintaxis anteriores, Java permite la inicialización de

La sintaxis completa de la declaración de una variable miembro de una clase en

El siguiente ejemplo intenta declarar dos variables separadas con el mismo

La declaración de una variable miembro dentro de la definición de una clase sin

En Java, se accede a las variables de instancia asociadas a un objeto

En C++, se puede acceder a las variables de instancia de un objeto a través de la

class Documento extends Pagina {

El valor de la variable version será el mismo para cualquier objeto instanciado de

En C++, es necesario redeclarar todas las variables estáticas fuera de la definición

Si se examinara en este caso la zona de memoria reservada por el sistema para

En C++, a las variables de clase se accede utilizando el operador de ámbito junto

En Java, a las variables de clase se accede utilizando el nombre de la clase, el

System.out.println( "Hola, Mundo" );

Como es una constante, se le ha de proporcionar un valor en el momento en que

Si se intenta modificar el valor de una variable final desde el código de la

La palabra clave final también se puede aplicar a métodos, significando en este

1.3.2 Entrada y salida de datos

Si miramos la API de PrintStream podemos ver la variedad de métodos para

void print(String s) Escribe un string

void println(String x) Escribe un string y termina la línea.

void println() Termina la línea actual.

La salida de errores: System.err

No parece muy útil utilizar out y err si su destino es el mismo, o al menos en el

Re-definir la salida estándar

Para mostrar como re-definir la salida estándar pondremos en practica el ejemplo

En el ejemplo anterior se crea el archivo correspondiente para cada tipo de salida.

java -jar archivo.jar > salida_normal.txt 2> salida_error.txt

Ó lo siguiente para una clase (.class):