1，如何理解面向对象？
 
（1）面向对象的特点
 
它是一种思想，它可以使复杂的问题简单化，
 
它可以实现角色转变，是我们从执行者转变为指挥者
 
（2）举例说明（结合实际场景，遇到什么场景就举什么例子）
 
例子1：
 
现在这场面试其实就是在运用面向对象的思想在解决问题，公司老板招聘员工代表公司的业务量大，公司蒸蒸日上在发展，公司需要找一些具备专业知识的对象来完成公司的工作，我们中的某些人就是这个对象，具备这些专业的知识，您就可以指挥这些人来完成这些工作，为公司创造业
 
绩
 
 相对来说，如果是面向过程，公司的老板做这些业务，完成这些工作量，就需要具备的这些专业知识，熟悉完成这些业务的
 
每一个过程。
 
 老板通过雇佣员工，使用员工的能力，将复杂的问题简单化，同时也从程序的执行者变成了指挥者。
 
 

 

面向对象程序设计的4个主要特点是什么？
 
抽象
 
封装
 
继承
 
多态
 
类和对象体现了抽象和封装
 
基于以上四点的程序称为面向对象的程序设计。
 
什么是类？
 
前边我们学习过c++中的结构体，struct的使用是先声明，然后定义一个该结构体的变量，最后再初始化（赋值）
 
其实结构体的声明当中有很多不同数据类型的成员，在一个结构体当中，这就是对属性的封装，但是结构体与类相比较，还缺少了一个重要的环节，结构体当中只有属性，只封装了属性，但没有封装相应的操作，也就是没有封装操作成员属性的函数。
 
类当中有两个方面，一是封装属性，二是封装函数。在自己声明的类当中要既有属性又有函数，这就是类。
 
什么是对象？
 
在结构体中声明一个结构体就相当于我们设计了一个类，定义一个结构体就相当于我们定义了一个对象
 
比如 声明一个结构体相当于封装了一个类（但缺少相应的操作）
 
struct Student{
 
private int num;
 
string name;
 
float score;
 
string address;
 
这里如果再有函数就是一个类了
 
};
 
定义给两个结构体，相当于我们定义了两个对象
 
Student student1，student2；
 
初始化结构体，相当于对象的初始化
 
 
 
 
客观世界中任何一个事物都可以看成一个对象（Object），对象可以是自然物体（如汽车、狗熊）也可以是一种逻辑(如班级、连队）。
 
任何一个对象都有两个要素：一个是静态特征，如班级专业，班级人数，所在教室，这种静态特征称为属性。
 
                                             一个是动态特征，如班级学习、班级开会、班级体育比赛，这种动态特征称为行为（或功能）。
 
封装的意义？
 
把一部分或全部属性和部分功能（函数）对外界屏蔽，就是从外界（类的大括号之外）看不到，不可知，这就是封装的意义。
 
实际上就是用了一个后边会介绍的关键字 private 私有化关键字来完成，就是隐蔽，比如账号的密码，你如果玩网络游戏，你的账号密码别人都可以看到，访问，所以要把它封装。
 
封装两个方面的含义：一是将有关数据和操作代码封装在对象当中，形成一个基本单位，各个对象之间相对独立互不干扰。
 
                                   二是将对象中某些属性和操作私有化，已达到数据和操作信息隐蔽，有利于数据安全，防止无关人员修改。
 
 
 
 
类与对象之间的关系是什么？
 
程序设计当中，常用到抽象这个词，这个词就是解释类与对象之间关系的词。
 
类与对象之间的关系就是抽象的关系。
 
一句话来说明：类是对象的抽象，而对象则是类得特例，即类的具体表现形式。
 
举例说明上面的那句话：
 
我们都是人类，人类是不是有自己的属性，属性有年龄、名字、ID、性别，人类是不是有功能，即操作能力，能说话、能吃饭、能睡觉，能思考解决问题。
 
我们大家都是人类，我们彼此却又不相同，我们每一个人具有自己的属性的能力，每一个人就是人类的某一个对象。
 
把我们共同的属性和功能向上抽取，这就是抽象，抽象程一个人类。
 
 
 
 
继承
 
面向对象的继承是为了软件重用，简单理解就是代码复用，把重复使用的代码精简掉的一种手段。
 
如何精简，当一个类中已经有了相应的属性和操作的代码，而另一个类当中也需要写重复的代码，那么就用继承方法，把前面的类当成父类，后面的类当成子类，子类继承父类，理所当然。就用一个关键字extends就完成了代码的复用。
 
 
 
 
多态
 
没有继承就没有多态，继承是多态的前提。
 
举例来说明多态
 
猫、狗、鸟都是动物
 
动物不同于植物，猫、狗、鸟都可以叫、都可以吃
 
这些功能可以同时继承自动物类，猫类、狗类、鸟类都是动物类的子类
 
但是猫的叫声是“喵喵喵” ，狗的叫声是“汪汪汪”，鸟的叫声是“吱吱支”
 
猫爱吃鱼，狗爱吃骨头，鸟爱吃虫子
 
这就是虽然继承自同一父类，但是相应的操作却各不相同，这叫多态。
 
由继承而产生的不同的派生类，其对象对同一消息会做出不同的响应。
 
 
 
 
知道了以上概念就可以进行面向对象编程（Object Oriented Programming，简称OOP）
 
现在开始声名一个学生类：
 
class  Student{
 
int num;
 
string name;
 
char sex;
 
void display(){
 
cout<<"num:"<<num<<endl;
 
cout<<"name:"<<name<<endl;
 
cout<<"sex:"<<sex<<endl;
 
}
 
}；
 
封装一个类，然后用这个类定义两个对象
 
Student student1,student2;
 
如果是重要或是私有的信息，不让外界知道，可以进行私有化处理：
 
class {
 
private：
 
int num;
 
string name;
 
char sex;
 
public：
 
void display(){
 
cout<<"num:"<<num<<endl;
 
cout<<"name:"<<name<<endl;
 
cout<<"sex:"<<sex<<endl;
 
}
 
}student1，student2；
 
在C++中如果不定义private和public，则系统默认为是私有。
 
还可以用无名类来定义对象，必须要求封装类之后同时定义对象。
 
 
 
 
对象成员的引用或初始化
 
私有化的不可以这样写
 
不能 student1.num=100001；student1.name=”张三";针对于public:
 
对象调用函数 student1.display();
 
 

1.面向对象程序设计有三大特点，分别是封装，继承，多态，接下来就介绍一下这三个特点，积累一下。
 
2.封装，封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体是类，类通常对用户隐藏其实现的细节，这就是封装的思想，在Java中通常通过建立一个实体类，用来封装对象的属性和行为，通过setXxx()和getXxx()方法封装起来，例如，用户在使用一款软件的时候，只需知道如何使用软件，点击某个按钮就可以实现一定的功能，用户不需要知道软件是如何被开发出来的，软件内部是如何工作的，在使用该软件时不依赖于开发时的细节和软件内部工作的细节。
 
采用封装的思想保证了类内部数据结构的完整性，应用该类的用户不能轻易直接操纵该数据结构，而只能执行该类允许公开的数据。这样可以避免外部对内部数据的影响，提高程序的可维护性。
 
总结一下，封装性就是利用抽象数据类型将数据和基于数据的操作封装在一起，保护数据并隐蔽具体的细节，只保留有限的接口与外界联系。
 
接下来附上一个封装的例子，定义一个实体类，声明属性为私有的，通过setXxx()和getXxx()的公共方法来封装数据(即封装属性)，利用this关键字来引用成员变量，最后通过建立一个测试类来调用setXxx()和getXxx()方法，其中实体类中有两个构造方法，一个为无参构造方法，一个为有参构造方法，代码如下所示：
 
 
Student.java文件，实体类代码：
 
package tom.bean;

/*
 * 学生实体类
 */
public class Student {
	private String name;// 声明一个私有字符串变量，表示姓名
	private int age;// 声明一个私有整型变量，表示年龄
	private String sex;// 声明私有一个私有字符串变量，表示性别
	private String major;// 声明一个私有字符串变量，表示专业

	public Student() { // 无参构造方法
	}

	public Student(String name, int age, String sex, String major) { // 有参构造方法
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.major = major;
	}

	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 String getSex() {	//获得性别的方法
		return sex;
	}

	public void setSex(String sex) {	//设置性别的方法
		this.sex = sex;
	}

	public String getMajor() {	//获得专业的方法
		return major;
	}

	public void setMajor(String major) {	//设置专业的方法
		this.major = major;
	}

}
 
Test.java文件，测试类代码：
 
 
 
package tom.test;

import tom.bean.Student;

public class Test {
	public static void main(String[] args){
		Student student=new Student();//实例化Student对象
		/*设置各个属性的内容*/
		student.setName("Lc");
		student.setAge(22);
		student.setSex("男");
		student.setMajor("软件工程专业");
		/*获得学生各个属性的内容，打印输出信息*/
		System.out.print("第一位学生的信息如下:"+"\n"+"姓名为"+student.getName());
		System.out.print(",年龄为"+student.getAge());
		System.out.print(",性别为"+student.getSex());
		System.out.print(",专业为"+student.getMajor());
		
		Student student1=new Student("123nh", 21, "女", "英语专业");
		System.out.print("\n");
		System.out.print("第二位学生的信息如下:"+"\n"+"姓名为"+student1.getName());
		System.out.print(",年龄为"+student1.getAge());
		System.out.print(",性别为"+student1.getSex());
		System.out.print(",专业为"+student1.getMajor());
	}
}
 

 运行测试类后结果如下：
 
 
3.继承性，简单来说就是使子类的对象拥有父类的全部属性和行为，同时可以增添自己的所特有的属性和行为。这样可以节省写共同具有的属性和方法代码的时间，有利于代码的复用，这就是继承的基本思想。软件的代码使用继承思想可以缩短软件开发的时间，复用那些已经定义好的类可以提高系统和软件的性能，减少系统和软件在使用过程中出现错误的几率。一个类可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类，继承父类的属性和方法，子类的实例都是父类的实例，但不能说父类的实例是子类的实例。
 
继承的实现，在Java语言中，继承通过extends关键字来实现，用这个extends关键字时指明当前的类为子类，并指明从哪个类继承而来，即在子类的声明中，通过使用extends关键字来指明其父类，其基本格式如下：
 
修饰符 class 子类名 extends 父类名{
 
类体
 
}
 
接下来附上一个小例子，定义一个People类，其中有姓名，年龄和性别属性和setXxx()和getXxx()的方法，作为父类，在定义一个Student类，继承于父类，作为子类，在子类中只定义2个属性，一个学号，一个专业，再定义一个Test测试类，实例化子类，利用子类对象调用父类的属性和方法，具体见代码：
 
目录结构如下图：
 
 
People.java文件代码：
 
package tom.bean;

/*
 * 定义一个人类，作为Student的父类
 */
public class People {
	private String name;//声明一个私有变量，表示姓名
	private int age;//声明一个私有变量，表示年龄
	public String sex="男";//声明一个公有变量，表示性别，初始化为男
	
	public People() {	//无参构造方法
	}

	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 String getSex() {	//获得性别方法
		return sex;
	}

	public void setSex(String sex) {	//设置性别方法
		this.sex = sex;
	}
	
	
}
 

 Student.java文件代码：
 
package tom.bean;

/*
 * 定义一个学生类，继承于人类，作为子类
 */
public class Student extends People{
	private String stuId;//声明一个变量，表示学号
	private String major;//声明一个变量，表示专业
	
	public Student(){	//定义无参构造方法		
	}

	public String getStuId() {	//获得学号方法
		return stuId;
	}

	public void setStuId(String stuId) {	//设置学号方法
		this.stuId = stuId;
	}

	public String getMajor() {	//获得专业方法
		return major;
	}

	public void setMajor(String major) {	//设置专业方法
		this.major = major;
	}
	
	
}
 

 Test.java文件的代码：
 
package tom.test;

import tom.bean.Student;

/*
 * 测试类，实例化子类，调用父类的属性和方法，也调用自己所特有的方法
 */
public class Test {
	//主方法
	public static void main(String[] args) {
		Student student = new Student();//实例化Student类
		student.setName("Xg");//调用父类People类的设置姓名的方法
		student.setAge(22);//调用父类People类的设置年龄的方法
		student.setStuId("2012131735");//调用Student类的设置学号的方法
		student.setMajor("软件工程");//调用Student类的设置专业的方法
		/*打印输出学生信息*/
		System.out.println("学生信息如下：");
		System.out.print("姓名为"+student.getName());
		System.out.print("，年龄为"+student.getAge());
		System.out.print("，性别为"+student.sex);
		System.out.print("，学号为"+student.getStuId());
		System.out.print("，专业为"+student.getMajor());
	}
}
 

 运行Test.java文件后，结果如下图所示：
 
 
4.多态性，简单来说就是一个程序中同名的多个不同方法共存的情况，通常使用方法的重载和重写（也叫覆盖）来实现类的多态性，多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类以及相关类，多态的实现并不依赖具体类，而是依赖抽象类和接口，在多态的机制中，父类通常会被定义为抽象类，在抽象类中给出一个方法的标准，而不给出实现的具体过程，通过继承父类来实现，而比抽象类更方便的是将抽象类定义为接口。这里先暂时介绍到这里，多态中使用方法的重写和重载以后在专门写一篇文章！以免这篇文章篇幅过长！
 
5.以上就是面向对象程序设计的三大特点，仅供大家学习参考，写得不好请见谅，如有错误请指出，谢谢！
 

封装
 
# encoding = utf-8

"""
面向对象第一大特征：封装
基于Python3
"""


class CellPhone:
    """
    手机类
    """
    def __init__(self, cell_phone_number):
        self.cell_phone_number = cell_phone_number
        self.battery_percentage = 100

    def dial(self, cell_phone_number):
        print("Calling %s" % cell_phone_number)

    def send_sms(self, cell_phone_number, message):
        print("Sending %s to %s" % (message, cell_phone_number))

    def start_charge(self):
        print("Charging...")

    def stop_charge(self):
        print("Charge Finished")


if __name__ == '__main__':
    P30 = CellPhone("159xxxxxxxx")
    P40 = CellPhone("180xxxxxxxx")
    print("P30 手机号是 %s" % P30.cell_phone_number)
    print("P30 手机还剩余电量 %d" % P30.battery_percentage)

    P40.battery_percentage = 50
    print("P40 手机号是 %s" % P40.cell_phone_number)
    print("P40 手机还剩余电量 %d" % P40.battery_percentage)

    P30.dial(P40.cell_phone_number)
    P40.send_sms(P30.cell_phone_number, "Give u feedback later")
 
继承
 
# encoding = utf-8
from OOP import CellPhone


class SymbianMobilePhone(CellPhone):
    """
    塞班手机
    """
    pass


class SmartMobilePhone(CellPhone):
    """
    智能手机
    """
    def __init__(self, cell_phone_number, os="Android"):
        super().__init__(cell_phone_number)
        self.os = os
        self.app_list = list()
    
    def download_app(self, app_name):
        print("正在下载应用 %s" % app_name)
        
    def delete_app(self, app_name):
        print("正在删除应用 %s" % app_name)
        

class FullSmartMobilePhone(SmartMobilePhone):
    """
    全面屏智能手机
    """
    def __init__(self, cell_phone_number, screen_size, os="Android"):
        super().__init__(cell_phone_number, os)
        self.screen_size = screen_size


class FolderScreenSmartMobilePhone(SmartMobilePhone):
    """
    折叠屏智能手机
    """
    def fold(self):
        print("The CellPhone is folded")
        
    def unfold(self):
        print("The CellPhone is unfolded")

 
多态
 
# encoding = utf-8
class IPhone:
    """
    IPhone基类，具有一个解锁功能
    """
    def unlock(self, pass_code, **kwargs):
        print("解锁IPhone")
        return True


class IPhone5S(IPhone):
    """
    IPhone5S,unlock功能增加了指纹解锁
    """
    def finger_unlock(self, fingerprint):
        return True

    def unlock(self, pass_code, **kwargs):
        fingerprint = kwargs.get("fingerprint", None)
        if self.finger_unlock(fingerprint):
            print("指纹解锁成功")
            return True
        else:
            return super().unlock(pass_code)


class IPhoneX(IPhone):
    """
    IPhoneX, unlock功能增加刷脸解锁
    """
    def face_unlock(self, face_id):
        return True

    def unlock(self, pass_code, **kwargs):
        face_id = kwargs.get("face_id", None)
        if self.face_unlock(face_id):
            print("通过刷脸解锁成功")
            return True
        else:
            super().unlock(pass_code)
 
抽象
 
from abc import ABCMeta, abstractmethod

class MobilePhone(metaclass=ABCMeta):

    @abstractmethod
    def unlock(self, credential):
        pass

class IPhone(MobilePhone):
    def unlock(self, credential):
        print("IPhone解锁")

class IPhone5S(MobilePhone):
    def unlock(self, credential):
        print("5S解锁")

class IPhoneX(MobilePhone):
    def unlock(self, credential):
        print("IPhoneX解锁")

def test_unlock(phone):
    if isinstance(phone, IPhone):
        phone.unlock("......")
    else:
        print("传入的参数必须是MobilePhone类型")
        return False


if __name__ == '__main__':
    phone = IPhone()
    test_unlock(phone)