Como corrigir java.lang.UnsupportedClassVersionError: Versão major.minor não suportada

Estou tentando usar o Notepad ++ como minha ferramenta multifuncional editar, executar, compilar etc.

Eu tenho o JRE instalado e configurei minha variável de caminho para o .../bindiretório

Quando executo o meu "Hello world" no Notepad ++, recebo esta mensagem:

java.lang.UnsupportedClassVersionError: test_hello_world :
 Unsupported major.minor version 51.0
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClassCond(Unknown Source)
       .........................................

Eu acho que o problema aqui é sobre versões; algumas versões do Java podem ser antigas ou muito novas.

1. Como faço para corrigir isso?
2. Devo instalar o JDK e configurar minha variável de caminho para o JDK em vez do JRE?
3. Qual é a diferença entre a PATHvariável no JRE ou JDK?

O número da versão mostrado descreve a versão do JRE com a qual o arquivo de classe é compatível.

Os principais números relatados são:

Java SE 14 = 58,
Java SE 13 = 57,
Java SE 12 = 56,
Java SE 11 = 55,
Java SE 10 = 54,
Java SE 9 = 53,
Java SE 8 = 52,
Java SE 7 = 51,
Java SE 6.0 = 50,
Java SE 5.0 = 49,
JDK 1.4 = 48,
JDK 1.3 = 47,
JDK 1.2 = 46,
JDK 1.1 = 45

(Fonte: Wikipedia )

Para corrigir o problema real, você deve tentar executar o código Java com uma versão mais recente do Java JRE ou especificar o parâmetro de destino no compilador Java para instruir o compilador a criar código compatível com versões anteriores do Java.

Por exemplo, para gerar arquivos de classe compatíveis com Java 1.4, use a seguinte linha de comando:

javac -target 1.4 HelloWorld.java

Nas versões mais recentes do compilador Java, é provável que você receba um aviso sobre o caminho da classe de autoinicialização não estar definido. Mais informações sobre esse erro estão disponíveis em uma postagem no blog. Novo aviso javac para definir uma fonte mais antiga sem o caminho de inicialização .

java.lang.UnsupportedClassVersionError acontece devido a um JDK mais alto durante o tempo de compilação e JDK mais baixo durante o tempo de execução.

No Eclipse, eu apenas fui ao comando de menu Janela -> Preferências -> Java -> Compilador e, em seguida, defina "Nível de conformidade do compilador" como 1,6.

Não se preocupe, eu resolvi isso.

Na verdade, é simples - você precisa instalar o JRE / JDK com a mesma versão.

JRE 6 -> JDK 6

JRE 7 -> JDK 7

E assim por diante.

Este erro significa que você está tentando carregar um arquivo "classe" Java que foi compilado com uma versão mais recente do Java que você instalou.

Por exemplo, seu .classarquivo poderia ter sido compilado para o JDK 7 e você está tentando executá-lo com o JDK 6.

Portanto, a solução é:

• Atualize seu tempo de execução Java ou

• Recompile a classe se você tiver a fonte, usando seu compilador Java local (se você tiver um).

  javac FileName.java

Para desenvolvedores, isso pode acontecer se outro desenvolvedor fizer o check-in de um arquivo .class e eles tiverem uma versão mais recente do java do que a sua!

Você está tentando executar seu programa com uma versão Java que não suporta a versão na qual o código foi compilado. Então, basicamente, você deve ter compilado seu código com uma versão superior e tentando executá-lo usando uma versão inferior.

Como você está recebendo

Unsupported major.minor version 51.0

e a versão 51.0 corresponde ao J2SE 7, você provavelmente compilou seu código no Java 7 e tentou executá-lo usando uma versão inferior. Verifique o que é java -versionexibido. Deve ser a versão Java 7. Caso contrário, faça as alterações apropriadas no PATH / JAVA_HOME. Ou você pode compilar com a mesma versão que está tentando executar o código. Se as configurações são confusas, você sempre pode fornecer o caminho absoluto /home/user/jdk1.7.0_11/bin/javace /home/user/jdk1.7.0_11/bin/java.

Eu tive uma situação semelhante no Mac e o seguinte processo funcionou para mim:

No terminal, digite

vi ~/.profile

Em seguida, adicione esta linha no arquivo e salve

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk<version>.jdk/Contents/Home

onde a versão é a do seu computador, como 1.7.0_25.

Saia do editor e digite o seguinte comando para torná-lo eficaz

source ~/.profile 

Em seguida, digite java -version para verificar o resultado

java -version 

O que é um .profilearquivo?

O arquivo .profile é um arquivo oculto. É um arquivo opcional que informa ao sistema quais comandos serão executados quando o usuário cujo arquivo de perfil está logado. Por exemplo, se meu nome de usuário for bruno e houver um arquivo .profile em / Users / bruno /, todo o seu conteúdo será executado durante o procedimento de login.

Fonte: http://computers.tutsplus.com/tutorials/speed-up-your-terminal-workflow-with-command-aliases-and-profile--mac-30515

No menu do Eclipse, Janela -> Preferências -> Java -> Compilador, verifique também "Definir configurações específicas do projeto".

Se você ainda tiver o erro com a mesma versão Java: tente excluir a pasta de construção do seu projeto manualmente. Em seguida, reinicie o Eclipse.

Você pode ter alguma biblioteca JAR compilada no Java 7 e possui apenas o Java 6 como Java Runtime. Isso pode acontecer com algumas novas bibliotecas.

O problema mais comum é a configuração incorreta de sua JAVA_HOMEvariável, que deve apontar para a biblioteca correta do Java Development Kit, se você instalou várias.

Para descobrir onde a pasta Java do SDK está localizada, execute os seguintes comandos:

jrunscript -e 'java.lang.System.out.println(java.lang.System.getProperty("java.home"));'

Debian / Ubuntu

Para verificar qual java (openjdk) você instalou, verifique via:

dpkg -l "openjdk*" | grep ^i

ou:

update-java-alternatives -l

Para alterar, use:

update-alternatives --config java

^{Prefixo com, sudose necessário.}

para selecionar a versão java alternativa.

Ou verifique quais estão disponíveis para instalação:

apt-cache search ^openjdk

^{Prefixo com, sudose necessário.}

Então você pode instalar, por exemplo:

apt-get install openjdk-7-jre

^{Prefixo com, sudose necessário.}

Fedora, Oracle Linux, Red Hat

Instale / atualize o pacote apropriado via:

yum install java-1.7.0-openjdk java-1.7.0-openjdk-devel

O java-1.7.0-openjdkpacote contém apenas o Java Runtime Environment. Se você deseja desenvolver programas Java, instale o java-1.7.0-openjdk-develpacote.

BSD

Existe um pacote OpenJDK 7 na coleção de Ports do FreeBSD chamado openjdk7 que provavelmente precisa ser reconfigurado.

Veja: Página wiki do OpenJDK .

janelas

Basta instalar a biblioteca Java SE Development Kit apropriada no site Oracle ou instalar

Jenkins

Se você está enfrentando esse problema com o Jenkins, consulte:

• JENKINS-30561 - Não foi possível iniciar o agente usando SSH

No entanto, a seleção da versão correta do Java (mais recente) com update-alternativesdeve funcionar.

Eu enfrentei o mesmo problema quando estava trabalhando com um script Ant para criar meu aplicativo.

Eu uso o Eclipse no meu desenvolvimento de aplicativos e alterei a versão do compilador nas propriedades de construção do projeto. Mas isso não funcionou para mim. Então eu descobri que posso fornecer a versão do compilador no script Ant.

Modifiquei o script Ant na seção em que ele compila arquivos Java.

<target name="build-java" depends="prepare-build">
    <echo message="Compiling java files"/>
    <javac ....
           target="1.5"...
    </javac>
</target>

Isso funcionou para eu resolver o principal problema menor não suportado.

Quando instalei o JDK 1.7, o problema foi resolvido.

Eu tive o mesmo problema com um projeto escrito em 1.7 e tentei executar em 1.6.

Minha solução no Eclipse:

• Clique com o botão direito do mouse em Propriedades do Projeto -> Caminho de Construção Java -> Bibliotecas

• Selecione sua Biblioteca do sistema JRE e clique em Editar à direita e escolha o JRE de destino.

• Agora vá para o Java Compiler à esquerda e altere o nível de conformidade do Compiler para o seu destino.

Isso funcionou para mim.

Conforme respondido em outras partes por várias pessoas, o programa Java está sendo executado em uma versão mais antiga do Java que aquela para a qual foi compilado. Ele precisa ser "compilado" para compatibilidade com versões anteriores. Em outras palavras, há uma incompatibilidade entre as versões Java de origem e de destino.

A alteração das opções nos menus do Eclipse não responde ao pôster original, que disse que ele / ela não está usando o Eclipse. No OpenJDK javac versão 1.7, é possível compilar o pacote cruzado para 1.6 se você usar parâmetros -sourcee -target, além disso, fornecer o arquivo rt.jar da versão de destino (ou seja, a mais antiga) em tempo de compilação. Se você realmente instalar o JRE 1.6, poderá apontar para sua instalação (por exemplo, /usr/lib/jvm/java-6-openjdk-i386/jre/lib/rt.jar no Ubuntu, / usr / jdk / jdk1. Aparentemente, 6.0_60 / jre / lib / rt.jar no SunOS. Desculpe, não sei onde ele está no sistema Windows). Igual a:

javac -source 1.6 -target 1.6 -bootclasspath /usr/lib/jvm/java-6-openjdk-i386/jre/lib/rt.jar HelloWorld.java

Parece que você pode simplesmente baixar o rt.jar da Internet e apontar para ele. Isso não é muito elegante:

javac -source 1.6 -target 1.6 -bootclasspath ./rt.jar HelloWorld.java

Com base nisso...

J2SE 8 = 52
J2SE 7 = 51
J2SE 6.0 = 50
J2SE 5.0 = 49
JDK 1.4 = 48
JDK 1.3 = 47
JDK 1.2 = 46
JDK 1.1 = 45

No Eclipse, clique com o botão direito do mouse no projeto no package explorer:

Caminho de Construção -> Configurar Caminho de Construção

Debaixo:

Caminho de Construção Java -> Bibliotecas -> Adicionar Biblioteca -> Biblioteca do Sistema JRE -> JREs Instalados -> Pesquisa .

Inclua o JRE necessário, selecionando a biblioteca na lista disponível após a conclusão da pesquisa.

• Se você usa o Maven, defina seu nível de compilação Java. Abra uma linha de comando e escreva java -versionpara o seu nível de compilação:

  

• Se você usar o IntelliJ IDEA, selecione projeto → Arquivo → Configurações → Implementar Execução de Execução → Compilador → Java Compiler . Altere o código de bytes como 1.7, como esta imagem:

  

Se você enfrentar esse problema ao usar o Maven , poderá compilar seu código usando o plug-in Maven Compiler .

 <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
       .....

UPDATE: defina sourcee targetcomo 1.8, se você estiver usando o JDK 8.

Eu tive a mesma mensagem de erro ao executar o Ant no Eclipse, mas as outras soluções mencionadas aqui não resolveram o meu problema. O engraçado é que a execução do Ant a partir da linha de comando do Windows estava funcionando bem, portanto, tinha que haver um problema de configuração no Eclipse.

Descobriu-se que no Eclipse você pode especificar o ambiente com o qual o Ant deve estar executando e isso foi definido como um JRE em vez de um JDK.

• Vá para: Executar -> Ferramentas Externas -> Configurações de Ferramentas Externas ...
• Selecione o Ant build.xml para o seu projeto (se você tiver vários projetos)
• Ative a guia 'JRE'
• Aqui foi selecionado 'JRE separado: jre6'. Quando mudei isso para um JDK da série 1.6 ou 1.7, o erro desapareceu.

Como faço para corrigir isso?

Esse erro significa que o JRE que está sendo usado para executar o código da classe não reconhece a versão do Java usada. Geralmente porque a versão do Java que gerou o seu arquivo de classe (ou seja, o compilou) é mais recente.

Para corrigi-lo, você pode

a) Compile suas fontes Java com a mesma versão ou mais antiga do compilador Java que será usada para executá-lo. ou seja, instale o JDK apropriado.

b) Compile suas fontes Java com a versão mais recente do compilador Java, mas no modo de compatibilidade. ou seja, use o -targetparâmetro

c) Execute suas classes compiladas em um JRE com a mesma versão ou mais recente que o JDK usado para compilar as classes.

Você pode verificar as versões que está usando no momento javac -versionpara o compilador e java -versiono tempo de execução.

Devo instalar o JDK e configurar minha variável PATH para o JDK em vez de JRE?

Para a compilação, certamente, instale e configure o JDK específico que você deseja.

Para tempo de execução, você pode usar o que acompanha o JDK ou um JRE independente, mas independentemente, verifique se instalou as versões corretas e se configurou seu PATH para que não haja surpresas.

Qual é a diferença entre a variável PATH no JRE ou JDK?

A variável de ambiente PATH diz ao shell de comandos onde procurar o comando digitado. Ao digitar java, o interpretador de shell de comando procurará em todos os locais especificados na PATHvariável, da esquerda para a direita, para encontrar o javaexecutável apropriado para executar. Se você possui várias versões do Java instaladas - ou seja, você tem ojava executável em vários locais especificados na variável PATH, o primeiro encontrado ao passar da esquerda para a direita será o que é executado.

O comando do compilador é javace só vem com o JDK. O comando runtime está javae vem com o JDK e está no JRE.

É provável que você tenha uma versão (51.0 = Java 7) javacinstalada e também tenha a mesma versão javainstalada, mas outra versão anterior javaestá aparecendo anteriormente no PATH e, portanto, está sendo invocada em vez da que você espera .

Você usou uma versão superior do JDK para compilar e tentar executar a partir de uma versão inferior do JDK / JRE .

Para verificar isso, consulte as informações da versão:

javac -version

java -version

Eles serão diferentes e o javac terá um número de versão maior.

Para contornar isso, execute usando java da versão JDK ou se você tiver um JRE / JDK mais recente que também funcione.

which javacdirá a localização, por exemplo /usr/bin/javac,. Basta executar diretamente usando /usr/bin/java <program>.

OU você pode definir a variável de ambiente como uma solução permanente.

Tive esse problema ao reverter para o Java 6 e tentar executar as classes compiladas anteriormente com o Java 7. O que funcionou para mim foi Preferências> java> compilador -> definir o nível de conformidade para 1,6 e, crucialmente, "definir configurações do projeto".

Hoje, essa mensagem de erro apareceu no nosso Tomcat 7 no Ubuntu 12.04.2 LTS (Precise Pangolin):

/var/log/tomcat7/localhost.2014-04-08.log:
8 / abr / 2014 9:00:55 AM org.apache.catalina.core.StandardContext filterStart
SEVERE: exceção ao iniciar o filtro struts2
java.lang.UnsupportedClassVersionError: controller / ReqAccept: major.minor versão 51.0 não suportada (não é possível carregar o controlador de classe.ReqAccept)

O aplicativo Struts é compilado com o Java 7.

Acabou que alguém usa "service tomcat [stop / start]" para reiniciar o Tomcat 7,

$ ps -ef | grep java
tomcat7 31783 1 32 20:13? 00:00:03 / usr / lib / jvm / java padrão / bin / java ...
$ / usr / lib / jvm / java padrão / bin /
java - versão de versão "1.6.0_27"

O que causa o erro "Não suportado major.minor versão 51.0".

Quando usamos "/etc/init.d/tomcat7 [stop / start]" para reiniciar o Tomcat 7, o problema foi resolvido.

$ ps -ef | grep java
tomcat7 31886 1 80 20:24? 00:00:10 /usr/local/java/jdk1.7.0_15/bin/java
$ /usr/local/java/jdk1.7.0_15/bin/java -version
versão java "1.7.0_15"

Eu resolvi isso. Eu corri:

JAVA_HOME=/usr/lib/jvm/java-7-openjdk-i386

O erro é enganoso Unsupported major.minor version 51.0,. Isso dá a impressão de que a versão 51 (Java 7) não é suportada. E devemos usar o Java 6.

O erro deveria ter sido:

A versão atual do Java, 50, não é suportada. Use a versão 7 do Java (51: 0 e superior).

Seu arquivo Java é compilado com uma versão diferente (versão superior do compilador) da versão (versão inferior do tempo de execução) com a qual você está tentando executá-lo.

É entendimento básico de que as classes compiladas com versões inferiores devem ser executadas nas versões superiores posteriores. Mas o oposto (compilado com a versão mais alta do compilador e tentando executá-lo com a versão mais baixa de tempo de execução) não é possível às vezes.

Portanto, este erro é mostrado ao tentar executar seu programa. Major.minor versão xx não suportada

P: Criei um aplicativo em Java 7, mas quando meus usuários tentam executá-lo, eles recebem um erro Major.minor versão 51.0 não suportado. O que isso significa e o que posso fazer sobre isso?

R: Se você compilar um aplicativo usando javac no Java 7, os arquivos de classe resultantes terão o número da versão 51.0. As versões do Java anteriores ao 7 não reconhecem esse número, portanto, seus usuários terão que atualizar para o Java 7 antes de executar seu aplicativo. Se você não estiver usando nenhuma API Java 7, poderá tentar compilar seu aplicativo usando javac -target 1.6 para criar um arquivo de classe compatível com 1.6. Se seu aplicativo for implantado usando o webstart, você poderá especificar a versão mínima necessária. Para obter mais informações, consulte os documentos sobre Java Web Start e JNLP aqui. Esse problema desaparecerá assim que acionarmos a atualização automática para o Java 7 para usuários finais que possuem o Java 6 em seus desktops. O cronograma para isso ainda não foi determinado. Queremos dar aos desenvolvedores tempo para resolver quaisquer problemas entre o código e o JDK 7 primeiro.

(Fonte: oracle.com .)

Oh, o Mac OS XI conseguiu resolver esse problema configurando a variável JAVA_HOME:

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.7.0_75.jdk/Contents/Home

Primeiro, vamos acertar no básico ...

O JRE é um componente do NetBeans / Eclipse / autônomo que fornecerá bibliotecas, JVM, plug-ins Java e Java web start. Observe que ele não fornece complementadores ou depuradores.

O JDK é o superconjunto do JRE, juntamente com complementadores e depuradores.

Portanto, quando você tiver sua biblioteca padrão como um JRE em vez de JDK, terá um bom tempo importando coisas, mas ela não será compilada.

Em vez disso, defina seu caminho como JDK (eu uso o NetBeans, e eu os defino usando netbeans.conf em netbeans / etc / netbeans.conf e altere o caminho).

Eu tive o problema pelo qual estava tendo que executar uma compilação do Maven no meu projeto a partir da linha de comando para executar meus testes de unidade; se eu fiz uma alteração na classe de teste e deixei o Eclipse recompilar automaticamente, obtive o erro "Unsupported major.minor version 51.0".

Eu tenho o JDK6 e o ​​JDK7 instalados, mas todas as minhas configurações do JRE estavam apontando para 1.6, tanto no pom quanto na página de propriedades do projeto no Eclipse. Nenhuma quantidade do Maven Update Project e / ou atualização resolveu isso.

Finalmente, tentei fechar o projeto e reabri-lo, e isso pareceu corrigi-lo! HTH

Você compilou sua classe Java com o JDK 7 e está tentando executar a mesma classe no JDK 6.

• Instale o JDK 7.0.55 e configure o Java for Eclipse para JDK 7.0.55.
• Crie o projeto com o JDK 7.0.55, configurando no caminho de construção JDK 7.0.55.
• Defina o compilador no Eclipse para JDK 7.0.55 pelo menu Windows -> Preferências -> Java -> Compilador - escolha 1.7.

A resposta é para o problema:

Exceção no encadeamento "main" java.lang.UnsupportedClassVersionError: edu / stevens / cs549 / dhts / main / LocalContext: major.minor não suportado, versão 52.0

Eu estava tendo o mesmo problema. Para aqueles que estavam tendo esse problema nas instâncias do AWS ec2 e de alguma forma foram redirecionados aqui para esta pergunta. Estou respondendo por isso e gostaria de compartilhar como fiz. Eu estava com problemas porque as instâncias do Amazon EC2 estavam executando o java versão 1.7 e talvez meu projeto não fosse compatível porque estava usando o Maven e meio que foi pré-configurado para o java 1.8. Então eu instalei a nova versão do java:

sudo yum -y install java-1.8.0

E o passo importante é remover a versão mais antiga:

sudo yum remove java-1.7.0-openjdk

Lembre-se de excluí-lo após instalar a nova versão, caso contrário, ele continuaria usando a mesma versão anterior e espero que resolva o seu problema, o que ocorreu no meu caso.