看看Python的OOP和Java有什么区别？
Posted monkey7788
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了看看Python的OOP和Java有什么区别？相关的知识，希望对你有一定的参考价值。
Python从规划之初就已经是一门面向政策的言语，正因为如此，在Python中创立一个类和政策是很简略的。本章节咱们将详细介绍Python的面向政策编程。
假定你曾经没有触摸过面向政策的编程言语，那你或许需求先了解一些面向政策言语的一些根柢特征，在脑筋里头构成一个根柢的面向政策的概念，这样有助于你更简略的学习Python的面向政策编程。
接下来咱们先来简略的了解下面向政策的一些根柢特征。
面向政策技能简介
类(Class): 用来描绘具有相同的特征和办法的政策的集结。它界说了该集结中每个政策所共有的特征和办法。政策是类的实例。
类变量：类变量在整个实例化的政策中是共用的。类变量界说在类中且在函数体之外。类变量一般不作为实例变量运用。
数据成员：类变量或许实例变量用于处理类及其实例政策的相关的数据。
办法重载：假定从父类承继的办法不能满意子类的需求，能够对其进行改写，这个过程叫办法的掩盖（override），也称为办法的重载。
实例变量：界说在办法中的变量，只作用于当前实例的类。
承继：即一个派生类（derived class）承继基类（base class）的字段和办法。承继也答应把一个派生类的政策作为一个基类政策对待。例如，有这样一个规划：一个Dog类型的政策派生自Animal类，这是仿照"是一个（is-a）"联络（例图，Dog是一个Animal）。
实例化：创立一个类的实例，类的详细政策。
办法：类中界说的函数。
政策：经过类界说的数据结构实例。政策包括两个数据成员（类变量和实例变量）和办法。
创立类
运用class句子来创立一个新类，class之后为类的称谓并以冒号结束，如下实例:
class ClassName:
‘类的帮助信息’ #类文档字符串
class_suite #类体
类的帮助信息能够经过ClassName.__doc__检查。
class_suite 由类成员，办法，数据特征组成。
实例
以下是一个简略的Python类实例:
#!/usr/bin/python
-- coding: UTF-8 --
class Employee:
‘悉数职工的基类’
empCount = 0
def init(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print “Total Employee %d” % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
empCount变量是一个类变量，它的值将在这个类的悉数实例之间共享。你能够在内部类或外部类运用Employee.empCount拜访。
榜首种办法__init__()办法是一种特别的办法，被称为类的结构函数或初始化办法，当创立了这个类的实例时就会调用该办法
创立实例政策
要创立一个类的实例，你能够运用类的称谓，并经过__init__办法承受参数（LanpachemicaLs）。
“创立 Employee 类的榜首个政策”
emp1 = Employee(“Zara”, 2000)
“创立 Employee 类的第二个政策”
emp2 = Employee(“Manni”, 5000)
拜访特征
您能够运用点(.)来拜访政策的特征。运用如下类的称谓拜访类变量:
emp1.displayEmployee()
emp2.displayEmployee()
print “Total Employee %d” % Employee.empCount
完好实例：
#!/usr/bin/python
-- coding: UTF-8 --
class Employee:
‘悉数职工的基类’
empCount = 0
def init(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print “Total Employee %d” % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
“创立 Employee 类的榜首个政策”
emp1 = Employee(“Zara”, 2000)
“创立 Employee 类的第二个政策”
emp2 = Employee(“Manni”, 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print “Total Employee %d” % Employee.empCount
实施以上代码输出作用如下：
Name : Zara ,Salary: 2000
Name : Manni ,Salary: 5000
Total Employee 2
你能够添加，删去，修改类的特征，如下所示：
emp1.age = 7 # 添加一个 ‘age’ 特征
emp1.age = 8 # 修改 ‘age’ 特征
del emp1.age # 删去 ‘age’ 特征
你也能够运用以下函数的办法来拜访特征：
getattr(obj, name[, default]) : 拜访政策的特征。
hasattr(obj,name) : 检查是否存在一个特征。
setattr(obj,name,value) : 设置一个特征。假定特征不存在，会创立一个新特征。
delattr(obj, name) : 删去特征。
hasattr(emp1, ‘age’) # 假定存在 ‘age’ 特征回来 True。
getattr(emp1, ‘age’) # 回来 ‘age’ 特征的值
setattr(emp1, ‘age’, 8) # 添加特征 ‘age’ 值为 8
delattr(empl, ‘age’) # 删去特征 ‘age’
Python内置类特征
dict : 类的特征（包括一个字典，由类的数据特征组成）
doc :类的文档字符串
name: 类名
module: 类界说所在的模块（类的全名是’main.className’，假定类位于一个导入模块mymod中，那么className.module 等于 mymod）
bases : 类的悉数父类构成元素（包括了以个由悉数父类组成的元组）
Python内置类特征调用实例如下：
#!/usr/bin/python
-- coding: UTF-8 --
class Employee:
‘悉数职工的基类’
empCount = 0
def init(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self):
print “Total Employee %d” % Employee.empCount
def displayEmployee(self):
print "Name : ", self.name, ", Salary: ", self.salary
print “Employee.doc:”, Employee.doc
print “Employee.name:”, Employee.name
print “Employee.module:”, Employee.module
print “Employee.bases:”, Employee.bases
print “Employee.dict:”, Employee.dict
实施以上代码输出作用如下：
Employee.doc: 悉数职工的基类
Employee.name: Employee
Employee.module: main
Employee.bases: ()
Employee.dict: {‘module’: ‘main’, ‘displayCount’:, ‘empCount’: 0, ‘displayEmployee’:, ‘doc’: ‘xe6x89x80xe6x9cx89xe5x91x98xe5xb7xa5xe7x9ax84xe5x9fxbaxe7xb1xbb’, ‘init’:}
python政策毁掉(废物收回)
同Java言语相同，Python运用了引证计数这一简略技能来追寻内存中的政策。
在Python内部记录着悉数运用中的政策各有多少引证。
一个内部跟踪变量，称为一个引证计数器。
当政策被创立时， 就创立了一个引证计数， 当这个政策不再需求时， 也就是说， 这个政策的引证计数变为0 时， 它被废物收回。但是收回不是"当即"的， 由解说器在适当的机会，将废物政策占用的内存空间收回。
a = 40 # 创立政策
b = a # 添加引证，的计数
c = [b] # 添加引证.的计数
del a # 削减引证的计数
b = 100 # 削减引证的计数
c[0] = -1 # 削减引证的计数
废物收回机制不只针对引证计数为0的政策，相同也能够处理循环引证的情况。循环引证指的是，两个政策相互引证，但是没有其他变量引证他们。这种情况下，仅运用引证计数是不可的。Python 的废物收集器实际上是一个引证计数器和一个循环废物收集器。作为引证计数的补偿， 废物收集器也会留神被分配的总量很大（及未经过引证计数毁掉的那些）的政策。 在这种情况下， 解说器会暂停下来， 试图整理悉数未引证的循环。
实例
析构函数 del ，__del__在政策消逝的时分被调用，当政策不再被运用时，__del__办法运行：
#!/usr/bin/python
-- coding: UTF-8 --
class Point:
def __init( self, x=0, y=0):
self.x = x
self.y = y
def del(self):
class_name = self.class.name
print class_name, “destroyed”
pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印政策的id
del pt1
del pt2
del pt3
以上实例运行作用如下：
3083401324 3083401324 3083401324
Point destroyed
留心：一般你需求在单独的文件中界说一个类，
类的承继
面向政策的编程带来的首要优点之一是代码的重用，完成这种重用的办法之一是经过承继机制。承继彻底能够了解成类之间的类型和子类型联络。
需求留心的当地：承继语法 class 派生类名（基类名）：//… 基类名写作括号里，根柢类是在类界说的时分，在元组之中指明的。
在python中承继中的一些特征：
1：在承继中基类的结构（init()办法）不会被自动调用，它需求在其派生类的结构中亲自专门调用。
2：在调用基类的办法时，需求加上基类的类名前缀，且需求带上self参数变量。差异于在类中调用一般函数时并不需求带上self参数
3：Python总是首要查找对应类型的办法，假定它不能在派生类中找到对应的办法，它才开端到基类中逐一查找。（先在本类中查找调用的办法，找不到才去基类中找）。
假定在承继元组中列了一个以上的类，那么它就被称作"多重承继" 。
语法：
派生类的声明，与他们的父类类似，承继的基类列表跟在类名之后，如下所示：
class SubClassName (ParentClass1[, ParentClass2, …]):
‘Optional class documentation string’
class_suite
实例：
#!/usr/bin/python
-- coding: UTF-8 --
class Parent: # 界说父类
parentAttr = 100
def init(self):
print “调用父类结构函数”
def parentMethod(self):
print ‘调用父类办法’
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print “父类特征 :”, Parent.parentAttr
class Child(Parent): # 界说子类
def init(self):
print “调用子类结构办法”
def childMethod(self):
print ‘调用子类办法 child method’
c = Child() # 实例化子类
c.childMethod() # 调用子类的办法
c.parentMethod() # 调用父类办法
c.setAttr(200) # 再次调用父类的办法
c.getAttr() # 再次调用父类的办法
以上代码实施作用如下：
调用子类结构办法
调用子类办法 child method
调用父类办法
父类特征 : 200
你能够承继多个类
class A: # 界说类 A
…
class B: # 界说类 B
…
class C(A, B): # 承继类 A 和 B
…
你能够运用issubclass()或许isinstance()办法来检测。
issubclass() - 布尔函数判别一个类是另一个类的子类或许后代类，语法：issubclass(sub,sup)
isinstance(obj, Class) 布尔函数假定obj是Class类的实例政策或许是一个Class子类的实例政策则回来true。
办法重写
假定你的父类办法的功用不能满意你的需求，你能够在子类重写你父类的办法：
实例：
#!/usr/bin/python
-- coding: UTF-8 --
class Parent: # 界说父类
def myMethod(self):
print ‘调用父类办法’
class Child(Parent): # 界说子类
def myMethod(self):
print ‘调用子类办法’
c = Child() # 子类实例
c.myMethod() # 子类调用重写办法
实施以上代码输出作用如下：
调用子类办法
根底重载办法
下表列出了一些通用的功用，你能够在自己的类重写：
序号 办法, 描绘 & 简略的调用
1 init ( self [,args…] )
结构函数
简略的调用办法: obj = className(args)
2 del( self )
析构办法, 删去一个政策
简略的调用办法 : dell obj
3 repr( self )
转化为供解说器读取的形式
简略的调用办法 : repr(obj)
4 str( self )
用于将值转化为适于人阅览的形式
简略的调用办法 : str(obj)
5 cmp ( self, x )
政策比较
简略的调用办法 : cmp(obj, x)
运算符重载
Python相同支撑运算符重载，实例如下：
#!/usr/bin/python
class Vector:
def init(self, a, b):
self.a = a
self.b = b
def str(self):
return ‘Vector (%d, %d)’ % (self.a, self.b)
def add(self,other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)