来自  资质荣誉 2019-10-06 06:02 的文章
当前位置: 澳门太阳娱乐手机登录 > 资质荣誉 > 正文

迭代器设计模式小例子

来自《Thinking in Java》

一个类的定义放在另一个类的内部,这个类就叫做内部类

  • 10.1创建内部类

public class First {
public class Contents{
public void f(){
System.out.println("In Class First's inner Class Contents method f()");
}
}
}
这样的类就叫内部类,内部类了解外部类,并能与之通信

  • 10.2 链接到外部类

package cn.zlb.innerclass;
interface Selector{
boolean end();
int current();
void next();
}
public class Sequence {
private Object[] items = null;
int next = 0;
public Sequence(int size){
items = new Object[size];
}
public void add(int i){
items[next++] = i;
}
private class SequenceSelector implements Selector{
private int i = 0;
@Override
public boolean end() {
return i==items.length;
}
@Override
public int current() {
// TODO Auto-generated method stub
return (int) items[i];
}
@Override
public void next() {
// TODO Auto-generated method stub
if(i < items.length){ i++;}
}
}
public Selector getSelector(){
return new SequenceSelector();
}
public static void main(String[] args) {
}
}

内部类自动拥有对其外围类的所有成员的访问权,因为当某个外围类创建一个内部类时,次内部类必定会秘密捕获一个指向外部类的引用用那个引用来访问外部成员

  • 10.3 使用.this 和 .new
    内部类中得到当前外围类对象的引用,可以使用.this关键字,.new关键字 如果想直接创建一个内部类对象,而不是通过外围类对象的方法来得到,可以使用.new关键字 注意与new的区别

private int num ;
public Test2(){
}
public Test2(int num){
this.num = num;
}
private class Inner{
public Test2 getTest2(){
return Test2.this;
}
public Test2 newTest2(){
return new Test2();
}
}
public static void main(String [] args){
Test2 test = new Test2(5);
Test2.Inner inner = test.new Inner();
Test2 test2 = inner.getTest2();
Test2 test3 = inner.newTest2();
System.out.println(test2.num);
System.out.println(test3.num);
}

  • 10.4 内部类与向上转型
    将内部类上转型为基类时,尤其是转型为一个接口时,内部类就有了用武之地
public interface Shape {  

public void paint();
}
public class Painter {
private class InnerShape implements Shape{
public void paint(){
System.out.println("painter paint() method");
}
}
public Shape getShape(){
return new InnerShape();
}
public static void main(String []args){
Painter painter = new Painter();
Shape shape = painter. getShape();
shape.paint();
}
}
此时,内部类是private的,可以它的外围类Painter以外,没人能访问。 这样,private内部类给累的设计者提供了一种途径,通过这种方式可以完全阻止任何依赖于类型的编码,并完全隐藏实现的细节。

  • 10.5在方法和作用域内的内部类
  • 10.6匿名内部类

public interface Shape {
public void paint();
}
public class Painter {
public Shape getShape(){
return new Shape(){
public void paint(){
System.out.println("painter paint() method");
}
};
public static void main(String [] args){
Painter painter = new Painter();
Shape shape = painter.getShape();
shape.paint();
}
}

注意匿名内部类一定要以分号结束 在这个匿名内部类中使用了默认的构造器来生成Shape(),如果你的基类需要一个有参数的构造器呢?
如果在这个内部类中需要用到这个参数那么这个参数一定的是final类型的

public class B {
public A getA(int num){
return new A(num){
};
}
}
public class A {
private int num;
public A(int num){
this.num = num;
}
public A(){
}
}

另外,还可以在匿名内部类里定义属性 由于类是匿名的,自然没有构造器,如果想模仿构造器,可以采用实例初始化({})

public A getA(){
return new A(){
int num = 0;
String str;
{
str = "javaeye";
System.out.println("hello robbin");
}
};
}

  • 10.6.1 使用匿名内部类改造工厂方法

package cn.zlb.factory;
interface Service{
void method1();
void methid2();
}
interface ServiceFactory{
Service getService();
}
class ImplementService1 implements Service{
@Override
public void method1() {
// TODO Auto-generated method stub
System.out.println("ImplementService1 method1");
}
@Override
public void methid2() {
// TODO Auto-generated method stub
System.out.println("ImplementService1 method2");
}
//使用匿名内部类
private ServiceFactory serviceFactory = new ServiceFactory() {
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService1();
}
};
}
class ImplementServiceFactory1 implements ServiceFactory{
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService1();
}
}
class ImplementServiceFactory2 implements ServiceFactory{
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService2();
}
}
class ImplementService2 implements Service{
@Override
public void method1() {
// TODO Auto-generated method stub
System.out.println("ImplementService2 method1");
}
@Override
public void methid2() {
// TODO Auto-generated method stub
System.out.println("ImplementService2 method2");
}
private ServiceFactory serviceFactory = new ServiceFactory() {
@Override
public Service getService() {
// TODO Auto-generated method stub
return new ImplementService2();
}
};
}
public class factory {
public static void method(ServiceFactory sf){
Service s = sf.getService();
s.methid2();
s.method1();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
method(new ImplementServiceFactory1());
method(new ImplementServiceFactory2());
}
}

  • 10.7 嵌套类
    static的内部类就叫做嵌套类 前面提到了很多次,嵌套类是个例外 使用嵌套类时有两点需要注意:
    a、创建嵌套类对象时,不需要外围类
    b、在嵌套类中,不能像普通内部类一样访问外围类的非static成员
    另外,嵌套类还有特殊之处,就是嵌套类中可以有static方法,static字段与嵌套类,而普通内部类中不能有这些
  • 10.8为何需要内部类
    a、内部类提供了某种进入外围类的窗户。
    b、也是最吸引人的原因,每个内部类都能独立地继承一个接口,而无论外围类是否已经继承了某个接口。 因此,内部类使多重继承的解决方案变得更加完整。 在项目中,需要多重继承,如果是两个接口,那么好办,接口支持多重继承。 如果是两个类呢?这时只有使用内部类了。

多的不说,直接上代码。

interface Selector {boolean end();Object current();void next();}

public class Sequence {private Object[] items;private int next = 0;public Sequence{items = new Object[size];}public void add{if (next < items.length) {items[next++] = x;}}private class SequenceSelector implements Selector {

 private int i = 0; public boolean end() { return i==items.length; } public Object current() { // TODO Auto-generated method stub return items[i]; } public void next() { // TODO Auto-generated method stub if (i<items.length) { i++; } } }public Selector selector(){ return new SequenceSelector();}public static void main(String[] args){ Sequence sequence = new Sequence; for (int i = 0; i < 10; i++) { sequence.add(Integer.toString; } Selector selector = sequence.selector(); while (!selector.end { System.out.println(selector.current; selector.next(); }}

这个例子很简单,相信也不需要解释什么了。

本文由澳门太阳娱乐手机登录发布于 资质荣誉,转载请注明出处:迭代器设计模式小例子

关键词: