上回的问题居然没有人回，是不是策略模式写得太烂了！(100分)

现在我又写一个，这回用JAVA！
本人写的一个类工厂模式，但是我感觉有好象不太象，但是我主要是为解决一个这样的问题，
那就是：给一个文件名称的参数，然后根据这个文件的名称，生成相应的文件实体，然后打开文件！
其中我有个问题，抽象类怎么也有实例呢？是不是跟接口的实例一样理解呢！下面是代码！
import java.util.*;
public class IteratorTest
{
public static void main(String args[])
{
ArrayList al = new ArrayList() ;
Iterator i = al.iterator() ;
String FileName ="bmp" ;
//do
c
FileClass ei = (FileClass)CreateFile.CreateF(FileName) ;
ei.OpenFile() ;
}
}
abstract class FileClass
{
public abstract boolean OpenFile() ;
public String FileID ;
public String FileKind ;
public String FilePath ;
}
class ImageFile extends FileClass
{
public ImageFile()
{
super() ;
}
public boolean OpenFile()
{
System.out. print("this is a imageFile") ;
return true ;
}
}
classdo
cFile extends FileClass
{
publicdo
cFile()
{
super() ;
}
public boolean OpenFile()
{
System.out. print("this is ado
cFile") ;
return true ;
}
}
class CreateFile
{
public static Object CreateF(String FileName)
{
if (FileName == "bmp") //这里应该用CASE语句好一些！
{
ImageFile f = new ImageFile() ;
return f ;
}
else
if (FileName == "doc")
{
do
cFile f = new do
cFile() ;
return f ;
} else
return null ;
}
}

抽象类没有实例，上面的
FileClass ei = (FileClass)CreateFile.CreateF(FileName) ;
ei.OpenFile();
ei实际上是一个FileClass子类的引用，并且将引用向上转型为FileClass，由于FileClass
是虚拟类，因此ei.OpenFile();的时候会调用实际对象如ImageFile的OpenFile()。

抽象类有实例跟JAVA的构造模式有关，因为JAVA的构造是上朔造型，也就是说在建立子类的
实例前先建立该子类的根类实例，然后逐层建立，直到创建子类的实例，抽象类不能单独创建
但继承它的子类在创建实例前一定要先建立它的。
这跟接口不一样的

ei实际上是一个FileClass子类的引用，好无疑问，EI实际上就是ImageFile的实例，
引用是该实例的首地址，但是实例本身也是首地址啊，他们有区别么！

to only you :
only you 真是 ONLY YOU，当 当 。。。。
FileClass ei = (FileClass)CreateFile.CreateF(FileName) ;
ei.OpenFile();
根据你的观点那么EI还是OBJECT的实例是么！因为FILECLASS还是继承了OBJECT啊 ，
因为JAVA的构造是上朔造型，那么在建立一个类的实例的时候那他得产生多少他的
父实例啊，那不太浪费内存了么，或者在产生了一个父实例之后，产生了一个子实例
再把父实例给切掉是吧！

只有一个实例，否则就不叫做继承了，子类的实例可以上溯成父类的实例。

to billy_yuan:
我说的意思是这种关系就如同塔楼一样，子类实例之所以可以上所造型就是因为在它的
顶层已经存在父类的内存结构，实例当然只有一个，但它的确包含了他的父类的内存映像，
可能我的说法有问题，但请不要以这种口气和别人讨论问题，别人有可能错了，但关心你的
问题或者发表以下自己的见解本身就是对你这个问题的关注！
如果我错了，谢谢你的指点！恕我在这里胡说八道了！看下例子
class B
{
int i;
public B()
{
i=10;
}
};
public class A extends B
{
public static void main(String[] args)
{
A a=new A();
System.out.println("Hello World!"+a.i);
}
}
运行的结果是:Hello World!10
在A中并没有给i值操作,真正操作的是在B的构造函数中,这说明A在创建的时候的确先创建了
B,而且B也的确存在于内存中,它并没有一个真正的实例指向它,但它可以通过子类防问!
就如同我先前讲,这类似一种塔式结构,每个子类都会从根部为它的每个父类调用构造函数

class B
{
int i;
public B()
{
i=10;
}
};
public class A extends B
{
public static void main(String[] args)
{
A a=new A();
System.out.println("Hello World!"+a.i);
}
}
运行的结果是:Hello World!10
在A中并没有给i值操作,真正操作的是在B的构造函数中,这说明A在创建的时候的确先创建了
B,而且B也的确存在于内存中,它并没有一个真正的实例指向它,但它可以通过子类防问!
就如同我先前讲,这类似一种塔式结构,每个子类都会从根部为它的每个父类调用构造函数

首先，你的感谢ONLY YOU对本问题的关注，本人的语气是有点问题，如果冒犯了你的话，
我在此对您表示歉意，当时可能只关注问题的解决没有顾及太多其他的问题。
我猜存在父类的镜像并不是说存在他的实例的，只是存在他的类的的映射。
不过CreateFile类这里没有设计好，后来我用
FileClass ei = (FileClass)Class.forName(className).newInstance()来代替，这样的话就简单了，
不然的话，CREATEFILE类的话不太好被人理解。我写的时候也觉得扁扭！

多人接受答案了。