面向对象三大特性
一.封装
-->概念:封装是指隐藏对象中的一些不希望被外界访问到的属性和方法
-->作用:增强存储数据的安全性
1.封装的引入
class Cat():
def __init__(self,name,color):
self.name = name
self.color = color
def speak(self):
print("miao")
def sleep(self):
print("%s is sleeping"%self.name)
c1 = Cat("小白","white")
print(c1.name) 小白
print(c1.color) white
这些属性是可以在类对象外部进行修改的,所以这是不安全的,需要一种方式去增强数据的安全性,即属性不能随意修改,且不能修改为任意的值,因此需要进行封装
2.封装的方法
<1>将属性名修改为希望外界不知道的名字self.hidden_name = name(此法防君子不防小人)
<2>提供一个getter和setter方法是外部可以访问并修改属性
优点:增加验证,提高数据存储的安全性
class Cat():
def __init__(self,name,color):
self.hidden_name = name #方法1的体现,防君子不防小人
self.color = color
def get_name(self): # get_name获取name
return self.hidden_name
def set_name(self,name): #set_name修改name
self.hidden_name = name
c1 = Cat("小白","white")
# print(c1.get_name()) #小白
c1.set_name("大黑")
print(c1.hidden_name) #大黑
<3>可以对对象的属性使用双下划线的方式__xxx 这个其实是:_类名__属性名(python内置)
class Dog:
def __init__(self,name):
self.__name = name
def get_name(self):
return self.__name
def set_name(self,name):
self.__name = name
d1 = Dog("小黑")
print(d1.get_name()) # 小黑 未修改前的访问
d1.__name = "小白" #强行修改
print(d1.get_name()) # 小黑 #不能随意修改了
// 硬要修改,使用内置方法,_类名__属性名(python内置)
print(d1._Dog__name) #小黑
d1._Dog__name ="小白"
print(d1._Dog__name) #小白
二.继承
-->继承简介
1.提高代码复用性 2.让类与类之间产生了关系,才引出了多态
具体操作:在一个类的创建出来的括号中添加一个父类(超类,基类),继承父类的方法
[注意] : 如果省略的父类,那么默认父类为Object,Object是所有类的父类 [注意]如果子类和父类有相同的方法时,那么调用该方法时,会调用子类的方法.
这种特性称之为方法的重写.(可理解为就近原则)
class Animal: //定义第一个类(父类)
def run(self):
print("animal running")
def speak(self):
print("animal speaking")
class Dog(Animal): //定义第二个类(子类),并声明父类位Animal
def run(self):
print("dog running")
def look_home(self):
print("dog can look home")
d1 = Dog()
# 继承Animalrun和speak方法
d1.run() #animal running
d1.speak() #animal speaking
# 方法的重写:Animal 和 Dog 都有run方法
d1.run() #dog running 就近原则,自己有先使用自己的
-->多重继承
python种支持多重继承,即一个类对应多个父类
如果多个父类中有相同方法,那么前面的方法会把后面的覆盖
父类查看方法:__bases__查看当前类的父类(base后面有s,所以这个可以检验一个或多个父类) 格式:类名.__bases__
class Ag(): //定义第一个类
def test(self):
print("hello")
class Bg(): //定义第二个类
def test(self):
print("world")
class C(Ag,Bg): //定义第三个类(并声明该类的父类位Ag和Bg)
pass
print(C.__bases__) #(<class '__main__.Ag'>, <class '__main__.Bg'>)
c = C()
c.test() #hello 前面的父类会把后面的用拥有的相同方法覆盖
三.多态
#多态的意思是，不同的对象，都实现了同一个接口，
#因此我们可以不管这个对象是什么，直接调用这个方法就可以了。
class A:
def __init__(self,name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name = name
class B:
def __init__(self,name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name = name
class C():
pass
a = A('小黑')
b = B('小红')
c = C()
def speak(obj):
print("你好,我是%s"%obj.name)
speak(a) # 你好,我是小黑
speak(b) # 你好,我是小红
speak(c) # AttributeError: 'C' object has no attribute 'name'
多态简单实例(加深理解)
len()
多个对象都能够使用len()函数,因此在len()体现了面向对象的多态特性
因此正是由于多态的这种特性,大大提高了代码的复用率,提高效率
lst = [1,2,3,4]
s ="python"
print(len(lst)) #4
print(len(s)) #6
四.属性和方法
类属性:
在类中定义的属性 可以被类对象和类创建出来的实例对象访问,
只能通过类对象去修改,无法通过实例对象修改
实例属性:
通过实例定义的属性,只能被实例对象访问和修改,不可被类修改和访问
类方法:
第一个参数位cls,系统自动传入,cls指当前的类对象,可以被类对象和类创建出来的实例对象访问,
实例方法:
在类中直接定义,以self位第一个参数开头的都是实例方法,
可以通过实力调用a.方法名()
也可以通过类调用A.方法名(a)
静态方法:
无关于类的方法,一个无关竟要的方法,比如获得当前时间,工具方法
class A():
num =1
a = A()
//类属性
# print(A.num) #1
# print(a.num) #1
class B():
num =1
def __init__(self): # 实例属性
self.name ="小黑"
def test(self): # 实例方法
print("test方法被调用了")
@classmethod
def test_class(cls): //类方法
print("test_class方法被执行了")
@staticmethod //静态方法
def test_calm():
print("我是静态方法")
