内部类

读书笔记：
代码：
将内部类向上转型为一个接口时，内部类就有了用武之地。(和从实现某个接口的对象得到这个接口的引用，向上转型为这个对象的基类。效果是一样的)
因为实现某个接口的内部类对于其他人来说能够完全不可见，不可用。你得到的只是一个基类或接口的引用，所以能够方便的隐藏实现细节。
public interface Contents {
int value();
}

public interface Destination {
String readLabel();
}

class Parcel3 {
private class PContents implements Contents {
int i = 11;
public int value() {
return i;
}
}
protected class PDestination implements Destination {
private String label;
private PDestination(String str) {
label = str;
}
public String readLabel(){
return label;
}
}
public PContents getPContents () {
return new PContents();
}
public Destination dest(String s) {
return new PDestination(s);
}
}
public class TestParse1 {
public static void main(String[] args) {
Parcel3 p = new Parcel3();
Contents c = p.getPContents();
Destination d = p.dest("hello");
}
}


1.Parcel3中，PContents 是private的，所有只有Parcel3能访问他，protected 只有Parcel3及其子类、同包类能访问。
2.Contents C 是不能向下转型为PContents、PDestination 的，因为是private内部类的。除非你是继承它的子类。
private内部类完全阻止依赖于类型的编码，并且完全隐藏了实现的细节。客户端程序员不能访问任何新加的、原本不属于公共接口的方法。所以扩展接口是没有价值的。


方法内部及作用域内的内部类
为什么要这么用：
1.如果你实现了某个接口可以创建并返回对其的引用
2.创建一个类你不想这个类是公共可用的

public class Parcel4 {
public Destination dest(String s) {
class PDestination implements Destination {
private String label;
private PDestination(String where) {
label = where;
}
public String readLabel(){return label;}
}
return new PDestination(s);
}
public static void main(String[] args) {
Parcel4 p = new Parcel4();
Destination d = p.dest("sdfsd");
}
}

1.你可以在同一目录任何类中定义的PDestination内部类，不会有命名冲突
2.在dest方法外不能访问PDestination
3.dest方法执行完毕，并不以为着PDestination就不可用了

在作用域内使用内部类：
public class Parcel5 {
private void internalTracking(Boolean b) {
if(b) {
class A {
private String id;
A(String s) {
id = s;
}
String getId() {
return id;
}
A a = new A("a");
String s = a.getId();
}
}
}
public void track(){
internalTracking(true);
}
public static void main(String[] args) {
Parcel5 p = new Parcel5();
p.track();
}
}


匿名类例子：

public class Parcel6 {
public Contents cont () {
return new Contents() {
private int i = 11;
public int value() {
return i;
}
};//分号必须的
}
public static void main(String[] args) {
Parcel6 p = new Parcel6();
Contents c = p.cont();
}
}

1.在匿名类中，你可以对定义新的成员变量、
2.不能有已命名的构造器。
3.如果它要使用在它外部定义的对象，编译器要求其参数引用是final的，如果忘了会得到一个编译器错误
如下：
public class Parcel9 {
public Destination dest(final String dest, final float price) {
return new Destination() {
private int i;
{
i = Math.round(price);
if(i > 100) {
System.out.println("aaa");
}
}
private String label = dest;
public String readLabel() {
return label;
}
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d = p.dest("hello", 103.0F);
}
}

内部类与访问外部成员
内部类自动拥有外部类所有成员的访问权，当某个外部类对象创建一个内部类对象时候，内部类会保存一个外部类对象的引用，是根据这个隐藏的引用来访问的。内部类只能在与外部类相关联的情况下被创建。


内部类与访问外部类对象

1.如果你需要外部类对象的引用，可以在外部类名称后加个句点和this关键字来获取，任何方法都可以获取那个保存的指向外部类的引用。
public class Parcel11 {
class Contents {
private int i = 11;
public int value() { return i; };
}
class Destination {
private String label;
Destination(String where) {
this.label = where;
}
public String readLabel() {
return label;
}
}
public static void main(String[] args) {
Parcel11 p = new Parcel11();
Parcel11.Contents c = p.new Contents();
Parcel11.Destination d = p.new Destination("hello"); 
}
}

必须先new一个外部类对象，才会生成一个内部类对象。内部类对象会悄悄连接到生成他的外部类对象，如果是嵌套类，则不需要先创建外部类对象。

多层内部类访问外部类
如下：
class MNA {
private void f() {}
class T {
private void g(){}
public class B {
void h() {
g();
f();
}
}
}
}

public class Parcel11 {
     public static void main(String[] args) {
MNA m = new MNA();
MNA.T mnat = m.new T();
MNA.T.B mnatb = mnat.new B();
mnatb.h();
     }
}


内部类的继承
因为内部类的对象初始化要用到外部类的引用，所以在继承内部类的时候。外部类的对象必须被初始化，而在被继承类中并不存在要连接的缺省对象，
class WithInner {
class Inner{}
}
public class InheritInner extends WithInner.Inner {
InheritInner(WithInner wi) {
wi.super();
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}

InheritInner 继承内部类，生成构造器时，缺省的构造器不好，你不能只是传递一个指向外部类对象的引用。必须使用这种语法“
enclosingClassReference.super();
提供了必要的引用，然后程序才会通过。


内部类可以重载吗
class Egg {
private Yolk y;
public Egg() {
System.out.println("new Egg()");
y = new Yolk();
}
protected class Yolk {
public Yolk() {
System.out.println("Egg.Yolk()");
}
}
}

public class BigEgg extends Egg {
public class Yolk {
public Yolk () {
System.out.println("BigEgg.yolk()");
}
}
public static void main(String[] args) {
new BigEgg();
}
}
输出：
new Egg()
Egg.Yolk()

当你继承了外部类的时候，内部类并没有发生特别的变化。这2个内部类是单独的实体各自在各自的空间里。互不影响。

class Egg2 {
protected class Yolk {
public Yolk() { System.out.println("Egg2.Yolk()"); }
public void f() { System.out.println("Egg2.Yolk.f()");}
}
private Yolk y = new Yolk();
public Egg2() {
System.out.println("new Egg2()");
}
public void insertYolk(Yolk yy) {y = yy; }
public void g() { y.f(); }
}

public class BigEgg extends Egg2 {
public class Yolk extends Egg2.Yolk {
public Yolk () {
System.out.println("BigEgg2.yolk()");
}
public void f() {
System.out.println("BigEgg.Yolk.f()");
}
}
public BigEgg() { insertYolk(new Yolk()); }
public static void main(String[] args) {
Egg2 e2 = new BigEgg();
e2.g();
}
}

输出：

Egg2.Yolk()
new Egg2()
Egg2.Yolk()
BigEgg2.yolk()


局部内部类

interface Counter {
int next();
}
public class LocalInnerClass {
private int count = 0;
Counter getCounter(final String name) {
class LocalCounter implements Counter {
public LocalCounter() {
System.out.println("LocalCounter");
}
public int next() {
System.out.print(name);
return count++;
}
}
return new LocalCounter();
}
Counter getCounter2(final String name) {
return new Counter() {
{
System.out.println("Counter");
}
public int next() {
System.out.print(name);
return count++;
}
};
}
public static void main(String[] args) {
LocalInnerClass lic = new LocalInnerClass();
Counter c1 = lic.getCounter("local inner");
Counter c2 = lic.getCounter2("anoymous inner");
for(int i=0; i<5; i++)
System.out.println(c1.next());
for(int i=0; i<5; i++)
System.out.println(c2.next());
}
}

输出如下:
LocalCounter
Counter
local inner0
local inner1
local inner2
local inner3
local inner4
anoymous inner5
anoymous inner6
anoymous inner7
anoymous inner8
anoymous inner9

1.局部内部类不能有访问控制符。因为他不是外部类的一部分
2.可以访问当前当前代码块内的常量。和外部类的所有成员。
使用局部内部类而不使用匿名内部类的原因是，你不需要不止一个此内部类的对象。

[size]内部类标识符[/size]
1.外部类的名字+'$'+内部类的名字
2.如果是匿名的，编译器会自动产生一个数字作为标识符
3.如果内部类是嵌套在别的内部类之中同1.