1. Objetos
Tudo em Java é um objeto.
Mais precisamente, existem muito poucas coisas em Java que não são objetos. Por exemplo, tipos primitivos. Mas esta é uma exceção bastante rara à regra.
Então, o que é um objeto?
Um objeto é uma entidade que agrupa dados com métodos que processam os dados . Quando dizemos "dados", queremos dizer variáveis, é claro.
As variáveis de um objeto são chamadas de "dados" ou "estado".
Os métodos de um objeto são chamados de "comportamento". É comum alterar o estado de um objeto (variáveis) apenas usando os métodos desse objeto. Alterar as variáveis de um objeto diretamente (sem usar seus métodos) é considerado incorreto.
Todo objeto , assim como toda variável, tem um tipo . Esse tipo é determinado uma vez quando o objeto é criado e não pode ser alterado no futuro. O tipo de um objeto é sua classe.
Cada objeto tem sua própria cópia de variáveis de instância (campos). Se uma variável int não estática for declarada em uma classe e seu programa criar 10 objetos dessa classe, cada objeto terá sua própria variável int.
Interagindo com um objeto
A maneira mais conveniente de trabalhar com um objeto é armazenar uma referência a ele em uma variável e, em seguida, chamar métodos nessa variável. Isso parecerá familiar para você:
variable.method()
Onde variable
é uma variável que armazena uma referência a um objeto e method
é um método dessa classe.
Se você quiser se referir a um campo (variável) de um objeto, também precisará usar o operador ponto :
variable.field
Onde variable
é uma variável que armazena uma referência a um objeto e field
é uma variável de instância (campo).
2. new
operador
Para criar um objeto de uma determinada classe, você precisa usar o new
operador. Em geral, é assim que parece criar um objeto:
Class variable = new Class(arguments);
Onde Class
está o nome da classe da variable
variável assim como o nome da classe do objeto a ser criado. E variable
é uma variável que armazena uma referência ao objeto criado. E arguments
é um espaço reservado para uma lista delimitada por vírgulas de argumentos passados para o construtor.
A lista específica de argumentos que podem ser passados é decidida pelos programadores que escrevem a classe.
Você já criou objetos antes e até usou essa construção específica. Você não esqueceu, eu espero?
Scanner console = new Scanner(System.in);
int x = console.nextInt();
Scanner console
— isso cria uma console
variável cujo tipo é Scanner
. — isso cria um novo objeto. E o operador de atribuição define a variável igual a uma referência ao objeto recém-criado.new Scanner(System.in)
Scanner
console
Na segunda linha, chamamos o nextInt()
método no Scanner
objeto, usando a console
variável, que armazena uma referência ao Scanner
objeto.
Exemplos de criação de objetos:
Código | Descrição |
---|---|
|
Criar um String objeto |
|
Criar um Scanner objeto |
|
Crie um int[] : um contêiner de 10 int elementos |
Os objetos criados são chamados de objetos da classe ou instâncias da classe , enquanto a classe é chamada de classe do objeto . Por exemplo, a s
variável armazena uma referência a uma instância da String
classe.
3. Apresentação das aulas
Acho que você já viu como é muito conveniente usar classes escritas por outros programadores. Mas que tal escrever suas próprias classes?
Como você sabe quando e onde precisa de sua própria classe e como criar uma?
Os programadores geralmente criam suas próprias classes quando desejam trazer uma nova entidade para o programa. Isso soa confuso? Então vou tentar explicar, mas vou começar de longe.
Grupo de dados
Simplificando um pouco, podemos dizer que um objeto em Java é um bloco de memória que contém as variáveis declaradas em uma classe (campos de instância). Ou, em outras palavras, variáveis combinadas em um grupo.
Digamos que seu programa precise armazenar as coordenadas dos 100
pontos e precise de um método para exibi-los na tela. Isso pode ser feito usando matrizes. Por exemplo, assim:
class Solution
{
public static void printPoints(int[] x, int[] y, int[] color)
{
for (int i = 0; i < x.length; i++)
System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
}
public static void main(String[] args)
{
int[] x = new int[100];
int[] y = new int[100];
int[] color = new int[100];
printPoints(x, y, color);
}
}
Seria muito mais conveniente se tivéssemos um único tipo para armazenar todas as informações sobre um ponto: x
, y
, color
. Se esse tipo não existir em Java, você mesmo poderá criá-lo.
Para fazer isso, escreveremos o código para uma Point
classe:
public class Point
{
public int x;
public int y;
public int color;
}
Agora o código acima pode ser reescrito como:
class Solution
{
public static void printPoints(Point[] points)
{
for (int i = 0; i < points.length; i++)
System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
}
public static void main(String[] args)
{
Point[] data = new Point[100];
for (int i = 0; i < data.length; i++)
data[i] = new Point();
printPoints(data);
}
}
Agora vamos adicionar um método à Point
classe que exibirá informações sobre o objeto:
public class Point
{
public int x;
public int y;
public int color;
public void print()
{
System.out.println("Color of (" + x + ", " + y + ") = " + color);
}
}
Agora a Solution
classe fica assim:
class Solution
{
public static void printPoints(Point[] points)
{
for (int i = 0; i < points.length; i++)
points[i].print();
}
public static void main(String[] args)
{
Point[] data = new Point[100];
for (int i = 0; i < data.length; i++)
data[i] = new Point();
printPoints(data);
}
}
Escondemos habilmente as coordenadas do ponto e as informações de cor dentro da Point
classe junto com o método que exibe o estado do ponto.
As classes são uma maneira de gerenciar a complexidade do programa. Um programa grande torna-se menos complexo quando é dividido em muitas classes pequenas.
4. Objetos mutáveis versus objetos imutáveis
Era uma vez, estudamos constantes em Java e chegamos a uma conclusão que não é muito reconfortante. As constantes permitem que você proteja as variáveis de serem alteradas, mas não podem impedir alterações nos objetos aos quais se referem.
Para resolver esse problema, Java criou objetos constantes. Ou, como são chamados com mais frequência, objetos imutáveis.
A propósito, você já conhece essa classe, cujos objetos não podem ser alterados: String
. Um String
objeto permanece inalterado para sempre após ser criado. E como os criadores do Java conseguiram isso?
Primeiro, todas as variáveis da String
classe são ocultas, ou seja, declaradas private
.
Em segundo lugar, você não pode herdar a String
classe: sua declaração de classe inclui o final
modificador.
Terceiro, e o mais interessante, todos os métodos da String
classe, que, em teoria, você esperaria alterar o objeto existente, na verdade não o alteram, mas retornam um novo.
Por exemplo, o toUpperCase()
método transforma todas as letras na string em maiúsculas. Mas, em vez de alterar o objeto no qual o método é chamado, ele retorna um novo String
objeto que consiste em letras maiúsculas:
String text = "This is a very important message";
String message = text.toUpperCase();
Isto é o que ficará na memória após a execução deste código:
Portanto, sinta-se à vontade para passar suas strings para qualquer método: ninguém irá alterá-las.
GO TO FULL VERSION