面向对象四大特征

OOP(Object-oriented Programming)

1.继承(Inheritance)

　　继承表达的是类之间的包含关系。使用继承思想可以缩短软件开发的时间，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的几率。继承关系可以用树形关系来表示。子类的实例都是父类的实例，但是不能说父类的实例都是子类的实例。

1）C++

　　有三种继承方式：public,protected,private

父类成员权限 public protected private 公有继承 public protected 不可见 保护继承 protected protected 不可见 私有继承 private private 不可见

　
　　当一个类从多个父类继承时，称之为“多重继承”。
　　代码实例：

#include <iostream>using namespace std;class A1{public:    int x;    A1(int a = 0) {        x = a;    }    void d(){        cout << "A1.x=" << x << endl;    }};class A2{public:     int x;     A2(int a = 0){        x = a;     }     void d(){        cout << "A2.x=" << x << endl;     }};class A3 : public A1,public A2{     int y;public:     A3(int a,int b,int c):A1(a),A2(b){        y = c;     }     void d(){        cout << "A3.y=" << y << endl;     }};int main(){    A3 c3(1,2,3);    c3.d();    return 0;}

输出结果：
A3.y = 3

2)Java

　　Java用extends关键字表示继承。当创建一个类时，如果没有明确地指出要继承的类， 就总是隐式地从根类Object进行继承。Java和C++的区别在于前者只允许单继承。
　　Tips:
　　(a) 如果子类出现与父类同名的成员变量或者静态方法，会发生隐藏，即子类成员变量屏蔽掉父类同名成员变量和静态方法。
　　 如果子类出现与父类同名的普通成员方法，则称为覆盖。使用super关键字可以在子类中访问父类同名的成员变量和成员方法。
　　(b)子类是不能够继承父类的构造器。如果父类的构造器都是带参的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则无需如此。
　　代码实例：

package demo;public class A {    public static void main(String[] args) {        new Son();    }}class Father{    private static String i = "father static";    static{        System.out.println(i);    }    private String j = fun();    public Father(){        System.out.println("father constructor");    }    private String fun(){        System.out.println("father non static");        return "";    }}class Son extends Father{    private static String i = "son static";    static{        System.out.println(i);    }    private String j = fun();    public Son(){        System.out.println("son constructor");    }    private String fun(){        System.out.println("son non static");        return "";    }}

输出结果：

2.封装(Encapsulation)

　　继承是为了扩展已经存在的代码，封装的目的则是为了使代码模块化，减少耦合，隐藏信息。他们的目的都是代码重用。

3.多态(Polymorphism)

1)C++

　　多态性是为了接口重用，程序在运行时才决定调用的函数，而不是像普通的函数那样在编译期间就确定了函数的调用地址。
　　多态通过虚函数实现，只有重写（或称覆盖）虚函数才算多态，重写普通的成员函数不算。现在来区分一下重载(overload)，重写(override)和隐藏(hide)。复杂的事情要简单化：
　　重写：基类函数声明有virtual关键字，派生类中的函数必须要与基类中的一模一样（函数名，参数列表，返回类型）
　　重载：范围是在一个域中，基类和派生类的关系谈不上重载。重载是函数名相同但是函数参数不同，跟返回值是否相同无关。
　　隐藏：只要基类和派生类函数名字相同，不符合重写的就是隐藏。
　　
　　代码实例：

#include<iostream>using namespace std;class A{public:    A(int x):a(x){        ++c;        a += 1;    }    virtual void s() const{        cout << c << '_' << a << endl;    }protected:    static int c;private:    int a;};class B:public A{public:    B(int x,int y):A(x),b(y){        ++c;        b += 10;    }    virtual void s() const{        cout << c << '_' << b << endl;    }private:    int b;};int A::c = 0;int main(){     B d(1,2);     A* a = &d;     a->s();     return 0;}

输出结果：
2_12
　　

2)Java

　　Java实现多态三个条件：继承，重写，向上转型。有两种形式可以实现多态：继承和接口。

(1)基于继承的多态：Java中没有virtual关键字，不需要虚函数实现多态。
(2)基于接口的多态：指向接口的引用必须是指定实现了该接口的一个类的实例，运行时，根据对象引用的类型来执行相应的方法。

　　经典代码：

package demo;class A {    public String show(D obj) {        return ("A and D");    }    public String show(A obj) {        return ("A and A");    } }class B extends A{    public String show(B obj){        return ("B and B");    }    public String show(A obj){        return ("B and A");    } }class C extends B{}class D extends B{}public class Test {    public static void main(String[] args) {        A a1 = new A();        A a2 = new B();        B b = new B();        C c = new C();        D d = new D();        System.out.println("1--" + a1.show(b));        System.out.println("2--" + a1.show(c));        System.out.println("3--" + a1.show(d));        System.out.println("4--" + a2.show(b));        System.out.println("5--" + a2.show(c));        System.out.println("6--" + a2.show(d));        System.out.println("7--" + b.show(b));        System.out.println("8--" + b.show(c));        System.out.println("9--" + b.show(d));          }}

输出结果：

结论：当超类对象引用变量引用子类对象时，由被引用对象的类型而不是引用对象的类型决定调用谁的成员方法。但是这个调用方法必须在超类中被定义。在继承链中对象方法的调用存在一个优先级：
this.show(O)——>super.show(O)——>this.show((super)O)— >super.show((super)O)

4.抽象(Abstraction)

1)抽象类

　　数据抽象是实现多态的一种机制。
Tips:
(1)抽象类不能被实例化，抽象方法必须由子类重写
(2)子类的抽象方法不能与父类同名
(3)abstract不能与private,static,final或者native同时出现。因为：private对子类是不可见的！static方法必须被实现！final是不能被子类对象重写的！native方法根本就不是用Java实现的！

2)接口

　　接口比抽象类更加抽象，它用来建立类与类之间的协议，它所提供的只是一种形式，而没有具体的实现。接口弥补了抽象了不能多重继承的缺陷。
Tips:
(1)接口中不存在实现的方法。
(2)实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。
(3)不能用new实例化一个接口，但是可以声明一个接口变量，该变量必须引用一个实现该接口的类的对象。