OFF Verdadeiro ou Falso? Fato ou Ficção?

Hum … interessante , olha soh se vc nao alocar , ficar criando variareis de instância ou alocando pilha , nao haveria problema algum, lembrando como vc nao tinha nenhuma estrutura de interrupção seu programa ficaria, funcionando ate apertar Control+C , Correto ?
Pelo q entendi vc simplesmente chamava o método novamente ou seja ele entrou em loop infinito lembrando estava em loop mas nao estava alocando mais espaço no heap nem criando ilhas de isolamento .

Procure sobre a discução sobre por que é preferivel um for do que recursividade(chamar o proprio método dentro dele mesmo até alguma condição).

É dificil ver onde realmente é necessario usar recursividade.

Você está pensando como um programador Lisp, em que o jeito de fazer tais coisas (fazer laços) é esse mesmo - fazer uma chamada recursiva a si mesmo.

Mas se você, como programador Java, fizer isso, vai acabar tendo uma chamada indiretamente recursiva ao main, e você talvez pudesse ter alguns problemas. Não está tão “errado” assim, mas abre uma lata de minhocas que você talvez não possa resolver de maneira tranquila. Para efeitos do pobre coitado que vai consertar o seu programa mais tarde (e que talvez atenda pelo nome de “Pedro”, ou seja, você) evite fazer tais coisas.

Bem como já foi citado se vc simplesmente chegasse no final e chamasse novamente o método
estaria botando seu programa em um loop infinito
sua função nunca pararia

vc teria que definir um critério de parada

usar recursividade é mais complicado do que iteratividade
neste caso realmente um laço seria mais indicado
e também nunca vi o método main chamar ele mesmo
é o ponto de entrada do programa concordo que seria errado chamar ele novamente no final

edmarr:

Hum … interessante , olha soh se vc nao alocar , ficar criando variareis de instância ou alocando pilha , nao haveria problema algum, lembrando como vc nao tinha nenhuma estrutura de interrupção seu programa ficaria, funcionando ate apertar Control+C , Correto ?
Pelo q entendi vc simplesmente chamava o método novamente ou seja ele entrou em loop infinito lembrando estava em loop mas nao estava alocando mais espaço no heap nem criando ilhas de isolamento .

Exatamente…
Ae eu colokei para a pessoa digitar 1 para voltar no início (chamava o main), e 2 para sair do programa (System.exit(0))…

pedroroxd, boa tarde!

Mostre como esta seu código (coloque no forum), acho que fica mais fácil a visualização de todos. Pode ser?
Abraços.

Eu Nem tenho mais o projeto, mas era algo do tipo:

public static void inicio() {

            Scanner meuscaner;
        meuscaner = new Scanner(System.in);
        double v1,v2,result = 0;
        int iOp = 0;

        System.out.println("Digite:");
        System.out.println("1 Para Somar");
        System.out.println("2 Para Subtrair");
        System.out.println("3 Para Multiplicar");
        System.out.println("4 Para Dividir");
        iOp = Integer.parseInt(meuscaner.nextLine().toString());

        System.out.println("Digite um valor");
        v1 = Double.parseDouble(meuscaner.nextLine().toString());
        System.out.println("Digite outro valor");
        v2 = Double.parseDouble(meuscaner.nextLine().toString());

        switch(iOp) {
            case 1: result = v1+v2; break;
            case 2: result = v1-v2; break;
            case 3: result = v1*v2; break;
            case 4: result = v1/v2; break;
        }

        System.out.println("O resultado é" + result);

        int k=0;
        System.out.println("Digite 1 para sair e 2 para voltar ao início");
        k = Integer.parseInt(meuscaner.nextLine().toString());

        switch (k) {
            case 1: System.exit(0);
            case 2: inicio(); // AQUI!!!! Eu chamava o método inicio();
        }

    }

public static void main(String[] args) {
        inicio();
    }

Vc teria problema se a cada chamada tivesse um ;

Teste n = new Teste();

Ai uma determinada hora vc estouraria a memória destinada para JVM .
Do mais vc nao teria problema nao lembrando cuidado ao usar Recursividade priorize sempre pelas Estruturas de Controle .

é mas vc tem que lembrar que vc vai estar carregando novamente o programa na memória
quando chamar o método main
e vai ser dificil mas se o cara chamar vezes suficientes o main a vc pode sobrecarregar a memoria até
disparar StackOverflowError

fazendo um loop vc terá carregado uma vez seu programa na memoria
e as variaveis que nao tem mais referencia e essas coisas o garbage collector cuida pra vc
já se chamar o main novamente num

Olha na minha mensagem assima… Nao era o método main, era o método inicio();
Ele falou que se chamasse ele, estaria errado…

Caros,

Não está errado pelo fato de ser tecnicamente inviável, mas sim pelo fato de não condizer com as melhores práticas de programação.

Primeiro que o método main deveria ser chamado apenas uma vez, ou seja, no início da execução do programa.

Quando ao fato de usar mais memória, tenho minhas dúvidas, não sendo uma justificativa tão válida.

Nenhuma recursividade, neste caso, é necessária.

Logicamente, ficaria algo assim:

Programa inicia (main)
Enquanto( não sair )
executa calculadora

Traduzindo para Java, pode ser algo assim:

public class Calculadora {

  private static boolean exit = false;

  public static void main(String[] args) {
    Calculadora calc = new Calculadora();
    while( !exit ) {
      calc.executar();
    }
  }

  public void executar() {
    //código da calculadora

    // se usuário digitar comando para sair
    exit = true;
  }
}

E, não é querer falar não, mas a galera está precisando de boas aulas de português, heim. Affff

faça um teste
crie uma classe e use o método main abaixo e rode:

public static void main(String[] args) {
     main(args);
}

vc verá que irá dar StackOverflowError

Hehe…
Olhe o código que eu postei ali em cima…

Nao era o método main, era o método inicio();
Ele falou que se chamasse ele, estaria errado…

pedroroxd, seu código não esta errado, esta chamando o método inicio() corretamente e como ele é estático, carregou apenas uma vez na memória pelo classloader.

Obs: Só tem que ver se não estoura a pilha (stack) porque tem chamada recursiva, mesmo assim, de acordo com seu código, vai demorar um bocado para estourar a pilha.

Abraços.

Fim de papo…

de qualquer maneira vc teria uma recursividade
onde a parada dependeria da ação do usuário
como foi citado não seria uma boa prática
mas funcionaria
neste caso ainda opto pelo laço hehe

eduardoac:

pedroroxd, seu código não esta errado, esta chamando o método inicio() corretamente e como ele é estático, carregou apenas uma vez na memória pelo classloader.
Abraços.

Agora vou reivindicar meus pontos para o professor!!!
hahahaha!

Usando recursividade, uma hora pode dar estouro de pilha (StackOverFlow), logo seria “errado”.

Lembrando variaveis de instancia e Objetos fica no Heap , variaveis locais fica na Pilha .

Como a recursividade era com base no que ele fornecia , acho q daqui uns 3 dias ele iria estourar a pilha. (Isto dependendo do tamanho da memoria da JVM)

Agora eu fiquei na dúvida…JVM tem uma quantidade de memória RELATIVA???
PQ “dependendo”???

:?:

Pedro na verdade, esse estilo de programação, mais se parece com o C/C++… o uso de GOTO, ficou obsoleto até mesmo em C/C++. Tenha em mente uma coisa, JAVA não é uma linguagem para ser usada somente de forma OOP e nem tão pouco somente PROCEDURAL. JAVA é um equilíbrio de tudo que há nas outras linguagens de programação.

Eu aconselho a estudar um pouco mais sobre OOP.

É comum ver um aluno novato na sala de aula tentar resolver os problemas de forma procedural em JAVA, mas isso se deve ao fato que ao longo dos anos esse estilo de programação predominou por muito tempo; até ao tempo de hoje.

O melhor a fazer é esquecer esses conceitos procedurais e foca na OOP.
Bem vindo ao mundo JAVA de ser!!

:?:

Hehe
Cada um com uma opnião diferente…
Mas pelo - agora consegui entender melhor como que funciona essa “memória”

neryxk a quantidade de memoria usada em uma JVM é…digamos configuravel…

quando vc vai executar sua classe, vc da o comando java <parametros> suaClasse… existe o parametro -Xms (acho que era algo assim), podendo ficar java -Xms512 pacote.Classe

se eu falei bestera alguém me corrija…

para o criador do tópico, eu diria que não esta errado, sendo uma aula introdutória, coisa que me parece ser por ensinar a fazer essa calculadora no dos, esta certo, se chama recursividade isso, funciona, apenas não é uma boa forma de resolver o problema, porém resolve (se fosse uma aula mais avançada, ou mesmo de boas praticas, ai eu ja consideraria que está errado e claro, isso é apenas a minha opinião)

Pedro,

Veja bem. O que vou te falar é independe da linguagem.

Para você entender os problemas do que você está pensando em fazer, é necessário que primeiro você entenda alguns conceitos.

Quando um programa é carregado na memória, ele é dividido em duas áreas, área de código e área de dados.

A área de dados, por sua vez, é dividida em Heap e Stack.

Quando você chama uma função B a partir da função A todas as variáveis locais da função A são empilhadas no Stack. Quando a chamada dessa função B termina, elas são desempilhadas para que a execução da função A continue.

O tamanho desse espaço de Stack é limitado.

Caso você chame a função B e dentro da função B ela chama a ela mesma (recursividade), as variáveis da função B são empilhadas da mesma forma.

Caso a função B chame a si mesma 1000 vezes antes de atingir a condição de parada, você vai ter TODAS as variáveis das 1000 chamadas na pilha. O coletor de lixo NÃO vai apagar, pois ele está esperando você terminar a execução dessas funções.

Somente no final, quando você atinge a condição de parada, é que as funções vão sendo desempilhadas.

Então o que acontece no seu caso é o seguinte. Você vai ocupar memória demais e, caso a quantidade de chamadas seja grande o suficiente para estourar o stack, você vai receber a mensagem de erro: “Exception in thread “main” java.lang.StackOverflowError”.

A recursividade é um recurso que deve ser usado com cuidado, mas é muito útil em alguns casos.

Espero ter ajudado.

E Daniel pega leve com a galera… hauhauahuaauha

Abraços
Wanderson

Hehe…
Ajudou sim pablosaraiva, e muito…

Não devo chamar um classe dentro de outra, isso agora é fato
Mas depois que eu lembrei, que não foi o main que eu chamei, foi o inicio();
E mesmo ele disse que tava errado…
Se quiser ver o código olhe na página anterior

Ninguem falou que não pode chamar uma classe dentro da outra. Alias, isso é super normal. O problema é a maneira como você faz isso. Se é adequado ou não. Cada caso um caso. NESTE seu caso, você não deveria usar recursividade, mas sim fazer como no exemplo que dei antes.

Não acredite em todas as besteiras que dizem por ai. Procura informações fundamentadas e bem documentadas para aprender as coisas. Aprenda bem os conceitos, pq as linguagens mudam sempre, os conceitos, em geral, são mais consolidados.

Fontes:
http://java.sun.com/j2se/reference/whitepapers/memorymanagement_whitepaper.pdf
http://www.go-java.com/blog/2007/02/23/1172235821156.html

Isso talvez explique o pq a JVM trava sempre que eu tento executar uma aplicação que captura imagem da webcam tendo em vista que o código está funfando…

Mais me diz cara É SÓ EU IR NO TERMINAL(DOS) E DIGITAR ESSES COMANDOS QUE EU “AUMENTO OU DIMINUO” A CAPACIDADE DA JVM??? E ESSE 512 QUE VC COLOCOU SERIA NO CASO A “RECONFIGURAÇÃO” DA CAPACIDADE DA MEMÓRIA???

SE NÃO FOR PEDIR DEMAIS, COMO FAÇO PRA VERIFICAR A MEMÓRIA ATUAL???

CARA, MUITO OBRIGADO MESMO… FOI DE EXCELENTE AJUDA SEU POST!!

E sobre o assunto da recursividade :

Grande abraço!

É triste pensar, em perder tempo, tentando reiventar a roda… hehehe.
Com tantos outros problemas que cercam a comunidade JAVA no Brasil, agente aqui, tentando explicar uma coisa que já é sabida por todos para um jovem que quer colocar a prova a capacidade que nós temos em desenvolver em JAVA. Se ele quer fazer assim, ele faz, não vejo problema nisso, é certo que ele sabe dos riscos que ocorrem do uso da recursividade.

xwillianss:

É triste pensar, em perder tempo, tentando reiventar a roda… hehehe.
Com tantos outros problemas que cercam a comunidade JAVA no Brasil, agente aqui, tentando explicar uma coisa que já é sabida por todos para um jovem que quer colocar a prova a capacidade que nós temos em desenvolver em JAVA. Se ele quer fazer assim, ele faz, não vejo problema nisso, é certo que ele sabe dos riscos que ocorrem do uso da recursividade.

Acho que toda argumentação é válida, independente se é “obsoleta” ou não, o que acontece é que ninguém é melhor que ninguém, devemos ter humildade antes de tudo…
Eu concordo com o cara que disse acima que isso tem mais haver com boas práticas de programação. Infelizmente boas práticas de programação só são aprendidas praticando! O nosso amigo disse que estava no início da aprendizagem, talvez (agora to especulando), ele nem sabia que tinha feito uma recursão, essa simplesmente foi a lógica que ele uso para fazer seu programa funcionar.
Eu acho que o professor só não foi feliz quando disse que estava errado, o programa compila e funciona, não está errado, somente não está condizente com o que boas práticas de programação sugerem…

renamed:

Acho que toda argumentação é válida, independente se é “obsoleta” ou não, o que acontece é que ninguém é melhor que ninguém, devemos ter humildade antes de tudo…
Eu concordo com o cara que disse acima que isso tem mais haver com boas práticas de programação. Infelizmente boas práticas de programação só são aprendidas praticando! O nosso amigo disse que estava no início da aprendizagem, talvez (agora to especulando), ele nem sabia que tinha feito uma recursão, essa simplesmente foi a lógica que ele uso para fazer seu programa funcionar.
Eu acho que o professor só não foi feliz quando disse que estava errado, o programa compila e funciona, não está errado, somente não está condizente com o que boas práticas de programação sugerem…

Gostei do Comentário .

Por favor, evite as letras maiúsculas. Fica horrível de ler.

A VM tem por padrão um heap de no máximo 64mb. O parâmetro informado pelo colega aumenta esse padrão.

Você pode testar o tamanho total de memória disponível com o comando:

Runtime.getRuntime().totalMemory()

E o tamanho livre disponível com o comando:

Runtime.getRuntime().freeMemory()

Quanto ao problema do post, não creio que isso se resuma a má prática. Não existe uma condição de término certa para a calculadora, nem houve o reconhecimento dessa limitação por parte do programador, portanto, um dia, poderia haver o StackOverflowError. E seria extremamente frustrante para a equipe de programação esse erro, já que só aparece de vez enquando (ainda bem que o Java é bem descritivo, mas no C++ isso poderia se tornar uma enorme dor de cabeça).

O professor, claro, perdeu uma ótima oportunidade de explicar a técnica de recursividade e seus problemas, e porque isso seria prejucial para o caso desse exercício. De qualquer forma, se eu fosse esse professor, não descontaria nota.

Ou, se fosse descontar, seria pouquíssima. É lógico que o objetivo disfarçado do professor era avaliar se o aluno sabia usar alguma estrutura de repetição, mas como não disse isso explicitamente no enunciado, não pode descontar muita nota.

Mark_Ameba:

Procure sobre a discução sobre por que é preferivel um for do que recursividade(chamar o proprio método dentro dele mesmo até alguma condição).

É dificil ver onde realmente é necessario usar recursividade.

na verdade não… grandes algoritimos que usam “dividir para consquistar” usam recursividade como o quicksort por exemplo…
a recursividade te da um poder muito grande mas deve saber usa-la corretamente…

luistiagos:

Mark_Ameba:

Procure sobre a discução sobre por que é preferivel um for do que recursividade(chamar o proprio método dentro dele mesmo até alguma condição).

É dificil ver onde realmente é necessario usar recursividade.

na verdade não… grandes algoritimos que usam “dividir para consquistar” usam recursividade como o quicksort por exemplo…
a recursividade te da um poder muito grande mas deve saber usa-la corretamente…

Inté.

KWill:

luistiagos:

na verdade não… grandes algoritimos que usam “dividir para consquistar” usam recursividade como o quicksort por exemplo…
a recursividade te da um poder muito grande mas deve saber usa-la corretamente…

Ei, usando pilhas dá para criar um quicksort iterativo, como fica a sua afirmação?

Inté.

Usando pilhas os efeitos colaterias são os mesmos dos algoritmos recursivos. Além da implementação ser mais trabalhosa.

Algoritmos iterativos são bons quando você não precisa manter os estados das iterações anteriores. Recursivos são melhor usados quando você quer mantê-los.

renamed:

xwillianss:

É triste pensar, em perder tempo, tentando reiventar a roda… hehehe.
Com tantos outros problemas que cercam a comunidade JAVA no Brasil, agente aqui, tentando explicar uma coisa que já é sabida por todos para um jovem que quer colocar a prova a capacidade que nós temos em desenvolver em JAVA. Se ele quer fazer assim, ele faz, não vejo problema nisso, é certo que ele sabe dos riscos que ocorrem do uso da recursividade.

Acho que toda argumentação é válida, independente se é “obsoleta” ou não, o que acontece é que ninguém é melhor que ninguém, devemos ter humildade antes de tudo…
Eu concordo com o cara que disse acima que isso tem mais haver com boas práticas de programação. Infelizmente boas práticas de programação só são aprendidas praticando! O nosso amigo disse que estava no início da aprendizagem, talvez (agora to especulando), ele nem sabia que tinha feito uma recursão, essa simplesmente foi a lógica que ele uso para fazer seu programa funcionar.
Eu acho que o professor só não foi feliz quando disse que estava errado, o programa compila e funciona, não está errado, somente não está condizente com o que boas práticas de programação sugerem…

Opa…
Valew ae
Sou iniciante em java mesmo… E é praticando que se aprende novas práticas de programação…
humildade é tudo

Bom…
Depois de tantos posts…
Vou dar como OFF…
Mas se alguém quiser acresentar algo de importante que outros não falarem, fiquem a vontade…
Assim eu aprendo +

Como seu programinha é de algoritimo simples e de pequeno porte.
Não teriam problemas, mas se esse fosse um programa de grande estrutura e fize-se um grande número de chamadas ao método, que talves utiliza-se de declaração de objetos não declarados para toda a classe, o desempenho da máquina cairia antes da passagem do bargage colector.

em C isso não ocorreria e sua aplicação seria mais correta que o uso de laços.

Pois poderia fazer a desabilitação do que era da última execução.

Sua aplicação seria a corretamente utilizada em uma interface gráfica em que o processo ou a Thread poderia ser executada e finalizada sequêncialmente

Opa…
Vlw pela dica DavidUser…

Com os computadores de hoje, com essa quantidade de memória, até acho que meu programinha humilde não faria diferença… (MINHA OPINIÃO)

Mas na verdade eu não chamei o método main, e sim o inicio();
(olhe na página 1 / o post número 8, lá tem o código), o que deu a entender por aqui, que estava correto…

Não tem um geito de limpar a memória que não está sendo utilizada de tempos em tempos em uma Thread?

Jeito tem… o Garbage Collector faz isso para você.

Mas o problema da sua recursividade não é limpar memória não usada, mas sim estourar a pilha de memória em uso.

Não adianta teimar. Confia na gente!

Lembrando , vc pode solicitar que o GC faça isto pra vc , mas ele pode nao achar necessario e nao fazer .

A propia VM , faz a coleta quando se acha necessario .

UHAhuAHUhau
Hihi
Vlw pelo esclarecimento ;D

neeryck:

maior_abandonado:

quando vc vai executar sua classe, vc da o comando java <parametros> suaClasse… existe o parametro -Xms (acho que era algo assim), podendo ficar java -Xms512 pacote.Classe

Isso talvez explique o pq a JVM trava sempre que eu tento executar uma aplicação que captura imagem da webcam tendo em vista que o código está funfando…

Mais me diz cara É SÓ EU IR NO TERMINAL(DOS) E DIGITAR ESSES COMANDOS QUE EU “AUMENTO OU DIMINUO” A CAPACIDADE DA JVM??? E ESSE 512 QUE VC COLOCOU SERIA NO CASO A “RECONFIGURAÇÃO” DA CAPACIDADE DA MEMÓRIA???

SE NÃO FOR PEDIR DEMAIS, COMO FAÇO PRA VERIFICAR A MEMÓRIA ATUAL???

CARA, MUITO OBRIGADO MESMO… FOI DE EXCELENTE AJUDA SEU POST!!

E sobre o assunto da recursividade :

Grande abraço!

bom… parece que o vini_godoy ja respondeu (muito melhor do que eu faria inclusive), eu não tinha visto a pergunta, por isso não tinha respondido até então.

apenas mais uma coisa a acrescentar, esse ajuste de memoria na hora que você executa o programa, serve apenas para essa chamada de programa, ou seja, apenas para essa execução da JVM, outros softwares rodando na JVM ainda usam a configuração padrão da memoria.

em duvida quanto a isso da um java -X no dos e le as opções de parametros.

C:\Users\pepi>java -x
‘java-x’ não é reconhecido como um comando interno
ou externo, um programa operável ou um arquivo em lotes.

O_o

Ps: Windows Vista…

pedroroxd:

C:\Users\pepi>java -x
‘java-x’ não é reconhecido como um comando interno
ou externo, um programa operável ou um arquivo em lotes.

O_o

Ps: Windows Vista…

java -X

PS … verifique seu path
configure usando o seguinte link

http://www.guj.com.br/article.show.logic?id=163

java -X deu na mesma…
vou ver seu link…

Se eu não tiver esse negoço tem algum problema?
Java funciona direitinho aqui…
Mas o comando java -X não executa…

Esse J2SE é realmente necessário?
Qual a funcionalidade dele?

C:\>java -X
    -Xmixed           mixed mode execution (default)
    -Xint             interpreted mode execution only
    -Xbootclasspath:<directories and zip/jar files separated by ;>
                      set search path for bootstrap classes and resources
    -Xbootclasspath/a:<directories and zip/jar files separated by ;>
                      append to end of bootstrap class path
    -Xbootclasspath/p:<directories and zip/jar files separated by ;>
                      prepend in front of bootstrap class path
    -Xnoclassgc       disable class garbage collection
    -Xincgc           enable incremental garbage collection
    -Xloggc:<file>    log GC status to a file with time stamps
    -Xbatch           disable background compilation
    -Xms<size>        set initial Java heap size
    -Xmx<size>        set maximum Java heap size
    -Xss<size>        set java thread stack size
    -Xprof            output cpu profiling data
    -Xfuture          enable strictest checks, anticipating future default
    -Xrs              reduce use of OS signals by Java/VM (see documentation)
    -Xcheck:jni       perform additional checks for JNI functions
    -Xshare:off       do not attempt to use shared class data
    -Xshare:auto      use shared class data if possible (default)
    -Xshare:on        require using shared class data, otherwise fail.

The -X options are non-standard and subject to change without notice.

As opções -XX, por outro lado, dependem da versão do JDK que está sendo usada.
Para uma lista parcial delas (existem algumas que realmente não estão documentadas), olhe:
http://java.sun.com/javase/technologies/hotspot/vmoptions.jsp

hehe…
nem vo instalar não…
amanha vo formatar e colocar ubuntu aki…

pedroroxd:

hehe…
nem vo instalar não…
amanha vo formatar e colocar ubuntu aki…

espero que sim…
meus colegas usam ubuntu, tem uns que já acostumaram, mas falaram que no início é meio chato…

Sou novato, mas prefiro o linux sem saber usar do q essa bosta de windows hAhuAHUhua

Hum… vou responder baseado no que eu vi nas primeiras paginas.

Antes do main ser executado existe a execução do bloco estático (se existir) da classe em questão.

Seria possível vc chamar o método estático main recursivamente com pouco uso de recursos se vc inicializasse, por exemplo, os objetos e variáveis necessários para o controle do seu programa nesse bloco estático. Ainda assim vc vai ter q lidar com o fato que empilhar chamadas recursivas de métodos alocam memória e isso é um recurso finito.

Entretanto nada obriga vc a chamar o main de forma recursiva. A chamada do main pode estar associado a um evento, não necessariamente um empilhamento ou loop externo. Nesse caso o ‘main’ não é um bom exemplo mas uma chamada a um método chamado, sei la, ‘eval’ sim.

2 [ empilha ]

• [empilha ]
  2 [ empilha ]
  = [invoca eval(pilha)]