Tipos de datos (C# y Java)

Visual Studio 2008 Otras versiones Personas que lo han encontrado til: 3 de 4 - Valorar este tema Actualizacin: noviembre 2007 En este tema se describen algunas de las similitudes y diferencias principales en cmo se representan y asignan los datos, y se recolectan los elementos no utilizados en Java y en C#. Tipos de datos compuestos

El concepto de clase como tipo de datos compuesto de campos, mtodos y eventos es similar en Java y C#. (La herencia de clases se describe independientemente en el tema titulado Herencia y clases derivadas (C# y Java).) C# introduce el concepto de estructura como tipo de datos compuesto asignado por pila que no admite la herencia. En la mayora de los otros aspectos, las estructuras son muy similares a las clases. Las estructuras proporcionan una manera ligera de agrupar campos y mtodos relacionados para el uso en los bucles de pequeas dimensiones y otros escenarios donde el rendimiento es crucial. C# permite crear un mtodo de destructor al que se llama antes de que se destruyan las instancias de una clase. En Java, se puede utilizar un mtodo finalice para contener cdigo que limpia los recursos antes de que se recolecten los elementos no utilizados del objeto. En C#, el que realiza esta funcin es el destructor de clase. El destructor se parece a un constructor sin los argumentos y con un carcter de tilde delante (~). Tipos de datos integrados

C# proporciona todos los tipos de datos que estn disponibles en Java y agrega compatibilidad para los nmeros sin signo y un nuevo tipo de punto flotante de 128 bits de alta precisin. Para cada tipo de datos primitivo en Java, la biblioteca de clases principal proporciona una clase contenedora, que lo representa como un objeto de Java. Por ejemplo, la clase Int32 contiene el tipo de datos int y la clase Double contiene el tipo de datos double. Por otro lado, todos los tipos de datos primitivos en C# son objetos en el espacio de nombres System. Para cada tipo de datos, se proporciona un nombre corto o alias. Por

ejemplo, int es el nombre corto correspondiente a System.Int32 y double es la forma abreviada de System.Double. En la tabla siguiente se proporciona la lista de tipos de datos de C# y sus alias. Como puede ver, los primeros ocho de estos tipos corresponden a los tipos primitivos disponibles en Java. Sin embargo, tenga en cuenta que el tipo boolean de Java se denomina bool en C#. Nombre Clase Tipo corto .NET byte Byte Entero sin signo sbyte SByte Entero con signo int uint short ushort long ulong float double char bool object string Int32 UInt32 Int16 UInt16 Int64 UInt64 Single Double Char Entero con signo Entero sin signo Entero con signo Entero sin signo Entero con signo Entero sin signo Tipo de punto flotante de precisin simple Tipo de punto flotante de precisin doble Un carcter Unicode Ancho 8 8 32 32 16 16 64 64 32 64 16 8 Intervalo (bits) 0 a 255 -128 a 127 -2.147.483.648 a 2.147.483.647 0 a 4294967295 -32.768 a 32.767 0 a 65535 -922337203685477508 a 922337203685477507 0 a 18446744073709551615 -3,402823e38 a 3,402823e38 -1,79769313486232e308 a 1,79769313486232e308 Smbolos Unicode utilizados en el texto True o false

decimal

Boolean Tipo Boolean lgico Tipo base de todos los otros Object tipos String Una secuencia de caracteres Tipo preciso fraccionario o integral, que puede Decimal representar nmeros decimales con 29 dgitos significativos

128

1.0 10e28 a 7.9 10e28

Dado que C# representa todos los tipos de datos primitivos como objetos, es posible llamar a un mtodo de objeto de un tipo de datos primitivo. Por ejemplo:

C#
static void Main() { int i = 10; object o = i; System.Console.WriteLine(o.ToString()); }

Esto se logra con la ayuda de las conversiones automticas boxing y unboxing. Para obtener ms informacin, vea Conversin boxing y unboxing (Gua de programacin de C#). Constantes

Java y C# proporcionan la capacidad para declarar una variable cuyo valor se especifica en tiempo de compilacin y no se puede cambiar en tiempo de ejecucin. Java utiliza el modificador de campo final para declarar este tipo de variable, mientras que C# utiliza la palabra clave const. Adems de const, C# proporciona la palabra clave readonly para declarar variables a las que se puede asignar un valor una vez en tiempo de ejecucin, ya sea en la instruccin de declaracin o en otra parte del constructor. Despus de la inicializacin, el valor de una variable readonly no puede cambiar. Un escenario en el que las variables readonly son tiles es cuando los mdulos que se han compilado independientemente tienen que compartir datos como un nmero de versin. Si el mdulo A se actualiza y se vuelve a compilar con un nuevo nmero de versin, el mdulo B se puede inicializar con ese nuevo valor constante sin tener que volver a compilarlo. Enumeraciones

Las enumeraciones se utilizan para agrupar constantes con nombres en forma similar a la forma en que se utilizan en C y C++; no estn disponibles en Java. En el ejemplo siguiente se define una enumeracin Color sencilla. C#
public enum Color { Green, //defaults Orange, //defaults Red, //defaults Blue //defaults } to to to to 0 1 2 3

Tambin se pueden asignar valores integrales a las enumeraciones, tal como se muestra en la siguiente declaracin de enumeracin: C#
public enum Color2 { Green = 10, Orange = 20, Red = 30, Blue = 40 }

En el siguiente ejemplo de cdigo se llama al mtodo GetNames del tipo Enum para mostrar las constantes disponibles para una enumeracin. Luego, asigna un valor a una enumeracin y muestra el valor. C#
class TestEnums { static void Main() { System.Console.WriteLine("Possible color choices: "); //Enum.GetNames returns a string array of named constants for the enum. foreach(string s in System.Enum.GetNames(typeof(Color))) { System.Console.WriteLine(s); } Color favorite = Color.Blue; System.Console.WriteLine("Favorite Color is {0}", favorite); System.Console.WriteLine("Favorite Color value is {0}", (int) favorite); } }

Resultado

Possible color choices: Green Orange

Red Blue Favorite Color is Blue Favorite Color value is 3 Cadenas

Los tipos de cadena en Java y C# denotan un comportamiento similar con leves diferencias. Ambos tipos de cadena son inmutables, lo que significa que los valores de las cadenas no se pueden cambiar una vez que se han creado las cadenas. En ambos casos, los mtodos que parecen modificar el contenido real de una cadena crean en realidad una nueva cadena que se devolver como resultado, dejando la cadena original sin cambios. El proceso de comparacin de los valores de cadena es diferente en C# y Java. Para comparar los valores de cadena en Java, los desarrolladores deben llamar al mtodo equals de un tipo string, mientras que el operador == compara los tipos de referencia de forma predeterminada. En C#, los desarrolladores pueden utilizar los operadores == o != para comparar directamente valores de cadena. Aunque una cadena es un tipo de referencia en C#, los operadores == y != compararn, en forma predeterminada, los valores de las cadenas en lugar de las referencias. Como en Java, los desarrolladores de C# no deben usar el tipo string para concatenar cadenas con el fin de evitar la sobrecarga de crear nuevas clases de cadenas cada vez que se concatene la cadena. En su lugar, los desarrolladores pueden utilizar la clase StringBuilder, que es funcionalmente equivalente a la clase StringBuffer de Java. Literales de cadena

C# proporciona la posibilidad de evitar el uso de secuencias de escape como "\t" para la ficha o "\" para los caracteres de barra diagonal inversa dentro de las constantes de cadena. Para ello, simplemente declare la cadena textual mediante el smbolo @ para preceder la asignacin del valor de cadena. Los siguientes ejemplos muestran cmo utilizar los caracteres de escape y cmo asignar literales de cadena: C#
static void Main() { //Using escaped characters: string path1 = "\\\\FileShare\\Directory\\file.txt"; System.Console.WriteLine(path1);

//Using String Literals: string path2 = @"\\FileShare\Directory\file.txt"; System.Console.WriteLine(path2); }

Conversin y conversin de tipos

Java y C# siguen reglas similares para la conversin automtica y la conversin de tipos de datos. Al igual que Java, C# admite conversiones de tipo implcitas y explcitas. En el caso de conversiones de ampliacin, las conversiones son implcitas. Por ejemplo, la siguiente conversin de int a long es implcita, como en Java: C#
int int1 = 5; long long1 = int1; //implicit conversion

La siguiente es una lista de conversiones implcitas entre los tipos de datos de .NET Framework: Tipo de origen Byte Sbyte Int Uint Short Ushort Long Ulong Float Char Tipo de destino short, ushort, int, uint, long, ulong, float, double o decimal short, int, long, float, double o decimal long, float, double o decimal long, ulong, float, double o decimal int, long, float, double o decimal int, uint, long, ulong, float, double o decimal float, double o decimal float, double o decimal double ushort, int, uint, long, ulong, float, double o decimal

Puede convertir el tipo de expresiones que desee convertir explcitamente usando la misma sintaxis que en Java: C#

long long2 = 5483; int int2 = (int)long2;

//explicit conversion

La tabla siguiente muestra las conversiones explcitas. Tipo de origen Tipo de destino Byte sbyte o char Sbyte byte, ushort, uint, ulong o char Int sbyte, byte, short, ushort, uint, ulong o char Uint sbyte, byte, short, ushort, int o char Short sbyte, byte, ushort, uint, ulong o char Ushort sbyte, byte, short o char Long sbyte, byte, short, ushort, int, uint, ulong o char Ulong sbyte, byte, short, ushort, int, uint, ulong o char Float sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal Double sbyte, byte, short, ushort, int, uint, long, ulong, char o decimal Char sbyte, byte o short Decimal sbyte, byte, short, ushort, int, uint, long, ulong, char, float o double Tipos de referencia y valor

C# admite dos tipos de variables:

Tipos de valor Estos son los tipos de datos primitivos integrados, como char, int y float, as como tambin los tipos definidos por el usuario declarado con la estructura.

Tipos de referencia Clases y otros tipos de datos complejos que se construyen a partir de los tipos primitivos. Las variables de estos tipos no contienen una instancia del tipo, sino slo una referencia a una instancia.

Si se crean dos variables del tipo de valor, i y j, como se muestra a continuacin, i y j son completamente independientes entre s: C#

int i = 10; int j = 20;

Tienen ubicaciones de memoria independiente:

Si cambia el valor de una de estas variables, la otra no se ver afectada de forma natural. Por ejemplo, si tiene una expresin como la siguiente, an no existe ninguna conexin entre las variables: C#
int k = i;

Es decir, si cambia el valor de i, k permanecer con el valor que tena i en el momento de la asignacin. C#
i = 30; System.Console.WriteLine(i.ToString()); System.Console.WriteLine(k.ToString()); // 30 // 10

Sin embargo, los tipos de referencia actan de forma diferente. Por ejemplo, podra declarar dos variables de la siguiente forma: C#
Employee ee1 = new Employee(); Employee ee2 = ee1;

Ahora, puesto que las clases son tipos de referencia de C#, ee1 se conoce como referencia a Employee. La primera de las dos lneas anteriores crea una instancia de

Employee en memoria y define ee1 para que haga referencia a ella. As, cuando se establece ee2 para que sea igual a ee1, el primero contiene un duplicado de la referencia a la clase de la memoria. Si ahora cambia las propiedades de ee2, las propiedades de ee1 reflejan estos cambios, ya que ambas apuntan al mismo objeto de la memoria, tal como aparece a continuacin:

Conversiones boxing y unboxing

El proceso de convertir el tipo de un valor en el tipo de una referencia se denomina conversin boxing. El proceso inverso, convertir el tipo de una referencia en el tipo de un valor, se denomina conversin unboxing. Esto queda reflejado en el ejemplo de cdigo siguiente: C#
int i = 123; object o = i; int j = (int)o; // a value type // boxing // unboxing

Java requiere que esas conversiones se realicen manualmente. Los tipos de datos primitivos se pueden convertir en objetos de clases contenedoras construyendo esos objetos o aplicando la conversin boxing. De igual manera, los valores de los tipos de datos primitivos se pueden extraer de los objetos de las clases contenedoras llamando a un mtodo adecuado de estos objetos, o realizar una conversin unboxing. Para obtener ms informacin acerca de las conversiones boxing y unboxing, vea Conversin boxing y unboxing (Gua de programacin de C#). http://msdn.microsoft.com/es-es/library/ms228360%28v=vs.90%29.aspx

UNIDAD I: C# NET ELEMENTOS BSICOS TEMA 4: C# NET DECLARACION Y TIPO DE VARIABLES A toda variable que se use en un programa, se deber declarar de preferencia al principio del programa. En C# NET (tambin se le conoce como C# ) existen los siguientes tipos de variables: C# Tipo sbyte short int long byte ushort uint ulong float double decimal char bool .Net Framework (System) type System.Sbyte System.Int16 System.Int32 System.Int64 System.Byte System.Uint16 System.UInt32 System.Uint64 System.Single System.Double System.Decimal System.Char System.Boolean Signed? Yes Yes Yes Yes No No No No Yes Yes Yes N/A N/A Bytes en Ram 1 2 4 8 1 2 4 8 4 8 12 2 1/2 Rango -128 a 127 -32768 a 32767 -2147483648 a 2147483647 -9223372036854775808 a 9223372036854775807 0 a 255 0 a 65535 0 a 4294967295 0 a 18446744073709551615 Aprox. 1.5 x 10-45 a 3.4 x 1038 con 7 decimales Aprox. 5.0 x 10-324 a 1.7 x 10308 con 15 o 16 decimales Aprox. 1.0 x 10-28 a 7.9 x 1028 con 28 o 29 decimales Cualquier caracter Unicode true o false

En particular cada tipo de dato que se menciona aqu es en realidad un OBJETO, que se deriva a su vez de una clase que provee el framework de microsoft net es por eso que se incluye la clase de la cual proviene el tipo de dato. Es decir en un programa se podr declarar una variable por ejemplo float pi; o tambin se podr declarar y crear un objeto derivado de esa clase, por ejemplo System.Float alfa = new System.Float(); para este caso observar y tener en cuenta dos cosas: Observar cmo se declara y crea un objeto ( este formato de creacin de objetos aprenderlo bien).

Como objeto alfa podr usar todas las propiedades y mtodos asociadas al objeto, ms adelante se ve un tema donde se analiza ms a fondo el concepto de clases y objetos. Signed significa que se puede usar el signo + o - al usar la variable. Por ultimo variables strings o variables cadena, se podrn crear usando la clase STRING que creara un objeto de dicho tipo. Para declarar un variable en un script o programa solo usar el siguiente formato: Tipo de dato lista de variables; ejemplo:

string nombre, ciudad; int alfa, beta; string ciudad=tijuana; float pi=3.1416;

Para el caso de objetos numricos derivados de la clase respectiva, solo usar el formato que se indic en los prrafos de arriba. Recordar que c# net es case-sensitive, es decir reconoce la diferencia que hay entre maysculas y minsculas, en otras palabras no declarar alfa e intentar capturar o desplegar ALFA. Para convertir nmeros a strings no hay problema, solo cargar o asignar el nmero o variable numrica a la variable string, pero para convertir strings a nmeros existen y debern usarse los mtodos Parse de las clases respectivas ejemplo; String beta1=100; Int beta2 = System.Int32.Parse(beta1); Las secuencias de escape que reconoce c#(csharp) y que se pueden usar dentro de una string son:

Character Escape Sequence ' \' \ \ Alert \a Backspace \b Form feed \f New Line \n Carriage Return \r Horizontal Tab \t Vertical Tab \v A unicode character specified by its number e.g. \u200 \u A unicode character specified by its hexidecimal code e.g. \xc8 \x Null \0 (zero)

Tipos de datos primitivos en C#

Los tipos de datos primitivos son aquellos que almacenan directamente el valor, a diferencia de los tipos de datos referencia que almacenan la direccin de memoria donde se almacena el dato (los objetos son tipo de datos referencia) Los tipos de datos primitivos los podemos agrupar en:

Tipos enteros
Segn el valor entero mximo a almacenar podemos elegir entre: int (2147483,648, 2147483647) (es el que normalmente hemos elegido hasta este momento cada vez que necesitamos almacenar un valor entero), byte (podemos almacenar un valor entre 0 y 255), sbyte (-128 y 127), short (-32768, 32767), ushort (0, 65535), uint (0, 4294967295), long (9223372036854775808, 9223372036854775807) y ulong (0, 18446744073709551615)

Problema 1:

Confeccionar un programa que defina variables enteras una por cada tipo. Mostrar por pantalla el valor almacenado en cada variable
Programa:
using using using using System; System.Collections.Generic; System.Linq; System.Text;

namespace TiposDatosPrimitivos1 { class Program { static void Main(string[] args) { byte v1 = 200; Console.WriteLine("Valor almacenado byte:" + v1); sbyte v2=-100; Console.WriteLine("Valor almacenado sbyte:" + v2); short v3 = 30000; Console.WriteLine("Valor almacenado short:" + v3); ushort v4 = 60000; Console.WriteLine("Valor almacenado ushort:" + v4); int v5 = -2000000000; Console.WriteLine("Valor almacenado int:" + v5); uint v6 = 2000000000; Console.WriteLine("Valor almacenado uint:" + v6); long v7 = -1000000000000000000; Console.WriteLine("Valor almacenado long:" + v7); ulong v8 = 1000000000000000000; Console.WriteLine("Valor almacenado ulong:" + v8); Console.ReadKey(); } } }

en la variable de tipo en la variable de tipo en la variable de tipo en la variable de tipo en la variable de tipo en la variable de tipo en la variable de tipo en la variable de tipo

Problema 2:

Mostrar el valor mximo y mnimo que puede almacenar cada tipo de dato entero en C#.

Programa:
using using using using System; System.Collections.Generic; System.Linq; System.Text;

namespace TiposDatosPrimitivos2 { class Program { static void Main(string[] args) { Console.WriteLine("Valor mximo y mnimo para tipo byte."); Console.WriteLine("Mnimo:" + byte.MinValue); Console.WriteLine("Mximo:" + byte.MaxValue); Console.WriteLine("Valor mximo y mnimo para tipo sbyte."); Console.WriteLine("Mnimo:" + sbyte.MinValue); Console.WriteLine("Mximo:" + sbyte.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo short."); Console.WriteLine("Mnimo:" + short.MinValue); Console.WriteLine("Mximo:" + short.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo ushort."); Console.WriteLine("Mnimo:" + ushort.MinValue); Console.WriteLine("Mximo:" + ushort.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo int."); Console.WriteLine("Mnimo:" + int.MinValue); Console.WriteLine("Mximo:" + int.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo uint."); Console.WriteLine("Mnimo:" + uint.MinValue); Console.WriteLine("Mximo:" + uint.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo long."); Console.WriteLine("Mnimo:" + long.MinValue); Console.WriteLine("Mximo:" + long.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo ulong."); Console.WriteLine("Mnimo:" + ulong.MinValue); Console.WriteLine("Mximo:" + ulong.MaxValue); Console.ReadKey(); } } }

de dato

de dato

de dato

de dato

de dato

de dato

de dato

de dato

Los tipos de datos primitivos tienen asociados clases con una serie de propiedades y mtodos. Las propiedades MinValue y MaxValue nos permiten acceder a los valores mnimos y mximos que pueden almacenar cada tipo de dato.

Tipos reales
Podemos almacenar la parte entera y la parte fraccionaria. Disponemos tres tipos de datos reales: float, double y decimal.
Problema 3:

Mostrar el valor mximo y mnimo que puede almacenar cada tipo de dato real en C#.
Programa:
using using using using System; System.Collections.Generic; System.Linq; System.Text;

namespace TiposDatosPrimitivos3 { class Program { static void Main(string[] args) { Console.WriteLine("Valor mnimo y mximo para tipo de dato float."); Console.WriteLine("Mnimo:" + float.MinValue); Console.WriteLine("Mximo:" + float.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo de dato double."); Console.WriteLine("Mnimo:" + double.MinValue); Console.WriteLine("Mximo:" + double.MaxValue); Console.WriteLine("Valor mnimo y mximo para tipo de dato decimal."); Console.WriteLine("Mnimo:" + decimal.MinValue); Console.WriteLine("Mximo:" + decimal.MaxValue); Console.ReadKey(); } } }

El tipo de dato decimal es el que ms se adecua para almacenar datos monetarios (tiene una precisin de 28 dgitos decimales)

Tipo char
El tipo de dato primitivo char puede almacenar un caracter Unicode.
char letra='A';

Tipo lgico
Puede almacenar el valor true o false.
bool encontrado=false;

Problema 4:

Mostrar cuantos bytes de memoria requieren cada tipo de dato primitivo en C# (utilizar el operador sizeof)
Programa:
using using using using System; System.Collections.Generic; System.Linq; System.Text;

namespace TiposDatosPrimitivos4 { class Program { static void Main(string[] args) { Console.WriteLine("Bytes reservados sizeof(byte)); Console.WriteLine("Bytes reservados sizeof(sbyte)); Console.WriteLine("Bytes reservados sizeof(short)); Console.WriteLine("Bytes reservados sizeof(ushort)); Console.WriteLine("Bytes reservados sizeof(int)); Console.WriteLine("Bytes reservados sizeof(uint)); Console.WriteLine("Bytes reservados sizeof(long)); Console.WriteLine("Bytes reservados sizeof(ulong)); Console.WriteLine("Bytes reservados sizeof(float)); Console.WriteLine("Bytes reservados sizeof(double)); Console.WriteLine("Bytes reservados + sizeof(decimal)); Console.WriteLine("Bytes reservados sizeof(char)); Console.WriteLine("Bytes reservados sizeof(bool)); Console.ReadKey();

para el tipo byte:" + para el tipo sbyte:" + para el tipo short:" + para el tipo ushort:" + para el tipo int:" + para el tipo uint:" + para el tipo long:" + para el tipo ulong:" + para el tipo float:" + para el tipo double:" + para el tipo decimal:" para el tipo char:" + para el tipo bool:" +

} } }

http://www.csharpya.com.ar/detalleconcepto.php?codigo=180&inicio=40