Python中理解 ‘面向对象’，‘类’，‘类的结构’，‘封装’，私有方法和私有属性，继承

一、面向对象

概述

面向过程 和 面向对象 的基本概念

面向过程：---侧重于怎么做？
1.把完成某一个需求的 所有步骤 从头到尾 逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数
特点：
1.注重步骤与过程，不注重职责分工
2.如果需求复杂，代码会变得很复杂
3.开发复杂项目，没有固定的套路，开发难度很大

面向对象：--谁来做?
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
1.在完成某一个需求前，首先确定职责--要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供的固定套路
3.需要在面向过程的基础上，再学习一些面向对象的语法

"""

2

# _*_ coding:utf-8 _*_
"""
file: 面向对象01.py
date: 2018-07-17 10:05 AM
author: westos-dd
desc:
类的设计：
在程序开发中，要设计一个类，通常需要满足以下三个要求：
1.类名 这类事物的名字，满足大驼峰命名法
2.属性 这类事物具有什么样的特征
3.方法 这类事物具有什么样的行为

需求：
小明今年18岁，身高1.75，每天早上要跑步，会去吃东西
小美今年17岁，身高1.65 小美不跑步，小美喜欢吃东西
Person()
name
age
height
run()
eat()

一只黄颜色的狗狗叫大黄
看见生人旺旺叫
看见家人摇尾巴
Dog()
color
name
shout()
shake()
"""

3.

# _*_ coding:utf-8 _*_
"""
file: 面向对象02.py
date: 2018-07-17 10:06 AM
author: westos-dd
desc:
    
面向对象的基础语法：
定义简单的类：
定义只包含方法的类：
class 类名：
	def 方法1(self,参数列表):
	    pass
	def 方法2(self,参数列表):
	    pass

当一个类定义完成之后，要使用这个类来创建对象，语法格式如下:
对象变量 = 类名()

需求
	小猫爱吃鱼，小猫要喝水
"""
class Cat():
    def eat(self):
        print '小猫爱吃鱼'
    def drink(self):
        print '小猫要喝水'

tom = Cat()
tom.eat()
tom.drink()

"""
在日常开发中，不推荐在类的外部给对象增加属性
如果在运行时，没有找到属性，程序会报错
"""

4

# _*_ coding:utf-8 _*_
"""
file: 面向对象03.py
date: 2018-07-17 10:18 AM
author: westos-dd
desc:
    

"""
class Cat():
    # 哪一个对象调用的方法，self就是哪一个对象的引用
    def eat(self):
        print '%s love fish' % self.name
    def drink(self):
        print '小猫要喝水'

# 创建猫对象
tom = Cat()
#tom.name = 'tom'
tom.eat()
tom.drink()
tom.name = 'tom'
print tom
#addr = id(tom)
# %x:打印格式为十六进制
#print '%x' % addr
# %d:打印格式为十进制
#print '%d' % addr

# 再创建一个猫对象
lazy_cat = Cat()
lazy_cat.name = 'miaomiao'
lazy_cat.eat()
lazy_cat.drink()
print lazy_cat

lazy_cat2 = lazy_cat
print lazy_cat2

5.

# _*_ coding:utf-8 _*_
"""
file: 面向对象04.py
date: 2018-07-17 11:03 AM
author: westos-dd
desc:
    
初始化方法
我们现在已经知道了使用 类名() 就可以创建一个对象
当使用类名()创建对象时，python的解释器会自动执行以下操作：
	1.为对象在内存中分配空间--创建对象
	2.调用初始化方法为对象的属性设置初始值--初始化方法(__init__)
这个初始化方法就是__init__方法，__init__是对象的内置方法
__init__方法是专门用来定义一个类具有哪些属性的方法
"""
# class Cat():
#     def __init__(self):
#         print '这是一个初始化方法'
#         # self.属性名 = 属性的初始值
#         self.name = 'Tom'
#         #print 'hello'
#
# # 使用 类名() 创建对象的时候，会自动调用初始化方法 __init__
# tom = Cat()
# print tom.name

class Cat(object):
    def __init__(self,new_name):
        # self.name = 'Tom'
        self.name = new_name
        # 在类中，任何方法都可以使用self.name
    def eat(self):
        print '%s 爱吃鱼' % self.name

tom = Cat('tom')
print tom.name
tom.eat()

lazy_cat = Cat('lazy_cat')
lazy_cat.eat()

实验结果

/usr/bin/python2.7 /home/kiosk/PycharmProjects/python/1.py
tom
tom 爱吃鱼
lazy_cat 爱吃鱼

Process finished with exit code 0

改造初始化方法--初始化的同时设置初始值：
在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造
1.把希望设置的属性值，定义成__init__方法的参数
2.在方法内部使用self.属性名 = 形参 接收外部传递的参数
3.在创建对象时，使用类名(属性1，属性2..)调用

二、类

# _*_ coding:utf-8 _*_
"""
file: 01.py
date: 2018-07-17 3:53 PM
author: westos-dd
desc:
    
类是一个特殊的对象
Python中一切皆对象
	class AAA: 定义的类属性属于类对象
	obj1 =AAA: 属于实例对象
在运行程序时，类 同样会被加载到内存
在python中，类 是一个特殊的对象--类对象

除了封装 实例(对象) 的属性和方法外，类对象还可以有自己的属性和方法

通过 类名. 的方式可以直接访问类的属性或者调用类的方法

"""
class Tool(object):
    # 1.使用了赋值语句定义类属性，记录所有的工具的数量
    count = 0
    def __init__(self,name):
        self.name = name
        Tool.count += 1


tool1 = Tool('斧头')
tool2 = Tool('榔头')
tool3 = Tool('梯子')
print Tool.count

类属性就是针对类对象定义的属性
    使用赋值语句在class关键字下方可以定义类属性
    类属性用于记录于这个类相关的特性

类方法就是针对类对象定义的方法
    在类方法内部就可以直接访问类属性或者调用其他类方法

语法如下：
@classmethod
def 类方法(cls):
    pass

# _*_ coding:utf-8 _*_
"""
file: 06.py
date: 2018-07-25 3:23 PM
author: westos-dd
desc:


"""
class Toy(object):
    # 1.定义类属性
    count = 0

    @classmethod
    def show_toy_count(cls):
    # cls.coun:在类方法的内部，访问当前的类属性
        print '玩具对象的数量 %d' % cls.count
    def __init__(self,name):
        self.name = name
        # 让类属性的值 +1
        Toy.count += 1

# 创建玩具对象
toy1 = Toy('乐高')
toy2 = Toy('玩具车')
toy3 = Toy('玩具熊')

# 调用类方法
Toy.show_toy_count()
# 在方法的内部，可以直接访问类属性

运行结果为

/usr/bin/python2.7 /home/kiosk/PycharmProjects/python/1.py
玩具对象的数量 3

Process finished with exit code 0

静态方法
在开发时，如果需要在类中封装一个方法，这个方法：
    既不需要访问实例属性或者调用实例方法
    也不需要访问类属性或者调用类方法
这个时候可以把这个方法封装成一个静态方法

语法如下：
@staticmethod
def 静态方法():
    pass
静态方法需要修饰器@staticmethod来标识，告诉解释器这是一个静态方法
通过类名，调用静态方法

# _*_ coding:utf-8 _*_
"""
file: 06.py
date: 2018-07-25 3:23 PM
author: westos-dd
desc:


"""
class Cat(object):
    @staticmethod
    # 静态方法不需要传递第一个参数：self
    def call():
        print '小猫喵喵叫～'

# 通过类名.调用静态方法
# 不需要创建对象，直接可以使用
Cat.call()

/usr/bin/python2.7 /home/kiosk/PycharmProjects/python/1.py
小猫喵喵叫～

Process finished with exit code 0

# _*_ coding:utf-8 _*_
"""
file: 综合应用.py
date: 2018-07-22 1:36 PM
author: westos-dd
desc:
    
1.设计一个Game类
2.属性
	类属性，记录游戏的历史最高分(与这个游戏类有关系，与每次游戏无关)
	实例属性，记录当前游戏玩家的玩家姓名
3.方法：
    静态方法：方法show_help显示游戏帮助信息
	类方法：方法show_top_score显示历史最高分
	实例方法：方法start_game开始当前玩家的游戏

4.主程序步骤
	1.查看帮助信息
	2.查看历史最高分
	3.创建游戏对象，开始游戏
"""
class Game(object):
    # 1.记录历史最高分
    top_score = 0
    def __init__(self,player_name):
        self.player_name = player_name

    @staticmethod
    def show_help():
        print '@#@!$@!$'

    @classmethod
    def show_top_score(cls):
        print '历史记录 %d' % cls.top_score

    def star_game(self):
        print '%s 开始游戏了' % self.player_name

#1.查看游戏帮助信息
Game.show_help()
# 2.查看历史最高分
Game.show_top_score()
# 创建游戏对象。开启游戏
game = Game('小明')
game.star_game()

"""
案例小结：
1.实例方法：方法内部需要访问实例属性
2.类方法：方法内部只需要访问类属性
3.静态方法：方法内部不需要访问实例属性和类属性

提问：如果方法内部，既需要访问实例属性，又需要访问类属性，应该定义什么方法？
应该定义实例方法
因为，类只有一个，在实例方法的内部可以使用 类名.访问类属性
"""

类的结构

实例：
1.使用面向对象开发，第一步是设计类
2.使用 类名() 创建对象，创建对象的动作有两步
    1.在内存中为对象分配空间
    2.调用初始化方法__init___ 为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在--实例

因此：
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法

在程序执行时：
1.对象各自拥有自己的实例属性
2.调用对象的方法，可以通过self
    访问自己的属性
    调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中之有一份，在调用方法时，需要把对象的引用传递到方法内部

三、封装

封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

# _*_ coding:utf-8 _*_
"""
file: 封装——01.py
date: 2018-07-17 11:51 AM
author: westos-dd
desc:
    
封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
4.对象方法的细节都被封装在类的内部

XX爱跑步
1.XX体重75.0公斤
2.XX每次跑步会减肥0.5公斤
3.XX每次吃东西体重会增加1公斤
"""
class Person():
   def __init__(self,name,weight):
       self.name = name
       self.weight = weight
   def __str__(self):
       return '我的名字叫 %s 体重是 %.2f' % (self.name,self.weight)
   def run(self):
       print '%s 爱跑步' % self.name
# 在对象的方法内部，是可以直接访问对象的属性
       self.weight -= 0.5
   def eat(self):
       print '%s 吃东西' % self.name
       self.weight += 1

lily = Person('lily',75.0)
lily.run()
#lily.eat()
print lily

amy = Person('amy',45.0)
amy.eat()
#amy.run()
print amy
print lily

用Python简单写士兵开枪

# _*_ coding:utf-8 _*_
"""
file: 士兵开枪.py
date: 2018-07-17 2:08 PM
author: westos-dd
desc:
1.士兵瑞恩有一把AK47
2.士兵可以开火(士兵开火扣动的是扳机)
3.枪 能够 发射子弹(把子弹发射出去)
4.枪 能够 装填子弹 --增加子弹的数量
Soldier               Gun
-------------         -----------------
name                  model
gun                   bullet_count #子弹数量足够多才能完成射击的动作
-------------         -----------------
__init__(self):		  __init__(self):
fire(self):          add_bullet(self,count):#装填子弹的方法
			         shoot(self):
"""
class Gun():
    def __init__(self,model):
        # 枪的型号
        self.model = model
        # 子弹的数量
        self.bullet_count = 0
    def add_bullet(self,count):
        self.bullet_count += count

    def shoot(self):
        # 1.判断子弹的数量
        if self.bullet_count <= 0:
            print '%s 没有子弹了' % self.model
            return
        # 2.发射子弹
        self.bullet_count -= 1
        # 3.提示发射信息
        print '%s 突突突 %d' % (self.model,self.bullet_count)

class Soldier():
    def __init__(self,name):
        self.name = name
        self.gun = None
    def fire(self):
        # 1.判断士兵有没有枪
        if self.gun == None:
            print '%s 还没有枪。。' %self.name
            return
        # 2.高喊口号
        print 'go!!! %s' %self.name
        # 3.让枪装填子弹
        self.gun.add_bullet(50)
        # 4.让枪发射子弹
        self.gun.shoot()

# 1.创建枪对象
ak47 = Gun('AK47')
#ak47.add_bullet(50)
#ak47.shoot()

# 创建士兵
ryan = Soldier('Ryan')
ryan.gun = ak47
ryan.fire()
print ryan.gun


"""
一个对象的属性可以是另外一个类创建的对象
"""

2、摆放家具

# _*_ coding:utf-8 _*_
"""
file: 摆放家具.py
date: 2018-07-17 11:57 AM
author: westos-dd
desc:
摆放家具
需求：
1.房子有户型，总面积和家具名称列表
	新房子没有任何的家具
2.家具有名字和战地面积，其中
	床：占4平米
	衣柜：占2平面
	餐桌：占1.5平米
3.将以上三件家具添加到房子中
4.打印房子时，要求输出:户型，总面积，剩余面积，家具名称列表

"""
class HouseItem():
    # 初始化方法
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return '[%s] 占地 %.2f' % (self.name,self.area)

# 创建家具
bed = HouseItem('bed',4)
print bed
chest = HouseItem('chest',2)
print chest
table = HouseItem('table',1.5)
print table

class House():
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        #剩余面积
        self.free_area = area
        # 家具名称列表
        self.item_list = []
    def __str__(self):
        return '户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s' % \
               (self.house_type,self.area,self.free_area,self.item_list)
    def add_item(self,item):
        print '要添加 %s' % item

# 创建房子对象
my_home = House('两室一厅',100)

# 添加家具
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

摆放家具2

# _*_ coding:utf-8 _*_
"""
file: 摆放家具2.0.py
date: 2018-07-17 2:01 PM
author: westos-dd
desc:
在完成添加家具的方法之前，我们先简单回顾一下之前的代码
小结：
1.创建了一个家具类，使用到__init___和__str__两个内置的方法
2.准备了一个add_item方法 准备添加家具
3.使用 房子类 创建了一个 房子对象
4.让 房子对象 调用三次add_item方法，将三件家具以实参的形式传递到add_item内部

"""
class HouseItem():
    # 初始化方法
    def __init__(self,name,area):
        self.name = name
        self.area = area
    def __str__(self):
        return '[%s] 占地 %.2f' % (self.name,self.area)

class House():
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        #剩余面积
        self.free_area = area
        # 家具名称列表
        self.item_list = []
    def __str__(self):
        return '户型：%s\n总面积：%.2f[剩余：%.2f]\n家具：%s' % \
               (self.house_type,self.area,self.free_area,self.item_list)
    def add_item(self,item):
        print '要添加 %s' % item
        # 1.判断家具的面积
        if item.area > self.free_area:
            print '%s 的面积太大了，无法添加' % item.name
            # 如果不满足，下方的代码就不执行
            return
        # 2.将家具的名称添加到列表中
        self.item_list.append(item.name)
        # 3.计算剩余的面积
        self.free_area -= item.area

# 1.创建家具
bed = HouseItem('bed',4)
print bed
chest = HouseItem('chest',2)
print chest
table = HouseItem('table',7)
print table

#2.创建房子对象
my_home = House('两室一厅',60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print my_home

四、私有方法和私有属性

# _*_ coding:utf-8 _*_
"""
file: 01.py
date: 2018-07-17 3:42 PM
author: westos-dd
desc:
私有属性和私有方法
应用场景及定义方式
应用场景
	在实际开发中，对象的某些属性或方法可能只希望在对象的内部使用，而不希望在外部被访问到
	私有属性 就是 对象 不希望公开的 属性
	私有方法 就是 对象 不希望公开的 方法
定义方法
	在定义属性或方法时，在属性名或者方法名前增加两个下划线，定义的就是私有属性或方法
"""
class Women():
    def __init__(self,name):
        self.name = name
        self.__age = 18
    def ___secret(self):
        print '%s 的年龄是 %d' % (self.name,self.__age)

lily = Women('lily')
# 私有属性，在外界不允许直接访问
#print lily.age
# 私有方法，外界不允许直接访问
lily.secret()

2

# _*_ coding:utf-8 _*_
"""
file: 02.py
date: 2018-07-17 3:43 PM
author: westos-dd
desc:
父类的私有属性和私有方法
1.子类对象不能在自己的方法内部，直接访问父类的私有属性和私有方法
2.子类对象可以通过父类的公有方法间接访问到私有属性或私有方法
私有属性，私有方法是对象的隐私，不对外公开，外界以及子类都不能直接访问
私有属性，私有方法常用做一些内部的事情

"""
class A(object):
    def __init__(self):
        # 在初始化方法中定义了两个属性，一个共有属性，一个私有属性
        self.num1 = 100
        self.__num2 = 200
        # 定义私有方法
    def __test(self):
        print '私有方法 %d %d' % (self.num1,self.__num2)
    def test(self):
        print '%d' % self.__num2
        self.__test()
class B(A):
    def demo(self):
        # 在子类的方法中，不能访问父类的私有属性
        print '访问父类的私有属性 %d' % self.__num2
        # 在子类的方法中，不能调用父类的私有方法
        self.test()
# 创建了一个子类对象
b = B()
print b
# 在外界不能直接访问对象的私有属性/调用私有方法
# print b.__num2
# b.__test
b.test()

五、继承

# _*_ coding:utf-8 _*_
"""
file: 继承——01.py
date: 2018-07-17 2:47 PM
author: westos-dd
desc:
    
面向对象三大特性
1.封装：根据职责将属性和方法封装到一个抽象的类中
2.继承：实现代码的重用，相同的代码不需要重复的写
3.多态：不同的对象调用相同的方法，产生不同的结果，
    增加代码的灵活度
"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵～'

fentiao = Cat()
fentiao.eat()
fentiao.drink()
fentiao.run()
fentiao.sleep()
fentiao.call()

# 子类继承自父类，可以直接享受父类中已经封装好的方法
# 子类中应该根据自己的职责，封装子类特有的属性和方法

单继承
1.继承的概念 语法和特点
继承的概念：子类拥有父类的所有方法和属性(子类只需封装自己特有的方法)
2.继承的语法
class 类名(父类)
        def 子类特有的方法

继承的传递性：（爷爷 父亲 儿子）
1.C类从B类继承，B类又从A类继承
2.那么C类就具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵～'

class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'

class Dog(Animal):
    def bark(self):
        print '旺旺～'

# 创建一个hellokitty对象
kt = Hellokitty()

kt.speak()

# 子类可以继承自父类的所有属性和方法
kt.call()
# 继承的传递性，子类拥有父类和父类的父类的属性和方法
kt.eat()
kt.drink()
kt.run()
kt.sleep()

dog = Dog()
dog.sleep()
dog.bark()
dog.call()

重写父类

# _*_ coding:utf-8 _*_
"""
file: 继承——04.py
date: 2018-07-17 3:06 PM
author: westos-dd
desc:
重写父类方法有两种情况：
1.覆盖父类的方法
2.对父类方法进行扩展

1.覆盖父类的方法
如果在开发中，父类的方法的实现和子类方法的实现，
完全不同，就可以使用覆盖的方式，
在子类中重新编写父类的方法

具体实现方式，就相当于在子类中定义了
一个和父类同名的方法并且实现
重写之后，在运行时，只会调用子类的重写方法，
而不会再调用父类封装的方法
"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵～'

class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'
    def call(self):
        print '偶哈呦 空你起哇'

kt = Hellokitty()
# 如果子类中，重写了父类的方法
# 在运行中，只会调用子类中重写的方法，不会调用父类的方法
kt.call()

对父类的方法进行扩展

# _*_ coding:utf-8 _*_
"""
file: 继承——05.py
date: 2018-07-17 3:07 PM
author: westos-dd
desc:
对父类的方法进行扩展
如果在开发中，子类的方法实现包含有父类的方法实现
(父类原本封装的方法实现是子类方法的一部分
就可以使用扩展方法)
1.在子类中重写父类的方法
2.在需要的位置使用 父类名.方法(self) 来调用父类方法的执行
(使用父类名称调用父类方法)
3.代码其他的位置针对子类的需求，编写子类特有的代码实现

"""
class Animal():
    def eat(self):
        print '吃'
    def drink(self):
        print '喝'
    def run(self):
        print '跑'
    def sleep(self):
        print '睡'

class Cat(Animal):
    # 子类拥有父类的所有属性和方法
    def call(self):
        print '喵喵～'

class Hellokitty(Cat):
    def speak(self):
        print '我可以说日语'
    def call(self):
        print '偶哈呦 空你起哇'
        # 调用原本在父类中封装的方法
        Cat.call(self)
        print '#@!#@!#@!'
kt = Hellokitty()
# 如果子类中，重写了父类的方法
# 在运行中，只会调用子类中重写的方法，不会调用父类
kt.call()

练习

# _*_ coding:utf-8 _*_
"""
file: 继承——06.py
date: 2018-07-21 4:45 PM
author: westos-dd
desc:
    

"""
class Bird():
    def __init__(self):
        self.hungry = True
    def eat(self):
        if self.hungry:
            print 'Aaaaaa...'
            self.hungry = False
        else:
            print 'no Thanks!'

class SongBird(Bird):
    def __init__(self):
        self.sound = 'Squawk!'
        Bird.__init__(self)
    def sing(self):
        print self.sound

# bird = Bird()
# bird.eat()

littlebird = SongBird()
littlebird.eat()
littlebird.sing()

多继承

# _*_ coding:utf-8 _*_
"""
file: 多继承.py
date: 2018-07-17 3:21 PM
author: westos-dd
desc:
多继承
子类拥有一个父类叫做单继承
子类可以拥有多个父类，并且具有所有父类的属性和方法
例如：孩子会继承自己父亲和母亲的特性

语法：
calss 子类名（父类名1，父类名2...）
	pass
"""
class A(object):
    def test(self):
        print 'A----test 方法'
    def demo(self):
        print 'A----demo方法'
class B:
    def demo(self):
        print 'B-----demo 方法'
    def test(self):
        print 'B-----test 方法'

class C(B,A):
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass

c = C()
c.test()
c.demo()