Classes, campos, métodos, construtores e objetos são os blocos de construção de aplicativos Java baseados em objetos. Este tutorial Java ensina como declarar classes, descrever atributos por meio de campos, descrever comportamentos por meio de métodos, inicializar objetos por meio de construtores e instanciar objetos de classes e acessar seus membros. Você também aprenderá sobre setters e getters, sobrecarga de métodos e configuração de níveis de acesso para campos, construtores e métodos.
O que você aprenderá neste tutorial Java
- Como declarar uma classe
- Usando campos para descrever atributos
- Usando métodos para descrever comportamentos
- Usando construtores para inicializar objetos
- Como trabalhar com objetos Java
Baixe o código-fonte de aplicativos de exemplo neste tutorial. Criado por Jeff Friesen para JavaWorld.
Como declarar uma classe
A aula é um modelo para fabricação de objetos. Você declara uma classe especificando o class palavra-chave seguida por um identificador não reservado que a nomeia. Um par de caracteres de colchetes de abertura e fechamento correspondentes ({ e }) acompanham e delimitam o corpo da classe. Esta sintaxe aparece abaixo:
class identifier
{
// class body
}
Por convenção, a primeira letra do nome de uma classe é maiúscula e os caracteres subsequentes são minúsculos (por exemplo, Employee). Se um nome consistir em várias palavras, a primeira letra de cada palavra será maiúscula (como SavingsAccount). Esta convenção de nomenclatura é chamada CamelCasing.
O exemplo a seguir declara uma classe chamada Book:
class Book
{
// class body
}
O corpo de uma classe é preenchido com campos, métodos e construtores. Combinar esses recursos de linguagem em classes é conhecido como encapsulamento. Esse recurso nos permite programar em um nível mais alto de abstração (classes e objetos) em vez de focar separadamente em estruturas e funcionalidades de dados.
Aulas utilitárias
Uma classe pode ser projetada para não ter nada a ver com a fabricação de objetos. Em vez disso, ele existe como um espaço reservado para campos de classe e/ou métodos de classe. Tal classe é conhecida como classe de utilidade. Um exemplo de classe utilitária é a biblioteca de classes padrão Java Math aula.
Aplicativos multiclasse e main()
Um aplicativo Java é implementado por uma ou mais classes. Aplicações pequenas podem ser acomodadas por uma única classe, mas aplicações maiores geralmente requerem múltiplas classes. Nesse caso, uma das classes é designada como classe principal e contém o main() método de ponto de entrada. Por exemplo, a Listagem 1 apresenta uma aplicação construída utilizando três classes: A, Be C; C é a classe principal.
Listagem 1. Uma aplicação Java com múltiplas classes
class A
{
}
class B
{
}
class C
{
public static void main(String() args)
{
System.out.println("Application C entry point");
}
}
Você poderia declarar essas três classes em um único arquivo fonte, como D.java. Você então compilaria este arquivo de origem da seguinte maneira:
javac D.java
O compilador gera três arquivos de classe: A.class, B.classe C.class. Execute este aplicativo através do seguinte comando:
java C
Você deve observar a seguinte saída:
Application C entry point
Alternativamente, você poderia declarar cada classe em seu próprio arquivo fonte. Por convenção, o nome do arquivo fonte corresponde ao nome da classe. Você declararia A em A.java, por exemplo. Você poderia então compilar esses arquivos de origem separadamente:
javac A.java javac B.java javac C.java
Para economizar tempo, você pode compilar todos os três arquivos de origem de uma só vez, substituindo o nome do arquivo por um asterisco (mas mantendo o .java extensão de arquivo):
javac *.java
De qualquer forma, você executaria o aplicativo por meio do seguinte comando:
java C
Ao projetar aplicativos multiclasse, você designará uma dessas classes como a classe principal e localizará a main() método nele. No entanto, nada impede que você declare main() métodos nas outras classes, talvez para fins de teste. Essa técnica é mostrada na Listagem 2.
Listagem 2. Declarando mais de um main() método
class A
{
public static void main(String() args)
{
System.out.println("Testing class A");
}
}
class B
{
public static void main(String() args)
{
System.out.println("Testing class B");
}
}
class C
{
public static void main(String() args)
{
System.out.println("Application C entry point");
}
}
Depois de compilar o código-fonte, você executaria os seguintes comandos para testar as classes auxiliares A e Be para executar a classe de aplicativo C:
java A java B java C
Você observaria então as seguintes linhas de saída, uma linha por java comando:
Testing class A Testing class B Application C entry point
Usando campos para descrever atributos
Uma classe modela uma entidade do mundo real em termos de estado (atributos). Por exemplo, um veículo tem uma cor e uma conta corrente tem saldo. Uma classe também pode incluir estado não-entidade. Independentemente disso, o estado é armazenado em variáveis conhecidas como Campos. Uma declaração de campo tem a seguinte sintaxe:
(static) type identifier ( = expression ) ;
Uma declaração de campo começa opcionalmente com a palavra-chave static (para um atributo que não é de entidade) e continua com um type que é seguido por um não reservado identifier que nomeia o campo. O campo pode ser inicializado explicitamente especificando = seguido por um expression com um tipo compatível. Um ponto e vírgula encerra a declaração.
O exemplo a seguir declara um par de campos em Book:
class Book
{
String title;
int pubYear; // publication year
}
O title e pubYear as declarações de campo são idênticas às declarações de variáveis que apresentei em Java 101: recursos elementares da linguagem Java. Esses campos são conhecidos como campos de instância porque cada objeto contém sua própria cópia deles.
O title e pubYear campos armazenam valores para um livro específico. No entanto, você pode querer armazenar um estado independente de qualquer livro específico. Por exemplo, você pode querer registrar o número total de Book objetos criados. Veja como você faria isso:
class Book
{
// ...
static int count;
}
Este exemplo declara um count campo inteiro que armazena o número de Book objetos criados. A declaração começa com o static palavra-chave para indicar que há apenas uma cópia deste campo na memória. Cada Book objeto pode acessar esta cópia e nenhum objeto possui sua própria cópia. Por esta razão, count é conhecido como um campo de classe.
Inicialização
Os campos anteriores não receberam valores atribuídos. Quando você não inicializa explicitamente um campo, ele é inicializado implicitamente com todos os seus bits definidos como zero. Você interpreta esse valor padrão como false (para boolean), 'u0000' (para char), 0 (para int), 0L (para long), 0.0F (para float), 0.0 (para double), ou null (para um tipo de referência).
No entanto, também é possível inicializar explicitamente um campo quando o campo é declarado. Por exemplo, você poderia especificar static int count = 0; (o que não é necessário porque count o padrão é 0), String logfile = "log.txt";, static int ID = 1;ou mesmo double sinPIDiv2 = Math.sin(Math.PI / 2);.
Embora seja possível inicializar um campo de instância através de atribuição direta, é mais comum realizar essa inicialização em um construtor, o que demonstrarei mais tarde. Em contraste, um campo de classe (especialmente uma constante de classe) normalmente é inicializado através da atribuição direta de uma expressão ao campo.
Vida útil e escopo
Um campo de instância nasce quando seu objeto é criado e morre quando o objeto é coletado como lixo. Um campo de classe nasce quando a classe é carregada e morre quando a classe é descarregada ou quando o aplicativo termina. Esta propriedade é conhecida como vida.
Os campos de instância e classe são acessíveis desde suas declarações até o final de suas classes declarantes. Além disso, eles são acessíveis ao código externo apenas em um contexto de objeto (por exemplo, campos) ou contextos de objeto e classe (para campos de classe) quando recebem níveis de acesso adequados. Esta propriedade é conhecida como escopo.
A seguir: Usando métodos para descrever comportamentos
