Curso
Introdução a Scala
3 h
27.1K
A DataCamp lançou recentemente seu primeiro curso de Scala: Introduction to Scala. Dá uma olhada!
Confira também os seguintes tutoriais:
Introdução
Em geral, a programação orientada a objetos (POO) é composta por classes e objetos e busca representar entidades do mundo real, como polimorfismo e herança.
A POO torna o desenvolvimento muito mais rápido e econômico, além de facilitar a manutenção do software. O principal motivo para isso é o conjunto de recursos que ela oferece: você tem classes e objetos que podem ser facilmente reutilizados no futuro conforme a necessidade, ao contrário de um programa que não usa classes e objetos. Isso leva a um software de maior qualidade, que também é extensível com novos métodos e atributos.
Imagine que você tem um showroom de carros; a cada poucos meses, um novo modelo é lançado e, para informar o público sobre seu nome e seus recursos, você precisaria definir novos métodos e atributos do zero. Porém, se você tiver um programa orientado a objetos com uma classe de carro, tudo o que precisa fazer é criar um objeto para esse novo carro, que vai usar os métodos e atributos da classe com as informações do veículo.
A classe pode ser vista como a representação ou o projeto dos objetos. As classes geralmente têm seus próprios métodos (comportamentos) e atributos.
Os atributos são elementos que diferenciam cada objeto dos demais e determinam várias características de um objeto. Já os métodos funcionam como funções na programação: eles definem como a instância da classe se comporta. É principalmente graças aos métodos (comportamentos) que os objetos podem sofrer ações.
A figura acima ajuda a entender melhor o fluxo da programação orientada a objetos ou, de forma mais específica, como é uma classe. Na imagem, há uma class car que possui attributes: fuel, max speed e pode ter mais atributos, como model, make, etc. Ela tem diferentes conjuntos de methods, como refuel(), getFuel(), setSpeed(), e métodos adicionais podem ser change gear, start the engine, stop the engine, etc.
Então, quando você fala de um carro específico, você terá um objeto, que é uma instanciação de uma classe.
Agora, vamos falar sobre programação orientada a objetos em Scala.
Classes e objetos em Scala
Assim como em C++ e Java, a programação orientada a objetos em Scala segue praticamente as mesmas convenções. Ela traz o conceito de definir classes e objects e, dentro da classe, constructors. Essencialmente, é isso que compõe a programação orientada a objetos em Scala.
Declaração de classe
class Class_name{
// methods and attributes
}
Uma classe em Scala é definida pela palavra-chave class, seguida do nome da classe, que geralmente começa com letra maiúscula. Há algumas palavras opcionais que podem ser usadas na declaração de classe em Scala, como: class-name, que deve começar com letra maiúscula; superclass, o nome da classe-pai precedido pela palavra-chave extend; traits, uma lista separada por vírgulas implementada pela classe, também precedida por extend.
Uma classe em Scala pode herdar apenas uma classe-pai, o que significa que Scala não oferece suporte a herança múltipla. No entanto, isso pode ser alcançado com o uso de Traits.
Por fim, o corpo de uma classe em Scala é delimitado por chaves {}.
// Name of the class is Car
class Car
{
// Class variables
var make: String = "BMW"
var model: String = "X7"
var fuel: Int = 40
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Class object
var obj = new Car();
obj.Display();
}
}
Você pode salvar o código acima com o nome class.scala e executá-lo no terminal com scala class.scala. O resultado deverá ser como o mostrado abaixo.
Bem, o código acima não aproveita totalmente os recursos que um programa orientado a objetos oferece. A saída será sempre a mesma, não importa quantas vezes você o execute. Você definiu variáveis estáticas dentro da classe, e os valores dessas variáveis permanecerão constantes, mesmo que você crie infinitos novos objetos. Em outras palavras, não dá para esperar que ele traga detalhes de um Mercedes-Benz ou de uma Ferrari.
Construtor em Scala
Construtores são usados principalmente para inicializar o estado do objeto. Essa inicialização acontece no momento da criação do objeto, e eles são chamados apenas uma vez.
Existem dois tipos de construtores em Scala: Primary e Auxiliary. Neste tutorial, você vai aprender sobre o construtor primário (Fonte: O'Reilly).
class Class_name(Parameter_list){
// methods, attributes
}
O construtor primário compartilha o mesmo corpo da classe e é criado implicitamente junto com a definição da classe. Ele começa na definição da classe e abrange todo o corpo da classe. Além disso, quando há apenas um construtor no programa Scala, ele é conhecido como construtor primário. Um construtor primário pode ser definido com zero, um ou mais parâmetros.
Vamos retomar o exemplo anterior, mas agora acrescentando o recurso de construtor primário para observar o efeito.
Aqui você também vai conhecer um novo recurso de uma classe: uma classe pode ter vários objetos ou instâncias, todos independentes entre si.
// Name of the class is Car
class Car(make: String, model: String, fuel: Int)
{
// Class method
def Display()
{
println("Make of the Car : " + make);
println("Model of the Car : " + model);
println("Fuel capacity of the Car : " + fuel);
}
}
object Main
{
// Main method
def main(args: Array[String])
{
// Multiple Class object
var obj1 = new Car("BMW", "X7", 40);
var obj2 = new Car("Mercedes Benz", "S350D", 50);
obj1.Display();
obj2.Display();
}
}
Veja rapidamente a saída:
Legal, né? Com a ajuda de um construtor, você conseguiu gerar resultados bem mais úteis.
Declarando objetos em Scala
Declarar objetos em Scala também pode ser chamado de instanciar ou invocar uma classe. Assim como as classes, os objetos são uma unidade fundamental da programação orientada a objetos.
Um objeto pode ter três características (Fonte: GeeksforGeeks):
State:os atributos de um objeto o representam. Eles refletem as propriedades desse objeto.Behavior:os métodos de um objeto o representam. Eles refletem como o objeto responde a outros objetos.Identity:dá um nome único ao objeto e permite que ele interaja com outros objetos.
Considere Dog como um objeto e veja, no diagrama abaixo, sua identidade, estado e comportamento.
Todas as instâncias ou objetos compartilham os atributos e métodos da classe. Uma única classe pode ter vários objetos, como você viu aqui. Porém, o estado ou os valores de cada objeto são únicos.
Para finalizar, vamos escrever um código que junta construtores primários, variáveis de classe, atributos e métodos em um único exemplo.
Abaixo está uma representação dos componentes reunidos na classe Motorcycle.
O código abaixo é bastante autoexplicativo; de forma geral, ele verifica se o motor da moto está on ou off. Inicialmente, o motor está desligado, o programa informa esse estado e então liga o motor.
class Motorcycle(make:String,color:String) {
var engineState: Boolean = false;
def startEngine() {
if (engineState == true){
println("The engine is already on.");
}
else {
engineState = true
println("The engine is now on.");
}
}
def showAtts() {
println("This motorcycle is a "+ color + " " + make);
if (engineState == true){
println("The engine is on.");
}
else{
println("The engine is off.");
}
}
}
object Main
{
def main (args: Array[String])
{
var m = new Motorcycle("BMW K 1600 GTL","White");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
println("------");
println("Calling showAtts...");
m.showAtts();
println("------");
println("Starting engine...");
m.startEngine();
}
}
Parabéns!
Parabéns por concluir este tutorial.
Agora você sabe como declarar classes e métodos, instanciar objetos, definir seus atributos e chamar métodos de instância em Scala. Esses conceitos serão úteis não só em Scala, mas também em outras linguagens de programação.
Os conceitos de programação orientada a objetos são interessantes e, ao mesmo tempo, muito poderosos. Eles adicionam uma nova dimensão ao seu código e favorecem a reutilização. À medida que seu programa cresce, o código se torna mais complexo. Há muito conteúdo em POO, como herança, polimorfismo e métodos de instância. Outro recurso poderoso é o Singleton. Princípios de design ajudam a manter seu código mais estruturado e legível. Para saber mais sobre padrões de projeto, considere ler este livro.
Fique à vontade para deixar suas dúvidas sobre este tutorial na seção de comentários abaixo.
Por fim, não esqueça de fazer o novo curso de Scala na DataCamp, Introduction to Scala.
Tópicos
