一、面向对象介绍

二、为什么要用面向对象开发

三、封装、继承、多态、类、方法

　　面向过程和面向对象的区别

　　编程范式：

　　　　一般情况下，拿到一个项目不同的两个人有不同的编写方式（相同的是固定的语法、数据结构）。对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别，就是编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路， 大多数语言只支持一种编程范式，当然也有些语言可以同时支持多种编程范式。 两种最重要的编程范式分别是面向过程编程和面向对象编程。

　　面向过程（Procedural Programming）：

　　　　所谓的面向过程，就是为了完成一个需求，将一个大的需求，分成不同的模块，甚至更小的模块（方法）里面，然后程序从上往下一步一步的完成计算执行。一般学基础的同学都这么写，但是有个问题存在。大家写的都是一个模块（方法）调用下一个模块的结果，可能多个方法都取一个函数的执行结果。试想一下，如果我需要增加或减少一个功能，凡是调用这个函数（方法）结果的函数都需要进行修改。这样傻瓜式的编写过程特别不实用，如果写脚本还能凑合着用。如果做个项目呢，经常有不同的需求，这样的话等于在给自己挖坑。这就可以理解为是面向过程编程。

　　面向对象（Object-Oriented Programming ）：

　　　　OOP编程就是“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

　　　　世界万物，皆可分类。世界万物，皆为对象。只要是对象，就肯定属于某种品类。只要是对象，就肯定有属性。

　　面向对象特性：

　　Class 类
　　　　一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性、共同的方法。其实就是把多个有相同属性的事物抽象出来，然后定义一个类别。

　　Object 对象 
　　　　一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同。其实就是定义一个类以后，你类里面给这个事物定义的一些方法（其实就是属性）。定义好类了，得实现吧，例如这个类就是造机器，造出的机器就是对象，也就是实例。

　　Encapsulation 封装
　　　　在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。封装就是把内部不想给外部看到的数据进行封锁，只有内部可以查看调用，外部找不到。

　　Inheritance 继承
　　　　一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

　　Polymorphism 多态
　　　　态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。
　　　　编程其实就是一个将具体世界进行抽象化的过程，多态就是抽象化的一种体现，把一系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进行对　话。

　　　　举个列子：发送一个指令，比如说我是老板要建一栋楼房。销售要去卖楼房，承包商要买材料，承包商要找工人。我只说句话，他家都分头开始工作，而不是我要一个一个的去督促说明。

  1.  class Dos:#定义一个类狗
  2.      def bulk(self):#类里面有对象狗，会叫吧
  3.          print("叫一声")#具体怎么叫
  4.  
  5.  d1 = Dos()#生成一条狗
  6.  d2 = Dos()#再生成一条狗
  7.  d3 = Dos()#再来一条狗
  8.  
  9.  d1.bulk()#狗1叫
  10.  d2.bulk()#狗2叫
  11.  d3.bulk()#狗3叫
  12.  >>>叫一声
  13.  >>>叫一声
  14.  >>>叫一声
    简单的一个类就定义完了
  1.  class Dos:
  2.      def __init__(self,name):#这个类实例化，其实就是给类传值
  3.          self.name = name
  4.  
  5.      def bulk(self):
  6.          print("%s叫一声"%self.name)
  7.  
  8.  d1 = Dos("狗一")
  9.  d2 = Dos("狗二")
  10.  d3 = Dos("狗三")
  11.  
  12.  d1.bulk()
  13.  d2.bulk()
  14.  d3.bulk()
  15.  >>>狗一叫一声
  16.  >>>狗二叫一声
  17.  >>>狗三叫一声
  1.  类变量和实例变量的优先
  2.  #!/usr/bin/env python
  3.  class Person(object):
  4.      n = 234#类变量
  5.      def __init__(self,name,age):
  6.          self.name = name
  7.          self.age = age
  8.          self.n = 123#实例变量
  9.  
  10.      def Leader(self):
  11.          print("这里是定义领导[%s]的方法"%self.name)
  12.  
  13.  r1 = Person("哈哈哈","")#传参数给类，让它实例化
  14.  
  15.  print(r1.name,r1.n,r1.age)#打印实例参数，如果我把self.n注释掉，它肯定会去类变量取到值为234这个变量。所以得出，先找实例变量，再找类变量。
  16.  print(Person.n)#打印类变量的方法
  17.  >>>哈哈哈 123 11
  18.  >>>234
  1.  #为什么要用类变量呢，有人说我可以在初始化时候给他定义一个默认参数如下，def __init__(self,name,age,n = "baidu"),
  2.  如果这是一个百度公司的员工信息表，我只需要每次给每个人引用n这个变量就可以给他加上说，昂，这是百度公司，但你要是直接写人默认参数，他每次都要初始化一次，这样效率明显降低。
  3.  class Person(object):
  4.      n = "baidu"#类变量
  5.      def __init__(self,name,age):
  6.          self.name = name
  7.          self.age = age
  8.  
  9.      def Leader(self):
  10.          print("这里是定义领导[%s]的方法"%self.name)
  11.          print(Person.n)
  12.  
  13.  r1 = Person("哈哈哈","")
  14.  d1 = r1.Leader()

　　析构函数：

　　　　在实例释放、销毁的时候执行。通常做一些收尾工作。例如，程序执行完毕后，关闭数据库连接等收尾工作。

　　

  1. #析构函数，首先给类传参，执行里面一个方法，然后删除r1，然后再定义r2给类传参，再执行里面的一个方法。看结果。。
  2. class Person(object):
  3.     n = "baidu"#类变量
  4.     def __init__(self,name,age):
  5.         self.name = name
  6.         self.age = age
  7.  
  8.     def __del__(self):
  9.         print("程序执行完毕")
  10.  
  11.     def Leader(self):
  12.         print("这里是定义领导[%s]的方法"%self.name)
  13.  
  14. r1 = Person("哈哈哈","")
  15. d1 = r1.Leader()
  16. del  r1
  17. r2 = Person("呵呵","")
  18. d1 = r2.Leader()
  19. >>>这里是定义领导[哈哈哈]的方法
  20. >>>程序执行完毕#del r1的结果，我们说了析构函数是实例释放或销毁时候执行，所以当销毁r1是后，自动执行了析构函数
  21. >>>这里是定义领导[呵呵]的方法
  22. >>>程序执行完毕#同上，在实例执行结尾的时候执行

　　私有属性：

　　　　我们知道有些参数我们只想让内部更改，外部职能看（当然内部也是可以更改的），那怎么办的，我们就用到了私有属性。

  1.  class Person(object):
  2.      n = "baidu"#类变量
  3.      def __init__(self,name,age,money):
  4.          self.name = name
  5.          self.age = age
  6.          self.__money = money
  7.  
  8.      def Leader(self):
  9.          print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))
  10.  
  11.  r1 = Person("A","",30000)
  12.  d1 = r1.Leader()
  13.  >>>领导A 工龄11年 月薪30000元
  14.  r1.name = "B"
  15.  r1.age =  33#更改了工龄，看结果也执行成功了
  16.  r1.__money  = ""#把月薪该一下，我靠，前面加了__就上天了，不让改了，这下明白私有属性了吧
  17.  d1 = r1.Leader()
  18.  >>>领导B 工龄33年 月薪30000元
  1.  class Person(object):
  2.      n = "baidu"#类变量
  3.      def __init__(self,name,age,money):
  4.          self.name = name
  5.          self.age = age
  6.          self.__money = money
  7.  
  8.      def Leader(self):
  9.          print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))
  10.  
  11.      def Change(self):
  12.          pass
  13.  
  14.  r1 = Person("A","",30000)
  15.  # d1 = r1.Leader()
  16.  print(r1.name,r1.age)
    >>>A 11
  17.  print(r1.__money)#AttributeError: 'Person' object has no attribute '__money',提示没有该属性

问题来了，那如果我非要改这个属性该怎么办呢？

  1.  #外部查看修改不了，我就在类的内部定义一个方法，让它在内部更改
    我们知道属性分静态属性（就是变量）和动态属性（其实就是类下面的方法）
  2.  
  3.  class Person(object):
  4.      n = "baidu"#类变量
  5.      def __init__(self,name,age,money):
  6.          self.name = name
  7.          self.age = age
  8.          self.__money = money#在属性名前加两个下滑线
  9.  
  10.      def Leader(self):
  11.          print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))
  12.  
  13.      def Change(self):#定义的方法可以访问私有属性
  14.          self.__money -= 10000
  15.          print("领导%s表现不好 工龄%s  月薪涨到%s"%(self.name,self.age,self.__money))
  16.  
  17.  r1 = Person("A","",30000)
  18.  d1 = r1.Change()
    >>>>领导A表现不好 工龄11  月薪涨到20000
    这就相当于封装了。

　　

　　私有方法：
　　　　说白了就是在类内部定义方法，只不过就是这个方法外部访问调用不了。我们知道私有属性是在属性前加两个下划线。那方法也是

　

  1.  class Person(object):
  2.      n = "baidu"#类变量
  3.      def __init__(self,name,age,money):
  4.          self.name = name
  5.          self.age = age
  6.          self.__money = money
  7.  
  8.      def Leader(self):
  9.          print("领导%s 工龄%s年 月薪%s元"%(self.name,self.age,self.__money))
  10.  
  11.      def __Change(self):
  12.          self.__money -= 10000
  13.          print("领导%s表现不好 工龄%s  月薪涨到%s"%(self.name,self.age,self.__money))
  14.  
  15.  r1 = Person("A","",30000)
  16.  d1 = r1.Change()
  17.  》》》AttributeError: 'Person' object has no attribute 'Change'
  18.  方法前加了两个下划线外部就访问不了了

　　继承：

　　　　

  1.  class People(object):
  2.      def __init__(self,name,age):
  3.          self.name = name
  4.          self.age = age
  5.  
  6.      def eat(self):
  7.          print("%s eating %s"%(self.name,self.age))
  8.  
  9.      def sleep(self):
  10.          print("%s sleep %s"%(self.name,self.age))
  11.  
  12.  class Man(People):#括号了写的是继承谁，就写谁是父类
  13.      pass
  14.  
  15.  m1 = Man("zhangsan",33)
  16.  m1.eat()
  17.  #简单的继承，我给类Man传两个参数
  18.  执行类People里面的eat方法
  1.  class People(object):
  2.      def __init__(self,name,age):
  3.          self.name = name
  4.          self.age = age
  5.  
  6.      def eat(self):
  7.          print("%s eating %s"%(self.name,self.age))
  8.  
  9.      def sleep(self):
  10.          print("%s sleep %s"%(self.name,self.age))
  11.  
  12.  class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
  13.      def Write_code(self):
  14.          print("name:%s write code %s行 "%(self.name,self.age))
  15.  
  16.  m1 = Man("zhangsan",33)#我给类Man传参数，但是他继承的是People类，所以也就等于这里是给People传参数，但它继承了People类，所以这里就等于给自己传参数
  17.  m1.eat()
  18.  m1.Write_code()#男人需要干嘛呢，写代码。
  19.  >>>zhangsan eating 33
  20.  >>>name:zhangsan write code 33行 
  1. #如果我在父类里面定义了一个eat，但是我子类里面再定义一个eat，他会执行谁呢？
  2. class People(object):
  3.     def __init__(self,name,age):
  4.         self.name = name
  5.         self.age = age
  6.  
  7.     def eat(self):
  8.         print("%s eating %s"%(self.name,self.age))
  9.  
  10.     def sleep(self):
  11.         print("%s sleep %s"%(self.name,self.age))
  12.  
  13. class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
  14.     def Write_code(self):
  15.         print("name:%s write code %s行 "%(self.name,self.age))
  16.  
  17.     def eat(self):
  18.         print("eating。。。。。。。。")
  19.  
  20. m1 = Man("zhangsan",33)
  21. m1.eat()
  22. m1.Write_code()
  23. >>>eating。。。。。。。。#答案告诉我们，执行的是子类里面的eat
  24. >>>name:zhangsan write code 33行 
  1.  #如果我不想单独执行父类里面的方法，或者单独执行子类里面的方法。我想让他们同时开始工作
  2.  class People(object):
  3.      def __init__(self,name,age):
  4.          self.name = name
  5.          self.age = age
  6.  
  7.      def eat(self):
  8.          print("%s eating %s"%(self.name,self.age))
  9.  
  10.      def sleep(self):
  11.          print("%s sleep %s"%(self.name,self.age))
  12.  
  13.  class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
  14.      def Write_code(self):
  15.          print("name:%s write code %s行 "%(self.name,self.age))
  16.  
  17.      def eat(self):
  18.          People.eat(self)#只需要在这里加上父类的相同方法
  19.          print("eating。。。。。。。。")
  20.  
  21.  m1 = Man("zhangsan",33)
  22.  m1.eat()
  23.  >>>zhangsan eating 33
  24.  >>>eating。。。。。。。。
  1. #首先定义了一个父类，下面定义两个子类（男人和女人）
  2. class People(object):
  3.     def __init__(self,name,age):
  4.         self.name = name
  5.         self.age = age
  6.  
  7.     def eat(self):
  8.         print("%s eating %s"%(self.name,self.age))
  9.  
  10.     def sleep(self):
  11.         print("%s sleep %s"%(self.name,self.age))
  12.  
  13. class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
  14.     def Write_code(self):
  15.         print("name:%s write code %s行 "%(self.name,self.age))
  16.  
  17.     def eat(self):
  18.         People.eat(self)
  19.         print("eating。。。。。。。。")
  20.  
  21. class Woman(People):
  22.     def shopping(self):
  23.         print("name:%s go shopping %s行 "%(self.name,self.age))
  24.  
  25. m1 = Man("zhangsan",33)
  26. m1.eat()
  27. m1.Write_code()
  28. w1 = Woman("lisi",23)
  29. w1.shopping()
  30.  
  31. >>>zhangsan eating 33
  32. >>>eating。。。。。。。。
  33. >>>name:zhangsan write code 33行
  34. >>>name:lisi go shopping 23行

重构：

  1.  class People(object):
  2.      def __init__(self,name,age):
  3.          self.name = name
  4.          self.age = age
  5.  
  6.      def eat(self):
  7.          print("%s eating %s"%(self.name,self.age))
  8.  
  9.      def sleep(self):
  10.          print("%s sleep %s"%(self.name,self.age))
  11.  
  12.  class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
  13.      def __init__(self,name,age,money):#我想在Man这个子类里面再单独添加一个参数，但如果直接在父类里面添加的话，Woman这个子类也就跟着添加了，但是我只想子啊Man类里面添加这个参数。所以涉及到了重构，单独给Man这个类添加一个参数
  14.          People.__init__(self,name,age)
  15.          self.money = money
  16.          print("name ：%s age ：%s %s元"%(self.name,self.age,self.money))
  17.  
  18.      def Write_code(self):
  19.          print("name:%s write code %s行 "%(self.name,self.age))
  20.  
  21.      def eat(self):
  22.          People.eat(self)
  23.          print("eating。。。。。。。。")
  24.  
  25.  class Woman(People):
  26.      def shopping(self):
  27.          print("name:%s go shopping %s行 "%(self.name,self.age))
  28.  
  29.  m1 = Man("zhangsan",33,10000)
  30.  m1.eat()
  31.  >>>name ：zhangsan age ：33 10000元
  32.  >>>>zhangsan eating 33
  33.  >>>>eating。。。。。。。。
  1.  #!/usr/bin/env python
  2.  class People(object):
  3.      def __init__(self,name,age):
  4.          self.name = name
  5.          self.age = age
  6.  
  7.      def eat(self):
  8.          print("%s eating %s"%(self.name,self.age))
  9.  
  10.      def sleep(self):
  11.          print("%s sleep %s"%(self.name,self.age))
  12.  
  13.  class Man(People):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
  14.      def __init__(self,name,age,money):
  15.          # People.__init__(self,name,age)#这样的话我需要知道父类的名称，如果继承的多的话，我就全部都得改
  16.          super(Man,self).__init__(name,age)#super诞生后，我们就不用考虑父类名称
  17.          self.money = money
  18.          print("name ：%s age ：%s %s元"%(self.name,self.age,self.money))
  19.  
  20.      def Write_code(self):
  21.          print("name:%s write code %s行 "%(self.name,self.age))
  22.  
  23.      def eat(self):
  24.          People.eat(self)
  25.          print("eating。。。。。。。。")
  26.  
  27.  class Woman(People):
  28.      def shopping(self):
  29.          print("name:%s go shopping %s行 "%(self.name,self.age))
  30.  
  31.  m1 = Man("zhangsan",33,10000)
  32.  m1.eat()
  33.  w1 = Woman("lisi",23)
  34.  w1.shopping()
  35.  >>>name ：zhangsan age ：33 10000元
  36.  >>>zhangsan eating 33
  37.  >>>eating。。。。。。。。
  38.  >>>name:lisi go shopping 23行

　　多继承：

  1.  class People(object):
  2.      def __init__(self,name,age):
  3.          self.name = name
  4.          self.age = age
  5.  
  6.      def eat(self):
  7.          print("%s eating %s"%(self.name,self.age))
  8.  
  9.      def sleep(self):
  10.          print("%s sleep %s"%(self.name,self.age))
  11.  
  12.  class Relatione(object):#定义一个交朋友的类
  13.      def make_friends(self,obj):
  14.          print("%s 跟 %s 交朋友"%(self.name,obj.name))
  15.  
  16.  class Man(People,Relatione):#父类写了人的两个共性，吃喝睡，凡是人都需要吃喝睡。
  17.      def __init__(self,name,age,money):
  18.          # People.__init__(self,name,age)#这样的话我需要知道父类的名称，如果继承的多的话，我就全部都得改
  19.          super(Man,self).__init__(name,age)#super诞生后，我们就不用考虑父类名称
  20.          self.money = money
  21.  
  22.      def Write_code(self):
  23.          print("name:%s write code %s行 "%(self.name,self.age))
  24.  
  25.      def eat(self):
  26.          People.eat(self)
  27.          print("eating。。。。。。。。")
  28.  
  29.  class Woman(People,Relatione):
  30.      def shopping(self):
  31.          print("name:%s go shopping %s行 "%(self.name,self.age))
  32.  
  33.  m1 = Man("zhangsan",33,10000)
  34.  w1 = Woman("lisi",23)
  35.  m1.make_friends(w1)
    >>>zhangsan 跟 lisi 交朋友

　　

　　新式类和经典类的区别：

　　　　新式类：

　　　　class name（object）：

  1. class B(A):
  2.     pass
  3.     # def __init__(self):
  4.     #     print("B")
  5.  
  6. class C(A):
  7.     # def __init__(self):
  8.     #     print("C")
  9.  
  10. class D(B,C):
  11.     pass
  12.  
  13. obj = D()
  14. #如果ABCD都打开，执行后，首先从左往右先打印的是B，因为D继承了B，C。如果B不执行，就执行C，如果我C也注释不执行，C继承了A，就会打印A

　　　　class name（）：#没有了object

　　看上面的例子，如果B类不执行，就直接找A了，就不会再找C类了。

　　　　总结：

　　　　　　经典类是深度优先，新式类是广度优先。

　　

　　

　　　　

　　　　

Python之路-python(面向对象一)的更多相关文章

  1. 自学Python之路-Python基础+模块+面向对象+函数

    自学Python之路-Python基础+模块+面向对象+函数 自学Python之路[第一回]:初识Python    1.1 自学Python1.1-简介    1.2 自学Python1.2-环境的 ...

  2. （转）Python之路,Day6 - 面向对象学习

    本节内容:   面向对象编程介绍 为什么要用面向对象进行开发? 面向对象的特性:封装.继承.多态 类.方法.     引子 你现在是一家游戏公司的开发人员,现在需要你开发一款叫做<人狗大战> ...

  3. Python之路Python作用域、匿名函数、函数式编程、map函数、filter函数、reduce函数

    Python之路Python作用域.匿名函数.函数式编程.map函数.filter函数.reduce函数 一.作用域 return 可以返回任意值例子 def test1(): print(" ...

  4. 自学Python之路-Python核心编程

    自学Python之路-Python核心编程 自学Python之路[第六回]:Python模块       6.1 自学Python6.1-模块简介    6.2 自学Python6.2-类.模块.包  ...

  5. 自学Python之路-Python并发编程+数据库+前端

    自学Python之路-Python并发编程+数据库+前端 自学Python之路[第一回]:1.11.2 1.3

  6. 自学Python之路-Python网络编程

    自学Python之路-Python网络编程 自学Python之路[第一回]:1.11.2 1.3

  7. Python之路Python文件操作

    Python之路Python文件操作 一.文件的操作 文件句柄 = open('文件路径+文件名', '模式') 例子 f = open("test.txt","r&qu ...

  8. Python之路Python内置函数、zip()、max()、min()

    Python之路Python内置函数.zip().max().min() 一.python内置函数 abs() 求绝对值 例子 print(abs(-2)) all() 把序列中每一个元素做布尔运算, ...

  9. Python之路Python全局变量与局部变量、函数多层嵌套、函数递归

    Python之路Python全局变量与局部变量.函数多层嵌套.函数递归 一.局部变量与全局变量 1.在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量.全局变量作用域是整个程序,局 ...

  10. python之路----初识面向对象（二）

    类命名空间与对象.实例的命名空间 创建一个类就会创建一个类的名称空间,用来存储类中定义的所有名字,这些名字称为类的属性 而类有两种属性:静态属性和动态属性 静态属性就是直接在类中定义的变量 动态属性就 ...

随机推荐

  1. 利用mysqldump 将一个表按条件导出数据

    mysqldump -uroot -pdsideal -t dsideal_db t_resource_info --where="res_type=1 and group_id=1 and ...

  2. CentOS下强行umount卸载设备

    fuser -cu /usr/local/tomcat7/webapps/dsideal_yy/html/down/ fuser -ck /usr/local/tomcat7/webapps/dsid ...

  3. git 设置多项目实现多账号登陆

    9:45 2015/11/18git 设置多项目时实现多账号用户登陆git config --global user.name "your_name" git config --g ...

  4. Android --自定义简单Toast

    1. 效果图

  5. winform学习之-----小知识（20160624）

    一.//判断是否按下回车键if(e.KeyCode == Keys.Enter){   pictureBoxKeyDownLogin_Click(sender,e);}或是e.KeyCode == K ...

  6. Java中系统属性Properties介绍 System.getProperty()参数大全

       在JDK文档中System类中有这样的方法getProperties()在此方法的详细介绍中有下面的参数可供使用: java.version Java 运行时环境版本 java.vendor J ...

  7. 关于tag标签系统的实现

    实验室的项目,需要做对用户发布的主题进行打标签的功能,纠结甚久,实现思路如下: 一.数据库表的设计 1.tag表 create table qa_tag ( tag_id int primary ke ...

  8. Address already in use:JVM_Bind

    1.原因:端口被占用 2.解决方式: 方式一:重启电脑 方式二:方式一不行执行方式二 双击Tomcat server   将Ports下HTTP/1.1对应的Port Number 改为其他值 备注: ...

  9. Webform——中国省市三级联动以及IsPostBack

    首先要明白Webform的运行顺序,当开始启动时候,首先执行的是Page_Load事件, 当点击任意按钮后,每次点击都要先执行一遍Page_Load(在这里Page_Load里面的事件是给数据控件加载 ...

  10. SQL server 子查询、设置主键外键、变量及变量查询

    一.子查询 子查询,又叫做嵌套查询. 将一个查询语句做为一个结果集供其他SQL语句使用,就像使用普通的表一样,被当作结果集的查询语句被称为子查询. 子查询有两种类型: 一种是只返回一个单值的子查询,这 ...