目录
继承
package com.hoko;
public class Animal {
private String name;
private int id;
public Animal(String myName,int myid) {
name = myName;
id = myid;
}
public void eat() {
System.out.println("animal : eat");
System.out.println(name+"正在吃");
}
public void sleep() {
System.out.println(name+"正在睡");
}
public void introduction() {
System.out.println("大家好！我是" + id + "号" + name + ".");
}
}
class Penguin extends Animal {
public Penguin (String myName,int myid) {
super(myName, myid);
}
}
class Mouse extends Animal {
public Mouse (String myName,int myid) {
super(myName, myid);
}
}
class Animal:
def __init__(self, myName, myid):
self.__name = myName
self.__id = myid
def eat(self):
print(self.__name + "正在吃")
def sleep(self):
print(self.__name + "正在睡")
def introduction(self):
print("大家好！我是" + self.__id + "号" + self.__name + ".")
class Penguin(Animal):
def __init__(self, myName, myid):
super(Penguin, self).__init__(myName, myid)
class Mouse(Animal):
def __init__(self, myName, myid):
super(Mouse, self).__init__(myName, myid)
extends关键字
public class Animal {
private String name;
private int id;
public Animal(String myName, String myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}
public class Penguin extends Animal{
}class Animal:
def __init__(self, myName, myid):
# 初始化属性值
pass
def eat(self):
# 吃东西方法的具体实现
pass
def sleep(self):
# 睡觉方法的具体实现
pass
class Penguin(Animal):
pass
implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。
public interface A {
public void eat();
public void sleep();
}
public interface B {
public void show();
}
public class C implements A,B {
}from abc import ABCMeta, abstractmethod
class A(metaclass=ABCMeta):
@abstractmethod
def eat(self):
pass
@abstractmethod
def sleep(self):
pass
class B(metaclass=ABCMeta):
@abstractmethod
def show(self):
pass
class C(A, B):
def eat(self):
print('吃')
def show(self):
print('表演')
def sleep(self):
print('睡')
C().sleep()
super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
package com.hoko;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class Animal {
void eat() {
System.out.println("animal : eat");
}
}
class Dog extends Animal {
void eat() {
System.out.println("dog : eat");
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
class Animal:
def eat(self):
print("animal : eat")
class Dog(Animal):
def eat(self):
print("dog : eat")
def eatTest(self):
self.eat()
super(Dog, self).eat()
a = Animal()
a.eat()
d = Dog()
d.eatTest()
构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
package com.hoko;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class SuperClass {
private int n;
SuperClass(){
System.out.println("SuperClass()");
}
SuperClass(int n) {
System.out.println("SuperClass(int n)");
this.n = n;
}
}
// SubClass 类继承
class SubClass extends SuperClass{
private int n;
SubClass(){ // 自动调用父类的无参数构造器
System.out.println("SubClass");
}
public SubClass(int n){
super(300); // 调用父类中带有参数的构造器
System.out.println("SubClass(int n):"+n);
this.n = n;
}
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
private int n;
SubClass2(){
super(300); // 调用父类中带有参数的构造器
System.out.println("SubClass2");
}
public SubClass2(int n){ // 自动调用父类的无参数构造器
System.out.println("SubClass2(int n):"+n);
this.n = n;
}
}
public class Test{
public static void main (String args[]){
System.out.println("------SubClass 类继承------");
SubClass sc1 = new SubClass();
SubClass sc2 = new SubClass(100);
System.out.println("------SubClass2 类继承------");
SubClass2 sc3 = new SubClass2();
SubClass2 sc4 = new SubClass2(200);
}
}class SuperClass:
def __init__(self, *args):
if len(args) == 0:
print("SuperClass()")
elif len(args) == 1:
print("SuperClass(int n)")
self.__n = args
class SubClass(SuperClass):
def __init__(self, *args):
if len(args) == 0:
super(SubClass, self).__init__()
print("SubClass")
elif len(args) == 1:
super(SubClass, self).__init__(300)
print("SubClass(int n):" + str(args[0]))
self.__n = args
class SubClass2(SuperClass):
def __init__(self, *args):
if len(args) == 0:
super(SubClass2, self).__init__(300)
print("SubClass2")
elif len(args) == 1:
super(SubClass2, self).__init__()
print("SubClass2(int n):" + str(args[0]))
self.__n = args
print("------SubClass 类继承------")
sc1 = SubClass()
sc2 = SubClass(100)
print("------SubClass2 类继承------")
sc3 = SubClass2()
sc4 = SubClass2(200)
重写(Override)与重载(Overload)
重写(Override)
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。
在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：
package com.hoko;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
}
public class Test{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
}
}class Animal:
def move(self):
print("动物可以移动")
class Dog(Animal):
def move(self):
print("狗可以跑和走")
a = Animal()
b = Dog()
a.move()
b.move()
python和java继承的不同
静态语言 vs 动态语言
对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。
对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了：
class Timer(object):
def run(self):
print('Start...')
这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
Python的“file-like object“就是一种鸭子类型。对真正的文件对象，它有一个read()方法，返回其内容。但是，许多对象，只要有read()方法，都被视为“file-like object“。许多函数接收的参数就是“file-like object“，你不一定要传入真正的文件对象，完全可以传入任何实现了read()方法的对象。
方法的重写规则
-
参数列表与被重写方法的参数列表必须完全相同。
-
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
-
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
-
父类的成员方法只能被它的子类重写。
-
声明为 final 的方法不能被重写。
-
声明为 static 的方法不能被重写，但是能够被再次声明。
-
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
-
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
-
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
-
构造方法不能被重写。
-
如果不能继承一个类，则不能重写该类的方法。
Super 关键字的使用
当需要在子类中调用父类的被重写方法时，要使用 super 关键字。
package com.hoko;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
super.move(); // 应用super类的方法
System.out.println("狗可以跑和走");
}
}
public class Test{
public static void main(String args[]){
Animal b = new Dog(); // Dog 对象
b.move(); //执行 Dog类的方法
}
}
class Animal:
def move(self):
print("动物可以移动")
class Dog(Animal):
def move(self):
super(Dog, self).move()
print("狗可以跑和走")
b = Dog()
b.move()
重载(Overload)
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则:
- 被重载的方法必须改变参数列表(参数个数或类型不一样)；
- 被重载的方法可以改变返回类型；
- 被重载的方法可以改变访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
public class Overloading {
public int test(){
System.out.println("test1");
return 1;
}
public void test(int a){
System.out.println("test2");
}
//以下两个参数类型顺序不同
public String test(int a,String s){
System.out.println("test3");
return "returntest3";
}
public String test(String s,int a){
System.out.println("test4");
return "returntest4";
}
public static void main(String[] args){
Overloading o = new Overloading();
System.out.println(o.test());
o.test(1);
System.out.println(o.test(1,"test3"));
System.out.println(o.test("test4",1));
}
}
from functools import singledispatch
@singledispatch
def test(obj):
print("test1")
return 1
@test.register(int)
def function_int(a:int):
print("test2")
@test.register(list)
def function_int(obj):
print("test")
return "returntest"
if __name__ == "__main__":
print(test(object))
test(1)
print(test([1,'test3']))
print(test(["test4",]))
重写与重载之间的区别
| 区别点 | 重载方法 | 重写方法 |
|---|---|---|
| 参数列表 | 必须修改 | 一定不能修改 |
| 返回类型 | 可以修改 | 一定不能修改 |
| 异常 | 可以修改 | 可以减少或删除，一定不能抛出新的或者更广的异常 |
| 访问 | 可以修改 | 一定不能做更严格的限制（可以降低限制） |
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
- (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
- (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
- (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
多态
多态的优点
- 1. 消除类型之间的耦合关系
- 2. 可替换性
- 3. 可扩充性
- 4. 接口性
- 5. 灵活性
- 6. 简化性
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
以下是一个多态实例的演示，详细说明请看注释：
package com.hoko;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
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("看家");
}
}
from abc import abstractmethod, ABCMeta
class Animal(metaclass=ABCMeta):
@abstractmethod
def eat(self):
pass
class Cat(Animal):
def eat(self):
print("吃鱼")
def work(self):
print("抓老鼠")
class Dog(Animal):
def eat(self):
print("吃骨头")
def work(self):
print("看家")
if __name__ == '__main__':
def show(a):
a.eat()
if isinstance(a, Cat):
c = a
c.work()
elif isinstance(a, Dog):
c = a
c.work()
show(Cat())
show(Dog())
a = Cat()
a.eat()
c = a
c.work()
重写
我们将介绍在 Java 中，当设计类时，被重写的方法的行为怎样影响多态性。
我们已经讨论了方法的重写，也就是子类能够重写父类的方法。
当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
要想调用父类中被重写的方法，则必须使用关键字 super。
package com.hoko;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
class Employee {
private String name;
private String address;
private int number;
public Employee(String name, String address, int number) {
System.out.println("Employee 构造函数");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck() {
System.out.println("邮寄支票给： " + this.name
+ " " + this.address);
}
public String toString() {
return name + " " + address + " " + number;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public void setAddress(String newAddress) {
address = newAddress;
}
public int getNumber() {
return number;
}
}
class Salary extends Employee
{
private double salary; // 全年工资
public Salary(String name, String address, int number, double salary) {
super(name, address, number);
setSalary(salary);
}
public void mailCheck() {
System.out.println("Salary 类的 mailCheck 方法 ");
System.out.println("邮寄支票给：" + getName()
+ " ，工资为：" + salary);
}
public double getSalary() {
return salary;
}
public void setSalary(double newSalary) {
if(newSalary >= 0.0) {
salary = newSalary;
}
}
public double computePay() {
System.out.println("计算工资，付给：" + getName());
return salary/52;
}
}
public class Test {
public static void main(String [] args) {
Salary s = new Salary("员工 A", "北京", 3, 3600.00);
Employee e = new Salary("员工 B", "上海", 2, 2400.00);
System.out.println("使用 Salary 的引用调用 mailCheck -- ");
s.mailCheck();
System.out.println("\n使用 Employee 的引用调用 mailCheck--");
e.mailCheck();
}
}class Employee:
def __init__(self, name, address, number):
print("Employee 构造函数")
self.__name = name
self.__address = address
self.__number = number
def mailCheck(self):
print("邮寄支票给： " + self.__name
+ " " + self.__address)
def toString(self):
return self.__name + " " + self.__address + " " + self.__number
def getName(self):
return self.__name
def getAddress(self):
return self.__address
def setAddress(self, newAddress):
address = newAddress
def getNumber(self):
return self.__number
class Salary(Employee):
def __init__(self, name, address, number, salary):
self.__salary = 0.0
super(Salary, self).__init__(name, address, number)
self.setSalary(salary)
def mailCheck(self):
print("Salary 类的 mailCheck 方法 ")
print("邮寄支票给：" + self.getName()
+ " ，工资为：" + str(self.__salary))
def getSalary(self):
return self.__salary
def setSalary(self, newSalary):
if newSalary >= 0.0:
self.__salary = newSalary
def computePay(self):
print("计算工资，付给：" + self.getName())
return self.__salary / 52
if __name__ == '__main__':
s = Salary("员工 A", "北京", 3, 3600.00)
e = Salary("员工 B", "上海", 2, 2400.00)
print("使用 Salary 的引用调用 mailCheck -- ")
s.mailCheck()
print("\n使用 Employee 的引用调用 mailCheck--")
e.mailCheck()
例子解析
-
实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。
-
当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。
-
e 是 Employee 的引用，但引用 e 最终运行的是 Salary 类的 mailCheck() 方法。
-
在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。
以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。
Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。
多态的实现方式
方式一：重写：
这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。
方式二：接口
-
1. 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
-
2. java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
