接下来进入第五章的学习：面向对象基础

一、类

1.类（class）：由3部分组成

类的名称：类名
类的属性：一组数据
类的方法：允许对其操作的方法（行为）

例如

#设计一个人类
类名: People
属性: 身高 体重 年龄 性别
行为(方法):吃饭  睡觉

2.那么我们该如何去定义类呢？

class 类名:
属性列表
方法列表

例如：定义一个猫类

class cat(object):          #继承object父类legs = 4                #这就是猫的属性#像猫的其他属性如颜色什么的，每只猫都不一样，我们要后面用init去输入每只猫的颜色，这里放后面去讲          def eat(self):          #这些就是猫的行为（方法）print('猫吃老鼠')def drink(self):print('猫喝水')cat1=cat()  #这样cat1就有了cat的所有属性print(cat1.legs)  #是4
cat1.eat()        #输出'猫吃老鼠'

3.类添加属性

在我们定义完一个类之后，创建了类的对象，我们可以手动给这个对象添加属性

定义一个人类

class Person(object):#属性:身高,体重,年龄#行为:吃饭 睡觉 喝水#定义一个普通方法def eat(self):print('人都要吃饭')#定义一个普通方法def sleep(self):print('人都要休息')
P=Person()
P.name = '张三'  #这样就给他添加上属性了

4.init()方法 (初始化方法)

class 类名：初始化方法，用来完成一些默认的设置

 def __init__(self):函数体语句      #类去赋值对象的时候会直接运行这个函数

例如定义一个汽车类

class cars(object):def __init__(self,color,wheelnum):self.color = colorself.wheelnum = wheelnumdef move(self):print('车子在移动...')def whistle(self):print('汽车在鸣笛')car1=cars('white','4')     #就需要在赋类的时候输出参数
print(car1.color)
car1.move()

创建完之后依然可以修改其属性的值

car1.color='black'  #直接这样修改就好了

5.del()方法 (析构方法)

创建对象后，python解释器默认调用init()

同样，当删除一个对象的时候，python解释器也会默认调用del()

class Animal(object):#定义初始化方法  创建对象时候自动调用def __init__(self,name):self.name = name#定义普通方法def walk(self):print('动物会跑')#定义一个析构方法  删除对象的时候自动调用def __del__(self):print('%s对象被干掉'%(self.name))dog = Animal('哈皮狗')
dog.walk()
del dog     #这时候会输出 哈皮狗对象被干掉
print(dog.walk()) #就会报错了

但是呢，要在对象的引用计数为0时，对象才是真正的被删除

#创建一个cat对象
cat = Animal('波斯猫')
cat2 = cat
cat3 = catprint('删除对象1')
del cat
print('删除对象2')
del cat2
print('删除对象3')
del cat3
# 只有在cat3被删除后，才会输出 波斯猫对象被干掉

python 会在程序结束前自动调用del

总结:
变量保存了对象的引用,对象的引用计数加1,
使用__del__()删除对象的时候,对象的引用计数-1,对象被删除
如果对象的引用计数不是1,每删除一次对象的引用计数减1,直到引用计数为0时候
该对象才被真正的删除

6.魔方方法

魔方方法：
特殊方法：是指被包含下划线的方法或者所能调用到的方法的统称，这些通常会在特殊的情况下调用，并且基本没有手动调用他们的必要。

例如str 定义一个车类

class Car(object):#定义初始化方法  创建对象的时候被自动调用def __init__(self,newColor,newWheelNum):self.color = newColorself.wheelNum = newWheelNum#定义一个析构方法  删除对象的时候被自动调用def __del__(self):print('%s对象被删除'%(self.color))#定义一个魔方方法def __str__(self):msg = '%s-%d'%(self.color,self.wheelNum)return msg#创建一个对象laosi
laosi = Car('红色',4)
print(laosi)

总结:如果类的属性比较多,可以重写str()方法打印属性,方便阅读,无需手动调用,当使用print打印对象的时候,自动调用

7.重写一般方法和重写特殊的构造方法

重写涉及一个概念:继承

如果现在有两个类A(父类)，B(子类) 如果子类B继承父A, ，类B的某个方法被调用的时候先从B中找，如果找不到再去A中找，如果在A找不到----》基类（object）

class 命名（基类==父类）:#声明一个父类A
class A(object):#声明一个普通方法def sayHello(self):print('我是A')#声明一个子类B
class B(A): #B类后面圆括号里面继承的父类名字#声明一个普通方法# def sayHello(self):#     print('我是B')

8.理解一下self

class Animal(object):#定义一个初始化方法def __init__(self,name):self.name = name#定义一个普通方法def printName(self):print('动物的名字是:%s'%self.name)  #self=dogdog=Animal('哈士奇')
dog.printName()    #动物的名字是:哈士奇

总结:self可以理解成对象的本身

我们来做一个烤地瓜的应用熟悉一下类的使用

类名:SweetPotato

属性:根据数字判断地瓜的生熟度 0~3生的 3~5半生不熟 5~8烤熟了 8以上烤糊了，有番茄酱芥末蜂蜜

class sweetpotato(object):
def __init__(self):self.cooklevel = 0self.cookstring = '生的'self.condiments=[]def cook(self,time):self.cooklevel += timeif 0<self.cooklevel<=3:self.cookstring='生的'elif 3<self.cooklevel <=5:self.cookstring='半生不熟'elif 5 <self.cooklevel<=8:self.cookstring='烤熟啦'elif self.cooklevel >8:self.cookstring='烤糊了哈哈'def addcondiments(self,condiment):self.condiments.append(condiment)def __str__(self):str1='%s,%s'%(self.cookstring,self.condiments)return str1             #有这个就不用我一个个输出它的属性了s = sweetpotato()print('开始测试烤地瓜')
s.cook(4)
print(s)s.cook(4)
print(s)s.addcondiments('芥末')
s.addcondiments('蜂蜜')
print(s)

蛮有意思的可以看看哈哈哈

9.访问限制

如果有一个对象，当需要对其进行修改属性：
1.直接修改对象名.属性名 = 新数据
2.间接修改对象名.方法名()

将属性定义为私有：__双下划线后面跟属性名

直接看例子把会更让人懂一些

#定义一个人类
class Person(object):#定义一个初始化方法def __init__(self,name,money):self.__name = nameself._money = money#定义普通方法对属性设置def setName(self,value):#数据过滤if len(value) <= 4:self.__name = valueelse:print('名称的长度不能大于4个字符')#定义普通方法获取属性值def getName(self):return self.__name#定义私有方法def __sayHello(self):print('我的名字是:%s,我有%s存款'%(self.__name,self._money))#定义公有方法获取私有属性def test(self):self.__sayHello()

然后这时候我们创建一个对象p

p = Person('张三','99999999')
print(p.name)  #是不让访问的哦
Print(p.__name) #也同样不行

那应该怎么办呢？我们可以通过方法去访问他

print(p.gerNmae())

那么不能通过对象访问，自然也不能通过对象修改值了

同样啊，私有方法不能直接访问的

那么什么又是半公开属性呢，就是他是受保护的属性，Python中有个默认的规定,即在属性名前加上单个下划线(_属性名)来表示这是个受保护的属性,虽然Python解释器不会对使用单个下划线前缀的属性名做特殊处理,但程序员们会严格遵守这个约定,不会在类外部访问这种属性

私有属性为什么不能在类外访问?

因为_name python解释器将它转换成_Person__name，可以通过_Person__name访问,但是不建议这样做

p._Person__name = '李淑芬'
print(p.getName())

二、继承

继承的概念：在现实生活中，一般指子女继承父辈的基因,财产

1.单继承

一个子类继承父类的方法，但不会继承属性

class Cat(object):
#定义初始化方法
def __init__(self,name,color):self.name = nameself.color = color#定义一个普通方法
def eat(self):print('猫喜欢吃老鼠')#定义子类Bosi继承父类Cat
class Bosi(Cat):#定义初始化方法def __init__(self,type,num):self.type = typedef sleep(self):print('睡觉呢')bosi=Bosi('bosi',4)
bosi.eat()           #'猫喜欢吃老鼠'

2.多继承

简而言之就是继承多个父类

class A(object):def test(self):print('test----A')#声明一个父类B
class B(object):def test(self):print('test---B')#声明一个子类,同时继承A和B两个父类
class C(A,B):def test(self):  #理解方法重写:比如语言  父母一般只会汉语 我们还会其他语言 比如英语 日语print('test----C')#创建一个对象c
c = C()
c.test()   #是输出test----c,但如果没有这个，就是输出test-----A
print(C.__mro__)#可以打印查看执行方法的顺序
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

总结:一个子类同时继承了多个父类,如果调用同名的方法,先从子类找,子类没有到父类里面找根据就近原则

3.重写父类

重写父类其实就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖父类中的方法，跟刚刚讲的那个就近原则一样

class Person(object):#定义普通方法def lunch(self):print('人都需要吃饭')#定义一个子类Student,继承父类Person
class Student(Person):#子类重写和父类同名的方法def lunch(self):print('学生需要吃饭')#创建Student对象s
s = Student()
s.lunch()   #'学生需要吃饭'

那么子类要怎么样才能继承父类的属性呢

emm准确意义上来说不是继承父类的属性，是可以直接调用父类的init函数

class Person(object):#定义初始化方法def __init__(self,name,age,sex):self.name = nameself.age = ageself.sex = sex#定义普通方法def eat(self):print('人都需要吃饭')#定义普通方法def speak(self):print('我会汉语')#定义子类Student继承父类Person
class Student(Person):#定义初始化方法def __init__(self,name,age,sex,no):        #有三种方法的# 调用父类同名方法#1.父类类名.父类初始化方法# Person.__init__(self,name,age,sex)# 2.super()# super().__init__(name, age, sex)#3.super()super(Student,self).__init__(name, age, sex)self.no = no#创建一个对象
s = Student('张学友',20,'男',110)

面向对象基础（类封装继承等等）相关推荐

Java第三次作业——面向对象基础（封装）
Java第三次作业--面向对象基础(封装) (一)学习总结 1.什么是面向对象的封装性,Java中是如何实现封装性的?试举例说明. 封装性就是指对外部不可见,用对象直接访问类中的属性,在面向对象法则中 ...
scala面向对象基础---类继承和特质
一.类继承传送门:Scala基础-类继承 Scala的类继承调用超类的构造方法重写超类的成员 3.1.不被继承的成员 3.2.不可重写的成员 3.3.无参方法与字段子类型多态与动态绑定抽象类 ...
Java面向对象三大特性(封装继承多态)解释及案例
文章目录包包基本语法命名规则命名规范导入包实例访问修饰符面向对象编程-封装面向对象编程-继承 super关键词 super和this的比较方法重写/覆盖 (override) 注意事 ...
【小白学java】java的面向对象设计：封装+继承+抽象类+接口（day06）
课程链接:共六天第一天:开发环境:初识java,搭建环境第二天:语言基础:关键字.变量.常量.运算符第三天:数据结构:基本类型.包装类型.引用类型(数组和对象) 第四天:流程控制:分支判断.循环 ...
第九课（面向对象）：封装继承多态
一.面向对象概念:根据模板(创建一个类)并实例化这个思路就叫面向对象二.使用面向对象编程好处: 可以重复使用(实例化类) 容易修改(只用修改类的模板) 三.面向对象的特点: 封装继承多态类名 ...
-1-2 java 面向对象基本概念封装继承多态变量 this super static 静态变量匿名对象值传递初始化过程代码块 final关键字抽象类接口
java是纯粹的面向对象的语言也就是万事万物皆是对象程序是对象的集合,他们通过发送消息来相互通信每个对象都有自己的由其他的对象所构建的存储,也就是对象可以包含对象每个对象都有它的类型也就是 ...
类封装继承接口抽象类综合测试
第一题 1.定义一个学生类型 1)有姓名,年龄,所在班级,c成绩,html成绩,java成绩这几个属性 2)有一个输出自己信息的方法 3)有一个输出总成绩的方法要求:用该学生类型定义两个学生变量,并 ...
python面向对象-4类的继承与方法的重载
1.类的继承与方法的重载上面就是先定义了一个类A,然后由定义了一个类B,B继承了类A,这样B就有了A的非私有属性和方法. 1 class Washer: 2 company='ZBL' 3 def ...
7-4 jmu-Java-03面向对象基础-04-形状-继承 (15 分)
前言前面题目形状中我们看到,为了输出所有形状的周长与面积,需要建立多个数组进行多次循环.这次试验使用继承与多态来改进我们的设计. 本题描述: 定义抽象类Shape 属性:不可变静态常量double ...
python3 面向对象、类、继承、组合、派生、接口、子类重用父类方法
对象是特征(变量)与技能(函数)的结合体而类是一系列对象共同的特征与技能的集合体 class teacher:lesson = "python"def __init__(self, ...

面向对象基础（类封装继承等等）