Java IntBuffer（和其他基元类型缓冲区）的工厂方法返回实例，但这些类实际上是抽象定义的

看起来无论如何都不能创建这个类的实例，因为它声明了抽象，但同时有一个静态工厂方法

IntBuffer-allocate（int-capacity）

现在您只需通过

Buffer b=IntBuffer.allocate（128）

但是等等，IntBuffer是抽象的，它没有任何预定义的具体子类。那么这是如何工作的呢

编辑-------------

---

我已经怀疑它返回了IntBuffer的一个子类，但是我找不到HeapIntBuffer或任何这样的子类。我想这是私下宣布的吗？？因此它从api文档中消失了

仅仅因为有一个静态方法，并不意味着它只是创建了一个

IntBuffer

的实例。下面是工厂方法可以做的事情的一个简短示例：

abstract class IntBuffer

抽象类抽象{
静态抽象createInstance（整数大小）{
返回大小<10？新的SmallImplementation（）：新的LargeImplementation（）；
}
公共抽象字符串getDescription（）；
}
类实现扩展了抽象{
@重写公共字符串getDescription（）{
return“我是小尺寸的实现”；
}
}
类LargeImplementation扩展了抽象{
@重写公共字符串getDescription（）{
return“我是大尺寸的实现”；
}
}
公开课考试{
公共静态void main（字符串[]args）引发InterruptedException{
抽象小=抽象.createInstance（1）；
抽象大=抽象.createInstance（100）；
System.out.println（small.getDescription（））；
System.out.println（large.getDescription（））；
}
}

---

这基本上是多态性的核心——测试中的代码；由工厂方法选择正确的实现。

仅仅因为存在静态方法，并不意味着它只是创建了

IntBuffer

的实例。下面是工厂方法可以做的事情的一个简短示例：

abstract class IntBuffer

抽象类抽象{
静态抽象createInstance（整数大小）{
返回大小<10？新的SmallImplementation（）：新的LargeImplementation（）；
}
公共抽象字符串getDescription（）；
}
类实现扩展了抽象{
@重写公共字符串getDescription（）{
return“我是小尺寸的实现”；
}
}
类LargeImplementation扩展了抽象{
@重写公共字符串getDescription（）{
return“我是大尺寸的实现”；
}
}
公开课考试{
公共静态void main（字符串[]args）引发InterruptedException{
抽象小=抽象.createInstance（1）；
抽象大=抽象.createInstance（100）；
System.out.println（small.getDescription（））；
System.out.println（large.getDescription（））；
}
}

---

这基本上是多态性的核心——测试中的代码；由工厂方法选择正确的实现。

仅仅因为存在静态方法，并不意味着它只是创建了

IntBuffer

的实例。下面是工厂方法可以做的事情的一个简短示例：

abstract class IntBuffer

抽象类抽象{
静态抽象createInstance（整数大小）{
返回大小<10？新的SmallImplementation（）：新的LargeImplementation（）；
}
公共抽象字符串getDescription（）；
}
类实现扩展了抽象{
@重写公共字符串getDescription（）{
return“我是小尺寸的实现”；
}
}
类LargeImplementation扩展了抽象{
@重写公共字符串getDescription（）{
return“我是大尺寸的实现”；
}
}
公开课考试{
公共静态void main（字符串[]args）引发InterruptedException{
抽象小=抽象.createInstance（1）；
抽象大=抽象.createInstance（100）；
System.out.println（small.getDescription（））；
System.out.println（large.getDescription（））；
}
}

---

这基本上是多态性的核心——测试中的代码；由工厂方法选择正确的实现。

仅仅因为存在静态方法，并不意味着它只是创建了

IntBuffer

的实例。下面是工厂方法可以做的事情的一个简短示例：

abstract class IntBuffer

抽象类抽象{
静态抽象createInstance（整数大小）{
返回大小<10？新的SmallImplementation（）：新的LargeImplementation（）；
}
公共抽象字符串getDescription（）；
}
类实现扩展了抽象{
@重写公共字符串getDescription（）{
return“我是小尺寸的实现”；
}
}
类LargeImplementation扩展了抽象{
@重写公共字符串getDescription（）{
return“我是大尺寸的实现”；
}
}
公开课考试{
公共静态void main（字符串[]args）引发InterruptedException{
抽象小=抽象.createInstance（1）；
抽象大=抽象.createInstance（100）；
System.out.println（small.getDescription（））；
System.out.println（large.getDescription（））；
}
}

---

这基本上是多态性的核心——测试中的代码；由工厂方法选择正确的实现。

它起作用，因为allocate不返回IntBuffer，而是返回IntBuffer的子类。以下是IntBuffer.allocate的源代码：

abstract class Abstract {
   static Abstract createInstance(int size) {
       return size < 10 ? new SmallImplementation() : new LargeImplementation();
   }

   public abstract String getDescription();
}

class SmallImplementation extends Abstract {
   @Override public String getDescription() {
       return "I'm an implementation for small sizes";
   }
}

class LargeImplementation extends Abstract {
   @Override public String getDescription() {
       return "I'm an implementation for large sizes";
   }
}

public class Test {
   public static void main(String[] args) throws InterruptedException {
       Abstract small = Abstract.createInstance(1);
       Abstract large = Abstract.createInstance(100);
       System.out.println(small.getDescription());
       System.out.println(large.getDescription());
   }
}

---

分配很好。

它可以工作，因为allocate不返回IntBuffer，而是返回IntBuffer的子类。以下是IntBuffer.allocate的源代码：

abstract class Abstract {
   static Abstract createInstance(int size) {
       return size < 10 ? new SmallImplementation() : new LargeImplementation();
   }

   public abstract String getDescription();
}

class SmallImplementation extends Abstract {
   @Override public String getDescription() {
       return "I'm an implementation for small sizes";
   }
}

class LargeImplementation extends Abstract {
   @Override public String getDescription() {
       return "I'm an implementation for large sizes";
   }
}

public class Test {
   public static void main(String[] args) throws InterruptedException {
       Abstract small = Abstract.createInstance(1);
       Abstract large = Abstract.createInstance(100);
       System.out.println(small.getDescription());
       System.out.println(large.getDescription());
   }
}

---

作业很好。

它工作，因为分配不起作用