Orientação a Objetos: Polimorfismo

 

Esse é o ultimo post sobre os 4 pilares da Orientação a Objetos, aonde vamos desmistificar o polimorfismo na Orientação a Objetos.

Polimorfismo é um dos pilares fundamentais na programação orientada a objetos, conceito que permite que objetos de diferentes classes sejam tratados como instâncias de uma classe pai comum. No contexto da linguagem Apex, que é utilizada na plataforma Salesforce, o polimorfismo permite que um único método possa processar diferentes tipos de objetos, cada um com sua própria implementação, possibilitando que os desenvolvedores criem código mais flexível e reutilizável em sistemas mais complexos.  Por exemplo, pode-se ter uma classe base chamada "Conta", com um método "calcularDesconto". Classes derivadas como "ContaPremium" e "ContaStandard" podem sobrescrever esse método para fornecer implementações específicas. 

Aqui está um exemplo simplificado de como isso pode ser feito em Apex:

public abstract class Conta {

    public virtual Decimal calcularDesconto() {

        // Implementação padrão

        return 0.0;

    }

}

public class ContaPremium extends Conta {

    public override Decimal calcularDesconto() {

        // Implementação para conta premium

        return 20.0;

    }

}

public class ContaStandard extends Conta {

    public override Decimal calcularDesconto() {

        // Implementação para conta standard

        return 10.0;

    }

}

 Neste exemplo, "Conta" é uma classe abstrata com um método "calcularDesconto" que é sobrescrito pelas classes "ContaPremium" e "ContaStandard". Cada classe derivada tem sua própria implementação do método, refletindo as regras de negócio específicas para cada tipo de conta. Isso demonstra o poder do polimorfismo, onde o mesmo método pode comportar-se de maneira diferente dependendo do tipo de objeto que o invoca.Isso é útil para escrever código mais genérico e reutilizável, facilitando a manutenção e a expansão de sistemas complexos. 

Para mais informações sobre programação em Apex e polimorfismo, você pode consultar recursos online como tutoriais e documentação oficial.

Espero que tenha ajudado a entenderem mais sobre os Pilares da Programação Orientada a Objetos.

Podem manda msgs sugerindo novos assuntos para trazer aqui para vcs.

Forte abraço e até o próximo post.

Orientação a Objetos: Herança

 

A herança em Apex, uma linguagem de programação orientada a objetos utilizada na plataforma Salesforce, permite que as classes compartilhem atributos e métodos, facilitando a reutilização de código e a organização lógica dos componentes do software. Por exemplo, pode-se ter uma classe base "Veiculo" com atributos como "marca" e "modelo", e métodos como "ligar()" e "desligar()". Uma classe "Carro", que herda de "Veiculo", pode adicionar atributos específicos como "numeroDePortas" e métodos como "abrirPortaMalas()", enquanto ainda mantém acesso aos elementos herdados da classe base. Isso significa que "Carro" pode invocar os métodos "ligar()" e "desligar()" sem a necessidade de reescrevê-los, demonstrando o poder da herança para evitar redundâncias e promover uma arquitetura de software mais limpa e eficiente. Para implementar herança em Apex, utiliza-se a palavra-chave "extends", que estabelece uma relação hierárquica entre a classe base e a classe derivada, permitindo que a última acesse os membros não privados da primeira. A herança é um conceito fundamental na programação orientada a objetos e é amplamente aplicada em Apex para construir aplicações robustas e escaláveis dentro do ecossistema Salesforce.

Aqui abaixo temos um exemplo simples de como a herança pode ser implementada em Apex:

 

public class Veiculo {

    public String marca;

    public String modelo;

    public void ligar() {

        // Código para ligar o veículo

    }

    public void desligar() {

        // Código para desligar o veículo

    }

}

public class Carro extends Veiculo {

    public Integer numeroDePortas;

    public void abrirPortaMalas() {

        // Código para abrir o porta-malas

    }

}

// Exemplo de uso

Carro meuCarro = new Carro();

meuCarro.marca = 'Ford';

meuCarro.modelo = 'Mustang';

meuCarro.numeroDePortas = 2;

meuCarro.ligar();

meuCarro.abrirPortaMalas();

meuCarro.desligar();

 Neste exemplo, a classe "Carro" herda da classe "Veiculo", o que significa que "Carro" tem acesso aos atributos e métodos definidos em "Veiculo". A classe "Carro" também define um atributo adicional "numeroDePortas" e um método adicional "abrirPortaMalas()". Ao criar uma instância de "Carro", podemos ver como ela pode usar tanto os métodos herdados ("ligar()" e "desligar()") quanto os métodos definidos especificamente para ela ("abrirPortaMalas()"). Isso demonstra a utilidade da herança em reutilizar código e organizar logicamente as funcionalidades de classes relacionadas. Para mais informações e exemplos, você pode consultar recursos online como tutoriais e documentações oficiais.

 No próximo post, vamos falar do ultimo pilar da Orientação a Objetos:  Polimorfismo.

Forte abraço e até o próximo post.

Orientação a Objetos: Abstração

A abstração é um pilar fundamental na programação orientada a objetos, permitindo que os desenvolvedores criem sistemas mais flexíveis, escaláveis e fáceis de manter. No contexto do Salesforce, a linguagem Apex oferece recursos robustos para aplicar abstração, facilitando a implementação de lógicas de negócios complexas e a integração com outras aplicações.

O Apex, uma linguagem fortemente tipada e orientada a objetos, possui uma sintaxe similar ao Java/C#, o que torna sua adoção por desenvolvedores com experiência em linguagens semelhantes mais acessível. A plataforma Salesforce proporciona um ambiente de execução multi-locatário, onde o código Apex opera dentro de limites estabelecidos para garantir a eficiência e a boa gestão dos recursos compartilhados (tem um post no blog aonde falo sobre os limites da ORG).

Um exemplo prático de abstração em Apex pode ser a criação de classes base que definem métodos abstratos, os quais serão implementados por subclasses específicas. Isso permite que diferentes objetos compartilhem uma interface comum, mas tenham comportamentos distintos conforme as necessidades de cada contexto de negócio.

Considere o seguinte cenário: uma organização precisa gerenciar diferentes tipos de comunicações com seus clientes, como e-mails e mensagens SMS. Podemos abstrair a ideia de "comunicação" em uma classe base chamada "Comunicacao"`, que define um método abstrato `enviar()`. As subclasses `Email` e `SMS` implementariam esse método de acordo com os requisitos específicos de cada tipo de comunicação.

Vamos ao exemplo prático:

public abstract class Comunicacao {

    public abstract void enviar(String mensagem, String destinatario);

}

public class Email extends Comunicacao {

    public override void enviar(String mensagem, String destinatario) {

        // Implementação específica para enviar e-mail

    }

}

public class SMS extends Comunicacao {

    public override void enviar(String mensagem, String destinatario) {

        // Implementação específica para enviar SMS

    }

}

Com essa estrutura, o código que depende da comunicação não precisa saber se está lidando com um e-mail ou uma mensagem SMS, ele simplesmente chama o método `enviar()` da interface `Comunicacao`. Isso não só simplifica o design do sistema, mas também facilita a manutenção e a expansão futura do código.

A abstração, portanto, é uma técnica valiosa que ajuda os desenvolvedores a escrever código mais limpo e modular, promovendo a reutilização e a adaptabilidade. No Salesforce, o uso eficaz da abstração em Apex pode significar a diferença entre um projeto bem-sucedido e um que enfrenta desafios constantes de manutenção e escalabilidade.

Para aprofundar-se mais sobre abstração e outros conceitos de programação no Salesforce, recomenda-se explorar os recursos educacionais disponíveis e praticar a escrita de código que utilize esses princípios fundamentais de design de software.

No próximo post, vamos falar sobre Herança na Orientação a Objetos.

Forte abraço e até o próximo post.

Orientação a Objetos: Encapsulamento

 

Vamos dar continuidade ao assunto Programação Orientada a Objetos, e mostrar um exemplo de código Apex usando encapsulamento.

Encapsulamento é um conceito fundamental na programação orientada a objetos, e no Apex, a linguagem de programação utilizada na plataforma Salesforce, não é diferente. Encapsulamento ajuda a proteger os dados e a lógica interna de uma classe de acessos externos indesejados, permitindo que apenas métodos específicos possam interagir com esses dados.

Aqui está um exemplo simples de como você pode aplicar o encapsulamento em uma classe Apex:

public class ContaBancaria {

    // Atributos privados para impedir o acesso direto

    private String nomeTitular;

    private Decimal saldo;

    // Construtor para inicializar a conta

    public ContaBancaria(String nome, Decimal saldoInicial) {

        this.nomeTitular = nome;

        this.saldo = saldoInicial;

    }

    // Método público para depositar dinheiro

    public void depositar(Decimal valor) {

        if (valor > 0) {

            this.saldo += valor;

        } else {

            // Lançar uma exceção ou tratar o erro de valor inválido

        }

    }

    // Método público para sacar dinheiro

    public Boolean sacar(Decimal valor) {

        if (valor > 0 && this.saldo >= valor) {

            this.saldo -= valor;

            return true;

        } else {

            // Lançar uma exceção ou tratar o erro de saldo insuficiente

            // ou valor inválido

            return false;

        }

    }

    // Getters para acessar os atributos de forma controlada

    public String getNomeTitular() {

        return this.nomeTitular;

    }

    public Decimal getSaldo() {

        return this.saldo;

    }

}

Neste exemplo, os atributos `nomeTitular` e `saldo` são marcados como privados, o que significa que eles não podem ser acessados diretamente de fora da classe `ContaBancaria`. Em vez disso, métodos públicos como `depositar` e `sacar` são fornecidos para permitir que operações sejam realizadas nesses atributos de maneira controlada. Além disso, os métodos `getNomeTitular` e `getSaldo` permitem o acesso aos valores dos atributos, mas não permitem que sejam modificados diretamente, mantendo a integridade dos dados.

O encapsulamento não só protege os dados de manipulações indesejadas, mas também torna o código mais modular e fácil de manter. Ao expor apenas o que é necessário através de métodos públicos, você pode alterar a implementação interna da classe sem afetar o código que a utiliza, desde que a interface pública permaneça consistente.

Esperamos que este exemplo tenha ajudado a esclarecer como o encapsulamento pode ser implementado em Apex e como ele pode beneficiar o design do seu código. Para mais informações sobre boas práticas de programação e encapsulamento, você pode consultar recursos como a documentação Salesforce sobre o assunto.

No próximo post, vamos falar de abstração na Orientação a Objetos.

Forte abraço e até o próximo post.

Orientação a Objetos: Um Paradigma Fundamental para Desenvolvedores Modernos

 

 

A orientação a objetos (OO) é mais do que apenas uma maneira de programar, é uma filosofia que, quando bem compreendida e aplicada, pode levar a um código mais limpo, manutenção fácil e escalável. Neste post, vamos explorar os conceitos fundamentais da OO e como eles podem ser aplicados para melhorar seu desenvolvimento de software.
São eles:

• Encapsulamento: O primeiro pilar da OO é o encapsulamento, que é a prática de esconder os detalhes internos de uma classe do mundo exterior. Isso significa que você pode mudar a implementação interna sem afetar outros códigos que usam a classe.O encapsulamento ajuda a manter o código modular e fácil de alterar.
• Abstração: A abstração envolve a criação de modelos simples que representam a complexidade do mundo real. Ao abstrair, focamos nas características essenciais de um objeto, ignorando as irrelevantes. Isso simplifica o design do programa e reduz a complexidade.
• Herança: A herança permite que uma classe herde características de outra classe. Isso promove a reutilização de código e a criação de uma hierarquia de classes que podem compartilhar comportamento comum, facilitando a manutenção e a expansão do código.
• Polimorfismo: O polimorfismo é a capacidade de um método ter várias formas. Isso é geralmente alcançado através de sobrecarga de métodos ou sobrescrita de métodos em classes derivadas. O polimorfismo permite que o mesmo método tenha comportamentos diferentes, dependendo do contexto em que é usado.

A aplicação desses princípios de OO pode transformar a maneira como você pensa sobre e escreve código. Ao adotar a OO, você pode criar sistemas mais robustos e flexíveis que estão prontos para crescer e se adaptar às necessidades em constante mudança do mundo do software.

Se você está procurando melhorar suas habilidades de programação ou quer entender melhor os princípios de design de software, mergulhar na orientação a objetos é um excelente ponto de partida. Compartilhe este post com sua rede no LinkedIn e inicie uma conversa sobre como a OO tem impactado seu trabalho como desenvolvedor!

No próximo post, vou trazer exemplos de código APEX aplicando os pilares da Orientação a Objetos.

Forte abraço e até o próximo post.

Limites de Governança do Apex no Salesforce: Uma Exploração Detalhada

 Limites de Governança do Apex no Salesforce: Uma Exploração Detalhada

No ecossistema Salesforce, os limites de governança do Apex são essenciais para manter a eficiência e a estabilidade da plataforma multilocatária. 

Esses limites são projetados para garantir que o código Apex personalizado não monopolize os recursos compartilhados, o que poderia afetar negativamente a experiência de outros usuários na mesma instância. 

Vamos mergulhar nos detalhes desses limites e entender como eles impactam o desenvolvimento no Salesforce.

Os limites de governança do Apex são divididos em várias categorias, cada uma com suas próprias restrições específicas. Aqui estão alguns dos limites mais críticos que os desenvolvedores devem estar cientes:

• Limites de Transação por Apex: Estes limites são aplicados a cada transação de Apex individualmente. Por exemplo, há um limite de 100 consultas SOQL sincronizadas por transação e 200 para Apex assíncrono.
• Limites de CPU: O tempo máximo de CPU permitido para o código Apex em servidores Salesforce é de 10.000 milissegundos para processos síncronos e 60.000 milissegundos para processos assíncronos.
• Limites de Memória Heap: O tamanho total da heap para Apex síncrono é de 6 MB, enquanto para o Apex assíncrono, o limite é de 12 MB.
• Limites de Chamadas Externas: Em uma transação, o número máximo de chamadas externas  (solicitações HTTP ou chamadas de serviços web) é 100, com um tempo máximo acumulado de timeout de 120 segundos.
• Limites de DML: Há um limite de 150 instruções DML emitidas por transação e um total de 10.000 registros processados como resultado de instruções DML.

Esses são apenas alguns exemplos dos limites impostos pelo Salesforce para garantir que nenhum código Apex individual consuma mais do que sua parcela justa de recursos. É importante que os desenvolvedores compreendam e respeitem esses limites ao criar triggers do Apex, pois excedê-los pode resultar em exceções de runtime que não podem ser tratadas, levando a falhas na execução do código.

Além dos limites técnicos, há também práticas recomendadas que os desenvolvedores devem seguir para otimizar o desempenho e evitar atingir esses limites. Algumas dessas práticas incluem:

• Escrever Código Eficiente: Utilizar padrões de design e algoritmos eficientes para minimizar o uso de recursos.
• Testar Código Extensivamente: Realizar testes rigorosos para identificar e corrigir problemas de desempenho antes da implantação.
• Monitorar e Avaliar: Usar ferramentas de monitoramento para acompanhar o uso dos recursos e ajustar o código conforme necessário.

Os limites de governança do Apex são um aspecto crucial do desenvolvimento no Salesforce, pois eles ajudam a manter a integridade e o desempenho da plataforma. Ao entender e aderir a esses limites, os desenvolvedores podem criar soluções robustas e escaláveis que aproveitam o poder do Salesforce sem comprometer a experiência do usuário final.

Para mais informações detalhadas sobre os limites de governança do Apex e como eles se aplicam a diferentes aspectos do desenvolvimento no Salesforce, os desenvolvedores podem consultar o Guia de Referência Rápida de Limites e Alocações do Salesforce Developers e outros recursos educacionais disponíveis na comunidade Salesforce.

Até o próximo post e forte abraço.

O que são Triggers no Apex: Uma Visão Geral

 No mundo do desenvolvimento Salesforce, as triggers do Apex são fundamentais para a personalização e automação de processos de negócios. Mas o que exatamente são essas triggers e como elas funcionam?

Uma trigger do Apex é um tipo de código que executa ações personalizadas antes ou depois de eventos específicos de registros no Salesforce, como inserções, atualizações ou exclusões. Essencialmente, elas são ouvintes de eventos que aguardam por mudanças nos registros para executar lógicas definidas pelo desenvolvedor.

Por exemplo, uma trigger pode ser configurada para validar dados antes que um registro seja salvo no banco de dados ou para atualizar campos em registros relacionados após uma alteração. Isso permite que os desenvolvedores estendam a funcionalidade padrão do Salesforce para atender às necessidades complexas de negócios.

As triggers do Apex são divididas em dois tipos principais: before triggers e after triggers. As before triggers são usadas para validar ou atualizar valores
de registros antes de serem salvos no banco de dados. Já as after triggers são utilizadas para acessar valores de campos que são definidos pelo sistema, como
o ID do registro ou o campo LastModifiedDate, e para realizar alterações em outros registros.

A sintaxe de uma trigger do Apex começa com a palavra-chave `trigger` seguida pelo nome da trigger, o tipo de objeto Salesforce ao qual ela se aplica e o
evento que a dispara. Por exemplo:

trigger MyTrigger on SOBJECT (before insert) {

    // escrevemos nosso código aqui

}

Neste exemplo, `MyTrigger` é uma trigger que será executada antes da inserção de um novo registro no objeto `Account`.

É importante notar que as triggers do Apex devem ser usadas com cautela. Elas podem causar alterações em cadeia e, se não forem bem projetadas, podem levar a problemas de desempenho ou exceder os limites de governança do Salesforce. Portanto, é essencial que os desenvolvedores tenham uma compreensão sólida dos melhores práticas de codificação e dos limites da plataforma ao trabalhar com triggers do Apex.

Para aqueles que estão começando ou procuram aprofundar seus conhecimentos em triggers do Apex, o Salesforce Trailhead oferece módulos educacionais que cobrem desde a escrita e sintaxe até exemplos práticos de triggers. Além disso, o Guia do Desenvolvedor Apex do Salesforce fornece uma documentação abrangente sobre a implementação e considerações de triggers.

As triggers do Apex são uma ferramenta poderosa no arsenal de qualquer desenvolvedor Salesforce, permitindo uma personalização avançada e automação de processos que vão além das capacidades padrão da plataforma. Com o conhecimento adequado e uma abordagem cuidadosa, as possibilidades são praticamente ilimitadas.

Vamos aprofundar esse assunto com as melhores práticas na criação de triggers e os padrões que podemos aplicar no desenvolvimento delas.

Forte abraço e até o próximo post.