读前声明：本文主要参考了Real Python中的内容，提炼了一些主要的内容，如果英文还不错的想详细了解的话建议直接进入该网站阅读。

提到类的设计，我们不得不提及面向对象(OOP)，它是一种编程思想，极大的提高了开发的效率，降低了维护的难度与面向对象相对应的编程模式是面向过程，与面向过程编程相比，它有着易维护，高可复用性和易扩展的优点，而这些优点与面向对象的三大特性是紧密对应的：由于封装的特性，它更加易于维护

由于继承的特性，它更加易于扩展，复用

由于多态的特性，它更加易于扩展，复用

PS:当然天下没有免费的午餐，由于面向对象中加入了类，而类的实例化需要分配内存，增加了时空复杂度，所以性能上会低于面向过程。

接下来，我们针对类的组成部分一一分析python类与Java类设计上的不同之处，每种不同之处都有代码的展示：

0.Java类与python类的整体一瞥：

java:

public class Car {

private String color;

private String model;

private int year;

public Car(String color, String model, int year) {

this.color = color;

this.model = model;

this.year = year;

}

public String getColor() {

return color;

}

public String getModel() {

return model;

}

public int getYear() {

return year;

}

}

python:

class Car:

def __init__(self, color, model, year):

self.color = color

self.model = model

self.year = year

1.类属性和成员方法的访问控制

Java：private/protected/public三种修饰符依次限定成员的访问控制权限，权限由低到高。

Python：相较于Java严格的权限控制，python只有public/non-public两种限定,并且python没有明显的修饰符，以双下划线(‘__’)开头的属性为non-public，而其他则为public。

Ps:因此对于私有属性，Java中通常通过getters和setters函数来进行访问,而python中有对应getter和setter专门的装饰语法，代码如下：

python:

class Car:

def __init__(self, color, model, year):

self.color = color

self.model = model

self.year = year

self._voltage = 12

@property

def voltage(self):

return self._voltage

@voltage.setter

def voltage(self, volts):

print("Warning: this can cause problems!")

self._voltage = volts

@voltage.deleter

def voltage(self):

print("Warning: the radio will stop working!")

del self._voltage

2.类定义与编译单元(文件)的关系

Java中具有public class和class两种不同的形式，而python则没有关于类的限定，这个不同之处体现在工程上就是，Java中public类必须定义在同名文件中，因此一个文件只能定义一个public类。而python则没有这种限制，它可以在一个模块中定义多个类。

3.继承

Python可以多继承，而Java则不允许多继承，如果一个类涉及到与多个其他类存在继承关系时，通常会设计interface来替代class，关于这种机制的产生就不得不引入下面的多态。

java:

public class Vehicle {

private String color;

private String model;

public Vehicle(String color, String model) {

this.color = color;

this.model = model;

}

public String getColor() {

return color;

}

public String getModel() {

return model;

}

}

public interface Device {

int getVoltage();

}

public class Car extends Vehicle implements Device {

private int voltage;

private int year;

public Car(String color, String model, int year) {

super(color, model);

this.year = year;

this.voltage = 12;

}

@Override

public int getVoltage() {

return voltage;

}

public int getYear() {

return year;

}

}

python：

class Vehicle:

def __init__(self, color, model):

self.color = color

self.model = model

class Device:

def __init__(self):

self._voltage = 12

class Car(Vehicle, Device):

def __init__(self, color, model, year):

Vehicle.__init__(self, color, model)

Device.__init__(self)

self.year = year

4.多态

我们学习过多继承都知道“钻石问题”会导致歧义，因此Java利用interface这种机制来避免歧义，也就是同样的方法在不同的类中有不同的实现，而python则采用“duck type”形式来达到相似于接口的目的。代码如下：

python：

>>> def charge(device):

... if hasattr(device, '_voltage'):

... print(f"Charging a {device._voltage} volt device")

... else:

... print(f"I can't charge a {device.__class__.__name__}")

...

>>> class Phone(Device):

... pass

...

>>> class Rhino:

... pass

...

>>> my_car = Car("yellow", "Beetle", "1966")

>>> my_phone = Phone()

>>> my_rhino = Rhino()

>>> charge(my_car)

Charging a 12 volt device

>>> charge(my_phone)

Charging a 12 volt device

>>> charge(my_rhino)

I can't charge a Rhino

总结

通过如上对Java和python类的探讨，从面向对象的封装，继承和多态三种特性着手，分析了两种主流编程语言的异同。发现每种语言的设计都拥有自己的独特规则，但都大同小异，他们都遵从了面向对象的思想。有了这种从本质着手的思维，再次学习新的东西时，就会有大局观，不会纠结小细节，很容易上手。