I am a newbie in Java. With this code:
public class MyClass{
enum State {STATE1, STATE2, STATE3}
State curState;
...
public MyClass(){
curState=STATE1;
}
}
I get error
STATE1 cannot be resolved to variable
If I chage STATE1 to State.STATE1 everything works, but I don't want to write enum name every time! I don't understand why I have to. enum is declared in the MyClass scope.
One possible solution is to use a static import. For instance if all the above is in the pkg package, then:
package pkg;
import static pkg.MyClass.State.*;
public class MyClass {
enum State {
STATE1, STATE2, STATE3
}
State curState;
// ...
public MyClass() {
curState = STATE1;
}
}
As per the Static Import Tutorial:
The static import construct allows unqualified access to static members without inheriting from the type containing the static members. Instead, the program imports the members, either individually or en masse.
Related
When we want to close a class to inheritance we are declaring class with final,
final class Myclass {}
but when we declare the constructor private it will be the same effect,
class Myclass {
private Myclass() {}
}
But is it really the same? Is there any difference for optimization of code or readability of code? And which classes has to close to inheritance,
immutable class maybe
every method and member variable declared static of class
But for second option java.util.Arrays hasn't been declared with final even if all methods of Arrays are declared static.
but when we declare ctor private it will be the same effect
Not necessarily, consider this example using static classes:
public class SOExample {
private static class ClassWithPrivateConstructor {
private ClassWithPrivateConstructor() {
System.out.println("I have a private constructor");
}
}
private static class ClassThatExtendsClassWithPrivateConstructor extends ClassWithPrivateConstructor {
}
public static void main(String[] args) {
new ClassThatExtendsClassWithPrivateConstructor();
}
}
This will print "I have a private constructor".
but is it really same? is there any difference for optimization of code or readablity of code. and which classes has to close to inheritance,
When a developer sees that a class is final, they understand that the intention of the author was that it should not be extended.
When a developer sees that a class has a private constructor, they understand that the class can't be instantiated. This is generally because it is either a static utility class or a singleton.
But for second option java.util.Arrays hasn't declared with final even if all methods of Arrays declared static
This is a good observation. My guess is that it probably should have been but can't be changed now for backward compatibility.
What I usually do is I make the class final and the constructor private:
it removes the ambiguity about the class use (emphasising it's a utility class)
it keeps the user away from what they aren't supposed to do (to initiate, to extend).
.
#NoArgsConstructor(access = AccessLevel.PRIVATE)
public final class HttpTool {}
That said, there is nothing wrong with java.util.Arrays. The designer achieves the desired effect (non-instantiability) with the necessary minimum (the private constructor).
If you want to create an immutable class or just a class that for some reason should not have childrens you should declare it as final. Private constructor should be used in utility classes, this way you block inheritance and also make sure instance of the class cannot be created.
I'm new to JAVA and im trying to understand how inheritance works.
I have 3 classes:
package dziedziczenie2;
public class Kobieta {
protected Oczy Eyes = new Oczy();
public static void main(String[] args) {
Kobieta x = new Kobieta();
System.out.println(x.Eyes); // blue
x.Eyes.kolor = "red";
System.out.println(x.Eyes); // red
}
}
class Oczy{
public String kolor = "blue";
public String toString(){
return kolor;
}
}
other package:
package dziedziczenie;
import dziedziczenie2.Kobieta;
public class Ania extends Kobieta{
public static void main(String[] args) {
Ania x = new Ania();
System.out.println(x.Eyes); // blue
x.Eyes.kolor = "red"; // type Oczy not visable
}
}
My questiong is, why i cant change Eye.kolor in Ania class simply my typing x.Eyes.kolor.
I know that Oczy is not public, but i can use its toString method somehow.
EDIT: Why i can use its toSting method and i cant use its member?
Do I have to make a method in Kobieta that will interact with Oczy member for me every time i want to interact with Oczy member from other package?
Thanks in advance
The class Oczy has access modifier "default" which is accessible only in the package "dziedziczenie2" n not in package "dziedziczenie".
1) Option:
You may simply create a file Oczy.java with declaring public class Oczy and u r done.
2) Option:
You may declare public static class Oczy in the class Kobieta like this.
public class Kobieta {
// ur code
public static class Oczy {
// ur code
}
}
Eyes is of type Oczy which has default visibility, since it has no access modifier. You can only access its members in the same package it's declared in, even if those are public.
Do I have to make a method in Kobieta that will interact with Oczy
member for me every time i want to interact with Oczy member from
other package?
You can do that or you can move the Oczy to its own compilation unit (.java file) and make it public.
If I understand correctly you are expecting Eyes to be inherited to Ania class.
Because in inheritance attributes are not inherited like methods. Eyes is attribute of Kobieta class so when Ania extends Kobieta it dont inherit it.
I have followed Singleton:
public class GameConfig {
private static GameConfig mGameConfig = null;
private String mStr = "Boo";
public static GameConfig getInstance(){
if(mGameConfig == null){
mGameConfig = new GameConfig();
}
return mGameConfig;
}
private GameConfig(){}
public String getStr() {
return mStr;
}
}
Now I try to do some experiment:
Lets say I have other class User that goes to use this singelton:
public class User{
....
private void init(){
String str = GameConfig.getInstance().getStr();
}
}
So far so good.
I'll take above mentioned class User and add import static:
import static com.app.utils.GameConfig.getInstance; // no error, why??
public class User{
....
private void init(){
String str = GameConfig.getInstance().getStr();
// I can't type
// String str = getStr(); !!
// getInstance return instance
}
}
Why is there no error? Because that's valid syntax. Isn't it good for things to work?
import static com.app.utils.GameConfig.getInstance; // no error, why??
will make getInstance() available without naming the class, for instance:
GameConfig gc=getInstance();
As a side note, I'd rename the method to be more descriptive, like getGameConfig.
The Java Language specification has the answer. First, the definition of a member
A class body may contain declarations of members of the class, that
is, fields (§8.3), methods (§8.4), classes (§8.5), and interfaces
(§8.5).
A class body may also contain instance initializers (§8.6), static
initializers (§8.7), and declarations of constructors (§8.8) for the
class.
And the definition of a single static import
A single-static-import declaration imports all accessible static
members with a given simple name from a type. This makes these static
members available under their simple name in the class and interface
declarations of the compilation unit in which the single-static-import
declaration appears.
SingleStaticImportDeclaration:
import static TypeName . Identifier ;
The static method getInstance is a static member of the GameConfig class. You can therefore import it with
import static com.app.utils.GameConfig.getInstance;
If in the below
// I can't type
// String str = getStr(); !!
you meant for getStr() to be static method of GameConfig, it makes sense that it won't compile, since you haven't imported that member.
There is no error becuase the static import is valid. static imports allow to import the static content from a class. This allows to use the static variables/methods directly wihtout using the class name.
Also you cannot use getStr directly because that is not a static method.
Since it is a valid static import.So no error.
According to java static import
The static import construct allows unqualified access to static members without inheriting from the type containing the static members. Instead, the program imports the members, either individually. at
Here getInstance() is static member so it is valid import statement.
I have a code:
package why;
public class Foo
{
public class Foo1
{
String bar;
public Foo1(String bar)
{
this.bar = bar;
}
public static Foo1 MYCONSTANT = new Foo(null);
}
}
Why do I get 'non-static variable this cannot be referenced from a static context'?
I allocate the instance of non-static class.
Why even here?
public static Foo getMYCONSTANT()
{
return new Foo(null, null);
}
Thank you
Lets take a look at this example:
public class MainClass {
public class NonStaticClass {
public static NonStaticClass nonStatic = new NonStaticClass();
//Compile error: The field nonStatic cannot be declared static;
//static fields can only be declared in static or top level types
public static int i = 10;//this field also causes the same compile error
}
}
The problem is that NonStaticClass is, well, not static. A non static inner class can't contain static fields.
If you want to have a static field in the inner class you need to make the class static.
From the java documentation:
Inner Classes
As with instance methods and variables, an inner class is associated
with an instance of its enclosing class and has direct access to that
object's methods and fields. Also, because an inner class is
associated with an instance, it cannot define any static members
itself.
For more information take a look at Nested Classes
I'm not sure what your real question is ... but perhaps this might help:
http://en.wikipedia.org/wiki/Singleton_pattern
In the second edition of his book "Effective Java" Joshua Bloch claims
that "a single-element enum type is the best way to implement a
singleton"[9] for any Java that supports enums. The use of an enum is
very easy to implement and has no drawbacks regarding serializable
objects, which have to be circumvented in the other ways.
public enum Singleton {
INSTANCE;
}
Why are you not able to declare a class as static in Java?
Only nested classes can be static. By doing so you can use the nested class without having an instance of the outer class.
class OuterClass {
public static class StaticNestedClass {
}
public class InnerClass {
}
public InnerClass getAnInnerClass() {
return new InnerClass();
}
//This method doesn't work
public static InnerClass getAnInnerClassStatically() {
return new InnerClass();
}
}
class OtherClass {
//Use of a static nested class:
private OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();
//Doesn't work
private OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
//Use of an inner class:
private OuterClass outerclass= new OuterClass();
private OuterClass.InnerClass innerClass2 = outerclass.getAnInnerClass();
private OuterClass.InnerClass innerClass3 = outerclass.new InnerClass();
}
Sources :
Oracle tutorial on nested classes
On the same topic :
Java: Static vs non static inner class
Java inner class and static nested class
Top level classes are static by default. Inner classes are non-static by default. You can change the default for inner classes by explicitly marking them static. Top level classes, by virtue of being top-level, cannot have non-static semantics because there can be no parent class to refer to. Therefore, there is no way to change the default for top-level classes.
So, I'm coming late to the party, but here's my two cents - philosophically adding to Colin Hebert's answer.
At a high level your question deals with the difference between objects and types. While there are many cars (objects), there is only one Car class (type). Declaring something as static means that you are operating in the "type" space. There is only one. The top-level class keyword already defines a type in the "type" space. As a result "public static class Car" is redundant.
Class with private constructor is static.
Declare your class like this:
public class eOAuth {
private eOAuth(){}
public final static int ECodeOauthInvalidGrant = 0x1;
public final static int ECodeOauthUnknown = 0x10;
public static GetSomeStuff(){}
}
and you can used without initialization:
if (value == eOAuth.ECodeOauthInvalidGrant)
eOAuth.GetSomeStuff();
...
You can create a utility class (which cannot have instances created) by declaring an enum type with no instances. i.e. you are specificly declaring that there are no instances.
public enum MyUtilities {;
public static void myMethod();
}
Sure they can, but only inner nested classes. There, it means that instances of the nested class do not require an enclosing instance of the outer class.
But for top-level classes, the language designers couldn't think of anything useful to do with the keyword, so it's not allowed.
public class Outer {
public static class Inner {}
}
... it can be declared static - as long as it is a member class.
From the JLS:
Member classes may be static, in which case they have no access to the instance variables of the surrounding class; or they may be inner classes (§8.1.3).
and here:
The static keyword may modify the declaration of a member type C within the body of a non-inner class T. Its effect is to declare that C is not an inner class. Just as a static method of T has no current instance of T in its body, C also has no current instance of T, nor does it have any lexically enclosing instances.
A static keyword wouldn't make any sense for a top level class, just because a top level class has no enclosing type.
As explained above, a Class cannot be static unless it's a member of another Class.
If you're looking to design a class "of which there cannot be multiple instances", you may want to look into the "Singleton" design pattern.
Beginner Singleton info here.
Caveat:
If you are thinking of using the
singleton pattern, resist with all
your might. It is one of the easiest
DesignPatterns to understand, probably
the most popular, and definitely the
most abused.
(source: JavaRanch as linked above)
In addition to how Java defines static inner classes, there is another definition of static classes as per the C# world [1]. A static class is one that has only static methods (functions) and it is meant to support procedural programming. Such classes aren't really classes in that the user of the class is only interested in the helper functions and not in creating instances of the class. While static classes are supported in C#, no such direct support exists in Java. You can however use enums to mimic C# static classes in Java so that a user can never create instances of a given class (even using reflection) [2]:
public enum StaticClass2 {
// Empty enum trick to avoid instance creation
; // this semi-colon is important
public static boolean isEmpty(final String s) {
return s == null || s.isEmpty();
}
}
Everything we code in java goes into a class. Whenever we run a class JVM instantiates an object. JVM can create a number of objects, by definition Static means you have the same set of copy to all objects.
So, if Java would have allowed the top class to be static whenever you run a program it creates an Object and keeps overriding on to the same Memory Location.
If You are just replacing the object every time you run it whats the point of creating it?
So that is the reason Java got rid of the static for top-Level Class.
There might be more concrete reasons but this made much logical sense to me.
The only classes that can be static are inner classes. The following code works just fine:
public class whatever {
static class innerclass {
}
}
The point of static inner classes is that they don't have a reference to the outer class object.
I think this is possible as easy as drink a glass of coffee!.
Just take a look at this.
We do not use static keyword explicitly while defining class.
public class StaticClass {
static private int me = 3;
public static void printHelloWorld() {
System.out.println("Hello World");
}
public static void main(String[] args) {
StaticClass.printHelloWorld();
System.out.println(StaticClass.me);
}
}
Is not that a definition of static class?
We just use a function binded to just a class.
Be careful that in this case we can use another class in that nested.
Look at this:
class StaticClass1 {
public static int yum = 4;
static void printHowAreYou() {
System.out.println("How are you?");
}
}
public class StaticClass {
static int me = 3;
public static void printHelloWorld() {
System.out.println("Hello World");
StaticClass1.printHowAreYou();
System.out.println(StaticClass1.yum);
}
public static void main(String[] args) {
StaticClass.printHelloWorld();
System.out.println(StaticClass.me);
}
}
One can look at PlatformUI in Eclipse for a class with static methods and private constructor with itself being final.
public final class <class name>
{
//static constants
//static memebers
}
if the benefit of using a static-class was not to instantiate an object and using a method then just declare the class as public and this method as static.