python函数重写 python函数重构

python 重载和重写的区别

重载和重写，这是两个新概念，是两个令我们容易混淆的概念。方法重载(overloading method)

是在一个类里面，方法名字相同，而参数不同。返回类型呢？可以相同也可以不同。方法重写(overiding method)

子类不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。方法重载是让类以统一的方式处理不同类型数据的

一种手段。Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同个数和

类型的参数来决定具体使用哪个方法,

这就是多态性。方法重写：在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定

的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。

如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类重写方法的规则:

参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载.

返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载.访问修饰符的限制一定要大于被重写方法的访问修饰符

（publicprotecteddefaultprivate）重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽

泛的检查型异常．例如，父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception，只能抛出

IOException的子类异常，可以抛出非检查异常．重载的规则：必须具有不同的参数列表；可以有不同的返回类型，只要参数列表不同就可以

了；可以有不同的访问修饰符；可以抛出不同的异常；注意，Java的方法重载要求同名的方法必须有不同的参数表，仅有返回类型不同是不足以区分两

个重载的方法。重写方法只能存在于具有继承关系中,重写方法只能重写父类非私有的方法。下面分别举一个例子来说明方法重载：public class

TestOverLoad{ public static void main(String[] args) {Test test = new

Test(); test.print(null); } }class Test{ public void print(String

some){System.out.println("String version print"); } public void

print(Object some){ System.out.println("Object version print");

}}该程序输出的结果是String version print。

相关问答

Q1: 在Python中为什么重写__new__方法时，不需要声明它是静态方法？

这个不需要纠结，就和你写的 "if" 解释器如何判断它是关键字？一个意思。

这个是解释器自己的逻辑，同样__init__()方法和其他方法也定义也没有区别，为什么实例化先会调用它，也是一个意思。

通俗点讲，你带了几个朋友回家，你要给家里人介绍一下，其中有一个朋友是你们家亲戚，那是不是就可以不用介绍了？

Q2: python怎么重写集合方法

class Set(object):

def __init__(self,data=None):

if data == None:

self.__data = []

else:

if not hasattr(data,'__iter__'):

#提供的数据不可以迭代，实例化失败

raise Exception('必须提供可迭代的数据类型')

temp = []

for item in data:

#集合中的元素必须是可哈希

hash(item)

if not item in temp:

temp.append(item)

self.__data = temp

#析构函数

def __del__(self):

del self.__data

#添加元素，要求元素必须可哈希

def add(self, other):

hash(other)

if other not in self.__data:

self.__data.append(other)

else:

print('元素已存在，操作被忽略')

#删除元素

def remove(self,other):

if other in self.__data:

self.__data.remove(other)

print('删除成功')

else:

print('元素不存在，删除操作被忽略')

#随机弹出并返回一个元素

def pop(self):

if not self.__dat:

print('集合已空，弹出操作被忽略')

return

import random

item = random.choice(self.__data)

self.__data.remove(item)

return item

#运算符重载，集合差集运算

def __sub__(self, other):

if not isinstance(other,Set):

raise Exception('类型错误')

#空集合

result = Set()

#如果一个元素属于当前集合而不属于另一个集合，添加

for item in self.__data:

if item not in other.__data:

result.__data.append(item)

return result

#提供方法，集合差集运算，复用上面的代码

def difference(self,other):

return self - other

#｜运算符重载，集合并集运算

def __or__(self, other):

if not isinstance(other,Set):

raise Exception('类型错误')

result = Set(self.__data)

for item in other.__data:

if item not in result.__data:

result.__data.append(item)

return result

#提供方法，集合并集运算

def union(self,otherSet):

return self | otherSet

#运算符重载，集合交集运算

def __and__(self, other):

if not isinstance(other,Set):

raise Exception('类型错误')

result = Set()

for item in self.__data:

if item in other.__data:

result.__data.append(item)

return result

#^运算符重载，集合对称差集

def __xor__(self, other):

return (self-other) | (other-self)

#提供方法，集合对称差集运算

def symetric_difference(self,other):

return self ^ other

#==运算符重载，判断两个集合是否相等

def __eq__(self, other):

if not isinstance(other,Set):

raise Exception('类型错误')

if sorted(self.__data) == sorted(other.__data):

return True

return False

#运算符重载，集合包含关系

def __gt__(self, other):

if not isinstance(other,Set):

raise Exception('类型错误')

if self != other:

flag1 = True

for item in self.__data:

if item not in other.__data:

#当前集合中有的元素不属于另一个集合

flag1 = False

break

flag2 = True

for item in other.__data:

if item not in self.__data:

#另一集合中的元素不属于当前集合

flag2 = False

break

if not flag1 and flag2:

return True

return False

#=运算符重载，集合包含关系

def __ge__(self, other):

if not isinstance(other,Set):

raise Exception('类型错误')

return self == other or self other

#提供方法，判断当前集合是否为另一个集合的真子集

def issubset(self,other):

return selfother

#提供方法，判断当前集合是否为另一集合的超集

def issuperset(self,other):

return self other

#提供方法，清空集合所有元素

def clear(self):

while self.__data:

del self.__data[-1]

print('集合已清空')

#运算符重载，使得集合可迭代

def __iter__(self):

return iter(self.__data)

#运算符重载，支持in运算符

def __contains__(self, item):

return item in self.__data

#支持内置函数len()

def __len__(self):

return len(self.__data)

#直接查看该类对象时调用该函数

def __repr__(self):

return '{'+str(self.__data)[1:-1]+'}'

#使用print()函数输出该类对象时调用该函数

__str__ = __repr__

Q3: python的三大特征

第一点：封装

隐藏对象的属性和实现细节，仅对外提供公共访问方式，在Python中用双下线开头的方式将属性设置成私有的。

拥有三个好处：将变化隔离，便于使用，提高复用性，提高安全性。

第二点：继承

继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，父类又被称为基类或超类，新建的类称为派生类或子类。即一个派生类继承基类的字段和方法，继承也允许把一个派生类的对象作为一个基类对象对待。

第三点：多态

一种事物的多种体现形式，函数的重写其实就是多态的一种体现。Python中，多态指是父类的引用指向子类的对象。

实现多态的步骤：

1. 定义新的子类;

2. 重写对应的父类方法;

3. 使用子类的方法直接处理，不调用父类的方法;

多态的好处：

1. 增加了程序的灵活性;

2. 增加了程序的可扩展性。

Q4: python类方法重写

从父类继承中的方法，如果不满足程序的需求，就需要重写。

方法重写指的是在子类中自定义实现父类中的同名方法。