一、面向对象三大特征介绍

Python 是面向对象的语言，也支持面向对象编程的三大特性：继承、封装（隐藏）、多态。

1、封装（隐藏）
隐藏对象的属性和实现细节，只对外提供必要的方法。
通过“私有属性、私有方法”的方式，实现“封装”。Python 追求简洁的语法
2、继承
继承可以让子类具有父类的特性，提高了代码的重用性。从设计上是一种增量进化，原有父类设计不变的情况下，可以增加新的功能，或者改进已有的算法。
3、多态
多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是：同样是休息方法，人不同休息方法不同。张三休息是睡觉，李四休息是玩游戏，程序员休息是“敲几行代码”。

二、继承

继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。
如果一个新类继承自一个设计好的类，就直接具备了已有类的特征，就大大降低了工作
难度。已有的类，我们称为“父类或者基类”，新的类，我们称为“子类或者派生类”。

1、语法格式

Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
    class 子类类名(父类 1[，父类 2，...])：
         类体
如果在类定义中没有指定父类，则默认父类是 object 类。也就是说，object 是所有类的父
类，里面定义了一些所有类共有的默认实现，比如：__new__()。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下：
父类名.__init__(self, 参数列表)

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def say_age(self):
        print("年龄是：",self.__age)



class Student(Person):
    def __init__(self,name,age,grade):
        self.grade = grade
        Person.__init__(self,name,age) 
# 构造函数中包含调用父类构造函数。根据需要，不是必须。 子类并不会自动调用父类的__init__()，我
# 们必须显式的调用它。


if __name__ == '__main__':
    s=Student('诸葛',18,1)
    s.say_age()

2、类成员的继承和重写

1. 成员继承：子类继承了父类除构造方法之外的所有成员。
2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age

    def say_age(self):
        print("年龄是：",self.__age)



class Student(Person):
    def __init__(self,name,age,grade):
        self.grade = grade
        Person.__init__(self,name,age) 

    def say_age(self):
        print(self.name,"的年龄是：",self.age)
# 构造函数中包含调用父类构造函数。根据需要，不是必须。 子类并不会自动调用父类的__init__()，我
# 们必须显式的调用它。


if __name__ == '__main__':
    s=Student('诸葛',18,1)
    s.say_age()

 3、super()获得父类定义

在子类中，如果想要获得父类的方法时，我们可以通过 super()来做。
super()代表父类的定义，不是父类对象。

class A:
    def say(self):
        print("A: ",self)
        print("say AAA")
class B(A):
    def say(self):
        #A.say(self) 调用父类的 say 方法
        super().say() #通过 super()调用父类的方法
        print("say BBB")

if __name__ =="__main__:

    b = B()
    b.say()

4、设计模式_工厂模式实现

工厂模式实现了创建者和调用者的分离，使用专门的工厂类将选择实现类、创建对象进
行统一的管理和控制。

class CarFactory:
    def createCar(self,brand):
        if brand == "1":
            return one()
        elif brand == "2":
            return two()

        elif brand == '3':
            return three()
        else:
            return "未知品牌，无法创建"
class one:
    pass
class two:
    pass
class three:
    pass
factory = CarFactory()
c1 = factory.createCar("1")
c2 = factory.createCar("2")
print(c1)
print(c2)

5、设计模式_单例模式实现

单例模式（Singleton Pattern）的核心作用是确保一个类只有一个实例，并且提供一
个访问该实例的全局访问点。

单例模式只生成一个实例对象，减少了对系统资源的开销。当一个对象的产生需要比较
多的资源，如读取配置文件、产生其他依赖对象时，可以产生一个“单例对象”，然后永久
驻留内存中，从而极大的降低开销。

class One:
    __obj = None   #  用于存储这个单例
    __init_flag = True
    def __new__(cls, *args, **kwargs):
         # 指的是One这个类里面的  类属性
         if cls.__obj == None:
               # object 是类的默认父类
             cls.__obj = object.__new__(cls)
         return cls.__obj
    def __init__(self,name):
        if One.__init_flag:
            print( "init....")
            self.name = name
            One.__init_flag = False

if __name__=='__main__':
    a = One( "aa")
    print(a)
    b = One( "bb")
    print(b)

初始理解

其实这些知识很早就有接触，而且一些概念也牢记于心了。自己叙述面向对象的特征会是这样的：
面向对象的三大特征是封装、继承和多态。封装是对代码的封装以实现迪内聚高耦合的设计，使代码更安全且具有良好的扩展性。继承是父类产生子类的过程，子类可以使用父类的非私有的属性和方法。多态是一个对象在不同时刻可以表现出不同状态的现象。外加Animal和Cat的例子。
这一段时间敲了不少的Java代码，在敲代码的过程中想了无数次的面向对象这几个概念，对他们有了更深的了解，在这里分享一下。

封装

封装确实是对代码的封装，但是只是这样理解却又太肤浅了，至少结合Java来思考一下里面的封装嘛。
不知道大家有没有想过我们在写JavaBean的时候为什么要将属性的权限修饰为private，其实是为了使我们的代码更安全。分析如下：

public class Cat {
    //这里通过private修饰属性，外界访问属性需要通过getter和setter方法
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    //假设我们设置age，如果用户恶意将age设置为100
    //众所周知，impossible，因此我们可以通过setter方法进行if判断然后再赋值
    public void setAge(int age) {
        this.age = age;
    }
}

我们可以考虑一下如果没有setter方法的判断，我们将该类的属性设置为public呢？那么用户的恶意输入，怎样规避呢？
总之：private是封装的一种体现。

封装还有其他的方法：为了提高代码的复用性可以将公共逻辑抽取成方法，将公共属性抽取成类。例如我们在不同的位置用到了相同的for循环，在idea中我们就可以选中相同的for循环部分，点击快捷键 ctrl + alt + m 将其抽取为方法。

继承

继承是面向对象的三大特征之一，过程就是使子类获得父类的属性和方法。
这个过程较容易理解，关键字是extends，如果我们定义的类没有显式继承某个类，系统默认为我们继承Objects。继承是我们代码的coding量变少了，提高了代码的复用性。
这里更深的体会是继承提高了代码的维护性。主要表现就是如果方法的代码需要修改，某些情况下我们只需要修改一处就可以实现。
但是这里还有一点没有想通的继承肯定会增加代码的耦合性，我们为什么还要这样夸大继承呢？我有这种疑问就是陷入了一个思维的误区，可以看这篇文章来解疑：为耦合辩护,为继承伸冤

多态

多态的三个必要条件是：

1. 有继承或实现关系
2. 有方法的重写
3. 父类引用指向子类对象

class Fu {
    int num = 10;
    public void method(){
        System.out.println("Fu.. method");
    }
}
class Zi extends Fu {
    int num = 20;
    public void method(){
        System.out.println("Zi.. method");
    }
}
public class Test2Polymorpic {
    public static void main(String[] args) {
        Fu f = new Zi();
        System.out.println(f.num);
        f.method();
    }
}

关于为什么访问成员变量和成员方法的会分别get父类和子类的值和方法，这里有讲解。从虚拟机角度看Java多态->（重写override）的实现原理

1. 好处：提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
2. 弊端：不能使用子类的特有成员
   解决弊端可以通过向下转型：格式为子类型 对象名 = (子类型)父类引用;

class Fu {
    public void show(){
        System.out.println("Fu..show...");
    }
}
class Zi extends Fu {
    @Override
    public void show() {
        System.out.println("Zi..show...");
    }
    public void method(){
        System.out.println("我是子类特有的方法, method");
    }
}
public class Test {
    public static void main(String[] args) {
        //向上转型 : 父类引用指向子类对象
        Fu f = new Zi();
        f.show();
        // 多态的弊端: 不能调用子类特有的成员
        // f.method();
        //解决方法：
        // A: 直接创建子类对象
        // B: 向下转型
        //向下转型 : 从父类类型, 转换回子类类型
        Zi z = (Zi) f;
        z.method();
    }
}

如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException，可以使用instanceOf来解决。

abstract class Animal {
    public abstract void eat();
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void watchHome(){
        System.out.println("看家");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

public class Test4Polymorpic {
    public static void main(String[] args) {
        useAnimal(new Dog());
        useAnimal(new Cat());
    }

    public static void useAnimal(Animal a){
        a.eat();
        // 判断a变量记录的类型, 是否是Dog
        if(a instanceof Dog){
            Dog dog = (Dog) a;
            dog.watchHome();
        }
    }

}

最后再来一张图体会一下多态的强大：：：：：

面向过程和面向对象区别

我们都常听到软件设计思想有面向对象和面向过程。那么什么是面向对象、什么是面向过程呢？

接下来我举个例子说明一下他们两者的区别。

  有一天你想吃鱼香肉丝，怎么办，有两个选择。

 第一：自己买鱼、肉丝、调料、胡萝卜等其他配菜，然后洗菜，开炒，装盘。

 第二：去饭店，“老板，给我来一份鱼香肉丝”。

那么这两种有什么区别呢？很显然，第一种是面向过程思想，第二种是面向对象思想。

面向对象有什么优势呢？

 首先不需要知道鱼香肉丝是怎么做的，降低了耦合性，如果有一天不喜欢吃鱼香肉丝了，喜欢吃番茄炒蛋的话，对于一来说，有点难了，需要从新买菜。对于第二来说，好，马上换就可以了。提高了可维护性，总的来说，降低了耦合度，提高了可维护性。

面向对象是具体化的，流程化的，解决一个问题，需要一步一步分析，一步一步实现。

面向对象是模型化的，只要出现出一个类，密封好，等需要用的时候直接用就可以了，不需要要一步一步实现。

面向过程优点和缺点：

  优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较浪费资源。

  缺点：不易维护、不易复用、不易扩展

面向对象优点和缺点：

  优点：易维护、易复用、易扩展、面向对象有封装、继承、多态的特征，可以设计出低耦合的系统，使系统更加灵活、易于维护。

  缺点：性能比面向过程差

二、面向对象三大特征：封装、继承、多态

 1、封装

  所谓的封装，就是把客观的事物封装成抽象类，例如把密某个人需要做某件事，我们把某个人看成一个类，把他需要用的工具带在身上，他用到的方法装在脑子里，我不管他是怎么完成这件事的，他只要给我返回这件事的结构就可以了，不需要关心这件事怎么做，这就是封装。

2、继承

    继承有这样一种能力，就是使用现有允许使用的功能。并不需要重新编写这些类已经有的功能。通过继承创建了新的类成为子类或派生类。被继承的成为基类。继承有两种，一种是实现继承，另一种是接口继承。

         实现继承：可以直接使用基类的属性和方法，无需额外编码。

         接口继承：是指使用属性和方法的名称，但是子类必须提供实现的能力。

2、多态

  所谓的多态就是对一个实例的相同方法在不同的情况下有不同表现形式。多态机制使得不同内部结构的对象可以共享相同的外部接口。这意味着，虽然不同类的内部操作不同，但是可以通过一个公共类，他们可以通过相同的方法给与调用。