java编程之内部类（二）

public class Outer {
private String tag;
public Outer(String tag) {
this.tag = tag;
}

public void getTag() {
System.out.println(tag);
}

class Inner {
public void f() {
//内部类方法访问外部类元素
System.out.println("Inner："+tag);
getTag();
}
}
public static void main(String[] args){
Outer.Inner oi = new Outer("Outer.tag").new Inner();
oi.f();
}
}/*
Inner:Outer.tag
Outer.tag

2、匿名内部类和工厂方法

interface Book{void infoBook();}
interface BookFactory{Book getBook();}

class Math implements Book{
private double priceM = 29.80;
private String name = "Math";
public void infoBook(){
System.out.println(name+":"+priceM);
}
public static BookFactory factory = new BookFactory(){
//向上转型：类引用向上转型为接口引用
public Book getBook(){
return new Math();
}
};
}

class English implements Book{
private double priceE = 31.80;
private String name = "English";
public void infoBook(){
System.out.println(name+":"+priceE);
}
//实现接口的匿名内部类
public static BookFactory factory = new BookFactory(){
public Book getBook(){
return new English();
}
};
}
public class FactoryAndInner{
public static void getInfo(BookFactory factory){
Book theBook = factory.getBook();
theBook.infoBook();
}
public static void main(String[] args){
getInfo(Math.factory);
getInfo(English.factory);
}
}

3、内部类的继承

内部类的构造器必须连接到指向其外围类对象的引用

a.该例中InheritInner将只继承内部类

----------

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);
}
}

----------

b.明确继承内部类

----------

class InnerExtends_2 {
public static void main(String[] args){
//构造器调用顺序：Outer2.Inner父类构造器->
//Outer2父类构造器->
//Outer1.Inner构造器->
//Outer2.Inner构造器
Outer1 ot = new Outer2();
//g()中将调用覆盖后的f()方法
ot.g();
}
}

class Outer1 {
protected class Inner {
public Inner() {System.out.println("Outer1.Inner");}
public void f() {System.out.println("Outer1.Inner.f()");}
}

private Inner in = new Inner();
public Outer1(){System.out.println("new Outer1");}
public void insertInner(Inner x){in = x;}
public void g(){in.f();}
}

class Outer2 extends Outer1{
public class Inner extends Outer1.Inner{
public Inner(){System.out.println("Outer2.Inner");}
//覆盖父类方法
public void f(){System.out.println("Outer2.Inner.f()");}
}
//insertInner方法允许Outer2.Inner向上转型为Outer1.Inner
public Outer2(){insertInner(new Inner());}
}

class Outer{
private int i = 0;
private static String s;
private  static class Inner{
public void f(){
//只能访问外部类的静态成员
System.out.println(s);
}
}

public static Inner inner(){
return new Inner();
}

public static void main(String[] args){
//嵌套类创建对象不需要外部类对象
Inner in = inner();
}
}

----------
接口内部的类：一般接口当中不允许放置任何代码，但是嵌套类可以作为接口的一部分。任何放置到接口当中的类都自动地是public和static的
interface InterfaceInner {
void f();
//存在于接口内部的类
class Inner{
public void g(){}
}
Inner inner();
}
class Test implements InterfaceInner{
public void f(){}
public Inner inner(){
return new Inner();
}
public static void main(String[] args){
Inner in = new Test().inner();
}
}