Objetos em Java

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. newoperador

Para criar um objeto de uma determinada classe, você precisa usar o newoperador. Em geral, é assim que parece criar um objeto:

Class variable = new Class(arguments);

Onde Classestá o nome da classe da variablevariá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 consolevariá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)Scannerconsole

Na segunda linha, chamamos o nextInt()método no Scannerobjeto, usando a consolevariável, que armazena uma referência ao Scannerobjeto.

Exemplos de criação de objetos:

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

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 svariável armazena uma referência a uma instância da Stringclasse.

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 100pontos 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 Pointclasse:

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 à Pointclasse 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 Solutionclasse 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 Pointclasse 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 Stringobjeto permanece inalterado para sempre após ser criado. E como os criadores do Java conseguiram isso?

Primeiro, todas as variáveis ​​da Stringclasse são ocultas, ou seja, declaradas private.

Em segundo lugar, você não pode herdar a Stringclasse: sua declaração de classe inclui o finalmodificador.

Terceiro, e o mais interessante, todos os métodos da Stringclasse, 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 Stringobjeto 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.