面向对象--类,嵌套

一:类的成员:

例:

class Foo:          #创建类
    #方法
    def __init__(self,name):
            #实例变量/字段
            self.name = name
    #方法
    def func(self):
            pass

#obj.Foo类的对象
#obj.Foo类的实例

obj = Foo(‘四大龙王‘)

成员分为三类:  字段 - 方法 - 属性

  字段(变量):

    - 实例变量(字段)

      -公有实例变量(字段)

class Foo:

    def __init__(self,name):
           self.name = name
            self.age = 123

    def func(self):
          print(self.name)

obj = Foo(‘李哥‘)
print(obj.name)
print(obj.age)
obj.func()

      -私有实例变量(字段)

class Foo:
    def __init__(self,name):
        #私有实例变量(私有字段)
        self.__name = name   #私有

        self.age = 123

    def func(self):
        print(self.__name)

obj = Foo(‘小狗‘)
print(obj.age)
#obj.__name  #无法访问
obj.func()        #找到一个内部:func, 让func帮助执行内部私有__name

    -类变量(静态字段)

      -公有类变量(静态字段)

class Foo:
    country = "中国"

    def __init__(self):
        pass

    def func(self):
        #内部调用
        print(self.country)
        print(Foo.country)   #推荐
#外部调用

print(Foo.country)

obj = Foo()
obj.func()

      -私有类变量(静态字段)

class Foo:
    __country = "中国"

    def __init__(self):
        pass

    def func(self):
        #内部调用
        print(self.__country)
        print(Foo.country)           #推荐

#外部无法调用私有类变量
#print(Foo.country)

obj = fooc()
obj.func()

字段:

class Foo:
    #类变量(静态字段)
    country = "中国"

    def __init__(self,name):
           #实例变量(字段)
            self.name = name

    def func(self):
            pass

"""
准则:
    实例变量(字段)访问时,使用对象访问,即:obj.name
    类变量(静态字段)访问时,使用类方法,即Foo.country (实在不方便的时候才用对象访问)

"""

什么时候使用变量?

  当所有对象中有共同的字段时要改都改,要删都删时,可以将实例变量(字段)提取到类变量(静态字段)

方法:

方法分为:

  -实例方法:由对象调用,至少一个self参数;执行实例方法时,自动将调用该方法的对象赋值给self.

class Foo(object):
    def __init__(self,name):
        self.name = name

    #实例方法
    def func(self):
        print(self.name)

obj = Foo(‘..‘)
obj.func()

  -静态方法:由类调用,无默认参数.

class Foo(object):
    def __init__(self,name):
        self.name = name

    #静态方法,如果无需使用对象中封装的值,那么久可以使用静态方法
    @staticmethod
    def display(a1,a2):
        return a1+a2
Foo.display(1,3)

  -类方法:由类调用,至少一个cls参数,执行类方法时,自动将调用该方法的类赋值给cls.

class Foo(object):
    #类方法,cls是类
    @classmethod
    def show(cls,x1,x2):
        print(cls,x1,x2)
#执行类方法
Foo.show(1,8)

方法包含:实例方法,静态方法,类方法,三种方法在内存中都归属于类,区别在于调用方式不同.

属性

1:属性的基本使用

# ##############定义###############
class Foo:
    def func(self):
        pass

    #定义属性
    @property
    def prop(self):
        pass

# ###############调用###############
foo_obj = Foo()

foo_obj.func()
foo_obj.prop                #调用属性

Python的属性的功能是:属性内部进行一系列的逻辑计算,最终将计算结果返回。

注意:

  在定义时,在方法上添加@property;

  属性仅有一个self参数

  无需使用括号

  方法: foo_obj.func()

  属性:foo_obj.prop

  属性存在的意义是:访问属性时可以制造出和访问字段完全相同的假象

  属性通过方法改造出来,如果Python中没有属性,方法完全可以替代其功能

2.属性的两种定义方式

属性的定义有两种方式:

  装饰器 即:在方法上应用装饰器

  静态字段 即:在类中定义值为property对象的静态字段

二:嵌套

"""
创建三个学校且三个学校的设施内容等都是一致.
"""
class School(object):
    def __init__(self, name, address):
        self.name = name
        self.address = address

    def speech(self):
        print(‘讲课‘)

obj1 = School(‘老男孩北京校区‘, ‘美丽富饶的沙河‘)
obj2 = School(‘老男孩上海校区‘, ‘浦东新区‘)
obj3 = School(‘老男孩深圳校区‘, ‘南山区‘)

class Teacher(object):
    def __init__(self, name, age, salary):
        self.name = name
        self.age = age
        self.__salary = salary
        self.school = None

t1 = Teacher(‘李杰‘, 19, 188888)
t2 = Teacher(‘艳涛‘, 18, 60)
t3 = Teacher(‘女神‘, 16, 900000)
# ############## 老师分配校区
t1.school = obj1
t2.school = obj1
t3.school = obj2
# ####################################
# 查看t1老师,所在的校区名称/地址
print(t1.school.name)
print(t1.school.address)
print(t1.name)
print(t1.age)
t1.school.speech()

# 准则: 字段和方法的归类.

原文地址:https://www.cnblogs.com/wangjun187197/p/9549919.html

时间: 2024-10-12 04:07:05

面向对象--类,嵌套的相关文章

Php面向对象 – 类常量

类常量:类中,保存运行周期内,不变的数据. 定义: const关键字 const 常量名 = 常量值 例子: class Student { public  $stu_id; public  $stu_name; public  $stu_gender; const  GENDER_MALE = '男'; const  GENDER_FEMALE = '女'; } 类常量不受访问限定修饰符的限制 访问: 类::常量名 例子: class Student { public  $stu_id; pu

《转》面向对象类设计原则

面向对象类的设计原则 1                 SRP(单一职责原则) 这个原则看起来很简单,就是说一个类只能承担一个职责. 但这里有一个关键:"职责"是如何理解的? 按照汉语的理解,职责其实分为两部分:"职"和"责"."职"就是这个类是什么,而"责"就是这个类要干什么. 举个例子来说:Door是一个对象,那么它的"职"就是门,"责"就是"开门.关

php面向对象类中常用的魔术方法

php面向对象类中常用的魔术方法 1.__construct():构造方法,当类被实例化new $class时被自动调用的方法,在类的继承中可以继承与覆盖该方法,例: //__construct() class construct{ public function __construct(){ $this->var = "this is var"; } } class con2 extends construct{ public function __construct(){ $

面向对象类成员

面向对象类成员:字段,方法,属性 一.字段: 举个例子: class Foo: def __init__(self, name): self.name = name 其中的self.name就是字段,不过这是一个普通的字段,保存在对象中,可以通过对象去访问例如: 1 obj = Foo("DJC") 2 print(self.name) 3 4 >>>DJC 除了普通字段还有静态字段来看以下代码: class Foo: s = 123 def __init__(sel

Java基础知识:面向对象&类图

类(Class)封装了数据和行为,是面向对象的重要组成部分,它是具有相同属性.操作.关系的对象集合的总称.在系统中,每个类都具有一定的职责,职责指的是类要完成什么样的功能,要承担什么样的义务.一个类可以有多种职责,设计得好的类一般只有一种职责.在定义类的时候,将类的职责分解成为类的属性和操作(即方法).类的属性即类的数据职责,类的操作即类的行为职责.设计类是面向对象设计中最重要的组成部分,也是最复杂和最耗时的部分. 1.面向对象特性 1)抽象 2)继承 3)封装 4)多态 2.类图: 在软件系统

Java面向对象-类与对象

Java面向对象-类与对象 类与对象的关系 我们通俗的举个例子,比如人类是一种类,张三这个人就是人类的具体的一个个体,也就是java中的对象:这就是一个类与对象的关系: 类的定义 下面看实例 类的创建和使用 看下面实例 我们在com.java1234.chap03.sec01包下新建一个Person类 1 package com.java1234.chap03.sec01; 2 3 /** 4 * Person类 文件名和类名必须一致 5 * @author user 6 * 7 */ 8 pu

面向对象 类和对象

//面向对象     类     对象 //类是对象的抽象化//对象是类的实例化 class Ren{ //成员变量 var $tpo; var $zhong; var $name; var $sex; //成员方法 function Eat() { echo "正在用手吃饭";  } function Run() {  echo "跑的很快"; }} //实例化对象$r=new Ren();$r->name="张三";echo $r-&g

图解Python 【第五篇】:面向对象-类-初级基础篇

由于类的内容比较多,分为类-初级基础篇和类-进阶篇 类的内容总览图: 本节内容一览图: 今天只讲类的基础的面向对象的特性 前言总结介绍: 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个"函数"供使用(可以讲多函数中公用的变量封装到对象中) 对象,根据模板创建的实例(即:对象),实例用于调用被包装在类中的函数,对象是一个类的实例 实例(instance):一个对象的实例化实现. 标识(identity):每个对象的实例都需要一个可

C#编程语言与面向对象——类与对象

由于ASP.NET技术是全面向对象的,因此,要掌握这一技术,必须具备有扎实的面向对象理论基础 使用C#编程,所有的程序代码几乎都放在类中,不存在独立于类中之外的函数,因此,类是面向对象编程的基本单元 在绝大多数面向对象语言中,一个类都可以包含两种成员:字段和方法.字段与方法这两个概念是面向对象理论的术语,是通用与各种面向对象语言的.而在各种的具体面向对象语言(比如C#)中,可以简单地理解: 字段及变量,方法及函数. C#编程语言与面向对象--类与对象