CONCEPTOS

PROGRAMACIÓN: Hacer que las computadoras hagan lo que nosotros queremos

Objetivo: Definir los pasos a seguir para resolver un problema dado y conseguir un resultado
esperado: CONSISTENTE, REPETIBLE Y CONFIABLE

PROGRAMA: Instrucciones ejecutables por el procesador que llevan a cabo un algoritmo que
permiten resolver un problema dado.

ALGORTIMO: un conjunto de reglas, ordenadas de forma lógica, para desarrollar un cálculo o para
solucionar un problema, ya sea de forma manual o utilizando una máquina.

• Este mecanismo comprende 2 conceptos:

DATOS: Que representan “objetos” sobre los que operamos.

PROCEDIMIENTOS: Que son las reglas que definen cómo manipular los datos.

• Un algoritmo debe tener las siguientes características:

Ser preciso: El desarrollo de Ser definido: Si se ejecuta con Ser finito: En la representación
cada paso debe obedecer a un un mismo conjunto de datos de de un algoritmo siempre se
orden lógico. entrada, el resultado será incluyen los pasos inicio y fin.
siempre el mismo.

Presentación formal: Las Corrección: El algoritmo debe Eficiencia: En cuanto menos

formas de presentación son: el ser correcto, es decir debe recursos requiere será más
pseudocódigo, diagrama de flujo satisfacer la necesidad o eficiente el
y diagramas de solucionar el problema para el algoritmo.
Nassi/Schneiderman, entre cual fue diseñado.
otras.

LENGUAJES:

Bajo nivel: Lenguajes de código máquina, son un conjunto de instrucciones en código binario que el
ordenador es capaz de ejecutar directamente, específicos de cada tipo de procesador o CPU. Por
ejemplo: Assembler.

Alto nivel: más parecidos al lenguaje natural, cercanos al problema, nos olvidamos de la estructura
interna del ordenador. Por ejemplo: COBOL, Java, Phyton.

“Código fuente” (source code): documento de texto que contiene las instrucciones en el lenguaje
correspondiente.
EJECUCIÓN DEL CÓDIGO

El código fuente contiene el programa en un formato legible, en el lenguaje de alto nivel

correspondiente

• INTERPRETADO: el código fuente se lee y ejecuta instrucción por instrucción, con poca o
ninguna optimización.
• COMPILADO: el código fuente es procesado por un compilador el cual genera:
• Objeto ejecutable (binario): optimizado por la plataforma de hardware y sistema operativo
correspondiente.
• Bytecodes: es un paso intermedio, que luego será interpretado por una máquina virtual VM

MÁQUINA VIRTUAL

Para que el ejecutable se independiente del sistema operativo (portable) se ejecuta en una MV.

• Ésta “máquina” interpreta el programa compilado (bytecode).

CICLO DE VIDA DEL SOFTWARE

• Diseñar el algoritmo de solución.

• Escribir el código fuente y generar el objetivo ejecutable (script/bytecode/exe).
• Ejecutar la solución y verificar el resultado.
• Debug.

VARIABLES: Son posiciones de memoria donde se guardan:

• Datos de entrada (parámetros).

• Resultados intermedios y datos de salida.

PROGRAMACIÓN EN JAVA

Tipo de datos primitivos Toda información que se maneja en Java

puede representarse por un objeto o por un tipo de dato básico o de
tipo primitivo. Java soporta ocho tipos de datos primitivos:

Una cadena de caracteres es un objeto. El tipo String en Java nos

permite crear objetos que contienen texto (palabras, frases, etc.).
Muchas veces se cree erróneamente que el tipo String es un tipo
primitivo por analogía con otros lenguajes donde String funciona
como una variable elemental. En Java no es así.

Los tipos no primitivos corresponden a objetos

creados a partir de una clase y por ser objetos
asume como valor por defecto null.
CONVERSIONES DE TIPO

Java es un lenguaje fuertemente tipado, o sea estricto a la hora de asignar valores a las variables. El
compilador sólo admite asignar a una variable un dato del tipo declarado en la variable, aunque, en
ciertas circunstancias permite realizar conversiones para almacenar en una variable un dato de tipo
diferente al declarado.

Conversiones implícitas
Las conversiones implícitas son las que se realizan en forma
automática a través del compilador, antes de almacenarlo en una
variable. Ejemplo: un dato de tipo byte es almacenado en la variable b y
luego es convertido a int al asignarlo a la variable i:

Conversiones explícitas

En caso en que no se cumplan las condiciones para una conversión implícita, ésta puede realizar se
en forma explícita utilizando la expresión:

variable_destino=(tipo_destino)dato_origen;

Con esta expresión se le indica al compilador que convierta dato_origen a tipo_destino para que
pueda ser almacenado en la variable destino.

Constantes

Una constante es una variable cuyo valor no puede ser modificado Para definir una constante en Java
se utiliza la palabra reservada final, delante de la declaración del tipo

final tipo nombre_constante=valor;

Ejemplo:

final double pi=3.1416;

PROGRAMACIÓN ORIENTADA A OBJETOS

Es un paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y
programas de computadora. En síntesis podemos decir que vamos a tener un objeto, el que tiene
atributos y características propias del mismo.

Entre los lenguajes existentes podemos citar C++, Java, Smalltalk, etc.

¿Qué es un objeto?

Es una entidad existente en la memoria del ordenador que

tiene unas propiedades (atributos o datos sobre sí mismo
almacenados por el objeto) y unas operaciones disponibles
específicas (métodos).

¿Qué es una clase?

Una clase es un anteproyecto o un prototipo (molde) que define las

variables y métodos comunes a todos los objetos de cierto tipo.

El cuerpo de la clase, encerrado entre { y }, corresponde a la lista de

atributos y métodos que constituyen la clase. No es obligatorio,
pero en general se listan primero los atributos y luego los métodos.

Package: Identifica el paquete que va a contener la clase que

estamos definiendo. Toda clase debe estar contenida en un
paquete. La generación de paquetes permite organizar las clases
de manera estructurada y jerárquica.

Objetos

Una vez creada la clase, es necesario generar objetos a partir de ella. A esta acción se la denomina
instanciar una clase. Las instancias u objetos de una clase se crean con el operador new, que crea la
instancia, la almacena en memoria y devuelve una referencia a la misma que normalmente se guarda
en una variable para posteriormente invocar a los métodos del objeto.

Luego, una vez instanciada la clase, esto es creado el

objeto, podemos operar, accediendo directamente a sus
miembros (métodos o atributos) públicos.

Constructores

El constructor de una clase es una herramienta, a partir de la cual, reservamos la memoria necesaria
para utilizar los objetos, opcionalmente establecemos el estado del nuevo objeto que estamos
creando (esto sería, inicializar sus variables miembro), y por último establecemos la relación entre el
nombre de la variable que creamos, y la porción de memoria donde vamos a guardar el objeto
(referencia al objeto).
Sobrecarga de métodos

Gracias a la sobrecarga de métodos, es posible escribir métodos que tengan el mismo nombre,
siendo su comportamiento diferente. La restricción que debemos cumplir a la hora de utilizar esta
característica es que podemos escribir métodos con el mismo nombre, pero que se diferencien uno
de otro por la cantidad de parámetros, o al menos el tipo de dato de alguno de sus parámetros.

Encapsulamiento

Private: Este modificador sólo es aplicable a los miembros de una clase (atributos y/o métodos), y no
a la clase en sí. El declarar un miembro como private, hace que el uso del miembro esté restringido al
interior de la clase, no pudiendo ser utilizado desde fuera de la misma.

Default (Ninguno): La no utilización de un modificador de acceso, le da al elemento un acceso “por

default”. Si un elemento (clase, método o atributo) tiene acceso por defecto, únicamente las clases
de su mismo paquete tendrán acceso al mismo.

Public: Un elemento (clase, método o atributo) public será visible desde cualquier clase,
independientemente del paquete en que se encuentre.

Métodos getter() y setter()

Para asignar o recuperar el valor de un atributo particular,

vamos a necesitar métodos que estén expuestos al
exterior. En general vamos a llamar a estos métodos “get”
+ el nombre del atributo para recuperar su valor y “set” +
el nombre del atributo para asignarle un valor.

El uso de la palabra this es necesario para invocar a un

miembro del propio objeto en caso que una variable local
y un atributo posean el mismo nombre (para distinguir cuál es el atributo).

Métodos y campos estáticos

Una variable static representa información en toda la clase (todos los objetos de la clase comparten
el mismo dato).

A diferencia de los atributos en general que suelen

ser de tipo privados, los atributos estáticos suelen
llevar el modificador de acceso public(o protected
o ninguno) lo cual permite que puedan ser
accedidos por afuera de la clase. Dado que el método estático no hace referencia a ningún objeto en
particular, no puede hacer referencia a campos y métodos que si dependan de un objeto.

Clases de Envoltorio o Wrapper

Para cada uno de los tipos primitivos Java proporciona una clase que
lo representa. A esas clases se las conoce como clases de
envoltorio, y se diferencian en la nomenclatura de los tipos primitivos
ya que estos se escriben en minúscula, en tanto que los nombres de las clases de envoltorio se
inician con una letra mayúscula (como por convención se escriben todos los nombres de una clase).
Las clases de envoltorio o envolventes en Java son las siguientes:

• java.lang.Boolean
• java.lang.Byte
• java.lang.Character
• java.lang.Double
• java.lang.Integer
• java.lang.Float
• java.lang.Long
• java.lang.Short

Un ejemplo claro para las clases de envoltorio es el método que permite convertir un String en el tipo
primitivo que representa. Por ejemplo:

int i = Integer.parseInt("1000");

String

Permite manipular cadenas de caracteres mediante el uso de los siguientes métodos:

• charAt(int index); • startsWith(prefix);

• equals(); • split(String regex)
• equalsIgnoreCase(String anotherString) • toLowerCase();
• length(); • toUpperCase();
• substring(beginIndex, endIndex); • trim();
• substring(beginIndex);

Scanner

La clase Scanner nos permite manipular de forma simple cualquier ingreso (input) que queramos
realizar en nuestro programa. Por default vamos a utilizar siempre el flujo de entrada estándar
(System.in), de manera que podamos realizar cualquier ingreso de datos a través del teclado de la
computadora.

Scanner teclado = new Scanner(System.in);

int numeroEnteroAIngresar = teclado.nextInt();

De forma similar podremos realizar el ingreso de cualquier tipo de dato primitivo:

• next();
• nextBoolean(); • nextInt();
• nextByte(); • nextLine();
• nextDouble(); • nextLong();
• nextFloat(); • nextShort();