PC SOFT

FORUMS PROFESSIONNELS
WINDEVWEBDEV et WINDEV Mobile

Accueil → WINDEV 22 → WinDev e Programação Orientada a Objetos (OOP)
WinDev e Programação Orientada a Objetos (OOP)
Débuté par BOLLER, 11 mai 2018 23:11 - 4 réponses
Membre enregistré
2 852 messages
Popularité : +89 (91 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é
2 852 messages
Popularité : +89 (91 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
// La table
CAS 1 : TableAjoute(taElements, nouveau_libellé)

// La liste
CAS 2 : ListeAjoute(lsElements, nouveau_libellé)

// La zone répétée
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
// La table
CAS 1 : champ = vl.champ_table

// La liste
CAS 2 : champ = vl.champ_liste

// La zone répétée
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é
2 852 messages
Popularité : +89 (91 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é
2 852 messages
Popularité : +89 (91 votes)
Posté le 11 mai 2018 - 23:21
Example Download

https://depot.pcsoft.fr/resource.awp…

--
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é
2 852 messages
Popularité : +89 (91 votes)
Posté le 11 mai 2018 - 23:27
http://blog.ytreza.org/

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/