|
WinDev e Programação Orientada a Objetos (OOP) |
Débuté par BOLLER, 11 mai 2018 23:11 - 4 réponses |
| |
| | | |
|
| |
Membre enregistré 3 649 messages Popularité : +175 (223 votes) |
|
Posté le 11 mai 2018 - 23:11 |
Introdução
Se você vier no Slack, você pode se deparar com o @Jack. Eu falo muito com o @Jack e aprendemos coisas um com o outro. Mas muitas vezes, o @Jack me diz:
É complicado encontrar algo que explique o OOP com o WinDev®.
Alguns dias depois, um dos meus colegas de trabalho me disse:
Congelar essa laje na OOP.
Nem um nem dois, eu peguei meu teclado e decidi salve o mundopara explicar o OOP. A teoria, mas também a prática com WinDev.
Eu não te dou uma promessa falsa, eu posso falhar. De fato, OOP é um conceito muito amplo com concreto e abstrato. O concreto explica o como, mas não o porquê , enquanto o resumo explica o porquê, mas não o como . Vou ter que explicar as duas noções ao mesmo tempo.
Estou contando com você para me orientar na escrita desses artigos (porque haverá vários). Você tem que me fazer perguntas, me diga se eu sou muito vago, muito complicado, errado ou qualquer coisa. Quando eu tiver escrito todos os artigos, vou fazer um bonito bem condensado que vou publicar no developez.com.
Apresentação da OOP De uma maneira abstrata Imagine o seu programa como uma grande caixa. Você entra e vê muitas caixas grandes. Eles são todos negros, você não vê o que está dentro. Eles não são da mesma forma ou tamanho. Algumas caixas estão relacionadas a outras. Você entra em uma dessas caixas e vê a mesma coisa, essa caixa também contém outras caixas pretas. E assim por diante. Você decide mudar o comportamento do seu programa, então você cria uma nova caixa. E você substitui por outra caixa. Essas caixas são do mesmo tamanho e formato, mas se você comparar o conteúdo delas, verá que elas são diferentes. Duas caixas da mesma forma, mas com comportamento diferente.
E concretamente Caixas são objetos. Eles são pretos, então não podemos ver por dentro. Isso significa que o desenvolvedor, ao manipular o objeto, não precisa saber como o objeto funciona. Esse princípio é chamado de encapsulamento.
Uma caixa com a mesma forma de outra pode substituir essa outra caixa, mesmo que seu conteúdo (comportamentos) seja diferente. Isso significa que o desenvolvedor pode trocar objetos semelhantes (esses objetos têm a mesma interface), mas não necessariamente têm o mesmo comportamento. Este princípio é chamado polimorfismo.
Esses dois conceitos (encapsulamento e polimorfismo) estão entre os conceitos mais importantes da POO. Eles são parte do porque OOP.
E de uma maneira pictórica? Eu estou construindo meu carro. Vamos simplificar as coisas, há o chassi e o motor. Eu tenho o chassi de um Clio® e um Ferrari®. Da mesma forma para o motor, eu tenho o de um Clio e uma Ferrari.
Com o princípio de encapsulamento, não sei como funcionam os motores. Quando você pensa sobre isso, eu não tenho um motor Clio e um motor Ferrari. Eu tenho dois motores, ponto. O principal é que eles trabalham e fazem o que eu espero deles.
Com o princípio do polimorfismo, posso usar qualquer motor com qualquer chassi. Os motores se encaixam em ambos e se conectam perfeitamente.
No final, fazendo brinquedo, eu posso criar:
uma Ferrari; um Clio; um carro com um chassi Clio e um motor Ferrari; um carro com um chassi da Ferrari e um motor Clio. conclusão E é isso, eu te falei sobre OOP sem mencionar as palavras classe, método, propriedade ou herança. Esse é o caminho , e vamos falar sobre isso em um artigo futuro.
Enquanto isso, comente este artigo. Dê sua opinião, faça perguntas. Ajude-me a melhorar.
E se você puder compartilhá-lo, isso me faria muito feliz.
Obrigado por ler.
Artigo traduzido do link
http://blog.ytreza.org/windev-et-la-programmation-orientee-objet-poo-partie-1/
Jonathan Laurent 12 de abril de 2018 em Windev , OOP
-- Adriano José Boller ______________________________________________ Consultor e Representante Oficial da PcSoft no Brasil +55 (41) 99949 1800 adrianoboller@gmail.com skype: adrianoboller http://wxinformatica.com.br/ |
| |
| |
| | | |
|
| | |
| |
Membre enregistré 3 649 messages Popularité : +175 (223 votes) |
|
Posté le 11 mai 2018 - 23:14 |
WinDev e Programação Orientada a Objetos (OOP) - Parte 2
Jonathan Laurent 17 de abril de 2018 em Windev , OOP
introdução Muitos de vocês apreciaram o primeiro artigo sobre OOP. Bem, parabéns, você me motivou a escrever um segundo artigo (eu sei, ainda estamos aguardando o segundo artigo sobre expressões regulares, mas ainda não encontrei a inspiração).
Neste artigo, darei um exemplo onde comparo a OOP à programação processual. Você pode baixar este exemplo do repositório PCSoft, mas, por favor, para aqueles que não conhecem o OOP, espere o artigo pedir que você revise o código para não ir muito rápido.
De fato, eu quero continuar ensinando o porquê (encapsulamento e polimorfismo) e temo que você pare apenas como (classe de criação, método, propriedade, etc ...). É um erro que cometi quando comecei a aprender e comecei a querer colocar as coisas em todos os lugares, sem pensar. Pior, eu treinei meus colegas e o código resultante (ainda em atividade) me decepciona muito hoje.
Tome tempo ...
Baixe o exemplo
OOP por exemplo Primeiro de tudo, você deve saber que tudo que você pode fazer proceduralmente, você pode fazê-lo em OOP. Mas o oposto também é verdade . OOP não é melhor que processual, OOP é diferente.
Na minha maneira de apresentá-lo a você, eu vou fazer você preferir o OOP, desde que eu quero que você entenda os benefícios. O nível de qualidade do primeiro exemplo (programação procedural) é menor que o do segundo (OOP). Isso é feito de propósito.
Em processual O primeiro exemplo é escrito em processual. Permite manipular uma tabela, uma lista e uma zona repetida. Três ações são possíveis em cada um dos campos:
Adicione um item Excluir o item selecionado Visualizar conteúdo em uma lista Eu deixo você ler o código da janela fenTest01 (para iniciantes , Ctrl + E, em seguida, digite 01 e faça Enter). O código de interesse está nos botões 3 Adicionar Item , Excluir Item Selecionado e Rastrear Conteúdo .
Você vai descobrir que para cada campo, usamos os métodos com o prefixo: Tablexxx, Listxxx e ZoneRepétexxx.
Eu poderia fatorar um pequeno código, mas voluntariamente, eu não fiz isso, porque todo mundo sabe que o OOP é melhor! (Espero que você tenha percebido a ironia)
Finalmente, chamo a atenção para a presença de uma palavra-chave em particular, a palavra-chave SELON . Vamos ver mais tarde porque eu insisto nisso, mas é importante.
É isso aí, você testou a janela e deu a volta por aí. Você controla o código, é perfeito.
Com OOP Agora, eu deixo você saber o código da janela fenTest02 (para iniciantes, Ctrl + E, 02, etc ...).
É a mesma janela e ela está fazendo a mesma coisa. Teste, você não verá nenhuma diferença.
O código que nos interessa é sempre nos 3 botões. Aqui está o código do botão Adicionar um item :
nouveau_libellé est une chaîne = DonneGUID(guidFormaté) champ est un cChampAvecElements dynamique = recupérer_champ() champ.ajouter(nouveau_libellé)
E compare com o código anterior:
nouveau_libellé est une chaîne = DonneGUID(guidFormaté)
SELON brQuelChamp CAS 1 : TableAjoute(taElements, nouveau_libellé)
CAS 2 : ListeAjoute(lsElements, nouveau_libellé)
CAS 3 : ZoneRépétéeAjoute(zrElements, nouveau_libellé) FIN
E aqui eu quero chamar sua atenção para as duas noções que eu falo com você o tempo todo:
encapsulamento O primeiro é o encapsulamento.
Eu não sei como o método Add funciona porque ocultei os detalhes da implementação na classe. Então eu defini o que é chamado de nível de abstração .
Eu não tenho que saber se eu deveria usar TableAdd , ListAdd ou AddRegionAdd, que são funções muito específicas. Em todo caso, simplesmente terei que usar o método Add , que é muito mais abstrato . OOP torna as coisas mais simples, tornando-as mais abstratas.
Polimorfismo O segundo é o polimorfismo.
Eu estou trabalhando com um objeto do tipo cChampAvecElements. Abra a função retrieve_field (para iniciantes, coloque o cursor sobre ela e pressione F2). Você encontra o seguinte código:
Procedure recupérer_champ() champ est un cChampAvecElements dynamique SELON brQuelChamp CAS 1 : champ = vl.champ_table
CAS 2 : champ = vl.champ_liste
CAS 3 : champ = vl.champ_zone_répétée FIN RENVOYER champ
Notamos o seguinte:
Encontramos a CONTA . O objetivo do polimorfismo é fazer desaparecer o SELON. Se você usa um SELON, então há uma boa chance de usar o polimorfismo, a menos que você esteja no que é chamado de fábrica . Este é um pouco o caso em nosso exemplo (não exatamente porque não criamos os objetos nesta função, mas vamos agir como se ...).
Vemos que temos três variáveis locais (se o vl não lhe disser nada, convido você a ler o artigo WinDev - convenção de codificação em meus projetos ).
Eles são definidos na parte de declaração da janela:
Procedure MaFenêtre() stVariableFenêtre est une structure champ_table est un cChampAvecElements dynamique champ_liste est un cChampAvecElements dynamique champ_zone_répétée est un cChampAvecElements dynamique FIN
vl est une stVariableFenêtre
LOCAL vl.champ_table = allouer un cChampTable(taElements, taElements.Colonne1) vl.champ_liste = allouer un cChampListe(lsElements) vl.champ_zone_répétée = allouer un cChampZoneRépétée(zrElements, zrElements.coLibellé)
Cada variável tem um tipo diferente ( cFieldTable , cFieldList e cFieldZoneRepeat ), mas podemos armazená-los em uma variável do tipo cFieldEvecElements . Isso é chamado de polimorfismo . Um objeto cChampAvecElements pode ter vários formulários.
Conclusão no exemplo Com o polimorfismo e o encapsulamento, tentamos ocultar os detalhes o máximo possível para permitir que o desenvolvedor entenda a real intenção do código com muito mais facilidade e permita que o código evolua.
De fato, se eu precisar usar um campo de entrada, só preciso criar uma classe cChampSaisie e isso funcionará da mesma maneira que as outras. Só terei que alterar a função get_field para manter meu código funcionando.
Finalmente, convido você a ler os códigos dos outros dois botões. O botão Desenhar Conteúdo é o que eu acho mais interessante.
conclusão Neste artigo, ainda permaneci no porquê . Espero que este exemplo tenha permitido que você entendesse melhor os dois conceitos de encapsulamento e polimorfismo.
Se desejar, você pode começar a explorar como estudar as classes cChampAvecElements , cFieldTable , cFieldList e cFieldZoneComplete . Vou explicá-los em detalhes em um artigo futuro.
Se você quiser ir mais longe, convido você a estudar outros projetos que usam OOP. Por exemplo, você pode ligar para meus projetos yLogger e yImageComposée (a ser lançado brevemente) são exemplos perfeitos (I misturar alegremente OOP e programação procedural).
Finalmente, espero que tenham gostado deste artigo e lhe ensinado coisas. Sinta-se à vontade para me dar sua opinião por comentário. Aceito tudo (perguntas, comentários, conselhos, críticas, etc ...).
E se você quiser compartilhar este artigo, não hesite, isso vai me fazer muito feliz.
Desejo a todos um bom dia.
Artigo traduzido do link
http://blog.ytreza.org/windev-poo-windev-et-la-programmation-orientee-objet-poo-partie-2/
Jonathan Laurent 12 de abril de 2018 em Windev , OOP
-- Adriano José Boller ______________________________________________ Consultor e Representante Oficial da PcSoft no Brasil +55 (41) 99949 1800 adrianoboller@gmail.com skype: adrianoboller http://wxinformatica.com.br/ |
| |
| |
| | | |
|
| | |
| |
Membre enregistré 3 649 messages Popularité : +175 (223 votes) |
|
Posté le 11 mai 2018 - 23:20 |
WinDev e Programação Orientada a Objetos (OOP) - Parte 3
Jonathan Laurent 2 de maio de 2018 em Windev , OOP
Edit du 03/05/2018 : suite à une remarque pertinente de @Jack sur les propriétés et sur les objets, je modifie un peu le texte.
introdução
Aqui está o terceiro artigo sobre OOP com WinDev®. Se você não os leu, convido-o a ler os anteriores ( artigo 1 e 2 ).
Em artigos anteriores, expliquei por que usamos a POO. Hoje vou explicar como . Vamos ver como criar uma classe e, mais importante, como ela é estruturada. Eu insisto novamente, OOP é interessante se você souber por que e como . Se você entender apenas uma das duas noções, você criará caos em seus projetos. É experiência ...
Finalmente, a apresentação que vou lhe dar será muito geral. Não voltarei aos detalhes. Então, para os conhecedores, saiba que não vou falar sobre casos especiais hoje. Será para a próxima vez.
Classes Ao usar o OOP, criamos e manipulamos objetos. A criação é feita por meio de uma ferramenta chamada class . Devemos considerar uma classe como um molde que pode ser usado à vontade para criar quantos objetos você desejar. Se você quiser outro tipo de objeto, usamos outro molde. Agora descreverei a composição de uma aula.
Você fala "objeto"? Antes de prosseguir, é bom integrar algumas noções de vocabulário.
Objetos (ou instâncias de classe) Um objeto (também chamado de instância de classe) é uma entidade colocada na memória que foi criada a partir do molde que é uma classe. Cada objeto tem sua própria identidade e vários objetos da mesma classe podem coexistir ao mesmo tempo.
Os membros (ou atributos) de uma classe Em geral, quando você está falando sobre um membro de uma classe, você está falando sobre uma variável. Essa variável é especial porque está relacionada ao objeto. Isso significa que dois objetos diferentes têm uma variável diferente. Para dar um exemplo, imagine que você tenha duas janelas do WinDev. Cada um tem uma propriedade ..Height diferente. ..Altura é o equivalente de um membro.
Os membros têm recursos que veremos na próxima vez.
Métodos Se membros são variáveis, então métodos são procedimentos ou funções. Uma coisa os distingue dos procedimentos / funções aos quais você está acostumado. Eles têm acesso direto aos membros, bem como a instância da própria aula.
Os métodos também possuem características que estudaremos depois.
Em uma classe, existem dois métodos específicos:
O construtor O construtor é um método especial que permite inicializar o objeto, assim seus membros. Aceita parâmetros como qualquer método. No entanto, ele não pode retornar um valor (implicitamente consideramos que ele retorna o objeto criado). Deve-se notar que o construtor é necessariamente chamado para a criação de um objeto.
O destruidor Este é o segundo método particular que você vai encontrar, mas que você quase nunca irá usar. É chamado quando o objeto é destruído e permite liberar os recursos mantidos pelo objeto. Por razões técnicas que você certamente verá nos comentários ou no meu 10º artigo sobre a POO, não sabemos necessariamente quando o destruidor será chamado. É por isso que não recomendo usá-lo sem saber o que você está realmente fazendo.
Propriedades Para iniciantes, as propriedades são um conceito que não é encontrado no processual. Visto de fora, uma propriedade parece um membro, mas visto de dentro, parece um método. Esta é uma noção muito interessante no OOP.
Claro, você vai me dizer que você já conhece as propriedades desde que você já tenha manipulado com os objetos do WinDev (..heter mencionado acima, por exemplo). Mas, neste caso, você realmente faz a diferença entre uma propriedade e um membro? Você verá a diferença um pouco mais adiante no artigo e entenderá por que ele é inédito (edit: @Jack, obrigado por essa observação).
Crie uma classe com o WinDev No WinDev, criar uma classe é muito simples. Esta é a mesma ação que criam uma procedimentos de coleta, a menos que você escolher classe em vez (para iniciantes, em WINDEV 22, você faz Ctrl + N / Código / Classe).
E agora, você acaba com uma boa aula recém criada e vê três blocos de código:
afirmação Neste bloco, você declara os membros da classe. Simplificando, você os declara como se estivesse na parte da Declaração Global de uma janela ou procedimento. Um membro se declara da mesma maneira que uma variável. Você pode especificar um valor padrão para cada membro na parte da declaração, mas eu prefiro inicializá-los explicitamente no construtor.
Por exemplo, para ter uma classe com um membro my_value:
cMaClasse est une Classe ma_valeur est une chaîne FIN
O construtor Como explicado anteriormente, o construtor permite inicializar os membros.
Procedure Constructeur(valeur_initiale est une chaîne) ma_valeur = valeur_initiale
Para ter um código limpo e otimizado, aconselho você a colocar apenas o código de inicialização dos membros. E certifique-se de que a otimização seja a mais rápida possível (evite ler um arquivo ou acessar o banco de dados, por exemplo).
O destruidor Deixe vazio para começar.
Procedure Destructeur()
Adicione um método Um método é criado como em uma coleção de procedimentos (para iniciantes: F4, indique o nome e deixe tudo por padrão). E aqui está um novo método. Codifique como você codificaria um procedimento / função e é isso.
A única peculiaridade é que você tem acesso direto ao membro, bem como à instância da classe (o objeto).
Para acessar os membros, você pode nomear diretamente o membro. Dependendo da configuração do seu projeto, você pode ter que preceder o nome do membro com os dois pontos (.
Procedure ajouter_suffixe(suffixe est une chaîne) ma_valeur = ma_valeur + suffixe
ou
Procedure ajouter_suffixe(suffixe est une chaîne) :ma_valeur = :ma_valeur + suffixe
Para acessar o objeto, você tem disponível o objeto de palavra-chave (preste atenção, é muito fácil esquecer esta palavra). Considere que isso é o equivalente da variável MyWindow em uma janela.
Procedure est_égal(autre_objet est un cMaClasse) RENVOYER objet.ma_valeur = autre_objet.ma_valeur
Crie uma propriedade Para criar uma propriedade, é necessário percorrer o menu contextual (clique com o botão direito na classe no explorador do projeto e depois com a nova propriedade ou clique com o botão direito do mouse no painel de código no nível da lista de membros e métodos da classe).
É-lhe pedido um nome e se deseja que a propriedade seja acessível para leitura e / ou escrita. Para os outros parâmetros, deixe-os de lado por enquanto.
Como eu lhe disse, uma propriedade parece um procedimento quando vista de dentro. De fato, o WinDev cria dois blocos de código:
Recuperando a propriedade (lendo) Atribuição da propriedade (escrita) A presença de código em um bloco ativa-o enquanto a ausência o desativa. Isso permite que você use um novo sistema para você, caso nunca tenha feito OOP. A possibilidade de ter variáveis acessíveis na leitura, na escrita ou em ambos.
Por exemplo, posso criar a propriedade de tamanho que faz o seguinte:
Procedure Taille() RENVOYER Taille(:ma_valeur)
Eu posso ler o tamanho do meu objeto, mas não posso alterá-lo.
Lidar com uma turma A manipulação de uma classe parece um pouco com a manipulação de uma estrutura, exceto que a estrutura não propõe um método (a menos que você tenha lido os primeiros artigos do meu blog).
Um exemplo será mais revelador do que um texto longo:
mon_objet est une cMaClasse("valeur test") Trace(mon_objet.ma_valeur)
mon_objet.ajouter_suffixe(" fin") Trace(mon_objet.ma_valeur)
SI mon_objet.taille >= 15 ALORS Trace("L'objet a une taille de 15 ou plus") SINON Trace("L'objet a une taille de moins de 15")
Pequenas observações a granel Você pode usar a sintaxe mon_objet.ma_valeurou mon_objet:ma_valeur. Se você não tem uma convenção de codificação para as aulas, você pode se inspirar na minha . Eu já disse, mas não esqueça a palavra-chave objeto !!! Eu convido você a ler a documentação do WinDev nas aulas . O componente yAnalyse está totalmente programado em OOP. Além de ter uma ferramenta prática, é também uma oportunidade de ter um bom exemplo sobre a OOP. conclusão E agora, você sabe o básico do OOP com o WinDev. Eu intencionalmente escondi muitas coisas para você ter um artigo o mais simples possível. No próximo artigo, discutirei a implementação do polimorfismo, a parte mais interessante na minha opinião sobre a POO.
Espero que você goste de ler este artigo tanto quanto eu o escrevo. Como eu lhe disse para os anteriores, não hesite em comentar e criticar os artigos para que eu possa melhorar e / ou corrigi-los. Você também pode me fazer suas perguntas, vou tentar respondê-las o mais rápido possível.
Por fim, ficarei muito grato se você compartilhar este artigo com seus colegas ou em redes sociais. Quanto mais somos loucos, mais rimos.
Agradeço sua leitura e lhe direi muito em breve para um novo artigo.
Link
http://blog.ytreza.org/windev-et-la-programmation-orientee-objet-poo-partie-3/
Jonathan Laurent 2 de maio de 2018 em Windev , OOP
-- Adriano José Boller ______________________________________________ Consultor e Representante Oficial da PcSoft no Brasil +55 (41) 99949 1800 adrianoboller@gmail.com skype: adrianoboller http://wxinformatica.com.br/ |
| |
| |
| | | |
|
| | |
| |
Membre enregistré 3 649 messages Popularité : +175 (223 votes) |
|
Posté le 11 mai 2018 - 23:21 |
| |
| |
| | | |
|
| | |
| |
Membre enregistré 3 649 messages Popularité : +175 (223 votes) |
|
Posté le 11 mai 2018 - 23:27 |
| |
| |
| | | |
|
| | | | |
| | |
|