作为一个学python的新晋小白,简单表达一下自己的想法。之前对Java略懂一二,因此基于两者的异同来阐述自己的观点。如有不妥之处还望指正。
1.python类和java类的使用一览
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
从代码行上来看,显然还是python的代码行较少,显得较为简洁,同时,这个也可以被称为Python的优点之一。而且从中也可以明显看出python类中的变量可以直接使用,但是java中使用变量需要先声明再使用。
2.Python的继承
python和java在继承方面最大的区别就是python子类可以继承多个父类,但是java子类只能继承一个父类,如果一个子类需要多继承的话一般设计成interface接口的方式来实现。比如创造一个child类,类型father和mother。在Python中,father类和mother类可以都设计成child的父类,但在java中可以设计成father父类和mother接口,继承需要extends关键字实现,接口需要implements关键字实现
python实现
class child(father,mother):
java实现
class child extends father implements mother
3. Python多态
java中的多态跟Python中的多态是有区别的。java中的多态定义:
多态存在的三个必要条件
一、要有继承;
二、要有重写;
三、父类引用指向子类对象。
java多态演示
public class Test {
public static void main(String[] args) {
show(new Cat()); // 以 Cat 对象调用 show 方法
show(new Dog()); // 以 Dog 对象调用 show 方法
Animal a = new Cat(); // 向上转型
a.eat(); // 调用的是 Cat 的 eat
Cat c = (Cat)a; // 向下转型
c.work(); // 调用的是 Cat 的 work
}
public static void show(Animal a) {
a.eat();
// 类型判断
if (a instanceof Cat) { // 猫做的事情
Cat c = (Cat)a;
c.work();
} else if (a instanceof Dog) { // 狗做的事情
Dog c = (Dog)a;
c.work();
}
}
}
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void work() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void work() {
System.out.println("看家");
}
}
执行以上程序,输出结果为:
吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠
Python多态
类具有继承关系,并且子类类型可以向上转型看做父类类型,如果我们从 Person 派生出 Student和Teacher ,并都写了一个 whoAmI() 方法:
class Person(object):
def __init__(self, name, gender):
self.name = name
self.gender = gender
def whoAmI(self):
return 'I am a Person, my name is %s' % self.name
class Student(Person):
def __init__(self, name, gender, score):
super(Student, self).__init__(name, gender)
self.score = score
def whoAmI(self):
return 'I am a Student, my name is %s' % self.name
class Teacher(Person):
def __init__(self, name, gender, course):
super(Teacher, self).__init__(name, gender)
self.course = course
def whoAmI(self):
return 'I am a Teacher, my name is %s' % self.name
在一个函数中,如果我们接收一个变量 x,则无论该 x 是 Person、Student还是 Teacher,都可以正确打印出结果:
def who_am_i(x):
print x.whoAmI()
p = Person('Tim', 'Male')
s = Student('Bob', 'Male', 88)
t = Teacher('Alice', 'Female', 'English')
who_am_i(p)
who_am_i(s)
who_am_i(t)
运行结果:
I am a Person, my name is Tim
I am a Student, my name is Bob
I am a Teacher, my name is Alice
这种行为称为多态。也就是说,方法调用将作用在 x 的实际类型上。s 是Student类型,它实际上拥有自己的 whoAmI()方法以及从 Person继承的 whoAmI方法,但调用 s.whoAmI()总是先查找它自身的定义,如果没有定义,则顺着继承链向上查找,直到在某个父类中找到为止。
由于Python是动态语言,所以,传递给函数 who_am_i(x)的参数 x 不一定是 Person 或 Person 的子类型。任何数据类型的实例都可以,只要它有一个whoAmI()的方法即可:
class Book(object):
def whoAmI(self):
return 'I am a book'
这是动态语言和静态语言(例如Java)最大的差别之一。动态语言调用实例方法,不检查类型,只要方法存在,参数正确,就可以调用。
文章部分转载自https://blog.csdn.net/u012762054/article/details/81980750https://www.zhihu.com/question/27194944/answer/933997424