static-methods

问题 I really don't understand why the getMyClass2 method below cannot be static, why isn't it valid Java code? public class MyClass { private class MyClass2 { public String s1 = ""; public String s2 = ""; } private MyClass2 myClass2; private static MyClass2 getMyClass2() { MyClass2 myClass2 = new MyClass2(); return myClass2; } public MyClass() { myClass2 = getMyClass2(); } } 回答1: You have to say that the inner class is static because non-static is bound to the instance so it cannot be returned

问题 I have this test code example: public class Test { private static class Test3 { private void print1() { System.out.println("1"); } } private static class Test4 extends Test3 { private void print1() { System.out.println("2"); } } public static void main(String[] args) { System.out.println("Overriden call to private method ----------------"); OuterTest.Test1 test1 = new OuterTest.Test1(); OuterTest.Test2 test2 = new OuterTest.Test2(); OuterTest.Test1 test12 = new OuterTest.Test2(); test1

问题 I've created my own custom pseudo enumerations within my domain model to allow me to have some more verbose values. For example, my class is as follows: public abstract class Enumeration<X, Y> : IComparable where X : IComparable { public Enumeration(X value, Y displayName) { } public Y DisplayName { get { return _displayName; } } public X Value { get { return _value; } } } And a class that inherits it would be: public class JobType : Enumeration<string, string> { public static JobType

问题 I've created my own custom pseudo enumerations within my domain model to allow me to have some more verbose values. For example, my class is as follows: public abstract class Enumeration<X, Y> : IComparable where X : IComparable { public Enumeration(X value, Y displayName) { } public Y DisplayName { get { return _displayName; } } public X Value { get { return _value; } } } And a class that inherits it would be: public class JobType : Enumeration<string, string> { public static JobType

问题 I've created my own custom pseudo enumerations within my domain model to allow me to have some more verbose values. For example, my class is as follows: public abstract class Enumeration<X, Y> : IComparable where X : IComparable { public Enumeration(X value, Y displayName) { } public Y DisplayName { get { return _displayName; } } public X Value { get { return _value; } } } And a class that inherits it would be: public class JobType : Enumeration<string, string> { public static JobType

问题 I've created my own custom pseudo enumerations within my domain model to allow me to have some more verbose values. For example, my class is as follows: public abstract class Enumeration<X, Y> : IComparable where X : IComparable { public Enumeration(X value, Y displayName) { } public Y DisplayName { get { return _displayName; } } public X Value { get { return _value; } } } And a class that inherits it would be: public class JobType : Enumeration<string, string> { public static JobType

问题 I know it's wired to have such a case but somehow I have it: class foo #static method @staticmethod def test(): pass # class variable c = {'name' : <i want to reference test method here.>} What's the way to it? Just for the record: I believe this should be considered as python worst practices. Using static methods is not really pythoish way if ever... 回答1: class Foo: # static method @staticmethod def test(): pass # class variable c = {'name' : test } 回答2: The problem is static methods in

问题 I'm working on a web application that sees dozens of concurrent users per second. I have a class that will be instantiated many times within the same page load. In that class, I have some properties that will always be the same across every object, so I'm thinking about declaring these properties as static in an effort to reduce the memory that will be used when multiple instances of this class are instantiated during the same page request. Will doing this use less memory for this application

问题 I'm working on a web application that sees dozens of concurrent users per second. I have a class that will be instantiated many times within the same page load. In that class, I have some properties that will always be the same across every object, so I'm thinking about declaring these properties as static in an effort to reduce the memory that will be used when multiple instances of this class are instantiated during the same page request. Will doing this use less memory for this application

问题 First of all, I understand how, in general, a decorator work. And I know @staticmethod strips off the instance argument in the signature, making class C(object): @staticmethod def foo(): print 'foo' C.foo //<function foo at 0x10efd4050> C().foo //<function foo at 0x10efd4050> valid. However, I don't understand how the sourcec code of staticmethod make this happen. It seems to me that when wrapping method foo in staticmethod , an instance of staticmethod is instantiated, then some magic