About static method

can static methods be overloaded
can static methods do not have access tp implicit variable calles this

No overloading concept for static members.
Try this:
public class testest extends test2 {
public static void out() {
System.out.println (" hello world from testtest ");
public static void main(String s[]) {
test2 x = new testest();
x.out();
class test2 {
public static void out() {
System.out.println (" hello world from test2 ");
c:\>javac testest.java
c:\>java testest
It will give you: hello world from test2.
The point is: static members are not attached to instance, but to class itself
So if you do this:
test2 x = null;
x.out();
1. do you think it will compile?
YES
2. so what is the result?
Same, hello world from test2
3. Why?
Because you declare x as test2.
What JVM do is, it will see what class is x, it will find out that x is class of "test2". Then it will execute: test2.out()
rgds,
Alex

Similar Messages

Question about static method hiding

I undestand that a static method may only be hidden in a subclass not overridden. But, I don't understand why an exception type thrown by the subclass method must be a subtype of the exception type thrown by the superclass method. For example,
public class A {
public static void foo() throws ExceptionA { }
public class B extends A {
public static void foo() throws ExceptionB { }
gives a compile-time error if ExceptionB is not a subclass of ExceptionA. This makes perfect sense in the non-static case but what does it matter here?
Thanks,
Tim

I don't understand your point. In either case, static
or non-static, ExceptionB must be the same or a
subclass of ExceptionA. My question is why this
matters in the static case.I think it's for binary compatibility, that is, so that you can make changes to Java source files and recompile only the changed files. If you originally did not have the static method in class B, and called B.foo() in another class, the A.foo() method would actually be called at run time. If you then change the B class and add a foo() method, it must be compatible so that the other class's method call is still valid.
If you're unfamiliar with the concept of binary compatibility, read the chapter in the Java Language Specification. It's a critical but often overlooked aspect of the Java language.

Trying to understand Static methods

Hi all,
I am trying to learn a little bit about static methods and hope that someone here can help me understand it better. My understanding of static methods is that they exist only once (More like global methods). This tells me that usage of static methods should be used with care as they are likely to cause problems in cases where multiple users try to access a static object at the same time.
I am looking at a piece of code that had me thinking for a bit. I cant post the code itself but here is an example of how the code is structured
The first class declares a couple of non static arrays and makes them available via the getters and setters. It also has one method that calls a static method in another class.
package com.tests.statictest;
import java.util.ArrayList;
public class ClassA{
     ArrayList arrayList1 = new ArrayList();
     ArrayList arrayList2 = new ArrayList();
     public ClassA(){
          arrayList1.add("TEST1");
          arrayList1.add("TEST2");
          arrayList2.add("Test3");
          arrayList2.add("Test4");
     ArrayList getArrayList1(){
          return arrayList1;
     ArrayList getArrayList2(){
          return arrayList2;
     ArrayList getJoinedArrayList(){
          return ClassB.joinArrays(arrayList1,arrayList2);
}The second class contains the static method that is called by the above class to join the two arrays. This class is used by many other classes
package com.tests.statictest;
import java.util.ArrayList;
public class ClassB{
     public static ArrayList joinArrays(ArrayList list1, ArrayList list2){
          ArrayList list3 = new ArrayList();
          list1.addAll(list2);
          return list1;
}And here is my test class
package com.tests.statictest;
public class ClassC{
      public static void main(String args[]){
           ClassA classA = new ClassA();
          System.out.println(classA.getArrayList1());
          System.out.println(classA.getArrayList2());
          System.out.println(classA.getJoinedArrayList());
     }The output to the above program is shown below
[TEST1, TEST2]
[Test3, Test4]
[TEST1, TEST2, Test3, Test4]My question for the above is that i am wondering if the above is safe. Can you think of situations where the above is not recommended. What exactly would happen if ten instances of ClassA threads are executed at the same time? Woulnt the static method in ClassB corrupt the data?

ziggy wrote:
Hi all,
I am trying to learn a little bit about static methods and hope that someone here can help me understand it better. My understanding of static methods is that they exist only once (More like global methods). This tells me that usage of static methods should be used with care as they are likely to cause problems in cases where multiple users try to access a static object at the same time. There is no such thing as a "static object" in Java. The word "static" simply means "belonging to a class as a whole, rather than an individual instance."
My question for the above is that i am wondering if the above is safe. Can you think of situations where the above is not recommended. What exactly would happen if ten instances of ClassA threads are executed at the same time?ClassA isn't a thread, so it can't be "executed", per se.
Woulnt the static method in ClassB corrupt the data?"Staticness" doesn't have anything to do with it; the issue at hand is operations on a shared data structure, which is a concern whether you're dealing with static or non-static members. There is nothing inherent in ClassB that will "corrupt" anything, however.
~

Why is the static method in the superclass more specific?

Why is the static method in the superclass more specific than the static method in the subclass? After all, int is a subtype of long, but Base is not a subtype of Sub.
class Base {
    static void m(int i){ System.out.println("Base"); }
class Sub extends Base {
    static void m(long l){ System.out.println("Sub"); }
class Test {
    public static void main(String[] args) {
        int i = 10;
        Sub sub = new Sub();
        sub.m(i);
}The first example compiles without error.
Output: Base
class Base {
    void m(int i){ System.out.println("Base"); }
class Sub extends Base {
    void m(long l){ System.out.println("Sub"); }
class Test {
    public static void main(String[] args) {
        int i = 10;
        Sub sub = new Sub();
        sub.m(i);
}In the second example, both instance methods are applicable and accessible (JLS 15.12.2.1), but neither is more specific (JLS 12.2.2), so we get a compiler error as expected.
: reference to m is ambiguous,
both method m(int) in Base and method m(long) in Sub match
sub.m(i);
^
1 error
Why don�t we get a compiler error for the static methods?

Thank you for your ideas.
====
OUNOS:
I don't get Sylvia's response. This is about static methods, what are instances are needed for??Yes, the question is about static methods. I included the example with non-static methods for a comparison. According to JLS 15.12.2, both examples should cause a compiler error.
And why you create a Sub object to call the method, and dont just call "Sub.m(..)"Yes, it would make more sense to call Sub.m(i). Let�s change it. Now, I ask the same question. Why is there no compiler error?
====
DANPERKINS:
The error in your logic stems from calling static methods on instances, as ounos pointed out. Solution: don't. You won't see any more ambiguities.A static member of a class may also be accessed via a reference to an object of that class. It is not an error. (The value of the reference can even be null.)
Originally I was looking only at the case with non-static methods. Therefore, I used sub.m(i). Once I understood that case, I added the static modifiers. When posting my question, I wish I had also changed sub.m to Sub.m. Either way, according to JLS 15.12.2, a compiler error should occur due to ambiguous method invocation.
====
SILVIAE:
The question was not about finding an alternative approach that doesn't throw up an ambiguity. The question related to why, in the particular situations described, the ambiguity arises in only one of them.
Yes.
Proposing an alternative approach doesn't address the question.
Yes.
====
If anyone is really interested, here is some background to the question. Some people studying for a Sun Java certificate were investigating some subtleties of method invocations:
http://saloon.javaranch.com/cgi-bin/ubb/ultimatebb.cgi?ubb=get_topic&f=24&t=019182
I remember seeing the non-static case discussed in this forum once before in a more practical context. jschell probably knows the link.

Are Static methods Thread safe?

Hello All
I have a static method that takes a integer and returns a mathematically processed result.
Since this method is frequently required, I have placed it in a common class and declared it as static.
I want to know whether this method is thread safe?

There's nothing special about static methods, with regard to thread safety. If they access shared objects, then such access will usually need to be controlled by synchronisation; this might be on the object being accessed, some higher-level object or a special object allocated purely as a lock. The only way that you might think of them as special is that there's no instance of the Class on which you can synchronise.
You can declare a static method as synchronised. If you do, it will be synchronised on the single Class object of the class in which it is declared. This means that only one thread can be executing any part of the method at any one time. However, I understand that the Java Runtime itself sometimes synchronises on this Class object for its own reasons, therefore you might sometimes find a synchronised static method blocks when no other thread is executing it. Usually better, therefore, to explicitly synchronise on some object or other, than to use synchronised static methods.

A basic question about static variables and methods

What would be the effects if I declare lots of static variables and static methods in my class?
Would my program run faster?
Would the class take more memory spaces? (If so, how do I estimate an appropriate number of variabls and methods to be declared static?)
Thank you @_@

when you declare a static var the var isn't created for every instance of the class, it just "live" in the class
when you declare a static method is the same, so if you have:
class MyClass
static int myMethod()
//Method work
you dont need to have a instance of the class to call myMethod, you can do such things like this.
int value = Myclass.myMethod();
if myMethod isn't static you can't do this.. so, if
class MyClass
int myMethod()
//Method work
you CAN'T call
int value = MyClass.myMethod();
instead, you have to write
MyClass m;
m = new MyClass();
value = m.myMethod();

About overriding static method inheritance

I have some class PO2VOPropertyUtilsBean which extends the org.apache.commons.beanutils.PropertyUtilsBean.
In PropertyUtilsBean,there is a method:
protected PropertyUtilsBean getInstance() {}I override it in my extend calss PO2VOPropertyUtilsBean:
protected PO2VOPropertyUtilsBean getInstance() {
return new PO2VOPropertyUtilsBean();
}I use Eclipse3.1+Myeclipse4.0,when i choose java5.0 as complier,that all be ok.
But when i copy the source to my company, my pc uses java1.4 as compiler,it show me errors in the getInstance() method:
imcompartible return type,it should return PropertyUtilsBean.
Why?

Ok, so the getInstance() methods are indeed static.
As Kaj said, static methods cannot be overridden.
You would call the method by the classname. For example:
PropertyUtilsBean bean = PropertyUtilsBean.getInstance();If you write a class PO2VOPropertyUtilsBean with a getInstance() method, the call above will still go to class PropertyUtilsBean, and not to your derived class. After all, how is Java supposed to know that you want to have the method in PO2VOPropertyUtilsBean called? You would need to change the call:
PropertyUtilsBean bean = PO2VOPropertyUtilsBean.getInstance();

How to get the class name static method which exists in the parent class

Hi,
How to know the name of the class or reference to instance of the class with in the main/static method
in the below example
class AbstA
public static void main(String[] args)
System.out.println(getXXClass().getName());
public class A extends AbstA
public class B extends AbstA
on compile all the class and run of
java A
should print A as the name
java B
should print B as the name
Are there any suggestions to know the class name in the static method, which is in the parent class.
Regards,
Raja Nagendra Kumar

Well, there's a hack you can use, but if you think you need it,Could you let me the hack solution for this..
you probably have a design flaw and/or a misunderstanding about how to use Java.)May be, but my needs seems to be very genuine..of not repeat the main method contents in every inherited class..
The need we have is this
I have the test cases inheriting from common base class.
When the main method of the test class is run, it is supposed to find all other test cases, which belong to same package and subpackages and create a entire suite and run the entire suite.
In the above need of the logic we wrote in the main method could handle any class provided it knows what is the child class from which this main is called.
I applicate your inputs on a better way to design without replicating the code..
In my view getClass() should have been static as the instance it returns is one for all its instances of that class.
I know there are complications the way compiler handles static vars and methods.. May be there is a need for OO principals to advance..
Regards,
Raja Nagendra Kumar
Edited by: rajanag on Jul 26, 2009 6:03 PM

Static methods in Transfer Objects

Hi all,
I have a doubt about Transfer Object:
Is it possible to have a static method (or field)
inside a Transfer Object returned from
a Session Bean to a Client ?
Many thanks in advance,
Moreno

Static fields, yeah, they'd cause some interesting problems, so are not a good idea in TOs. You can do it, but YMMV (Your Mileage May Vary).
Static method? I'd get rid of it and put it in a utility class or somewhere else. Static methods are pretty meaningless when applied to TOs. The idea is to encapsulate data and some behavior - not provide procedural functionality.

Should I use a static method or an instance method?

Just a simple function to look at a HashMap and tell how many non-null entries.
This will be common code that will run on a multi-threaded weblogic app server and potentially serve many apps running at once.
Does this have to be an instance method? Or is it perfectly fine to use a static method?
public static int countNonNullEntries(HashMap hm){
if(hm==null)return 0;
int count=0;
for(int i=0; i<hm.size(); i++) {
if(hm.get(i)!=null)
{ count++;}
return count;
OR
public int countNonNullEntries(HashMap hm){
if(hm==null)return 0;
int count=0;
for(int i=0; i<hm.size(); i++) {
if(hm.get(i)!=null)
{ count++;}
return count;
}

TPD Opitz-Consulting com wrote:
The question is the other way around: Is there a good reason to make the method static?
Ususally the answer is: no.The question is: does this method need state? Yes -> method of a class with that state. No -> static.
The good thing of having this method statig is that it meight decrese memory foot pring but unless you're facing memory related problem you should not think about that.I doubt there is any difference between the memory foot print of a static or not method.
I'm not shure if this method beeing static maks problems in multithreaded environments like the one you're aiming at. But I do know that an immutable object is always thread save.Does the method use shared state (data)? No -> no multi threaded problems.
Can the parameters be modified by different threads? Yes, if multiple threads modified the parameter map, but nothing you can do about it here (no way to force the calling thread to lock on whatever you lock on).
So my answer to your question is: yes, it should be non static.The method should be static since it uses no state.
It is thread-safe when only the calling thread can modify the passed map (using a synchronized or ConcurrentHashMap is not enough, since you don't call a single atomic method on the map).
// Better use Map instead of HashMap
// We don't care about the generic type, but that does not mean we should use a raw type
public static int countNonNullEntries(Map<?, ?> map) {
// whether to accept null map or not, no need for explicit exception
// since next statement throw NPE anyway
Collection<?> values = map.values();
// note your method is called countNonNull, not countNull!
// (original code it would need to by if(null != mapValue) notNullsCounter++;
return values.size() - java.util.Collections.frequency(values, null);
}

Need Urgent Help with static methods!!!!

If I have a static method to which a variable is being passed...for example
static String doSomething(String str)
//..doSomething with str and return
If the method is invoked a second time by a separate entity when it is already in use by one entity(!!!not entity beans) .... will this lead to the second invocation overwriting str while the method is already in use and thus corrupting the variable that the method was passed from the first entity?

It's also a common misunderstanding about parameters. The method does not receive a variable as its parameter, it receives a reference to an object. And inside the method, the parameter acts just the same as a local variable would. So if two threads call the method (static or not), each thread has its own copy of the parameter.

Memory management with static methods

I made a class with no attributes and only static methods with the purpose of maintaining as little as possible about it in memory. What information is kept in memory by the JVM about such a class ?
Thanx in advance :)

Static methods don't consume less memory than regular instance
methods. Well, not exactly: a regular method requires a reference
to an instance as a hidden additional parameter. Thus, specifying
static for methods that don't access the object may actually save
a few bytes. However, the code is not duplicated for each instance.
Additionally, the JVM must keep any initialization values and the
names of the class and the methods, as needed by reflection.
Given suitable debugging options, local variables names and line
number may be kept in memory as well. Finally, all hosekeeping
info (gc, references and the like) must be kept in memory.

Abstract classes and static methods

I have an abstract report class AbstractReportClass which I am extending in multiple report classes (one for each report, say ReportA, ReportB, ...). Each report class has its own static column definitions, title, etc., which I have to access through a static method getDataMeta() in a web application. Each report has the same exact code in getDataMeta, and no report may exist without these fields. My intuition tells me that AbstractReportClass should contain the code for getDataMeta, but I know that you can't mix abstract and static keywords.
Am I missing a simple solution to unify the getDataMeta code in the abstract base class? or do I really need to have a static function getDataMeta with the same code in each of the base classes?
My apologies if this has been discussed many times before.
Thanks,
-Andrew

I'm not trying to be "right"; rather I just asked a question about whether I can do something that seems intuitive. Perhaps you might write code in a different way than I would or perhaps I wasn't clear about every little detail about my code? Do you regularly belittle people who ask questions here?
I have a loadFromDB() member function in AbstractReport for which all sub classes have an overloaded version. All reports I'm displaying have 4 common fields (a database id and a name and a monetary value, for example), but then each other report has additional fields it loads from the database. Inside ReportX classes' loadFromDB(), I call the superclass loadFromDB() function and augment values to get a completely loaded object. In fact, the loadedData member object resides in AbstractReport.
I can't use a report unless it has these common features. Every report is an AbstractReport. There is common functionality built on top of common objects. Isn't this the point of inheritance? I'm essentially saying that abstract class Shape has a getArea function and then I'm defining multiple types of Shapes (e.g. Rectangle and Circle) to work with...

Non-static method cannot be referenced from a static context....again sry

Hey, I know you guys have probably seen a lot of these, but its for an assignment and I need some help. The error I'm getting is: non-static method printHistory() cannot be referenced from a static context. Here are the classes effected
public class BankAccount {
private static int nextAccountNumber = 1000;
//used to generate account numbers
private String owner; //name of person who owns the account
private int accountNumber; //a valid and unique account number;
private double balance; //amount of money in the account
private TransactionHistory transactions; //collection of past transactions
private Transaction transaction;
//constructor
public BankAccount(String anOwnerName){
owner = anOwnerName;
accountNumber = nextAccountNumber++;
balance = 0.0;
transactions = new TransactionHistory();
//public String getOwner() {
public void deposit(double anAmount ){
     balance=balance+anAmount;
     transaction=new Transaction(TransactionType.DEPOSIT,accountNumber,anAmount,balance);
     transactions.add(transaction);
//public void withdraw(double anAmount){
//public String toString() {
***public void printHistory(){
     TransactionHistory.printHistory();
AND
public class TransactionHistory {
final static int CAPACITY = 6; //maximum number of transactions that can be remembered
//intentionally set low to make testing easier
private Transaction[] transactions = new Transaction[CAPACITY];
//array to store transaction objects
private int size = 0;
//the number of actual Transaction objects in the collection
public void add(Transaction aTransaction){
     if (size>5){
     transactions[0]=transactions[1];
     transactions[1]=transactions[2];
     transactions[2]=transactions[3];
     transactions[3]=transactions[4];
     transactions[4]=transactions[5];
     transactions[5]=aTransaction;
     transactions[size]=aTransaction;
     size=size++;
public int size() {
     return size;
***public void printHistory() {
     for(int i=0;i<6;i++){
          System.out.println(transactions);
//public void printHistory(int n){
The project still isn't finished, so thats why some code is commented out. The line with *** infront on it are the methods directly effected, I think. Any help would be great.

In Java, static means "something pertaining to an object class". Often, the term class is substituted for static, as in "class method" or "class variable." Non-static, on the other hand, means "something pertaining to an actual instance of an object. Similarly, the term +instance+ is often substituted for +non-static+, as in "instance method" or "instance variable."
The error comes about because static members (methods, variables, classes, etc.) don't require an instance of the object to be accessed; they belong to the class. But a non-static member belongs to an instance -- an individual object. There's no way in a static context to know which instance's variable to use or method to call. Indeed, there may not be any instances at all! Thus, the compiler happily tells you that you can't access an instance member (non-static) from a class context (static).
~

Non-static method/object cannot be referenced from a static context...?????

What does this mean. I know about static, but I don't understand why I get this so many times.
I try to do something pretty normal and this is what I get a lot of times. I mean: the main() method should be static right? Then what good is the main() method if you cannot let it do stuff for you like this:
public class Test extends JFrame
    public Test
        setSize( 100, 100 );
        show();
public static main( String args[] )
    Test window = new Test();
    draw();
public void draw()
    blablabla whatever I want to do, a lot of times I can't.....
}Why is this, what is the reason for Java to forbid this and what can I do about it?

Your draw() method, since it isn't defined as static is considered by Java to be part of your Test object; hence, it can only be invoked in the context of an existing instance of your object. In other words, any Java program that wanted to use your draw() method would have to create an instance of your Test class using something likemyTest = new Test()Your main method, however, is something different. Since you want to execute your class as a program, the Java run-time environment needs to have standard starting point. This starting point is the main method. The problem is that the main method must be static, because the run-time environment cannot be expected to know beforehand the correct way to create an instance of your class so that non-static methods can be invoked. The drawback is that your main method can only directly access methods that are defined as static.
There are two possible solutions to this problem, and which of the two you want to use depends on the object-oriented nature of your program.
On the one hand, if your draw() method is closely tied to the object itself, if the draw() method is actually drawing your object or a part of it, it should be left as an instance method, and you should simpy use the instance of the object you created in your main method:public static main( String args[] )
    Test window = new Test();
    // maybe some code to generate something to draw???
    window.draw();
}This is what I think you are trying to do.
On the other hand, if your draw() method was some kind of universal method that didn't depend in any way on the current configuration of your instance, you could simply define draw() as static at which point your main method (or a method in an external class) could invoke it directly, without a corresponding instance. But if you did that, the draw() method itself would only be able to access static variables and methods.
Doug

About static method

Similar Messages

Maybe you are looking for