使用Java进行多少处理和内存使用？

Question

我正在考虑是否有两个指针更好，每个对象子类和超级一个，或者我是否应该使用强制转换。

这使用了多少系统资源：

objectName.functionOne();
((SubClass) objectName).functionOther();

它比以下更好：

SuperClass objectA = (SuperClass) getSameInstance();
SubClass objectB = getSameInstance();
objectA.functionOne();
objectB.functionOther();

基本上，我的主要问题是关于使用铸造的资源，而不是制作额外的指针。 看起来我可以保存几个在线演员阵容，例如：

((SubClass) objectName).functionOther();

但是，值得吗？

谢谢，
GRAE

更新：

我的问题有一些不清楚的部分。 基本上，我有一个超级类，我通过一个大功能使用。 它适用于三个子类。 有些超级班级正在按照我的意愿行事。 但是，我在一些地方碰到了路障，我必须使用三个不同子类中的一个来完成一个功能; 仅在其中一个子类中的函数。

我可能只有：

SuperClass instanceRef;
SubClass instanceRef2;

instanceRef.etc()
instanceRef.etc2()
instanceRef.etc3()
instanceRef2.specialSubClassOnlyCall();
instanceRef2.specialSubClassOnlyCall2();

或者我可以：

SuperClass instanceRef;

instanceRef.etc()
instanceRef.etc2()
instanceRef.etc3()
((SpecialSubClass)instanceRef).specialSubClassOnlyCall();
((SpecialSubClass)instanceRef).specialSubClassOnlyCall2();

但是，我不知道哪个更有效率。

更新2：

这是一个例子，向您展示我在说什么：

class Shape
Triangle extends Shape
Square extends Shape
Circle extends Shape
Cube extends Shape

两个指针示例:(缩小额外指针。）

Shape pointer1 = (Shape) getSomeRandomShape();
Cube pointer2 = null;

pointer1.getWidth();
pointer1.getHeight();
pointer1.generalShapeProp();
pointer1.generalShapeProp2();
pointer1.generalShapeProp3();

if(sure_its_cube)
{
   pointer2 = (Cube) pointer1;
   pointer2.getZAxis();
   pointer2.getOtherCubeOnlyThing();
   pointer2.getOtherCubeOnlyThing2();
   pointer2.getOtherCubeOnlyThing3();
   pointer2.getOtherCubeOnlyThing4();
}

或者我可以这样做。 （下面是一堆演员。）

Shape pointer1 = (Shape) getSomeRandomShape();

pointer1.getWidth();
pointer1.getHeight();
pointer1.generalShapeProp();
pointer1.generalShapeProp2();
pointer1.generalShapeProp3();

if(sure_its_cube)
{
   ((Cube)pointer1).getZAxis();
   ((Cube)pointer1).getOtherCubeOnlyThing();
   ((Cube)pointer1).getOtherCubeOnlyThing2();
   ((Cube)pointer1).getOtherCubeOnlyThing3();
   ((Cube)pointer1).getOtherCubeOnlyThing4();
}

那么五个演员比一个额外的指针更差吗？ 什么是六个演员，或20？ 是一个演员比指针差。

GRAE

Answer 1

做任何使代码更清晰的事情，忘记微优化。

Answer 2

从您的代码片段可以 getSameInstance() ， getSameInstance()返回一个 SubClass 。 在这种情况下，最简单的解决方案是

 
 
 
  
  SubClass objectB = getSameInstance(); objectB.functionOne(); objectB.functionOther();
 
  

没有演员阵容，没有后顾之忧:-)

正如其他人正确指出的那样，主要关注的应该是代码可读性和简单性，而不是性能。 只有当您知道自己需要时才进行优化，并且已经证明（使用分析器）代码中存在瓶颈 。 即使在这种情况下，微优化在Java中也很少有用。

另外注意：如果方法很重（在这种情况下，你有效地使你的代码变慢，而不是更快），或者有副作用（在这种情况下你的程序的行为可能会明显改变），调用相同的方法两次可能会有问题。

顺便提一下你的代码片段

SuperClass objectA = (SuperClass) getSameInstance();

绝对没有必要将返回值向上转换为SuperClass - 超类引用总是可以指向子类对象。 （我想无论如何编译器都会忽略这样的upcast，所以它在字节码中没有区别。）

更新

你还没有发表我要求的方法的声明。 但根据你的解释，我认为它应该看起来像

public Shape getSomeRandomShape();

它是否正确？

这将意味着你的第二个原始代码片段（带有getSameInstance()调用）不正确 - 强制转换应该是相反的方式。 你设法让我迷惑了，所以你有一个令人困惑的答案:-)

同样在最新的示例中，您不需要将返回值强制转换为(Shape) ，因为它已经是Shape 。 演员阵容让你的代码变得混乱。 同样，UPDATE 2的第二个示例中的许多强制转换使代码难以阅读。 我更喜欢第一个版本，有两个引用（ 不是指针btw - Java没有指针）。

我只关心这里的代码可读性 - 正如其他人已经注意到的那样， 你真的应该浪费你的时间来考虑演员阵容的成本 。 只需专注于使您的代码尽可能简单易读 。 您很可能永远不会注意到您在上面显示的两个代码片段的性能之间的微小区别（除非他们在紧密循环中执行数百万次 - 但是，我猜，JIT会优化无论如何都被抛弃了）。 但是，您会注意到理解一个代码段与另一个代码段之间的差异，对于不熟悉此代码的人 - 或者已经忘记了详细信息的人，可能是您在大约6个月内。

Answer 3

转换不是在运行时完成的“操作”。 编译器只需要确保静态类型安全。

刚看了JVM代码，这两种方法基本相同，它们实现为

CHECKCAST Main$B
INVOKEVIRTUAL Main$B.mySubMethod()V

因此存在一个小的开销，但在两种情况下都是相同的（因为你无论如何都要做一个向下转换）。

Answer 4

可读性和代码维护应该是这样的优先事项，而不是性能，除非你真正遇到瓶颈（极不可能）。

但是，没有理由有两个引用（指针）。 只需引用子类。 在几乎所有情况下，您可以使用子类引用对超类引用执行任何操作（重载方法的参数是我所知道的唯一例外）。

Answer 5

只需使用更易于阅读的解决方案，并保持最清洁（可能是第一个解决方案）。 在这么低的优化水平下，除了在你真正需要额外0.01％性能提升的边缘情况下，它真的不值得。

对于它的价值，你实际上并不需要将子类强制转换为超类引用（列出的第二个解决方案），只是反过来。 在将超类强制转换为子类时，通常首选在强制转换之前使用instanceof验证其类型，而不是进行假设。

Answer 6

假设您有一台64位计算机，它可以节省8个字节的资源。 让我们说你花了10分钟考虑一下。 这是好用的时间吗？

1 GB增加了大约100美元的服务器成本，因此8字节的成本约为0.0000008美元

10分钟的时间最低工资价值约1美元。

资源是可重用的，你的时间不是。 更重要的是，任何人阅读/支持您的代码的时间可能更加昂贵，这就是简单/清晰度更为重要的原因。