面向对象 编程及面向对象三大属性：封装 继承 多态
面向对象
面向对象(Object Oriented,OO)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术 [1] 发展到一定阶段后的产物。
早期的计算机编程是基于面向过程的方法，例如实现算术运算1+1+2 = 4，通过设计一个算法就可以解决当时的问题。随着计算机技术的不断提高，计算机被用于解决越来越复杂的问题。一切事物皆对象，通过面向对象的方式，将现实世界的事物抽象成对象，现实世界中的关系抽象成类、继承，帮助人们实现对现实世界的抽象与数字建模。通过面向对象的方法，更利于用人理解的方式对复杂系统进行分析、设计与编程。同时，面向对象能有效提高编程的效率，通过封装技术，消息机制可以像搭积木的一样快速开发出一个全新的系统。面向对象是指一种程序设计范型，同时也是一种程序开发的方法。对象指的是类的集合。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。
起初，“面向对象”是专指在程序设计中采用封装、继承、多态等设计方法。
面向对象的思想已经涉及到软件开发的各个方面。如，面向对象的分析（OOA，Object Oriented Analysis），面向对象的设计（OOD，Object Oriented Design）、以及我们经常说的面向对象的编程实现（OOP，Object Oriented Programming）。
面向对象的分析根据抽象关键的问题域来分解系统。面向对象的设计是一种提供符号设计系统的面向对象的实现过程，它用非常接近实际领域术语的方法把系统构造成“现实世界”的对象。面向对象程序设计可以看作一种在程序中包含各种独立而又互相调用的对象的思想，这与传统的思想刚好相反：传统的程序设计主张将程序看作一系列函数的集合，或者直接就是一系列对电脑下达的指令。面向对象程序设计中的每一个对象都应该能够接受数据、处理数据并将数据传达给其它对象，因此它们都可以被看作一个小型的“机器”，即对象。
面向对象的基础语法
当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：
对象变量 = 类名()
类的设计：
在程序开发中，要设计一个类，通常需要满足以下三个要求：
1.类名 这类事物的名字，满足大驼峰命名法
2.属性 这类事物具有什么样的特征
3.方法 这类事物具有什么样的行为
例如：
小明今年18岁，身高1.75，每天早上要跑步，会去吃东西
小美今年17岁，身高1.65，小美不跑步，小美喜欢吃东西
类名：Person( )
属性：name age height
方法：run( ) eat( )
一只黄颜色的狗狗叫大黄
看见生人汪汪叫
看见家人摇尾巴
类名：Dog( )
属性：color name
方法：shout( ) shake( )
需求：
小猫爱吃鱼,小猫要喝水
"""
class Cat():def eat(self):print '小猫爱喝水'def drink(self):print '小猫要喝水'
tom = Cat()
tom.eat()
tom.drink()# 需求：
# 小明今年18岁，身高1.75,每天早晨要跑步，会去吃东西
# 小美今年17岁，身高1.65,小美不跑步,喜欢吃东西
# Person()
# name
# age
# height
# run()
# eat()
面向对象的基础语法：
定义简单的类：
定义只包含方法的类：
class 类名：
def 方法1(self,参数列表)：
pass
def 方法2(self,参数列表)：
pass
当一个类定义完成后，要使用这个类来创建对象,语法格式如下：
对象变量 = 类名 ()
class Cat():def eat(self):print '%s 爱喝水 ' %self.namedef drink(self):print '%s 要喝水' %self.name
# 创建猫对象
tom = Cat()
tom.name = 'tom'
tom.eat()
tom.drink()
print tom
# addr = id (tom)
# print '%x' %addr
# %x:打印格式为十六进制
# print '%d' %addr
# %d:打印格式为十进制
mimi = Cat()
mimi.name = 'lazy_cat'
mimi.eat()
mimi.drink()
print mimi
addr1 = id(mimi)
print 'mimi的地址为 %s' %addr1
lazy_cat2 = mimi
addr2 = id (lazy_cat2)
print 'lazy_cat2的地址为 %s' %addr2"""
在日常开发中，不推荐在类的外部给对象增加属性
如果在运行时，没有找到属性，程序会报错
"""
self的使用：
万能说法：self 哪一个对象调用的方法，self就是哪一个对象的引用
# self 哪一个对象调用的方法，self就是哪一个对象的引用def eat(self):print '%s 爱吃鱼 ' % self.namedef drink(self):print '%s 要喝水' % self.name# 创建猫对象
tom = Cat()
tom.name = 'tom'
tom.eat()
tom.drink()
print tom
# addr = id (tom)
# print '%x' %addr
# print '%d' %addr
mimi = Cat()
mimi.name = 'mimi'
mimi.eat()
mimi.drink()
print mimi
# 创建出来的两个猫对象没有任何关系面向对象初始化
初始化方法
我们现在已经知道了使用类名()就可以创建一个对象
当使用类名()创建对象时，python的 解释器会自动执行以下操作：
1.为对象在内存中分配空间–创建对象
2.调用初始化方法为对象的属性设置初始值–初始化方法(init(self))
这个初始化方法就是init方法，init时对象的内置方法
init方法是专门用来定义一个类具有哪些属性的方法
class Cat():def __init__(self):print '__init__(self)是一种初始化方法'# 使用类名()创建对象的时候，会自动调用初始化方法'__init__(self)'self.name = 'fentiao'# self.属性名 = 属性的初始值,此时传入的属性名是固定的
tom = Cat()
print tom.name
Jimmy = Cat()
print Jimmy.name
# 固定的属性名称'fentiao'
class Cat():def __init__(self,new_name):# 传入形参new_nameprint '__init__(self)是一种初始化方法'self.name = new_name# 在类中，任何方法都可以使用self.nameprint '%s 爱吃小鱼' %self.name
tom = Cat('tom')
print tom.name
Jimmy = Cat('Jimmy')
print Jimmy.name
内置方法
del方法：
在python中当使用类名()创建对象时，为对象分配空间后，
会自动调用init方法；
当一个对象被从内存中销毁前，会自动调用del方法
class Cat():def __init__(self,new_name):self.name = new_nameprint '%s 来了' %self.namedef __del__(self):print '%s 被删除了' %self.name
Tom = Cat('Tom')
print Tom.nameprint '~~~~~'class Cat():def __init__(self,new_name):self.name = new_nameprint '%s 来了' %self.namedef __del__(self):print '%s 被删除了' %self.name
Tom = Cat('Tom')
print Tom.name
del Tom
print '~~~~~'
str内置方法
在python中，使用python输出对象变量,
默认情况下，会输出这个变量引用的对象是由哪一个类创建的对象
以及在内存中的地址（十六进制）
如果在开发中，希望使用print输出对象变量时，
能够打印自定义的内容，就可以利用str这个内置方法
class Cat():def __init__(self,new_name):self.name = new_namedef __str__(self):# 必须返回一个字符串return '我是一只叫%s的小猫咪' %self.nameTom = Cat('tom')
print Tom
“面向对象”是专指在程序设计中采用封装、继承、多态等设计方法：
下面我们就来学习封装 继承 多态
什么是封装 继承 多态 ？
1.封装
根据职责将属性和方法封装到一个抽象的类中定义类的准则
2.继承
实现代码的重用,相同的代码不需要重复的编写设计类的技巧
子类针对自己特有的需求,编写特定的代码
3.多态
不同的子类(这是之前提到的继承的知识)对象调用相同的方法，产生不同的执行结果
封装
1.封装是面向对象编程的一大特点
2.面向对象编程的第一步 将属性和方法封装到一个抽象的类中
3.外界使用类创建对象，然后让对象调用方法
class Person:def __init__(self, name, weight):self.name = nameself.weight = weightdef __str__(self):return '我的名字是 %s,我的体重为 %.2f' % (self.name, self.weight)def run(self):self.weight -= 0.5print '%s 每次跑步体重减少0.5公斤' % self.name
# 在对象的方法内部，是可以直接访问对象的属性def eat(self):self.weight += 1print '%s每次吃东西体重增加一公斤' % self.nameXX = Person('xiaoming', 75.0)
XX.run()
XX.eat()
XX.eat()
print XX
摆放家具
需求：
1.房子有户型，总面积和家具名称列表
新房子没有任何的家具
2.家具有名称和占地面积，其中
床：占4平方米
衣柜：占2平方米
餐桌：占1.5平米
3.将以上三种家具添加到房子中
4.打印房子时，要求输出：户型，总面积，剩余面积，家具名称列表
设计思路：
1.创建了一个家具类，使用init和str两个内置方法
2.准备了一个add_furniture 方法准备添加家具
3.使用房子类 创建了一个 房子对象
4.让 房子对象 调用三次add_furniture 方法，
将三件家具以实参的形式传递到add_furniture
class Furniture:def __init__(self, name, area):#初始化方法self.name = nameself.area = areadef __str__(self):return '%s 占地 %.2f' % (self.name, self.area)# 创建家具
bed = Furniture('bed', 4)
print bed
chest = Furniture('chest', 2)
print chest
table = Furniture('table', 1.5)
print tableclass House:def __init__(self, type, area):self.type = typeself.area = areaself.free_area = area# 剩余面积self.fur_list = []# 家具名称列表def __str__(self):return '房子户型: %s' \'占地面积：%.2f' \'剩余面积: %.2f' \% (self.type, self.area, self.free_area)def add_furniture(self, fur_name, fur_area):print '添加 %s,面积为 %s' % (fur_name, fur_area)# 1.判断家具面积和剩余占地面积if fur_area > self.free_area:print '你的%s面积过大,无法添加' %fur_namereturn# 2.将家具名称添加到列表中else:self.fur_list.append(fur_name)# 3.计算剩余面积self.free_area -= fur_area# 创建房子
my_home = House('两室一厅', 100)
print House
# 添加家具
my_home.add_furniture('bed', 100)
my_home.add_furniture('chest', 2)
my_home.add_furniture('table', 1.5)
print my_home
士兵开枪问题：
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 = modelself.bullet_count = 0def add_bullet(self, count):self.bullet_count += countdef shoot(self):if self.bullet_count <= 0:print '%s子弹不够' %self.modelreturnself.bullet_count-= 1print '%s tututu 剩余子弹数目为 %d' % (self.model, self.bullet_count)class Soliar:def __init__(self, name):self.name = nameself.Gun = Nonedef bullet_add(self,count):self.Gun.add_bullet()def fire(self):if self.Gun == None:print '%s 没枪阿' % self.namereturnprint '冲阿'self.Gun.shoot()# 1.创建枪对象
ak47 = Gun('AK47')# 2.创建士兵
ryen = Soliar('RYEN')
ryen.Gun = ak47
ryen.Gun.add_bullet(50)
ryen.Gun.shoot()
ryen.fire()
ryen.fire()
print ryen.Gun
面向对象的三大属性：
封装：根据职责将属性和方法封装在一个抽象的类中
继承：实现代码的重用，相同的代码不需要重复的写
多态：不同的对象调用相同的方法，产生不同的结果,增强代码的灵活度
单继承
1.继承的概念 语法 和 特点
概念：字类拥有父类的所有方法和属性(子类只需封装自己特有的功能属性)
2.继承的语法
class 类名(父类)
def 子类特有的方法
继承的传递性:(爷爷 父亲 儿子)
1.C类从B类继承，B类从A类继承
2.C类具有B类和A类的所有属性和方法
子类拥有父类以及父类的父类中封装的所有属性和方法
class Animal():def eat(self):print '吃吃吃'def drink(self):print '呵呵呵'def lue(self):print '略略略'class Cat(Animal):def buy(self):print '买买买'class DuolaAmeng(Cat):def play(self):print '玩玩玩'
DD = DuolaAmeng()
DD.lue()
DD.buy()
DD.drink()
DD.eat()
DD.play()
重写父类
方法有两种情况：
1.覆盖父类的方法
2.对父类方法进行扩展
覆盖父类的方法
如果在开发中,父类方法的实现和子类方法的实现完全不同,
就可以使用覆盖的方式,在子类中重新编写父类的方法
具体实现方式,就相当于在子类中定义了
一个和父类同名的方法并且实现
重写之后，在运行时，只会调用子类的重写方法,
而不会调用父类封装的方法
class Animal():def eat(self):print '吃吃吃'def drink(self):print '呵呵呵'def lue(self):print '略略略'class Cat(Animal):def call(self):print '喵喵～'class DuolaAmeng(Cat):def speak(self):print '我可以说日语'def call(self):print '欧哈有'
dingdang = DuolaAmeng()
# 如果子类中，重写了父类的方法
# 在运行中，只会调用子类中重写的方法，不会调用父类的方法
dingdang.call()
继承重写扩展：
对父类的方法进行拓展
如果在开发中，子类的方法实现包含有父类的方法实现
(父类原本封装的方法实现是子类方法的一部分就可以使用扩展方法)
1.在子类中重写弗雷德方法
2.在需要的位置i使用 父类名.方法(self)来调用父类方法的执行
(使用父类名称调用父类方法)
3.代码其他的位置针对子类的需求，编写子类特有的代码实现
class Animal():def eat(self):print '吃吃吃'def drink(self):print '呵呵呵'def lue(self):print '略略略'class Cat(Animal):def call(self):print '喵喵～'class DuolaAmeng(Cat):def speak(self):print '我可以说日语'def call(self):print '欧哈有'Cat.call(self)print '卡哇伊'
kt = DuolaAmeng()
kt.call()
当出现重写扩展被初始化需要先继承父类初始化属性,否则被覆盖的属性不能被子类继承调用
class Bird:def __init__(self):self.hungry = Truedef eat(self):if self.hungry:print '饿了,然后吃饱饱了'else:print '不饿,谢谢'class SongBird(Bird):def __init__(self):self.sound = 'lalala'Bird.__init__(self)def sing(self):print self.sound# bird = Bird()
# bird.eat()Little_bird = SongBird()
# Little_bird .eat() #继承父类时会报错,因为被init初始化时覆盖了,
# 此时需要在之前继承父类的初始化
Little_bird.eat()
Little_bird.sing()
多继承
子类拥有一个父类叫单继承
子类可以拥有多个父类，并且具有所有父类的属性和方法
例如:孩子会继承自己父亲和母亲的特性
语法：
calss 字类名 (父类名1,父类名2…)
pass
class A():def test(self):print 'A--test方法'def demo(self):print 'A--demo方法'class B():def test(self):print 'B--test方法'def demo(self):print 'B--demo方法'class C(B, A):pass
# 多继承可以让子类对象，同时具有多个父类的属性和方法
# 当多继承时,不同的父类中有相同的方法或属性,子类继承时,遵循其后跟的父类顺序
# 谁在前，就用谁c = C()
c.demo()
c.test()
class D(C):pass
D = C()
D.test()
D.demo()
3.多态
不同的子类(这是之前提到的继承的知识)
对象调用相同的方法，产生不同的执行结果
class Dog(object):def __init__(self, name):self.name = nameprint '%s 会汪汪叫,自由自在玩' % self.namedef game(self):print '%s 会玩 2048' % self.nameclass Zhuhegou(Dog):def game(self):print '%s 会打王者荣耀' % self.nameclass Person(object):def __init__(self, name):self.name = namedef game_with_dog(self,dog):# 将 狗 写入游戏和人玩print '%s 和 %s一起玩游戏' % (self.name, dog.name)dog.game()# 创建一个人对象
xiaolin = Person('xiaolin')
# 创建一个狗对象
wangcai = Zhuhegou('汪财')
# 汪财和人玩 汪财会玩王者荣耀# wangcai = Dog('汪财')
# 汪财和人玩 汪财会玩2048
xiaolin.game_with_dog(wangcai)
面向对象 编程及面向对象三大属性：封装 继承 多态相关推荐
- Day55-每日一道Java面试题-Java 面向对象编程三大特性: 封装 继承 多态
Java 面向对象编程三大特性: 封装 继承 多态 封装 封装把一个对象的属性私有化,同时提供一些可以被外界访问的属性的方法,如果属性不想被外界访问,我们大可不必提供方法给外界访问.但是如果一个类没有 ...
- python多态的三种表现形式_python小结----面向对象的三大特征(封装,继承,多态)
面向对象的三大特征: 封装,继承,多态 面向对象的编程思想核心:高类聚,低耦合–程序的设计模式范畴 封装 什么是封装: 在面向对象编程的思想中,对代码进行高度封装,封装又叫包装 封装就是指将数据或者函 ...
- Java面向对象三大特性(封装继承多态)解释及案例
文章目录 包 包基本语法 命名规则 命名规范 导入包实例 访问修饰符 面向对象编程-封装 面向对象编程-继承 super关键词 super和this的比较 方法重写/覆盖 (override) 注意事 ...
- Python学习笔记④——类、面向对象的三大特征 [封装+继承+多态]
✅ Blogger Learns Python is for learning the "Deep Learning". 文章目录 一.面向对象编程的简介 二.类与对象 -- 基础 ...
- 三大特征 封装 继承 多态
''' 1.面向对象与面向过程 面向过程:核心过程二字,过程即解决问题的步骤,就是先干什么后干什么 基于该思想写程序就好比在这是一条流水线,是一种机械式的思维方式 优点:复杂的过程流程化 缺点:扩展性 ...
- 深入理解Java面向对象三大特性 封装 继承 多态
1.封装 封装的定义: 首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系 为什么需要封装: 封装符合面向对象设计原则的第一条:单一性原则,一个类 ...
- OC面向对象的三大特征(封装 继承 多态)习题2 复合
复合:一个类中有一个成员变量是另外一个类的对象. 比如我现在要制作一台电脑,电脑需要CPU,显示器,鼠标和键盘等.这些东西的研发都是很复杂的过程.如果现在有成型的CPU等组件,就可以直接用这些组件攒一 ...
- 大数据笔记8—java基础篇4（面向对象-封装-继承-多态）
面向对象 一.面向对象 1.面向过程 1.2.举例 1.3.总结 二.面向对象 1.简述 2.举例 3.思想特点 2.1.类的定义格式 2.1.1.简述 2.2.2.格式 2.3.3.示例 三.类的使 ...
- c语言编程 菲薄拉,C语言设计模式-封装-继承-多态
快过年了,手头的工作慢慢也就少了,所以,研究技术的时间就多了很多时间,前些天在CSDN一博客看到有大牛在讨论C的设计模式,正好看到了,我也有兴趣转发,修改,研究一下. 记得读大学的时候,老师就告诉我们 ...
最新文章
- 红外协议之NEC协议
- go 调用winapi_golang 调用windows API 中文的处理
- 黄仁勋从煤气灶下取出最新GPU：7nm全新安培架构，售价20万美元，训练性能顶6张V100...
- pyV8不支持dom操作，关于PyV8的支持DOM的疑问
- springboot使用原生servlet、filter、listener
- 【三国志战略版】拆解与分析
- springboot使用ImportBeanDefinitionRegistrar 动态注册bean
- sql server 群集_SQL Server群集索引概述
- Java线程的同步 - synchronized
- checkbox选中与取消选择
- Unity渐进式GPU烘焙找不到显卡
- Android 项目总结(view控件之设置大小和间距)
- 新建网站常用的50个网站推广方法
- Excel使用right函数截断数据，并覆盖原来的数据
- 13年android手机top,2013安卓手机性能大排行：小米3才第七
- 报表数据源之Hadoop
- 使用SNMP检查服务器中运行的进程信息
- #FreeFortnite的卑鄙本质
- UGUI - 中设置UISprite图片灰显方法
- BP神经网络原理及其应用,bp神经网络的工作原理