Your example won't even compile. You're confusing functions with lambda expressions. Lambda expressions look a little like a function but they are something different. Lambda can be compiled into functions at run time and that's often what they're used for, but they can't be implicitly assigned to a var. Doing it you're way would look like this:

    Expression<Func<string>> func = () => "foo";
    func.Compile()();
    

That's hardly better, and it's still not anonymous! You probably like Lambda Expressions because they make things like LINQ elegant, and indeed they do. But a lambda expression is confusingly similar looking to a func (indeed a mistake you made) but when you try to do something more complicated like this:

    Expression<Func<string>> func = () =>
    {
      string foo = "bar";
      return foo;
    };
    

That won't compile because a lambda expression can't have a statement body, it can only contain (a single!) expression.

Now the cool thing about lambda expressions is that to the end user they are simple and elegant assuming you know that they are not the same thing as functions, but on the other end of it; consuming a lambda expression you get to see the guts of it and realize what a hack it is on the language. Sure, in the context of a compiled statically typed language it's rather powerful. It's how they are able to compile a lambda expression into a SQL statement, because you can inspect lambda expressions which you can't do to functions.

Now you asked about Java and I'm not going to defend Java or predict what their intentions are, but I'll just say that Java is being much more conservation about sticking to what it is; a statically typed compiled language. C# is attemping to be everything to every body.