标签: static-methods

好的,情况就是这样:

我有一个通用的基类,我需要用一些静态值初始化.这些值与我的通用基类加载的类型无关.

我希望能够做到这样的事情:

GenericBaseclass.Initialize(AssociatedObject);

同时也有一个类这样做:

public class DerivedClass : GenericBaseclass<int>
{
   ...
}

有没有办法实现这个目标？我可以创建一个非泛型的基类并将静态方法放在那里,但我不喜欢那个"hack":)

如果我有一个大的.NET方法,我想知道将它拆分成多种方法是否是一种好的做法.我担心的是:1 - 如果只调用一次方法,是否有任何创建方法的点？
2 - 如果我在我的类中调用私有方法,我尽量不使用实例变量.这是好事还是坏事？例如:

var a, b;
public void TestMe
{
   FirstTest(a,b);
}
private void FirstTest(paramA, paramB)
{
         //code here with passed in parameters
}

//instead of:
private void FirstTest()
{
      //code here with instance variables a,b
}  

编辑:用实例替换全局

我使用BigDecimalClass 有相当多的代码,我讨厌界面的笨拙.

通过使用BigDecimal以下方法创建一个带有静态方法的辅助类,我减轻了使用整数s 的痛苦:

compare(BigDecimal first, int second)
divide(BigDecimal dividend, BigDecimal divisor, int scale)
divide(BigDecimal dividend, int divisor, int scale)
divide(int divident, int divisor, int scale)
multiply(BigDecimal first, BigDecimal second, int scale)
multiply(BigDecimal first, int second, int scale)
multiply(int first, int second, int scale)
zeroPad(BigDecimal value, int totalLength, int scale)

这就是我现在所需要的,代码比以前更具可读性.但是,我读到静态方法是一个"坏"的东西,他们不遵循OO原则.

BigDecimal但是,如果我扩展,我会定义一个新类型,因此我必须重新定义所有方法用我的对象包装它们,否则我将无法使用增强方法的结果.做起来似乎并不聪明.

你会如何解决这个问题？

   public static int rank(int key, int[] a) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo <= hi) {
            // Key is in a[lo..hi] or not present.
            int mid = lo + (hi - lo) / 2;
            if      (key < a[mid]) hi = mid - 1;
            else if (key > a[mid]) lo = mid + 1;
            else return mid;
        }
        return -1;
    }

上面的静态方法进行二分查找.它是线程安全的吗？我知道局部变量是线程安全的,但"a"这里是一个数组,所以这意味着它是Java中的一个对象,对吧？那是问题吗？刚刚读取数组,没有以任何方式进行修改,所以我假设这个方法是线程安全的.但我想确保理解为什么.

谢谢!

我目前有一个辅助类来执行基本的AsyncTasks,如下所示.我在需要时从活动中调用该函数.代码似乎工作正常,我没有遇到任何问题.但是,我想知道这是一个很好的编码实践,还是有任何我不知道的后果.任何反馈都会很乐意接受和赞赏.

public class OtherUtils {

    public static void updatePromptsOption(final boolean showPrompt, final Context context) {
        new AsyncTask<Void, Void, Void>() {
            @Override
            protected Void doInBackground(Void... params) {
                Editor preferenceEditor = PreferenceManager.getDefaultSharedPreferences(context).edit();
                preferenceEditor.putBoolean(Constants.SHOW_PROMPT, showPrompt).commit();
                return null;
            }

        }.execute();    
     }
}

我已经阅读了这篇相关文章,但没有太多具体的答案(或多或少的语言设计不好): 为什么静态方法不能在Java中抽象化

我有点像Scala的新人,这可能吗(可能有特征或什么)？

我尝试让我的基类扩展一个特征,但是当我真的希望它们需要在伴随对象中实现时,需要子类来实现抽象静态方法作为成员方法.

我发现了如何动态地向类中添加新方法(移植类)的非常好的示例:

def say(host, msg):
   print '%s says %s' % (host.name, msg)

def funcToMethod(func, clas, method_name=None):
   setattr(clas, method_name or func.__name__, func)

class transplant:
   def __init__(self, method, host, method_name=None):
      self.host = host
      self.method = method
      setattr(host, method_name or method.__name__, self)

   def __call__(self, *args, **kwargs):
      nargs = [self.host]
      nargs.extend(args)
      return apply(self.method, nargs, kwargs)

class Patient:
   def __init__(self, name):
      self.name = name

if __name__ == '__main__':
   jimmy = Patient('Jimmy')
   transplant(say, jimmy, 'say1')
   funcToMethod(say, jimmy, 'say2')

   jimmy.say1('Hello')
   jimmy.say2(jimmy, 'Good Bye!')

但我不明白,如何修改它添加静态方法.有人能帮我吗？

我是C++编程的新手,在做一些C++程序时我有一个疑问,那就是如何实现静态成员函数的动态绑定.正常成员函数的动态绑定可以通过将成员函数声明为虚拟来实现,但是我们不能将静态成员函数声明为虚函数,所以请帮助我.请看下面的例子:

#include <iostream>
#include <windows.h>
using namespace std;

class ClassA
{
     protected :
     int width, height;
     public:
     void set(int x, int y)
     {
       width = x, height = y;
     }
     static void print()
     {
       cout << "base class static function" << endl;
     }
     virtual int area()
     {
       return 0;
      }
};

class ClassB : public ClassA
{
     public:
   static void print()
   {
    cout << "derived class static function" << endl;
   }
   int area()
   {
    return (width * height);
   }
}; …

这个问题看起来有点奇怪.假设我有一个服务,我想在具有一些静态方法的Utility类中使用.该服务是一个Spring bean,所以我自然会使用一个setter和(@Autowired)将它注入我的实用程序类.正如Spring的文档中提到的,所有bean在bean上下文中都是静态的.因此,当您想要在类中注入bean时,您不必使用"static"修饰符.见下文:

public class JustAClass{
  private Service service;

  public void aMethod(){
     service.doSomething(....);
  }

  @Autowired
  public void setService(Service service){
     this.service = service;
  }

}

现在回到我先提到的内容(在静态方法中使用Service):

public class JustAClass{
  private static Service service;

  public static void aMethod(){
     service.doSomething(....);
  }

  @Autowired
  public void setService(Service service){
     this.service = service;
  }

}

尽管Service是静态的,但我不得不将静态置于其定义之后.这对我来说有点违反直觉.这是错的吗？还是更好的方式？谢谢

我使用静态Web方法使用jQuery调用了一个代码隐藏方法.那个web方法调用是成功的,但是当我在该方法中绑定网格视图时会产生一个错误,该错误无法在静态方法中使用控件.我们可以解决这个问题.

  public static DataTable GetDataTable()
        {
            DataSet ds = new DataSet();        
            SqlCommand cmd = new SqlCommand("StoredProcedurename");
            String constr = ConfigurationManager.ConnectionStrings["DBConnection"].ConnectionString;
            SqlConnection con = new SqlConnection(constr);


            string Startdate = DateTime.Now.ToString("yyyy-MM-dd");
            string EndDate = Convert.ToDateTime(Startdate).AddMonths(-6).ToString("yyyy-MM-dd");
            cmd.CommandType = CommandType.StoredProcedure;      
            cmd.Parameters.AddWithValue("@FromDate", Startdate);
            cmd.Parameters.AddWithValue("@ToDate", EndDate );
            cmd.Connection = con;
            SqlDataAdapter sda = new SqlDataAdapter(cmd);       

            sda.Fill(ds);

            //i want to use same dataset to bind with the grid
            gridToBind.DataSource = ds.Tables[1];
            gridToBind.DataBind();
            txtStatus.Text="Data Received";
           //above three lines throws error.

          return ds.Tables[1];

        }

并获得错误"非静态字段,方法或属性需要对象引用"