13

I'm a C++ programmer currently learning Java and I'm wondering if OOP in Java follows the same principle of separation of class definition and declaration as C++ does, ie. place them both in separate files. I've had a look around the internet, including the Android developer website, and all the code I've come across has the definition and declaration carried out at the same time.

Is this simply one of the difference between development in C++ and development in Java, or are the sources I've been looking at simply doing things that way to limit the complexity of their code for posting on the internet? I have seen declarations and definitions combined in some C++ documentation, though I know it is bad practice to do so.

Improve this question
7
  • Well you have interfaces and their implementation separation in Java. Commented Jan 16, 2012 at 13:52
  • 2
    What's with everyone and interfaces? That's absolutely not what they are for. Separating a single class into interface and implementation makes no sense: they exist to allow a lightweight form of multiple inheritance, to describe a general behaviour that can be implemented separately. This is different from C++'s separation of definition of a specific class. Commented Jan 16, 2012 at 13:57
  • 1
    Separating a single class into interface and implementation makes perfect sense when the class is "heavy" and you want an easy way to, for example, create a mock for your testing code. Of course, doing it for very simple classes may be overkill. Commented Jan 16, 2012 at 14:00
  • @Viruzzo Agreed. We don't need every class to have a IMyClass and MyClassImpl. Commented Jan 16, 2012 at 14:02
  • Quite; the distinction between classes and interfaces in Java has very little in common with that between headers and definitions in C++. Commented Jan 16, 2012 at 14:05

7 Answers 7

Reset to default
10

There is a practical reason for separating declaration in C++, and it's to allow source files to be compiled separately. There is no such need in Java (as everything is compiled to bytecode separately), so it isn't allowed.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Another reason for the separation in C++, as I recall, is that you can give someone your class' public interface without giving them the code. In Java, this metadata is in the .class file, so you don't need a separate header.
@yshavit true, of course; it all comes down to being able to compile without having to include the other classes' source (respectively for perfomance and for security reasons).
5

The below answer has been edited heavily based on the comments.

You do not need to split your class into definition and declaration purely for the compiler's sake, as there is no need for forward declarations in Java (as there is in C++). You may want to split a class definition and declaration into an interface/class pair (or [abstract] class/class pair) due to design requirements, such as:

  • Multiple classes implementing a single interface.
  • Remote Procedure Calls, where you don't want to expose any of your class dependencies (since they may not be available on the client side)
  • Class that is used by other classes, but you don't need/want its full functionality when testing (ex. database access service which you may want to mock in your test code)

However, this is more akin to using a virtual base class and concrete implementing classes in C++ and is often called "programming to an interface". You can read more about the technique in this article (with some arguments there why you may prefer to use an abstract class instead of an interface as the base). Also, such splitting should be considered carefully; in many cases, splitting a class is just pure overkill and will lead to unnecessary code bloat.

Therefore, the short answer is: you don't need to split the class only for the sake of having forward declaration (which the original question asks), though you may want to do it if there is a design reason to (but this is not the equivalent of C++'s header/class file split).

Improve this answer

13 Comments

+1: Use interfaces to separate the contract from the implementation.
-1: Justified if multiple implementations of MyService are needed; otherwise it's premature abstraction (which is the root of much evil)
(for the edit) but that behavious is comparable to C++'s pure abstract classes, still not directly related to declaration separation. Understand that the main source of controversy here is the "to achieve similar functionality" part: these functionalities are not directly related!
@AndrewSpencer even if you have only one implementation it can be useful to introduce an interface, e.g. when the implementation has some dependencies that users shouldn't be required to import. For example, if I have a remote service that depends on - let's say Spring - the client should not have to import Spring just to be able to call that service. All that's needed is the interface and a dependency for the remote call API. And then there are frameworks which just require interfaces, like JEE 5.
@Thomas you are missing the point: yes, there are cases when interfaces are required and yes, sometimes useful even for a single implementation, but no, this doesn't directly relate to C++'s header files. As for " the implementation has some dependencies that users shouldn't be required to import" what do you mean? Even if you refer only to the interface you will require any and all of the implementation's dependencies, even if you load it at runtime.
|
3

In Java you don't have a choice: the classname is linked to the file name. For a file named x/y/z/T.java from the root of your source files, T.java must look like:

package x.y.z; [some modifiers here] class T { // class T here }

There are ways to separate "class definition" from "implementation", the closest to what you have in mind is declaring an interface I and having a class C implementing I. Also consider abstract classes.

An interface has the exact same constraint except you declare an interface instead of a class. An abstract class is just a class with the abstract modifier.

Improve this answer

Comments

1

There are no header and source files in Java like you have in C++. If you want to separate the class declaration from its implementation, you can define an interface that declares the methods and then create a class that implements the interface.

Improve this answer

11 Comments

Why the downvote? Just because everyone answered the same thing at the same time?
An awful lot of people don't agree that this is a "wrong" answer.
I know I do; as for the awful lot of people, they can vote as everyone else.
@Viruzzo if you vote everyone down, then please explain why you consider the answers wrong.
I did in the question's comments.
|
0

In Java you have one class in one file, i.e. you can't - and don't need to - split classes over multiple files (you can have multiple non-public classes in one file though).

What you can do is use interfaces, i.e. define the interface for a class in one file and implement that interface in a class in another file. If you then distribute the API you just distribute the interface.

Improve this answer

Comments

0

The separation you write about does not exist in Java. You can separate the method definitions (non static ones) to an interface.

Improve this answer

Comments

0

No, this kind of separation is not present in java. But look at the interface keyword. you can declare interfaces explicitly!

Improve this answer

1 Comment

I don't understand why -1. The answer is short, but what is wrong?