内部类深入研究

内部类深入研究    

 

 

关于为什要使用内部类问题：

        问题：

         如果只是需要一个对接口的引用，为什么不通过外围类实现那个接口呢？

          如果直接在外部类引用接口能满足需求时，那么就应该这样做。两者区别在于：后者不是总能享用
到接口带来的方便。
         内部类最吸引人的地方在于：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了
某个（接口的）实现，对于内部类都没有影响。
         内部类使得多重继承的解决方案更加完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。也就是说，
内部类允许继承多个非接口类型（类或抽象类）。
         一个实现多重继承类的例子代码如下：

 

    // 举个例子：
    // 有两个这样类D和E
    class D {
    }

    abstract class E {
    }

    // 我要建一个类Z实现多重继承类D和类E
    // 只有采用内部类的方式：
    // 如：
    class Z extends D {
            E makeE() {
                    return new E() {
                    };
            }
    }

    // 调用内部类
    public class Test {
            static void takesD(D d){}
            static void takesE(E e){}
            public static void main(String[] args) {
                    Z z=new Z();
                    takesD(z);
                    takesE(z.makeE());               
            }
    }

 

   内部类还有一些其它特性:
   1.内部类可以有多个实例,每个实例都有自己的状态信息,并且与外围类对象的信息相互独立.
   2.在外围类中,可以让多个内部类以不同方式实现同一个接口.
   3.创建内部类对象的时刻并不依赖于外围类对象的创建.
   4.内部类并没有令人迷惑的“is-a”关系；它就是一个独立的尸体。

 

   使用内部匿名内部类，工厂方法将变得非常简单。

    普通工厂方法模式如下：

 

//抽象产品
public interface Service {
  void method1();
  void method2();
}



//具体产品

public class Implementation1 implements Service {

	@Override
	public void method1() {
		System.out.println("Implementation1 method1");
	}

	@Override
	public void method2() {
		System.out.println("Implementation1 method2");
	}

}

public class Implementation2 implements Service {

	@Override
	public void method1() {
		System.out.println("Implementation2 method1");
	}

	@Override
	public void method2() {
		System.out.println("Implementation2 method2");
	}

}

//构造者
public interface ServiceFactory {
	Service getService();
}

//具体构造者
public class Im1ServiceFactory implements ServiceFactory {
	@Override
	public Service getService() {
		return new Implementation1();
	}

}

public class Im2ServiceFactory implements ServiceFactory {

	@Override
	public Service getService() {
		return new Implementation2();
	}

}
//模式使用
public class Factories {

	public static void main(String[] args) {
      Service s;
      ServiceFactory serviceFactory1 =new Im1ServiceFactory();
      ServiceFactory serviceFactory2 =new Im2ServiceFactory();
      s=serviceFactory1.getService();
      s.method1();
      s.method2();
      
      s=serviceFactory2.getService();
      s.method1();
      s.method2();
      
	}

}

    使用匿名内部类

 

public interface Service {
 void method1();
 void method2();
}
public interface ServiceFactory {
  Service servicce();
}

public class Implementation1 implements Service {

      public Implementation1() {
            // TODO Auto-generated constructor stub
      }

      @Override
      public void method1() {
            // TODO Auto-generated method stub
            System.out.println("Implementation1 method1");
      }

      @Override
      public void method2() {
            // TODO Auto-generated method stub
            System.out.println("Implementation2 method2");
      }
      public static ServiceFactory factory=new ServiceFactory() {
            
            @Override
            public Service servicce() {
                  // TODO Auto-generated method stub
                  return new Implementation1();
            }
      };

}


public class Implementation2 implements Service {

      public Implementation2() {
            // TODO Auto-generated constructor stub
      }

      @Override
      public void method1() {
            // TODO Auto-generated method stub
            System.out.println("Implentation2 method1");

      }

      @Override
      public void method2() {
            // TODO Auto-generated method stub
            System.out.println("Implentation2 method2");
      }

      public static ServiceFactory factory = new ServiceFactory() {

            @Override
            public Service servicce() {
                  // TODO Auto-generated method stub
                  return new Implementation2();
            }
      };

}

public class Factories {
      public static void main(String[] args) {
   serviceConsumer(Implementation1.factory);
   serviceConsumer(Implementation2.factory);
      }
      public static void  serviceConsumer(ServiceFactory fact) {
            Service service=fact.servicce();
            service.method1();
            service.method2();
      }
}