Por que é bom dividir um programa em várias classes? [fechadas]

Ainda sou estudante do ensino médio (ingresso na 10ª série) e ainda tenho que fazer um curso de informática na escola. Tudo o que fiz até agora é através de livros. Esses livros me ensinaram conceitos como herança, mas como a divisão de um programa em várias classes ajuda? Os livros nunca me disseram.

Estou perguntando isso principalmente por causa de um projeto recente. É um videogame arcade, como um jogo em Flash, como algumas pessoas disseram (embora eu não tenha idéia do que é um jogo em Flash ). O problema é que é apenas uma classe. Funciona perfeitamente bem (um pouco de atraso ocasional) com apenas uma classe. Então, eu estou apenas perguntando como dividi-lo em várias classes ajudaria.

Este projeto estava em Java e eu sou a única pessoa trabalhando nele, para constar.

A resposta mais simples é que, se você colocar tudo em uma classe, precisará se preocupar com tudo de uma vez ao escrever um novo código. Isso pode funcionar para pequenos projetos, mas para aplicativos enormes (estamos falando de centenas de milhares de linhas), isso rapidamente se torna quase impossível.

Para resolver esse problema, você divide partes da funcionalidade em suas próprias classes e encapsula toda a lógica. Então, quando você quiser trabalhar na classe, não precisará pensar no que mais está acontecendo no código. Você pode apenas se concentrar nesse pequeno pedaço de código. Isso é inestimável para trabalhar com eficiência, no entanto, é difícil apreciar sem trabalhar em aplicativos que são enormes.

É claro que existem inúmeros outros benefícios em dividir seu código em partes menores: o código é mais sustentável, mais testável, mais reutilizável etc., mas para mim o maior benefício é que ele torna programas massivos gerenciáveis, reduzindo a quantidade de código que você usa. precisa pensar ao mesmo tempo.

Bem, a resposta mais simples pode ser "Isso ajuda a organizar as coisas". Se nada mais, você pode compará-lo às seções de um caderno - é muito mais simples se você tiver "todas as coisas relacionadas à interface do usuário" aqui e "todas as coisas relacionadas à jogabilidade" por lá.

A resposta mais sofisticada é que dividir o trabalho não é apenas conveniente, mas muito importante para gerenciar a complexidade (e "gerenciar a complexidade" é praticamente o nome do jogo quando se trata de programação). Classes ou outros tipos de módulo permitem "separar preocupações". Você não apenas sabe onde procurar "coisas relacionadas à interface do usuário", mas também pode ter certeza de que, se quiser fazer uma alteração na interface do usuário, pode fazê-lo em um só lugar e não precisa preocupe "agora, esse é o único local em que defino minha fonte como Comic Sans?". E você pode fazer uma alteração e saber que o efeito dessa alteração é apenas para o escopo (pequeno) apropriado. Se tudo estiver em uma única classe ou módulo, essencialmente tudo será global,

No caso específico de classes como um tipo de módulo de software, também há muito comportamento associado a uma classe, e a maioria dos desenvolvedores no paradigma orientado a objetos acha muito útil ter nomes significativos associados às classes relacionadas ao grupo. funções juntas. Então você provavelmente não teria uma UIaula, provavelmente teria uma Buttonaula. Existe todo um conjunto de conhecimentos e técnicas associados ao design de classes orientado a objetos e é a maneira mais comum de organizar grandes sistemas na programação convencional.

Essa é uma boa pergunta! Simples e bem solicitado. Bem ... a resposta não é tão fácil de entender para um estudante que estuda ciência da computação e provavelmente não conhece profundamente OO e provavelmente não tem trabalho em experiência.

Portanto, posso responder descrevendo um cenário e fazendo você imaginar como o software multi-classes é melhor que o software monolítico (feito apenas por uma classe):

• Legibilidade : É muito mais difícil procurar e escrever código dentro de um arquivo com 10.000 linhas do que vários arquivos pequenos e organizados.
• Reutilização : se você escrever uma única classe, poderá reduzir a duplicação de código . Isso significa mais linhas de código e provavelmente mais bugs (!)
• Testabilidade : Que tal testar uma única funcionalidade? Se você isolar uma funcionalidade lógica em uma classe, sua vida será mais fácil.
• Manutenção de código : você pode corrigir um bug ou aprimorar a funcionalidade com classes de multiplicação em um único local: As pequenas e agradáveis ​​classes.
• Estrutura do projeto : oooooh, você pode imaginar o quão feio será um projeto com apenas um arquivo de origem?

Há muitas boas respostas aqui e definitivamente concordo com elas, mas sinto que há algo mais que vale a pena mencionar.

No momento, como você disse, você está trabalhando sozinho em seu projeto. No entanto, no futuro, haverá momentos em que você precisará trabalhar em um ambiente de equipe. Durante esses períodos, você dividirá o trabalho (presumivelmente o projeto será bastante grande). Como resultado, existem algumas (acho que realmente duas grandes ) opções diferentes. Você pode ter várias cópias de um arquivo e trabalhar em "partes" separadas do arquivo e, em seguida, "combiná-las" com copiar e colar posteriormente e modificá-las para que suas partes possam trabalhar juntas, ou você pode dividir essas "partes" bastante. facilmente em diferentes classes e discuta como você escreverá essas classes e use esse conhecimento para prosseguir.

Ainda será preciso trabalhar para integrar todas as peças separadas, mas será muito mais fácil de manter. Como o arquivo x contém o código y, é esse o código que você sabe que precisa modificar. Isso entra na coisa da organização que a maioria das outras respostas fala.

Segurando um programa na cabeça. Link de Giorgio

De fato, o que você fez é reinventar a programação processual. Lembre-se, é bem possível escrever um software dessa maneira e o compilador provavelmente não se importará. Por muitos anos, foi assim que as coisas foram feitas até que os computadores ficaram mais rápidos e as ferramentas melhoraram.

Dito isto, se você dividir seu código em diferentes unidades lógicas (Classes, módulos, etc.), é que você pode ter um monte de partes curtas e fáceis de entender. que pode ser mantido mais tarde. Muitos dos meus módulos têm menos de 20 linhas de código. Eu sei que todo o código de um determinado assunto está em um local específico. Isso também significa que, se alguém se juntar ao projeto, terá mais facilidade em encontrar as coisas.

Como Gerald Sussman disse, nossos programas devem ser escritos primeiro para que as pessoas possam lê-lo e depois para que o computador possa executá-lo. (E se você ainda não leu "Estrutura e Interpretação de Programas de Computador, deve ler)

Um usa várias classes porque, à medida que você entra em coisas maiores, descobre que simplesmente não há como acompanhar tudo quando se trata de uma grande pilha de código.

Você simplesmente tem que dividir e conquistar para lidar com isso.

A programação orientada a objetos é a melhor ideia que já vi na programação. Mas não é a melhor coisa em todos os casos, você precisa de um pouco de experiência em programação para entender o ponto, e muitas pessoas estão reivindicando fazer OOP quando não estão.

Se você pode procurar "programação estruturada", provavelmente encontrará algo mais útil imediatamente. (Certifique-se de ler sobre programação estruturada antiga . Termos antigos geralmente têm significados novos e sofisticados, e você ainda não precisa de nada sofisticado.) Esse é um conceito bastante simples sobre como dividir seu programa em sub-rotinas, o que é muito mais fácil do que quebrando-o em objetos. A idéia é que seu programa principal seja uma rotina curta que chama sub-rotinas ("métodos" em Java) para fazer o trabalho. Cada sub-rotina sabe apenas o que é dito por seus parâmetros. (Um desses parâmetros pode ser um nome de arquivo, para que você possa trapacear um pouco.) Portanto, analisar o cabeçalho de uma sub-rotina / método fornece uma idéia rápida do que ele faz, faz quase de relance.

Todas as sub-rotinas são divididas da mesma forma, até que algumas linhas de código sem nenhuma chamada de método façam o trabalho. Um programa principal que chama alguns métodos, cada um dos quais chama alguns métodos, cada um dos quais ... Até pequenos métodos simples que fazem o trabalho. Dessa forma, você pode observar qualquer parte de um programa muito grande (ou pequeno) e entender rapidamente o que ele faz.

O Java foi projetado especificamente para pessoas que escrevem código orientado a objetos. Mas mesmo o programa OO mais intenso usa alguma programação estruturada, e você sempre pode subverter qualquer idioma. (Eu fiz OO na planilha C.) Para que você possa executar o SP, ou qualquer outra coisa, em Java. Esqueça as aulas e concentre-se em métodos grandes que podem ser divididos em métodos pequenos e gerenciáveis. Devo acrescentar que o SP ajuda muito a permitir que você reutilize seu código, e também com o princípio DRY (pesquise no Google, mas significa "Não se repita").

Espero ter explicado por que e como dividir seu código em várias partes sem trazer "classes". Eles são uma ótima idéia e são ideais para jogos e o Java é uma ótima linguagem para OOP. Mas é melhor saber por que você está fazendo o que está fazendo. Deixe o OOP em paz até que ele faça algum sentido para você.

Um dos benefícios é a reutilização. Um programa é basicamente um monte de instruções agrupadas. Você descobriria que algumas dessas instruções também são adequadas para outros programas.

Digamos que você faça um jogo de salto. Mais tarde, quando você decide fazer um jogo de canhão, descobre que o cálculo da física usado no jogo de salto é útil aqui.

Então, em vez de escrevê-lo novamente ou, melhor ainda, copiá-lo e colá-lo no novo programa, você o transforma em uma classe. Então, da próxima vez que você criar outro jogo em que a mecânica do jogo exija física, você poderá reutilizá-lo. Claro que isso é simplificado demais, mas espero que faça sentido.

Antes de tudo, observe que eu sou C ++ e Python, não Java, portanto, parte disso pode não se aplicar tão completamente. Corrija-me se eu fizer algumas suposições incorretas sobre como as classes funcionam em Java.

As classes são úteis principalmente quando são instanciadas. Uma classe da qual nenhuma instância é criada é realmente apenas um espaço de nomes glorificado. Se você usar todas as suas classes dessa maneira, os benefícios de mover coisas de namespace para namespace podem parecer insignificantes - no máximo, você ganhará com alguns dados privados em cada uma delas e, assim, encapsulará um pouco as coisas.

No entanto, não é aí que as aulas brilham. Considere a Stringclasse: você pode ter todos os mesmos recursos usando charmatrizes e algumas funções estáticas. Nesse ponto, as funções oferecem um pouco de segurança extra e açúcar sintático. Você pode escrever em string.length()vez de length(char_array); isso não é grande coisa, mas muitas pessoas ainda gostam. Além disso, você sabe que se alguém lhe deu um String, ele foi criado com o Stringconstrutor e deve funcionar com a lengthfunção - se a versão do array não puder lidar com algum caractere, não haverá como impedir que você o coloque lá .

Ainda não é isso, no entanto. O ponto principal é que as classes agrupam dados e funções que operam nele e abstraem os dois. Quando você tem um método, void f(Builder b)sabe que receberá um Buildere pode esperar que ele suporte certo comportamento. No entanto, você não sabe nada sobre os dados ou as funções que estão sendo executadas - na verdade, as definições para ambos ainda não podem ser gravadas enquanto você escreve e compila f.

O primeiro ponto a entender é que as classes facilitam a transmissão de dados, garantindo que não sejam quebrados. O segundo ponto é que tanto os dados quanto a função (implementações) de um objeto têm algo sobre o objeto, não algo que você pode apenas dizer do seu tipo.

A idéia toda é baseada em uma regra geral denominada dividir e conquistar .
Este paradigma pode ser usado em quase todos os lugares; você divide um problema em problemas menores e depois resolve esses pequenos, simples e conhecidos problemas.
Dividir seu programa em classes é um dos tipos de divisão que começaram a se tornar comuns na última década. Nesse paradigma de programação, modelamos nosso problema com alguns objetos e tentamos resolvê-lo enviando mensagens entre esses objetos.
Algumas pessoas podem dizer que essa abordagem é mais fácil de compreender, expandir e depurar.
Embora algumas pessoas discordem :)

Não se trata de dividir um programa em classes, mas de como você modela seu aplicativo, ou seja, como visualiza partes do seu aplicativo. Dividir as coisas é apenas um mecanismo que usamos para entender melhor as coisas complexas. Não é só com programação. Imagine uma placa de circuito com muitos fios entrelaçados, formando uma estrutura complexa com cada fio conectado em algum lugar (código espaguete). Você terá que seguir cada fio até o fim para descobrir as conexões. Pelo contrário, imagine fios agrupados e codificados por cores de acordo com sua função. Torna-se muito mais fácil consertar as coisas.

A idéia é que você não comece com um programa longo e depois o divida em classes. Mas você modela seu aplicativo primeiro em termos de objetos / classes e depois os conecta para criar aplicativos.