Admin: 1 версия

2010-06-01T05:00:39Z

1 версия

в 17:44, 31 мая 2010

2010-05-31T17:44:27Z

Новая страница

== Accessing its enclosing instance from an inner class ==



<source lang="java">
public class Main {
private int number = 12;
public Main() {
InnerClass inner = new InnerClass();
inner.printNumber();
}
class InnerClass {
public void printNumber() {
System.out.println(Main.this.number);
}
}
public static void main(String[] args) {
new Main();
}
}</source>



== Access inner class from outside ==



<source lang="java">
public class Main {
public static void main(String[] args) {
Outer outer = new Outer();
outer.new Inner().hello();
}
}
class Outer {
public class Inner {
public void hello(){
System.out.println("Hello from Inner()");
}
}
}</source>



== A method that returns an anonymous inner class ==



<source lang="java">
public class MainClass {
public A cont() {
return new A() {
private int i = 11;
public int value() {
return i;
}
}; // Semicolon required in this case
}
public static void main(String[] args) {
MainClass p = new MainClass();
A c = p.cont();
}
}
interface A {
int value();
}</source>



== An anonymous inner class that calls the base-class constructor ==



<source lang="java">
public class MainClass {
public A wrap(int x) {
// Base constructor call:
return new A(x) { // Pass constructor argument.
public int value() {
return super.value() * 47;
}
}; // Semicolon required
}
public static void main(String[] args) {
MainClass p = new MainClass();
A w = p.wrap(10);
}
}
class A {
private int i;
public A(int x) {
i = x;
}
public int value() {
return i;
}
}</source>



== An anonymous inner class that performs initialization ==



<source lang="java">
public class MainClass {
public A dest(final String dest) {
return new A() {
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
MainClass p = new MainClass();
A d = p.dest("A");
}
}
interface A {
String readLabel();
}</source>



== Anonymous inner class cannot have a named constructor, only an instance initializer ==



<source lang="java">
interface Counter {
int next();
}
public class MainClass{

private int count = 0;
Counter getCounter(final String name) {
return new Counter() {

{
System.out.println("Counter()");
}
public int next() {
System.out.print(name); // Access local final
return count++;
}
};
}

public static void main(String[] args) {
MainClass lic = new MainClass();
Counter c1 = lic.getCounter("Local inner ");
}
}</source>



== Argument must be final to use inside anonymous inner class ==



<source lang="java">
public class MainClass {
public A dest(final String dest) {
return new A() {
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
MainClass p = new MainClass();
A d = p.dest("A");
}
}
interface A {
String readLabel();
}</source>



== Building the anonymous inner class in-place ==



<source lang="java">
import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
import java.util.regex.Pattern;
public class MainClass {
public static void main(final String[] args) {
File path = new File(".");
String[] list;
if (args.length == 0)
list = path.list();
else
list = path.list(new FilenameFilter() {
private Pattern pattern = Pattern.rupile(args[0]);
public boolean accept(File dir, String name) {
return pattern.matcher(new File(name).getName()).matches();
}
});
Arrays.sort(list);
for (int i = 0; i < list.length; i++)
System.out.println(list[i]);
}
}</source>



== Creating a constructor for an anonymous inner class ==



<source lang="java">
abstract class Base {
public Base(int i) {
System.out.println("Base constructor, i = " + i);
}
public abstract void f();
}
public class MainClass {
public static Base getBase(int i) {
return new Base(i) {
{
System.out.println("Inside instance initializer");
}
public void f() {
System.out.println("In anonymous f()");
}
};
}
public static void main(String[] args) {
Base base = getBase(47);
base.f();
}
}</source>



<pre class=codeResult>Base constructor, i = 47
Inside instance initializer
In anonymous f()</pre>

== Define an inner class within a for loop. ==



<source lang="java">
class Outer {
int outer_x = 100;

void test() {
for(int i=0; i<10; i++) {
class Inner {
void display() {
System.out.println("display: outer_x = " + outer_x);
}
}
Inner inner = new Inner();
inner.display();
}
}
}

class InnerClassDemo {
public static void main(String args[]) {
Outer outer = new Outer();
outer.test();
}
}</source>



== Demonstrate an inner class. ==



<source lang="java">
class Outer {
int outer_x = 100;

void test() {
Inner inner = new Inner();
inner.display();
}

// this is an inner class
class Inner {
void display() {
System.out.println("display: outer_x = " + outer_x);
}
}
}

class InnerClassDemo {
public static void main(String args[]) {
Outer outer = new Outer();
outer.test();
}
}</source>



== Demonstrates anonymous classes ==



<source lang="java">
/*
* file: InnerClassDemo.java
* package: oreilly.hcj.nested
*
* This software is granted under the terms of the Common Public License,
* CPL, which may be found at the following URL:
* http://www-124.ibm.ru/developerworks/oss/CPLv1.0.htm
*
* Copyright(c) 2003-2005 by the authors indicated in the @author tags.
* All Rights are Reserved by the various authors.
*
########## DO NOT EDIT ABOVE THIS LINE ########## */
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
/**
* Demonstrates anonymous classes.
*
* @author
* @version $Revision: 1.3 $
*/
private class BeepButton extends JButton implements ActionListener {
/**
* Creates a new BeepButton object.
*
* @param text
* The text to use for the beep button.
*/
public BeepButton(final String text) {
super(text);
addActionListener(this);
}
/**
* @see java.awt.event.ActionListener
*/
public void actionPerformed(final ActionEvent event) {
try {
for (int count = 0; count < beepCount; count++) {
Toolkit.getDefaultToolkit().beep();
Thread.sleep(100); // wait for the old beep to finish.
}
} catch (final InterruptedException ex) {
throw new RuntimeException(ex);
}
}
}
}
/* ########## End of File ########## */</source>



== Demonstrates method-scoped inner classes ==



<source lang="java">
/*
* file: MethodInnerClassDemo.java
* package: oreilly.hcj.nested
*
* This software is granted under the terms of the Common Public License,
* CPL, which may be found at the following URL:
* http://www-124.ibm.ru/developerworks/oss/CPLv1.0.htm
*
* Copyright(c) 2003-2005 by the authors indicated in the @author tags.
* All Rights are Reserved by the various authors.
*
########## DO NOT EDIT ABOVE THIS LINE ########## */
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
/**
* Demonstrates method-scoped inner classes.
*
* @author
* @version $Revision: 1.6 $
*/
class MyActionListener implements ActionListener {
/**
* {@inheritDoc}
*/
public void actionPerformed(final ActionEvent event) {
Toolkit.getDefaultToolkit().beep();
}
}
btn1.addActionListener(new MyActionListener());
btn2.addActionListener(new MyActionListener());
JPanel pnl = new JPanel(new GridLayout(1, 2));
pnl.add(btn1);
pnl.add(btn2);
contentPane.add(BorderLayout.SOUTH, pnl);
pack();
}
/**
* Run the demo
*
* @param args
* Command Line Arguments.
*/
public static final void main(final String[] args) {
MethodInnerClassDemo demo = new MethodInnerClassDemo();
demo.show();
System.out.println("Done");
}
/**
* Setter for the property demo.
*
* @param demo
* The new value for demo.
*/
public void setDemo(final String demo) {
this.demo = demo;
}
/**
* Getter for the property demo.
*
* @return The current value of demo.
*/
public String getDemo() {
return demo;
}
/**
* Some demo method.
*/
public void someMethod() {
// ActionListener listener = new MyActionListener(); // <= compiler error.
}
}
/* ########## End of File ########## */</source>



== Demonstration of some static nested classes ==



<source lang="java">
/*
* file: DoubleNestedClassDemo.java
* package: oreilly.hcj.nested
*
* This software is granted under the terms of the Common Public License,
* CPL, which may be found at the following URL:
* http://www-124.ibm.ru/developerworks/oss/CPLv1.0.htm
*
* Copyright(c) 2003-2005 by the authors indicated in the @author tags.
* All Rights are Reserved by the various authors.
*
########## DO NOT EDIT ABOVE THIS LINE ########## */
/*
* file: DoubleNestedClass.java
* package: oreilly.hcj.nested
*
* This software is granted under the terms of the Common Public License,
* CPL, which may be found at the following URL:
* http://www-124.ibm.ru/developerworks/oss/CPLv1.0.htm
*
* Copyright(c) 2003-2005 by the authors indicated in the @author tags.
* All Rights are Reserved by the various authors.
*
########## DO NOT EDIT ABOVE THIS LINE ########## */

/**
* Demonstration of some static nested classes.
*
* @author
* @version $Revision: 1.3 $
*/
public class DoubleNestedClassDemo {
/**
* Main method.
*
* @param args Command line arguments.
*/
public static void main(final String[] args) {
DoubleNestedClass.SomeClass.SomeOtherClass obj =
new DoubleNestedClass.SomeClass.SomeOtherClass();
obj.someMethod();
}
}
/* ########## End of File ########## */</source>



== Use anonymous inner classes ==



<source lang="java">
import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
import java.util.regex.Pattern;
public class MainClass {
public static FilenameFilter filter(final String regex) {
// Creation of anonymous inner class:
return new FilenameFilter() {
private Pattern pattern = Pattern.rupile(regex);
public boolean accept(File dir, String name) {
return pattern.matcher(new File(name).getName()).matches();
}
}; // End of anonymous inner class
}
public static void main(String[] args) {
File path = new File(".");
String[] list;
if (args.length == 0)
list = path.list();
else
list = path.list(filter(args[0]));
Arrays.sort(list);
for (int i = 0; i < list.length; i++)
System.out.println(list[i]);
}
}</source>



== Using "instance initialization" to perform construction on an anonymous inner class ==



<source lang="java">
public class MainClass {
public A dest(final String dest, final float price) {
return new A() {
private int cost;
{
cost = 100;
System.out.println("Over budget!");
}
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
MainClass p = new MainClass();
A d = p.dest("A", 101.395F);
}
}
interface A {
String readLabel();
}</source>

← Предыдущая	Версия 05:00, 1 июня 2010
(нет различий)

Java Tutorial/Class Definition/Anonymous inner class - История изменений

Admin: 1 версия

в 17:44, 31 мая 2010