精华内容
下载资源
问答
  • 2(1)定义Shape作为父类,并在类中定义方法求周长和面积; (2)定义Shape子类圆形(circle),具有半径属性和常量PI,同时重写父类的方法; (3)定义Shape子类长方形(rectangle),具有长和宽的属性,同时...

    2(1)定义类Shape作为父类,并在类中定义方法求周长和面积; (2)定义Shape子类圆形(circle),具有半径属性和常量PI,同时重写父类中的方法; (3)定义Shape子类长方形(rectangle),具有长和宽的属性,同时重写父类的方法; (4)创建图形面积周长计算器(ShapeCalculate),具有计算不同图形面积和周长的方法。 (5)对ShapeCalculate计算面积和周长方法进行测试。

    class Shape():
        def zhouchang(self):
            pass
    
        def mianji(self):
            pass
    
    class Circle(Shape):
        PI = 3.14
        def __init__(self, radius):
            self.radius = radius
    
        def zhouchang(self):
            return 2 * self.PI * self.radius
    
        def mianji(self):
                return self.PI * self.radius ** 2
    
    class Rectangle(Shape):
        def __init__(self, c, k):
            self.c = c
            self.k = k
    
        def zhouchang(self):
            return 2 * (self.c + self.k)
    
        def mianji(self):
            return self.c * self.k
    
    def ShapeCalculate(a):
        s = a.mianji()
        z = a.zhouchang()
        print('周长是{},面积是{}'.format(s, z))
    
    aa = Circle(4)
    bb = Rectangle(3, 4)
    ShapeCalculate(aa)
    ShapeCalculate(bb)
    

    在这里插入图片描述

    展开全文
  • Python中定义类方法

    千次阅读 2019-07-31 22:29:40
    方法也分实例方法类方法, 与属性类似 在class中定义的全部是实例...在class中定义类方法,需要这么写: class Person(object): count = 0 @classmethod def how_many(cls): return cls.count def __init__(se...

    方法也分实例方法类方法, 与属性类似

    在class中定义的全部是实例方法,实例方法第一个参数 self 是实例本身。

    在class中定义类方法,需要这么写:

    class Person(object):
        count = 0
        @classmethod
        def how_many(cls):
            return cls.count
        def __init__(self, name):
            self.name = name
            Person.count = Person.count + 1
    
    print(Person.how_many())
    p1 = Person('Bob')
    print(Person.how_many())
    

    结果为:

    0
    1

    通过标记一个 @classmethod,该方法将绑定到 Person 类上,而非类的实例。类方法的第一个参数将传入类本身,通常将参数名命名为 cls,上面的 cls.count 实际上相当于 Person.count


    任务:
    如果将类属性 count 改为私有属性__count,则外部无法读取__score,但可以通过一个类方法获取,请编写类方法获得__count值。

    class Person(object):
    
        __count = 0
    
        @classmethod
        def how_many(cls):
            return cls.__count
    
        def __init__(self, name):
            self.name = name
            Person.__count = Person.__count + 1
            
    print(Person.how_many())
    p1 = Person('Bob')
    print(Person.how_many())
    

    结果为:

    0
    1


    大家加油!
    学习链接:https://www.imooc.com/code/6179

    展开全文
  • Python中类方法定义及常用的实现方式

    万次阅读 多人点赞 2018-10-29 19:02:18
    1. python的属性和方法查看 class Person_1: mind = '有思想' belif = '有信仰' animal = '高级动物' def tt(): pass print(Person_1.__dict__) #查询Person所有的内容,表现形式是字典. print(Person_...

    1. python类的属性和方法查看

    class Person_1:
        mind = '有思想'
        belif = '有信仰'
        animal = '高级动物'
    
    
        def tt():
            pass
    
    print(Person_1.__dict__)  #查询类Person中所有的内容,表现形式是字典.
    print(Person_1.__dict__['belif'])  #查询类Person中的变量'belif'
    
    
    class Person_2:
        mind = '有思想'
        belif = '有信仰'
        animal = '高级动物'
        
        def work():
            print('666')
            
        def money():
            print('777')
    
    print(Person_2.animal)  #高级动物
    print(Person_2.mind)  #有思想
    Person_2.mind = '没有思想'  #修改变量'mind'的值,可以通过__dicy__查看修改后的内容
    Person_2.pay = '货币交换'  #增加变量'pay'和它的值,可以通过__dicy__查看增加后的内容
    Person_2.say = '语言交流'
    print(Person_2.work())  #也可以调用类中的方法(函数),工作中不用类名去操作
    print(Person_2.__dict__)  #查看类中所有的内容
    
    

    运行:

    {'__module__': '__main__', 'mind': '有思想', 'belif': '有信仰', 'animal': '高级动物', 'tt': <function Person_1.tt at 0x10f243f28>, '__dict__': <attribute '__dict__' of 'Person_1' objects>, '__weakref__': <attribute '__weakref__' of 'Person_1' objects>, '__doc__': None}
    有信仰
    高级动物
    有思想
    666
    None
    {'__module__': '__main__', 'mind': '没有思想', 'belif': '有信仰', 'animal': '高级动物', 'work': <function Person_2.work at 0x1114429d8>, 'money': <function Person_2.money at 0x1114421e0>, '__dict__': <attribute '__dict__' of 'Person_2' objects>, '__weakref__': <attribute '__weakref__' of 'Person_2' objects>, '__doc__': None, 'pay': '货币交换', 'say': '语言交流'}
    

    2. python对象方法、类方法、静态方法:

    下面是简单的几个例子:

    class Person(object):
        
        grade=6     # 类变量
        
        def __init__(self):
            self.name = "king"
            self.age=20
            
        def sayHi(self):    #加self区别于普通函数
            print ('Hello, your name is?',self.name)
            
        def sayAge(self):
            print( 'My age is %d years old.'%self.age)
            
            
        @staticmethod     # 静态方法不能访问类变量和实例变量,也不能使用self
        def sayName():
            print ("my name is king") 
            
              
        @classmethod     #类方法可以访问类变量,但不能访问实例变量
        def classMethod(cls):  
            #print('cls:',cls)
            print('class grade:',cls.grade)        
            #print("class method")
                
            
    class Child(object):
        
        def __init__(self):
            self.name = "小明"
            self.age=20
         
            
        def sayName(self,obj):
            print('child name is:',self.name)
            print(obj.sayName)
            print(obj.sayName()) # 这里要特别注意带括号和不带括号的区别:一个是对象,一个是方法
            
    
    p = Person()    # 实例化对象
    print('p.grade:',p.grade)  # 实例对象调用类变量
    p.grade=9
    print(p.classMethod(),p.grade) # 实例改变类变量时,其grade变量只会在实例中改变
    
    
    print(Person().grade) # 类对象调用类变量
    p.sayHi()       # 实例对象调用类成员函数 
    Person().sayAge() # 类对象调用类成员函数
    
    
    p.sayName()    # 实例对象调用类静态方法
    m=Person()
    m.sayName()    # 多个实例共享此静态方法
    Person().sayName() # 类对象调用静态方法
    
    
    p.classMethod()  # 实例对象调用类方法
    Person.classMethod() # 类对象调用类方法
    
    # 调用类
    tt=Child()
    tt.sayName(Person()) 
    
    

    运行结果:

    p.grade: 6
    class grade: 6
    None 9
    6
    Hello, your name is? king
    My age is 20 years old.
    my name is king
    my name is king
    my name is king
    class grade: 6
    class grade: 6
    child name is: 小明
    <function Person.sayName at 0x10f1cc598>
    my name is king
    None
    

    小小总结下:

    python中实现静态方法和类方法都是依赖于python的装饰器来实现的。 对象方法有self参数,类方法有cls参数,静态方法不需要这些附加参数。

    • 静态方法

    要在类中使用静态方法,需在类成员函数前面加上@staticmethod标记符,以表示下面的成员函数是静态函数。使用静态方法的好处是,不需要定义实例即可使用这个方法。另外,多个实例共享此静态方法(静态方法无法访问类属性、实例属性,相当于一个相对独立的方法,跟类其实没什么关系,简单讲,静态方法就是放在一个类的作用域里的函数而已)。

    • 类方法

    类方法与普通的成员函数和静态函数有不同之处。定义: 一个类方法就可以通过类或它的实例来调用的方法, 不管你是用类来调用这个方法还是类实例调用这个方法,该方法的第一个参数总是定义该方法的类对象。 也即是方法的第一个参数都是类对象而不是实例对象. 按照习惯,类方法的第一个形参被命名为 cls。任何时候定义类方法都不是必须的(类方法能实现的功能都可以通过定义一个普通函数来实现,只要这个函数接受一个类对象做为参数就可以了)。同时,类方法可以访问类属性,无法访问实例属性。上述的变量grade,在类里是类变量,在实例中又是实例变量,所以使用的时候要注意,使用好的话功能很强大,使用不好容易混淆。

    3. 类方法之间的调用

    class Person(object):
        
        # 不加任何参数直接定义,也是类方法
        def Work():
            print(" I am working!")
                    
        # 类方法       第一种方法:加装饰器方法
        @classmethod   
        def Think(cls,b):    #类方法Think必须要带至少1个参数,第一个参数默认为类名,后面可以引用。
            cls.Eat(b)       #在类方法Think中,调用类方法Eat类方法。
            cls.Work()       #在类方法Think中,调用Work类方法。        
            print(b,",I am Thinking!")
        
    
        # 属于第二种方法,先定义类方法,至少1个参数,第一个默认为类名。
        def Eat(cls,b):      
            print(b+",I am eating")
        Eat=classmethod(Eat)    #第二种方法:通过内建函数classmethod()来创建类方法。  
        
        # 静态方法,引用时直接用类名.Sleep()即可。
        @staticmethod            
        def Sleep():
            print("I am sleeping")
                            
        # 这种方法是:实例对象调用方法
        def __scolia__(self):         
            print("scola")
            return "scola"
                   
        # 实例对象可以访问的私有方法,在类方法中可以相互调用和使用。类不能直接访问或者外部访问。
        def __good(self):           
            print("good")
            return "good"
        
        
    Person.Think("li")
    Person.Eat("jcy")
    Person.Work() 
    # a.Work()  报错,实例对象不能调用类方法
    Person.Sleep()
    
    a=Person()
    a.__colia__() # 魔术方法,没有私有化。
    #a.__good()   # 私有方法:报错了!
    

    运行:

    li,I am eating
     I am working!
    li ,I am Thinking!
    jcy,I am eating
     I am working!
    I am sleeping
    scola
    

    4. python使用@property @x.setter @x.deleter

    • 只有@property表示只读。
    • 同时有@property和@x.setter表示可读可写。
    • 同时有@property和@x.setter和@x.deleter表示可读可写可删除。

    方法必须要先经过 property()函数的装饰后,才有后面两个装饰器的用法。

    直接看实例:

    class student(object):  #新式类
        
        def __init__(self,id):  
            self.__id=id  
            
        @property  #只读  
        def score(self):  
            return self._score 
        
        @score.setter #只写  
        def score(self,value):          
            if not isinstance(value,int):  
                raise ValueError('score must be an integer!')    
            if value<0 or value>100:  
                raise ValueError('score must between 0 and 100')   
            self._score=value  
                   
        @property #只读
        def get_id(self):  
            return self.__id  
        
      
    s=student('123456')  
    s.score=100 # 写  
    print(s.score) #读  
    print(s.__dict__)
    print (s.get_id) #只读
    #s.get_id=456 #只能读,不可写:AttributeError: can't set attribute
    
    
    class A(object): # 新式类(继承自object类)
        
        def __init__(self):
            self.__name=None
            
        def getName(self):
            return self.__name
        
        def setName(self,value):
            self.__name=value
            
        def delName(self):
            del self.__name
            
        name=property(getName,setName,delName)
     
    a=A()
    print(a.name) #读
    a.name='python' #写
    print(a.name) #读
    del a.name #删除
    #print a.name #a.name已经被删除 AttributeError: 'A' object has no attribute '_A__name'
    
    

    运行结果:

    100
    {'_student__id': '123456', '_score': 100}
    123456
    None
    python
    

    经典类和新式类的对比:

    class test1:#经典类:没有继承object    
        def __init__(self):    
            self.__private='alex 1' #私有属性以2个下划线开头 
            
        #读私有属性    
        @property    
        def private(self):    
            return self.__private 
        
        #尝试去写私有属性(对于经典类而言,“写”是做不到的)  
        @private.setter    
        def private(self,value):    
            self.__private=value
            
        #尝试去删除私有属性(对于经典类而言,“删除”也是做不到的)  
        @private.deleter  
        def private(self):  
            del self.__private  
     
    
         
    class test2(object):# 新式类:继承了object    
        def __init__(self):    
            self.__private='alex 2' #私有属性以2个下划线开头 
            
        #读私有属性    
        @property    
        def private(self):    
            return self.__private   
        
        #写私有属性    
        @private.setter    
        def private(self,value):    
            self.__private=value  
            
        #删除私有属性  
        @private.deleter  
        def private(self):  
            del self.__private  
          
    t1=test1()    
    #print t1.__private # 外界不可直接访问私有属性    
    print (t1.private) # 读私有属性
    print (t1.__dict__) 
    t1.private='change 1' #对于经典类来说,该语句实际上是改变了实例t1的实例变量private  
    print (t1.__dict__)
    print (t1.private) # 输出刚刚添加的实例变量private  
    
    t1.private='change 2'  
    print (t1.__dict__)  
    del t1.private # 删除刚刚添加的实例变量private  
    print (t1.__dict__) 
    #print (t1.private) #读私有属性,因为已经删除,所以这里会报错
    
    print ('-------------------------------------------------------')
    t2=test2()    
    print (t2.__dict__)  
    print (t2.private) # 继承了object,添加@private.setter后,才可以写    
    t2.private='change 2' # 修改私有属性    
    print (t2.__dict__)   
    print (t2.private)  
    del t2.private #删除私有变量  
    #print t2.private #私有变量已经被删除,执行“读”操作会报错:AttributeError: 'test2' object has no attribute '_test2__private'    
    print (t2.__dict__) 
    
    

    运行:

    alex 1
    {'_test1__private': 'alex 1'}
    {'_test1__private': 'change 1'}
    change 1
    {'_test1__private': 'change 2'}
    {}
    -------------------------------------------------------
    {'_test2__private': 'alex 2'}
    alex 2
    {'_test2__private': 'change 2'}
    change 2
    {}
    

    貌似差别也不是很大。

    参考:
    https://blog.csdn.net/sxingming/article/details/52916249

    5. “魔术方法”的使用

    可以参考:https://blog.csdn.net/NightCharm/article/details/79357559

    展开全文
  • Java类中方法定义

    千次阅读 2017-08-20 17:54:13
    的方法 用来定义类的某种行为 ,也称为行为,方法,...1.如果方法具有返回值,方法中必须使用关键字return返回该值,返回类型为该返回 值的类型。 return 表达式; return作用: 1.跳出方法 2.给出结果 2. 如果
    类的方法
    用来定义类的某种行为 ,也称为行为,方法,成员方法
    格式
    [访问修饰符] void|返回值类型 方法名(数据类型 参数名,数据类型 参数名……);
    注:void表示无返回值
    两种情况
    1.如果方法具有返回值,方法中必须使用关键字return返回该值,返回类型为该返回 值的类型。 return 表达式;
    return作用: 1.跳出方法 2.给出结果
    2. 如果方法没有返回值,返回类型为void
    在本类内部,可以直接通过方法名称调用内部的方法
    方法的调用
    方法完成某个特定的应用进程功能,并返回结果
    方法的调用:执行方法中包含的语句
    语法:对象名。方法名();
    方法之间允许相互调用,不需要知道方法的具体实现,提高了效率

    在本类中调用本类的实例:
    package com.jredu.ch08;
    public class Ch01 {
    public int a;
    public int b;
    public int test(){
    return a;
    }
    public int test2(){
    //在本类内部可以直接调用本类内部的方法
    return test();//等价于 return a;
    }
    public void test3(){
    }
    public void test4(){
    test3();
    }
    }
    在调用另一类时,需要定义对象。实例:
    package com.jredu.ch07.exer;
    //地区类
    public class Area {
    //属性:地区编号,地区名称
    public int num;
    public String name;
    public Area( String name,int num) {
    super();
    this.num = num;
    this.name = name;
    }
    }
    package com.jredu.ch07.exer;
    //房屋类
    public class House {
    //属性:房屋编号,房屋类型(一居室、两居室等等),所在区域,
    public String num;
    public String type;
    public Area area;// 调用上面的Area类
    public int price;
    public House(String num, String type,int price,Area area) {
    super();
    this.num = num;
    this.type = type;
    this.area = area;
    this.price = price;
    }
    public void show(){
    System.out.println("房屋编号是:"+num);
    System.out.println("房屋类型是:"+type);
    System.out.println("房屋的价格是:"+price);
    System.out.println("房屋所在的区域是:"+area.name+","+"该地区编号是"+area.num);
    }
    public static void main(String[] args) {
    Area a=new Area("海淀区中关村",1);//很重要。在调用其他类的时候要定义对象
    House house=new House("001", "一室一厅", 3000,a);
    house.show();
    }
    }
    面向对象的思想
    类的方法实现某个特定的功能
    某个类不需要知道它如何实现
    知道了实现此功能的类和它的方法名,就可以直接调用了,你不用重复写代码
    如何使用带参数的方法
    展开全文
  • 定义声明和体。基本格式如下: class 类名{ 体 } 特点: 1、是Java程序的基本要素,一个Java应用程序就是由若干个所构成; 2、声明的变量称为对象变量,也简称 对象 ; 3、class 关键字是...
  • python 三种定义类的方式

    千次阅读 2018-03-05 11:23:28
    在Python中方,有三种定义类的方法: 常规方式、@classmethod修饰方式、@...class类定义 In [1]: class A: ...: def common(self,x): ...: print "executing common(%s,%s)"% (self,x) ...: pri...
  • 是 Java 的一种重要的...在 Java 中定义一个,需要使用 class 关键字、一个自定义的类名和一对表示程序体的大括号。完整语法如下: [public][abstract|final]class<class_name>[extends<class_name...
  • java匿名内部什么是匿名内部?匿名内部的使用场景?匿名内部如何创建?匿名内部的实现和使用例1(实现接口)例2(继承) 什么是匿名内部? 匿名内部,顾名思义,就是不知道这个到底是什么名字,也...
  • C++头文件定义类方法

    万次阅读 多人点赞 2019-06-29 16:52:57
    新手在写C++程序定义类的时候,可能会犯一个错误,就是在main函数文件里定义很多,一个文件包含很多函数,这样程序看起来很冗杂。今天总结一下如何在C++使用...头文件一般是声明,包括的成员,方法,还...
  • 1、定一个枚举 ...   public enum Color ... //定义枚举的常量  RED(1,"hongse"), GREEN(2,"qingse"),BLACK(3,"heise");    private int code;  private String name;    
  • 定义一个名为 Circle的,其中含有double型的成员变量centerX和centerY表 示圆心坐标,radius 表示圆的半径。...定义默认构造方法,在该方法中调用有参数构造方法,将圆的半径设置为1.0。画出该的...
  • (3)Student类中定义一个无参的构造方法和一个接收两个参数的构造方法,两个参数分别为姓名和成绩属性值。 (4)在测试类中创建两个Student对象,一个使用无参的构造方法,然后调用方法给姓...
  • 方法中定义内部

    千次阅读 2018-03-27 18:57:52
    方法中定义内部 理论上内部可以定义中的任意位置上,这就包括了:、方法、代码块中。不过如果从实用角度上讲在方法中定义内部的形式是最多的。范例:在方法中定义内部 class Outer{//定义一个外部...
  • 在java类中定义常量的三中方法

    千次阅读 2018-07-15 00:00:16
    主要讲解如何在java类中定义常量:/** * Method One */ interface ConstantInterface { String SUNDAY = "SUNDAY"; String MONDAY = "MONDAY"; String TUESDAY = "TUESDAY"; ...
  • 定义一个表示学生信息的Student...

    万次阅读 多人点赞 2018-07-30 17:33:18
    定义一个表示学生信息的Student,要求如下: (1)Student的成员变量: ... 在构造方法中通过参数完成对成员变量的赋值操作。 (3)Student的方法成员:  getNo(): 获得学号; getName():获...
  • Interface中定义方法

    千次阅读 2016-03-28 22:57:00
    Interface中定义方法,加入方法体
  • 类中定义方法 PyCharm 提示Method xxx may be ‘static’http://stackoverflow.com/questions/23554872/why-does-pycharm-propose-to-change-method-to-static原因是该方法不涉及对该属性的操作,编译器建议声明...
  • 题目:设计一个复数complex,分别将复数的实部和虚部作为属性,定义三个构造方法(没有参数时默认为实部和虚部都为0;一个参数时默认为实数,即虚部为0,两个参数时分别为实部和虚部),并定义两个成员方法计算两个复数...
  • 定义一个时,会有很多内置方法。此时关于参数的调用,本菜鸟感觉比较模糊。现在此总结一下。 class Person(object): #此处不能填写参数,因为这个规定的是从哪里继承,是什么类型#的子类 def init(self, first_...
  • JS中定义类方法

    万次阅读 2007-10-24 20:13:00
    JS中定义类的方式有很多种: 1、工厂方式 function Car(){ var ocar = new Object; ocar.color = "blue"; ocar.doors = 4; ocar.showColor = function(){ document.write(this.color) }; return...
  • 的基本定义语法,使用关键字class去定义一个,语法格式如下:访问控制符 class 类名{  成员变量声明  构造器声明  成员方法声明 } 一.访问控制符 包含:public ,private ,protected 二.类名要有意义,且首...
  • 定义:在普通的基础上扩充了一些抽象方法 。 1. 抽象方法:只声明而未实现的方法(没有方法体) 所有抽象方法使用abstract定义。同时抽象方法所在的也要用abstract定义,表示抽象。 举例:定义一个抽象...
  • 1.方法中的泛型 public static T backSerializable(Class clazz , String path ,String fileName){ FileInputStream fis = null; ObjectInputStream ois = null; Object obj = null; try { ...
  • 代码1 import static java.lang.Math.PI;... * 定义一个圆 * 内部提供一个属性半径r * 提供两个方法计算面积和周长并输出 * 定义一个测试使用 * */ class Circle4 { double r; public Ci...
  • 一、抽象与抽象方法定义 抽象:只在普通的基础上扩充了一些抽象...抽象类中包含抽象方法,抽象方法不包含方法体,即抽象类中没有具体实现,所以抽象类中不能直接产生实例化对象 举例:创建一个简单的抽象...
  • java中能在方法中定义方法吗?

    千次阅读 2018-05-18 17:02:02
    方法中不能直接定义方法,但可以在方法中定义里面再定义方法: public static void main(String[] args) {  class A { void test() { System.out.println("test()"); } } new A().test(); }
  • 习题6.13 定义一个Student,包含如下内容: 成员变量:学号,姓名,性别,班干部否,数学,语文,外语 成员方法:输入,总分,平均分 编程实现这个,并调用相应的方法输入数据,计算总分和平均分。 代码块: ...
  • 在实体类中定义方法,另外创建实体方法接口、,并且由实体保存实体方法的引用,当被调用具体的方法时,执行实体方法类中的实现。 这个实体方法接口、并非service接口、,因为service一般都不会被实体...
  • 抽象和抽象方法定义及讲解?

    千次阅读 多人点赞 2019-02-26 17:26:23
    首先说抽象: (1)抽象只能作为其他的基类,它不能直接实例化,对抽象不能使用new 操作符。 (2)抽象类中可以包含抽象成员,但非抽象类中不可以。...(1)抽象方法必须声明在抽象类中。 ...
  • Java中类定义

    千次阅读 2018-11-04 14:27:45
    举一个例子说明下,比如Person(人)就是一个,那么具体的某个人“张三”就是“人类”这个的对象,而“姓名、身高、体重”等信息就是对象的属性,人的动作比如“吃饭、穿衣”等就是对象的方法。总之就是有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,513,687
精华内容 1,405,474
关键字:

类中定义方法