Boa tarde!
Eu nao entendi este Serie serie...
de onde vem o primeiro serie? e o que nos criamos anteriormente? mas ai na deveria ter um import?
ou e uma biblioteca que eu na oto logado (acho improvavel...)
Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!
Solucionado
Boa tarde!
Eu nao entendi este Serie serie...
de onde vem o primeiro serie? e o que nos criamos anteriormente? mas ai na deveria ter um import?
ou e uma biblioteca que eu na oto logado (acho improvavel...)
Olá, Diegho. Como vai?
Essa é uma dúvida clássica e super importante quando estamos dando os primeiros passos na Orientação a Objetos com Java! Fique tranquilo, não se trata de nenhuma biblioteca oculta ou falta de login no seu ambiente.
O que está acontecendo aí é o conceito de tipagem utilizando as suas próprias classes. Vamos quebrar isso em partes para ficar bem simples de entender.
O primeiro Serie (com o "S" maiúsculo) refere-se exatamente à classe Serie que você ou o instrutor criaram anteriormente no projeto.
Em Java, quando criamos uma classe, nós não estamos apenas escrevendo um arquivo de código, nós estamos criando um novo tipo de dado. Da mesma forma que o Java possui tipos nativos como String para textos e int para números inteiros, a sua classe Serie passa a ser um tipo válido dentro do seu sistema.
O segundo serie (com o "s" minúsculo) é apenas o nome da variável (ou atributo) que vai guardar aquele objeto.
Para visualizar melhor, pense na estrutura que você já conhece:
String nomeDoFilme;
int duracaoEmMinutos;
Serie serie; // Tipo de dado (Classe) seguido pelo Nome da variável!
No Java, você só precisa utilizar o comando import quando a classe que você quer usar está em um pacote (package) diferente daquele onde você está escrevendo o código atual.
Se a classe onde você escreveu private Serie serie; e a classe Serie estiverem dentro da mesma pasta (ou seja, declaradas sob o mesmo package no topo do arquivo), o Java já as enxerga automaticamente. Elas estão no mesmo "bairro", então não precisam de um mapa (o import) para se encontrarem.
Quando você coloca private Serie serie; dentro de outra classe (como uma classe chamada Episodio, por exemplo), você está aplicando um conceito chamado Composição. Você está dizendo para o Java: "Olha, todo Episódio pertence a uma Serie".
Dessa forma, o seu objeto passa a ter acesso a todas as informações daquela série. Veja este exemplo prático de como você usaria isso no método main:
// 1. Criamos o objeto da série
Serie breakingBad = new Serie();
breakingBad.setNome("Breaking Bad");
// 2. Criamos o objeto do episódio
Episodio episodio1 = new Episodio();
episodio1.setNome("Piloto");
// 3. Associamos a série ao episódio usando a variável que te causou dúvida!
episodio1.setSerie(breakingBad);
A partir desse momento, o seu episódio sabe exatamente a qual série ele pertence e pode consultar os dados dela por herança de contexto.
É um estalo mental necessário no início da jornada com Java, mas logo isso se tornará automático para você. Continue firme nos estudos de Orientação a Objetos!
Espero que possa ter lhe ajudado!
Obrigado, Evandro!
Eu já imaginava que seria assim, mas na aula isso não está muito claro e eu poderia estar presumindo errado...
Outra dúvida, que talvez nem caiba aqui por serem aulas especificamente de Java: essa construção funciona para todos os tipos de linguagem quando falamos de POO, ou é algo específico do Java?
Pergunto porque eu já programo em Python e JavaScript, mas ambos mais voltados para programação funcional, com apenas o conhecimento raso de POO necessário para trabalhar com React.
Obrigado, Evandro!
Eu já imaginava que seria assim, mas na aula isso não está muito claro e eu poderia estar presumindo errado...
Outra dúvida, que talvez nem caiba aqui por serem aulas especificamente de Java: essa construção funciona para todos os tipos de linguagem quando falamos de POO, ou é algo específico do Java?
Pergunto porque eu já programo em Python e JavaScript, mas ambos mais voltados para programação funcional, com apenas o conhecimento raso de POO necessário para trabalhar com React.
Olá, Diegho! Como vai?
Faz todo o sentido a sua dúvida! Essa "estranheza" inicial é extremamente comum (e muito justificada) para quem vem de linguagens com tipagem dinâmica e foco mais funcional, como o JavaScript e o Python.
Para responder direto ao ponto: O conceito por trás disso (Composição) é universal em todas as linguagens que suportam Orientação a Objetos (POO), mas a sintaxe (a exigência de escrever o tipo antes) é algo específico de linguagens de tipagem estática, como o Java.
Vamos desmistificar como isso se traduz para o mundo que você já domina:
O Java possui tipagem estática e forte. Isso significa que o compilador é muito rigoroso e exige saber exatamente o que (qual formato/molde) uma variável vai guardar antes mesmo do programa rodar. É por isso que somos obrigados a avisar: "Atenção, Java! A variável 'serie' só vai aceitar objetos que sejam do tipo 'Serie'."
Já o Python e o JavaScript possuem tipagem dinâmica. Neles, as variáveis são como "caixas genéricas" que se moldam ao que você coloca dentro delas em tempo de execução. Você não avisa o tipo antes; a linguagem descobre na hora.
O conceito de colocar uma classe dentro da outra para que elas conversem (Composição) continua existindo, só muda o jeito de escrever. Veja o paralelo:
No JavaScript:
Como não há tipagem estática, você não declara a classe Serie como tipo. Você simplesmente cria o atributo (geralmente no construtor) e depois injeta o objeto inteiro nele.
class Episodio {
constructor() {
this.nome = "";
this.serie = null; // Apenas inicializa a "caixa". Não avisamos que é do tipo Serie.
}
}
const breakingBad = new Serie("Breaking Bad");
const episodio1 = new Episodio();
// Aqui ocorre a Composição idêntica à do Java!
episodio1.serie = breakingBad;
No Python:
A lógica é exatamente a mesma do JavaScript.
class Episodio:
def __init__(self):
self.nome = ""
self.serie = None # Dinâmico, aceita qualquer coisa.
breaking_bad = Serie("Breaking Bad")
episodio_1 = Episodio()
# Composição acontecendo
episodio_1.serie = breaking_bad
Nota sobre o Python moderno: Hoje em dia, o Python possui Type Hints (Dicas de Tipagem). Se você quiser deixar o seu código Python com a mesma cara rigorosa do Java, você poderia escrever:
self.serie: Serie = None. O TypeScript faz exatamente o mesmo papel para o JavaScript!
Já que você usa React, você já faz algo muito parecido sem perceber! Quando você passa um objeto complexo de configuração ou de dados via props de um componente pai para um componente filho, você está aplicando um princípio estrutural muito similar à Composição da POO: você está delegando propriedades e comportamentos de uma entidade maior para uma menor.
A tipagem rigorosa do Java pode parecer um pouco burocrática no início, mas em sistemas muito grandes, ela previne uma infinidade de bugs que o JavaScript deixaria passar em branco.
Considerando essa sua transição entre os estilos funcionais do JS/Python para as regras rígidas da POO em Java, qual dessas abordagens (a liberdade dinâmica ou o rigor dos tipos) está parecendo mais confortável para você até o momento?