四方法内部类
方法内部类只在该方法内部可见方法内部类可以定义在方法中的任何位置
/**
* 内部类实现接口
*
* @author leizhimin ::
*/
public class Test {
public static void main(String[] args) {
Outer outer = new Outer();
Foo f = outergenFoo();
Bar b = outergenBar();
fsay();
breadme();
}
}
class Outer {
public Foo genFoo() {
//方法内的内部类
class FooImpl implements Foo {
public void say() {
Systemoutprintln(say foo!);
}
}
return new FooImpl();
}
public Bar genBar() {
Bar b = null;
if (true) {
//任意位置的内部类
class BarImpl implements Bar {
public void readme() {
Systemoutprintln(say bar!);
}
}
b = new BarImpl();
}
return b;
}
}
运行结果
say foo!
say bar!
Process finished with exit code
五匿名类
匿名类不给出类名直接定义一个类通常这个类实现了某种接口或者抽象匿名类的访问权限更没有讨论价值了看个例子就行了
在一些多线程程序中比较常见有点变态呵呵
/**
* 匿名类
*
* @author leizhimin ::
*/
public class Test {
public Foo f = new Foo() {
public void say() {
Systemoutprintln(O(∩_∩)O哈哈~!);
}
};
public Foo test() {
return new Foo() {
public void say() {
Systemoutprintln(say foo!);
}
};
}
public static void main(String[] args) {
Test t = new Test();
tfsay();
ttest()say();
}
}
interface Foo {
void say();
}
运行结果
say foo!
Process finished with exit code
/**
* 普通类的匿名初始化
*
* @author leizhimin ::
*/
public class Fk {
private String x;
public Fk(String x) {
thisx = x;
}
@Override
public String toString() {
return Fk{ +
x= + x + \ +
};
}
}
class Test {
public Fk hehe() {
//把后面的一对大括号去掉呢呵呵
return new Fk(fk) {
};
}
public static void main(String[] args) {
Test t = new Test();
Fk f = thehe();
Systemoutprintln(f);
}
}
运行结果
Fk{x=fk}
Process finished with exit code
还有一个不得不提的经典实例来自thining in java有改动
interface Service {
void method();
void method();
}
interface ServiceFactory {
Service getService();
}
class Implementation implements Service {
private Implementation() {}
public void method() {Systemoutprintln(Implementation method);}
public void method() {Systemoutprintln(Implementation method);}
public static ServiceFactory factory = new ServiceFactory() {
public Service getService() {
return new Implementation();
}
};
}
class Implementation implements Service {
private Implementation() {}
public void method() {Systemoutprintln(Implementation method);}
public void method() {Systemoutprintln(Implementation method);}
public static ServiceFactory factory = new ServiceFactory() {
public Service getService() {
return new Implementation();
}
};
}
public class Factories {
public static void serviceConsumer(ServiceFactory fact) {
Service s = factgetService();
thod();
thod();
}
public static void main(String[] args) {
serviceConsumer(Implementationfactory);
serviceConsumer(Implementationfactory);
}
}
这个应用给了我们很多思考我就不说了不同人看了会有不同的感受
内部类的巧妙使用会让你的代码很牛如果要形容下那就是没看懂的时候感觉神出鬼没看懂后感觉鬼斧神工不过这些代码多了别人想看懂都难想看懂你思路就难上加难了呵呵!
六静态内部类
静态内部类是static class型的内部类这种内部类特点是它不能访问外部类的非静态成员要创建静态内部类对象时候也不需要外部类对象了直接可以
new 外部类名内部类构造方法
来创建给个例子
/**
* 静态内部类
*
* @author leizhimin ::
*/
public class Outer {
public static int i =;
protected static class Inner {
int i =;
String name;
Inner(String name) {
thisname = name;
}
void sayHello() {
Systemoutprintln(Hello + name);
Outeri++;
}
}
public Inner genInner(String name) {
return new Inner(name);
}
}
class Test {
public static void main(String[] args) {
OuterInner in = new OuterInner();
insayHello();
Systemoutprintln(Outeri);
OuterInner in = new Outer()genInner();
insayHello();
Systemoutprintln(Outeri);
}
}
运行结果
Hello
Hello
Process finished with exit code
七接口内部类
接口内部类自动都是public static的相当于为接口定义了一种变量类型这在java的设计中就有使用比如在HashMap中就有
static class Entry implements MapEntry
下面我给个例子
/**
* 接口内部类
*
* @author leizhimin ::
*/
public interface AInterface {
void readme();
class Inner implements AInterface {
public void readme() {
Systemoutprintln(我是一个接口内部类);
}
}
}
class Main {
public static void main(String[] args) {
AInterfaceInner in = new AInterfaceInner();
inreadme();
}
}
八内部的类的嵌套
所谓内部类嵌套就是内部类里面再定义内部类其实这种用法还真没见过试试写个简单例子看看吧
/**
* 嵌套内部类
*
* @author leizhimin ::
*/
public class Outer {
private void f() {
Systemoutprintln(f);
}
class A {
private void a() {
f();
Systemoutprintln(a);
}
class B {
protected void b() {
a();
Systemoutprintln(b);
}
}
}
}
class Test{
public static void main(String[] args) {
Outer o = new Outer();
OuterA a = onew A();
OuterAB b = anew B();
bb();
}
}
运行结果
f
a
b
Process finished with exit code
八内部类的继承
内部类的继承可以继承内部类也可以继承外部类
/**
* 内部类的继承可以继承内部类也可以继承外部类
*
* @author leizhimin ::
*/
public class Outer {
class Inner {
void doSomething() {
Systemoutprintln(Inner doing );
}
}
class Inner extends Inner {
void doSomething() {
Systemoutprintln(Inner doing );
}
void readme() {
Systemoutprintln(HeHe!);
}
}
}
class Test {
public static void main(String[] args) {
Outer outer = new Outer();
OuterInner in = outernew Inner();
OuterInner in = outernew Inner();
indoSomething();
indoSomething();
inreadme();
}
}
运行结果
Inner doing
Inner doing
HeHe!
Process finished with exit code
总结
内部类是Java中最复杂深奥的概念之一而且内部类在访问控制修饰符继承实现抽象序列化等等很多方面都是一个很让人迷惑的问题在实际中这些问题也许永远没机会没时间搞清但是一般说来懂得以上的内部类的知识就足够用了
内部类的设计也许是弥补Java语言本身的先天不足吧作为语言来说这个特性太变态了点难道就没别的法了?
以上的总结完全是建立在实践基础上的所列举的例子也许偏颇不能全面反映问题的本质希望有兴趣的博友多多发表自己的看法与观点
