Contente

• Uma introdução rápida - C # vs Java
• Olá Mundo! em c #
• Introdução ao C #: métodos e classes
• Usando métodos
• Usando variáveis
• Passando argumentos e Usando Strings
• Aprenda o controle de fluxo em C # e crie testes simples!
• Próxima vez

Nesta postagem, você aprenderá sobre programação C # para Android, bem como onde ela se encaixa no grande esquema de desenvolvimento do Android.

Se você está interessado em se tornar um desenvolvedor Android, pode ter a impressão de que precisa aprender um dos dois idiomas: Java ou Kotlin. Esses são os dois idiomas oficialmente suportados pelo Android Studio e, portanto, os dois idiomas nos quais muitos guias e tutoriais se concentram. O desenvolvimento do Android é muito mais flexível e variado que isso, e há muitas outras maneiras de abordá-lo. Muitos deles envolvem C #.

Ler:Quero desenvolver aplicativos Android - quais idiomas devo aprender?

C # é a linguagem de programação que você usará se optar por criar um jogo no Unity, por exemplo - que também é o mecanismo de jogo mais popular e amplamente usado na Play Store. Em geral, é útil aprender a programação C # se você estiver interessado no desenvolvimento de jogos.

Você também deve aprender a programação C # se quiser usar o Xamarin. O Xamarin é uma ferramenta que permite aos desenvolvedores criar aplicativos usando o Visual Studio que podem ser facilmente portados para iOS e Android, perfeito para projetos de plataforma cruzada.

Então, com isso dito, há definitivamente uma boa razão para aprender a programação C # para Android. Vamos dar uma olhada no que você precisa saber.

Uma introdução rápida - C # vs Java

O C # é uma linguagem de programação orientada a objetos, desenvolvida pela Microsoft por volta de 2000, com o objetivo de ser moderna, simples e flexível. Como o Java (desenvolvido pela Sun Microsystem em 1990), ele originalmente evoluiu do C ++, garantindo que haja muitas semelhanças entre os dois. Por exemplo, ambos usam a mesma "base sintática", o que significa que efetivamente usam muita da mesma terminologia e estrutura. Existem algumas pequenas diferenças, mas se você estiver familiarizado com um idioma, poderá entender muito do outro sem precisar ter aprendido especificamente. Para iniciantes, muitos acharão que é um pouco mais fácil aprender a programação C #.

Como linguagens orientadas a objetos, C # e Java descreverão objetos por meio de classes. Essa é uma abordagem modular da programação, que permite que trechos de código sejam usados ​​repetidamente.

Porém, onde o C # difere do Java é o uso de delegados, sua abordagem para escuta de eventos, propriedades virtuais versus finais, conversão implícita e muito mais.

A boa notícia: você realmente não precisa saber o que isso significa quando começa a aprender C #. O principal argumento é que a estrutura é um pouco mais fácil de aprender em C # e tende a exigir menos digitação. Isso é especialmente verdadeiro, considerando que, quando você aprende Java para Android, também precisa se familiarizar com as muitas classes e APIs necessárias para criar aplicativos Android. Assim, você também pode aprender a programação C # como um trampolim para Java.

Olá Mundo! em c #

A tradição no mundo da codificação é que, sempre que você aprender um novo idioma, crie um programa simples para exibir "Hello World!" Na tela. Isso basicamente garante que você possa colocar as ferramentas necessárias em funcionamento e compilar algo simples. É como ler "testando, testando 1, 2, 3" em um microfone!

Nesse caso, usaremos o Visual Studio para criar um aplicativo de console. Então, depois de fazer o download do Visual Studio (gratuito), clique em:

Arquivo> Novo> Projeto

E depois:

Visual C #> Área de trabalho clássica do Windows> Aplicativo de console (.NET Framework)

É assim que criamos um aplicativo que será executado no console do Windows.

Feito isso, a estrutura básica do seu projeto aparecerá na janela principal. Você verá um código parecido com este:

namespace ConsoleApp3 {programa de classe {static void Main (string args) {}}}

Agora basta adicionar duas linhas, assim:

namespace ConsoleApp3 {programa de classe {static void Main (string args) {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}}

Isso vai escrever “Hello World!” Na tela e, em seguida, aguarde um pressionamento de tecla. Quando o usuário toca em qualquer tecla, o programa termina e sai automaticamente.

Observe que ambas as linhas terminam com ponto e vírgula. Isso ocorre porque qualquer instrução em C # deve terminar com um ponto-e-vírgula, que comunica ao C # que a linha foi concluída (é a mesma em Java). A única exceção é quando a linha é seguida imediatamente por um colchete aberto, que explicaremos em um momento.

Pressione o botão “Iniciar” na parte superior da tela, e isso deve iniciar o aplicativo, permitindo que você veja isso na prática.

Classes são pedaços de código que descrevem objetos, que são efetivamente pedaços de dados

Então, o que exatamente está acontecendo aqui?

Introdução ao C #: métodos e classes

Para aprender a programação C # para Android, você precisa entender classes e métodos.

Classes são pedaços de código que descrevem objetos, que são efetivamente pedaços de dados. Para começar, você não precisa se preocupar muito com isso: saiba que a página do código com a qual você está trabalhando agora é chamada de "classe" e que você pode interagir com outras classes do seu projeto. Um projeto pode ter apenas uma classe, com todo o seu código funcionando a partir daí, ou pode ter várias.

Dentro de cada classe, você também terá métodos. Esses métodos são trechos de código que você pode consultar a qualquer momento dentro dessa classe - e às vezes de fora dela.

Nesse caso, a classe é chamada Programa. Isso é definido logo no topo pela linha que lê: class Program. E se você abrir a janela "Solution Explorer" à direita, poderá encontrar Program.cs. O nome da classe é sempre o mesmo que o nome do arquivo.

Em seguida, usamos um colchete para conter todo o código a seguir. Parênteses nos dizem que tudo o que se segue pertence um ao outro. Assim, até o colchete fechar, todo o código a seguir faz parte do Programa.

Isto é seguido pelo nosso primeiro método, definido pela seguinte linha:

static void Main (string args)

Isso é seguido por mais colchetes abertos, o que significa que o próximo bit de código faz parte do método "Main" (que ainda está dentro da classe Program). E foi aí que colocamos o nosso "Olá Mundo".

"Estático vazio" nos diz essencialmente que esse método faz algo independente (em vez de manipular dados a serem usados ​​pelo programa mais amplo) e que não pode ser referenciado por classes externas. O material "string args" nos permite passar informações para o método a ser manipulado posteriormente. Estes são chamados de "parâmetros" e "argumentos". Novamente, você não precisa se preocupar com nada disso ainda. Apenas saiba que “estático vazio” seguido por uma palavra, colchetes e colchetes, marca o início de um novo método.

As próximas duas linhas são as que adicionamos: elas obtêm o console e acessam seus comandos para gravar na tela e aguardar pressionar uma tecla.

Finalmente, fechamos todos os nossos colchetes: primeiro o método, depois a classe e depois o "namespace", que é o nome do projeto ao qual a classe pertence (neste caso, "ConsoleApp3" - fiz aplicativos de teste anteriores dessa maneira) .

Confuso? Não se preocupe, está prestes a fazer mais sentido.

Usando métodos

Portanto, métodos são pacotes de códigos com nomes. Para demonstrar por que usamos métodos, pode ser útil criar um novo e colocá-lo para funcionar como exemplo.

Portanto, crie um novo método que esteja dentro da classe Program (portanto, ele deve estar dentro desses colchetes, mas fora dos colchetes pertencentes a “Principal”).

Chame isso de "NewMethod" e, em seguida, coloque as duas linhas que você acabou de escrever aqui. Isso deve ficar assim:

classe Programa {static void Main (string args) {} static void NewMethod () {Console.WriteLine ("Hello World!"); Console.ReadKey (); }}

Agora adicione uma referência ao NewMethod no seu método Main, assim:

static void Main (string args) {ar ​​NewMethod (); }

Isso vai "chamar" o método que você acabou de criar, direcionando essencialmente o programa nessa direção. Pressione Iniciar e você verá o mesmo que antes. Exceto agora, se você quiser, você pode escrever “NewMethod ();” quantas vezes quiser e continuar repetindo o texto sem precisar escrever muito código.

Ao longo de um grande programa, poder referenciar trechos de código como esse se torna incrivelmente poderoso. Essa é uma das coisas mais importantes a entender quando você tenta aprender a programação C # para Android.

Podemos criar tantos métodos quanto gostamos dessa maneira e dessa maneira ter um pedaço de código muito limpo e organizado. Ao mesmo tempo, também podemos fazer referência a métodos incorporados ao C # e a qualquer biblioteca que possamos usar. "Principal" é um exemplo de método "interno". Este é o método pelo qual todos os programas serão iniciados e o C # entende que ele deve ser executado primeiro. Se você não colocar nada aqui, nada acontecerá!

Os argumentos incluídos nos colchetes nesse caso são, portanto, necessários apenas porque foi assim que a Microsoft projetou o método Main. No entanto, estávamos bem em deixar nossos colchetes vazios.

Usando variáveis

Agora é hora de realmente fazer algo um pouco interessante em nosso código. Especificamente, vamos dar uma olhada em como você usaria variáveis ​​para tornar o programa mais dinâmico. Essa é uma das coisas mais importantes a entender se você deseja aprender a programação C #.

Uma variável é basicamente um contêiner para um dado. Lembre-se da matemática do ensino médio e lembre-se de ver coisas assim:

10 + x = 13
Encontre x

Aqui, "x" é uma variável e, é claro, o valor que representa é "3".

Também é exatamente assim que uma variável funciona na programação. Exceto aqui, uma variável pode representar muitos tipos diferentes de dados: incluindo texto.

Para criar uma nova variável, primeiro precisamos informar ao C # que tipo de dados será usado para conter.

Portanto, dentro do seu método NewMethod (), primeiro você criará sua variável e depois atribuirá um valor a ela. Em seguida, adicionaremos ao nosso comando "WriteLine":

número int; número = 10; Console.WriteLine ("Olá Mundo!" + Número);

Usamos um tipo de variável chamada "número inteiro" que pode ser qualquer número inteiro. Em C #, nos referimos a eles usando "int". No entanto, poderíamos ter usado facilmente um "ponto flutuante", por exemplo, que é uma "variável de ponto flutuante" e nos permite usar casas decimais.

Se você executar esse código, ele deverá agora escrever “Hello World! 10 ”para a tela. E, é claro, poderíamos alterar o valor de "número" a qualquer momento para alterar o.

Como "number" é criado dentro de NewMethod (), não podemos acessá-lo de outras partes do nosso código. Mas se o colocarmos fora de todos os métodos, ele ficará disponível globalmente. Para fazer isso, precisamos garantir que a variável também seja estática:

programa de classe {static int number = 10; static void Main (string args) {NewMethod (); static void NewMethod () {Console.WriteLine ("Olá, mundo!" + número); Console.ReadKey (); }}

Finalmente, há mais uma maneira de transmitir esses dados, e isso seria usá-los como argumento, passando-os para o nosso método. Pode parecer assim:

static void Main (string args) {int number = 10; Console.WriteLine ("Olá, qual é o seu nome?"); NewMethod (número); static void NewMethod (número int) {Console.WriteLine ("Hello World!" + número); Console.ReadKey (); }}

Aqui, estamos definindo nosso método NewMethod como necessitando de um argumento, que deve ser um número inteiro e que será referido no método como "número". Fazemos isso simplesmente adicionando essas informações aos colchetes. Então, quando chamamos o método de qualquer outro lugar do programa, precisamos "passar" esse valor entre colchetes. Você pode criar métodos com vários parâmetros; nesse caso, basta separar as variáveis ​​listadas com vírgulas.

Existem diferentes cenários em que o uso de todas essas estratégias diferentes para manipular dados será apropriado. Uma boa programação significa encontrar o caminho certo para o trabalho!

Passando argumentos e Usando Strings

Tente executar o próximo trecho de código e veja o que acontece:

classe Program {static void Main (string args) {Console.WriteLine ("Olá, qual é o seu nome?"); NewMethod (Console.ReadLine ()); static void NewMethod (String UserName) {Console.WriteLine ("Hello" + UserName); Console.ReadKey (); }}

Você deve descobrir que é solicitado a digitar seu nome e que o console o agrada. Este simples trecho de código contém várias lições úteis.

Primeiro, vemos um exemplo de como usar um tipo diferente de variável, chamado String. Uma String é uma série de caracteres, que podem ser um nome ou uma história inteira.

Assim, você poderia facilmente escrever UserName = "Adam". Mas, em vez disso, estamos obtendo a string do console com a instrução: Console.ReadLine ().

Poderíamos ter escrito:

Usuário de String; Usuário = Console.ReadLine (); NewMethod (Usuário);

Mas, para manter nosso código o mais organizado possível, pulamos essas etapas e colocamos o "ReadLine" diretamente entre colchetes.

Em seguida, passamos essa string para nosso NewMethod e cumprimentamos o usuário, usando o método que você já conhece.

Uma String é uma série de caracteres, que podem ser um nome ou uma história inteira.

Felizmente, agora você está começando a entender um pouco sobre por que o C # é escrito da maneira como é e como você pode usar coisas como variáveis ​​e métodos para criar um software flexível e poderoso.

Mas há mais um aspecto importante que você deve saber se deseja aprender a programação C #: controle de fluxo.

Aprenda o controle de fluxo em C # e crie testes simples!

Uma das razões pelas quais usamos variáveis ​​ao codificar é para que possamos editar facilmente nossos programas posteriormente. Outra é para que você possa obter informações do usuário ou gerá-las aleatoriamente.

Mas talvez o melhor motivo para aprender variáveis ​​de C #, seja para que seus programas se tornem dinâmicos: para que possam reagir de maneira diferente, dependendo de como são usados.

Para esse fim, precisamos de "controle de fluxo" ou "declarações condicionais". Essas são apenas maneiras sofisticadas de dizer que vamos executar o código de mais de uma maneira, dependendo do valor de uma variável.

E uma das maneiras mais poderosas de fazer isso é com uma declaração "se". Neste exemplo, vamos cumprimentar nosso usuário principal de maneira diferente dos outros, procurando pelo nome de usuário.

estático void NewMethod (String UserName) {Console.WriteLine ("Hello" + UserName); if (UserName.Equals ("Adam")) {Console.WriteLine ("Bem-vindo de volta, senhor"); } Console.ReadKey (); }

As instruções "If" funcionam testando a validade de uma instrução, que entra entre colchetes. Nesse caso, estamos perguntando se a string UserName é igual à string "Adam". Se essa declaração entre colchetes for verdadeira - as duas cadeias são iguais -, o código nos seguintes colchetes será executado. Caso contrário, essas linhas serão ignoradas.

Da mesma forma, podemos comparar números inteiros e flutuantes, e podemos testar para ver se um é maior que o outro, etc. Podemos até usar várias instruções if diferentes dentro de outras como bonecas russas. Chamamos esses "ifs aninhados".

Próxima vez

Existem muitas outras estratégias que você pode usar para controle de fluxo - incluindo coisas como instruções de chave. Felizmente, você já pode ver como podemos usar essas instruções e técnicas para começar a fazer algumas coisas úteis. Você pode facilmente transformar esse código em um questionário!

Eventualmente, o C # com ferramentas como o Unity permitirá criar jogos totalmente funcionais!

Mas, para realmente criar ferramentas e jogos impressionantes, há mais algumas coisas que precisamos explorar. Então, surpresa! Haverá uma parte dois!

Na próxima lição, você descobrirá como criar loops que iteram ao longo do tempo, bem como criar novas classes e interagir com elas. Vejo você então!