La T.G.S. Se fundamentan en tres premisas básicas, a saber:A)Los sistemas existen dentro de sistemas.Las moléculas existen dentro de células las células dentro de tejidos, los tejidos dentro de los órganos, los órganos dentro de los organismos, los organismos dentro de colonias, las colonias dentro de culturas nutrientes, las culturas dentro de conjuntos mayores de culturas, y así sucesivamente.B ) Los sistemas son abiertos.Es una consecuencia de la premisa anterior. Cada sistema que se examine, excepto el menor o mayor, recibe y descarga algo en los otros sistemas, generalmente en aquellos que le son contiguos. Los sistemas abiertos son caracterizados por un proceso de intercambio infinito con su ambiente, que son los otros sistemas. Cuando el intercambio cesa, el sistema se desintegra, esto es, pierde sus fuentes de energía.C) Las funciones de un sistema dependen de su estructura.Para los sistemas biológicos y mecánicos esta afirmación es intuitiva. Los tejidos musculares, por ejemplo, se contraen porque están constituidos por una estructura celular que permite contracciones.No es propiamente las TES. , Sino las características y parámetros que establece para todos los sistemas, lo que se constituyen el área de interés en este caso. De ahora en adelante, en lugar de hablar de TES., se hablará de la teoría de sistemas.El concepto de sistema pasó a dominar las ciencias, y principalmente, la administración. Si se habla de astronomía, se piensa en el sistema solar; si el tema es fisiología, se piensa en el sistema nervioso, en el sistema circulatorio, en el sistema digestivo;La sociología habla de sistema social, la economía de sistemas monetarios, la física de sistemas atómicos, y así sucesivamente.El enfoque sistemático, hoy en día en la administración, es tan común que casi siempre se está utilizando, a veces inconscientemente.
INSTITUTO TECNOLOGICO SUPERIOR DE LA MONTAÑA
PROGRAMACIÓN II
ING. FRANCISCO CASTRO HURTADO
ALUMNO: ELOY ALBINO MORENO
VISUAL BASIC
Visual Basic es un lenguaje de programación desarrollado por Alan Cooper para Microsoft. El lenguaje de programación es un dialecto de BASIC, con importantes añadidos. Su primera versión fue presentada en 1991 con la intención de simplificar la programación utilizando un ambiente de desarrollo completamente gráfico que facilitará la creación de interfaces gráficas y en cierta medida también la programación misma. Desde el 2001 Microsoft ha propuesto abandonar el desarrollo basado en la API Win32 y pasar a trabajar sobre un framework o marco común de librerías independiente de la versión del sistema operativo, .NET Framework, a través de Visual Basic .NET (y otros lenguajes como C Sharp (C#) de fácil transición de código entre ellos) que presenta serias incompatibilidades con el código Visual Basic existente.
Visual Basic (Visual Studio) constituye un IDE (entorno de desarrollo integrado o en inglés Integrated Development Enviroment) que ha sido empaquetado como un programa de aplicación, es decir, consiste en un editor de código (programa donde se escribe el código fuente), un depurador (programa que corrige errores en el código fuente para que pueda ser bien compilado), un compilador (programa que traduce el código fuente a lenguaje de máquina), y un constructor de interfaz gráfica o GUI (es una forma de programar en la que no es necesario escribir el código para la parte gráfica del programa, sino que se puede hacer de forma visual).
Visual Basic Script posee varios tipos de datos pero en la práctica sólo posee un tipo de variable, que va cambiando de un estado a otro según la información que introducimos dentro. Este tipo principal de datos es el tipo Variant, en él podemos introducir varios subtipos de datos con total libertad.
Para cambiar el subtipo de un variant, sólo tenemos que introducir un dato en la variable. La variable variant cambia automáticamente de un subtipo a otro, sin que tengamos que hacer ninguna operación adicional. Los distintos subtipos de datos que tenemos son los siguientes:
Booleano
Es un tipo de datos que contiene un si o un no.se corresponden: TRUE equivale a (-1) FALSE equivale a (0)
Byte
Numérico, entero sin signo hasta 65.000
Currency
Tipo de moneda, se utiliza para manipular de manera exacta valores monetarios, y en general cualquier cálculo que requiera una precisión de hasta 15 dígitos decimales
Fecha
Es un tipo de 64 bits de tamaño que almacena fechas. Se utiliza el formato americano: mes, día, hora.
Double
Coma flotante con doble precisión (64 bits)
Entero
Número entero, con signo.Desde -32.768 hasta 32.767
Entero largo
Este tipo es un valor entero con signo de doble precisión. Como los nuevos ordenadores trabajan con palabras de 32 bits, y no menos, se recomienda usar este tipo antes de el tipo entero normal.
Objeto
El subtipo de objeto es una referencia de puntero de 32 bits a una instancia de de objeto de automatización OLE. Los controles Active-X y java. Utilizan esta sintaxis: Set miobjeto = new oleObjeto
Single
Coma flotante de precisión simple
Cadena
Conjunto continuo de valores de caracteres, de longitud variable.
Como saber de qué subtipo es una variable Para averiguar el subtipo de una variable podemos utilizar la función VarType, de esta manera:
v1 = 3
document.write VarType (v1)
En este script declaramos una variable y le metemos un número y a continuación imprimimos en la página el valor que devuelve la función VarType. Al ejecutar este script podremos ver un "2" escrito en la página. Según el tipo de datos que halla en la variable, VarType devolverá un valor distinto, como indica esta tabla:
Constant
Value
Description
vbEmpty
0
Empty (uninitialized)
vbNull
1
Null (no valid data)
vbInteger
2
Integer
vbLong
3
Long integer
vbSingle
4
Single-precision floating-point number
vbDouble
5
Double-precision floating-point number
vbCurrency
6
Currency
vbDate
7
Date
vbString
8
String
vbObject
9
Automation object
vbError
10
Error
vbBoolean
11
Boolean
vbVariant
12
Variant (used only with arrays of Variants)
vbDataObject
13
A data-access object
vbByte
17
Byte
vbArray
8192
Array
EL LENGUAJE
SINTAXIS
La sintaxis mínima de BASIC sólo necesita los comandos LET, INPUT, PRINT, IF y GOTO. Un intérprete que ejecuta programas con esta sintaxis mínima no necesita una pila. Algunas de las primeras implementaciones eran así de simples. Si se le agrega una pila, se pueden agregar también ciclos FOR anidados y el comando GOSUB. Un intérprete de BASIC con estas características necesita que el código tenga números de línea.
Los números de línea fueron un aspecto muy distintivo del BASIC clásico. Sin embargo, el uso de números de línea tiene la desventaja de requerir que el programador estime cuántas líneas ocupará la parte del programa que escribe. Este requerimiento se cumple generalmente incrementando los números de línea en un intervalo regular, como 10, pero esto lleva a problemas a la hora que el código después agregado exceda el espacio disponible entre las líneas originales. Para aliviar este problema de los primeros intérpretes de BASIC, los usuarios expertos pronto escribieron sus propios programas utilitarios para renumerar sus programas, después del ingreso inicial. Más tarde aparecieron intérpretes de BASIC que incluían un comando específico RENUMBER, el que permitía renumerar rápidamente (y las veces que se quisiera) todo el código nuevamente, con cualquier intervalo entre líneas indicado y a partir de un número entero dado; eliminando así el principal problema de la numeración de líneas obligatoria.
En los dialectos modernos de BASIC MIUN ya no es necesario incluir números de línea (aunque son permitidos), y la mayoría (o todos) han añadido control de flujo estructurado y los constructores de declaración de datos similares a los de otros lenguajes, tales como C y Pascal:
· do
· loop
· while
· until
· exit
· on... goto
· gosub
· select ... case
Variantes recientes como Visual Basic han introducido algunas características orientadas a objetos, y hasta herencia en la última versión. La administración de memoria es más fácil que con muchos otros lenguajes de programación procedurales por el uso de un Recolector de basura (y a costas de la velocidad de ejecución).
PROCEDIMIENTOS Y CONTROL DE FLUJO
BASIC no tiene una biblioteca externa estándar como otros lenguajes como C. En cambio, el intérprete (o compilador) contiene una biblioteca incorporada de procedimientos intrínsecos. Estos procedimientos incluyen la mayoría de las herramientas que un programador necesita para aprender a programar y escribir aplicaciones sencillas, así como funciones para realizar cálculos matemáticos, manejar cadenas, entrada desde la consola, gráficos y manipulación de archivos.
Viejos dialectos de BASIC no permitían a los programadores escribir sus propios procedimientos. Los programadores en cambio debían escribir sus programas con un gran número de enunciados GOTO para hacer las derivaciones de flujo y retorno del programa. Esto podía producir un código fuente muy confuso (la mayoría de las veces era así), comúnmente conocido como
Con la inclusión posterior de enunciados GOSUB (Go-Subroutine) se ramificaba el programa a especies de subrutinas, sin parámetros o variables locales. Ellas proveen una forma de implementar una suerte de procedimientos (realmente no lo son, sencillamente es un "salto y retorno") y estructurar más el programa, evitando bastante la utilización de la dañina sentencia GOTO.
La mayoría de las versiones de BASIC más modernas, como Microsoft QuickBASIC (1985-1988) y BASIC PDS (Profesional Developmen System - 1990) añadieron soporte completo para subrutinas, funciones y programación estructurada. Esta es otra área donde BASIC difiere de muchos lenguajes de programación. Sin embargo la primitiva GOSUB se ha mantenido hasta las versiones actuales, por razones compatibilidad.
BASIC, como Pascal, hace una distinción entre un procedimiento que no devuelve un valor (llamado subrutina) y un procedimiento que lo hace (llamado función). Muchos otros lenguajes (como C) no hacen esa distinción y consideran todo como una función (algunas que devuelven un valor “void” [vacío]).
Mientras que las funciones que devuelven un valor son una adición relativamente reciente a los dialectos de BASIC, muchos de los primeros sistemas soportaban la definición de funciones matemáticas en línea, con DEF FN (“DEFine FunctioN” [DEFinir FuncióN]). El Dartmouth BASIC original también soportaba funciones al estilo de Algol, así como subrutinas desde sus primeros tiempos.
TIPOS DE DATOS
BASIC es reconocido por tener muy buenas funciones para manipular cadenas de caracteres. Los primeros dialectos ya tenían un juego de funciones fundamentales (LEFT$, MID$, RIGHT$) para extraer y/o reemplazar subcadenas cadenas fácilmente. Como las cadenas son utilizadas en aplicaciones diarias, esta era una ventaja considerable sobre otros lenguajes al momento de su introducción.
El Dartmouth BASIC original soportaba únicamente datos de tipo numérico y cadenas. No había un tipo entero. Todas las variables numéricas eran de punto flotante. Las cadenas eran de tamaño dinámico. Soportaba arreglos de ambos, números y cadenas, en una o dos dimensiones.
Cada dialecto moderno de BASIC posee al menos los tipos de datos numéricos y string (cadena). Estos tipos de datos se pueden distinguir usando un posfijo: los identificadores de cadenas terminan con $ (signo pesos, ejemplo la variable NOMBRE$), mientras que los numéricos sencillamente no llevan posfijo; a menos que se requiera indicar y forzar explícitamente qué tipo de numérico es, por ejemplo A% es entero, A! es real simple precisión y A# es real doble precisión.
En BASIC las variables no necesitan forzosamente ser declaradas antes de usarse, excepto los arreglos de más de 10 elementos; aunque versiones BASIC relativamente modernas poseen la opción (considerada buena práctica de programación) para obligar al programador a declarar toda variable antes de su uso (una directiva como OPTION EXPLICIT). La declaración de variables en BASIC se hace usando la palabra clave DIM.
Muchos dialectos también soportan tipos numéricos adicionales, como enteros de 16 y 32 bits (simple y long, respectivamente), además de sus números de punto flotante. Adicionalmente algunos permiten la utilización de tipos de datos definidos por el usuario, similar a los "records" de Pascal, o las "structs" de C.
Versiones modernas de BASIC (como VBA) soportan una gran variedad de tipos de datos primitivos (o intrínsecos), además de los definidos por el usuario.
La mayoría de los dialectos de BASIC soporta arreglos en todos sus tipos de datos; es común también el soporte para arreglos multidimensionales.
Ejemplos: DIM MatrizDeEnteros(100,100) AS INTEGER DIM VectorDeEnteros%(30) DIM ListaDeNombres(50) AS STRING DIM ListaDeCiudades$(50)
Dependiendo del dialecto de BASIC y del uso del enunciado OPTION BASE, el primer índice de los arreglos que se declaren será 1, por defecto es cero.
En los ejemplos anteriores, si no se declara previamente "OPTION BASE 1", el primero es un arreglo en dos dimensiones de enteros 16 bits, con índices que van desde 0 hasta 100 (matriz de 101 x 101 elementos); en tanto que el segundo es un arreglo de enteros en una sola dimensión, de 0 a 30 (vector de 31 elementos). Observar que las dos formas de declaración de enteros son equivalentes, explicitándolo o con el uso del posfijo %. Análogamente para cadenas o string de caracteres, que en este caso además son de longitud variable (dinámicas, por defecto).
DISPONIBILIDAD Y VARIANTES DEL LENGUAJE
BASIC está disponible para casi todas las plataformas y sistemas operativos existentes. Una implementación gratuita que cumple con estándares y es multiplataforma es
Bywater BASIC (bwBASIC). El intérprete está escrito en C y viene bajo la licencia GNU. Está diseñado para interfaz de texto o consola (no gráfica), no incluye soporte para crear interfaces gráficas de usuario (GUI's, Graphical User Interface). Hay un BASIC gratuito que si incluye soporte para GUI, es similar a Visual Basic y se ejecuta en Windows y GNU/Linux, es Phoenix Object BASIC.Las versiones de intérpretes/compiladores más conocidos son la línea de productos Quick BASIC y QBASIC, éste último es sólo intérprete, ambos son de Microsoft. En la actualidad lo es el moderno Visual BASIC, que Microsoft ha tratado de mantener al menos mínimamente compatible con incluso las primeras versiones de sus BASIC (en realidad es escasamente compatible), si bien existe FreeBASIC que es un compilador libre, compatible en sintaxis con QBASIC/QuickBASIC.
Otras versiones comerciales incluyen PowerBASIC de PowerBASIC, PureBasic de Fantaisie Software, así como TrueBASIC de TrueBASIC, que cumple con los últimos estándares oficiales de BASIC. (True BASIC Inc. fue fundada por los creadores originales de Dartmouth BASIC.)
REALbasic es una variante disponible para Mac OS Classic, Mac OS X, Microsoft Windows y GNU/Linux, comercializada por los actuales propietarios de Rapid-Q, otra implementación inicialmente libre de BASIC actualmente abandonada. Una versión de un dialecto simple de BASIC para la parrot virtual machine, muestra cómo se implementa un intérprete de BASIC en un lenguaje similar al ensamblador. SmallBASIC es un dialecto que ejecuta en muchas plataformas (Win32, DOS, GNU/Linux y PalmOS) y viene bajo la licencia GNU (GPL).
Existen muchas implementaciones de BASIC freeware o GNU, como BCX, YaBasic, HBasic, XBasic, Gambas o Just BASIC, entre otras.
Ejemplos de código fuente
Ejemplo 1: Simple Saludo PRINT "Hola mundo"
Ejemplo 2: BASIC original no estructurado (Applesoft BASIC) [editar]10 INPUT "Cuál es su nombre:"; NN$20 PRINT "Bienvenido al 'asterisquero' ";NN$25 PRINT30 INPUT "con cuántos astericos inicia [Cero sale]:"; N40 IF N<=0 THEN GOTO 20050 AS$=""60 FOR I=1 TO N70 AS$=AS$+"*"80 NEXT I90 PRINT "AQUI ESTAN:"; AS$100 INPUT "Desea más asteriscos:";SN$110 IF SN$="" THEN GOTO 100120 IF SN$<>"S" AND SN$<>"s" THEN GOTO 200130 INPUT "CUANTAS VECES DESEA REPETIRLOS [Cero sale]:"; VECES140 IF VECES<=0 THEN GOTO 200150 FOR I=1 TO VECES160 PRINT AS$;170 NEXT I180 PRINT185 REM A repetir todo el ciclo (comentario)190 GOTO 25200 END Ejemplo 3: Equivalente en BASIC estructurado (Quick BASIC) [editar] DEFINT I-N 'Declara entera toda variable que comience con letras I a N iTrue = -1 'Flag en Verdadero INPUT "¿Cuál es su nombre"; NombreUsuario$ PRINT "Bievenido al 'asterisquero',"; NombreUsuario$ DO PRINT INPUT "¿Con cuántos asteriscos inicia [Cero sale]:"; NroAsteriscos IF NroAsteriscos<=0 THEN EXIT DO Asteriscos$ = "" FOR I=1 TO NroAsteriscos Asteriscos$=Asteriscos$ + "*" NEXT I PRINT "AQUI ESTAN: "; Asteriscos$ DO INPUT "Desea más asteriscos:";SN$ LOOP UNTIL SN$<>"" IF SN$<>"S" AND SN$<>"s" THEN EXIT DO 'Salida INPUT "CUANTAS VECES DESEA REPETIRLOS [Cero sale]:";iVeces IF iVeces<=0 THEN EXIT DO 'Salida FOR I = 1 TO iVeces PRINT Asteriscos$; NEXT I PRINT LOOP WHILE iTrue END
TIPOS DE DATOS QUE SOPORTA
LENGUAJE C++
Aunque las cuestiones de clasificación suelen ser un tanto artificiosas, dependiendo de la característica distintiva que se aplique, los tipos de datos C++ pueden clasificarse como sigue:
· Asimilables a enteros
o carácter (char)
o entero (int)
o booleano (bool)
o enumeraciones (enum)
o punteros (no tienen una palabra clave específica, sino un símbolo *, -calificador de tipo-)
· Fraccionarios (float, double)
· Ausencia de dato (void)
Más detalles sobre los tipos básicos en:
Tipos extendidos:
Son "adaptaciones" de detalle sobre los tipos básicos para mejor adaptarse a necesidades específicas.
· largo (long)
· corto (short)
· con signo (signed)
· sin signo (unsigned)
Los enteros y fraccionarios (en todas sus variaciones long, signed, etc) se conocen colectivamente como tipos numéricos.
Tipos compuestos
Aparte de los anteriores, C++ soporta tipos compuestos (también denominados tipos-clase). Son compuestos o agregados de tipos básicos, por esta razón se les denomina también tipos agregados o abstractos ADTs ("Abstract data types"). El "material" de que están compuestos son los tipos básicos, bien en estado "puro" o en sus diversas "adaptaciones". El proceso es recursivo, de forma que un tipo complejo puede contener miembros que son a su vez tipos complejos y así sucesivamente.
Desde el punto de vista semántico la gramática C++ establece como tipos compuestos ("Compound types") los siguientes:
· Matrices de objetos de cualquier tipo
· Funciones, que aceptan parámetros de ciertos tipos y devuelven void u objetos (o referencias a objetos) de cierto tipo
· Punteros a-void; punteros a-objetos, o punteros a-función (incluyendo miembros estáticos de clases) de un tipo determinado
· Punteros a miembros no-estáticos de clases (que señalan miembros de un tipo determinado dentro de objetos de una clase determinada
· Referencias a objetos o funciones de un tipo determinada
· Clases
· Uniones
· Enumeraciones
En la POO los tipos definidos por el usuario, reciben el nombre genérico de clases, entidades abstractas cuyos miembros son aglomerados de variables de distintos tipos (propiedades) y las funciones (métodos) que las manejan, inicializan y destruyen (Este capacidad de crear nuevos tipos de datos de cualquier nivel de complejidad y sus operaciones, es precisamente una de las características de la POO y se considera uno de los mayores avances en la tecnología de los lenguajes de computación.
Nota: existen dos mecanismos para generar este proceso recursivo (crear nuevos tipos complejos a partir de otros): la composición y la herencia; ambos son analizados en detalle al tratar de las clases.
Aunque desde el punto de vista de su Rvalue los punteros son asimilables a enteros (alojan direcciones de memoria), la gramática del lenguaje los distingue según el tipo de objeto al que apuntan, por lo que puede considerarse que constituyen un tipo con múltiples subtipos: Punteros-a-int; punteros-a-char; punteros-a-void; punteros-a-clase; punteros-a-función, Etc. Virtualmente existen tantas clases de punteros como tipos de objetos puedan ser señalados.
Tipos incompletos
Existen ocasiones en las que el lenguaje permite la declaración incompleta de tipos; entidades de las que el compilador no tiene por el momento toda la información que sería necesaria para una utilización normal, pero que a ciertos efectos puede ser suficiente. Son los llamados tipos incompletos ( 4.1.2). Su principal característica es que tanto su tamaño como el patrón de bits correspondiente son desconocidos para el compilador.
Tipos calificados
Los tipos básicos y complejos descritos anteriormente se denominan conjuntamente tipos no-calificados. La razón de esta denominación es que, en C++ existen ciertos especificadores (denominados calificadores) que al ser aplicados a un tipo, produce un tipo nuevo (tipo calificado) con propiedades y reglas de operación distintas del primitivo, pero con una representación interna exactamente igual a la del tipo no-calificado.
Estos cualificado res son las palabras-clave const, volatile y const volatile. Podemos suponer que la aplicación de estos calificadores supone la existencia de una especie de universo paralelo, en el que para cada tipo no-calificado puede existir la correspondiente versión const ( 3.2.1c), volatile ( 3.2.1d), o const volatile. Aunque la descripción de cada uno de estas palabras-clave se realiza en el apartado correspondiente, tienen ciertas características de actuación comunes:
· Un tipo complejo (por ejemplo una estructura) no se considera un tipo cualificado porque algunos de sus miembros lo sean.
· La calificación de un tipo complejo implica que todos sus propiedades tienen la misma calificación salvo que sean estáticas o tengan un calificador específico.
· Un calificador aplicado a una matriz no altera el tipo de la matriz en sí misma, sino al tipo de sus miembros.
Recordar que C++ dispone de un sistema que permite obtener el tipo de una entidad en tiempo de ejecución (mecanismo RTTI). Sin embargo, este mecanismo no permite obtener la "calificación" en su caso, del objeto. Para ciertas cuestiones la transformación de un tipo calificado en no calificado, y viceversa, es realizada automáticamente por el compilador en lo que se denominan conversiones triviales ( 2.2.5)
Nombres de tipos
Tanto externamente, para el programador que debe utilizarlos, como internamente, para las comprobaciones realizadas por el compilador, y como argumento de los operadores sizeof ( 4.9.13), new ( 4.9.20) o typeid ( 4.9.14), los tipos necesitan un nombre ("Type name") con el que distinguirlos de entre las infinitas posibilidades pueden existir en C++.
Ejemplos:
new char [5]; // char es un nombre de tipo
typeid (float); // float es un nombre de tipo
sizeof (long double); // long double es un nombre de tipo
En las declaraciones el nombre del tipo acompaña siempre al nombre de la entidad que se declara (objeto o función):
char mc[5];
float fl;
long double ld;
La gramática C++ denomina type-id [5] al identificador de los tipos, y señala que un type-id es sintácticamente una declaración de un objeto o función de ese tipo al que le falta el nombre de la entidad. Ejemplos:
type-id
declaración
Descripción del tipo
int
int m
m es un subtipo de los enteros denominado int ( 2.2.4)
int*
int* pi
pi es puntero-a-entero
int* [5]
int* mi[5]
mi es una matriz de cinco punteros-a-entero
int (*)[5]
int (* pf)[5]
pf es puntero-a-matriz de cinco enteros
int* ()
int* f1()
f1 es una función que no acepta argumentos devolviendo puntero-a-entero
int* (char*)
int* f2 (char*)
f2 función que acepta un puntero-a-char y devuelve un puntero-a-entero
int (*) (char)
int (* f3)(char)
f3 puntero-a-función que acepta un char y devuelve un entero
Temas relacionados:
· Especificador typedef ( 3.2.1a)
· Designación de tipos en los compiladores ( 4.2.4a2).
Tipo de funciones
El tipo de las funciones viene determinada por sus argumentos y por el valor devuelto. En caso de existir argumentos con valores por defecto se considera que estos últimos no tuvieran dichos valores. Ejemplo:
int foo(int = 0);
...
int (* fptr)(int) = &foo; // Ok!!
int (* fptr)() = &foo // Error: tipo de &foo y fptr no concuerdan
§5.8 Tipo de clases
Cada clase constituye un tipo en sí mismo; sin ningún otro tipo de atributo y sin que intervenga su estructura interna en la definición del tipo:
class C { int x; }; // Ok. tipo class C
class C { char c;}; // Error!! tipo ya definido
class D { int x;}; // Ok. tipo class D
La segunda línea es erronea porque dentro de un subespacio de nombres no pueden declararse dos objetos del mismo tipo con el mismo nombre.
§5.9 Tipo de miembros de clase
Es importante señalar que, aparte de la diferencia de tipo introducida por los calificadores (§5.5 ), los miembros no estáticos de clase constituyen a su vez submundos aparte en lo que respecta a los tipos. Por ejemplo: un miembro int m de clase C no se considera del mismo tipo que un int del espacio global o un miembro int m de otra clase D. Un caso análogo ocurre con las funciones y los métodos de clase: una función del espacio global aceptando un int y devolviendo void no es del mismo tipo que un método de la clase C que acepte un int y devuelva void. El cuadro adjunto muestra sendos ejemplos:
type-id
declaración
Descripción del tipo
int
int m
m es un int (entero)
int C::
int m
m es miembro int de-la-clase C
int*
int* pi
pi es un puntero-a-int
int C::*
int C::* iptr
iptr es puntero-a-miembro int de-la-clase C
int (char*)
int f1(char*)
f1 es función que devuelve int y acepta puntero-a-char
int C::(char*)
int C::f(char*)
f es una función-miembro de C que devuelve un int y recibe un puntero-a-char
TIPOS DE DATOS QUE SOPORTA JAVA
TIPOS DE DATOS
Tipos de datos simples
Para crear una variable (de un tipo simple) en memoria debe declararse indicando su tipo de variable y su identificador que la identificará de forma única. La sintaxis de declaración de variables es la siguiente:
TipoSimple Identificador1, Identificador2;
Esta sentencia indica al compilador que reserve memoria para dos variables del tipo simple TipoSimple con nombres Identificador1 e Identificador2.
Los tipos de datos en Java pueden dividirse en dos categorías: simples y compuestos. Los simples son tipos nucleares que no se derivan de otros tipos, como los enteros, de coma flotante, booleanos y de carácter. Los tipos compuestos se basan en los tipos simples, e incluyen las cadenas, las matrices y tanto las clases como las interfaces, en general.
Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados, para darles valor. En este apartado se explican los tipos de datos simples (o primitivos) que presenta Java, así como los literales que soporta (sintaxis de los valores que se les puede asignar).
a.) Tipos de datos enteros
Se usan para representar números enteros con signo. Hay cuatro tipos: byte, short, int y long.
Tipo
Tamaño
byte
1Byte (8 bits)
short
2 Bytes (16 bits)
int
4 Bytes (32 bits)
long
8 Bytes (64 bits)
Tabla 5: Tipos de datos enteros
Literales enteros
Son básicos en la programación en Java y presentan tres formatos:
Decimal: Los literales decimales aparecen como números ordinarios sin ninguna notación especial.
Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x ó 0X inicial, notación similar a la utilizada en C y C++.
Octal: Los octales aparecen con un 0 inicial delante de los dígitos.
Por ejemplo, un literal entero para el número decimal 12 se representa en Java como 12 en decimal, como 0xC en hexadecimal, y como 014 en octal.
Los literales enteros se almacenan por defecto en el tipo int, (4 bytes con signo), o si se trabaja con números muy grandes, con el tipo long, (8 bytes con signo), añadiendo una L ó l al final del número.
La declaración de variables enteras es muy sencilla. Un ejemplo de ello sería:
long numeroLargo = 0xC; // Por defecto vale 12
b.) Tipos de datos en coma flotante
Se usan para representar números con partes fraccionarias. Hay dos tipos de coma flotante: float y double. El primero reserva almacenamiento para un número de precisión simple de 4 bytes y el segundo lo hace para un numero de precisión doble de 8 bytes.
Tipo
Tamaño
float
4 Byte (32 bits)
double
8 Bytes (64 bits)
Tabla 6: Tipos de datos numéricos en coma flotante
Literales en coma flotante
Representan números decimales con partes fraccionarias. Pueden representarse con notación estándar (563,84) o científica (5.6384e2).
De forma predeterminada son del tipo double (8 bytes). Existe la opción de usar un tipo más corto (el tipo float de 4 bytes), especificándolo con una F ó f al final del número.
La declaración de variables de coma flotante es muy similar a la de las variables enteras. Por ejemplo:
double miPi = 314.16e-2 ; // Aproximadamente
float temperatura = (float)36.6; // Paciente sin fiebre
Se realiza un moldeado a temperatura, porque todos los literales con decimales por defecto se consideran double.
c.) Tipo de datos boolean
Se usa para almacenar variables que presenten dos estados, que serán representados por los valores true y false. Representan valores bi-estado, provenientes del denominado álgebra de Boole.
Literales Booleanos
Java utiliza dos palabras clave para los estados: true (para verdadero) y false (para falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los que el valor de falso se representaba por un 0 numérico, y verdadero cualquier número que no fuese el 0.
Para declarar un dato del tipo booleano se utiliza la palabra reservada boolean:
boolean reciboPagado = false; // ¡¿Aun no nos han pagado?!
d.) Tipo de datos carácter
Se usa para almacenar caracteres Unicode simples. Debido a que el conjunto de caracteres Unicode se compone de valores de 16 bits, el tipo de datos char se almacena en un entero sin signo de 16 bits.
Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.
Literales carácter
Representan un único carácter (de la tabla de caracteres Unicode 1.1) y aparecen dentro de un par de comillas simples. De forma similar que en C/C++. Los caracteres especiales (de control y no imprimibles) se representan con una barra invertida ('\') seguida del código carácter.
Descripción
Representación
Valor Unicode
Caracter Unicode
\udddd
Numero octal
\ddd
Barra invertida
\\
\u005C
Continuación
\
\
Retroceso
\b
\u0008
Retorno de carro
\r
\u000D
Alimentación de formularios
\f
\u000C
Tabulación horizontal
\t
\u0009
Línea nueva
\n
\u000A
Comillas simples
\’
\u0027
Comillas dobles
\"
\u0022
Números arábigos ASCII
0-9
\u0030 a \u0039
Alfabeto ASCII en mayúsculas
A.-Z
\u0041 a \u005A
Alfabeto ASCII en minúsculas
a.-z
\u0061 a \u007A
Tabla 7: Caracteres especiales Java
Las variables de tipo char se declaran de la siguiente forma:
char letraMayuscula = 'A'; // Observe la necesidad de las ' '
char letraV = '\u0056'; // Letra 'V'
e.) Conversión de tipos de datos
En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el que fue declarado. Este proceso se denomina "conversión", "moldeado" o "tipado". La conversión se lleva a cabo colocando el tipo destino entre paréntesis, a la izquierda del valor que queremos convertir de la forma siguiente:
char c = (char)System.in.read();
La función read devuelve un valor int, que se convierte en un char debido a la conversión (char), y el valor resultante se almacena en la variable de tipo carácter c.
El tamaño de los tipos que queremos convertir es muy importante. No todos los tipos se convertirán de forma segura. Por ejemplo, al convertir un long en un int, el compilador corta los 32 bits superiores del long (de 64 bits), de forma que encajen en los 32 bits del int, con lo que si contienen información útil, esta se perderá.
Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe ser igual o mayor que el tipo fuente":
Tipo Origen
Tipo Destino
byte
double, float, long, int, char, short
short
double, float, long, int
char
double, float, long, int
int
double, float, long
long
double, float
float
double
Tabla 8: Conversiones sin pérdidas de información
B. Vectores y Matrices
Una matriz es una construcción que proporciona almacenaje a una lista de elementos del mismo tipo, ya sea simple o compuesto. Si la matriz tiene solo una dimensión, se la denomina vector.
En Java los vectores se declaran utilizando corchetes ( [ y ] ), tras la declaración del tipo de datos que contendrá el vector. Por ejemplo, esta sería la declaración de un vector de números enteros (int):
int vectorNumeros[ ]; // Vector de números
Se observa la ausencia de un número que indique cuántos elementos componen el vector, debido a que Java no deja indicar el tamaño de un vector vacío cuando le declara. La asignación de memoria al vector se realiza de forma explícita en algún momento del programa.
Para ello o se utiliza el operador new:
int vectorNumeros = new int[ 5 ]; // Vector de 5 números
O se asigna una lista de elementos al vector:
int vectorIni = { 2, 5, 8}; // == int vectorIni[3]=new int[3];
Se puede observar que los corchetes son opcionales en este tipo de declaración de vector, tanto después del tipo de variable como después del identificador.
Si se utiliza la forma de new se establecerá el valor 0 a cada uno de los elementos del vector.
C. Cadenas
En Java se tratan como una clase especial llamada String. Las cadenas se gestionan internamente por medio de una instancia de la clase String. Una instancia de la clase String es un objeto que ha sido creado siguiendo la descripción de la clase.
Cadenas constantes
Representan múltiples caracteres y aparecen dentro de un par de comillas dobles. Se implementan en Java con la clase String. Esta representación es muy diferente de la de C/C++ de cadenas como una matriz de caracteres.
Cuando Java encuentra una constante de cadena, crea un caso de la clase String y define su estado, con los caracteres que aparecen dentro de las comillas dobles.
Vemos un ejemplo de cadena declarada con la clase String de Java:
String capitalUSA = "Washington D.C.";
String nombreBonito = "Amelia";
Más tarde profundizaremos con detenimiento en las cadenas Java.
BIBLIOGRAFIA
http://www.desarrolloweb.com/articulos/tipos-de-datos-vbscript.html
http://es.wikipedia.org/wiki/Visual_Basic
http://es.wikipedia.org/wiki/BASIC
http://www.zator.com/Cpp/E2_2a.htm
http://pisuerga.inf.ubu.es/lsi/Invest/Java/Tuto/II_2.htm
No hay comentarios:
Publicar un comentario