精华内容
下载资源
问答
  • 抽象类中定义静态方法

    千次阅读 2010-09-08 15:32:00
    一直认为抽象类不能实例化,所以就没有想过用直接调用方法,而是实例化它的子类,用子类调用方法, 没想到啊,抽象类中定义static方法不就可以了吗,static方法属于类,不需要实例化。using System;using System....

           一直认为抽象类不能实例化,所以就没有想过用直接调用方法,而是实例化它的子类,用子类调用方法,
     没想到啊,在抽象类中定义static方法不就可以了吗,static方法属于类,不需要实例化。

     

    using System;
    using System.Reflection;

    namespace AbstractFactory
    {
     /// <summary>
     /// Factory类
     /// </summary>
     public abstract class AbstractFactory
     {
     
      public static AbstractFactory GetInstance()
      {
       string factoryName = Constant.STR_FACTORYNAME.ToString();

       AbstractFactory instance;

       if(factoryName != "")

                    //AbstractFactory表示程序集的名称 ;factoryName表示要加载的类
                    instance = (AbstractFactory)Assembly.Load("AbstractFactory").CreateInstance(factoryName);
       else
        instance = null;

       return instance;
      }


      public abstract Tax CreateTax();

      public abstract Bonus CreateBonus();
     }
    }

     


    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// 客户端程序调用
     /// </summary>
     public class Calculator
     {
      public static void Main(string[] args)
      {
                //GetInstance不是static方法
                //AbstractFactory abstractFactory = new ChineseFactory().GetInstance();
                //double bonusValue = abstractFactory.CreateBonus().Calculate();
                //double taxValue = abstractFactory.CreateTax().Calculate();

     

                //GetInstance是static方法
                double bonusValue = AbstractFactory.GetInstance().CreateBonus().Calculate();
                double taxValue = AbstractFactory.GetInstance().CreateTax().Calculate();
                double salary = 4000 + bonusValue - taxValue;
                Console.WriteLine("Salary is:" + salary);
                Console.ReadLine();

             
      }
     }
    }

     

    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// ChineseFactory类
     /// </summary>
     public class ChineseFactory:AbstractFactory
     {
      public override Tax CreateTax()
      {
       return new ChineseTax();
      }

      public override Bonus CreateBonus()
      {
       return new ChineseBonus();
      }
     }
    }

     

    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// AmericanFactory类
     /// </summary>
     public class AmericanFactory:AbstractFactory
     {
      public override Tax CreateTax()
      {
       return new AmericanTax();
      }

      public override Bonus CreateBonus()
      {
                return new AmericanBonus();
      }
     }
    }

     

    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// 计算中国个人奖金
     /// </summary>
     public class ChineseBonus:Bonus
     {
      public override double Calculate()
      {
       return Constant.BASE_SALARY * 0.1;
      }
     }
    }

     

    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// 计算美国奖金
     /// </summary>
     public class AmericanBonus:Bonus
     {
      public override double Calculate()
      {
       return Constant.BASE_SALARY * 0.1;
      }
     }
    }

     

    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// 计算美国个人所得税
     /// </summary>
     public class AmericanTax:Tax
     {
      public override double Calculate()
      {
       return (Constant.BASE_SALARY + (Constant.BASE_SALARY * 0.1)) * 0.4;
      }
     }
    }

     

    using System;

    namespace AbstractFactory

     /// <summary>
     /// 计算中国个人所得税
     /// </summary>
     public class ChineseTax:Tax
     {
      public override double Calculate()
      {
       return (Constant.BASE_SALARY + (Constant.BASE_SALARY * 0.1)) * 0.4;
      }
     }
    }

     

    using System;
    using System.Configuration;

    namespace AbstractFactory
    {
     /// <summary>
     /// 公用的常量
     /// </summary>
     public class Constant
     {
      public static double BASE_SALARY = 4000;

      public static string STR_FACTORYNAME = ConfigurationSettings.AppSettings["factoryName"];
     }
    }

     

    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// 个人所得税抽象类
     /// </summary>
     public abstract class Tax
     {
      public abstract double Calculate();
     }
    }

     

    using System;

    namespace AbstractFactory
    {
     /// <summary>
     /// 奖金抽象类
     /// </summary>
     public abstract class Bonus
     {
      public abstract double Calculate();
     }
    }

     

    <?xml version="1.0" encoding="utf-8" ?>
    <configuration>
     <appSettings>
      <add key="factoryName" value="AbstractFactory.ChineseFactory"></add>
     </appSettings>
     
    </configuration>

    展开全文
  • 首先,这三种方法定义在类中。下面我先简单说一下怎么定义和调用的。(PS:实例对象的权限最大。)实例方法 定义:第一个参数必须是实例对象,该参数名一般约定为“self”,通过它来传递实例的属性和方法(也可以...

    Python中至少有三种比较常见的方法类型,即实例方法,类方法、静态方法。它们是如何定义的呢?如何调用的呢?它们又有何区别和作用呢?且看下文。

    首先,这三种方法都定义在类中。下面我先简单说一下怎么定义和调用的。(PS:实例对象的权限最大。)

    实例方法

    定义:第一个参数必须是实例对象,该参数名一般约定为“self”,通过它来传递实例的属性和方法(也可以传类的属性和方法);

    调用:只能由实例对象调用。

    类方法

    定义:使用装饰器@classmethod。第一个参数必须是当前类对象,该参数名一般约定为“cls”,通过它来传递类的属性和方法(不能传实例的属性和方法);

    调用:实例对象和类对象都可以调用。

    静态方法

    定义:使用装饰器@staticmethod。参数随意,没有“self”和“cls”参数,但是方法体中不能使用类或实例的任何属性和方法;

    调用:实例对象和类对象都可以调用。

    实例方法

    简而言之,实例方法就是类的实例能够使用的方法。这里不做过多解释。

    类方法

    使用装饰器@classmethod。

    原则上,类方法是将类本身作为对象进行操作的方法。假设有个方法,且这个方法在逻辑上采用类本身作为对象来调用更合理,那么这个方法就可以定义为类方法。另外,如果需要继承,也可以定义为类方法。

    如下场景:

    假设我有一个学生类和一个班级类,想要实现的功能为:
    执行班级人数增加的操作、获得班级的总人数;
    学生类继承自班级类,每实例化一个学生,班级人数都能增加;
    最后,我想定义一些学生,获得班级中的总人数。

    思考:这个问题用类方法做比较合适,为什么?因为我实例化的是学生,但是如果我从学生这一个实例中获得班级总人数,在逻辑上显然是不合理的。同时,如果想要获得班级总人数,如果生成一个班级的实例也是没有必要的。

    735155cd7cee5519ce102d293fc0d6f3.png

    静态方法

    使用装饰器@staticmethod。

    静态方法是类中的函数,不需要实例。静态方法主要是用来存放逻辑性的代码,逻辑上属于类,但是和类本身没有关系,也就是说在静态方法中,不会涉及到类中的属性和方法的操作。可以理解为,静态方法是个独立的、单纯的函数,它仅仅托管于某个类的名称空间中,便于使用和维护。

    譬如,我想定义一个关于时间操作的类,其中有一个获取当前时间的函数。

    972e7b153150fc74faf788fce9d4ad2a.png

    如上,使用了静态方法(函数),然而方法体中并没使用(也不能使用)类或实例的属性(或方法)。若要获得当前时间的字符串时,并不一定需要实例化对象,此时对于静态方法而言,所在类更像是一种名称空间。

    展开全文
  • 静态内部类定义在类中,任何方法外,用static定义静态内部类只能访问外部类的静态成员。 生成(new)一个静态内部类不需要外部类成员:这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成: Outer....

    静态内部类:(注意:前三种内部类与变量类似,所以可以对照参考变量)
    静态内部类定义在类中,任何方法外,用static定义。
    静态内部类只能访问外部类的静态成员。
    生成(new)一个静态内部类不需要外部类成员:这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成:
    Outer.Inner in=new Outer.Inner();
    而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。
    静态内部类不可用private来进行定义。例子:
    对于两个类,拥有相同的方法:
    People
    {
    run();
    }
    Machine{
    run();
    }
    此时有一个robot类:
    class Robot extends People implement Machine.
    此时run()不可直接实现。
    注意:当类与接口(或者是接口与接口)发生方法命名冲突的时候,此时必须使用内部类来实现。
    用接口不能完全地实现多继承,用接口配合内部类才能实现真正的多继承。

    package TomText;
    //测试对实例成员和类成员的不同访问形式。
    public class TomText_44 {
        static int i=1;
        int j=1;
        static void printStatic( ){
            System.out.println("i="+i);
            //System.out.println("j="+j);        //非法访问
        }
        void print(){
            System.out.println("i="+i);
            System.out.println("j="+j);
        }
        public static void main(String [ ] args){
            TomText_44.printStatic( );
            //StaticTest.print( );                //非法访问
            TomText_44.i=2;
            //StaticTest.j=2;                //非法访问
            TomText_44 st=new TomText_44( );
            st.i=3;
            st.j=3;
            st.print( );
            st.printStatic( );
        }
    
    }
    
    展开全文
  • 在python中,各种方法的定义如下所示: class MyClass(object):#在类中定义普通方法,在定义普通方法的时候,必须添加self ... #在类中定义静态方法,在定义静态方法的时候,不需要传递任何类的东...

    在python中,各种方法的定义如下所示:


    class MyClass(object):
    #在类中定义普通方法,在定义普通方法的时候,必须添加self
        def foo(self,x):
            print "this is a method  %s %s"  % (self,x)
        
    #在类中定义静态方法,在定义静态方法的时候,不需要传递任何类的东西
        @staticmethod
        def static_method(x):
            print "this is a static method: %s " % x
    
    
    #在类中定义类方法,在定义类方法的时候,需要传递参数cls
        @classmethod
        def class_method(cls,x):
            print "this is a class method: %s %s" %(cls,x)

    1、 在定义普通方法的时候,需要的参数是self,也就是把类的实例作为参数传递给方法,如果在不写self的时候,会发现报错TypeError错误,表示传递参数多了,其实也就是在调用类方法的时候,将实例作为参数传递了。

    在使用普通方法的时候,必须是使用实例来调用方法,不能使用类来调用方法,没有实例,那么方法将无法调用。


    2、 在定义静态方法的时候,和模块中的方法没有什么不同,最大的不同就在于静态方法在类的命名空间之中,并且在声明静态方法的时候,使用的标记为@staticmethod,表示为静态方法,在调用静态方法的时候,可以使用类名或者是实例名来进行调用,一般使用类名来进行调用

    静态方法主要是用来放一些方法,方法的逻辑属于类,但是又和类本身没有交互,从而形成了静态方法,主要是让静态方法放在此类的名称空间之内,从而能够更加有组织性。


    3、 在定义类方法的时候,传递的参数为cls,表示为类,此写法也可以变,但是一般写为cls。类的方法调用可以使用类,也可以使用实例,一般的情况下是使用类。


    4、 self表示为类型为类的object,而cls表示为类也就是class


    5、在继承的时候,静态方法和类方法都会被子类继承。在进行重载类中的普通方法的时候,只要 写上相同的名字即可进行重载。


    6、 在重载调用父类方法的时候,最好是使用super来进行调用父类的方法。

    静态方法主要用来存放逻辑性的代码,基本在静态方法中,不会涉及到类的方法和类的参数。

    类方法是在传递参数的时候,传递的是类的参数,参数是必须在cls中进行隐身穿


    class Date(object):
        day  = 0
        month = 0
        year = 0
    
    #define the init parameter
        def __init__(self,day=0,month=0,year=0):
            self.day = day
            self.month = month
            self.year = year
    
    #this is for the class method ,and the method is use parameter
    #this must use the parameter of the self,this is for the object
        def printf(self):
            print "the time is %s %s %s " %(self.day,self.month,self.year)
    
    #this is define a classmethod,and the praemter have a cls,and can use the cls to create a class
    #cls is passed of the class,then can initiate the object
        @classmethod
        def from_string(cls,date_as_string):
            day,month,year = map(int,date_as_string.split("-"))
            date1 = cls(day,month,year)
            date1.printf()
    
    #this is the static method,and thre is do something to manage the logic,not the class or object
        @staticmethod
        def is_date_valid(date_as_string):
            day,month,year = map(int,date_as_string.split("-"))
            return day <= 31 and month <= 12 and year <= 3999



    转载于:https://www.cnblogs.com/kellyseeme/p/5525062.html

    展开全文
  • 静态方法:static静态方法可以用类名调用,而非静态方法不能用类名调用,只能用实例对象调用静态方法静态方法会随着定义而被分配和装载入内存静态方法可以调用静态方法以及访问静态数据域,但静态方法不能...
  • VC类中定义静态常量

    2012-07-20 14:05:00
    在C++类中定义常量,有以下两种方法:1.在类定义体内定义枚举常量; 例如: class A { public: enum { THREAD_NUM = 100, MEM_BLOCK_SIZE = 1024, PORT = 8080 }; }; 这样定义出来的常量值在...
  • 但我自己实验了一下,发现居然可以接口中定义静态方法(static)惊奇(⊙o⊙)?难道是是我的jdk版本比较新的原因,后面的java规则发生了变动? 而且不仅java的接口中可以定义静态方法,抽象类中也可以。但是定义的...
  • static类型的属性和方法在类加载的时候就会存在于内存。 要想使用某个类的static属性和方法,那么这个类必须要加载到JAVA虚拟机。 非静态内部类并不随外部类一起加载,只有在实例化外部类之后才会...
  • 用c#定义一个工具utility,此类中定义一个静态方法,此方法实现文件夹的拷贝功能,有会的吗,谢谢了
  • 扩展方法被定义静态方法,但它们是通过实例方法语法进行调用的。 它们的第一个参数指定该方法作用于哪个类型,并且该参数以 this 修饰符为前缀。 扩展方法的要求如下: 1 第一个参数是要扩展或者要操作的...
  • java、c#等高级语言我们用static来定义静态方法和静态变量,那么python如何定义静态方法和静态变量呢。python提供了@classmethod和@staticmethod来定义静态方法,刚接触的时候不太明白,Stack Overflow提供...
  • 回顾在Python进阶记录之基础篇(十九)中,我们介绍了Python面向对象中对于@...类方法在我们前面介绍的面向对象相关内容中,我们在类中定义方法都是对象方法,即提供给对象的方法。我们在使用时需要先创建对象,...
  • 1、Java抽象类中不能有静态的抽象方法。  抽象类是不能实例化的,即不能被分配内存... 定义抽象方法的目的是重写此方法,但如果定义静态方法就不能被重写。 2、接口中不能有静态的抽象方法  接口中的方法也...
  • 问题及代码: /* ...* All rights reserved. * 文件名称:search.cpp * 作 者:单昕昕 ...* 问题描述:创建静态类其中定义一个泛型方法,实现查找数组元素的功能。 * 程序输入:数组元素,要查找的元素。 *
  • Java中静态变量只能在类主体中定义,不能在方法中定义。 静态变量属于类所有而不属于方法
  • 比如图中这么写报错 ,然后我删掉345行的static 程序就能跑起来了,静态变量的作用域是整个类,为什么我不能两个类中定义两组静态变量?,![图片说明]...
  • 第7.18节 案例详解:Python类中装饰器@staticmethod...本节定义了类StaticMethod,在类中定义静态方法stmethod、类方法clsmethod和实例方法objmethod,重写了__new__(self)方法。演示内容包括: 1. 在类方法clsmet...
  •   JDK8前,接口只能是抽象方法。 但是JDK8中,静态方法是可以直接...可以定义静态方法返回值前+default,然后其子类的实现类中进行调用,子类中也可以重写           三、...
  • public class plex { public plex(){ int i=1,j=1; while(i<=9) { j=1; while(j<=9) { System.out.println(i + "*" + j + "=" + ":" + i * j+"...
  • 1、静态域 ...静态方法不可以访问对象中的实例域,但是可以访问自身类中的静态域。 以下两种情况下使用静态方法: ①一个方法不需要访问对象状态,其所需参数都是通过显式参数提供; ②一个方法只需要
  • class DemoMthd: def __init__(self,x=0): self.x=x @staticmethod #静态方法装饰器 ... #print(self.x) #在静态方法中不是使用实例属性 @classmethod #方法装饰器 def class_mthd(cls)...
  • Python中类方法和静态方法

    千次阅读 2014-06-20 16:31:33
    在类中使用静态方法,需在类成员函数前面加上@staticmethod标记符,以表示下面的成员函数是静态函数。使用静态方法的好处是,不需要定义实例即可使用这个方法。另外,多个实例共享此静态方法
  • .NET MVC 扩展方法也是一种静态方法,也能像实例方法一样被调用。 .NET MVC 3扩展方法特点:  (1)扩展的名称以Extensions结尾;  (2)扩展的类型是static;  (3)扩展方法至少有一个参数,第一个...
  • 引题我们在定义javascript时,有时候会定义一些静态方法,并一些实例方法引用这些静态方法。例子:class C {static getData() {console.log('this is static method');}f() {C.getData();}}C.getData(); 这种...
  • const Person = class{  constructor(name,age){//构造函数对象实列化(调用new的时候)的时候执行  // console.log(`ES6的构造函数:${name},${age}`)  //属性构造函数  this.name = name;  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,640
精华内容 4,656
关键字:

在类中定义静态方法