android编程虚方法,Android NDK开发之旅22--C++--面向对象

前言

C++是面向对象的编程语言，因此有类的概念。下面介绍面向对象中一些比较重要的知识点。

继承

继承主要是提高代码的重用性。

下面是一个继承的例子：class Human

{

public:

Human(char* name, int age){

this->name = name;

this->age = age;

}

void say(){

cout <

}

private:

char* name;

int age;

};

class Woman :public Human{

public:

Woman(char* name, int age, float weight)

//指定调用父类的哪一个构造函数、初始化属性对象

:Human(name, age), m(name, age)

{

this->weight = weight;

}

void shopping(){

cout <

}

void say(){

cout <

}

private:

float weight;

Human m;

};

void main(){

Woman w("haha", 20, 90.0);

system("pause");

}

需要注意的地方有：通过:public来继承Human。

通过在自身构造的时候给父类构造函数传参。(同时给属性对象赋值)因为子类构造的时候，会先构造父类。

构造与析构的调用顺序：构造的时候先调用父类的构造函数，然后调用子类的构造函数。析构的时候相反。总结就是，先构造，先释放。

上面的继承中，子类覆盖了父类的say方法，但是这并不是多态(没有virtual关键字)。只是父类的say方法被隐藏了。子类可以对象调用父类的方法。

例如，我们可以通过下面的方式去指定调用父类还是子类的方法：void work(Human &m){

m.say();

}

void main(){

Woman w("haha", 20, 90.0);

//调用子类的say方法(这两种实质是一样)

w.say();

w.Woman::say();

//调用父类的say方法(显示指明，或者用子类去初始化父类的时候)

w.Human::say();

Human h = w;

h.say();

work(w);

system("pause");

}

例如Java中就无法使用被覆盖的父类方法了，但是通过JNI的方式可以访问到。

继承的访问修饰符

主要的规律就是，两个之中的最小值。基类中      继承方式             子类中

public     ＆ public继承        => public

public     ＆ protected继承     => protected

public     ＆ private继承       => private

protected  ＆ public继承        => protected

protected  ＆ protected继承     => protected

protected  ＆ private继承       => private

private    ＆ public继承        => 子类无权访问

private    ＆ protected继承     => 子类无权访问

private    ＆ private继承       => 子类无权访问

补充说明：public关键字能够在类本身、子类、类以外的地方使用。

protect关键字只能够在 类本身、子类 中使用。

private关键字只能够在 类本身 中使用。

多继承

多个父类通过,隔开：class Person{

};

//公民

class Citizen{

};

//学生，既是人，又是公民

class Student : public Person, public Citizen{

};

多继承的二义性问题class A{

public:

char* name;

};

class A1 : public A{

};

class A2 : public A{

};

class B : public A1, public A2{

};

void main(){

B b;

//这句话编译不通过，因为存在二义性

b.name = "3";

//B中有两个name的副本，我们可以指定使用哪个父类的name

b.A1::name = "1";

b.A2::name = "2";

system("pause");

}

继承的二义性.png

问题：B中有两个name的副本。但是我们一般情况下只需要一份。

解决办法：虚继承，不同路径继承来的同名成员只有一份拷贝，解决不明确的问题：

如果某个类B的两个父类(A1、A2)都继承于同一父类(A)，那么这两个父类(A1、A2)可以通过在继承的时候加上virtual关键字来解决二义性问题：class A{

public:

char* name;

};

class A1 : virtual public A{

};

class A2 : virtual public A{

};

class B : public A1, public A2{

};

void main(){

B b;

//这时候name的副本只有一份了

b.name = "3";

system("pause");

}

多态

多态的作用：程序的扩展性

继承的作用：程序的重用性

多态分类：动态多态：程序运行过程中，觉得哪一个函数被调用(重写)。

静态多态：重载。

这里主要讨论动态多态，动态多态的条件：继承

父类的引用或者指针指向子类的对象

函数的重写(需要增加virtual关键，否则的话就是覆盖)

简单的例子，注意添加virtual关键字(虚函数)：class Human

{

public:

virtual void say(){

cout <

}

};

class Woman :public Human{

public:

virtual void say(){

cout <

}

};

class Man :public Human{

public:

virtual void say(){

cout <

}

};

void say(Human &h){

h.say();

}

void main(){

Woman w;

Man m;

say(w);

say(m);

system("pause");

}

纯虚函数

纯虚函数(抽象类)当一个类具有一个纯虚函数，这个类就是抽象类

抽象类不能实例化对象

子类继承抽象类，必须要实现纯虚函数，如果没有，子类也是抽象类

抽象类(逻辑上就是Java中的接口)的作用：为了继承约束(新增加的类必须实现父类，提高代码重用性，保证系统的条理性、封闭性)，根本不知道未来的实现(例如JDBC中的驱动就是接口)class Shape{

public:

//纯虚函数

virtual void sayArea() = 0;

};

//圆

class Circle : public Shape{

public:

Circle(int r){

this->r = r;

}

void sayArea(){

cout <

}

private:

int r;

};

void main(){

//Shape s;抽象类不能创建对象

Circle c(10);

system("pause");

}

C++中的接口是按照逻辑上区分出来的，不像Java中有专门的interface关键字。例如在C++中我们可以把只有纯虚函数的类看做一个接口：class Drawble{

virtual void draw();

};