Java no support class

Constructs a SQLFeatureNotSupportedException object with a given reason , SQLState , vendorCode and cause .

Method Summary

Methods declared in class java.sql.SQLException

Methods declared in class java.lang.Throwable

Methods declared in class java.lang.Object

Methods declared in interface java.lang.Iterable

Constructor Detail

SQLFeatureNotSupportedException

public SQLFeatureNotSupportedException()

Constructs a SQLFeatureNotSupportedException object. The reason , SQLState are initialized to null and the vendor code is initialized to 0. The cause is not initialized, and may subsequently be initialized by a call to the Throwable.initCause(java.lang.Throwable) method.

SQLFeatureNotSupportedException

Constructs a SQLFeatureNotSupportedException object with a given reason . The SQLState is initialized to null and the vendor code is initialized to 0. The cause is not initialized, and may subsequently be initialized by a call to the Throwable.initCause(java.lang.Throwable) method.

SQLFeatureNotSupportedException

Constructs a SQLFeatureNotSupportedException object with a given reason and SQLState . The cause is not initialized, and may subsequently be initialized by a call to the Throwable.initCause(java.lang.Throwable) method. The vendor code is initialized to 0.

SQLFeatureNotSupportedException

public SQLFeatureNotSupportedException(String reason, String SQLState, int vendorCode)

Constructs a SQLFeatureNotSupportedException object with a given reason , SQLState and vendorCode . The cause is not initialized, and may subsequently be initialized by a call to the Throwable.initCause(java.lang.Throwable) method.

SQLFeatureNotSupportedException

Constructs a SQLFeatureNotSupportedException object with a given cause . The SQLState is initialized to null and the vendor code is initialized to 0. The reason is initialized to null if cause==null or to cause.toString() if cause!=null .

SQLFeatureNotSupportedException

Constructs a SQLFeatureNotSupportedException object with a given reason and cause . The SQLState is initialized to null and the vendor code is initialized to 0.

SQLFeatureNotSupportedException

public SQLFeatureNotSupportedException(String reason, String SQLState, Throwable cause)

Constructs a SQLFeatureNotSupportedException object with a given reason , SQLState and cause . The vendor code is initialized to 0.

SQLFeatureNotSupportedException

public SQLFeatureNotSupportedException(String reason, String SQLState, int vendorCode, Throwable cause)

Constructs a SQLFeatureNotSupportedException object with a given reason , SQLState , vendorCode and cause .

Report a bug or suggest an enhancement
For further API reference and developer documentation see the Java SE Documentation, which contains more detailed, developer-targeted descriptions with conceptual overviews, definitions of terms, workarounds, and working code examples.
Java is a trademark or registered trademark of Oracle and/or its affiliates in the US and other countries.
Copyright © 1993, 2023, Oracle and/or its affiliates, 500 Oracle Parkway, Redwood Shores, CA 94065 USA.
All rights reserved. Use is subject to license terms and the documentation redistribution policy.

Источник

How to Fix the Unsupported Class Version Runtime Error in Java

Runtime errors occur when a program is being executed and, in the case of compiled languages, after the program has been successfully compiled. Runtime errors are, therefore, harder to detect and prevent than compile-time errors [1]. In Java, some of these runtime errors (namely throwable objects which are not exceptions) are triggered at a very early stage, while the program is basically starting up. Namely, there is a process of dynamic loading, linking, and initializing of classes and interfaces by the Java Virtual Machine (JVM) that occurs at the very beginning of execution of any Java application [2]. This allows for a certain category of errors to be captured and dealt with before the program effectively starts.

This category of high level runtime errors in Java is represented by classes which are direct descendants of the java.lang.Error class [3], including the java.lang.LinkageError class which denotes errors occurring during the aforementioned startup process [4]. An instance of the Error class (or any of its subclasses) is a throwable object that a program is not expected or advised to handle, but instead, should cause immediate termination of the program. This is because most of these errors occur as a result of abnormal conditions, often so severe that it is impossible to know or control what further execution of the program might do. LinkageError instances in particular indicate critical class-related errors triggered during the class linking phase of the startup process, usually as a consequence of some post-compilation changes in the bytecode or the Java environment.

What is the UnsupportedClassVersionError Error and Why Does it Happen?

The java.lang.UnsupportedClassVersionError class extends java.lang.ClassFormatError which is thrown whenever the JVM attempts to read a class file and determines that the file is malformed or otherwise cannot be interpreted as a class file [5][6]. As per Java’s error class hierarchy (Figure 1), an instance of UnsupportedClassVersionError is also a LinkageError which means that the error is identified during the JVM class linking process.

The specific issue that the UnsupportedClassVersionError error raises is the detection of a class file which had been compiled with a newer version of Java than the one used to run it. For instance, if a specific .class file has been compiled with Java Development Kit (JDK) 15, trying to run it with Java Runtime Environment (JRE) 8 will trigger the UnsupportedClassVersionError error. This almost invariably happens when someone attempts to run a program with a JDK or a JRE version that is incompatible with, i.e., lower than the Java version in which the code was compiled.

How to Fix the UnsupportedClassVersionError Error

The solution to the UnsupportedClassVersionError error generally boils down to two options:

Run the code with a newer version of Java/JRE, or
Recompile the code with an older Java/JDK compiler.

As a variant of #2, recompiling the code can also be done by specifying the “target” or “release” parameter of a newer Java/JDK compiler to an earlier version of Java, to produce backward-compatible bytecode.

Before recompiling any code, it is important to know the runtime version of both the already compiled code and the environment in which it needs to run on. The message accompanying the UnsupportedClassVersionError error provides this information in the form of class file versions, which can be mapped directly to a specific Java version, using the values from the table below.

Maven Projects

When dealing with Maven projects, which the majority of both small and large enterprise Java programs are, it is possible to control the Java version targeted by the compilation process from the Maven configuration, i.e. Maven Project Object Model (POM) file. The relevant settings are shown in the Figure below.

Note that while it is possible to control the source and target versions independently, it is recommended to set them to equal values, as backward compatibility of the compiled bytecode cannot be guaranteed [8].

Can Constructors Throw Exceptions in Java

How to Fix and Avoid NullPointerException in Java

How to Fix «Illegal Start of Expression» in Java

«Rollbar allows us to go from alerting to impact analysis and resolution in a matter of minutes. Without it we would be flying blind.»

Источник

How to Resolve the NoClassDefFoundError in Java

The NoClassDefFoundError is a runtime error in Java that occurs if the Java Virtual Machine (JVM) or a ClassLoader instance attempts to load the definition of a class that could not be found. The class definition exists at compile-time but is not available at runtime.

What Causes NoClassDefFoundError

The NoClassDefFoundError occurs in Java when the JVM is unable to find a particular class at runtime which was available at compile-time.

The definition of the class is attempted to be loaded as part of a normal method call or creating an instance of the class using the new expression and no definition of the class could be found. Therefore, it can occur during the linking or loading of the unavailable class.

Common causes of the class definition being unavailable at runtime are:

NoClassDefFoundError Example

Here’s an example of a NoClassDefFoundError thrown when a class is attempted to be loaded that is available at compile-time but not at runtime:

class Vehicle < private String make; public String getMake() < return make; > public void setMake(String make) < this.make = make; > > public class NoClassDefFoundErrorExample < public static void main(String args[]) < Vehicle vehicle = new Vehicle(); vehicle.setMake("Audi"); System.out.println("Make = " + vehicle.getMake()); > >

In the above example, an instance of the Vehicle class is created in the NoClassDefFoundErrorExample.main() method and one of its methods is called. When the NoClassDefFoundErrorExample class is compiled and executed using the command line, it works fine and produces the correct output as expected:

$ ls NoClassDefFoundErrorExample.class Vehicle.class NoClassDefFoundErrorExample.java $ javac NoClassDefFoundErrorExample.java $ java NoClassDefFoundErrorExample Make = Audi

Now, if the Vehicle.class file is renamed and the NoClassDefFoundErrorExample class is executed again without recompiling, the NoClassDefFoundError is thrown:

$ mv Vehicle.class Vehicle2.class $ ls NoClassDefFoundErrorExample.class Vehicle2.class NoClassDefFoundErrorExample.java $ java NoClassDefFoundErrorExample Exception in thread "main" java.lang.NoClassDefFoundError: Vehicle at NoClassDefFoundErrorExample.main(NoClassDefFoundErrorExample.java:15) Caused by: java.lang.ClassNotFoundException: Vehicle at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:602) at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:178) at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:522) . 1 more

How to Resolve NoClassDefFoundError

The following steps should be followed to resolve a NoClassDefFoundError in Java:

The most common reason for the NoClassDefFoundError is that a particular class is not available in the application classpath. Find out which JAR file contains the problematic class and check whether this JAR is present in the application classpath. If not, the JAR should be added to the classpath and the application should be recompiled and executed again.
If that JAR is already present in the classpath, make sure the classpath is not overridden (e.g. by a start-up script). After finding out the exact classpath used by the application, the JAR file should be added to it.
Check the manifest file to see if the unavailable class is not defined in the Class-Path attribute. If so, it should be defined.
The NoClassDefFoundError can also occur due to the failure of static initialization. Check for the java.lang.ExceptionInInitializerError in the application logs.

Track, Analyze and Manage Errors With Rollbar

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Java errors easier than ever. Sign Up Today!

Источник