The following code gives me this error when i try to compile it alone:
Here is the code:
public class GameObject {
private int x;
private int y;
private float x_velocity;
private float y_velocity;
public abstract void Draw();
public abstract void Update();
}
Any ideas?
i don’t think a non-abstract class can have abstract methods, because then you could create instances of it which don’t have that method implemented.
so add a (empty) implementation to those methods, or make the whole class abstract
Yes, only abstract classes can have abstract methods. Note that the private data will not be accessible to derived classes, so if you do want them to be accessible then make them protected.
to add; technically a class with abstract methods is an abstract class 
and you cant instantiate something that doesnt know how to behave 
An abstract class doesn’t need abstract methods at all, to be abstract.
public [b]abstract[/b] class Foo {
}
Well that would be completely pointless 
I’m talking about an empty abstract class! A class with abstract methods is an abstract class, that statement doesn’t mean that a class without abstract methods is not an abstract class
that code was just an example of abstract class with no abstract methods, nothing to do with empty abstract classes (although it is one), your reply seems to be on sentence so this where confusion started
Well I’m not confused in any way; Mr Light took the statement of abstract methods implies abstract class to mean abstract class implies abstract methods Of course I was just saying that an empty class is pointless, then Abuse thought I was talking about an abstract class with no abstract methods
Though empty interface/classes are quite common for tagging purposes: Serializable. Could argue this has been superceeded by annotations though.
Kev
IMO that’s the exception of the rule as what they wanted to create was a class/interface that made your class serializable however they couldn’t make it a class as it would restrict derived classes from extending anything else and did not want to create an interface with a method that you only implement if you want a custom implementation.
What they could have done is either (a) had a method that stated whether it had a custom implementation with a corresponding empty method, or (b) had the methods return a boolean stating whether or not it wanted it to be processed in the default way. But having said that it does make sense to create an empty interface if your class agrees to a particular pattern that cannot (or should not) force a specific implementation. An example would be having all methods beginning with verify* to have a corresponding process* for every create* (or something of that nature).
What I was saying is that abstract methods don’t make the class abstract at all. Methods are 2nd to the class definition. A class with abstract methods isn’t an abstract class at all. Your turning abstract classes only permit abstract methods around, just because the compiler throws an error if that contact is not held. Because of the contact abstract methods do imply an abstract class. However if you blindly decorate a class with abstract every time you define an abstract method your doing something wrong. Yeah next thing you know you have IFoo AbstractFoo Foo or other stupid nonsense all over the place.
It is not the case that abstract classes only permit abstract methods; if that were the case, then they would be interfaces. Abstract methods may only be defined within abstract classes. See http://java.sun.com/docs/books/tutorial/java/IandI/abstract.html, or try to compile:
class AbsTest { abstract void foo(); }
Incidentally, one may define methods within an interface as abstract, although it is redundant. One may also define interfaces as abstract, but it has no meaningful semantics. I have done this as an note to myself that I intend to create a subinterface of the abstract interface.
It’s true Serialization is a special case. However, as you say later using an empty interface (or class in some cases) makes sense when you’re defining something that conforms to some entity description but doesn’t require any additional method implementations, so I’d hardly consider Serialization the only exception to the rule that empty interfaces/classes are useless. Useless to a coder, useful to a designer maybe ;). It’s often referred to as a tagging (or marker) interface.
Kev
you misinterpreted, perhaps the order in the sentence is wrong, I didn’t mean/say? abstract classes permit abstract and only abstract methods. “It is only in abstract classes that abstract methods are permitted.”
Interfaces are abstract classes with a special contract that specifies that no concrete methods are allowed. Because of java’s inheritance system/strategy/philosophy there are special abstract classes. (Interfaces don’t exist in general OO the word was lend from system-design)
I believe the JLS is a bit more foggy/fuzzy about it, but I count interfaces as abstract classes, so yes as we both said; Abstract methods may only be defined within abstract classes.
But the point I was making was… etc.