.this:生成对外部类对象的引用,格式:外部类名字后面跟着圆点和this
package thinking.java.chapter10;
public class DoThis {
void f() {
System.out.println("DoThis.f()");
}
public class Inner{
public DoThis outer() {
return DoThis.this;//产生对外部类对象的引用
}
}
public Inner inner() {
return new Inner();
}
public static void main(String[] args) {
DoThis dt = new DoThis();
DoThis.Inner dti = dt.inner();
dti.outer().f();
}
}
.new:告知某些对象去创建其内部类的对象
注意:在拥有外部类对象之前是不能创建内部类对象的,即内部类对象的创建要依赖于外部类的对象。这是因为内部类对象会暗暗地连接到创建它的外部类对象上。但是如果创建的是嵌套类(静态内部类),那么它就不需要对外部类对象的引用,因为静态是属于外部类类而不是外部类的对象的。类似于静态变量。
练习6:
package thinking.java.chapter091;
public interface InterfaceChapter10 {
public String say();
}
package thinking.java.chapter09;
import thinking.java.chapter091.InterfaceChapter10;
public class ExeBase {
protected class ExeInner implements InterfaceChapter10{
public ExeInner(){}
@Override
public String say() {
// TODO Auto-generated method stub
return "hello";
}
}
}
package thinking.java.chapter10;
import thinking.java.chapter091.InterfaceChapter10;
public class Exe6 extends thinking.java.chapter09.ExeBase {
public InterfaceChapter10 getExeBase() {
return this.new ExeInner();
}
public static void main(String[] args) {
Exe6 e = new Exe6();
System.out.println(e.getExeBase().say());
}
}
package thinking.java.chapter10;
public class Outer7 {
private String s = "hello";
private void hello() {System.out.println("String outer");}
class Inner7{
public void modify7(){
s = "hi";
hello();
}
}
public void testInner() {
Inner7 i = new Inner7();
i.modify7();
}
public static void main(String[] args) {
Outer7 o7 = new Outer7();
o7.testInner();
}
}
package thinking.java.chapter10;
public class Outer8 {
class Inner8{
private int ii1 = 1;
private int ii2 = 2;
private void showIi2() { System.out.println(ii2); }
private void hi() { System.out.println("Inner hi"); }
}
int oi = new Inner8().ii1;
public void showOi() {
System.out.println(oi);
}
public void showIi2() {
new Inner8().showIi2();
}
public void showhi() {
new Inner8().hi();
}
public static void main(String[] args) {
Outer8 o8 = new Outer8();
o8.showOi();
o8.showIi2();
o8.showhi();
}
}
package thinking.java.chapter10;
interface Ex9Interface{
public void f(String s);
}
public class Outer9 {
Ex9Interface fi() {
class Inner9 implements Ex9Interface{
public void f(String s) {
System.out.println(s);
}
}
return new Inner9();
}
public static void main(String[] args) {
Outer9 o9 = new Outer9();
o9.fi().f("tiffany");;
}
}
package thinking.java.chapter10;
interface ExInterface10{
public void f(String s);
}
public class Outer10 {
ExInterface10 fi(boolean b) {
if(b) {
class Inner10 implements ExInterface10{
public void f(String s) {
System.out.println(s);
}
}
return new Inner10();
}
return null;
}
public static void main(String[] args) {
Outer10 o10 = new Outer10();
o10.fi(true).f("tiffany");
}
}
package thinking.java.chapter10;
class Test11{
private class Inner11 implements ExeInterface11{
@Override
public void f(String s) {
System.out.println(s);
}
}
ExeInterface11 fi() {
return new Inner11();
}
}
public class Outer11 {
public static void main(String[] args) {
Test11 t = new Test11();
t.fi().f("tiffany");;
((Inner11)t.fi()).f("tiffany");//无法进行向下转型,因为内部类被隐藏了
}
}
匿名内部类:在创建一个对象时,却插入了一个类的定义