A melhor prática para modificar coleção atributos funcionalmente




Estou curioso para saber como ir sobre a implementação de uma classe que obedece a regras estritas de programação funcional.


Por exemplo, se eu tiver uma classe que tem dois atributos e eu tenho um método que lhes modifica, como eu iria sobre como fazer isso? Os atributos seria vals privadas, eo método teria que retornar uma nova instância do atributo cada vez que ela modifica. Isso é bom, só que eu gostaria de mantê-lo contido, ou seja, eu precisaria de uma maneira de definir o val.


Qual seria a melhor maneira de fazer isso para que eu não tenho milhares de casos de exemplo, uma coleção, flutuando em memória?
Esta é a minha opinião, mas; assim como as classes de caso do, eu gostaria implementar um `copy`método de tipos na classe para fazer a modificação possível, mantendo a imutabilidade, mas existe alguns casos que eu não posso ajudar a tê-lo mutável; por exemplo, quando se espera algo para tornar a operação de cópia muito grande e lento para a classe; como quando a classe tem tantos membros freqüentemente modificados. E não se preocupe com milhares de casos flutuando na memória, porque eles são automaticamente GC'ed, então o problema mais real é o custo do tempo de copiar as instâncias da classe. Por favor, diga-me se minha opinião é de alguma forma errada :)
<p>olá carlos!</p>
<p>é sempre uma boa prática separarmos as classes do nosso sistema pois se fazemos tudo em somente uma acabamos pendendo para o paradigma estrutural e não para o orientado a objetos.</p>
<p>isso também facilita na manutenção do código.</p>
<p>espero que tenha ajudado! :d</p>
<p>bons estudos! ^^</p> <p>bom em muitos exercícios a opinião do instrutor não condis com a pergunta. no meu caso vou tentando fazer pesquisando uma solução nos fóruns, ou mesmo deixando a questão para trás, provavelmente em outro exercício você vai se esclarecer melhor. </p>
<p>assim a classe compila:</p>
<p>nome do arquivo <code>fatorial.java</code>.</p>
<p>nome da classe <code>class fatorial</code></p>
<pre class="prettyprint"><code>class fatorial{
 //atributos e metodos
}</code></pre>
<p>espero ter contribuído com você.</p> <p>olá henrique!</p>
<p>esse erro ocorreu devido ao tipo de visibilidade da classe e dos atributos.</p>
<p>o que aconteceu é que você declarou a classe como <code>public</code>, onde todos podem acessar, mas os atributos, por não terem nenhuma visibilidade declarada, estavam como <code>package</code> (ou <code>default</code> ou <code>friendly</code>) que apenas classes dentro do mesmo pacote conseguem acessar. isso causou uma inconsistência no seu código.</p>
<p>quanto a segunda pergunta, o comum é sempre colocar uma visibilidade para suas classes e para seus atributos, salvos casos que apenas as classes de um determinado pacote podem ter acesso. teste o seguinte: coloque a visibilidade da classe e dos atributos como <code>public</code>. depois que os atributos estiverem públicos, tente remover a visibilidade da classe e veja o que acontece.</p>
<p>continuando o curso, você verá mais detalhes sobre o assunto, mas para mais informações, <a href="http://www.dsc.ufcg.edu.br/~jacques/cursos/p2/html/oo/visibilidade.htm" rel="nofollow">segue um link</a> onde encontra um compilado sobre o assunto.</p>
<p>espero ter ajudado!</p> <p>olá, rodrigo.</p>
<p>composição de classes é exatamente o que o nome sugere: <strong>composição</strong>.</p>
<p>já parou pra pensar como se compõe algo? ou quando algo é composto?</p>
<p>composição de classes é um conceito e a utilização de interfaces para composição é uma das técnicas usadas para isso. outra forma de composição muito utilizada que poucos conhecem é o relacionamento entre classes, onde uma classe possui uma referência (atributo) para outra classe.</p>
<p>ficou mais claro?</p> <p>deve-se compilar a classe que recebe a alteração/atualização, e executar a classe que tem o método executável, ou seja, o método main. ex:</p>
<p>javac conta.java //compilando a classe conta.</p>
<p>java programa //executando a classe programa, que executa as definições da classe conta.</p>
<p>pelo erro que vc está apontando, você está apenas misturando as duas coisas, pode-se compilar várias classes, mas apenas a do método main() pode ser executada.</p> <p>sempre que você retornar um objeto, retornará uma referência ao objeto. da mesma forma, quando você está passando um objeto, está passando uma referência. no entanto, passar um objeto como argumento <em>pode</em> ser diferente do que apenas alterar um objeto no escopo global, como mostram esses exemplos. isso ocorre porque a referência ao objeto é transmitida por valor.</p><p>se você estiver alterando os membros de um objeto, se você o passa como argumento ou apenas atualiza o objeto global não faz diferença. de qualquer maneira, você está trabalhando com o mesmo objeto.</p><p>exemplo 1:</p><pre><code>var object = {foo:'original'}; function changeobject() { object.foo = 'changed'; return object; } console.log(changeobject()); // outputs {foo:'changed'} console.log(object); // outputs {foo:'changed'} </code></pre><p>exemplo 2:</p><pre><code>var object = {foo:'original'}; function changeargument(object) { object.foo = 'changed'; return object; } console.log(changeargument(object)); // outputs {foo:'changed'} console.log(object); // outputs {foo:'changed'} </code></pre><p>por outro lado, se você estiver substituindo o objeto por um novo objeto, a alteração não persistirá se você fizer isso no argumento, mas persistirá se você fizer isso no objeto global. isso ocorre porque o argumento passa a referência ao objeto por valor. depois de substituir esse valor por uma referência a um novo objeto, você não está mais falando do mesmo objeto.</p><p>exemplo 3:</p><pre><code>var object = {foo:'original'}; function replaceobject() { object = {foo:'changed'}; return object; } console.log(replaceobject()); // outputs {foo:'changed'} console.log(object); // outputs {foo:'changed'} </code></pre><p>exemplo 4:</p><pre><code>var object = {foo:'original'}; function replaceargument(object) { object = {foo:'changed'}; return object; } console.log(replaceargument(object)); // outputs {foo:'changed'} console.log(object); // outputs {foo:'original'} </code></pre> para resolver esta questão, devemos colocar em prática nosso conhecimento sobre limite, em especial sobre suas propriedades.o limite é uma ferramenta utilizada para expor o comportamento de uma função ao se aproximar de determinados valores, além de possibilitar a definição de derivadas e a continuidade de funções. vamos supor que f(x) é uma função real e que c é um número real, teremos então o seguinte limite:esta expressão nos mostra que quando x se aproxima do valor de c, f(x) se aproxima de l, quando isto ocorre dizemos que o limite de f(x) quando x tende a c é igual a l.para melhor compreensão, iremos agora resolver um limite para que sirva de exemplo:para resolver este limite, temos que fazer com que x assuma valores cada vez mais próximos de 3: sendo assim, podemos perceber que quanto mais x se aproxima de 3, mais o limite da função se aproxima de 9, logo:para auxiliar na resolução dos limites, existem algumas propriedades que podem ser empregadas:podemos então calcular limite nos baseando no exemplo feito e utilizando as propriedades do limite. <p>oi williams,</p>
<p>com os patterns <code>decorator</code> e <code>chain of responsibility</code> é possível ter essa flexibilidade de passar &#34;infinitos&#34; objetos como parâmetro :d</p>
<p>mas no caso do <code>strategy</code> é diferente, pois a ideia é ter um objeto para executar uma lógica, sem que eles se conheçam entre si.</p> Não é exatamente o que você pediu, mas eu escrevi um Visual Studio Integration Package 2008, e se bem me lembro que eu poderia substituir o método "Add Reference", bem como herdar o "nó de referência" e, assim, mudar o seu comportamento, por exemplo seu construtor.


Esta funcionalidade pode estar faltando um add-in (que é mais limitada do que um pacote de integração), então você pode considerar escrever um pacote em seu lugar. <p>não acho que eles sejam mutuamente exclusivos, mas, nos casos em que são, você deve observar o que seus clientes desejam/precisam.</p><p>qualquer interface pode ser simplificada movendo funcionalidades complexas para outro local. eu acho que esse é o principal compromisso. para facilitar o uso para o usuário médio, você precisa torná-lo mais complicado para o usuário avançado. eles precisam fazer mais alguns cliques para obter suas coisas.</p><p>mas é claro que muitas vezes o software pode ser facilitado tanto para usuários avançados quanto para usuários casuais, sem sacrificar a usabilidade de nenhum deles. uma coisa importante é criar recursos ortogonais que possam ser combinados facilmente. muitas vezes, o software é complicado porque há muitos recursos sobrepostos. em vez disso, ao criar alguns recursos distintos que podem ser facilmente combinados, o software pode ser muito mais flexível e simples.</p><p>descobrir isso criando uma matriz de objeto/ação. liste o número de objetos diferentes no seu aplicativo ao longo de um eixo e as ações que você pode executar neles em outro eixo. a matriz não deve ser muito escassa.</p>