对象的事件：事件是指对象对于外部动作的响应，当对象发生了某个事件，就会执行相应的代码，这段代码被称为“事件过程”。事件是Visual Basic预先编辑好的并且能够被对象识别的的动作，VB采用的是事件驱动机制，当用户触发了某个事件时，程序就会执行该事件过程下的代码。 例如，用户点击一次按钮，就会触发一次该按钮的单击事件，即Command1_Click事件。 一个事件，就好比一个动作，用户单击按钮是一个事件，双击按钮也是一个事件，按下一个键盘的按键是一个事件，关闭某个窗口也是一个事件。实际上，VB编程的思想就是在于如何编写各种事件下的代码。 事件过程的语法：
Private Sub 对象名称_事件名称()       '响应事件的程序代码End Sub
其中对象名称就是对象的Name属性例如：窗口Form1的双击事件过程为：
Private Sub Form_DblClick()         '响应事件的程序代码End Sub
注意：窗体的事件只要写Form_事件名称即可，不需要写窗体的名称，即不用写成Form1_DblClick()。 通常事件过程的头尾不需要自己编写，只需要在代码区的上方选择相应的对象，再选择相应的事件后，即可自动产生。每个对象都有一个默认事件，在窗体设计界面双击该控件，会自动跳转到该对象的默认事件下，如果没有该事件，则系统会自动创建其默认事件。例如，按钮的默认事件是单击事件，窗体的默认事件是Form_Load()。对象事件练习：目标：设计一个应用程序，当单击窗体时，在窗体上随机位置打印一个五角星，当双击窗体时清除窗体上所有五角星。步骤一：新建一个工程步骤二：进入代码编辑区，写入以下代码：
步骤三：运行程序，查看效果。
本练习，通过对窗体的单击事件和双击事件编程，使学员可以清晰的了解如何创建事件过程，并对于同一个对象的不同事件过程有了初步的认知。每种对象都有很多事件，掌握它们的常用事件含义对于今后使用VB编程是会有很大的作用的，希望大家多去练习掌握。对象的方法：方法是对象所具有的动作，或者说该对象可以执行的功能。对象的方法是VB中已经定义封装好的通用子程序，用户可以直接调用。上面打印五角星的练习中，Form1.cls语句就是清除窗体的方法。使用方法的语句为：
对象名称.方法名称
               例如，让文本框Text1获得焦点的方法为：
Text1.SetFoucs
对象方法的练习：目标：设计一个应用程序，当单击按钮1时，文本框无法输入内容，当单击按钮2时，文本框可以输入内容。步骤一：新建工程，并按下图所示创建控件。
步骤二：进入代码区，分别在按钮一和按钮二的单击事件过程中写入如下代码：
步骤三：运行程序，查看效果好啦，对象的事件和方法就讲到这里，通过这两节课程，相信大家对于VB的对象已经有了一个全面的认识，希望大家多加练习，如果还有疑问可以给我留言，我会及时回复的。接下来的课程会开始讲解VB的标准控件，大家敬请期待哦。

今日背诵小纸条
对象是一组属性+方法的组合，其中可包含基本值、对象和函数
对象的定义
1 对象字面量
var hero{
 name: ‘产品小姐姐’，
 age: 16，
 weapon: [ ‘头盔’, ‘靴子’, ‘盔甲' ]，
 sayHi: function ( ) {
 console.log( this.name + ’很高兴认识你~’ );
 }
};
2 new Object法
var hero = new Object( );
// 其中new是指一种调用构造函数的方法，Object是构造函数名
hero.name = ‘产品小姐姐’;
hero.age = 16;
hero.weapon = [‘头盔’, ‘靴子’, ‘盔甲’];
hero.sayHi = function ( ) {
 console.log( this.name + ‘很高兴认识你’ );
}
3 工厂方法
function creatHero( name, age, weapon ){
 var hero = new Object( );
 hero.name = name;
 hero.age = age;
 hero.weapon = weapon;
 hero.sayHi = function ( ) {
 console.log( this.name + ‘很高兴认识你’ )；
 }
 return hero;
}
var hero1 = creatHero( ‘产品小姐姐’, 16 , [ ‘头盔’, ‘靴子’, ‘盔甲 ’] )；
4 自定义构造(对象)函数法
function Hero( name, age, weapon ){
 this.name = name;
 this.age = age;
 this weapon = weapon;
 this.sayHi = function ( ) {
 console.log( this.name + ‘很高兴认识你’ )；
 }
}
var hero1 = new Hero( ‘产品小姐姐’, 16 , [ ‘头盔’, ‘靴子’, ‘盔甲 ’] )；
对象的调用
· 属性的调用 hero.name; hero[ ‘hero’ ];
· 属性的方法 per-son.sayHi( );
· 构造函数的调用 var hero1 = new Object( ‘产品小姐姐’, 16 , [ ‘头盔’, ‘靴子’, ‘盔甲 ’] );
遍历对象的方法
for in 可以遍历对象的属性
var object = { };
for (var i = 0; i < 10; i++) {
 object[‘a’ + i] = i * 2;
}
for (var key in object) {
 console.log(key + ‘—‘ + object[key]);
}
删除对象
delete hero.name;
 //其中hero.name为对象的属性
说明
为区分函数名，构造函数使用帕斯卡命名，首字母大写，后续每个单词首字母都大写
this代表含义：1) 当在函数中，this指向Window; 2) 当在方法中，this指向的是所属对象；3) 当在构造函数中，this指向构造函数创建的对象
作用域说明
作用域指变量可生效的范围
全局变量：在整体代码中都可生效；
局部变量：只在部分代码片段内可生效，最常见的如函数内部
预解析说明
将变量和函数的声明提升到当前作用域的最上边(不包括赋值和调用)
当变量和函数名称相同时，优先函数

	

Python是一门面向对象的编程语言。
面向对象技术简介
类(class):用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
方法：类中定义的函数。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体外。类变量通常不作为函数变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override),也称为方法的重写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就被称为实例变量，实例变量就是一个用self修饰的变量。
继承：即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个(is-a)"关系(例图，Dog是一个Animal)。
实例化：创建一个类的示例，类的具体对象。
对象：通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。
类的定义：
class ClassName:
.
.
.
类实例化后，可以使用其属性，实际上，创建一个类后可以通过类名访问其属性。
类对象
类对象支持两种操作：属性引用和实例化。
属性引用使用和Python中所有的属性引用一样的标准语法：obj.name。
类对象创建后，类命名空间内所有属性名都是有效属性名。
class MyClass:
i = 1
def fun1(self)
return  ‘hello world’
x = MyClass()
print(‘MyClass类的属性i为：’, x.i)
print(‘MyClass类的方法fun1返回值为：’, x.fun1())
类有一个名为__init__()的特殊方法(构造方法)，该方法在类实例化时会自动调用。如下：
def __init__(self):
self.data = []
类定义了构造方法，如在语句x = MyClass() 中类的实例化操作会自动调用__init__()方法。
__init__()方法可以传递参数。
如：
class Complex():
image =0
real = 0
def __init__(self, realpart, imagpart)
self.r = realpart
self.i = imagpart
x = Complex(2, 3)
print(x.r, “+”, x.i, “i”)  #输出：2+3i
self代表类的实例，而非类。
类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，按照惯例它的名称是self。
class Test:
def prt(self):
print(self)
print(self.__class__)
t = Test()
t.prt()
执行结果：
__main__.Test
self代表类的实例，代表当前对象的地址，而self.__class__指向类。self不是Python的关键字，可以换成别的名称。
类的方法
在类的内部，使用def关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数self，self代表的是类的实例。
class people:
name = ‘ ’
age = 0
__weight = 0
def __init__(self, n, a, w):
self.name = n
self.age = a
self.__weight = w
def speak(self):
print(“%s 说：我今年 %d 岁”， %(self.name, self.age))
p = people(‘runoob’ , 10, 30)
p.speak()
继承
Python同样支持类的继承，如果一种语言不支持继承，类就没有意义。派生类的定义如下表示：
class DerivedClassName(BaseClassName):
.
.
.
BaseClassName必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用：
class DerivedClassName(modname.BaseClassName)
#类定义
class people:
#定义基本属性
name = ‘ ’
age = 0
#定义私有属性
__weight = 0
#定义构造方法
def __init__(self, n, a, w):
self.name = n
self.age = a
self.__weight =w
def speak(self):
print(“%s 说：我 %d 岁”, %(self.name, self.age))
#单继承示例
class student(people):
grade = ‘’
def __init__(self, n, a, w, g):
people.__init__(self, n, a, w)
self.grade = g
def speak(self):
print(“%s 说：我 %d 岁，我在 %d 年级。”， %(self.name, self.age, self.grade))
s = student(‘ken’, 10, 60, 3)
s.speak()
多继承
Python有限的支持多继承形式。有限的支持多继承是指Python虽然语法上支持多继承，但是却不推荐使用多继承。当一个子类有多个直接的父类时，该子类会继承所有父类的方法，但是如果多个父类有同名的方法，排在前面的父类中的方法会“遮蔽”后面父类中的方法。
多继承的类定义形如下例:
class DerivedClassName(Base1, Base2, Base3):
   .
   .
   .
需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
#!/usr/bin/python
class people:
name = ''
age = 0
__weight = 0
def __init__(self, n, a, w):
 self.name = n
 self.age = a
 self.__weight = w
def speak(self):
 print("%s 说: 我 %d 岁。" %(self.name,self.age))
class student(people):
grade = 0
def __init__(self, n, a, w, g):
 people.__init__(self, n, a, w)
 self.grade = g
def speak(self):
 print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
class speaker:
name = ''
topic = ''
def __init__(self, n, t):
 self.name = n
 self.topic = t
def speak(self):
 print("我叫%s, 我演讲的主题是 %s"%(self.name, self.topic))
class sample(speaker, student):
a = ''   #菜鸟教程上这里定义变量a不知道有啥作用, 删除语句不影响
def __init__(self, n, a, w, g, t):
 student.__init__(self, n, a, w, g)
 speaker.__init__(self, n, t)
test = sample("Tim",25,80,4,"Python")
test.speak()
方法重写
当父类的方法不能满足使用需求，可以在子类中重写父类方法。
#!/usr/bin/python
class parent:
     def method(self):
         print ("这是一个父类方法")
class Child(parent):
     def method(self):
         print ("这是一个子类方法")
c= Child()
c.method()
super(Child,c).method()
super() 函数是用于调用父类(超类)的一个方法。
super() 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
以下是 super() 方法的语法:
super(type[, object-or-type])
参数
type -- 类。
object-or-type -- 类，一般是 self
Python3.x 和 Python2.x 的一个区别是: Python 3 可以使用直接使用 super().xxx 代替 super(Class, self).xxx 。
类属性与方法
类的私有属性
__private_attrs:两个下划线开头，声明该属性为私有，不能在类的外部使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用def关键字来定义方法，与 一般函数不同，类方法必须至少包含一个参数self，self代表类的实例。self 名称并非规定好的，也可以使用this等，但是最好按照约定使用self。
类的私有方法
__private_method:两个下划线开头，声明该方法为私有方法，只能在类的内部调用，不能在类的外部调用。
实例：
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0  # 共有变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)
if __name__ == '__main__':
    counter = JustCounter()
    counter.count()
    counter.count()
    print(counter.publicCount)
    print(counter.__secretCount)   #报错，实例不能访问类的私有变量
输出：
1
2
2
Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/pythonProject1/main.py", line 27, in 
    print(counter.__secretCount)
AttributeError: 'JustCounter' object has no attribute '__secretCount'
类的私有方法实例如下：
class Site:
    def __init__(self, name, url):
        self.name = name
        self.__url = url
    def who(self):
        print('name:', self.name)
        print('url:', self.__url)
    def __foo(self):
        print('这是私有方法')
    def foo(self):
        print('这是公有方法')
        self.__foo()
x = Site('菜鸟教程', 'www.runoob.com')
x.who()
x.foo()
x.__foo()  #报错，外部不能调用私有方法
类的专有方法
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方
运算符重载
通过运算符重载，可以对自己定义的类的实例进行运算符操作。
 算术运算符的重载:
            方法名                  运算符和表达式      说明
            __add__(self,rhs)        self + rhs        加法
            __sub__(self,rhs)        self - rhs         减法
            __mul__(self,rhs)        self * rhs         乘法
            __truediv__(self,rhs)   self / rhs          除法
            __floordiv__(self,rhs)  self //rhs          地板除
            __mod__(self,rhs)       self % rhs       取模(求余)
            __pow__(self,rhs)       self **rhs         幂运算
实例：
# -*- coding: UTF-8 -*-
class Vector:
	    def __init__(self, a, b):
		        self.a = a
		        self.b = b
	    def __str__(self):
		        return 'Vector(%d, %d)'%(self.a, self.b)
	    def __add__(self, other):
		        return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1 + v2)
以上代码执行结果为：
Vector(7, 8)

网络图片
面向对象是几乎所有程序员要掌握的一种思想，也是在开发中有着非常重要的应用，我们常用的编程语言比如Java,C++,C#,PhP,Python等都可以使用面向对象开发出非常强健的代码，几乎所有面向对象的语言都具备三大特性。分别是：封装、继承和多态。在JavaScript中这三种特性仍然非常重要，使用封装，继承，多态的方式可以开发出非常强健的JS代码，提升项目的性能。
我们首先来了解一下封装的相关思想。
1.1. 创建一个类
在JavaScript中创建一个类非常简单，给一个函数取名后赋值给一个变量。初始化后，所有this都会自动指向新创建的实例。
var Product = function(id,name,costPrice){
 this.id = id;
 this.name=name;
 this.costPrice=costPrice;
}
除此之外，我们也可以使用原型方式来定义类的特性：
// 一次设置一个
Product.prototype.getName=function(){
 .....
}
// 或者一次设置多个
Product.prototype={
 getId:function(){
 .... 
 },
 getName:function(){
 .... 
 },
 constructor:Product // 还原构造器
}
定义好类之后，使用new关键字创建实例。有个最大问题是所有属性都对外公开，也就是我们的成本价，对外是透明的。
var product = new Product(1,’手机’,200);
alert(product.costPrice); // 成本价200
网络图片
1.2. 看看封装怎么做
JavaScript提供有以下几种控制方法和属性的权限：
1. 公开级别：对外公开
2. 私有级别：类内部可以访问，对外不公开
var Product = function(id,name,costPrice){
 // 公有属性
 this.name=name;
 // 私有属性
 var _id = id;
 var _costPrice=costPrice;
 // 公有方法
 this.show=function(){
 alert(‘2019年新品：’+this.name+’，价格公道，只要：’+calculatorSalePrice());
 } 
 // 私有方法
 function calculatorSalePrice(){
 return costPrice*4.5; // 一般手机利润是400%左右
 }
 // 特权方法(getter&setter)
 this.setId=function(id){
 _id = id;
 }
 this.getId=function(){
 return _id;
 }
 this.setCostPrice=function(costPrice){
 _costPrice = costPrice;
 }
 // 构造器
 this.setName(name);
 this.setCostPrice(costPrice);
}
我们对类再添加点特殊的内容:
// 类静态公有属性
Product.madeInChina = false;
// 类静态公有方法
Product.SALE =function(){
 console.debug(‘打折了，打折了，买不了吃亏，买不了上当’);
}
// 类原型公有定义
Product.prototype ={
 // 公有属性
 isCellphone ： true,
 // 公有方法
 toString : function(){ 
 }
}
做一个输出：
var p = new Product(5, ’华为P30’, 1200);
console.debug(p.name); // 华为P30
console.debug(p._costPrice); // undeined
console.debug(p.show()); // 2019年新品华为P30，价格公道，只要：5400’
console.debug(p.madeInChina ); // undeined
console.debug(p.isCellphone ); // true
从上面可以看出，对象实例访问不了静态公有属性，但是我们可以这样访问：
console.debug(Product.madeInChina); //false
Product.SALE(); //打折了，打折了，买不了吃亏，买不了上当
网络图片
其实静态方法在系统的类中有非常多的应用，比如大家可以了解String字符串类，有没有类似的静态方法呢，静态方法的作用是什么？？
利用闭包来完成封装，也是在实战应用中经常的开发技术，关于闭包的相关概念和应用，我们在后面的文章中继续给大家分享。
如果您有其他的见解，欢迎在评论区留言，谢谢！