Python类与对象

1.类的定义：

1)自定义类的语法

class 类名：
    '可选的文档字符串'
    类成员

2)类定义的构成

①class关键字；②类名；③冒号(:)；④文档字符串：可选择 ⑤类成员：类的属性和方法

3)pass语句

空语句；不做任何操作，一般用作占位语句；用于保证格式完整，保证语义完整

4)类的命名

①类名的命名规范

a.首字母大写
b.以大写字母分割单词
c.尽量不使用下划线(ps：容易转义)
d.例如：
        AddrBookEntry、RepairShop

②属性名

a.使用名词，说明操作的对象
b.首字母小写
c.以大写字母分割单词
d.例如：
        name、myEmail、myPhone

③方法名

a.使用谓词(动词+对象)，说明对什么对象进行操作
b.首字母小写
c.以大写字母分割单词
d.例如：
        updataPhone、addEmail

5)文档字符串

①.提供程序的帮助信息
②.可选的
③.通常是一个多行字符串    (ps:以前后各三个单引号为注释)
        a.首行以大写字母开始，句号结尾 (ps:句号是英文状态)
        b.第二行是空行
        c.第三行是详细的描述
④.可以通过"类名.__doc__"访问 ：输出文档字符串 (ps:格式不变)

例如：

class Show():
    '''Hello ! my friends.

    liu,zhang,li,huang'''
    def friendful(self):
        pass
print(Show.__doc__)

2.类的对象
创建类对象的语法格式

对象=类名(参数列表)  (ps:参数列表可选)

访问类属性和方法之前，必须先创建一个实例对象

使用点运算符，访问类对象的属性，调用类的对象的方法

例如：

class Plane:
    '''Plane's fly.

    p1,p2,p3'''
    def displayPlane(self):
        pass
p1=Plane()
p1.displayPlane()
print Plane.__doc__

1)类对象的生命周期：

定义类   —>   创建对象    —>    访问对象成员  —>销毁对象
  |               |                    |               |
 class         构造方法		  类对象.属性	   析构造方法
               __init__()  	  类对象.方法	   __del__()

①__init__()是构造方法

a.创建新对象时，系统会自动调用
b.传入新创建的的对象
c.可以为对象的属性赋值

②__del__()是析构方法

a.销毁对象时，系统会自动调用
b.传入要销毁的对象
c.回收对象所占的资源

2)self简介

①.英文中表示自己，自身
②.程序中表示类实例对象本身
③.是当前类的实例对象
④.使用方法如下：
        a.作为类方法定义的第一个参数
        b.是隐含参数，调用方法时不需要传入实参
            例如：del方法名(self,参数列表)
        c.访问类实例对象的属性
            例如：self.属性
        d.调用类实例对象的方法
            例如：self.方法(参数列表)

案例：

class Plane:
    '''plane will fly.

        平安,幸福'''
    pCount = 0
    def __init__(self,name,category):
        self.name=name
        self.category=category
        Plane.pCount+=1
    def displayPlane(self):
        print 'name:',self.name,'Category:',self.category
    def displayCount(self):
        print 'Total Plane:%d'%Plane.pCount
p1=Plane('平安','波音888')
p1.displayPlane()
p2=Plane('幸福','波音777')
p2.displayPlane()
p3=Plane('顺利','呼叫199')
p3.displayPlane()
print 'Total Plane:%d'%Plane.pCount

3)类和对象的属性

①任何时候都可以添加、修改或删除类和对象的属性
②使用赋值运算符为类对象添加、修改属性
③使用del删除类对象的属性
        del 类名.属性名

案例：

class Plane:
    '''plane will fly.

        平安,幸福'''
    pCount = 0
    def __init__(self,name,category):
        self.name=name
        self.category=category
        Plane.pCount+=1
    def displayPlane(self):
        print 'name:',self.name,'Category:',self.category
    def displayCount(self):
        print 'Total Plane:%d'%Plane.pCount
p1=Plane('平安','波音888')
p1.displayPlane()
#添加属性
p1.carryNum=567
#修改属性
p1.carryNum=998
#删除属性
del p1.carryNum
print 'carry Passmeger:',p1.carryNum
print 'Total Plane:%d'%Plane.pCount

4)销毁对象

①垃圾收集：定期回收的内存块，不再使用的过程
②自动回收：
    a.对于不需要的对象，系统会自动释放内存空间
    b.垃圾回收器在程序执行过程中会自动回收引用数为零的对象所使用的内存资源
③手动回收：
    调用__del__()方法清理销毁对象的任何非内存资源
(ps:__del__()析构方法类似清理空间站的意思，如果手动删除而不调用析构方法，一段时间后也会自动清空)

3.类的属性

①类属性
    a.与类绑定，不依赖于对象，又称为静态属性
    b.不需要实例化对象
    c.类和其对象都可以访问获取其值
②实例属性
    a.存在于对象中
    b.必须先创建对象，再访问获取其值 
    c.每一个不同的对象都有属于自己的实例属性值
(ps:当通过对象访问某个属性时，解析器会先尝试在实例命名空间中寻找，如果找不到，就会去类属性中查找)

1)类属性

①在类体中声明，并初始化
②访问方式
    类名.属性
    对象名.属性
(ps:  a.类属性属于类自身，对象仅在没有同名实例属性时才能访问它
      b.类和对象都可以访问类属性，但对象只能读取，不能修改类属性的值
      c.当试图通过对象给类属性赋值时，解释器会理解为给对象p1的pCount属性赋值
      d.如果对象p1没有pCount属性，会自动的给对象p1创建一个与类属性同名的实例属性
      e.因此，p1.pCount属性与Plane.pCount,不是同一个属性    )

案例：

class Plane:
    pCount=0
    def __init__(self,name,category):
        #声明实例属性，并初始化
        self.name=name
        self.category=category
        Plane.pCount+=1

print '已生成',Plane.pCount,'架飞机'
p1=Plane('平安','波音777')
print '     (Plane)已生成',Plane.pCount,'架飞机'
print '     (p1)已生成',p1.pCount,'架飞机'
p1.pCount+=1
p1.pCarry=360
print '         (p1)已生成',p1.pCount,'架飞机,载客量是',p1.pCarry,'人'

2)实例属性

多种声明方式：

①__init__()声明，并初始化

②通过赋值语句声明，并赋值

(ps:对象可以访问类属性，但类不能访问实例属性)

例如： Plane.name  是错误的访问

3)获取类属性信息

①内置函数
    dir():返回类属性列表
②类的字典属性__dict__():返回一个字典
    键是属性名
    值是相应的属性对象的数据值

class Plane:
    pCount=0
    def __init__(self,name,category):
        #声明实例属性，并初始化
        self.name=name
        self.category=category
        Plane.pCount+=1

代码运行之后结果如下：

调用dir()

>>> dir(Plane)
['__doc__', '__init__', '__module__', 'pCount']
>>> 

调用__dict__

>>> Plane.__dict__
{'__module__': '__main__', 'pCount': 0, '__doc__': None, '__init__': <function __init__ at 0x030068B0>}
>>> 

4)特殊的类属性

①每个类都具有内置属性

②使用点"."可以访问

③常用的类属性如下：

类属性	说明
__dict__	类的命名空间(字典)
__doc__	类的文档字符串，如果没有定义，值为none
__name__	类的名称
__module__	在类中定义的模块名称，交互模式其值为__main__
__bases__	一个可能是空的元组，包含了其在基类列表出现的顺序

5)获取实例属性信息

①内置函数dir()

②特殊的对象属性__dict__:获取对象属性

③特殊的对象属性__class__:获得对象所对应的类名

class Plane:
    pCount=0
    def __init__(self,name,category):
        #声明实例属性，并初始化
        self.name=name
        self.category=category
        Plane.pCount+=1
p1=Plane('平安','波音777')

运行后输入以下代码执行：

>>> p1.__dict__
{'category': '\xb2\xa8\xd2\xf4777', 'name': '\xc6\xbd\xb0\xb2'}
>>> p1.__class__
<class __main__.Plane at 0x02EF8F80>
>>> 

6)常用的内置函数

函数声明	说明
getattr(obj,name[,default])	访问对象的属性
hasattr(obj,name)	检查指定的属性是否存在  True or False
setattr(obj,name,value)obj是对象名，name是属性名	设置属性，如果属性不存在，将被创建
delattr(obj,name)	删除指定的属性

4.类的方法
①类方法   @classmethod  类方法名（cls,参数列表）

a.与类绑定，不依赖于对象

b.不需要实例化对象

c.类和其对象都可以调用执行

②实例方法    实例方法名(self,参数列表)

a.与类绑定，依赖于对象

b.在类中声明定义

c.必须先创建对象，在调用执行

d.类对象可以调用执行

③静态方法    @staticmethod  静态方法名(参数列表)

a.与类方法相似

1)类的方法

①语法：

@classmethod    #要求独占一行

类方法名(cls,参数列表)

②通过装饰器 "@classmethod"通知解释器是类方法

③第一个参数 cls表示当前类

④cls是隐藏参数，调用方法时不需要传入实参

例：

class Plane:
    pCount=0
    def __init__(self,name,category):
        #声明实例属性，并初始化
        self.name=name
        self.category=category
        Plane.pCount+=1
    @classmethod
    def displayCount(cls):
        print '已生产',Plane.pCount,'架飞机'
        print Plane.pCount
Plane.displayCount()
p1=Plane('平安','波音777')
p1.displayCount()

结果输出：

>>> 
已生产 0 架飞机
0
已生产 1 架飞机
1
>>> 

2)静态方法

①语法：

@staticmethod

静态方法名(参数列表)

②通过装饰器 "@staticmethod" 通知解释器是静态方法

③没有隐含参数

3)类方法与静态方法的比较：

①相同点

a.与类绑定，不依赖于对象

b.不需要实例化对象

c.类和其对象都可以调用执行

②不同点

	类方法	静态方法
装饰器	@classmethod	@staticmethod
方法声明	第一个参数是隐含参数 (有的场合需要cls参数，只能用类方法)	不需要隐含参数

例：

class Plane:
    pCount=0
    def __init__(self,name,category):
        #声明实例属性，并初始化
        self.name=name
        self.category=category
        Plane.pCount+=1
    @staticmethod
    def displayCount(cls):
        print '已生产',Plane.pCount,'架飞机'
        print Plane.pCount
Plane.displayCount()
p1=Plane('平安','波音777')
p1.displayCount()

5.综合案例

面向对象是解决问题的思维方式

java：类途径的面向对象的解决方案：接口，注解

JavaScript：原型链途径的面向对象解决方案

Python：类途径的面向对象解决方案

在Python中所有的类都像字典一样随意追加属性，但不能使用字典的取值方式

在Python中方法重载没有意义，，执行顺序：从下到上，从左到右

1)python面向对象

class Person:
    name=None
    def __init__(self):     #不报错，但也不会被调用，无意义
        print('on params....')
    def __init__(self,name,age=None):
        self.name=name
        self.age=age
    def say(self,str=None):
        print(self.name,'说：',str)

class Base2:
    def say(self,str):
        print('base2 say',str)

class Student(Person,Base2):
    score=0
    def __init__(self):
        Person.__init__(self,'zhangsan')
        self.score=100
    def say(self,str):
        print('student say',str)
        Person.say(self,str)
        Base2.say(self,str)

stu=Student()
print(stu.name)  #Person stu=new Student()
print(stu.score)
stu.say('who are you')



'''
p1=Person()
p1.name='zhangsan'
p1.sex='女'
del p1.sex
print(p1.name)
print(id(p1))  #打印p1对象的id地址

p2=Person()
print(id(p2))
print(p2.name)
print(dir(Person))
print(Person)

class Student(Person):
    score=0
stu=Student()
print(stu.name)  #相当于Person stu=new Student()
print(stu.score)

'''

2)java面向对象

public class Person {
    private String name;
    private int age;

    @Override
    public String toString() {
        return this.getName()+'\t'+this.getAge();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }
}

public class PersonDemo {
    public static void main(String[] args) {
        List <Person> people=new ArrayList<Person>();
        Person person1=new Person("zhansan",12);
        Person person2=new Person("lisi",36);
        Person person3=new Person("wanger",24);
        people.add(person1);
        people.add(person2);
        people.add(person3);
        //第一种排序
        Collections.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getName().compareTo(o2.getName());
                //return o2.getAge()-o1.getAge();//从大到小
            }
        });
        //第二种排序
        //Collections.sort(people,(o1,o2) -> o2.getAge()-o1.getAge());

        for (Person p:people
             ) {
            System.out.println(p);
        }

    }
}