Nevertherless, I happen to have regurgitated this phrase in a conversation, and found that the internet appears to be against me, but I am sure that there is something about Java being a pretty much 100% OO language because of this. Am I wrong?

List<Double> nums = new ArrayList<Double>();
...

for (double num : nums) {

...

}

private void foo(Integer i) {
  i = 6;
}

There is no "toString", but there is String.valueOf(prim) where prim is a value type, so you don't have to "new" anything to convert a primative to a string. It is possible that this ends up creating an object and calling toString in most Java implementions internally.

By default the Java compiler minifies parameter and field names. So if you do reflection on a parameter name and it was "pizza", you might find that Java will return "a" instead. This is mitigated by compiling in debug mode.

2 hours ago, exoteric wrote

Also, in C# you can extend value types like int or System.Drawing.Color using extension methods.

I'd like C# more if you could import namespaces, but not extension methods. So you'd have to do "using System.Linq.Enumerable;"

as opposed to just "using System.Linq;" and getting intellisense-pollution.

3 hours ago, Bass wrote

In Java people do similar things using static imports. It's not quite as 'object-oriented' as extension methods, but I think when used intelligently it makes code look really succinct (eg: in the case of JUnit).

It's good that Java got static imports so you don't need to write Math.bla all the time. Extension methods, on the other hand, usually come with natural auto-complete (Intellisense) support so you automatically see what methods apply to a value of a given type.

That said, you could probably cook up some nice auto-complete tool support for static imports so they act like extension methods: dot into a type and you see static imports as well. Select the static method and it rewrites from bla.method() to method(bla).

Eclipse can also rewrite a Static.foo() to foo() automatically by hitting CTRL-SHIFT-M.

1 day ago, Bass wrote

@magicalclick:

What is wrong with something like this? Integer is a ref type.

1 2 3

privatevoidfoo(Integer i) {   i = 6; }

I use int.

Just so you know, it is not only for consistancy. While most people use int, not Integer, there is more to it. If you are going to do uint[ int.Max ], you would waste memory on pointers. And this is crucial for stuff like BioInformatics.

Of course, it is kinda pointless to use Java on BioInformatics. Everyone has tried on Java gave up and switch to C++ due to massive performance issues.

Lolwut?

Compare to P/Invoke... Wow

6 hours ago, Bass wrote

So we are clear: you use a value type instead of a reference type when you want to use a reference type. For consistency.

Lolwut?

.............. ok, debate ref parameter to C++ and C# creators. I did not create ref parametr, they did.

FYI, I do not want to use ref type, like I said, ref type is not feasible in BioInformatics. I want to use value type and ref parameter. Please don't change my intention. And while I didn't make it so obviouse, ref parameter can skip a lot of unnecessary instuctions and when doing instructions at billion scale, it matters a lot.

This is getting confusing. My thought on int is.

Memory Address -> value.

And a custome class is

Obj Pointer -> realy memory address -> value.

And I want the first one, not second one. "Integer" is first or second?

    public static void modify(ref int i)
    {
        i = 10;
    }

does not do the same thing as the Java code:

    public static void modify(Integer i)
    {
        i = 10;
    }

The Java code will only change the value of i inside the method. Which in the case I've contrived does absolutely nothing.

public class Interger

{

 int _value;

 override operator = .....

}

But, still, Integer is not int. It cost extra pointer in memory. Unless I am wrong? Which no one has yet to explain how Integer is structured.

IMO, Integer[ one billion ] = ( 64bits pointer + 32bits value ) * one billion. Which is absolutly big no no in my previous examples.

And just for me only, I totally don't like to use objects when I can use primitives. Some people can debate this to death, but, I want to use int, that's all that matters.

1 hour ago, magicalclick wrote

?? I think Integer is fine? It is essentially

public class Interger

{

 int _value;

 override operator = .....

}

But, still, Integer is not int. It cost extra pointer in memory. Unless I am wrong? Which no one has yet to explain how Integer is structured.

IMO, Integer[ one billion ] = ( 64bits pointer + 32bits value ) * one billion. Which is absolutly big no no in my previous examples.

And just for me only, I totally don't like to use objects when I can use primitives. Some people can debate this to death, but, I want to use int, that's all that matters.

 

Java doesn't do operator overloading, so:

public static void doStuff(Integer i) {
  i = 5;
}

is equivalent to:

public static void doStuff(Integer i) {
  i = new Integer(5);
}

You're only changing doStuff's reference to i, not changing its actual value (the caller won't see the change).  You actually can't do the latter; Integer is immutable in Java.

[edit] And now I remember why I stopped posting.  Why in the world does this piece of crap forum dump you back to the first page of a thread when you post?

Yupe, C9 forum is still really bad. But, it doesn't do stuff like, reply and back to first page with no textbox. That was horrifying.

Nowhere in Java can you pass a parameter, assign it and have that assignment be anything but local to the method.

You can't in C# either (without the ref or out keywords) because even though it supports operator overloading, to prevent exactly this problem, it does not allow you to override the assignment operator.

C++ is a different kettle of fish because it makes it much more explicit what is a reference or pointer and what is not.

Thanks to clear that up on my first point. Because for some odd reason a guy told me to use some crappy non-value type and pretent it is the same. That actually confused me to think "Integer" is some kind of wacky special value type which apprently is not.

Thanks for the override info too.

void MyPassByRef(int[] i)
{
  i[0] = 42;
}
int Main()
{
  int value = 7;

  int[] byRef = new int[1]; byRef[0] = value;
  MyPassByRef(byRef);
  value = byRef[0];

  // value is now 42
  return value; 

} 

It supports anonymous classes, which work very similar to closures.

16 minutes ago,Bass wrote

@BitFlipper:

It supports anonymous classes, which work very similar to closures.

It's not very similar at all. For one, anonymous classes do not capture variables/parameters, which is one thing that makes closures so useful.

2 minutes ago,BitFlipper wrote

*snip*

It's not very similar at all. For one, anonymous classes do not capture variables/parameters, which is one thing that makes closures so useful.

They capture any variables marked final.

Yes and final variables cannot be changed, once again losing a lot of what real closures give you.

Plus the syntax compared to C#'s closures are verbose and clunky. Java's anonymous classes are a poor man's closure.

I agree that anonymous classes are verbose. But any modern IDE will generate the anonymous class for you using autocomplete, so the amount of keystrokes in Java and C# ends up being very similar.

6 hours ago,Bass wrote

@BitFlipper:

I agree that anonymous classes are verbose. But any modern IDE will generate the anonymous class for you using autocomplete, so the amount of keystrokes in Java and C# ends up being very similar.

I think bringing the IDE into the argument is a bit of a red herring. The fact remains that anonymous classes are not closures. Aside from the extra boilerplate, which I agree is not that much of a big deal, they're just not as versatile. The final variable requirement is just stupid.

17 hours ago,Ray7 wrote

*snip*

I think bringing the IDE into the argument is a bit of a red herring. The fact remains that anonymous classes are not closures. Aside from the extra boilerplate, which I agree is not that much of a big deal, they're just not as versatile. The final variable requirement is just stupid.

How it a red herring? I doubt people writing Java are using Notepad to code. The IDE indirectly fixes a lot of the language's deficiencies.

I never encountered a time where I was like "damn I wish I could write closures for mutable value types". So I don't find the final requirement to be a big deal.

Oracle intends to add "true closures" to Java 8, but I am not sure what that will accomplish other then complicating the language. If they really want to improve Java they'd let me disable checked exceptions somehow.