标签: static-methods

在具有少量POJO和许多辅助方法的应用程序中运行它们,有什么更好的性能:使辅助类单例或使方法静态？

在阅读这个问题并接受问题的答案时,我无法区分这两种方法.实际上通过阅读示例得到了重点,但后来,我无法编写自己的静态方法.

我尝试在目标c静态方法中使用googling 创建静态方法

这让我回到了这个和这个问题的链接.但是,这里的例子是CLASS方法,根据问题的第一个链接.这让我感到困惑.

这里的任何人都可以告诉我如何创建一个不是类方法的静态方法？

任何关于此的亮点都将受到赞赏.

我有这个静态方法:

public static void displayLevelUp(int level, Context context) {

    LayoutInflater inflater = (LayoutInflater) context
            .getSystemService(Context.LAYOUT_INFLATER_SERVICE);

    View layout = inflater.inflate(R.layout.custom_level_coast,
            (ViewGroup) findViewById(R.id.toast_layout_root));  // this row

    TextView text = (TextView) layout.findViewById(R.id.toastText);
    text.setText("This is a custom toast");

    Toast toast = new Toast(context);
    toast.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
    toast.setDuration(Toast.LENGTH_LONG);
    toast.setView(layout);
    toast.show();

    Toast.makeText(context, String.valueOf(level), Toast.LENGTH_SHORT)
            .show();

}

但是,我无法弄清楚如何让第一个findViewById玩得很好,因为它说它是一种非静态方法.我理解为什么会这么说,但必须有一个解决方法？我context进入了这个方法,但无法一起完成它们.

该飞镖风格指南建议使用构造函数,而不是静态方法来创建实例,因为" 命名的构造函数和工厂构造函数中达特给你所有的其他语言的静态方法的灵活性,同时仍然允许调用点显得像一个普通的构造函数调用 ".

那么是否存在技术原因,因为已经声明int.parse()并且double.parse()是静态方法而不是工厂构造函数？

更一般地说,选择在Dart中通过静态(工厂)方法编写工厂构造函数的指导原则是什么？

我不是在询问界面和抽象类之间的区别.

它是单独的成功,对吗？

interface Inter {
    public void fun();
}

abstract class Am {
    public static void fun() {
        System.out.println("Abc");
    }
}

public class Ov extends Am implements Inter {
    public static void main(String[] args) {
        Am.fun();
    }
}

为什么会发生冲突？

我有一个关于lambda表达式的可重用性而没有代码重复的问题.例如,如果我有一个辅助方法,我可以很容易地将它编码为静态方法,并且可以从其他类中引用它而不需要代码重复.这怎么会在lambda表达式中起作用？示例:我编写了以下静态方法

public class MyUtil {

    public static int doubleMe(int x) {
        return x * 2;
    }
}

我可以在整个项目的多个位置重复使用相同的方法而无需代码重复

public class A {

    public void someOtherCalculation() {
        MyUtil.doubleMe(5);
    }
}

public class B {

    public void myCalculation() {
        MyUtil.doubleMe(3);
    }
}

当涉及到lambda函数时,它如何工作,编写一次函数并在多个类中使用相同的函数.

Function<Integer, Integer> doubleFunction = x -> x * 2;

在我的例子中,我将在哪里编写上面的lambda函数,以及如何在A类和B类中重用它？

我在C#中有一个类,模板和静态方法类似

class BClass<T>
{
  public static BClass<T> Create()
  {
    return new BClass<T>();
  }
 }

从这里我导出一个类并为基类指定一个模板参数

class DClass : BClass<int> { }

当我尝试使用静态方法创建D的实例时出现问题

class Program
{
  static void Main(string[] args)
  {
    DClass d = DClass.Create();
  }
}

给出编译器错误"无法将类型'Test.BClass <int>'隐式转换为'Test.DClass'."

添加以下强制转换会导致运行时强制转换异常.

DClass d = (DClass)DClass.Create();

是否有任何succint方法允许静态方法创建派生类的实例？理想情况下,我想要相当于c ++ typedef,我不想要下面的语法(这确实有效).

BClass<int> d = DClass.Create();

对于不需要任何传递信息(对象实例或类)的方法,更好的方法是什么,因为例如它们只是进行简单的转换.@staticmethod还是方法？

class Foo(object):
    def __init__(self, trees):
        self.money = Foo.trees2money(trees)

    @staticmethod
    def trees2money(trees):
        return trees * 1.337

class Quu(object):
    def __init__(self, trees):
        self.money = self.trees2money(trees)

    def trees2money(self, trees):
        return trees * 1.337

是否有正确的方法来创建私有静态javascript变量(和函数),无论您创建多少次都不会更改new Obj？

这是我尝试过的,它似乎工作:

var ObjClass = (function(){

    var static_var = 0; //private static variable
    var static_fn = function(){ return static_var; }; //private static function

    return function(){
        ++static_var;
        var thisNumber = static_var;
        this.getThisNumber = function(){
             return thisNumber;
        }
        this.getStaticNumber = static_fn; //making static fn public
    }

})();

var obj1 = new ObjClass;
var obj2 = new ObjClass;
var obj3 = new ObjClass;

console.log(obj1.getThisNumber()); //output `1`
console.log(obj1.getStaticNumber()); //output `3`
console.log(obj2.getThisNumber()); //output `2`
console.log(obj2.getStaticNumber()); //output …

我刚刚用了半个小时来解决这个问题,我已经设法修复了我的代码,但是我并不完全理解发生了什么,并且想知道是否有人可以对它进行说明.

我有一个utils类型类,它包含一些静态字段(例如数据库连接端点),这些字段由各种其他程序使用,具体取决于手头的任务.基本上是一个图书馆.

这就是它之前的样子(虽然仍然破碎);

//DBUtils.java
public final class DBUtils {

    private static DBConnection myDBConnection = spawnDBConnection();
    private static DBIndex myDBIndex = null;

    private static DBConnection spawnDBConnection() {
        //connect to the database
        //assign a value to myDBIndex (by calling a method on the DBConnection object) <- IMPORTANT
        //myDbIndex NOT NULL HERE
        System.out.println("database connection completed");
        //return the DBConnection object
    }

    public static searchDB(String name) {
        //use the myDBIndex to find a row and return it
    }
}

简而言之,我使用静态spawnDBConnection()方法为myDBConnection和myDBIndex …