Java 内部类(成员内部类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class OuterClass {
class InnerClass1 {
private int i = 11;
public int value() {
return i;
}
}
class InnerClass2 {
private String str;
public InnerClass2(String str) {
this.str = str;
}
public String readStr() {
return str;
}
}
public void ship(String str) {
InnerClass1 class1 = new InnerClass1();
InnerClass2 class2 = new InnerClass2(str);
System.out.println(class2.readStr());
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.ship("test");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
	public InnerClass1 getInnerClass1(){
return new InnerClass1();
}
public InnerClass2 getInnerClass2(String str){
return new InnerClass2(str);
}
public void ship(String str) {
InnerClass1 class1 = getInnerClass1();
//实例化的时候直接调用方法
InnerClass2 class2 = getInnerClass2(str);
System.out.println(class2.readStr());
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.ship("test1");
OuterClass.InnerClass1 inner1 = outerClass.getInnerClass1();
OuterClass.InnerClass2 inner2 = outerClass.getInnerClass2("test");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public interface Selector {
boolean end();
Object current();
void next();
}
public class Sequence {
private Object[] items;
private int next = 0;
public Sequence(int size) {
items = new Object[size];
}
public void add(Object x){
if(next < items.length){
items[next++] = x;
}
}
private class SequenceSelector implements Selector{
private int i = 0;
@Override
public boolean end() {
return i == items.length;
}
@Override
public Object current() {
return items[i];
}
@Override
public void next() {
if(i < items.length){
i ++;
}
}
}
public Selector getSelector(){
return new SequenceSelector();
}
public static void main(String[] args) {
Sequence sequence = new Sequence(10);
for (int i = 0; i < 10; i++) {
sequence.add(Integer.toString(i));
}
Selector selector = sequence.getSelector();
while(!selector.end()){
System.out.println(selector.current());
selector.next();
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class DotThis {
public void f(){
System.out.println("DotThis.f()");
}
public class InnerClass{
public DotThis outClass(){
return DotThis.this;
}
}
public innerClass getInnerClass(){
return new innerClass();
}
public static void main(String[] args) {
DotThis dotThis = new DotThis();
DotThis.InnerClassclass1 = dotThis.getInnerClass();
class1.outClass().f();
}
}

1
2
3
4
5
6
7
public class DotNew {
public class InnerClass{}
public static void main(String[] args) {
DotNew dotNew = new DotNew();
DotNew.InnerClass innerClass = dotNew.new InnerClass();//表示是该外部类对象中建立的内部类对象
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
public class Parcel {
//此内部类是一个实现了Contents接口的private修饰的类，表明此类有相应的可调用的类，但是只能被
//Parcel类访问，其他类不可访问ContentsImp 类
private class ContentsImp implements Contents{
private int i ;
@Override
public int value() {
return i;
}
}
//DestinationImpl类是实现了Destination接口的类，并且被protected修饰符修饰，只有Parcel类
//及其子类还有同包下的类可对他进行访问。
protected class DestinationImpl implements Destination{
private String label;
public DestinationImpl(String label) {
this.label = label;
}
@Override
public String readLabel() {
return label;
}
}
public Contents getContents() {
return
new ContentsImp();
}
public DestinationImpl getDestination(String label) {
return new DestinationImpl(label);
}
}
//Test类与Parcel 在同一个包下
public class Test {
public static void main(String[] args) {
Parcel parcel = new Parcel();
//
Parcel.ContentsImp contentsImp = parcel.new ContentsImp();
报错 因为正在
//Test类中对ContentsImp进行访问
Parcel.DestinationImpl destinationImpl =parcel.new DestinationImpl("test");
//可以访问 因为当前类和他在同一个包下。
//
System.out.println(contents.value());
System.out.println(destinationImpl.readLabel());
}
}
//Test1类与Parcel
不在一个包下
public class Test1 {
public static void main(String[] args) {
Parcel parcel = new Parcel();
//
Parcel.DestinationImpl destinationImpl =parcel.new DestinationImpl("test");
//报错 因为现在	Test1类与Parcel
不在一个包下
不能访问内部类 DestinationImpl
Contents contents = parcel.getContents();
Destination destination = parcel.getDestination("test");
//正确的访问方式，这种情况即是向上转型，当取得了基类或者接口的引用时，可能无法找到他的正确类型
//不可直接去访问具体实现类，具体实现的细节也被隐藏起来了。
System.out.println(contents.value());
System.out.println(destination.readLabel());
}
}

1
2
3
4
5
class NewClass extends Parcel.DestinationImpl{
public NewClass(Parcel parcel, String label) {
parcel.super(label);
}
}