Arquivo da categoria ‘C#’

Condição – Case e Switch – Java, C++, C# e Abap

Publicado: 14 de fevereiro de 2014 em Abap, C#, C/C++, Java

A instrução CASE como o IF também é um comando clássico e existe em muitas linguagens de programação, seja ela compilada ou interpretada. O comando Case predominou por muitos anos e nos tempos atuais ganhou uma nova cara e um novo nome apesar de permanecer com a mesma estrutura, o SWITCH. Comando CASE ainda é usado nos dias atuais por varias linguagens de programação e linguagens de scripts entre elas o ABAP, PL/SQL, TRANSACT-SQL e outras.

A instrução CASE e SWITCH é como uma série de instruções IF, apenas usando a palavra-chave WHEN (Quando) ou CASE (Caso). A instrução é avaliada a partir de cima para baixo. Se a condição for verdadeira, então correspondente a cláusula é executado e execução salta para o fim do caso (avaliação curto-circuito).

Ou seja ao contrário de if-then e declarações if-then-else, a instrução switch pode ter um número de possíveis caminhos de execução. Um switch funciona com o byte, short, char, e tipos primitivos de dados int. Ele também funciona com tipos enumerados, a classe String, e algumas classes especiais que envolvem certos tipos primitivos: Character, Byte, Short, e Integer.

Exemplo:

Neste simples exemplo podemos ver como mostrar na tela o dia da semana usando um numero de 1 a 7.

Java

public class Caso {

public static void main(String[] args)
 {
      int dia = 5;
     switch (dia)
   {
       case 1:
      System.out.println("Segunda");
    break;
          case 2:
       System.out.println("Terça");
    break;
           case 3:
       System.out.println("Quarta");
    break;
           case 4:
       System.out.println("Quinta");
    break;
          case 5:
       System.out.println("Sexta");
    break;
          case 6:
       System.out.println("Sabado");
    break;

    default:
       System.out.println("Domingo");
    break;
  }

}

}

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication55
 {
     class Program
     {
         static void Main(string[] args)
         {
              int dia = 5;
     switch (dia)
   {
       case 1:
      Console.WriteLine("Segunda");
    break;
          case 2:
       Console.WriteLine("Terça");
    break;
           case 3:
       Console.WriteLine("Quarta");
    break;
           case 4:
       Console.WriteLine("Quinta");
    break;
          case 5:
       Console.WriteLine("Sexta");
    break;
          case 6:
       Console.WriteLine("Sabado");
    break;

   default:
   Console.WriteLine("Domingo");
   break;
  }

   Console.ReadKey();
         }
     }
 }

C++

#include "stdafx.h"
#include <iostream>
#include <cstdlib>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {
  int dia = 5;

switch (dia)
  {
  case 1:
   cout << "Segunda" << endl;
   break;

case 2:
   cout << "Terça" << endl;
   break;

case 3:
   cout << "Quarta" << endl;
   break;

case 4:
   cout << "Quinta" << endl;
   break;

case 5:
   cout << "Sexta" << endl;
   break;

case 6:
   cout << "Sabado" << endl;
   break;

default:
   cout << "Domingo" << endl;
   break;
  }
  system("pause");
  return 0;
 }

ABAP

*&---------------------------------------------------------------------*
*& Report  ZCASO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Caso
*&---------------------------------------------------------------------*
REPORT  ZCASO.

DATA dia TYPE i.

dia = 5.

CASE dia.

WHEN 1.
               WRITE : / 'Segunda'.

WHEN  2.
               WRITE : / 'Terça'.

WHEN  3.
               WRITE : / 'Quarta'.

WHEN  4.
               WRITE : / 'Quinta'.

WHEN  5.
               WRITE : / 'Sexta'.

WHEN  6.
               WRITE : / 'Sabado'.

WHEN OTHERS.
               WRITE : / 'Domingo'.
ENDCASE.

Classes – Escopos – Java, C++ e C#

Publicado: 14 de fevereiro de 2014 em C#, C/C++, Java

Escopo refere-se à vida e acessibilidade de uma variável. Quão grande é o alcance depende de onde uma variável é declarada. Por exemplo, se uma variável é declarada na parte superior de uma classe, ela será acessível a todos os métodos de classe. Se for declarada num método, em seguida, só pode ser utilizada em tal método.

O escopo de uma variável é a parte do programa que pode acessar uma variável. Quando você tenta acessar uma variável que não está no escopo, você normalmente tém um erro do compilador. Aqui estão algumas das regras de escopo:

  1. Variáveis ​​de classe (campos estáticos) estão no escopo em todos os lugares na classe.
  2. Se uma variável de classe é declarada “pública”, está no escopo em todas as classes.
  3. As variáveis ​​de instância (campos não-estáticos) estão no escopo em métodos não estáticos chamados em um objeto apropriado.
  4. As variáveis ​​e parâmetros locais estão no escopo apenas dentro do método que os declarou.

Exemplo:

Neste exemplo veremos o alcance do escopo das variáveis estáticas, publicas e privadas em sua classe. Na classe principal vemos o resultado do escopo utilizado na classe planeta.

As variáveis privadas podem ser utilizadas somente dentro da classe planeta, a variável publica pode ser utilizada por todas as classes ou neste caso pelo objeto, a variável estática é utilizada globalmente e não precisa ser instanciada, todos os objeto que você criar, ou seja outros planetas irão compartilhar os dados desta variável, as variáveis locais criadas dentro do construtor só podem ser utilizadas dentro do método em que foi criada.

Criamos o objeto da classe planeta chamado Marte, experimente criar outros objetos com nome de planetas e imprima seus valores.

Java

Classe #1 – Principal

public class principal {

public static void main(String[] args)
  {
      Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

      marte.apelido = "Marte";

      System.out.println("Quantidade de planetas: " + Planetas.numeroDePlanetas);
      System.out.println("Nome do Planeta: " + marte.apelido);
      System.out.println("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
      System.out.println("mas podem ser utlizadas dentro da classe");
  }
 }
 

Classe #2 – Planetas

public class Planetas {

 // Variavel da classe é compartilhada por todos
 public static long numeroDePlanetas;

 // Variavel de intancias
 private double x, y;
 private double massa;
 public String apelido;

      // Construtor
      //  x e y são  variaveis instanciadas,
      //  mas newX and newY são variaveis locais
      //  O construtor incrementa o valor
    public  Planetas(double novoX, double novoY, double novaMassa)
    {
       x = novoX;
       y = novoY;

       massa = novaMassa;
       numeroDePlanetas++;
    }
}

C#

Classe #1 – Principal

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication53  {
      class Program
      {
          static void Main(string[] args)
          {
              Planetas marte = new Planetas(3.0, 1.5, 6.419e23);

              marte.apelido = "Marte";

              Console.WriteLine("Quantidade de planetas: " + Planetas.numeroDePlanetas);
              Console.WriteLine("Nome do Planeta: " + marte.apelido);
              Console.WriteLine("As outras variaveis da classe não podem ser alcançadas devido ao escopo");
              Console.WriteLine("mas podem ser utlizadas dentro da classe");

              Console.ReadKey();
          }
      }
  }

Classe #2 – Planetas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication53 {

public class Planetas {

         // Variavel da classe é compartilhada por todos
          public static long numeroDePlanetas;

         // Variavel de intancias
          private double x, y;
          private double massa;
          public String apelido;

          // Construtor
          //  x e y são  variaveis instanciadas,
          //  mas newX and newY são variaveis locais
          //  O construtor incrementa o valor

          public Planetas(double novoX, double novoY, double novaMassa)
          {
              x = novoX;
              y = novoY;

              massa = novaMassa;
              numeroDePlanetas++;
          }
    }
} 

C++

Classe #1 – Principal

#include "stdafx.h"
#include <iostream>
#include <string>
#include "planetas.h"

using namespace std;

int _tmain(int argc, _TCHAR* argv[])  {

   Planetas marte(3.0, 1.5, 6.419e23);

   marte.apelido = "Marte";

   cout << "Quantidade de planetas: " << marte.numeroDePlanetas << endl;
   cout << "Nome do Planeta: " << marte.apelido << endl;
   cout << "As outras variaveis da classe não podem ser alcançadas devido ao escopo" << endl;
   cout << "mas podem ser utlizadas dentro da classe" << endl;

   system("pause");

   return 0;
}

Classe #2 – Planetas

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

class Planetas {

private:
    // Variavel de intancias
     double x, y;
     double massa;

public:

     // Variavel de intancias
     string apelido;

     // Variavel da classe é compartilhada por todos
     static int numeroDePlanetas;

     // Construtor
     //  x e y são  variaveis instanciadas,
     //  mas newX and newY são variaveis locais
     //  O construtor incrementa o valor

  Planetas(double novoX, double novoY, double novaMassa)
  {
    x = novoX;
    y = novoY;

    massa = novaMassa;
    numeroDePlanetas++;
   }
};

  int Planetas::numeroDePlanetas;

Encapsulamento que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações. Objetos restringem a visibilidade de seus recursos (atributos e métodos) aos outros usuários. Todo objeto tem uma interface, que determina como os outros objetos podem interagir com ele. A implementação do objeto é encapsulada, isso é, invisível ou visível  fora do próprio objeto.

Public – deixa visível a classe ou membro para todas as outras classes, subclasses e pacotes do projeto Java, ou namespaces do projeto C#.

Private – deixa visível o atributo apenas para a classe em que este atributo se encontra.

Protected – deixa visível o atributo para todas as outras classes e subclasses que pertencem ao mesmo pacote ou namespace.  O protected é um intermediário entre public e private.

Publico VS Private

  • Publico todas as classes podem usar os métodos e campos.
  • Privado apenas a classe  podem usar os métodos e campos.

Por que Controlar o Acesso?

  • Proteger informação privada.
  • Esclarecer como outros programadores devem usar sua classe.
  • Manter a implementação separado da interface.

Exemplo: imagine o seguinte cenário,  temos uma classe que é responsável por transações de cartões de credito geralmente este tipo de classe pertence a companhia de cartões de credito e foi desenvolvida por um outro programador e esta dentro de uma DLL ou OS, acontece que o desenvolvedor terceirizado cometeu um deslize deixando visível a propriedade numero do cartão. Um desenvolvedor malicioso pode facilmente capturar o numero do cartão referenciando o objeto.

Neste exemplo você deve brincar com o código fonte a fim de resolver o problema de controle de acesso , use CTRL+espaço após a classe para ver a visibilidade de acesso dos métodos e campos.

Java

Classe #1 – Principal

public class Malicioso {

// Assim que setar private esta void não podera ser escrita
// Você não tera mais acesso as propriedades da classe

  static void metodoMalicioso(CartaoCredito cartao)
  {
     cartao.gastos = 0;
     System.out.println("Seu numero de cartão: " + cartao.numeroCartao);
  }

  public static void main(String[] args)
  {
      // Uma transação hipotetica
      CartaoCredito transacao = new CartaoCredito();
      transacao.cobranca("3453 3636 0001 1267", 350.00);

      // Metodo malicioso Injeta um gasto valor de 0 e imprime o numero do cartão
      metodoMalicioso(transacao);
  }

}

Classe #2 – Cartão de Credito

public class CartaoCredito {

  // Esta declaração esta errada
  // Deste modo é possive capturar o numero do cartão
  // A classe expos o numero para que seja acessivel de outra classe
  // para não expor os numero use private
  // private String numeroCartao;
  // private double gastos;

   public String numeroCartao;
   double gastos;

   // Em java mesmo não declarando publico a propriedade ainda é acessivel
   //  public para a void ser vista por outras classes

   public  void cobranca (String nCartao,double valor)
   {
      numeroCartao = nCartao;
      gastos = gastos + valor;
   }

}

C#

Classe #1 – Principal

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Malicioso {

class Program
{

   // Assim que setar private esta void não podera ser escrita
   // Você não tera mais acesso as propriedades da classe

   static void metodoMalicioso(CartaoCredito cartao)
   {
      cartao.gastos = 0;
      Console.WriteLine("Seu numero de cartão: " + cartao.numeroCartao);
   }

   static void Main(string[] args)
   {
      // Uma transação hipotética
      CartaoCredito transacao = new CartaoCredito();
      transacao.cobranca("3453 3636 0001 1267", 350.00);

     // Metodo malicioso Injeta um gasto valor de 0 e imprime o numero do cartão
     metodoMalicioso(transacao);
     Console.ReadKey();
   }
  }
}

Classe #2 – Cartão de Credito

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Malicioso
 {

     public class CartaoCredito
     {
         // Esta declaração esta errada
         // Deste modo é possive capturar o numero do cartão
         // A classe expos o numero para que seja acessivel de outra classe
         // para não expor os numero use private
         // private String numeroCartao;
         // private double gastos;

         public String numeroCartao;
         public double gastos;

         //  public para a void ser vista por outras classes
         public void cobranca(String nCartao, double valor)
         {
             numeroCartao = nCartao;
             gastos = gastos + valor;
         }
     }
}

Classes – Static e Construtores – Java e C#

Publicado: 9 de fevereiro de 2014 em C#, Java

Construtores

Construtores são métodos especiais chamados pelo sistema no momento da criação de um objeto. Eles não possuem valor de retorno, porque você não pode chamar um construtor para um objeto, você só usa o construtor no momento da inicialização do objeto. Construtores representam uma oportunidade de inicializar seus dados de forma organizada. Construtores são obrigatórios em uma classe, mas não é preciso declara-los, caso não declare um construtor por default a declaração é: Classe().

Static

Declaração de  um tipo de Classe, método, propriedade ou variável que pertence exclusivamente a sua própria classe, classes estáticas não podem ser instanciadas.

Exemplo:

Neste cenário queremos saber quantos objetos de uma determinada classe foram instanciados, para isto criamos um contador no construtor do objeto e a cada objeto criado o contador aumenta nos mostrando no final a quantidade exata de novos objetos de uma classe. Visto que nosso contador pertence a classe e não a cada instancia de cada classe, neste caso para usar o contador não precisamos instanciar a classe graças a declaração static.

Java

Classe #1  – Principal


public class Principal {

public static void main(String[] args)
 {
      System.out.println("Quantidade de objetos:" + Construtor.quantidade);
      Construtor c1 = new Construtor();

      System.out.println("Quantidade de objetos:" + Construtor.quantidade);
      Construtor c2 = new Construtor();

      System.out.println("Quantidade de objetos:" + Construtor.quantidade);
      Construtor c3 = new Construtor();

      System.out.println("Quantidade de objetos:" + Construtor.quantidade);

}

}

Classe # 2 – Construtor


class Construtor {

static int quantidade;

Construtor() {
   quantidade = quantidade + 1;
 }

}

C#

Classe #1  – Principal

class Program     {
  static void Main(string[] args)  {

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);
     Construtor c1 = new Construtor();

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);
     Construtor c2 = new Construtor();

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);
     Construtor c3 = new Construtor();

     Console.WriteLine("Quantidade de objetos:" + Construtor.quantidade);

     Console.ReadKey();
    }
}

Classe # 2 – Construtor

class Construtor {

   public static  int quantidade;

   public  Construtor() {
      quantidade = quantidade+1;
   }

}

Classes – Referência – Java e C#

Publicado: 8 de fevereiro de 2014 em C#, Java

Tipos Primitivos

Um tipo primitivo (também conhecido por nativo ou básico) é fornecido por uma linguagem de programação como um bloco de construção básico. Dependendo da implementação da linguagem, os tipos primitivos podem ou não possuir correspondência direta com objetos na memória.

Ex: int, long, double, boolean, char, short, byte, float.

Referência

Referência na ciência da computação é registro que aponta o local em que se encontram armazenados os dados que identificam outro dado.

Tipos são arrays e objetos, – String, int[], Classes, …

Variáveis são como canecas fixas e os primitivos são pequenos o suficiente para caber dentro da caneca. Os objetos são grandes para caber dentro de variáveis. Variáveis guardam números que localizam um objeto e a localização do objeto é chamada de referencia.

Exemplo:

Neste cenário temos um bebê recém nascido que precisa ser registrado no cartório, para isto vamos criar um objeto bebê e através de um método vamos cadastrar os dados do bebê referenciando o objeto ao nosso bebê.

JAVA

1 – Classe Referencia


public class Referencia
 {
 static void cartorio(int codigo, String[] cadastro, Bebe objeto )
 {
   objeto.codigo     = codigo;
   objeto.nome       = cadastro[0];
   objeto.sobreNome  = cadastro[1];
   objeto.nomeMae    = cadastro[2];
   objeto.nomePai    = cadastro[3];
   objeto.sexo       = cadastro[4];
 }
 public static void main(String[] args)
 {

    // Vamos instanciar um novo bebe
    Bebe Samanta = new Bebe();

    // Vamos solicitar a ficha de registro para o novo bebê
    int codigoCartorio = 1438275;
    String[] fichaRegistro = {"Samanta", "Amaral", "Roberto Amaral", "Marcia Amaral", "Feminino"};

    // Vamos preerncher a ficha do novo bebê
    cartorio(codigoCartorio, fichaRegistro, Samanta);

    // Imprime registro do bebê
    System.out.println("Registro de Nascimento:");
    System.out.println("");
    System.out.println("Código: "+ Samanta.codigo );
    System.out.println("Nome: " + Samanta.nome + " " + Samanta.sobreNome);
    System.out.println("Nome do Pai: " + Samanta.nomePai);
    System.out.println("Nome da Mãe: " + Samanta.nomeMae);
    System.out.println("");
    System.out.println("Registro efetuado com sucesso");
 }

}

JAVA
2- Classe Bebe

public class Bebe
 {
  public int codigo = 0;
  public String nome = null;
  public String sobreNome = null;
  public String nomePai = null;
  public String nomeMae = null;
  public String sexo = null;

  public Bebe()
    {
    }
 }

C#

Para C# basta trocar os seguintes comandos na classe Referencia:


// Trocar:

System.out.println

// por:

Console.WriteLine

Classes – Java e C#

Publicado: 6 de fevereiro de 2014 em C#, Java

Programação Orientada a objeto

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software.

Classes

Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Em outros termos, uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar.

Representando o mundo real

Representando o mundo real temos um objeto bebê,  nosso bebê possui os seguintes atributos:

  • Nome
  • Peso
  • Sexo
  • Decibéis (choro)
  • Numero de cacas até agora

Nosso objeto bebê :


String nome
boolean genero
double peso
double decibeis
int numCaca

Porque Usar Classes?

No mundo real, muitas vezes você vai encontrar muitos objetos individuais todos da mesma espécie. Pode haver milhares de outros bebês na existência, todos parecidos. Cada bebê foi construído a partir do mesmo conjunto de projetos(DNA) e, portanto, contém os mesmos componentes. Em termos de orientação a objetos, dizemos que o seu bebê é uma instância da classe de objetos conhecidos como bebê. Uma classe é o modelo a partir do qual objetos individuais são criados. Criando a classe bebê teremos um objeto bebê com seus atributos definidos:

classe-bebe
A partir do objeto bebê podemos instanciar vários outros com as mesmas características:

classe-bebe2

Para cuidar dos bebês precisamos de enfermeiras e de um berçário, podemos também criar a classe enfermeiras e a classe berçário:

classe-bebe4

Na classe berçário podemos ter inúmeros bebês e varias enfermeiras para cuidar de cada bebê:

classe-bebe5

Podemos ir mais além e manipular varias classes a hospital, emergência, berçário, enfermeiras e bebê:

classe-bebe6

Criando Classes

Uma classe possui basicamente 3 partes distintas:

  • A Definição da classe .
  • Os membros da classe.
  • Construtor da classe.

Definição da classe: Nomes de classes são capitalizados , uma classe  é igual a um arquivo, ter um método principal (main) significa que a classe pode ser executada.


public class Bebe
{
}

Os membros da classe: Os membros da classe podem ser campos, propriedades, métodos e etc.


public class Bebe
{

String nome;
double peso= 5.0;
boolean genero;
int numCaca = 0;

}

Construtor: Nome do construtor é igual ao nome da classe, não possui retorno, nunca retorna nada, normalmente inicializa campos, todas as classes precisam de pelo menos um construtor, se você não escrever um, o padrão é Nomedaclasse() { }.


// Definição da classe
public class Bebe

{
     // membros da classe
     String nome;
     boolean eMasculino;

     // Construtor da Classe
     Baby (String meunome, boolean bebeMasculino)
     {
        nome = meunome;
        eMasculino = bebeMasculino;
     }
}

Instancias de Classes

Para criar uma instancia de uma classe use o comando new:

// Cria uma instancia
Bebe Daniel = new Bebe();

//para usar a instacia
Daniel.nome = "Daniel";

Exemplo: Neste cenário vamos criar duas classes bem simples e instanciar as classes na classe main (principal), utilizaremos apenas os princípios básicos de classes e veremos que ela funciona tanto em Java como em C#. Basicamente temos um hospital no qual seu berçário recebeu 3 novos bebês, assim que os bebês precisam de cuidados duas enfermeiras estão prontas para atende-los, seja trocando sua fralda ou prestando cuidados de enfermaria, deixando os bebê limpos e saudáveis novamente.

JAVA

Classe #1: Hospital Main Class.

public class Hospital {
	
// Esta classe funciona em Java e em C#
// Apenas troque as keyword:
// System.out.println  por
// Console.Writeln	
	
	public static void main(String[] args) {
		// Classe Hospital
		// Rescem nascidos

		Bebe Amanda = new Bebe();
		Bebe Julia = new Bebe();
		Bebe Rodrigo = new Bebe();

		// Bebê Amanda
		Amanda.nome = "Amanda";
		Amanda.tamanho = 30.4;
		Amanda.sexo = "feminino";

		// Bebê Julia
		Julia.nome = "Julia";
		Julia.tamanho = 28.7;
		Julia.sexo = "feminino";

		// Bebê Rodrigo
		Rodrigo.nome = "Rodrigo";
		Rodrigo.tamanho = 27.9;
		Rodrigo.sexo = "masculino";

		// Bebês
		System.out.println("Bebês no berçario do hospital: ");
		System.out.println("");
		System.out.println(Amanda.nome + " sexo: " + Amanda.sexo + " tamanho: "
				+ Amanda.tamanho);
		System.out.println(Julia.nome + " sexo: " + Julia.sexo + " tamanho: "
				+ Julia.tamanho);
		System.out.println(Rodrigo.nome + " sexo: " + Rodrigo.sexo
				+ " tamanho: " + Rodrigo.tamanho);

		// Bêbes que precisam de cuidados
		Amanda.setSaudavel(false);
		Rodrigo.setFezCoco(true);

		System.out.println("");
		System.out.println("Estes bebês precisam de uma enfermeira");
		if (Amanda.getSaudavel() == false) {
			System.out.println(Amanda.nome
					+ " está doente e precisa de cuidados");
		}
		if (Rodrigo.getFezCoco() == true) {
			System.out.println(Rodrigo.nome + " precisa trocar a fralda");
		}

		// Cria Enfermeiras
		Enfermeira Regina = new Enfermeira();
		Enfermeira Mara = new Enfermeira();
		Regina.nome = "Regina";
		Mara.nome = "Mara";

		// Enfermeiras trabalhando
		Amanda.setSaudavel(Regina.getEnfermaria());
		Rodrigo.setFezCoco(Mara.getTrocaFralda());

		// Bebês após cuidados
		System.out.println("");
		System.out.println(Regina.nome + " e " + Mara.nome
				+ " cuidaram dos bebês");
		if (Amanda.getSaudavel() == true) {
			System.out.println(Amanda.nome + " está saudavel novamente");
		}
		if (Rodrigo.getFezCoco() == false) {
			System.out.println(Rodrigo.nome + " esta com uma nova fralda");
		}
	}
}

Classe #2 – Classe Bebê.

public class Bebe {
	
	// Cria campos 
	public String nome = null;
	public Double tamanho = 0.0;
	public String sexo = null;
	private Boolean saudavel = true;
	private Boolean fezCoco = false;
	
    // Cria métodos Getter e Setter para a classe
	public Boolean getSaudavel() {
		return saudavel;
	}

	public void setSaudavel(Boolean saudavel) {
		this.saudavel = saudavel;
	}

	public Boolean getFezCoco() {
		return fezCoco;
	}

	public void setFezCoco(Boolean fezCoco) {
		this.fezCoco = fezCoco;
	}

    // Construtor da classe
	public Bebe() {
	}

}

Classe #3 – Classe Enfermeira.

public class Enfermeira {
	
	// Cria campos da classe
	public String nome = null;
	private Boolean enfermaria = true;
	private Boolean trocaFralda = false;

	// Construtor da classe
	public Enfermeira() {
	}

	// Métodos Getter e Setter
	public Boolean getEnfermaria() {
		enfermaria = true;
		return enfermaria;
	}

	public Boolean getTrocaFralda() {
		trocaFralda = false;
		return trocaFralda;
	}
}

C#

Para rodar estas classes em C# apenas crie um novo projeto e substitua a classe default pela classe hospital, no solution explorer clique com o botão direito no projeto, add, new item, class, renomeie a classe para Bebe.cs e colque a classe Bebe acima, faça o mesmo com a classe Enfermeira, as classes foram escritas para funcionar nas duas línguas e só é necessário substituir uma keyword:


// Em C# na classe Hospital a Void que inicializa o programa sua única diferença
// é a keyword String para Java e string para C#

public static void main(String[] args) // JAVA
static void Main(string[] args) // string minusculo C#

// Você pode substituir tudo de uma única vez no menu:
// Edit - Find and Replace - Quick Replace - botão para substituir todos
// Substitua na classe Hospital todos os comandos Java:

System.out.println // Java keywords

// por :

Console.WriteLine

Obs: A principal diferença destas 3 classe e o funcionamento do programa acima é que Java não necessita que o construtor das classes Bebe e Enfermeira sejam públicos, já em C# não seria possível instanciar as classe deste modo sem que o construtor tenha sido declarado publico. Experimente tirar a keyword public do construtor e compilar o programa.

Estilo de programação é um conjunto de regras ou orientações utilizadas ao escrever o código-fonte em um programa de computador. Afirma-se frequentemente que, após um estilo de programação especial, este irá ajudar os programadores a ler e compreender o código-fonte em conformidade com o estilo, e ajudar a evitar a introdução de erros.

A obra clássica sobre o assunto foi os elementos do estilo de programação, escrito na década de 1970, e ilustrado com exemplos do Fortran e PL/I línguas predominantes na época.

O modelo de programação usado em um programa em particular pode ser derivado a partir das convenções de codificação de uma empresa ou qualquer outra instituição de computação, bem como as preferências do autor do código. Estilos de programação muitas vezes são projetados para uma linguagem de programação específica (ou família de línguas): estilo considerado bom em código fonte C pode não ser apropriado para o código fonte BASIC, e assim por diante. No entanto, algumas regras são comumente aplicadas para muitas línguas.

Regra #1 – Usar bons nomes (significativos):


// Ruim - nomes não intuitivos
String a1;
int a2;
double b;

// Nomes intuitivos
// primeiro nome inicia em minúsculo
// segundo nome em maiúsculo

String primeiroNome;
String sobreNome;
int temperatura;

Regra #2 – Use Identação

public static void main (String[] arguments) {
    int x = 5
    x = x * x;
    if (x > 20) {
       System.out.println(x + "  é maior que 20.");
    }

    double y = 3.4;
}

Regra#3 – Use espaço em branco


// Difícil de ler a expressão

double cel=(fahr*42.0/(13.0-7.0));

// Coloque espaço em branco em expressões complexas
// fácil de ler a expressão

double cel = ( fahr * 42.0 / (13.0 -7.0) );

Regra#4 – Use linhas em branco


// Linhas em branco aumenta a legibilidade

public static void main (String[] arguments) {

    int x = 5
    x = x * x;

    if (x > 20) {
       System.out.println(x + " é maior que 20.");
    }

    double y = 3.4;
}

// Código sem legibilidade

public static void main (String[] arguments) {
int x = 5; x = x * x;
if (x > 20) {
System.out.println(x + " é maior que 20."); }
double y = 3.4;
}

Regra#5 – Não duplique testes (if)


// Teste duplicado
// se o pagamento base é menor que 8
// e as horas trabalhadas menor que 60
// o ultimo else if está duplicado

if (pagamentoBase < 8.0)
 { ... }
else if (horas > 60)
{ ... }
else if (pagamentoBase>= 8.0 && horas <= 60)
{ ... }

// Teste correto
if (pagamentoBase < 8.0)
 { ...}
 else if (horas > 60)
 {...}
 else
 { ...}

Mais informações sobre este assunto você pode encontrar neste PDF da universidade de Princeton:

Programming and Program Style (C):
http://www.cs.princeton.edu/courses/archive/spr11/cos217/lectures/07Style.pdf

A instrução return termina a execução do método em que aparece e devolve o controle para o método de chamada. Ele também pode retornar um valor opcional. Se o método é um tipo de vazio, a instrução de retorno pode ser omitido.

Em C++ e Python a terminologia correta é função em vez de método apesar de terem a mesma funcionalidade.

Java

public class metodos
 {
// Metodo para tipos de Frete
  public static String tipofrete (int frete)
  {
      String menssagem= "";
   if (frete == 0)  menssagem = "CIF - Frete a pago pelo fornecedor";
   if (frete == 1) menssagem = "Fob - frete a cargo do consumidor";
   return menssagem;
}

      public static void main(String[] args)
 {

// Executa o metodo
       System.out.println(tipofrete(0));
       System.out.println(tipofrete(1));

}

}

C++

#include "stdafx.h"
#include <iostream>
#include <string></pre>
using namespace std;

// Metodo para tipos de Frete
    string tipofrete(int frete)
 {
  string menssagem = "";
  if (frete == 0) menssagem = "CIF - Frete a pago pelo fornecedor";
  if (frete == 1) menssagem = "Fob - frete a cargo do consumidor";
  return menssagem;
 }

int _tmain(int argc, _TCHAR* argv[]) {

  // Executa o metodo
  cout << tipofrete(0)  <<"\n";
  cout << tipofrete(1) << "\n";
  system("pause");
return 0;

}

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;</pre>
namespace ConsoleApplication35 {

class Program
     {
         // Metodo para tipos de Frete
         public static String tipofrete(int frete)
         {
             String menssagem = "";
             if (frete == 0) menssagem = "CIF - Frete a pago pelo fornecedor";
             if (frete == 1) menssagem = "Fob - frete a cargo do consumidor";
             return menssagem;
         }

          static void Main(string[] args)

          {
            // executa o metodo
             Console.WriteLine(tipofrete(0));
             Console.WriteLine(tipofrete(1));
             Console.ReadKey();
          }
     }
 }

Python (Linux)

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# retorno.py

# Importa OS
import os

# Limpa a tela
os.system("clear")

# Cria função de frete
 def tipofrete(frete):
     menssagem= "";
     if (frete == 0):
         menssagem = "CIF - Frete a pago pelo fornecedor";
     if (frete == 1):
         menssagem = "Fob - frete a cargo do consumidor";
     return menssagem;

# Mostra tipo do frete
print tipofrete(0)
print tipofrete(1)

Metodo e Função – Java, C++, C# e Python

Publicado: 4 de fevereiro de 2014 em C#, C/C++, Java, Python

O método é um elemento que representa uma chamada de procedimento para um objeto. Sendo um elemento de uma classe, utilizado na programação orientada a objetos(Orientação a objetos). Métodos tem por finalidade realizar uma tarefa. Eles são análogos às funções em C, C++ e Python e sub-rotinas em pascal. Métodos geralmente correspondem à uma ação do objeto.

Exemplo:

Bidu é uma instância da classe Cachorro, portanto tem habilidade para latir, implementada através do método Latir(). Um método em uma classe é apenas uma definição. A ação só ocorre quando o método é invocado através do objeto, no caso Bidu. Dentro do programa, a utilização de um método deve afetar apenas um objeto em particular; Todos os cachorros podem latir, mas você quer que apenas o objeto Bidu dê o latido. Normalmente, uma classe possui diversos métodos, que no caso da classe Cachorro poderiam ser sente(), coma() e morda().

Em C++ e Python a terminologia correta é função em vez de método apesar de terem a mesma funcionalidade.

Java


public class metodos {

// Metodo para imprimir uma linha
  public static void novalinha()
  {
      // Cria uma linha vazia
      System.out.println("");
  }

   // Metodo para imprimir três linhas
  public static void treslinhas()
  {
      // Executa metodo para pular linha
     novalinha(); novalinha(); novalinha();
  }

public static void main(String[] args) {

       // Executa o metodo
       System.out.println("Linha numero 1");
       treslinhas();
       System.out.println("Linha numero 2");

   }
}

C++


#include "stdafx.h"
#include <iostream>

using namespace std;

  // Metodo para imprimir uma linha
  static void novalinha()
 {
   // Cria uma linha vazia
   cout << "\n";
 }

   // Metodo para imprimir três linhas
 static void treslinhas()
 {
    // Executa metodo para pular linha
    novalinha(); novalinha(); novalinha();
 }

 int _tmain(int argc, _TCHAR* argv[])
 {
    // Executa o metodo
    cout << "Linha numero 1\n";
    treslinhas();
    cout << "Linha numero 2\n";
    system("pause");
    return 0;
 }

C#


 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;

namespace ConsoleApplication35 {

class Program {

         // Metodo para imprimir uma linha
         public static void novalinha()
         {
            Console.WriteLine("");
         }

         // Metodo para imprimir três linhas
         public static void treslinhas()
         {
            novalinha(); novalinha(); novalinha();
         }

         static void Main(string[] args)
         {
            // executa o metodo
            Console.WriteLine("Linha numero 1");
            treslinhas();
            Console.WriteLine("Linha numero 2");
            Console.ReadKey();
           }
     }
 }

Python (Linux)


#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# metodos.py

# Importa OS
import os

# Limpa a tela
os.system("clear")

# Cria função para pular uma linha
def novalinha():
        print ""

# Cria Função para  pular tres linhas
def treslinhas():
    novalinha()
    novalinha()
    novalinha()

# executa a função para pular 3 linhas
print "Linha numero 1"
treslinhas()
print "Linha numero 2"

Como a Comentar Corretamente Seu Código

Publicado: 2 de fevereiro de 2014 em C#, C/C++, Java, Python

Imagine o seguinte cenário:

Uma fabrica de software que esta há vários anos no mercado e desenvolve aplicativos para Windows em 5 linguagens de programação  diferentes entre elas: C++, Java, C#, Delphi e Python. A fabrica conta com 5 equipes com 10 desenvolvedores cada. Acontece que ao longo dos anos cada sistema sempre teve sua própria autonomia de desenvolvimento havendo muitos códigos redundantes entre elas. O novo CEO da empresa resolveu  projetar um framework* único em C++  pretendendo poupar horas de programação de código entre as equipes.

O gerente de projeto responsável pelo framework* baixa no gerenciador de código fonte o seguinte código enviado pelo  líder da equipe de Python:

 cidade = raw_imput("Entre uma cidade")
 while cidade[-1]==" " :
         cidade = cidade[:-1]
 temp=raw_input("Entre uma temperatura in farenheit: ")
 temp = float (temp)
 temp = (temp - 32.0) * (100.0/180.0)
 temp = round(temp,3)
 temp = srt(temp)
 print "Na "+cidade+" é "+temp+ " graus celsius!"

Há um monte de problemas com este código fonte. Um rápido exame e nenhuma informação é revelada sobre qual dos nossos funcionários escreveu este código. Qual é o nome do arquivo? O que ele faz? À primeira vista, estamos perdidos. Este código iria receber uma nota 10?

O código fonte é devolvido e reformulado por uma desenvolvedora da equipe,  seguindo as melhores praticas de programação de software e retorna assim:

#Alicia P. Hacker
#Fah_para_Celsius.py

#coleta a cidade
cidade = raw_imput("Entre uma cidade")

#trunca espaços em branco
while cidade[-1]==" " :
cidade = cidade[:-1]

#coleta a temperatura
temp=raw_input("Entre uma temperatura in farenheit: ")

#converte string para float
temp = float (temp)

#Converte graus farenheith para graus celsius
temp = (temp - 32.0) * (100.0/180.0)

#Arredonda para três casas decimais
temp = round(temp,3)

#reconverte string para concatenação
temp = srt(temp)

#imprime o resultado
print "Na "+cidade+" são "+ temp + " graus celsius!"

Podemos ver claramente o nome de Alicia e o nome do seu arquivo. Além disso, ela comentou bem as linhas do seu programa. Este código iria receber uma nota 10.

Você deve ser como Alicia! Você deve comentar onde você puder colocar comentários que explicam o que está fazendo, e se você está fazendo algo complicado ou original não se esqueça de explicar bem.

Uma boa meta é ter um comentário a cada 1-4 linhas de código. Certifique-se de não só documentar o que o código está fazendo, mas, quando você começa a escrever um código mais avançado, você deve documentar o que foi deixado intencionalmente de fora, otimizado, testados e rejeitados, etc, basicamente, qualquer decisão de projeto que você faz.

Uma atividade simples que muitas fabricas de software ignoram  mas que possibilita o entendimento de códigos complicados com mais rapidez , encontrar facilmente os bugs, melhorar a comunicação entre equipes de desenvolvimento, facilidade de visualização além de embelezar o código(code beautifier).

* Framework é uma abstração que une códigos comuns entre vários projetos de software provendo uma funcionalidade genérica