public void anotherMethod() { // InnerClass is part of this MyClass. Perfectly instantiable. new Thread(new InnerClass()).start(); }
InnerClass innerClass = new TestClass().new InnerClass();
private class Foo { private int v1; //Visible from the inner class because it is an attribute. public void bar() { int v2 = true; //Not visible from the inner class final boolean v3 //Visible from the inner class new InnerClass() { public void overridenMethod() { //Here, you can use v1 and v3 but not v2 } } } }
public static InnerClass empty(String testKey) { InnerClass in = new InnerClass(); in.testKey =testKey; return in; }
function InnerClass() { this.method = function() { } } function OuterClass() { var decoratedClass = new InnerClass() this.method = decoratedClass.method.bind(decoratedClass) } var instance = new OuterClass instance.method()
public class OuterClass { public static void main(String[] args) { InnerClass otherInnerVar = new InnerClass(); // won't work }
for( final String s : value ) { doSomething( new InnerClass() { void something() { s.length();// accesing s from within the inner class } }); }
InnerClass myInnerClass = new InnerClass() { @Override void OuterClassMethod() { int OuterClassVariable = 10; System.out.println("OuterClassVariable" + " " + OuterClassVariable); } };
loadProxies.append(new InnerClass(remoteProxy.getClassDefinition()));
public static void main(String[] args) { // this results in an error: // no enclosing instance of type Parent is available InnterClass inner = new InnerClass(); // this works because you specify the surrounding object Parent parent = new Parent(); InnerClass inner = parent.new InnerClass(); }
// numbers: MyClass InnerClass MyClass m = new MyClass(); // 1 0 MyClass.InnerClass i = m.new InnerClass(); // 1 1 MyClass.InnerClass[] array = new MyClass.InnerClass[20]; // 1 1 for(int i = 0; i < 20; i++) { array[i] = m.new InnerClass(); } // 1 21
public void func(final int param) { InnerClass inner = new InnerClass() { public void innerFunc() { System.out.println(param); } } inner.innerFunc(); }
public class OuterClass { public static void main(String[] args) { InnerClass otherInnerVar2 = new OuterClass().new InnerClass(); // will work }
public static void main (String[] args){ OuterClass outer = new OuterClass(); // This is the key part: Here you are creating a new instance of inner class // AND defining its body. If you are using Eclipse, and only write the // new InnerClass() part, you'll notice that the IDE complains that you need // to implement the doSomething() method, which you will do as though you // were creating a plain 'ol class definition outer.showThis(new InnerClass(){ public void doSomething(){ System.out.println("This is the inner anonymous class speaking!"); } }); }
String string = "helloworld"; public class InnerClass { public void changeString() { string = "lol"; System.out.println(string); } } public static void main(String[] args) { OuterClass m = new OuterClass(); InnerClass c = m.new InnerClass(); c.changeString(); System.out.println(m.string); }
class OuterClass { ... InnerClass NewInnerClass() { return new InnerClass(this); } void SomeFunction() { InnerClass i = this.NewInnerClass(); i.GetOuterString(); } }
private String addArrayMarshaller(final MetaClass type, final boolean gwtTarget) { final String varName = getVarName(type); if (!arrayMarshallers.contains(varName)) { final String marshallerClassName = getMarshallerImplClassName(type, gwtTarget); final InnerClass arrayMarshaller = new InnerClass(generateArrayMarshaller(type, marshallerClassName, gwtTarget)); classStructureBuilder.declaresInnerClass(arrayMarshaller); addConditionalAssignment(type, Stmt.newObject(QualifyingMarshallerWrapper.class, Stmt.newObject(arrayMarshaller.getType()), type .asClass())); } arrayMarshallers.add(varName); return varName; }
private String addArrayMarshaller(final MetaClass type, final boolean gwtTarget) { final String varName = getVarName(type); if (!arrayMarshallers.contains(varName)) { final String marshallerClassName = getMarshallerImplClassName(type, gwtTarget); final InnerClass arrayMarshaller = new InnerClass(generateArrayMarshaller(type, marshallerClassName, gwtTarget)); classStructureBuilder.declaresInnerClass(arrayMarshaller); addConditionalAssignment(type, Stmt.newObject(QualifyingMarshallerWrapper.class, Stmt.newObject(arrayMarshaller.getType()), type .asClass())); } arrayMarshallers.add(varName); return varName; }
private MetaClass addFactoryDeclaration(final String factoryName, final MetaClass typeCreatedByFactory, final IOCProcessingContext processingContext) { final ClassStructureBuilder<?> builder = processingContext.getBootstrapBuilder(); final BuildMetaClass factory = ClassBuilder .define(factoryName, parameterizedAs(Factory.class, typeParametersOf(typeCreatedByFactory))) .publicScope().abstractClass().body().getClassDefinition(); builder.declaresInnerClass(new InnerClass(factory)); return factory; }
@Test public void testDefineClassWithInnerClass() { final ClassStructureBuilder<?> innerClass = ClassBuilder.define("Inner") .publicScope().body(); final String cls = ClassBuilder.define("foo.bar.Baz") .publicScope() .body() .declaresInnerClass(new InnerClass(innerClass.getClassDefinition())) .toJavaString(); assertEquals("failed to generate class with method using inner class", CLASS_DECLARING_INNER_CLASS, cls); }