java的类继承(与c++对比)

1. interface的引入

  使用interface来定义某一类通用操作,而又不强制规定其实现,对于Java的流行真是太重要了。  

  以JDBC举例。在Java之前,C++与数据库建立连接,常用的一个技术是OLEDB。这个技术我刚才搜索了一下,已经找不到太有效的内容了。我只记得开发比较复杂,如果我的应用要使用不同的数据库,就得为不同的数据库编写适配的代码。这是一件很头疼的事情。

 

  JDBC是怎么做的呢?java 提供了一个名为 java sql 的包,大家可以去看一下源码,这个包里的Statement, ResultSet 等等其实都是 interface。这些 interface 就定义了个标准,每个数据库厂商要支持Java连接,就得遵守这个标准。就是说,Oracle,要支持Java连接,就得提供自己的JDBC库,mysql要支持Java连接,也不例外,也得提供自己的JDBC库。这些由厂商提供的库,都严格遵守JDBC的标准。那么,我们在写数据库应用的时候,就使用这些标准的接口进行编程,当需要换一个数据库的时候,只需要换成这个数据库的JDBC就行了。我们看具体的例子:

public class MysqlExample {
    public static void main(String[] args) throws Exception {
        Connection conn = null;
        String sql;
        String url = "jdbc:mysql://localhost:3306/javademo?" + "user=root&password=root&useUnicode=true&characterEncoding=UTF8";
 
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn = DriverManager.getConnection(url);
            Statement stmt = conn.createStatement();
            sql = "create table student(NO char(20),name varchar(20),primary key(NO))";
            int result = stmt.executeUpdate(sql);
            if (result != -1) {
                sql = "select * from student";
                ResultSet rs = stmt.executeQuery(sql);                
                while (rs.next()) {
                    System.out.println(rs.getString(1) + "\t" + rs.getString(2));
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conn.close();
        }
     }
 }

上面这个程序中除了创建连接的URL,其他的地方都是遵守JDBC标准,而与具体的数据库没有关系了。这样一来,我们就可以为不同的数据库连接只写一份代码了。有了JDBC标准,数据库的具体实现与应用程序就真正做到了解耦。而JDBC标准,正是由 java.sql 这个package 里定义的各个 interface 来具体体现的。

 

 

2. 多态

其实在Java之前,大规模流行的面向对象编程语言,大概只有C++了。Java中有多种针对C++的改进,多态就是其中之一。对比两段代码。

 

#include<iostream>
using namespace std;

class Shape {
public:
//  virtual void draw() {
    void draw() {
        cout << "draw Shape" << endl;
    }   
};

class Circle : public Shape {
public:
//  virtual void draw() {
    void draw() {
        cout << "draw Circle" << endl;
    }   
};

int main() {
    Shape * s = new Circle();
    s->draw();
}

 

 

 

 

这段C++代码的输出是"draw Shape"。要使得它输出"draw Circle",就要把draw函数变成virtual,如注释中所写。这个功能,看上去使得C++的类机制更加灵活,因为静态绑定和运行时动态绑定两种机制都支持,而我们知道静态绑定,运行效率更高,C++程序可以自由地根据情况来使用两种绑定机制。

 

Java抛弃了静态绑定。Java认为,既然实现了继承,并且在子类中又提供了实现,那就应该是覆写。在Java中实现同样的代码,看看效果。

public class Main {
    public static void main(String args[]) throws IOException {
        Shape s = new Circle();
        s.draw();
    }   
}

class Shape {
    public void draw() {
        System.out.println("draw Shape");
    }   
}

class Circle extends Shape {
    public void draw() {
        System.out.println("draw Circle");
    }   
}

嗯,这次输出的是draw Circle。用C++的术语来说,Java中所有的成员方法都自动是virtual的。所有的子类方法会自动覆写父类的同名方法。

 

3. 抽象类和抽象方法

这一点,其实没什么特别的,C++中,如果一个类中定义了纯虚函数(没有实现,只有声明的虚函数),那这个类也是不能被实例化的。Java的类中,如果定义了一个抽象方法(以abstract修饰,不提供方法实现),那这个类就是抽象类,也不能实例化的。这一点上,两者是对应的。例如:

 

public class Main {
    public static void main(String args[]) throws IOException {
        Shape s = new Circle();
        s.draw();
    }   
}

abstract class Shape {
    public void draw() {
        System.out.println("draw Shape");
    }   

    public abstract double area();
}

class Circle extends Shape {
    public void draw() {
        System.out.println("draw Circle");
    }   

    public double area() {
        return 3.14;
    }   
}

 

1. Shape类前面的abstract不加,会报什么错?

如果Shape类不加abstract,则无法拥有abstract方法.

2. shape中的area的定义前不加abstract会怎么样? 

如果area方法不加abstract,则必须提供该方法的实现.

3. 如果Circle中没有实现area会怎么样?

如果Circle类没有实现area方法,则Circle必须指定为abstract,因为从基类得到abstract方法的类要么实现该方法,要么声明为abstract类.

 

 

4. 拒绝操作符重载

我们提到了,Java中是拒绝操作符重载的。理由是,如果实现了这个功能,用户就会定义出奇奇怪怪不可读的操作符。这一点,我是赞同的,看看scala中的flatMap这么清晰的一个函数,变成Haskell中的(>>=),可读性确实是下降了。

 

但有些地方,操作符重载也确实能提供更清晰的语法,比如BigInteger。这个类是Java中的高精度整型类。我们看一下,它的例子。

public class Main {
    public static void main(String args[]) {
        BigInteger one = BigInteger.valueOf(1);
        BigInteger two = BigInteger.valueOf(2);
        BigInteger three = one.add(two);
        System.out.println(three);
    }   
}

可以看到,Java中只能用 add 来表示两个大整数的相加。如果支持了操作符重载呢?我们用C++举个例子。

class BigInteger {
public:
    int value;

    BigInteger(int v) : value(v) {}

    BigInteger operator + (BigInteger & that) {
        return BigInteger(this->value + that.value);
    }   
};

int main() {
    BigInteger one(1);
    BigInteger two(2);
    BigInteger three = one + two;
    cout << three.value << endl;
}

在这个例子中,使用+比使用add方法更简洁清晰。但是,允许了操作符重载,开发者为了图方便,就有可能写出这种东西来:

class BigInteger {
public:
    int value;

    BigInteger(int v) : value(v) {}

    int operator >>= (int v) {
        return this->value + v;
    }   
};

int main() {
    BigInteger one(1);
    int a = one >>= 3;
    cout << a << endl;
}

这就失去了操作符重载原有的简洁性,而使代码变得不可读了。在这一点上,做得比较好是Python,它限制了可以重载的操作符的类型。

class BigInteger(object):
    def __init__(self, v): 
        self.value = v 

    def __add__(self, that):
        return BigInteger(self.value + that.value)

一个定义了 __add__ 方法的类,是可以直接使用 + 操作符的。但你不能定义乱七八糟意义不明的操作符。Python中是受限的操作符重载。这是我认为的最好的机制。退而求其次,应该是Java的做法,而不是C++的做法。

 

转载于:https://www.cnblogs.com/msymm/p/9395924.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值