Introdução às classes: escrevendo suas próprias classes, construtores

Olá! Hoje falaremos sobre aulas em Java. Pode-se dizer que as aulas são o núcleo da programação Java. Quando você se tornar um programador, sua principal tarefa será escrever suas próprias classes com funcionalidades diferentes. Vamos descobrir o que é isso e como funciona :) Como você já sabe, Java é uma linguagem de programação orientada a objetos. Todos os programas consistem em objetos que estão de alguma forma conectados entre si. Uma classe é essencialmente um modelo para um objeto. Ele determina a aparência de um objeto e quais funções ele terá. Todo objeto é um objeto de alguma classe . Vejamos o exemplo mais simples:

public class Cat {

    String name;
    int age;

}

Digamos que estamos escrevendo um programa, e neste programa precisamos de gatos para alguma coisa (por exemplo, temos uma clínica veterinária com a possibilidade de marcar uma consulta online). Criamos uma classe Cate especificamos duas variáveis ​​para ela – uma string namee um número age. Essas variáveis ​​de classe são chamadas de campos . Essencialmente, este é um modelo para todos os gatos que criaremos no futuro. Cada gato (objeto de classe Cat) terá duas variáveis ​​– nome e idade.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";

        System.out.println("We created a cat named" + barsik.name + ", his age - " + barsik.age);
    }

}

É assim que funciona! Criamos um gato, demos a ele um nome e uma idade e enviamos tudo para o console. Nada complicado :) As aulas geralmente descrevem objetos e fenômenos do mundo circundante. Um gato, uma mesa, uma pessoa, um raio, uma página de livro, uma roda - tudo isso será criado em seu programa usando classes separadas. Agora vamos dar uma olhada nas variáveis ​​que criamos na classe Cat. Eles são chamados de campos ou variáveis ​​de instância . O nome, aliás, revela toda a sua essência. Cada instância (objeto) da classe terá essas variáveis Cat. Cada gato que criamos terá sua própria variável namee seu próprio arquivo age. É lógico, em geral: tudo é igual com gatos reais :) Além das variáveis ​​​​de instância, existem outras - variáveis ​​​​de classe ou estáticas. Vamos adicionar ao nosso exemplo:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";
        count++;

        Cat vasia = new Cat();
        vasia.age = 5;
        vasia.name = "Vasya";
        count++;

        System.out.println("We created a cat named" + barsik.name + ", his age - " + barsik.age);
        System.out.println("We created a cat named" + vasia.name + ", his age - " + vasia.age);

        System.out.println("Total number of cats = " + count);
    }
}

Saída do console:

Мы создали кота по имени Барсик, его возраст - 3
Мы создали кота по имени Вася, его возраст - 5
Общее количество котов = 2

Agora temos uma nova variável em nossa classe - count(quantidade). Ela é responsável por contar os gatos criados. Cada vez que criamos um gato no método principal, incrementamos esta variável em 1. Esta variável é designada pela palavra-chave estática . Isso significa que pertence à classe e não a um objeto específico da classe. O que, claro, é lógico: se cada gato tiver seu próprio nome, precisaremos de um contador de gatos para todos. Isso é exatamente o que a palavra estática permite alcançar - counta mesma variável para todos os gatos. Observação: quando imprimimos no console, não escrevemos barsik.countou vasia.count. Ela não pertence nem a Barsik nem a Vasya – ela pertence a toda a classe Cat. Portanto, é simples count. Você também pode escrever Cat.count- isso também estará correto. nameIsso não funcionaria com a saída de uma variável para o console :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";
        count++;

        System.out.println("We created a cat named" + name + ", his age - " + barsik.age);

        System.out.println("Total number of cats = " + count);
    }
}

Erro! nameCada gato tem o seu. É aqui que o compilador fica confuso. "Enviar o nome para o console? De quem é o nome? :/"

Métodos

Além das variáveis, cada classe possui métodos. Falaremos sobre eles com mais detalhes em uma palestra separada, mas os pontos gerais são bastante simples. Os métodos são a funcionalidade da sua classe; o que os objetos desta classe podem fazer. Você já está familiarizado com um dos métodos - este é o main(). Mas o método main, como você lembra, é estático - ou seja, pertence a toda a classe (a lógica é a mesma das variáveis). E métodos comuns e não estáticos só podem ser chamados em objetos específicos que criamos. Por exemplo, se quisermos escrever uma classe para um gato, precisamos entender quais funções o gato deve ter em nosso programa. Com base nisso, vamos escrever alguns métodos para isso:

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("Meow!");
    }

    public void jump() {
        System.out.println("Jumping gallop!");
    }

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";

        barsik.sayMeow();
        barsik.jump();

    }
}

Pois bem, agora nossa aula está muito mais parecida com a descrição de um gato de verdade! Agora não temos apenas um gato chamado Barsik com nome e idade. Ele também pode miar e pular! Que tipo de gato existe sem essa “funcionalidade” :) Pegamos um objeto específico - barsike chamamos seus métodos sayMeow()e jump(). Nós olhamos para o console:

Мяу!
Прыг-скок!

Um verdadeiro gato! :)

Criando suas próprias aulas. Abstração

No futuro você terá que escrever suas próprias aulas. Em que você deve prestar atenção ao escrevê-los? Se estamos falando de variáveis, você precisa usar algo chamado abstração . A abstração é um dos quatro princípios fundamentais da programação orientada a objetos. Envolve destacar as características principais e mais significativas de um objeto e vice-versa - descartar as secundárias e insignificantes. Por exemplo, estamos criando um arquivo de funcionários da empresa. Para criar objetos funcionários, escrevemos uma classe Employee. Quais características são importantes para descrever um funcionário no arquivo da empresa? Nome completo, data de nascimento, número de segurança social, número de identificação fiscal. Mas é improvável que precisemos da altura, da cor dos olhos e do cabelo no cartão de funcionário da empresa. A empresa não precisa dessas informações. Portanto, para a classe Employeedefiniremos as variáveis String name​​, int age, int socialInsuranceNumbere int taxNumber, e abandonaremos informações desnecessárias para nós (como a cor dos olhos) e as abstrairemos . Mas se criarmos um arquivo de modelos fotográficos para uma agência de modelos, a situação muda drasticamente. Para descrever um modelo, altura, cor dos olhos e do cabelo são muito importantes para nós, mas o número TIN não é absolutamente importante para nós. Portanto, na classe Modelprecisamos criar variáveis int height​​, String hair, String eyes. É assim que funciona a abstração, é simples! :)

Construtores

Voltemos ao nosso exemplo do gato.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat barsik = new Cat();

        System.out.println("Something has been happening in the program for 2 hours...");

        barsik.age = 3;
        barsik.name = "Barsik";

    }
}

Observe este código e tente adivinhar o que há de errado com nosso programa. Durante duas horas em nosso programa havia um gato sem nome nem idade! Claro, isso está completamente errado. Não deveria haver nenhum gato no banco de dados da clínica veterinária sem informações sobre eles. Agora deixamos isso para o programador. Se ele não esquecer de indicar o nome e a idade, tudo ficará bem. Caso ele esqueça, haverá um erro no banco de dados, gatos desconhecidos. Como podemos resolver este problema? É necessário proibir de alguma forma a criação de gatos sem nome e idade. É aqui que as funções construtoras vêm em nosso auxílio . Aqui está um exemplo:

public class Cat {

    String name;
    int age;

    //constructor for class Cat
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
    }
}

Um construtor é essencialmente um modelo para objetos de classe. Neste caso, especificamos que para cada objeto catdevem ser especificados dois argumentos - uma string e um número. Se tentarmos agora criar um gato sem nome, não teremos sucesso.

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat(); //error!
    }
}

Agora que uma classe possui um construtor, o compilador Java sabe como os objetos devem ser e não permite que objetos sejam criados sem os argumentos especificados nele. Agora vamos dar uma olhada na palavra-chave thisque você vê dentro do construtor. Tudo é simples com ele também. "this" em inglês significa "isto, isto". Ou seja, esta palavra indica um objeto específico. Código no construtor

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

pode ser traduzido quase literalmente: " nome para este gato (que estamos criando) = o argumento do nome especificado no construtor. idade para este gato (que estamos criando) = o argumento de idade especificado no construtor." Depois que o construtor for acionado, você poderá verificar se nosso gato recebeu todos os valores necessários:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
        System.out.println(barsik.name);
        System.out.println(barsik.age);
    }
}

Saída do console:

Барсик
5

Quando o construtor for concluído:

Cat barsik = new Cat("Barsik", 5);

O seguinte realmente aconteceu lá dentro:

this.name = "Barsik";
this.age = 5;

E o objeto barsik(é this) recebeu valores dos argumentos do construtor. Na verdade, se você não especificar construtores na classe, ele ainda disparará o construtor ! Mas como isso é possível? O_O O fato é que em Java todas as classes possuem um chamado construtor padrão . Não possui argumentos, mas é acionado sempre que qualquer objeto de qualquer classe é criado.

public class Cat {

    public static void main(String[] args) {

        Cat barsik = new Cat(); //this is where the default constructor worked
    }
}

À primeira vista, isso não é perceptível. Bom, criamos um objeto e criamos, cadê o trabalho do designer? Para ver isso, vamos escrever Catum construtor vazio para a classe com nossas próprias mãos e, dentro dele, enviaremos alguma frase para o console. Se for exibido, o construtor funcionou.

public class Cat {

    public Cat() {
        System.out.println("Created a cat!");
    }

    public static void main(String[] args) {

        Cat barsik = new Cat(); //this is where the default constructor worked
    }
}

Saída do console:

Создали кота!

Aqui está a confirmação. O construtor padrão está sempre presente de forma invisível em suas classes. Mas você precisa conhecer mais uma característica dele. O construtor padrão desaparece da classe quando você cria algum construtor com argumentos. A prova disso, aliás, já vimos acima. Aqui neste código:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat(); //error!
    }
}

Não poderíamos criar um gato sem nome e idade porque definimos um construtor para Cat: string + número. O construtor padrão desapareceu da classe imediatamente depois disso. Portanto, lembre-se: se você precisar de vários construtores em sua classe, incluindo um vazio, será necessário criá-lo separadamente . Por exemplo, nossa clínica veterinária quer fazer boas ações e ajudar gatos vadios, cujos nomes e idades não sabemos. Então nosso código deverá ficar assim:

public class Cat {

    String name;
    int age;

    //for domestic cats
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //for street cats
    public Cat() {
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
        Cat streetCat = new Cat();
    }
}

Agora que especificamos explicitamente um construtor padrão, podemos criar os dois tipos de gatos. No construtor, você pode atribuir valores explicitamente, e não apenas retirá-los dos argumentos. Por exemplo, podemos registrar todos os gatos de rua em um banco de dados com o nome "Número do gato de rua...":

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Street cat number" + count;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

Temos uma variável countque é um contador de gatos de rua. Cada vez que executamos o construtor padrão, nós o incrementamos em 1 e atribuímos esse número como o nome do gato. Para um construtor, a ordem dos argumentos é muito importante. Vamos trocar os argumentos name e age em nosso construtor.

public class Cat {

    String name;
    int age;

    public Cat(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 10); //error!
    }
}

Erro! O construtor descreve claramente: ao criar um objeto, Catdeve ser passado um número e uma string, nesta ordem . É por isso que nosso código não funciona. Lembre-se disso e tenha isso em mente ao criar suas próprias classes:

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

public Cat(int age, String name) {
    this.age = age;
    this.name = name;
}

São dois designers completamente diferentes! Agora resolva alguns problemas para consolidar o material :)

• Museu de Antiguidades.

Sua tarefa é projetar a classe Artifact. Os artefatos mantidos no museu são de três tipos. A primeira é sobre a qual nada se sabe, exceto o número de série atribuído pelo museu (por exemplo: 212121). A segunda é sobre qual é conhecido o número de série e a cultura pela qual foi criado (por exemplo: 212121, “Aztecas”). O terceiro tipo é sobre o qual se conhece o número de série, a cultura pela qual foi criado e a idade exata de sua criação (por exemplo: 212121, “Aztecas”, 12). Crie uma classe Artifactque descreva as antiguidades armazenadas no museu e escreva o número necessário de construtores para ela. No método main(), crie um artefato de cada tipo.

public class Artifact {

    public static void main(String[] args) {
    }
}

• Site da reunião

Você está criando um banco de dados de usuários para um site de namoro. Mas o problema é que você esqueceu em que ordem eles precisam ser especificados e não tem as especificações técnicas em mãos. Projete uma classe Userque terá campos - nome ( String), idade ( short) e altura ( int). Crie o número necessário de construtores para que o nome, a idade e a altura possam ser especificados em qualquer ordem.

public class User {

    String name;
    short age;
    int height;

    public static void main(String[] args) {

    }
}