Introdução às Palavras-chave C #
O artigo a seguir é um conceito muito básico e elementar no mundo da programação. O artigo aborda Palavras-chave na linguagem de programação C #. É o trampolim para aprender a codificar. Vamos explorar a maioria das palavras-chave de nível elementar em C # com exemplos. Vamos começar.
Nota: Este artigo faz referência ao C # v4.0. Algumas palavras-chave podem não ter sido introduzidas em versões anteriores, enquanto que as palavras-chave mais recentes podem ter sido introduzidas em versões posteriores.O que são palavras-chave?
Palavras-chave são palavras reservadas em qualquer linguagem de programação.
Para quem eles estão reservados?
Eles são reservados para o compilador.
Por que eles são reservados?
As palavras-chave transmitem algum significado especial ao compilador. Sempre que um compilador encontra uma palavra-chave, ele continua executando um determinado conjunto de instruções associadas à palavra-chave.
Onde os uso no meu programa?
Todo programa contém combinações de palavras-chave e identificadores. Identificadores são elementos definidos pelo usuário do programa. As palavras-chave não são definidas pelo usuário. Portanto, eles não podem ser usados como identificadores.
Lembra do primeiro programa 'Hello World' que você aprendeu? Você usou algumas palavras-chave como pública, string, estática, nula etc.
Tipos de palavras-chave em C #
Abaixo estão os dois tipos de palavras-chave em C #:
A. Palavras-chave reservadas
Palavras-chave reservadas em C # são reservadas para o compilador em qualquer parte do programa.
1. base
Dentro de uma classe derivada, a palavra-chave base é usada para acessar os membros da classe base.
Exemplo:
using System;
public class Car
(
public void DisplayInfo(string engine)
(
Console.WriteLine("Engine - (0)", engine);
)
)
public class Ferrari : Car
(
public void DisplayInfo()
(
base.DisplayInfo("1.6 Litre 4-cylinder");
Console.WriteLine("Company - Ferrari");
)
)
public class Program
(
public static void Main()
(
var myCar = new Ferrari();
myCar.DisplayInfo();
)
)
Resultado:
2. bool, byte, char, double, decimal, float, int, long, sbyte, short, string, uint, ulong, ushort
Todas essas palavras-chave são usadas para especificar o tipo de variável. Ao especificar um tipo de variável, você informa ao compilador o tipo de valores que essa variável pode armazenar. Por exemplo, int pode armazenar valores inteiros e não seqüências de caracteres.
Exemplo:
using System;
public class Program
(
public static void Main()
(
bool varBool = true; // stores either true or false values
byte varByte = 205; // stores unsigned 8-bit integer (0 to 255)
sbyte varSByte = -128; // stores signed 8-bit integer (-128 to 127)
short varShort = -12345; // stores signed 16-bit integer (-32768 to 32767)
ushort varUShort = 65000; // stores unsigned 16-bit integer (0 to 65535)
int varInt = -1234567890; // stores signed 32-bit integer
uint varUInt = 1234567890; // stores unsigned 32-bit integer
long varLong = -9876543210; // stores signed 64-bit integer
ulong varUL = 9876543210; // stores unsigned 64-bit integer
char varChar = 'a'; // stores a single unicode character
string varString = "abc"; // stores a string of characters
float vsrFloat = 0.12F; // stores floating point numbers (4 bytes)
double varDouble = 1.23; // stores large floating point numbers (8 bytes)
decimal varDec = 4.56M; // stores large floating point numbers (16 bytes)
)
)
3. quebrar, continuar, ir
As instruções break e continue são usadas para alterar a iteração atual de um loop no tempo de execução. A palavra-chave break quebra o loop e sai sem executar as iterações restantes. A instrução continue sai da iteração atual do loop para continuar com a próxima iteração.
A palavra-chave goto é usada para pular a execução do programa para qualquer linha. A linha é acompanhada por um rótulo específico que é referenciado na instrução goto.
Exemplo:
using System;
public class Program
(
public static void Main()
(
for (int i = 1; i < 10; i++)
(
if (i % 2 == 0)
(
Console.WriteLine("(0) is even. Continuing to next iteration.", i);
continue;
)
if (i % 3 == 0)
(
goto myLabel;
)
if (i % 7 == 0)
(
Console.WriteLine("Found 7. Exiting loop.");
break;
)
continue; // To prevent execution of next statement unless goto statement encountered.
myLabel:
Console.WriteLine("(0) is non-even multiple of 3", i);
)
)
)
Resultado:
4. tente, pegue, finalmente
As palavras-chave try, catch e finalmente são usadas no tratamento de exceções. Qualquer código que possa resultar em uma exceção em tempo de execução é incluído em um bloco try. O bloco catch captura a exceção e processa um conjunto de instruções definidas no bloco. O bloco final é sempre executado independentemente de uma exceção ser lançada ou não.
Exemplo:
using System;
public class Program
(
public static void Main()
(
int() myArray = new int()(1, 2, 3, 4, 5);
try
(
for (int i = 0; i <= 5; i++)
(
Console.WriteLine(myArray(i));
)
)
catch (Exception e)
(
Console.WriteLine("(0) exception occurred.\n", e.GetType());
)
finally
(
myArray.Dump();
)
)
)
5. classe, enum, interface, estrutura
Essas palavras-chave são usadas para definir tipos definidos pelo usuário em C #.
Exemplo:
using System;
public interface Days
(
void DisplayDayOfWeek(int x);
)
public struct StructOfEnums : Days
(
public enum Days
(
Sun = 1,
Mon,
Tue,
Wed,
Thu,
Fri,
Sat
)
public enum OrdinalNum
(
First = 1,
Second,
Third,
Fourth,
Fifth,
Sixth,
Seventh
)
public void DisplayDayOfWeek(int num)
(
Console.WriteLine("(0) day of week is (1)", (OrdinalNum)num, (Days)num);
)
)
public class Program
(
public static void Main()
(
new StructOfEnums().DisplayDayOfWeek(1);
)
)
Resultado:
6. const, somente leitura
As palavras-chave const e readonly são usadas para definir constantes e campos de tipo somente leitura em C #. Um campo constante é uma constante em tempo de compilação, enquanto um campo somente leitura pode ser inicializado em tempo de execução. Um campo somente leitura pode ser reatribuído várias vezes por meio de um construtor, mas não pode ser alterado após a saída do construtor.
Exemplo:
using System;
public class Program
(
public const double AccelerationOfGravity_g = 9.8;
public readonly double mass;
public Program(double mass)
(
this.mass = mass;
)
public double CalculateWeight()
(
return this.mass * AccelerationOfGravity_g;
)
public static void Main()
(
var body1 = new Program(130.8d);
var body2 = new Program(98.765d);
Console.WriteLine("Weight of body 1 (W = mxg) = (0) newtons", body1.CalculateWeight());
Console.WriteLine("Weight of body 2 (W = mxg) = (0) newtons", body2.CalculateWeight());
)
)
Resultado:
7. faça, enquanto
Essas palavras-chave implementam os loops de fazer enquanto e enquanto.
Exemplo:
using System;
public class Program
(
public static void Main()
(
int i = 0;
do
(
Console.WriteLine("Hello World");
i++;
)
while (i < 5);
)
)
Resultado:
8. se, senão
Essas palavras-chave implementam a lógica if-then-else no programa.
Exemplo:
using System;
public class Program
(
public static void Main()
(
int i = 1;
if (i == 0)
Console.WriteLine("Hello World");
else
Console.WriteLine("Hey There!");
)
)
Resultado:
9. verdadeiro, falso
Essas palavras-chave denotam os valores booleanos de verdade e falsidade.
Exemplo
using System;
public class Program
(
public static void Main()
(
bool val = true;
if (val)
Console.WriteLine("Hello World");
else
Console.WriteLine("Hey There!");
)
)
Resultado:
10. para, foreach
Essas palavras-chave implementam os loops for e foreach.
Exemplo:
using System;
public class Program
(
public static void Main()
(
int() num = (1, 2, 3, 4, 5);
for (int i = 0; i < num.Length; i++)
Console.Write("(0)\t", i);
Console.WriteLine();
foreach (int i in num)
Console.Write("(0)\t", i * i);
)
)
Resultado:
11. privado, protegido, público, interno
Essas palavras-chave são os modificadores de acesso em C #. Eles controlam a acessibilidade de qualquer elemento C # em qualquer parte do programa.
Exemplo:
using System;
public class MyClass
(
// ascending order of accessibility
private int a;
protected int b;
internal int c;
public int d;
)
12. novo
Usado para declarar um novo objeto.
Exemplo:
using System;
public class Program
(
public static void Main()
(
var a = new int(3)(1, 2, 3);
)
)
13. nulo
Indica um valor nulo.
Exemplo:
Using System;
public class Program
(
public static void Main()
(
string a = null;
Console.Write(a);
)
)
Resultado:
14. retorno
Essa palavra-chave retorna o controle do método atual para o método de chamada.
Exemplo:
using System;
public class Program
(
public static int sum(int x, int y)
(
return x + y;
)
public static void Main()
(
Console.Write("Sum of 5 and 6 is (0)", sum(5, 6));
)
)
Resultado:
15. estática
Usado para declarar o membro da classe como estático.
Exemplo:
using System;
public class Program
(
public static void Main()
(
Console.WriteLine("Hello World");
)
)
Resultado:
16. interruptor, estojo
Essas palavras-chave implementam a condição da chave no programa.
Exemplo:
using System;
public class Program
(
public static void Main()
(
var abc = true;
switch (abc)
(
case true:
Console.WriteLine("Hello World");
break;
case false:
Console.WriteLine("Hey There!");
break;
)
)
)
Resultado:
17. isso
Essa palavra-chave é uma referência à instância atual da classe.
Exemplo:
using System;
public class Program
(
int myVar;
public Program(int val)
(
this.myVar = val;
)
public static void Main()
(
Program obj = new Program(123);
Console.WriteLine(obj.myVar);
)
)
Resultado:
18. usando
Essa palavra-chave é usada para incluir bibliotecas no programa atual.
Exemplo:
using System;
19. vazio
Essa palavra-chave é usada como um tipo de retorno de um método que não retorna nenhum valor.
Exemplo:
using System;
public class Program
(
public static void Main()
(
Console.WriteLine("Hello World");
)
)
Resultado:
B. Palavras-chave contextuais
Palavras-chave contextuais não são palavras-chave reservadas em C #. Em vez disso, eles transmitem significado especial em partes relevantes do código. Isso significa que, sempre que não for relevante, as palavras-chave contextuais podem ser usadas como identificadores válidos.
Exemplo:
O exemplo abaixo mostra que uma palavra-chave contextual pode ser usada como um identificador válido em determinadas áreas do código.
using System;
public class Program
(
public static void Main()
(
int await = 123;
Console.WriteLine(await);
)
)
Resultado:
Alguns exemplos de palavras-chave contextuais são assíncrono, aguardar, deixar, nome de, obter, definir, var, valor, ingressar etc.
Conclusão
Este artigo abordou o conceito muito básico de programação em qualquer idioma. Palavras-chave são os blocos de construção do código. É muito importante entender o significado transmitido por cada palavra-chave. Além disso, é recomendável explorar mais palavras-chave que não são usadas com muita frequência em todos os programas.
Artigos recomendados
Este é um guia para palavras-chave em C #. Aqui discutimos os tipos de palavras-chave em C # que são reservadas e contextuais em C #, juntamente com diferentes exemplos e implementação de código. Você também pode consultar os seguintes artigos para saber mais:
- Objetos em c #
- Matrizes 2D em C #
- Ponteiros em c #
- Trocando em C #
- Trocando em PHP
- Palavras-chave PHP
- C Palavras-chave
- Versões do Tableau
- Diferentes tipos de loops com suas vantagens
- Gráficos 2D em Java
- 3 tipos diferentes de matrizes em PHP (exemplos)
- Exemplos desta palavra-chave em Java