类与对象的理解与封装特性

 面向对象编程语言
   - 类: 一个模板, (人类)---是一个抽象的， 没有实体的
   - 对象: (eg: 张三， 李四)
   - 属性: (表示这类东西的特征, 眼睛， 嘴巴， 鼻子)
   - 方法： (表示这类物体可以做的事情， eg: 吃饭， 睡觉，学习)

1). 定义类:class: 类

from collections import  Counter

例子: str, list, dict, Counter

object代表是， 人类继承于哪一个类， 如果不知道继承哪个类， 就写object；

class 人类(object):
    # print('hello')

    # 构造方法(魔术方法)， 当创建对象的时候， 自动执行的函数
    def __init__(self, name, age, gender):
        # python解释器自动将对象传给self这个形参.
        # 看self到底是什么东西?

        # 将对象与该对象的属性绑定在一起.
        #  调用对象的属性两种方式:
        #       - 张三.name
        #       - self.name
        self.name = name     # 属性
        self.age = age       # 属性
        self.gender = gender # 属性
        print(self)  # 实质上是一个对象， <__main__.人类 object at 0x7f4fdc4864a8>

    # 方法(在类里面定义的函数， 叫做方法)
    def eat(self):
        print("%s 正在吃饭..." %(self.name))

创建对象====根据模板(类)创建对象(真实存在)

张三 = 人类("张三",  10, 'male')
print("张三:", 张三)

看对象的属性

print(张三.name)
print(张三.age)
print(张三.gender)

让对象执行方法

张三.eat()

对象与类掌握练习

应用练习1
创建一个类People,拥有的方法为砍柴,娶媳妇,回家;实例化对象,执行相应的方法
显示如下:
    老李,18岁,男,开车去娶媳妇
    校思浩,22岁,男,上山去砍柴
    唐浩,10岁,女,辍学回家
提示:
    属性:name,age,gender
    方法:goHome(), kanChai(),quXiFu()

class People(object):
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def huiJia(self):
        print("%s,%d,%s,辍学回家" %(self.name,self.age,self.gender))
    def quXiFu(self):
        print("%s,%d,%s,开车去娶媳妇" %(self.name,self.age,self.gender))
    def kanChai(self):
        print("%s,%d,%s,上山砍柴" %(self.name,self.age,self.gender))
Laoli = People('老李',18,'男')
zhangsan = People('校思浩',22,'男')
lisi = People('唐浩',10, '女')

Laoli.quXiFu()
zhangsan.kanChai()
lisi.huiJia()

类的私有属性与私有方法

类的私有属性:
    __private_attrs：两个下划线开头，声明该属性为私有，
    不能在类地外部被使用或直接访问。
    在类内部的方法中使用时 self.__private_attrs。
类的方法:
    在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，
    类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
    self 的名字并不是规定死的(因为是形参)，也可以使用 this，但是最好还是按照约定是用 self。
类的私有方法
    __private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，
    不能在类地外部调用。self.__private_methods。

class People(object):
    def __init__(self,name,age,gender, money):
        self.name = name
        self.age = age
        self.gender = gender
        self.__money = money

    def __play(self):
        print("王者荣耀正在进行时")

p1 = People('user1', 10, 'male', 1000000)
print(p1.gender)
p1.__play

栈数据结构的封装

应用练习2:栈的数据结构
class Stack:
    栈的方法:
    入栈(push), 出栈(pop), 栈顶元素(top),
    栈的长度(lenght), 判断栈是否为空(isempty)
    显示栈元素(view)
    操作结果:
    栈类的实例化
    入栈2次
    出栈1次
    显示最终栈元素

class Stack(object):
    # 构造函数
    def __init__(self):
        self.stack = []
    def push(self, value):
        """
        :param value: 入栈元素
        :return:
        """
        self.stack.append(value)
        return True

    def pop(self):
        # 判断栈是否为空
        if self.stack:
            # 获取出栈元素, 并返回
            item = self.stack.pop()
            return  item
        else:
            return  False

    def top(self):
        if self.stack:
            return  self.stack[-1]
        else:
            return  False
    def length(self):
        return  len(self.stack)

    def isempty(self):
        return self.stack==[]

    def view(self):
        return  ",".join(self.stack)

s = Stack()
s.push('1')
s.push('2')
s.push('3')
s.push('4')
print(s.top())
print(s.length())
print(s.isempty())
s.pop()
print(s.view())

队列数据结构的封装

class Queue(object):
    # 构造函数
    def __init__(self):
        self.queue = []
    def push(self, value):
        self.queue.append(value)
        return True
    def pop(self):
        if self.queue:
            del self.queue[-1]
        else:
            return  False

    def front(self):
        if self.queue:
            return  self.queue[0]
        else:
            return  False
    def rear(self):
        if self.queue:
            return  self.queue[-1]
        else:
            return  False
    def length(self):
        return  len(self.queue)

    def isempty(self):
        return self.queue==[]

    def view(self):
        return  ",".join(self.queue)
s = Queue()
s.push('1')
s.push('2')
s.push('3')
s.push('4')
print(s.front())
print(s.rear())
print(s.length())
print(s.isempty())
s.pop()
print(s.view())

第二个特性之继承

概念:

- 父类与子类/基类和派生类

from io import TextIOWrapper

class Animals(object):
    def __init__(self, name, age):
        self.name = name
        self.age= age
    def eat(self):
        print('eating......')


class Dog(Animals):  # 当Dog没有构造方法时，执行Animals里面的构造方法
    def __init__(self, name, age, power):
        # self.name = name
        # self.age = age
        # 执行Dog的父类的构造方法;
        super(Dog, self).__init__(name, age)
        self.power = power
    def eat(self):
        print(self.power)
        super(Dog, self).eat()


#  1. 如果子类没有的属性和方法， 则去父类找， 如果父类也没有， 就报错。
d1 = Dog("大黄",3,100)
print(d1.name)
print(d1.age)
print(d1.power)
d1.eat()

多继承原理

#coding:utf-8

# # 经典类
# class Person1:
#     pass
# p1 = Person1()
# print(p1)
#
# # 新式类
# class Person2(object):
#     pass
# p2 = Person2()
# print(p2)

# 在python2中既有新式类也有经典类;
#
#
#       经典类的继承算法: 深度优先算法
#       新式类的继承算法: 广度优先算法
# python3全部都是新式类;

class D:
    def test(self):
        print("D test")
class C(D):
    pass
    def test(self):
        print("C test")
class B(D):
    pass
    # def test(self):
    #     print("B test")
class A(B,C):
    pass
    # def test(self):
    #     print("A test")
a = A()
a.test()

三，多态性

#子类和父类存在相同方法时，子类会覆盖父类方法
#运形时总会调用子类方法--> 多态


class Animal(object):
    def run(self):
        print('running...')
    def cry(self):
        print('crying...')

class Dog(Animal):
    def run(self):
        print('dog running...')

    def eat(self):
        print('dog eating...')

class Cat(Animal):
    def run(self):
        print('cat running...')

cat = Cat()
cat.run()

dog = Dog()
dog.run()

图书管理系统

# 假设每本书只有一本

class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        # 0：'已借出' 1:'未借出'
        self.state = state
        self.bookIndex = bookIndex


    def __str__(self):
        return  'Book(%s, %d)' %(self.name, self.state)

class   BookManage(object):
    # 存放所有书籍信息, 列表里面存放的是Book对象
    books = []

    def start(self):
        """图书管理系统初始化数据"""
        self.books.append(Book('python', 'Guido', 1, 'IN23445'))
        self.books.append(Book('java', 'Guido1', 1, 'IN23445'))
        self.books.append(Book('C++', 'Guido2', 1, 'IN23445'))
        print("初始化数据成功!")

    def Menu(self):
        """图书管理菜单栏"""
        while True:
            print("""
                        图书管理操作
                        
            1). 添加书籍
            2). 删除数据
            3). 查询书籍
            4). 退出
            """)
            choice = input("请输入你的选择:")
            if choice == '1':
                self.addBook()
            elif choice == '2':
                self.delBook()
            elif choice == '3':
                self.borrowBook()
            elif choice == '4':
                exit()
            else:
                print("请输入正确的选择!")

    def addBook(self):
        print("添加书籍".center(0, '*'))
        name = input("书籍名称:")
        bObj = self.isBookExist(name)
        if bObj:
            print("书籍%s已经存在" %(bObj.name))
        else:
            self.books.append(Book(name,input("作者:"), 1, input("存放位置:")))
            print("书籍%s添加成功" %(name))

    def delBook(self):
        print("删除书籍".center(50,'*'))
        for i in self.books:
            print(i)
        name = input("删除书籍名称：")
        a = self.isBookExist(name)
        if a:
            self.books.remove(a)
            print("删除%s成功" %(a))
        else:
            print("书籍不存在")

    def borrowBook(self):
        print("查询书籍".center(50,'*'))
        for i in self.books:
            print(i)
        name = input("查询书籍名称：")
        b = self.isBookExist(name)
        for book in self.books:
            if book == b:
                print(book)
                break
            else:
                print("%s不存在" %(b))
                break
    def isBookExist(self, name):
        """检测书籍是否存在"""
        # 1. 依次遍历列表books里面的每个元素
        # 2. 如果有一个对象的书名和name相等， 那么存在；
        # 3. 如果遍历所有内容， 都没有发现书名与name相同， 书籍不存在;
        for book in self.books:
            if book.name == name:
                # 因为后面需要
                return book
        else:
            return  False

if __name__ == "__main__":
    bManger = BookManage()
    bManger.start()
    bManger.Menu()

菜鸟都能看懂（很容易理解）—— 类与对象

一、类与对象的定义

类的定义：
类（class）：是构造 对象 的模板或蓝图，类也是一组相关属性和行为的集合。

属性（成员变量）：就是该事物的状态信息（如同手机的颜色，材料）
行为（成员方法）：就是该事物能够做什么（如同手机的打电话，发短信功能）

类就如下图的手机图纸，它是抽象的，而不是真实存在的。

对象的定义：
对象：对象是类的实例。由于对象是根据类创建出来的，所以对象具备类中的属性和行为。

对象就如下图真实存在的手机，它是真实的

类和对象的关系：类是对象的蓝图（模板），对象是类的实体。

二、类与对象的代码举例

我们来举个例子帮助大家理解，比如说我们今天创建一个有关学生的类。

学生类定义如下：

public class Student{
	String name; //学生的名字
	int age; //学生的姓名
	public void study(){
		System.out.println("学生要学习")
	}
	public void play(){
		System.out.println("学生要玩耍")
	}
}

上面的代码，就是我们创建完一个有关学生的类，代码中学生的名字就是我们所说的属性（成员变量）我们都知道类是抽象的，它如同模板，而我们根据上面这个学生类创建出来的学生对象就是真实存在的。

根据学生类创建学生对象代码如下：

public class Test{
	public static void main(String[] args){
		Student stu = new Student(); //创建学生对象
		stu.study();//根据对象名（stu）加上点符号（.）就可以访问类中的成员
	}
}

打印结果：

学生要玩耍

三、总结

类就是对象的模板，我们通过类创建出来的对象会具备类中的属性和行为（成员变量和成员方法），创建对象的目的就是为了访问类中的成员变量和成员方法。是不是真的很好理解呢？通过理解我们就会发现他真的非常简单，这就是面向对象编程，JAVA语言的魅力。

0. 面向对象的三大特征

0.1 封装性

 把客观事物封装成抽象的类，每个类都有自己的属性与方法，并且类可以让自己的数据和方法只让可信的类或对象操作，对不可信的进行信息隐藏。内部操作对外部而言不可见（保护性）

0.2 继承性

 它可以是现有类的所有功能，并且再无需重新编写原有类的代码的情况下对这些功能进行扩展。

0.3 多态性（重点）

 指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。
面对对象的最大特征就是：可以进行生活的抽象

1. 类与对象的概念

类是共性的概念，而对象是一个具体、可以使用的事物。类是声场对象的蓝图，现有类才可以产生对象。对象的所有属性与行为，一定在类中进行了完整的定义。

1.1 类中的组成

1. 方法（操作的行为）
2. 属性（变量，描述每个对象的具体特点）

2. 类与对象的定义与使用

2.1 类的定义

class 类名称{
	属性1;
	属性2;
	……
	方法1;
	方法2;
	……
}

举例：定义一个Person类

class Person{
    // 属性
    public String name;
    public int age;
    // 构造方法
    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }
    // 普通方法
    public String getPersonInfo(){
        return "姓名：" + this.name + "年龄：" + this.age;
    }
}

类中的属性与方法（不带static关键字的）只能通过对象调用。

2.2 对象的产生

类名称 对象名称 = new 类名称();

以Person类为例，可以产生一个Person类的实例（对象）：

       Person per1 = new Person();
       Person per2 = new Person("zhangsan", 12); 

2.3 通过对象调用实例变量与实例方法

只要出现了关键字new，就开辟了内存。

        Person per = new Person("zhangsan", 18);
        System.out.println(per.name);
        System.out.println(per.getPersonInfo());

运行结果如下图所示：

3. 对象的内存分析

 先简单的将Java中的内存区域分为 * 栈内存* 和 堆内存 （实际Java的内存区域的划分远比这个复杂）

1. 栈内存（虚拟机局部变量表）：存放的是局部变量（包含编译期可知的各种基本数据类型、对象引用—>即堆内存地址—>对象的名称），Java栈是与线程对应起来的，每当创建一个线程，JVM就会为这个线程创建一个对应的Java栈。
2. 堆内存：保存的是真正的数据，即对象的属性信息。

new表示在对上新分配的空间。
举例：通过以下代码和内存分析给大家讲解一下内存：

class Person{
    // 属性
    String name;
    int age;
}
public class Test{
    public static void main(String[] args){
        Person per = new Person();
        System.out.println(per.name + "  " + per.age);
        per.name = "zhangsan";
        per.age = 18;
        System.out.println(per.name + "  " + per.age);
    }
}

以上代码运行后得：

以下按步骤进行分析，对应代码及内存图：

Person per = new Person();

        per.name = "zhangsan";
        per.age = 18;

通过per引用设置堆属性值，内存图如下所示：

对象（引用数据类型）必须在实例化后调用，否则会产生NullPointerException(运行时错误)，编译时不会出错"NullPointerException"在开发生涯中会一直存在，只有引用类型（数组、类、接口）才会产生此类异常。以后此类异常，就根据出错位置查看引用数据类型变量是否初始化。

4. 引用传递分析

引用传递的本质：一块堆内存可以被多个栈内存所指向

        Person per1 = new Person();
        Person per2 = new Person();
        per2 = per1;

前两句代码的内存图如下：

当 per2 = per1; 执行后，内存会怎么样变化？

垃圾空间： 没有任何栈内存指向的堆内存空间。
所有垃圾空间会不定期GC(垃圾收集)，GC会影响性能，所以开发之中一定要控制好对象的产生数量(无用的对象尽量少产生)