面向对象

1 java

java本身就是一门面向对象的语言

1.1 创建

class 类名 [extends 父类] [implements 接口]{

    public/default/protected/private [static] [final] XXX 变量;

    public/default/protected/private [static] [final] XXX  方法(参数列表){

        //实现

        return XXX;

    }

}

类名 变量名=new 类名([参数]);

1.1  static修饰的变量 只会实例化一次

修饰的方法 可以用类名直接调用 且静态方法不能调用非静态变量和方法

修饰的内部类可以不实例化外部类，直接实例化内部类，而且非static内部类和匿名内部类会保持外部类的一个引用 会有内存泄露的隐患

1.2 final修饰的变量不可更改

修饰的方法 子类不可重写

修饰的类 不可被继承

1.3 构造方法

每个类如果不实现构造方法，默认都会有一个无参数的构造方法

如果实现了带参数的构造方法，需要用到无参构造方法时，则必须显式的实现

private修饰的构造方法，不能直接通过new实例化

1.4 this  代指自己的引用

1.5 super 代指父类对象  一定放在方法的第一行

this super都不能与static共用

1.6 abstract

abstract修饰的类必须被继承，不能直接实例化

abstract修饰的方法 必须被子类继承并实现  如果没有实现 则当前类也变为abstract类

1.7 interface

接口主要的作用是统一方法，最重要的是包容未来的能力

接口可以继承多个别的接口，用以实现类似多继承的作用

接口中的方法默认为public abstractXXX();    变量默认为public static final XXX;

1.8 enum   java也支持枚举

1.9 代码块

1.9.1 静态代码块

优于构造函数，普通代码块执行 且只执行一次

1.9.2 普通代码块

优于构造函数执行   实例化一次执行一次

1.10 重载与重写

2 c++

作为c的超集 c++的面向对象部分还是带着c的一些特性的

2.1

类与结构体在C++中只有两点区别，除此这外无任何区别。　　

（1）class中默认的成员访问权限是private的，而struct中则是public的。　　

（2）从class继承默认是private继承，而从struct继承默认是public继承。

2.2

class A{

private:

int a;

char *b;

protected:

public:

A(A &a){     //复制构造函数

    b=new char[strlen(a.b)+1];

    strcpy(b,a.b);

}

~A(){    //析构     如果在继承关系中 析构函数应为虚析构函数 这样可以调用子类的析构

    delete[] b;

}

A(){};    //构造

A(void):a(3){};    //初始化变量    如果有多个变量初始化 则初始化顺序为定义变量的顺序

inline const int getA() const;   //定义

static void getB(){    //静态函数调用 直接A::getB()即可  因为static是独立于对象之外的 所以不能与this一起使用

     printf("static function");

}

};

//inline为内联函数

inline const int A::getA() const{    //实现        //前面的const修饰的是返回值      后面的const修饰的是函数所在类的this指针 所以函数内不能改变类中的变量  关键字mutable 可以打破这个局限

    return a;

}

class中如果不加说明 则默认为private

实例化

A *a=new A();//在堆中分配内存   需要delete

A a;                //在栈中分配内存

2.3 重载操作符

c++中 大多数运算符都可以重载

关键字 operatorXXX          XXX为操作符

函数对象 通过重载()运算符

2.4 友元

2.4.1 友元函数

友元函数的参数

访问非static的成员 需要传入对象

访问static成员或全局 不需要参数

实现：friend + 普通函数声明

友元函数不能被继承

2.4.2 友元类

实现：friend class +  类名

友元类的所有非private函数都是当前类的友元函数

2.5  模板与泛型

使用  template <typename T>

模板可以特化 即一部分是T类型 一部分是具体类型 如：

template <typename T>

T get(T &a,int);    //第二个参数是具体类型

2.6 命名空间   解决命名冲突

namespace XXX{

     int m=0;

}

cout<<XXX::m<<endl;

2.7 多继承与虚继承

c++支持多继承 有些时候还是很方便的  继承的多个类用逗号隔开 不过多继承初始化时 需要初始化所有父类 多继承容易出现二义性 比如两个父类同时实现了get()函数 而子类没有实现 则调用子类的get()时会出现二义性 解决是用 域操作符

虚继承是为了解决多继承中 多个父类继承同一个类的冲突

class A:public virtual B{}

2.8 继承权限

class A:[public,protected,private] B{};

public继承 不改变父类的成员访问权限

protected  public成员变为protected成员 其他不变

private      父类的public protected成员都变为private成员

默认为private继承

2.9

纯虚函数

class A{

    virtual void get()=0;    //纯虚函数

    virtual void set();    //虚函数

}

当类中有虚函数时  必须被继承实现

3 php

3.1

interface IA{

    public function a();

}

class B implements IA{

    static $sta;     //静态 本类中调用  self::$sta       直接调用B::$sta;

    private $param;     

    function __construct(){    //构造函数

    }

   [public,protect,private] function get(){   //权限控制 默认为public

        return $this->param;

    }

   function __destruct(){    //析构函数

    }

}

还有abstract   php的接口 抽象 类继承规则与java很相像

$this指向本类的对象 | self指向本类  | final修饰类和方法 类似java,但是不能修饰变量 | const定义常量，一般用在类中 | define也是定义常量 但是不能在类中使用 | instanceof判定实例的类型

3.2 魔术方法

3.3 反射

3.4 引用&     解引用unset    貌似只有大对象和大数组推荐用

4 python

4.1

# -*- coding:utf-8 -*-
def method3(self):
    print "method3"

class A():

    #如果想在类外部使用私有变量  用对象点操作符调用 _类名__变量名    如:  a._A__num=3      

    __num=0    #以__开始定义私有变量,函数  如果在函数中使用 应该self.__num   如果不用self 表示在函数中又定义了一个__num

    def __init__(self):    #构造函数
        print "init"
    def method1(self):   #不同成员函数 需要加self参数
        print "method1"
    @staticmethod     #static函数 参数列表中不需要加self 调用直接A.method2()
    def method2():

        print "static method2"

    def __del__(self):    #析构
        print "__del__"

a = A()
a.method1()
A.method=method3;  #动态增加函数 但是定义的全局函数 必须有self参数  同method3(a)

a.method()

#python中 可以动态添加变量

a.m=3;
del a.m   #删除变量

4.2 函数操作

getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。

4.3 继承

python支持多继承 像c++一样 多继承会有二义性问题  python的解决方法是根据继承的顺序查找成员 会调用找到的第一个成员

有地方说是根据深度优先原则 按照子类定义中的父类顺序进行查找  用的2.7版本

4.4 重写与重载

重写没什么特殊

重载: python是动态语言 所以对于类型不同的参数，参数数量相同的函数不需要特殊处理，

对于参数数量不同的 可以用默认值得方式

重载运算符则是重写python已经定义好的函数即可

5 js

js中没有类的概念 所以js中对象的概念与面向对象语言的对象不同   <js高级程序设计>第六章   有好多地方叫做函数对象而不是对象

5.1 定义

5.1.1  通过new

var obj=new Object();

obj.name="name";

obj.printName=function(){

    alert(this.name);

}

5.1.2  字面量

var obj={

    name:"name",

    getName:function(){

        console.log(this.name);

    }

}

obj.getName();

5.2 属性配置 

Object.defineProperty(函数对象,属性,{

    属性:false,

    value:"==>aa",

});

属性     数据属性与访问器属性不能一起使用

通用属性

configurable: 表示能否修改属性的特性或可以被删除
Enumerable：表示能否通过 for-in 循环遍历属性

数据属性

Writable：表示能否修改属性的值
Value：包含这个属性的值

访问器属性

get： 获取属性值
set： 设置属性值

5.3 原型链

盗个图  原型链在js中是很重要的概念

a、每个函数对象都有一个__proto__ 指向函数的prototype
b、每个函数的prototype都是一个对象
c、每个函数的prototype都有两个属性 一个是constructor 指向函数原型  一个是__proto__  指向他的对象
d、Object.prototype为null
e、Function.prototype也是一个对象 所以它的__proto__指向Object.prototype 所以 所有对象的__proto__最终都会到Object.prototype
f、每个函数都有一个__proto__指向Function.prototype
g、因为function Objection()是函数 所以函数Objcetion的 __proto__指向Function.prototype

5.3 this关键字

函数运行时 自动生成的一个内部对象且只能在函数内部使用，this类似一个变量 保存的总是调用该函数的对象

5.4 call与apply

5.4.1  call(obj,[arg1,[arg2...]])

将函数的对象上下文改变为由obj指向的新对象  如果没有提供obj 则obj代表全局对象

function add(a,b)  {  
    alert(a+b);  
}  
function sub(a,b)  {  
    alert(a-b);  
}   
add.call(sub,3,1); //结果为4  相当于add(3,1)

5.4.2 apply([obj[,argArray]])
与call用法一样 差别就是参数列表 一个是一个一个传参数 一个是参数是数组的形式

5.5 继承    具体内容太多了 简记一下

关键就是函数的prototype指向的对象与this

5.5.1 原型链

通过prototype实现继承

5.5.2 借用构造函数

就是通过call 不过通过call可以实现多继承 同样会有多个父类有相同函数的二义性  但是他会调用最后call的函数对象的函数

5.5.3 组合继承   常用的方法

因为原型链和借用构造函数各有缺点 所以将他们结合 扬长避短 成为较为常用的方式

5.5.4 原型式继承

就是创建一个空函数 并将函数的prototype的值赋给父类 然后new这个函数对象并返回

5.5.5 寄生式继承

5.5.6 寄生组合继承      说是最好的方式

5.5.7 闭包

闭包需要注意this和内存泄漏

//私有属性

function myobject() {
                //私有属性
                var privateVariable = 10;
                //特权方法
                this.publicMethod = function () {
                    return privateVariable;
                };
            }

var obj = new myobject();

console.log("==>" + obj.publicMethod());     //10

//静态私有变量

(function () {
                var name = "";
                Obj=function(value){
                    name=value;
                };
                Obj.prototype.getName=function(){
                    return name;
                };
            })();
            var obj = new Obj("aaa");
            var obj1 = new Obj("bbb");
            console.log("==>" + obj.getName());      //bbb

6 object-c
//a.h
@interface A:NSObject(M){
@private/@protect/@public/@package      //类C的权限控制都差不多 默认protect 方法没有这些
    NSString *name;
    int age;
}
-(void) setName:(NSString *)n setAge:(int)a;
+(NSString *)getName;                                             //+号是类方法    -实例方法
@end
//a.m
#include "a.h"

@implementation A

-(id)init(){                                     //构造

    if(self=[super init]){

    }

    return self;

}

-(void)dealloc{

}

-(void) setName:(NSString *)name setAge:(int)a{
    self->name=name;
    self->age=age;
}
+(NSString *)getName{
    return self->name;
}
@end
int main(){
    A *a=[A new];  //A *a=[[A alloc] init];
    [a setName:@"name" setAge:5];
    NSLog(@"==%@",[A getName]);
    return 0;
}
oc也支持static const  @class与c++类似
id类似(void *)  支持enum  self类似java中的this
6.2 @property与@synthesize  

生成带内存管理的set/get

@property (XXX) A *a;

6.2.1 内存管理参数

retain  适用于oc对象类型    先releasel  再retain  实现引用计数+1

assign 适用于非oc对象类型 就是直接赋值 引用计数不变

copy   先releasel 再copy  引用计数+1

retain与copy 一个是浅复制 只是复制引用  copy是深复制 复制引用的时候 值也重新复制

6.2.2 多线程参数

atomic  线程安全的 效率低 默认    nonatomic 不考虑多线程用

6.2.3 readwrite 读写               readonly  只读

6.3 重写与重载

可以重写 但是重写之后子类就不能调用父类的方法
不支持重载
6.4 协议 （就是接口）
@protocol proto <NSObject>
@optional    可以不实现
@required    必须实现的方法
-(void) get;
@end
@interface C : NSObject<proto,proto1,proto2>  //可以实现多个协议 但是继承只能继承一个
6.5 类别(分类)
@interface NSObject(Object)
@implementation NSObject(Object)
分类可以扩展原有类 但是有一些约束
只能添加方法 不能添加变量
如果分类重写了原有类的方法 则原有方法被覆盖   这样做一般不好
6.6 处理动态类型的方法
isKindOf  isMemberOfClass respodsToSeletor instancesRespondToSelector isSubclassOfClass performSelector performSelector

7 swift
权限控制private  public  internal表示所在模块都可以访问  默认是internal
7.2 支持运算符重载
7.3 支持重载和重写 重写前需要加override
7.4 协议 （接口）
protocol p{
    func p();
}

7.5 类扩展   类似oc的分类

extension String{  //实现  }

7.6 支持泛型

东西有点多 也太杂了