jueves, 15 de octubre de 2009

MANTENIMIENTO DE LA TABLA EMPLEADO

PRACTICA CALIFICADA NRO. 1
MANTENIMIENTO DE LA TABLA EMPLEADO.DBF

1. Crear la tabla Empleado.dbf, con la siguiente estructura:
CAMPO TIPO ANCHO DECIMALES
CODIGO CARÁCTER 6
NOMBRE CARÁCTER 30
DIRECCION CARÁCTER 50
TELEFONO CARÁCTER 8
SUELDOB NUMÉRICO 8 2
FNAC FECHA 8
FING FECHA 8
PROFESION CARÁCTER 20



2. Codificar el programa Principal y guardarlo con el nombre: principal.Prg
SET TALK OFF
SET STATUS OFF
SET SCOREBOARD OFF
USE EMPLEADO
INDEX ON CODIGO TO ORDCOD
OP = 0
DO WHILE OP <> 6
CLEAR
SET COLOR TO B
@00,00 TO 24,79 DOUBLE
SET COLOR TO BG
@01,01,23,78 BOX " "
@2,16 SAY "[ MENU PRINCIPAL ]"
SET COLOR TO RB+
@1,15 TO 3,65 DOUBLE
@4,18 TO 06,62 DOUBLE
@09,16 TO 11,33
@09,47 TO 11,64
@13,16 TO 15,33
@13,47 TO 15,64
@17,16 TO 19,33
@17,47 TO 19,64
@21,04 TO 23,13
@21,66 TO 23,75
SET COLOR TO GR+
@10,17 PROMPT "1.- INGRESOS "
@10,48 PROMPT "2.- CONSULTA I "
@14,17 PROMPT "3.- CONSULTA G "
@14,48 PROMPT "4.- MODIFICACION "
@18,17 PROMPT "5.- ELIMINACION "
@18,48 PROMPT "6.- SALIDA "
@22,05 SAY DATE()
@22,67 SAY TIME()
MENU TO OP
DO CASE
CASE OP = 1
DO I.PRG
CASE OP = 2
DO CI.PRG
CASE OP = 3
DO CG.PRG
CASE OP = 4
DO M.PRG
CASE OP = 5
DO E.PRG
ENDCASE
ENDDO
SET COLOR TO
CLEAR
3. Codificar el programa para ingresar los datos y guardarlo con el nombre: I.prg
SEG = 'S'
DO WHILE UPPER (SEG) <> 'N'
COD = SPACE(6)
STORE SPACE(25) TO NOM, DIR1, PROF
TEL= SPACE(8)
SB = 0.00
FN = DATE()
FI = DATE()
CLEAR
SET COLOR TO B
@00,00 TO 24,79 DOUBLE
SET COLOR TO BG
@04,05 SAY "INGRESE NUEVO CODIGO: "GET COD
READ
SEEK COD
IF FOUND()
@22,20 SAY "CODIGO YA INGRESADO, VERIFIQUE...!"
ELSE
@06,05 SAY "NOMBRE DEL EMPLEADO: " GET NOM
@08,05 SAY "DIRECCION DEL EMPLEADO: " GET DIR1
@10,06 SAY "TELEFONO DEL EMPLEADO: " GET TEL
@12,05 SAY "SUELDO DEL EMPLEADO: " GET SB PICTURE "99,999.99"
@14,05 SAY "FECHA DE NACIMIENTO: " GET FN
@16,05 SAY "FECHA DE INGRESO: " GET FI
@18,05 SAY "PROFESION DEL EMPLEADO: " GET PROF
READ
GRA = 'S'
SET COLOR TO BG+/B+
@21,20 SAY "GRABA LOS DATOS S/N: " GET GRA
READ
IF UPPER(GRA) = 'S'
APPEND BLANK
REPLACE CODIGO WITH COD
REPLACE NOMBRE WITH NOM
REPLACE DIRECCION WITH DIR1
REPLACE TELEFONO WITH TEL
REPLACE SUELDOB WITH SB
REPLACE FNAC WITH FN
REPLACE FING WITH FI
REPLACE PROFESION WITH PROF
@22,20 SAY "GRABACION COMPLETA..!"
ELSE
IF UPPER(GRA) = 'N'
@22,20 SAY "GRABACION CANCELADA..."
ENDIF
ENDIF
ENDIF
@23,20 SAY "CONTINUA INGRESANDO DATOS S/N: " GET SEG
READ
SET COLOR TO
ENDDO
RETURN
4. Codificar el programa para consultas individuales y guardarlo con el nombre: CI.Prg
SEG = 'S'
DO WHILE UPPER(SEG) <> 'N'
COD = SPACE(6)
CLEAR
SET COLOR TO B
@00,00 TO 24,79 DOUBLE
SET COLOR TO BG
@04,05 SAY "CODIGO: " GET COD
READ
SEEK COD
IF FOUND()
STORE NOMBRE TO NOM
STORE DIRECCION TO DIR
STORE TELEFONO TO TEL
STORE SUELDOB TO SB
STORE FNAC TO FN
STORE FING TO FI
STORE PROFESION TO PROF
@06,05 SAY "NOMBRE DEL EMPLEADO: " + NOM
@08,05 SAY "DIRECCION DEL EMPLEADO: " + DIR
@10,05 SAY "TELEFONO DEL EMPLEADO: " + TEL
@12,05 SAY "SUELDO DEL EMPLEADO: "
??SB PICTURE "99,999.99"
@14,05 SAY "FECHA DE NACIMIENTO: "
??FN
@16,05 SAY "FECHA DE INGRESO: "
??FI
@18,05 SAY "PROFESION DEL EMPLEADO: " + PROF
ELSE
SET COLOR TO BG+
@21,20 SAY "EL CODIGO NO EXISTE, VERIFIQUE..!"
ENDIF
SET COLOR TO BG+
@22,20 SAY "CONTINUA CONSULTANDO DATOS? S/N: " GET SEG
READ
ENDDO
RETURN

5. Codificar el programa para consulta general y guardarlo con el nombre: CG.Prg


TOT = 0.00
NLINEA = 22
COLCOD = 3
COLNOM = 10
COLDIR = 39
COLSIM = 67
COLSUE = 70
TIT = "CONSULTA GENERAL DE EMPLEADOS"
ENCA = " CODIGO NOMBRE DIRECCION SUELDO"
GO TOP
DO WHILE .NOT. EOF()
IF NLINEA = 22
CLEAR
SET COLOR TO GR+
@01,25 SAY TIT
SET COLOR TO GR+
@03,01 SAY ENCA
SET COLOR TO RB+
@04,01 SAY "=============================================================================="
NLINEA = 5
ENDIF
SET COLOR TO GR+
@NLINEA,COLCOD SAY CODIGO
@NLINEA,COLNOM SAY NOMBRE
@NLINEA,COLDIR SAY DIRECCION
@NLINEA,COLSIM SAY "Q."
@NLINEA,COLSUE SAY SUELDOB PICTURE "99,999.99"
TOT = SUELDOB + TOT
NLINEA = NLINEA + 1
SKIP
@22,38 SAY "EL TOTAL DE SUELDOS ES: Q."
SET COLOR TO G+
@22,70 SAY TOT PICTURE "99,999.99"
IF NLINEA = 22
SET COLOR TO R+*
@23,30 SAY "PRESIONES ENTER..!"
WAIT" "
SET COLOR TO
ENDIF
ENDDO
IF NLINEA < 22
SET COLOR TO R+*
@23,30 SAY "PRESIONE ENTER..!"
WAIT" "
SET COLOR TO
ENDIF
RETURN

6. Codificar el programa para modificar los datos y guardarlo con el nombre: M.prg
SEG = 'S'
DO WHILE UPPER(SEG) <> 'N'
CLEAR
COD = SPACE(6)
SET COLOR TO B
@00,00 TO 24,79
SET COLOR TO BG
@04,05 SAY "CODIGO: " GET COD
READ
SEEK COD
IF FOUND()
STORE NOMBRE TO NOM
STORE DIRECCION TO DIR1
STORE TELEFONO TO TEL
STORE SUELDOB TO SB
STORE FNAC TO FN
STORE FING TO FI
STORE PROFESION TO PROF
@06,05 SAY "NOMBRE DEL EMPLEADO :" GET NOM
@08,05 SAY "DIRECCION DEL EMPLEADO: " GET DIR1
@10,05 SAY "TELEFONO DEL EMPLEADO: " GET TEL
@12,05 SAY "SUELDO DEL EMPLEADO: "GET SB PICTURE "99,999.99"
@14,05 SAY "FECHA DE NACIMIENTO: "GET FN
@16,05 SAY "FECHA DE INGRESO: " GET FI
@18,05 SAY "PROFESION DEL EMPLEADO: " GET PROF
GRA = 'S'
SET COLOR TO BG+
@20,23 SAY "MODIFICA LOS DATOS? S/N: " GET GRA
READ
IF UPPER(GRA) = 'N'
@21,23 SAY "MODIFICACION CANCELADA..!"
ELSE
IF UPPER(GRA) = 'S'
REPLACE NOMBRE WITH NOM
REPLACE DIRECCION WITH DIR1
REPLACE TELEFONO WITH TEL
REPLACE SUELDOB WITH SB
REPLACE FNAC WITH FN
REPLACE FING WITH FI
REPLACE PROFESION WITH PROF
@21,23 SAY "MODIFICACION COMPLETA..!"
ENDIF
ENDIF
ELSE
SET COLOR TO BG+
@21,23 SAY "CODIGO NO ENCONTRADO, VERIFIQUE..!"
ENDIF
@22,23 SAY "MODIFICA OTRO CODIGO? S/N: " GET SEG
READ
ENDDO
RETURN

7. Codificar el programa para eliminar datos y guardarlo con el nombre: E.Prg
SEG = 'S'
DO WHILE UPPER(SEG) <> 'N'
COD = SPACE(6)
CLEAR
SET COLOR TO B
@00,00 TO 24,79 DOUBLE
SET COLOR TO BG
@04,05 SAY "CODIGO: " GET COD
READ
SEEK COD
IF FOUND()
STORE NOMBRE TO NOM
STORE DIRECCION TO DIR1
STORE TELEFONO TO TEL
STORE SUELDOB TO SB
STORE FNAC TO FN
STORE FING TO FI
STORE PROFESION TO PROF
@06,05 SAY "NOMBRE DEL EMPLEADO: " +NOM
@08,05 SAY "DIRECCION DEL EMPLEADO: " +DIR1
@10,05 SAY "TELEFONO DEL EMPLEADO: " +TEL
@12,05 SAY "SUELDO DEL EMPLEADO: "
??SB PICTURE "99,999.99"
@14,05 SAY "FECHA DE NACIMIENTO: "
??FN
@16,05 SAY "FECHA DE INGRESO: "
??FI
@18,05 SAY "PROFESION DEL EMPLEADO: " +PROF
ELI = 'S'
SET COLOR TO BG+
@20,23 SAY "ELIMINA LOS DATOS? S/N: " GET ELI
READ
IF UPPER(ELI) = 'S'
DELETE
PACK
@21,23 SAY "ELIMINACION COMPLETA..!"
ELSE
IF UPPER(ELI) = 'N'
@21,23 SAY "ELIMINACION CANCELADA..!"
ENDIF
ENDIF
ELSE
SET COLOR TO BG+
@21,23 SAY "CODIGO NO ENCONTRADO, VERIFIQUE..!"
ENDIF
SET COLOR TO BG+
@22,23 SAY "ELIMINA MAS DATOS? S/N: " GET SEG
READ
ENDDO
RETUR

martes, 2 de junio de 2009

Sesión de Aprendizaje del 3/06/09 al 05/06/09

BASE DE DATOS
1. Concepto:
Una base de datos es una colección de información organizada de forma que un programa de ordenador pueda seleccionar rápidamente los fragmentos de datos que necesite. Una base de datos es un sistema de archivos electrónico.
Las bases de datos tradicionales se organizan por campos, registros y archivos. Un campo es una pieza única de información; un registro es un sistema completo de campos; y un archivo es una colección de registros. Por ejemplo, una guía de teléfono es análoga a un archivo. Contiene una lista de registros, cada uno de los cuales consiste en tres campos: nombre, dirección, y número de teléfono.
A veces se utiliza DB, de database en inglés, para referirse a las bases de datos.
2. Características:
Entre las principales características de los sistemas de base de datos podemos mencionar:
Independencia lógica y física de los datos.
. Redundancia mínima.
. Acceso concurrente por parte de múltiples usuarios.
. Integridad de los datos.
. Consultas complejas optimizadas.
. Seguridad de acceso y auditoria.
. Respaldo y recuperación.
. Acceso a través de lenguajes de programación estándar.
3. Ventajas de las bases de datos:
· Control sobre la redundancia de datos:
Los sistemas de ficheros almacenan varias copias de los mismos datos en ficheros distintos.
· Consistencia de datos:
Eliminando o controlando las redundancias de datos se reduce en gran medida el riesgo de que haya inconsistencias.
· Compartición de datos:
En los sistemas de ficheros, los ficheros pertenecen a las personas o a los departamentos que los utilizan. Pero en los sistemas de bases de datos, la base de datos pertenece a la empresa y puede ser compartida por todos los usuarios que estén autorizados.
· Mantenimiento de estándares:
Gracias a la integración es más fácil respetar los estándares necesarios, tanto los establecidos a nivel de la empresa como los nacionales e internacionales.
· Mejora en la integridad de datos:
La integridad de la base de datos se refiere a la validez y la consistencia de los datos almacenados.
· Mejora en la seguridad:
La seguridad de la base de datos es la protección de la base de datos frente a usuarios no autorizados.
· Mejora en la accesibilidad a los datos:
Muchos SGBD proporcionan lenguajes de consultas o generadores de informes que permiten al usuario hacer cualquier tipo de consulta sobre los datos, sin que sea necesario que un programador escriba una aplicación que realice tal tarea.
· Mejora en la productividad:
El SGBD proporciona muchas de las funciones estándar que el programador necesita escribir en un sistema de ficheros.
· Mejora en el mantenimiento:
En los sistemas de ficheros, las descripciones de los datos se encuentran inmersas en los programas de aplicación que los manejan.
· Aumento de la concurrencia:
En algunos sistemas de ficheros, si hay varios usuarios que pueden acceder simultáneamente a un mismo fichero, es posible que el acceso interfiera entre ellos de modo que se pierda información o se pierda la integridad.
· Mejora en los servicios de copias de seguridad:
Muchos sistemas de ficheros dejan que sea el usuario quien proporcione las medidas necesarias para proteger los datos ante fallos en el sistema o en las aplicaciones.
4. Desventajas de las bases de datos
. Complejidad:
Los SGBD son conjuntos de programas que pueden llegar a ser complejos con una gran funcionalidad. Es preciso comprender muy bien esta funcionalidad para poder realizar un buen uso de ellos.
. Coste del equipamiento adicional:
Tanto el SGBD, como la propia base de datos, pueden hacer que sea necesario adquirir más espacio de almacenamiento. Además, para alcanzar las prestaciones deseadas, es posible que sea necesario adquirir una máquina más grande o una máquina que se dedique solamente al SGBD. Todo esto hará que la implantación de un sistema de bases de datos sea más cara.
. Vulnerable a los fallos:
El hecho de que todo esté centralizado en el SGBD hace que el sistema sea más vulnerable ante los fallos que puedan producirse. Es por ello que deben tenerse copias de seguridad (Backup).
5. Tipos de Campos
Cada Sistema de Base de Datos posee tipos de campos que pueden ser similares o diferentes. Entre los más comunes podemos nombrar:
Numérico: entre los diferentes tipos de campos numéricos podemos encontrar enteros “sin decimales” y reales “decimales”.
Booleanos: poseen dos estados: Verdadero “Si” y Falso “No”.
Memos: son campos alfanuméricos de longitud ilimitada. Presentan el inconveniente de no poder ser indexados.
Fechas: almacenan fechas facilitando posteriormente su explotación. Almacenar fechas de esta forma posibilita ordenar los registros por fechas o calcular los días entre una fecha y otra.
Alfanuméricos: contienen cifras y letras. Presentan una longitud limitada (255 caracteres).
Autoincrementables: son campos numéricos enteros que incrementan en una unidad su valor para cada registro incorporado. Su utilidad resulta: Servir de identificador ya que resultan exclusivos de un registro.
6. Administración de datos y de la base de datos:
El administrador de datos y el administrador de la base de datos son las personas o grupos de personas encargadas de gestionar y controlar todas las actividades que tienen que ver con los datos de la empresa y con la base de datos, respectivamente.
El administrador de datos es quien entiende los datos y las necesidades de la empresa con respecto a dichos datos. Su trabajo es decidir qué datos deben almacenarse en la base de datos y establecer políticas para mantener y gestionar los datos. Un ejemplo de tal política sería una que estableciera quién puede realizar qué operaciones sobre qué datos y en qué circunstancias.
La persona (o personas) que se encarga de implementar las decisiones del administrador de datos es el administrador de la base de datos. Su trabajo es crear la base de datos e implementar los controles necesarios para que se respeten las políticas establecidas por el administrador de datos. El administrador de la base de datos es el responsable de garantizar que el sistema obtenga las prestaciones deseadas, además de prestar otros servicios técnicos.

domingo, 31 de mayo de 2009

SESIÓN DE APRENDIZAJE DEL 27/05/09 AL 29/05/09

Orientado a Objetos
El objetivo de esta nota es poder llevar al Programador Medio o Principiante a comprender conceptos que conforman la programación Orientada a Objetos.
Estos conceptos son :
• Clases
• Objetos
• Propiedades
• Métodos
• Eventos
• Herencia
• Abstracción
• Polimorfismo
• Encapsulamiento
Trataré de explicar cada uno de estos conceptos de la manera más comprensible y didáctica posible.Clases y Objetos
Estos 2 conceptos deben explicarse juntos para que sean mejor comprendidos.Si tuviera que rápidamente definir con un ejemplo cual es la diferencia entre una Clase y un Objeto, se me ocurre la misma diferencia entre una RECETA y una COMIDA.Nuestra Clase, no es mas que una RECETA, que carece de sentido y funcionalidad hasta que creamos un Objeto (COMIDA).
Esta Clase (RECETA) nos dice de que propiedades, y características estará conformado nuestro Objeto.Ejemplo….Dim MiComida as NEW Paella
Aquí estamos creando un Objeto llamado MiComida y será de tipo PAELLA.
PAELLA es una clase que contiene todas las Propiedades necesarias (RECETA) que indica como debe ser creado nuestro objeto.
Coincidirán conmigo que una RECETA no es absolutamente nada hasta que se convierte en algo tangible como es una COMIDA.
Entonces.. Un Objeto gracias al código contenido en la clase va a tener Propiedades y Métodos.Un Objeto no es mas que una Instancia en memoria de una Clase. Es por eso que al igual que en un Restaurante un cocinero puede crear una Paella (OBJETO) muchísimas veces tomando de referencia la Receta (CLASE), en memoria, pueden existir innumerables Objetos creados por la misma Clase.
Cada Objeto creado en memoria, será pasible de cambios en sus propiedades por parte de la aplicación y cada unos será absolutamente independiente del otro.
Por Ejemplo…
Si tuviera una Clase PERRO y dotara a mi Clase de la Propiedad ColordePelo. Podría escribir el siguiente código.
Dim Perro1 as New Perro, Perro2 as New Perro
Perro1.ColordePelo=”Blanco”Perro2.ColordePelo=”Marron”En este Ejemplo he creado 2 PERROS, uno llamado Perro1 y otro Perro2. Y le modifiqué la propiedad ColordePelo a Perro1 y a Perro2, pero cada uno de ellos es totalmente independiente y ahora tengo 2 Objetos que fueron creados Exactamente Iguales en su origen, pero que ahora tienen características diferentes.
Otra Última comparación entre Clases y Objetos que se me ocurre, es la que existe entre un Plano y una Casa.
El PLANO es la CLASE que contiene todas las propiedades y características que tendrá que contener mi OBJETO (CASA) coincidirán nuevamente conmigo de que un simple Plano no es mas que una IDEA que tomará forma cuando se lleve a cabo creando nuestro Objeto CASA. PROPIEDADESComo ya hemos visto en nuestra explicación anterior un OBJETO contiene (entre otras cosas que luego explicaremos) Propiedades.
Volviendo a nuestro ejemplo, de nuestro Objeto PERRO, podríamos con solo pensarlo definir un conjunto de Propiedades que debería contener nuestro Objeto.
Por Ejemplo :
ColordePelo de tipo String
Raza de tipo String
Edad de tipo Integer
EsAgresivo de tipo Bolean
Por supuesto a Uds. Se le ocurrirán otras Propiedades, y características.Si pensamos en Programación Visual, Un Formulario no es mas que un Objeto que fue creado tomando como base una Clase que contiene todas las Propiedades que debe contener dicho Objeto.Por Ejemplo :
Caption , Font, Width, Height, Picture, ControlBox, etc.
Una Propiedad puede ser de Solo Lectura (ReadOnly) o con permisos de Lectura/Escritura.Esto significa que existen propiedades a las cuales NO Podremos asignarle valores, solamente podemos leer su contenido.
MÉTODOSYa sabemos que un Objeto no es más que una Instancia de una Clase.También sabemos que un Objeto contiene una o muchas Propiedades.Sabemos que nuestro “PERRO” tiene propiedades, pero también es cierto que nuestro PERRO al igual que muchos objetos, es capaz de realizar ACCIONES.
Por Ejemplo….
CORRERSALTARCOMEREsas acciones se denominan Métodos. Volviendo al ejemplo del FORMULARIO, un Formulario contiene muchísimas Propiedades tal como hemos señalado, pero también es capaz de ejecutar acciones CLOSE, RESIZE, MOVE, SHOW, etc.
En nuestra Clase PERRO, deberemos programar cada uno de los Métodos que necesitemos que sea capaz de llevar a cabo nuestro Objeto y dichos métodos no son mas que SUBs.Debemos colocar en cada unos de esos SUBs o Procedimientos, todo el código necesario que se debe ejecutar cuando una aplicación ejecuta por ejemplo…

miPerro.SaltarCuando pensemos en Objetos nos daremos cuenta de que el objetivo primario es Imitar a la vida real a Objetos reales, que gozan de Propiedades, ejecutan acciones y como veremos a continuación sufren estímulos externos e Internos.
EVENTOSComo acabamos de ver un Objeto es capaz de realizar acciones pero también esta expuesto a estímulos que lo condicionan y nosotros podremos determinar cuales serán los estímulos que a los cuales se les prestará atención.
Esos estímulos se llaman EVENTOS.
El ejemplo mas claro es el del EVENTO CLICK de un BOTON. , el cual dota a nuestro Objeto para que sea SENSIBLE al CLICK del MOUSE ejecutado por algún usuario en un momento indeterminado.Entonces, podemos hacer que nuestro OBJETO sea sensible a determinados estímulos.Podríamos crear un OBJETO “SER HUMANO” y volverlo sensible al CALOR, al HAMBRE, al FRIO, etc,
Conclusión :
Un Objeto es una Instancia de una Clase, y puede constar o no, de Propiedades, Métodos y ser sensible de sufrir Eventos.
HERENCIALa HERENCIA es sin lugar a dudas la característica más Importante que tienen los OBJETOS y nos indica que un OBJETO puede HEREDAR las Propiedades, Métodos y Eventos de otro OBJETO.Supongamos que creamos una CLASE llamada ANIMALES.
Dotaremos a nuestra Clase ANIMALES de todas las Propiedades inherentes a los ANIMALES y lo haremos de manera tal, que dicha clase nos servirá para referenciar a cualquier Animal.Pero luego se nos ocurre crear una CLASE llamada PERRO.
Como ya poseemos una CLASE desarrollada de tipo ANIMAL y que contiene innumerables propiedades que me sirven para conformar mi nueva CLASE PERRO, simplemente debo decir mediante código que mi CLASE PERRO, hereda las propiedades de la CLASE ANIMALES, entonces ya no necesito escribir código para muchísimas propiedades y métodos que son comunes a todos los animales.
Entonces….Si ya poseo una Clase MUEBLES y deseo crear una Clase SILLA, para que voy a volver a programar la propiedad MATERIAL, o la propiedad MEDIDAS ?, si esas Propiedades son comunes a todos los muebles ?
Esta filosofía nos enseña a programar de lo General a lo Particular.Y por sobre todas las cosas a Programar lo mas ABSTRACTO posible.
ABSTRACCIÓN La ABSTRACCIÓN es también uno de los Aspectos fundamentales que tenemos que tener en cuenta a la hora de programar Objetos.
Nuestra CLASE ANIMALES debe ser lo suficientemente ABSTRACTA para que podamos utilizarla para la creación de un número importante de Animales.
En definitiva… NO debe contener características peculiares ni delimitantes.Si creamos la CLASE ANIMALES e internamente le indicamos que estamos hablando de MAMIFEROS, esa CLASE no nos servirá para crear un PEZ.
Si creamos la CLASE PERSONAS y le decimos que son todos RUBIOS, esa clase no nos permitirá crear ningún OBJETO que nos sirva para manejar PERSONAS MORENAS.
Si creamos la CLASE MUEBLES y si forzamos nuestra CLASE indicándole que posee 2 puertas… como creamos una SILLA ?
Es muy común caer en este error, y habitualmente cuando debemos contra reloj crear aplicaciones, nos olvidamos de la ABSTRACCION y creamos código que luego no podemos reutilizar en otras aplicaciones debido a su particularidad.
La consigna es la REUTILIDAD de nuestros OBJETOS, que sean lo suficientes ABSTRACTOS para que puedan amoldarse a nuestros nuevos proyectos y no necesitemos escribir nuevamente tanto código.LA ABSTRACCIÓN y LA HERENCIA entonces se convierten en amigos INSEPARABLES e FUNDAMENTALES en la Programación ORIENTADA a OBJETOS.
POLIMORFISMOPOLIMORFISMO nos da idea de MULTIPLES FORMAS, y es en realidad la necesidad de dotar a nuestra clase de la posibilidad de que sus métodos o propiedades se comporten de manera diferente dependiendo de parámetros.
Supongamos que necesitamos dar salida a una determinada información y construimos una CLASE que contiene un método DarSalida y dicho método es el encargado de formatear la información necesaria y generar el OUTPUT de la mima.
Pero… ¿A dónde saldrá la información ?
¿Saldrá por la Impresora?, ¿Se enviará por Email ? o ¿Se exportará a un Archivo ? El usuario deberá manejar 3 métodos diferentes para cada una de estas variantes.
Debemos programar nuestros métodos para que se adapten a los parámetros externos y se comporten de manera diferente.
ENCAPSULAMIENTO La consigna de ENCAPSULAMIENTO nos orienta programar OBJETOS que solamente hagan pública la información mínima y necesaria que necesita el usuario de ese Objeto.QUE SE HACE pero NO COMO SE HACE.
De esta manera nuestro código estará seguro previniendo de que el Usuario pueda interferir en procesos internos.

Cuando nosotros le decimos a un Formulario que se cierre … Form1.Close Ese formulario simplemente hace lo que le indicamos, pero no tenemos acceso al código que se ejecuta en el momento de disparar el método.
La abundancia de Información a veces es contraproducente, se trata de que un Objeto exteriorice solo lo estrictamente necesario.
De esta manera nuestro OBJETO estará más protegido de errores, y crearemos así una capa adicional entre el NÚCLEO del OBJETO y el USUARIO.
Es Evidente que para cada uno de estos términos pueden existir miles de Explicaciones diferentes y ejemplos diferentes a los que yo he dado. Esta es simplemente mi visión de las cosas y realmente espero que sirva para muchos.

miércoles, 20 de mayo de 2009

SESIÓN DE APRENDIZAJE Nº1 DEL 20/05/09 AL 22/05/09

Programación Visual y Orientada a Objetos

1. CONCEPTO:
La Programación Orientada a Objetos (POO u OOP según sus siglas en inglés) es un paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y programas de computadora. Está basado en varias técnicas, incluyendo herencia, modularidad, polimorfismo, y encapsulamiento. Su uso se popularizó a principios de la década de 1990. Actualmente son muchos los lenguajes de programación que soportan la orientación a objetos.
Objeto:
Es un paquete de software que contiene una colección de datos y procedimientos relacionados.
En la POO los procedimientos se llaman MÉTODOS y los elementos de datos PROPIEDADES.
En sus PROPIEDADES se expresa todo lo que conoce un objeto y en sus MÉTODOS todo lo que puede hacer.
Cada objeto forma una unidad autocontenida e independiente.
2. CARACTERÍSTICAS:
· Encapsulado,
es el proceso de combinar datos y procedimientos encadenados lógicamente dentro de una clase/objeto.
Ventajas del Encapsulado:
· Protege los datos ante la corrupción que puedan causar otros objetos o partes del programa.
· Oculta los detalle de implementación compleja al resto del programa.
· Facilita la depuración y pruebas.
· Permite la reutilización de los objetos por otros programadores.
· Abstracción, es el proceso de abstraer lógicamente los datos y procedimientos que están relacionados dentro de una misma clase.
Ventajas de la Abstracción:
· Centrarse en las características esenciales de las clases abstraídas
· Ocultar los detalles de la implementación compleja.
· Fomentar la reutilización de las clases por otros programadores.
· Polimorfismo, es un método individual que tiene el mismo nombre en distintos objetos y realiza la misma función, aunque su implementación dentro de cada objeto sea distinta.
Ventajas del Polimorfismo:
· Simplificar el interface público de un objeto.
· Reduce el tamaño y aumenta la velocidad .
· Promocionar la reutilización del objeto por otros programadores
· Herencia, es el proceso mediante el cual todas las subclases de una superclase pueden utilizar los miembros de esa superclase/objeto.
Existen dos tipos de herencia: simple y múltiple.
Ventajas de la Herencia:
· Minimizar la programación redundante.
· Reducir el tamaño y optimizar la velocidad
· Aumentar la flexibilidad de la programación
El Encapsulado y el Polimorfismo son el corazón de la POO.
3. VENTAJAS:
· Fomenta la reutilización y extensión del código.
· Permite crear sistemas más complejos.
· Relacionar el sistema al mundo real.
· Facilita la creación de programas visuales.
· Construcción de prototipos
· Agiliza el desarrollo de software
· Facilita el trabajo en equipo
· Facilita el mantenimiento del software
Lo interesante de la POO es que proporciona conceptos y herramientas con las cuales se modela y representa el mundo real tan fielmente como sea posible.

lunes, 20 de abril de 2009

5TO. SEC. I.E.P. CLARETIANO - TRUJILLO

La Sentencia With



La tarea de el selector de campo completo cada vez que se referencia un campo de un registro es tedioso, sobre todo si el número de campos es grande.
La sentencia With permite referenciar el nombre del registro en su cabecera y posteriormente para llamar algún campo solo se necesita el nombre del campo y no el del selector de campo completo, con el nombre del registro.
Sintaxis:
With Variable Registro do
Begin
Sentencia que hacen referencia a campos de las variables del registro
End;
Variables Registro: nombre o nombres de registros
Sentencias: relacionadas con los campos
Ejemplos :
1.


Considere las siguientes declaraciones :
Type
Prueba = record
F1 : integer;
F2 : string [12];
Var
X : prueba;
Un modo de asignar valores a un registro y luego visualizarlo es con With, el cual puede ser:
With x do
Begin
F1 := 20;
F2 : =‘José María’;
End;
Writeln (x.F1, x.F2);
2.


With empleado do
writeln ( nombre) equivale a writeln (empleado.nombre);
Precauciones en el uso de la sentencia With
Aunque la sentencia With es muy útil para reducir la longitud de las sentencias de un programa que manipulan componentes de un registro, también puede reducir la claridad de las sentencias y producir ambigüedades. En particular deberá tener especial cuidado cuando incluya más de una variable registro en una sentencia With, ya que se puede producir ambigüedad aparente. Pascal siempre utiliza la variable registro más próxima.
Ejemplo
Type
Empleado = record
Nombre : string [20];
Edad : integer;
Empresa : string[30];
End;
Var
Socio : Empleado;
Jefe : Trabajador;
Deducciones : real;
Begin
with socio do
Begin
Readln (Nombre);
Neto : =Salario – Deducciones;
Writeln (Empresa);
End;
Nombre y Empresa referencian a la variable Socio, mientras que Salario se refiere a la variable Jefe.



Archivos


Un archivo es una estructura de datos consistente en una secuencia de elementos o componentes llamados registros, todos del mismo tipo, ya sea simple o estructurado. A diferencia de los arrays un archivo puede almacenarse en un dispositivo auxiliar disco, cintas, etc. de forma que los datos obtenidos durante y después del procesamiento no se pierdan.
Un archivo o fichero (file) es una colección de información (datos relacionados entre si) localizada o almacenada como una unidad en alguna parte de la computadora. Esta colección de datos sirve para entrada y salida a la computadora y se manejan con un programa.

Todos los archivos de Pascal independientemente del tipo, comparten características comunes. En primer lugar, todos los archivos se utilizan tanto para entradas (input) como para salidas (output) . La entrada es cuando un programa toma los datos de un archivo y utiliza éste en el programa; la salida, almacena el resultado de un programa en un archivo o envía los resultados a un dispositivo como un Terminal o una impresora. Aunque es posible que el archivo se utilice para entradas y salida.
Tipos de Archivos:
Archivo de Texto:
Los archivos de texto se componen de líneas que terminan en un cambio y avance de línea (CR/LF) , y contienen caracteres, palabras y sentencias.
La combinación CR/LF (códigos de ASCII 10 y 13) se conoce como un delimitador. Un delimitador marca el final de algún elemento, tal como un campo, registro, o este caso el fin de una línea. Se puede saber si un archivo es de texto utilizando la orden TYPE del DOS.
ARCHIVOS TIPIFICADOS:
Los archivos tipificados son archivos que contienen datos de un tipo particular, tales como enteros, reales, registros, etc. Estos archivos pueden hacer una programación más fácil y eficiente. De echo los archivos tipificados, proporcionan entradas y salida mucho más rápidas de las que hacen los archivos de texto.
Estos archivos tienen una estructura rígida que depende, y se define, según el tipo de datos que ellos mantiene.
Archivos no Tipificados:
Son unas herramientas especialmente eficientes proporcionados por Pascal. Mientras los archivos de texto suponen que un archivo consta de líneas terminadas con CR/LF y los archivos tipificados suponen que un archivo consta de una particular estructura de datos, los archivos no tipificados no hacen suposiciones sobre la estructura de datos. Se pueden leer los datos de un archivo no tipificado con cualquier tipo de dato.
Como no hace suposiciones la transferencia desde el disco a la estructura de datos es inmediata. Esto es porque los archivos no tipificados se utilizan para aplicaciones que requieren entradas y salidas a alta velocidad.


Tipos de acceso a un archivo:
Existen dos modalidades para acceder a un archivo de datos: acceso secuencial y acceso directo o aleatorio. El acceso secuencial exige elemento a elemento, es necesario una exploración secuencial comenzando desde el primer elemento. El acceso directo permite procesar o acceder a un elemento determinado haciendo una referencia directamente por su posición en el soporte de almacenamiento. Pascal estándar sólo admite el acceso secuencial, pero Turbo Pascal permite el acceso directo.
Los Archivos Tipeados (Con Tipo):
También llamados archivos binarios, contienen datos de tipo simple o estructurado, tales como integer, real , record, etc., excepto otro tipo de archivos. Los archivos con tipos están estructurados en elementos o registros (record) cuyo tipo puede ser cualquiera. A los elementos de estos archivos se accede directamente, al no situarse éstos en posiciones físicamente consecutivas, sino en posiciones lógicas. Esta es la razón por la cual se les denomina archivos de acceso aleatorio o directo. Los elementos de los archivos aleatorios son de igual tamaño y el término acceso directo significa que es posible acceder directamente a un elemento con solo especificar su posición. Declaración y asignación de archivos La declaración de un archivo con tipo se efectúa con la ayuda de las palabras reservadas file of. El procedimiento de asignación es idéntico al utilizado anteriormente.
Ejemplo:
Type
datos = record
clave : integer;
nombre : string[30];
puesto : string[20];
sueldo : real;
estado : boolean;
{true activo,false baja lógica}
end;
Var
archivo:file of datos;
Begin
Assign(archivo,'empleado.dat');
Archivos Sin Tipo:
Todos los archivos utilizados hasta ahora suponen algún tipo de estructura. Si no se conoce la estructura del registro se debe utilizar un archivo sin tipo. Los archivos sin tipo son canales de E/S de bajo nivel, principalmente utilizados para acceso directo a cualquier archivo de disco con independencia del tipo y estructura. Cualquier archivo de disco puede ser declarado como sin tipo. Turbo Pascal permite tratar un archivo como una serie de bloques sin necesidad de conocer el tipo de datos que contiene.
Archivos de Acceso Secuencial (Con Tipo)
Dependiendo de la manera en que se accedan los registros de un archivo, se le clasifica como secuencial o como directo. En el caso de los archivos de acceso secuencial, para tener acceso al registro localizado en la posición N, se deben haber accedido los N-1 registros previos, en un orden secuencial. Cuando se tienen pocos registros en un archivo, o que los registros son pequeños, la diferencia entre los tiempos de acceso de forma secuencial y directa puede no ser perceptible para el usuario; sin embargo, la diferencia viene a ser significativa cuando se manejan archivos con grandes cantidades de información. La forma de manejar los archivos de acceso secuencial es más sencilla en la mayoría de los lenguajes de programación, por lo que su estudio se antepone al de los archivos de acceso directo. El manejo secuencial de un archivo es recomendable cuando se deben procesar todos o la mayoría de los registros, como por ejemplo en los casos de una nómina de empleados o en la elaboración de reportes contables.
Tratamiento de Archivos desde Turbo Pascal:
El Turbo Pascal permite manipular archivos y directorios en disco de modo similar al sistema operativo MS-DOS. Pudiéndose realizar las siguientes operaciones con archivos y directorios:
Erase(nomvararchivo)
Rename(nomvararchivo,'nombrenuevoarchivo')
Chdir (directorio)
Mkdir (directorio)
Rmdir (directorio)
Getdir(unidad,camino)
Unidad = 0 unidad de arranque
Unidad = 1 A:
Unidad = 2 B:
Unidad = 3 C:
Camino contiene el directorio actual.
Gestión de archivos
La siguiente tabla recopila todos los procedimientos y funciones estándar para el tratamiento y manipulación de archivos en Turbo Pascal
Assign:
Éste procedimiento realiza la operación de asignar un archivo mediante una correspondencia entre una variable tipo archivo con un archivo externo situado en un disco.
Formato:
Assign(f,nombre);
f: nombre interno del archivo por el que se conoce el archivo dentro del programa(por ejemplo, el utilizado en la declaración)
nombre: nombre externo con el que se conoce el archivo por el sistema operativo (por ejemplo : 'a:program4.pas'); es una cadena que se define como una constante en el programa o bien una variable cuyo valor se lee interactivamente; puede ser una unidad:nombre.extensión o bien la ruta completa a un archivo.
Ejemplo :
Const
ruta ='c:\tp\lista.pas';
Var
ArchText : Text;
ArchBin : File;
Begin
assign (ArchText,ruta);
assign (ArchBin,'alumnos.dbf')


ChDir:


Formato:


ChDir(s);
Cambia el subdirectorio actual al especificado por la variable de cadena s.
Ejemplo: (asignación del archivo lista.pas ubicado en c:\tp\lista.pas)7
Var
ArchText : Text;
Begin
ChDir('C:\tp\');
assign (ArchText,'lista.pas');
CLOSE:
Éste procedimiento nos permite cerrar los archivos después que han sido utilizados, si los archivos no son cerrados se perderán los datos que se encuentran en la memoria auxiliar.
Formato :
Close (f);
F : Variable de archivo.
Ejemplo:
Var
ArchText : Text;
Begin
assign (ArchText,'c:\tp\lista.pas');
rewrite(ArchText);
close(ArchText);


Erase:
Éste procedimiento nos permite borrar un archivo, el archivo a borrar no debe estar abierto. Para borrar un archivo se debe realizar lo siguiente :
1. Asignar el archivo externo a una variable de archivo.
2. Llamar al procedimiento erase
Formato:
Erase(s);
Borra (elimina) un archivo cuya ruta de acceso está especificada por s.
Ejemplo:
Var
ArchText : Text;
Begin
assign (ArchText,'c:\tp\lista.pas');
erase(ArchText);


GetDir:
Formato :
GetDir(i,s);
Busca el nombre del subdirectorio actual. El primer parámetro i es un entero que representa la unidad : i=0 (unidad de disco actual, por defecto), i=1 (unidad A), i=2 (unidad B), etc. Después de la llamada, la variable de cadena s contiene el subdirectorio actual de esa unidad.
Ejemplo:
Var
s:string[80];
Begin
ChDir('c:\tp\');
GetDir(0,s);
WriteLn(s); {Resulta c:\tp}

MkDir:
Formato:
MkDir(s);
Crea un nuevo subdirectorio de nombre s.
Ejemplo:
Begin
MkDir('C:\nuevo\');

Rename:
Éste procedimiento renombra (cambia el nombre) un archivo externo. Para renombrar un archivo se debe hacer lo siguiente :
1. Asignar un archivo a la variable archivo
2. Llamar al procedimiento rename
Formato:
Rename(f,nombre_archivo)
f : variable de archivo
nombre_archivo : nuevo nombre del archivo

Ejemplo :
Var
ArchText : Text;
Begin
Assign (ArchText,'viejo.pas');
Rename (ArchText,'nuevo.pas');


Reset:
Éste procedimiento abre un archivo existente para una operación de lectura. Si se intenta llamar a Reset y el archivo especificado no existe, se producirá un error de E/S (entrada/salida).
Formato :
Reset(f);
f : variable de tipo archivo
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Reset(ArchText);


Rewrite:
Crea y abre un nuevo archivo. Si el archivo ya existe, Rewrite borra su contenido; en caso contrario, el archivo queda abierto para una operación de escritura.
Formato:
Rewrite(f);
f: variable de archivo
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Rewrite(ArchText);


RmDir:
Elimina el subdirectorio de nombre s.
Formato:
RmDir(s);
Ejemplo:
Begin
RmDir('C:\nuevo\');


Append:
El procedimiento Append abre un archivo existente para añadir datos al final del mismo.
Formato:
Append(f);
f: variable de archivo de texto que debe haber sido asociada con un archivo externo por medio de Assign.
Si el archivo no existe, se produce un error; y si ya estaba abierto, primero se cierra y luego se reabre.
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Rewrite(ArchText);
WriteLn(ArchText,'Primera línea');
Close(ArchText);
Append(ArchText);
WriteLn(ArchText,'Agrega esto al último');
Close(ArchText)
end.


Flush:
El procedimiento Flush vacía el buffer de un archivo de texto abierto para salida. Cuando un archivo de texto es abierto para escritura usando Rewrite o Append, la llamada a Flush llenará el buffer asociado al archivo. Esto garantiza que todos los carácteres escritos en el archivo en ese tiempo sean escritos en el archivo externo. Flush no afecta los archivos abiertos para entrada. Usando la directiva {$I}, IOResult devuelve 0 si esta operación fue realizada con éxito de lo contrario retonará un código de error.
Formato:
Flush(f);
f : variable de archivo
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'lista.pas');
Rewrite(ArchText);
WriteLn(ArchText,'Primera línea');
WriteLn(ArchText,'Segunda línea');
Flush(ArchText);
WriteLn(ArchText,'tercera línea');
WriteLn(ArchText,'Agrega esto al último');
Close(ArchText)
end.


Read:
El procedimiento Read se utiliza para la lectura de datos situados en un archivo de tipo texto.
Formato:
Read(f,v1,v2,..);
f: variable de archivo de texto
v1,v2,... variable de tipo char, integer, real o string
Ejemplo:
Var
ArchText : Text;
datos : string[20];
Begin
Assign(ArchText,'lista.pas');
Reset(ArchText);
Read(ArchText,datos);
WriteLn(ArchText,datos);
Close(ArchText)
End.


ReadLn:
EL procedimiento ReadLn se utiliza para la lectura de datos situados en un archivo de tipo texto. A diferencia de Read, ReadLn salta al principio de la siguiente línea del archivo. Este salto de línea se produce cuando se han asignado valores a la lista de varibles del procedimiento; en caso contrario, el procedimiento hace caso omiso del control de línea y sigue asignando información.
Formato:
ReadLn(f,v1,v2,..);
f :variable de archivo de texto
v1,v2,... variable de tipo char,integer, real o string
Ejemplo:
Var
ArchText : Text;
datos : string[20];
Begin
Assign (ArchText,'lista.pas');
Reset(ArchText);
ReadLn(ArchText,datos);
WriteLn(ArchText,datos);
Close(ArchText)
End.


SetTextBuf:
El procedimiento SetTextBuf asigna un buffer de entrada/salida a un archivo de texto. SetTextBuffer podría nunca ser usado en la apertura de un archivo, aunque éste puede ser llamado inmediatamente después de Reset, Rewrite, y Append. Si se invoca a SetTextBuf en una apertura de archivo las operaciones de entrada/salida son tomadas por éste procedimiento, y se pueden perder datos como resultado de el cambio de buffer.
formato : SetTextBuf(f,buffer)
Ejemplo:
Var
ArchText: Text;
Ch: Char;
buffer: array[1..4096] of Char; { buffer de 4K}
Begin
Assign(ArchText,'memoria.txt');
{Se utiliza un buffer grande para lecturas más rápidas}
SetTextBuf(ArchText,buffer);
Reset(ArchText); {Visualiza el archivo en la pantalla}
while not Eof(ArchText) do
Begin
Read(ArchText,Ch);
Write(Ch)
End;
Close(ArchText)
end.


Write:
EL procedimiento Write sirve para escribir datos en un archivo.
Formato: Write(f,v1,v2,...)
f :variable de tipo archivo
v1,v2,... variables de tipo de datos
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'nuevo.txt');
Rewrite(ArchText);
Write(ArchText,'Está es la primera línea.');
Write(ArchText,'Fin del texto.');
Close(ArchText)
End.
El contenido del archivo será : Está es la primera línea. Fin del texto.
WriteLn:
EL procedimiento WriteLn sirve para escribir datos en un archivo. A diferencia de Write, WriteLn incluye un salto de línea para separar el texto.
Formato:
WriteLn(f,v1,v2,...)
f :variable de tipo archivo
v1,v2,... variables de tipo de datos
Ejemplo:
Var
ArchText : Text;
Begin
Assign (ArchText,'nuevo.txt');
Rewrite(ArchText);
WriteLn(ArchText,'Está es la primera línea.');
WriteLn(ArchText,'Fin del texto.');
Close(ArchText)
end.
El contenido del archivo será :
Está es la primera línea. Fin del texto.


BlockRead:
Transfiere un bloque de datos de un archivo sin tipo hacia un buffer.
Formato:
BlockRead(arch,buffer,bloques,resul)
Arch: archivo sin tipo
Buffer: variable de cualquier tipo de longitud suficiente para acogerlos datos transferidos.
Bloques: expresión que corresponde al número de bloques de 128 bytes a transferir.
Resul: parámetro opcional que indica el número de bloques que Se leyeron o escribieron realmente.


BlockWrite:
Transfiere un buffer de datos hacia un archivo sin tipo.
Formato:
BlockWrite(arch,buffer,bloques,resul)
Arch: archivo sin tipo
Buffer: variable de cualquier tipo de longitud suficiente para acoger los datos transferidos.
Bloques: expresión que corresponde al número de bloques de 128 bytes a transferir.
Resul: parámetro opcional que indica el número de bloques que se leyeron o escribieron realmente.
Ejemplo:
Program CopiadeArchivos;
Var
fuente,destino : file; {archivo sin tipo}
buffer : array[1..512] of byte;
leidos : integer;
Begin
Assign(fuente,'original.txt');
Assign(destino,'copia.txt');
Reset(fuente,1);
Rewrite(destino,1);
BlockRead(fuente,buffer,SizeOf(buffer),leidos);
while leidos>0 do
Begin
BlockWrite(destino,buffer,SizeOf(buffer),leidos);
BlockRead(fuente,buffer,SizeOf(buffer),leidos)
end
close(fuente);
close(destino)
end.


Eof:
La función eof(end of file), fin de archivo, devuelve el estado de un archivo. Es una función de tipo lógico que indica si el fin de archivo se ha encontrado; devuelve true si se encontró, false en casi contrario.
Formato:
Eof(f)
f :variable de archivo
Ejemplo:
Var
ArchText: Text;
Ch: Char;
Begin
Assign(ArchText,'memoria.txt');
Reset(ArchText); {Visualiza el archivo en la pantalla}
while not Eof(ArchText) do
Begin
Read(ArchText,Ch);
Write(Ch)
end;
Close(ArchText)
end.
Eoln:
La función Eoln devuelve el estado de fin de línea de un archivo. Es una función de tipo lógico. Devuelve true si la posición actual del archivo (puntero) esta en la marca de fin de línea, o bien si Eof(f) es true, el caso contrario devuelve false.

Formato:
Eoln(f)
f :variable de archivo de texto
Var
car :char;
ArchText:text;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
Reset(ArchText);
{muestra sola la primera línea}
While not(Eoln(ArchText)) do
Begin
Read(ArchText,car);
Write(car)
end
end.
SeekEof:
Retorna el estado de fin de archivo. Es una función de tipo lógico. Sólo para archivos de texto. Si la posición actual del puntero de archivo se encuentra en la marca de fin de archivo devuelve true, de lo contrario retorna false. SeekEof es una función que avanza siempre al siguiente carácter, ignorando por completo los espacios en blanco.
Formato:
SeekEof(f)
f variable de archivo de texto
Ejemplo:
Var
car :char;
ArchText:text;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
Reset(ArchText);
{muestra el contenido del archivo}
While not(SeekEof(ArchText)) do
Begin
Read(ArchText,car);
Write(car)
End
end.


SeekEoln:
Retorna el estado de fin de línea. Es una función de tipo lógico. Sólo para archivos de texto. Si la posición actual del puntero de archivo se encuentra en la marca de fin de línea devuelve true, de lo contrario retorna false. SeekEoln es una función que avanza siempre al siguiente carácter, ignorando por completo los espacios en blanco.
Formato:
SeekEoln(f)
f :variable de archivo de texto
Ejemplo:
Var
car :char;
ArchText:text;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
Reset(ArchText);
{muestra el contenido del archivo}
While not(SeekEoln(ArchText)) do
Begin
Read(ArchText,car);
Write(car)
end;
Close(ArchText)
end.


IOResult:
Es una función que devuelve un número entero que indica el código del error de la última operación de E/S; si el valor de retorno es cero, esto nos indica que la operación se ha desarrollado sin problema.
Formato:
IOResult
Ejemplo:
Var
ArchText:text;
Nerror :integer;
Begin
Clrscr;
Assign(ArchText,'nuevo.txt');
{SI-}
Reset(ArchText);
Nerror:=IOResult;
{SI+}
if Nerror<>0 then
WriteLn('Código de error # ',Nerror)
else
Close(ArchText)
end.

FilePos:
Está función devuelve la posición actual del archivo (número de registro), en forma de un entero largo (longint).
Formato:
FilePos (f)
f :variable de tipo archivo
Notas :
1. Devuelve 0 si esta al principio del archivo.
2. Es igual a FileSize(f) si el puntero de posición del archivo esta al final del archivo.

FileSize:
Está función devuelve el tamaño actual del archivo(número de registros existentes en el archivo). Si el archivo esta vacío devuelve cero.
Formato:
FileSize(f)
f :variable de tipo archivo

Seek:
Sitúa el puntero de posición del archivo en el número de registro correspondiente.
Formato:
Seek(f,numreg)
f :nombre de archivo (no de tipo text) numreg número de posición del registro, el primer registro es cero; si numreg es menor que 0 o mayor que n (para un archivo de n registros), se producirán resultados impredecibles.
Ejemplo:
Seek(empleados,FileSize(empleados));
{está sentencia posiciona el puntero al final del archivo}

Truncate:
Está función trunca (corta, mutila) un archivo a partir de la posición actual del puntero del archivo.
Formato:
Truncate(f)
f :varible de tipo archivo
Si Truncate se ha ejecutado con éxito IOResult tendrá un valor de cero. El archivo debe estar abierto. Truncate no trabaja en archivos de texto.
Ejemplo:
Var
f: file of integer;
i,j: integer;
Begin
Assign(f,'prueba.int');
Rewrite(f);
For i := 1 to 5 do
Write(f,i);
Writeln('Archivo antes de ser truncado :');
Reset(f);
while not Eof(f) do
Begin
Read(f,i);
Writeln(i)
end;
Reset(f);
For i := 1 to 3 do
Read(f,j); { lectura de 3 registros }
Truncate(f); { Trunca el archivo a partir de aquí }
Writeln;
Writeln('Archivo después de ser truncado:');
Reset(f);
while not Eof(f) do
Begin
Read(f,i);
Writeln(i)
end;
Close(f);
end.


miércoles, 1 de abril de 2009

EXCELENCIA Y HABITO

http://www.youtube.com/watch?v=G7szUokmYF0VIDEO DE EXCELENCIA

CLASE DEL 1/04/09 PARA ALUMNOS DE 5. SEC. I.E.P. CLARETIANO

EJEMPLOS DE PROGRAMAS CON REGISTROS SIMPLES O UNITARIOS Y ARREGLOS DE REGISTROS
Programa que utiliza un registro simple o unitario para leer los campos del registro RMEDIC

Program Medicam;
Uses Crt;
Type
Rmedic=Record
Nom:String[20];
Lab:String[15];
Tipo:String[12];
Precio:Real;
End;
Var
Vmedic:Rmedic;
Begin
Clrscr;
Write('Medicamento: ');Readln(Vmedic.Nom);
Write('Laboratorio: ');Readln(Vmedic.Lab);
Write('Tipo: ');Readln(Vmedic.Tipo);
Write('Precio: ');Readln(Vmedic.Precio);
Clrscr;
Writeln('Medicamento: ',Vmedic.Nom);
Writeln('Laboratorio: ',Vmedic.Lab);
Writeln('Tipo: ',Vmedic.Tipo);
Writeln('Precio: ',Vmedic.Precio:4:2);
Readkey
End.


Programa que utiliza un arreglo de registro para leer los campos de 20 registros


Program KardexComp;
Uses Crt;
Type
Rproduc=Record
Cod:String[7];
Nom:String[20];
Marc:String[15];
Precio:Real;
Stock:Integer;
End;
Aproduc=Array[1..20] Of Rproduc;
Var
Vproduc:Aproduc;
i,f:Integer;
Begin
Clrscr;
For I:=1 To 20 Do
Begin
Clrscr;
Writeln('Registro No. ',i,':');
Write('C¢digo : ');Readln(Vproduc[i].Cod);
Write('Nombre : ');Readln(Vproduc[i].Nom);
Write('Marca : ');Readln(Vproduc[i].Marc);
Write('Precio : ');Readln(Vproduc[i].Precio);
Write('Stock : ');Readln(Vproduc[i].Stock);
End;
Clrscr;
Gotoxy(22,2);Write('Listado de Producto cuyo Stock < 10 ');
Gotoxy(4,4);Write('C¢digo');
Gotoxy(17,4);Write('Nombre');
Gotoxy(40,4);Write('Marca');
Gotoxy(54,4);Write('Precio');
Gotoxy(64,4);Write('Stock');
F:=6;
For I:=1 to 20 Do
Begin
If Vproduc[i].Stock<10 Then
Begin
Gotoxy(4,f);Write(Vproduc[i].Cod);
Gotoxy(17,f);write(Vproduc[i].Nom);
Gotoxy(40,f);Write(Vproduc[i].Marc);
Gotoxy(54,f);Write(Vproduc[i].Precio:4:2);
Gotoxy(64,f);Write(Vproduc[i].Stock);
F:=F+1;
End;
End;
Readkey;
End.






miércoles, 18 de marzo de 2009

SESIÓN DE CLASE PARA 5TO. SEC. -2009 - I.E.P. CLARETIANO

REGISTROS

CONCEPTO DE REGISTROS: Un registro es una estructura heterogénea de datos, denominados campos y a los que accedemos por nombre. Al igual que en cualquier otro dato, el tipo registro (Record) antes de poder ser utilizado debe ser declarado en la sección de tipos.

La única operación (a parte de la lectura) que se puede realizar con una variable registro como tal es la asignación, es decir, se pueden copiar todos los campos de una variable registro a otra variable registro del mismo tipo. Además un registro puede ser pasado como parámetro a una función o prpcedimiento.

DECLARACIÓN DE UN REGISTRO:

La sintaxis de declaración de un registro es la siguiente:

Type

Tipo registro = Record

Campo1:Tipo1;

....

Campo N:TipoN;

End;

En donde:

TipoRegistro: Nombre de la estructura o dato del registro.

Campo: Lista de uno o mas campos separados por comas.

Tipo: Cualquier tipo de dato estándar o de finido por el usuario.

Por ejemplo:

Type

Alumno=Record

Nombre:String;

Edad:Integer;

Domicilio:String;

Grado:String[10]

Telefono:String[10];

End;

Esta declaración ha creado un tipo de dato llamado Alumno con cinco campos.

VARIABLE TIPO REGISTRO:

La de un registro por si solo no significa nada, para poder usar un registro es necesario que se declare una variable del tipo registro en el bloque Var, de la siguiente manera:

Var

NombreRegistro:TipoRegistro;

Por ejemplo, basándose en la declaración de registro anterior podríamos tener:

Var

Estudiante: Alumno;

Aux:Alumno;

ACCESAR A LOS CAMPOS DE UN REGISTRO:

Es importante saber como accesar a uno o más campos de un registro, la menera más común es la siguiente:

NombreRegistro.Campo

Por ejemplo:

Alumno.Nombre:='José María';

Alumno.Edad:=5;

Alumno.Domicilio:='Av. Angamos 325';

Alumno.Grado:='Primero';

Alumno.Telefono:='842564';

Cuando los datos ya están almacenados en el registro se puede manipular de forma similar a los otros datos en memoria.

LECTURA DE LOS CAMPOS DE UN REGISTRO:

Readln(Alumno.Nombre);

Readln(Alumno.Telefono);

ESCRITURA DE LOS CAMPOS DE UN REGISTRO:

Writeln(Alumno.Nombre);

Writeln('Nro. Telefononico: ',Alumno.Telefono);

Por ejemplo basándonos en el registro alumno (Primera declaración), tendríamos el siguiente programa:

Program Registro1;
Uses Crt;
Type

Alumno =Record

Nombre:String;
Edad:Integer;
Domicilio:String;
Grado:String[10]
Telefono:String[10];
End;

Var

DatosA;Alumno;
Begin

Clrscr;

(*Lectura de datos *)

Write('Nombre : ');Readln(DatosA.Nombre);

Write('Edad: ');Readln(DatosA.Edad);

Write('Domicilio: ');Readln(DatosA.Domicilio);

Write('Grado: ');Readln(DatosA.Grado);
Write('Telefono: ');Readln(DatosA.Telefono);

(*Escritura de los datos del registro*)

Clrscr;

Writeln('DATOS DEL ALUMNO ');

Writeln(DatosA.Nombre);
Writeln(DatosA.Edad);
Writeln(DatosA.Domicilio);
Writeln(DatosA.Grado);

Writeln(DatosA.Telefono);

Readkey;

End.

REGISTROS ANIDADOS:

En la construcción de un programa grande que maneje registros, a menudo nos tocaremos con la necesidad de tener registros anidados, eso quiere decir que es posible declarar un tipo registro con campos que sean otros registros.

Veamos la siguiente declaración:

Type

Alumno =Record

Apellidos:String[30];

Nombres:String[30];

End;

Fecha=Record

dia,mes,anno:String[2];

End;

DatosEspecificos=Record

FechNac:Fecha;

GrupoSangre:String[10];

End;

Var

DatosA;Alumno;

Obsérvese que la variable FechNac es de tipo Fecha la cual hemos declrado anteriormente. Otra forma de declarar el registro anterior sería.

Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac=Record

dia,mes,anno:String[2];

End;

GrupoSangre:String[10];
End;
Lo malo de declarar un registro de esta manera (sin definición ni tipo) es que este no se puede mandar como parámetro.

COMO ACCESAR A REGISTROS ANIDADOS:

Para accesar a un campo de un registro anidado debemos de tener en cuenta la jerarquía de los registros, desde el nombre del registro principal (raíz) hasta el campo específico.

Por ejemplo basándonos en el registro alumno (Primera declaración), tendríamos el siguiente programa:

Program Registro2;

Uses Crt;

Type
Alumno =Record
Apellidos:String[30];
Nombres:String[30];
End;
Fecha=Record
dia,mes,anno:String[2];
End;
DatosEspecificos=Record
FechNac:Fecha;
GrupoSangre:String[10];
End;
Var
DatosA;Alumno;

DatosEs:DatosEspecificos;

Procedure Leer;

Begin

Readln(DatosA.Apellidos);

Readln(DatosEs.FechNac.Dia);

End;

Procedure Escribir;

Begin

Writeln(DatosA.Apellidos);
Writeln(DatosEs.FechNac.Dia);

End;

Begin

Clrscr;

Leer;

Escribir;

Readkey;

End.

ARRAY DE REGISTROS:

En casos muy raros utilizaremos registros simples o unitarios, por lo general nos veremos en la necesidad de usar varios registros, la forma más adecuada de utilizar varios registros, la forma más adecuada de utilizar varios registros a la vez es mediante un arreglo de registro. El siguiente ejemplo detalla como podemos leer, escribir y manipular los datos de un arreglo:

Program Registro3;

Uses Crt;

Const

Max=10;

(*Declaracion del registro anidado*)

Type

Notas=Record

N1,N2,N3:Real;

End;

Alumno=Record

Nombres:String[30];

Nota:Notas;

Promedio:Real;

End;

(*declaracion del arreglo de registro*)

Type

ArrAlumn0=Array[1..MAx] of Alumno;

Var

i:Integer;

(*En el procedimiento leer se pasa como parámetro un arreglos de registros);

Procedure Leer(Var Al:ArrAlum);

Begin

For I:=1 To Max Do

Begin

Clrscr;

Write('Ingrese el nombre del alumno ',i,':');

Readln(A[i].Nombres);

Write('Nota 1:');Readln(A[i].Nota.N1);

Write('Nota 2:');Readln(A[i].Nota.N2);

Write('Nota 3:');Readln(A[i].Nota.N3);

End;

End;

{La función Promedio recibe como parámetro solo un registro por lo que el parámetro debe ser de tipo Alumno, es decir un solo registro; y devuelve el promedio}

Function PromedioA(Alu:Alumno):Real;

Begin

PromedioA:=(Alu.Nota.N1+Alu.Nota.N2+Alu.Nota.N3)/3;

End;

Procedure CalcularPromedio(Var Al:ArrAlum);

Procedure Escribir(Var Al:ArrAlum);

Begin

For I:=1 To Max Do

Al[i].Promedio:=PromedioA(Al[i]);

End;

Procedure Escribir(Var Al:ArrAlum);

Begin
For I:=1 To Max Do
Begin
Clrscr;
Writeln('Nombre del Alumno ',i,':',A[i].Nombres);
Writeln('Nota 1:',A[i].Nota.N1);
Writeln('Nota 2:',A[i].Nota.N2);
Writeln('Nota 3:',A[i].Nota.N3);
Writeln('Promedio: ',Al[i].Promedio:4:2);

Writeln;

End;

End;

(*Declaración de la variable Alum del tipo ArrAlum, arreglo de registros)

Var

Alum:ArrAlum;

Begin

Clrscr;

Leer(Alum);

CalcularPromedio(Alum);

Clrscr;

Escribir(Alum);

Readkey

End.

Como todo arreglo el proceso de lectura y escritura es mediante un bucle repetitivo, en este caso hemos usado la sentencia For, y se debe de leer cada uno de los datos, por separado.

Otro aspecto es que el campo Promedio no es ingresado por el usuario, si no que se calcula mediante el procedimiento CalcularPromedio, este procedimiento le pasa como referencia un registro (El registro actual ) a la función PromedioA, el cual con los datos de ese único registro calcula el promedio y lo retorna.

Debemos diferenciar en los parámetros de referencia de las funciones y procedimientos, ya que a los procedimientos se les pasa como parámetros un arreglo de registros (de tipo ArrAlum) mientras que a la Función solo se le pasa un registro (de tipo Alumno).

lunes, 16 de marzo de 2009

5to. SEC. I.E.P. CLARETIAMO 2009

OPERADORES
OPERADORES ARITMÉTICOS:
+ Suma
- Resta
* Multiplicación
/ División . Nota: Trabaja la parte decimal
Div División entre enteros. Trunca la parte decimal
Mod Resto o residuo de una división entre enteros.
** Potenciación
^ Potenciación
OPERADORES RELACIONALES:
Mayor que >
Menor que <
Mayor o igual que >=
Menor o igual que <=
Igual que =
diferente de <>
OPERADORES LÓGICOS:
AND Y
OR O
NOT NO

domingo, 15 de marzo de 2009

SESIÓN 3 - 5TO. SEC. - 2009 - I.E.P. CLARETIANO

TIPOS DE DATOS EN FREE PASCAL
ENTEROS:
- Integer
- Word
- Sh0rtint
- Longint
- Byte
REALES:
- Real
- Double
- Single
- Extended
- Comp
CADENA DE CARACTERES:
- String
CARACTER:
- Char
LÓGICO:
- Boolean
SENTENCIAS BÁSICAS DE PASCAL
LECTURA:
Read o Readln Ejm:
Readln(n,m);
ESCRITURA:
Write o Writeln Ejm:
Writeln('Bodas de Oro Claret 2009'); Writeln(n);
POSICIÓN DEL CURSOR:
Gotoxy(x,y) Ejm:
Gotoxy(15,7); writeln('Somos la promo 2009');
COLOR DE TEXTO:
TEXTCOLOR(COLOR); Ejm:
Textcolor(Blue); writeln('Programando en Pascal¡);
COLOR DE FONDO DE TEXTO:
TEXTBACKGROUND(COLOR); Ejm:
Textcolor(White); Textbackgound(Red);Writeln('Viva el Perú');
ALTA INTENSIDAD:
HIGHVIDEO; Ejm:
Highvideo; write('P');
BAJA RESOLUCIÓN:
LOWVIDEO; Ejm:
Lowvideo; Writeln('Paz');
RESOLUCIÓN NORMAL:
NORMVIDEO; Ejm:
Normvideo;
LIMPIAR PANTALLA:
CLRSCR; Ejm:
Clrscr;
RETARDO:
DELAY(Valor); Ejm:
Delay(600);
LEER UNA TECLA:
READKEY; Ejm:
Readkey;
ESTRUCTURAS ALGORÍTMICAS
Sentencia Condicional If.. Then
Sintaxis:
If condición Then
Acción;
Ejm:
If A>B Then
Writeln('A es mayor que B');
Sentencia Condicional IF...Then...Else
Sintaxis:
If condición Then
Acción1
Else
Acción2;
Ejm:
If A>B Then
Writeln('A es mayor')
Else
Writeln('B es mayor');
Sentencia For..To..Do
Sintaxis:
For I:=vi to vf Do
Acción;
Ejm1:
For I:=1 to 100 Do
Writeln(I);
Ejm2:
For I:=1 to 100 do
Begin
S.=S+I;
Writeln(I);
End;
Sentencia While...Do
Sintaxis:
While Condición Do
Begin
Acción1;
AcciónN;
End;
Ejm:
While C<=100 Do
Begin
W riteln(I);
C:=C+1;
End;
Sentencia Repeat...Until
Sintaxis:
Repeat
Acción1;
AcciónN;
Until Condición;
Ejm:
Repeat
Writeln(I);
C:=C+1;
Until C>100;
Sentencia Case ...Of
Sintaxis:
Case Selector Of
Caso1: Acción1;
Caso2:Acción2;
Caso3:Acción3;
CasoN:AcciónN:
End;
Otra forma:
Case Selector Of
Caso1:Acción1;
Caso2:Acción2;
...
CasoN: AcciónN
Else
OtraAcción;
End;
Ejm:
Case n Of
1:Writeln('Uno');
2:Writeln('Dos');
3.Writeln('Tres');
4:Writeln('Cuatro');
End;
Case M Of
1..4: C:=C+4;
5..7:C:=C+7;
7..10:C:=C+10
Else
C:=C+15;
End;
TAREA
Desarrollar un programa que nos permita leer un número entero e invertirlo, el número deberá ser consistenciado para que sea un número mayor que 10.

SESIÓN 2- 2009 5TO. SEC. I.E.P. CLARETIANO

TÉCNICAS PARA LA FORMULACIÓN DE ALGORTIMOS


Las tres herramientas o técnicas utilizadas comúnmente son:

1. Pseudocódigo o Algoritmos

2. Diagrama de Flujo de Datos

3. Diagrama de Chapin o N-S


1. PSEUDOCÓDIGO O ALGORITMOS: Es la representación narrativa de los pasos que debe seguir un algoritmo para dar solución a un problema determinado. El pseudocódigo utiliza palabras que indican el proceso a realizar.

2. DIAGRAMA DE FLUJO DE DATOS: Es la representación gráfica de un algoritmo. También se peude decir que es la representación detallada en forma gráfica de como deben realizarse los pasos en la computadora para producir resultados.

3. DIAGRAMA NASSI-SCHNEIDERMAN: También conocido como diagrama de Chapin es como un diagrama de flujo en el que se omiten las flechas de unión y las cajas son contiguas. Las acciones sucesivas se pueden escribir en cajas sucesivas y como en los diagramas de flujo, se pueden escribir diferentes acciones en una caja.


SÍMBOLOS BÁSICOS PARA LA CONFECCIÓN DE UN DFD



PASOS O FASES PARA UNA BUENA PROGRAMACIÓN
1. ENUNCIADO O FORMULACIÓN DEL PROBLEMA: Esta fase está dada por el enunciado del problema, el cual requiere una definición clara y precisa. Es importante que se conozca lo que se desea que realice la computadora.
2. ANÁLISIS DEL PROBLEMA: Una vez que se ha comprendido lo que se desea de la computadora, es necesario definir:
-Los datos de entrada(DE)
- Cual es la información que se desea producir (salida)(DS)
- Los métodos y fórmulas que se necesitan para procesar los datos(DP)
3. SELECCIÓN A LA MEJOR ALTERNATIVA: Consiste en elegir o seleccionar la mejor alternativa a la solución del problema, es decir aquella que realiza el menor número de pasos para llegar a la solución del problema y también otro punto que se toma en cuenta para la solución a la mejor alternativa es el costo.
4. DISEÑO DEL ALGORITMO: En esta etapa se determina como hace el programa la tarea solicitada. El diseño del algoritmo es independiente del lenguaje de programación en el que se vaya a codificar posteriormente.
5. PRUEBA DE ESCRITORIO: Consiste en coger un lápiz y un papel y corroborar si funciona correctamente la lógica del algoritmo, en donde a las varables se les da tantos valores sean posibles para verificar si funciona correctamente.
6. CODIFICACIÓN: La codificción es la operación de escribir la solución del problema (de acuerdo a la lógica del diagrama de flujo o pseudocódigo), en una serie de instrucciones detalladas, en un código reconocible por la computadora, la serie de instrucciones detalladas se le conoce como código fuente, el cual se escribe en un lenguaje de programación o lenguaje de alto nivel.
7. COMPILACIÓN: Consiste en convertir cada una de las líneas del programa fuente en un programa ejecutable u objeto, este proceso se hace a través de un programa compilador.
8. PRUEBA EN EL COMPILADOR: Es similar a la prueba de escritorio con las diferencia que en este caso se hace a través del computador dándoles datos reales .
9. DOCUMENTACIÓN: Es la guía o comunicación escrita en sus variadas formas, ya sea en enunciados, procedimientos, dibujos o diagramas.
La documentación se divide en tres partes:
9.1. Documentación Interna: Son los comentarios o mensajes que se añaden al código fuente para hacer más claro el entendimiento de un proceso.
9.2. Documentación Externa: Se define en un documento escrito los siguientes puntos:
- Descripción o narrativa del problema.
- Nombre del autor.
- Algoritmo (Digrama de flujo o pseudocódigo)
- Diccionario de datos.
- Código Fuente (programa)
9.3. Manual del Usuario: Describe paso a paso la manera como funciona el programa, con el fin de que el usuario obtenga el resultado deseado.
10. MANTENIMIENTO: Se lleva a acbo después de terminado el programa, cuando se detecta que es necesario hacer algún cambio, ajuste o complementación al programa para que siga trabajando de manera correcta.
ESTRUCTURA DE UN PROGRAMA EN PASCAL
PROGRAM Nombre; Cabecera
Uses Crt;
Const Área de Declaraciones
Nombre=Valor;
Type
Nombre: Tipo-de-dato;
Var
Nombre=Tipo-de-dato;
Procedure .....................
Function .........................
Var
Nombre=Tipo-de-dato;
Begin Cuerpo Principal del Programa
End.