Synthetic Class in Java

What is a synthetic class in Java? Why should it be used? How can I use it?

Java has the ability to create classes at runtime. These classes are known as Synthetic Classes or Dynamic Proxies.

See http://java.sun.com/j2se/1.5.0/docs/guide/reflection/proxy.html for more information.

Other open-source libraries, such as CGLIB and ASM also allow you to generate synthetic classes, and are more powerful than the libraries provided with the JRE.

Synthetic classes are used by AOP (Aspect Oriented Programming) libraries such as Spring AOP and AspectJ, as well as ORM libraries such as Hibernate.

Well I found the answer to the first question on google:

> A class may be marked as synthetic if > it is generated by the compiler, that > is, it does not appear in the source > code.

This is just a basic definition but I found it in a forum thread and there was no explanation. Still looking for a better one...

For example, When you have a switch statement, java creates a variable that starts with a $. If you want to see an example of this, peek into the java reflection of a class that has a switch statement in it. You will see these variables when you have at least one switch statement anywhere in the class.

To answer your question, I don't believe you are able to access(other than reflection) the synthetic classes.

If you are analyzing a class that you don't know anything about (via reflection) and need to know very specific and low-level things about that class, you may end up using Java reflection methods that have to do with synthetic classes. The only "use" here is get more information about the class in order to use it appropriately in your code.

(If you're doing this, you're probably building a framework of some sorts that other developers could use. )

Otherwise, if you are not using reflection, there are no practical uses of synthetic classes that I know of.

synthetic classes / methods / fields:

These things are important for the VM. Have a look at following code snippet:

class MyOuter {
  
  private MyInner inner;

  void createInner() {
    // The Compiler has to create a synthetic method
    // to construct a new MyInner because the constructor
    // is private.
    // --> synthetic "constructor" method
    inner = new MyInner();
    
    // The Compiler has to create a synthetic method
    // to doSomething on MyInner object because this
    // method is private.
    // --> synthetic "doSomething" method
    inner.doSomething();
  }
  
  private class MyInner {
    // the inner class holds a syntetic ref_pointer to
    // the outer "parent" class
    // --> synthetic field
    private MyInner() {
    }
    private void doSomething() {
    }
  }
}

According to this discussion, though the language specification describes an "isSynthetic" proprty for classes, this is pretty much ignored by implementations and not used for either dynamic proxies or anonymous classes. Synthetic fields and constructors are used to implement nested classes (there is not concept of nested classes in byte code, only in source code).

I think that the concept of synthetic classes has simply proven to be not useful, i.e. nobody cares whether a class is synthetic. With fields and methods, it's probably used in exactly one place: to determine what to show in an IDE class structure view - you want normal methods and fields to show up there, but not the synthetic ones used to simulate nested classes. OTOH, you DO want anonymous classes to show up there.

They are created by JVM at run time when they invoke private members of inner class for debugging purpose

The methods,fields,class created by JVM during run time for its execution purpose are called Synthetic

http://www.javaworld.com/article/2073578/java-s-synthetic-methods.html

http://javapapers.com/core-java/java-synthetic-class-method-field/

As various answers have already pointed out, the compiler is allowed to generate various constructs (including classes) that do not directly correspond to something in souce code. These have to be marked as synthetic:

13.1. The Form of a Binary > A binary representation for a class or interface must also contain all of the following:
[...]

11. A construct emitted by a Java compiler must be marked as synthetic if it does not correspond to a construct declared explicitly or implicitly in source code, unless the emitted construct is a class initialization method (JVMS §2.9).
    [...]

As pointed out by @Holger in a comment to another question, relevant examples for such constructs are the Class objects representing method references and lambdas:

System.out.println(((Runnable) System.out::println).getClass().isSynthetic());
System.out.println(((Runnable) () -> {}).getClass().isSynthetic());

Output:

true
true

While this is not explicitly mentioned, it follows from 15.27.4. Run-Time Evaluation of Lambda Expressions: > The value of a lambda expression is a reference to an instance of a class with the following properties: [...]

and the almost identical wording for method references (15.13.3. Run-Time Evaluation of Method References).

As this class is not explicitly mentioned anywhere in source code, it has to be synthetic.

> What is a synthetic class in Java?

A synthetic class is a .class file generated by Java Compiler and it does not exist in the source code.

Example usage of synthetic class: Anonymous inner class

• java.text.DigitList$1 is a synthetic class and it is a anonymous inner class inside java.text.DigitList
• And there is no source code file named like DigitList$1.java but it is a inner file in DigitList.java

> Why should it be used?

It is a mechanism inside Java compiler logic to generate the .class file

> How can I use it?

No, developers do NOT use it directly.

Java compiler use synthetic to generate .class file, and then JVM reads the .class file to execute the program logic.

More details

• This article explains synthetic class in details
• This link lists all synthetic class exits in JDK

Also Synthetic Classes or Dynamic Proxies are used by EasyMock to create implementations of interfaces or abstract classes at runtime.

http://www.easymock.org/

When the Java compiler compiles certain constructs, such as inner classes, it creates synthetic constructs; these are classes, methods, fields, and other constructs that do not have a corresponding construct in the source code.
Uses: Synthetic constructs enable Java compilers to implement new Java language features without changes to the JVM. However, synthetic constructs can vary among different Java compiler implementations, which means that .class files can vary among different implementations as well.
reference:docs.oracle.com

If I get it right, a synthetic class is one generated on the fly, without having to give it an explicit name. For example:

//...
Thread myThread = new Thread() {
         public void run() {
           // do something ...
         }
       };
myThread.start();
//...

This creates a synthetic subclass of Thread and overrides its run() method, then instantiates it and starts it.

A synthetic class does not appear in your code: it is made up by compiler. E.g. A bridge method made up by compiler in java is typically synthetic.

public class Pair<T> {
    private T first;
    private T second;
    public void setSecond(T newValue) {
	    second = newValue;
    }
}


public class DateInterval extends Pair<String> {
    public void setSecond(String second) {
	    System.out.println("OK sub");
    }

    public static void main(String[] args) throws NoSuchFieldException, SecurityException {
	    DateInterval interval = new DateInterval();
	    Pair pair = interval;
	    pair.setSecond("string1");
    }
}

Using the command javap -verbose DateInterval, you can see a bridge method:

public void setSecond(java.lang.Object);
flags: ACC_PUBLIC, ACC_BRIDGE, ACC_SYNTHETIC

This was made up by compiler; it does not appear in your code.

Synthetic constructs are classes, methods, fields etc that do not have a corresponding construct in the source code. Synthetic constructs enable Java compilers to implement new Java language features without changes to the JVM. However, synthetic constructs can vary among different Java compiler implementations, which means that .class files can vary among different implementations as well.