精华内容
下载资源
问答
  • 2019-04-10 20:42:12

    面向对象编程的三大特征:封装、继承、多态

    一:封装
    对于封装而言,一个对象它所封装的是自己的属性和方法,所以他是不需要依赖其他对象就可以完成自己的操作。
    封装的三大好处:
    1、良好的封装能够减少耦合。
    2、类内部的结构可以自由修改。
    3、可以对成员进行更精确的控制。
    4、隐藏信息,实心细节。
    封装可以使我们容易的修改类的内部实现,二无需修改使用了该类的客户代码。
    二:继承
    继承是使用已存在的类定义作为基础建立新类的技术,新类的定义课增加新的数据或新的功能,也可以用父类的功能,但不能选择性的继承父类。
    继承定义了类如何相互关联,共享特征。对于若干相同或者相识的类,我们可以抽象出他们共有的行为或者属相并且将其定义成一个父类或者超类,然后用这些类继承改父类,他们不仅可以拥有父类的属性,方法,还可以定义自己独有的属性或者方法。
    继承需要记住三句话:
    1、子类拥有父类非private的属性和方法。
    2、子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
    3、子类可以用自己的方式实现父类的方法。
    继承少不了三个东西:构造器、protected关键字、向上转型
    构造器(Constructor):
    除了private的属性和方法不能被继承,还有一样子类继承不了------构造器。构造器只能被调动,不能被继承,调用父类的构造器方法,我们使用super()即可。

    对于继承,子类会默认调用父类的构造器,但是如果没有默认的父类构造器,子类必须显示的指定父类的构造器,而且必须是在子类构造器中做的第一件事。

    在讲继承的时候我们就知道父类的私有属性和构造方法并不能被继承,所以 Constructor 也就不能被 override(重写),但是可以 overload(重载),所以你可以看到一个类中有多个构造函数的情况。

    protected关键字:
    对于protected而言,他指明就类用户而言,他是private,但是对于任何继承与此类的子类而言或者其他任何位于同一个包的类而言,他确实可以访问的。
    三:多态
    实现多态有三个必要条件:继承,重写,向上转型
    继承:在多态中必须存在有继承关系的子类和父类。
    重写:子类对父类中某些方法进行重新定义,在调用者些方法时就会调用子类的方法。
    向上转型:在多态中需要将子类的引用赋给父类对象,只有这样改引用才能够具备既能调用父类的方法和子类的方法。
    多态问题????????????
    两个子类A\B继承了父类,A子类要进行微小改变,B子类不需要改变,完全继承父类。所以对A积蓄方法重写,不完全继承父类,从而实现多态。
    实现形式:
    在Java中两种形式可以实现多态:继承和接口
    基于继承实现多态:
    实现机制主要表现在父类和继承该父类的一个或者多个子类对某些方法的重写,多个子类对同一方法重现可以表现不同的行为。
    当子类重写父类的方法被调用时,只有对象继承链中最末端的方法才会被调用。
    对于应用子类的父类类型,在吹引用时,他适用于继承该福诶的所有子类,子类对象不同,对方法的实现也就不同,执行相同动作产生的行为也就不同。
    如果父类是抽象类,那么子类必须实现父类中所有的抽象方法,这样改父类所有的子类一定存在同一的对外接口,但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的同意接口处理该层次的方法。

      基于接口实现多态:
      继承是通过重写父类的同一方法的几个不同子类来体现的,那么就是通过实现接口并覆盖接口同一方法的几个不同类体现的。
      在接口的多态中,只想接口引用必须是指定这实现了接口的一个类的实例程序,在运行时,根据对象引用的实际类型来执行对应的方法。
    

    继承都是单继承,只能为一组相关的类提供一致的服务接口。但是接口可以是多继承,多实现,他能够录用一组相关或者不相关的接口进行组合与扩充,能够对外提供一致的服务接口。

    重载和重写的区别?

    • 重载: 发生在同一个类中,方法名必须相同,参数类型不同、个数不同、顺序不同,方法返回值和访问修饰符可以不同,发生在编译时。

    • 重写: 发生在父子类中,方法名、参数列表必须相同,返回值范围小于等于父类,抛出的异常范围小于等于父类,访问修饰符范围大于等于父类;如果父类方法访问修饰符为 private 则子类就不能重写该方法。

    更多相关内容
  • 面向对象编程三个基本特征

    万次阅读 2016-04-22 13:50:51
    三个基本特征面向对象三个基本特征是:封装、继承、多态。封装封装最好理解了。封装是面向对象特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让...

    基本特征

    面向对象的三个基本特征是:封装继承多态

    封装

    封装最好理解了。封装是面向对象的特征之一,是对象和类概念的主要特性。
    封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

    继承

    面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力:它可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。
    通过继承创建的新类称为“子类”或“派生类”。
    被继承的类称为“基类”、“父类”或“超类”。
    继承的过程,就是从一般到特殊的过程。
    要实现继承,可以通过“继承”(Inheritance)和“组合”(Composition)来实现。
    在某些 OOP 语言中,一个子类可以继承多个基类。但是一般情况下,一个子类只能有一个基类,要实现多重继承,可以通过多级继承来实现。

    继承概念的实现方式有三类:实现继承、接口继承和可视继承。

    • 实现继承是指使用基类的属性和方法而无需额外编码的能力;
    • 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力;
    • 可视继承是指子窗体(类)使用基窗体(类)的外观和实现代码的能力;

    在考虑使用继承时,有一点需要注意,那就是两个类之间的关系应该是“属于”关系。例如,Employee 是一个人,Manager 也是一个人,因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类,因为腿并不是一个人。

    抽象类仅定义将由子类创建的一般属性和方法,创建抽象类时,请使用关键字 Interface 而不是 Class。
    OO开发范式大致为:划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。

    多态

    1、概念
    多态性(polymorphisn)是允许你将父对象设置成为和一个或更多的他的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。

    2、实现方式
    实现多态,有二种方式,覆盖,重载。

    3、覆盖(Override)
    覆盖,是指子类重新定义父类的虚函数的做法。它是覆盖了一个方法并且对其重写,以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现,在接口中一般只是对方法进行了声明,而我们在实现时,就需要实现接口声明的所有方法。除了这个典型的用法以外,我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点:
    1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配,才能达到覆盖的效果;
    2、覆盖的方法的返回值必须和被覆盖的方法的返回一致;
    3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致,或者是其子类;
    4、被覆盖的方法不能为private,否则在其子类中只是新定义了一个方法,并没有对其进行覆盖。

    4、重载(Overload)
    重载,是指允许存在多个同名函数,而这些函数的参数表不同(或许参数个数不同,或许参数类型不同,或许两者都不同)。它是指我们可以定义一些名称相同的方法,通过定义不同的输入参数来区分这些方法,然后再调用时,VM就会根据不同的参数样式,来选择合适的方法执行。在使用重载要注意以下的几点:

    1. 在使用重载时只能通过不同的参数样式。例如,不同的参数类型,不同的参数个数,不同的参数顺序(当然,同一方法内的几个参数类型必须不一样,例如可以是fun(int,float),但是不能为fun(int,int));
    2. 不能通过访问权限、返回类型、抛出的异常进行重载;
    3. 方法的异常类型和数目不会对重载造成影响;
    4. 对于继承来说,如果某一方法在父类中是访问权限是priavte,那么就不能在子类对其进行重载,如果定义的话,也只是定义了一个新方法,而不会达到重载的效果。

    5、区别
    其实,重载的概念并不属于“面向对象编程”,重载的实现是:编译器根据函数不同的参数表,对同名函数的名称做修饰,然后这些同名函数就成了不同的函数(至少对于编译器来说是这样的)。如,有两个同名函数:function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的:int_func、str_func。对于这两个函数的调用,在编译器间就已经确定了,是静态的(记住:是静态)。也就是说,它们的地址在编译期就绑定了(静态绑定),因此,重载和多态无关!真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后,父类指针根据赋给它的不同的子类指针,动态(记住:是动态!)的调用属于子类的该函数,这样的函数调用在编译期间是无法确定的(调用的子类的虚函数的地址无法给出)。因此,这样的函数地址是在运行期绑定的(动态绑定)。

    结论就是:重载只是一种语言特性,与多态无关,与面向对象也无关!引用一句Bruce Eckel的话:“不要犯傻,如果它不是晚邦定,它就不是多态。”

    6、作用
    我们知道,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用!多态的作用,就是为了类在继承和派生的时候,保证使用“家谱”中任一类的实例的某一属性时的正确调用。

    展开全文
  • OOP的特征封装/隐藏(encapsulation)继承(inherit)继承的优点关键字继承的主要特性重写Object类super关键字继承内存图分析继承vs组合final多态必要条件底层实现原理分析 封装/隐藏(encapsulation) 在程序...

    封装/隐藏(encapsulation)

    在程序的设计过程中,为了提高系统安全性及便捷性,我们追求的是 “高内聚、低耦合”
    高内聚:类内部的数据操作细节自己完成,不允许暴露给用户
    低耦合:仅暴露少量方法给用户使用

    在开发过程中,我们一般通过访问修饰符来实现封装,各种访问修饰符的访问权限,如图所示:

    在这里插入图片描述

    封装要点:
    1:除非确定该属性会被子类继承,否则全部使用private修饰;
    2:要求提供相应的get/set来访问属性(这些方法要求用public修饰,从而提供对属性的读写操作);
    3:仅用于本类的辅助性方法用private,希望被其他类调用的用public;

    继承(inherit)

    我们知道类是对对象的抽象(抽出“象”的部分);而继承则是对某一批类的抽象,从而实现对现实世界更好的建模;

    继承的优点

    1:提高代码复用;(从复用性角度来考虑,组合和继承一样;后面会详细对比)
    2:从OOA(面向对象分析)和OOD(面向对象设计)方面考虑,更加方便我们建模(建立整个系统的模型、结构);

    关键字

    extends(扩展);子类是父类的扩展

    继承的主要特性

    1:如果类未通过extends来继承父类,系统默认父类为java.lang.Object(根基类);
    2:Java为单继承(C++为多继承);在程序较为复杂时,多继承会引起混乱,使得程序过于复杂,系统难以维护(但是Java中可通过接口来实现多继承)
    3:子类继承父类,可以获得父类的所有属性和方法(记住一点:构造方法除外);

    重写

    重写特点:
    1:方法名相同;
    2:返回值相同;
    3:参数列表相同;
    4:不能缩小访问权限(多态的关系);

    重写运用较多的地方在于子类重写父类方法;但普通方法也可重写;
    重写和重载二者没有任何关系,不要搞混淆了!

    Object类

    Object是所有Java类的根基类;如果在类的声明中未通过extends关键字指明父类;则默认父类为Object;
    Object中的toString方法经常会被我们重写;但我们需要知道在Object类中toString方法返回的是类名+包名+@+哈希码(哈希码根据对象内存位置生成,唯一不重复)

    super关键字

    super指代的是父类对象的直接引用,可通过super来调用父类中被子类覆盖(重写)的属性和方法;
    super作用在普通方法中没有顺序,随意调用;但是在构造方法中调用必须放在第一句;并且在构造方法中,如果第一句没有加super();系统会默认调用super()作为父类的初始化函数;(在初始化一个对象时,系统会默认调用该对象的无参构造方法,无参构造方法里会默认调用父类无参构造方法,如果未指定父类,调用Object的无参构造方法;最后返回的对象呈“包裹结构”

    继承内存图分析

    首先我们先定义三个类:

    父类—Animal

    package com.project.inherit;
    
    public class Animal {
    	String eye;
    	
    	public Animal(){
    		super();
    		System.out.println("创建一个动物");
    	}
    	
    	public void eat(){
    		System.out.println("动物吃饭");
    	}
    	
    	public void run(){
    		System.out.println("动物奔跑");
    	}
    }
    

    子类----Brid

    package com.project.inherit;
    
    public class Brid extends Animal {
    	
    	String wing;
    	
    	public Brid(){
    		//在无参构造方法中调用被子类覆盖的父类run方法
    		super.run();
    		System.out.println("创建一只鸟");
    	}
    	
    	//重写Animal run方法
    	public void run(){
    		System.out.println("小鸟飞");
    	}
    	
    	//子类特有方法sleep
    	public void sleep(){
    		System.out.println("小鸟睡觉");
    	}
    }
    

    测试类—Test

    package com.project.inherit;
    
    public class Test {
    	public static void main(String[] args) {
    		Brid brid = new Brid();
    		brid.wing = "翅膀";	//子类特有属性
    		brid.eye = "双眼";	//父类属性
    		brid.sleep();		//子类特有方法
    		brid.run();			//重写了父类方法
    		brid.toString();    //根基类方法
    	}
    }
    

    内存分析图:
    在这里插入图片描述

    继承vs组合

    组合是什么:
    去除继承概念,我们将父类作为一个对象new出来直接放到子类中,子类通过这个“组合”对象获取到该对象的方法和属性;比如:

    package com.project.inherit;
    
    public class Brid {
    	
    	String wing;
    	
    	public Brid(){
    		Animal animal = new Animal();   //去除了Brid和Animal的继承关系,将Animal作为对象
    										//直接放进来;作用同继承一样。
    		animal.run();
    	}
    }
    

    因此,我们可以得出如果仅从代码复用的角度来考虑,组合完全可以替代继承;
    但是从程序建模角度来考虑,继承比组合更加适用;继承会使程序的结构层次更加清晰,扩展性更强;
    我们可以表示为:
    is a的关系用继承;(比如小鸟是动物,这种关系用继承较好)
    has a的关系用组合;(小鸟有一对翅膀,这种关系用组合更加合适)

    final

    从final这个单词的意思“最终”我们就可以看出,它对程序会有什么样的影响了;
    1:修饰变量:常量,不可修改;
    2:修饰方法:不可重写(可重载);
    3:修饰类:不能继承其他类,也不能有子类;(比如:Math类,String类)

    多态

    多态主要是用来实现动态联编的,换句话说,就是程序的最终形态是由运行时决定的,而非编译时决定,即声明的引用变量最终会指向哪个实例对象;

    必要条件

    1:必须要有继承;
    2:子类必须重写父类方法;
    3:父类引用指向子类对象;

    底层实现原理分析

    首先,先声明三个类:
    父类—Animal

    package com.project.polymorphism;
    
    public class Animal {
    	String eye;
    	
    	public void voice(){
    		System.out.println("动物叫声");
    		testThis();
    	}
    	
    	public void testThis(){
    		System.out.println("this is animal");
    	}
    }
    

    子类—Dog

    package com.project.polymorphism;
    
    public class Dog extends Animal{
    
    	public void voice(){
    		System.out.println("汪汪");
    	}
    	
    	public void lookDoor(){
    		System.out.println("看门");
    	}
    	
    	public void testThis(){
    		System.out.println("this is dog");
    	}
    }
    

    测试类—Test

    package com.project.polymorphism;
    
    public class Test {
    	
    	public static void testAnimalVoice(Animal a){
    		//这里的a在编译时会被统一成Animal对象,而运行时,被解释成Dog对象
    		a.voice();
    		
    		//从包裹结构来看,可以知道,Dog对象中包含Animal对象
    		//因此,a对象属于Dog类在编译上不会出错,但是在运行时必须强制转换成Dog对象
    		if(a instanceof Dog){
    			((Dog) a).lookDoor();
    		}
    	}
    	
    	public static void main(String[] args) {
    		Animal d = new Dog();
    		testAnimalVoice(d);
    		
    		//测试this在继承关系中所代表的对象
    		d.testThis();
    	}
    }
    

    以上代码在运行时在内存中的表现形式为,如图所示:
    在这里插入图片描述
    说明:
    1:在Test测试类中我们可以发现,一共有两个引用变量(d和a),因此,将这两个引用变量放入栈中;

    2:通过继承关系我们可以知道,new出的新对象是包裹结构,如上图所示;

    3:super对象中的隐式参数super指代的是直接父类的引用,而通过Test测试类中的d.testThis()方法(最后打印结果为,this is dog)我们可以得出,this指代的是最终成型的对象,也就是最外层对象Dog,因此在父类Animal的voice方法中调用testThis()方法(等同于this.testThis()),其实调用的是子类Dog的testThis()方法;

    展开全文
  • 面向对象编程及其大特性

    万次阅读 2019-06-11 11:39:23
    编程语言分为面向过程编程、函数式编程和面向对象编程。其实python就是一种面向对象编程,那么我们先了解一下它们的特点和优缺点以及它们的区别是什么。 面向过程编程:“面向过程”(Procedure Oriented)是一种以...

    编程语言分为面向过程编程、函数式编程和面向对象编程。其实python就是一种面向对象编程,那么我们先了解一下它们的特点和优缺点以及它们的区别是什么。

    面向过程编程:“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。这些都是以什么正在发生为 目标进行编程,不同于面向对象的是谁在受影响。与面向对象明显的不同就是封装、继承、类。

    面向过程编程最易被初学者接受,其往往用一长段代码来实现指定功能,开发过程的思路是将数据与函数按照执行的逻辑顺序组织在一起,数据与函数分开考虑。

    • 特性:模块化   流程化
    • 优点:性能比面向对象高,因为类调用时需要实例化,开销比较大,比较消耗资源;单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发,性能是最重要的因素。
    • 缺点:没有面向对象易维护、易复用、易扩展

    函数式编程: 函数式编程也是种编程方式,它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算(lambda calculus),而且λ演算的函数可以接受函数当作输入(参数)和输出(返回值)。

    它的主要思想是把运算过程尽量写成一系列嵌套的函数调用。

    Python 不是也不大可能会成为一种函数式编程语言,但是它支持许多有价值的函数式编程语言构建。也有些表现得像函数式编程机制但是从传统上也不能被认为是函数式编程语言的构建。

    Python内建函数 : filter()、map()、reduce()、max()、min()

    面向对象编程:面向对象是按人们认识客观世界的系统思维方式,采用基于对象(实体)的概念建立模型,模拟客观世界分析、设计、实现软件的办法。通过面向对象的理念使计算机软件系统能与现实世界中的系统一一对应。

    面向对象编程可以将数据与函数绑定到一起,进行封装,这样能够更快速的开发程序,减少了重复代码的重写过程。

    • 特性:抽象 封装 继承 多态
    • 优点:易维护、易复用、易扩展,由于面向对象有封装、继承、多态性的特性,可以设计出低耦合  的系统,使系统更加灵活、更加易于维护
    • 缺点:性能比面向过程低

    可以拿生活中的实例来理解面向过程与面向对象,例如五子棋,面向过程的设计思路就是首先分析问题的步骤:1、开始游戏,2、黑子先走,3、绘制画面,4、判断输赢,5、轮到白子,6、绘制画面,7、判断输赢,8、返回步骤2,9、输出最后结果。把上面每个步骤用不同的方法来实现。

    如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方,这两方的行为是一模一样的,2、棋盘系统,负责绘制画面,3、规则系统,负责判定诸如犯规、输赢等。第一类对象(玩家对象)负责接受用户输入,并告知第二类对象(棋盘对象)棋子布局的变化,棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化,同时利用第三类对象(规则系统)来对棋局进行判定。

    可以明显地看出,面向对象是以功能来划分问题,而不是步骤。同样是绘制棋局,这样的行为在面向过程的设计中分散在了多个步骤中,很可能出现不同的绘制版本,因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中,绘图只可能在棋盘对象中出现,从而保证了绘图的统一。 


     面向对象编程三大特性

    在看面向对象编程三大特性之前,先了解一下对象和类的区别。

    对象和类 

    类(Class)是现实或思维世界中的实体在计算机中的反映,它将数据以及这些数据上的操作封装在一起。类实际上是创建实例的模板。

    对象(Object)是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。 而对象就是一个一个具体的实例。

     定义类的方法: 

    class 类():  

              pass

    那么如何将类转换成对象呢?

    实例化是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概念类,具体到该类实物的过程。实例化过程中一般由类名 对象名 = 类名(参数1,参数2...参数n)构成。

    定义类之后一般会用到构造方法__init__与其他普通方法不同的地方在于,当一个对象被创建后,会立即调用构造方法(也称为魔术方法)。自动执行构造方法里面的内容。

     1.封装特性

    封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。 所以,在使用面向对象的封装特性时,需要:

    1. 将内容封装到某处
    2. 从某处调用被封装的内容,调用方法如下:
    • 通过对象直接调用被封装的内容: 对象.属性名
    • 通过self间接调用被封装的内容:  self.属性名
    • 通过self间接调用被封装的内容:    self.方法名()

    对于面向对象的封装来说,其实就是使用构造方法将内容封装到 对象 中,然后通过 对象直接或者self间接获取被封装的内容。 

    具体例子如下:

    # 1). 类的定义
    class People:
        # 构造方法(魔术方法): 当创建对象时会自动调用并执行;
        # self实质上是实例化出来的对象, e.g: xiaoming, xiaohong;
        def __init__(self, name, age, gender):
            # print("正在创建对象")
            # print(self) # 实质上是一个对象
            # 将创建对象的属性(name, age, gender)封装到self(就是实例化的对象)变量里面;
            # 在类里面定义的变量: 属性
            self.name = name
            self.age = age
            self.gender = gender
        # 在类里面定义的函数: 方法
        def eat(self):
            print('%s eating......' %(self.name))
    
        def sleep(self):
            # 获取对象self封装的属性(name, age, gender)
            print('%s sleep.......' %(self.name))
    
    # 2). 实例化: 通过类实现对象的创建
    xiaoming = People("小明", 20, '男')
    # 将对象self/xiaoming封装的属性(name, age, gender)从里面拿出来;
    print(xiaoming.name)
    xiaoming.eat()
    xiaoming.sleep()
    
    xiaohong = People("小红", 20, '女')
    print(xiaohong.name)
    xiaohong.eat()
    xiaohong.sleep()

     2.继承特性

     1)继承

    继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、Superclass)。

    问题一:如何实现继承呢?         

    子类在继承的时候,在定义类时,小括号()中为父类的名字,例如: class son(father):   这里father就是son的父类。    

    问题二:继承的工作机制是什么?             

    父类的属性、方法,会被继承给子类。 举例如下:如果子类没有定义__init__方法,父类有,那么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的__init__方法。

    重写父类方法:就是在子类中,有一个和父类相同名字的方法,那么在子类中的方法就会覆盖掉父类中同名的方法,就实现了对父类方法的重写。

    调用父类的方法:

    1. 在子类中,直接利用  父类名.父类的方法名() 
    2. super()方法: python2.2+的功能,格式为: super(子类名称, self).父类的方法名() (建议用此方法)

    2)多继承 

     多继承,即子类有多个父类,并且具有它们的特征。

    新式类与经典类的区别:

    在Python 2及以前的版本中,由任意内置类型派生出的类,都属于“新式类”,都会获得所有“新式类”的特性;反之,即不由任意内置类型派生出的类,则称之为“经典类”。

    新式类:

    class 类名(object):

            pass

    经典类:

    class 类名:

           pass

    “新式类”和“经典类”的区分在Python 3之后就已经不存在,在Python 3.x之后的版本,因为所有的类都派生自内置类型object(即使没有显示的继承object类型),即所有的类都是“新式类”。 

    它们两个最明显的区别在于继承搜索的顺序不同,即:    

    经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找,然后再返回,开始查找右侧。    

    新式类多继承搜索顺序(广度优先算法):先在水平方向查找,然后再向上查找。

    图示如下:

     

    具体例子如下:

    # python2:
        # 经典类: 	class Father:
        # 新式类:   class Father(object):
    # python3:
    #       所有的都是新式类
    
    # 新式类:  广度优先
    # 经典类:  深度优先
    class D:
    	a = 'd'
    
    class B(D):
    	pass
    
    class C(D):
    	a = 'c'
    
    class A(B, C):
    	pass
    obj = A()
    print(obj.a)

    运行结果是 c,由此可见为广度优先搜索的结果。

    3)私有属性与私有方法

    默认情况下,属性在 Python 中都是“public”, 大多数 OO (面向对象)语言提供“访问控制符”来限定成员函数的访问。 

    在 Python 中,实例的变量名如果以 __ (双下划线)开头,就变成了一个私有变量/属性(private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只有内部可以访问,外部不能访问。

    那么私有属性一定不能从外部访问吗?

    python2版本不能直接访问 __属性名,是因为 Python 解释器对外把  __属性名 改成了  _类名__属性名 ,所以,仍然可以通过 _类名__属性名  来访问 __属性名 。 但是不同版本的 Python 解释器可能会把 __属性名  改成不同的变量名,因此不建议用此类方法访问私有属性。 

    私有属性和方法的优势:

    1. 确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。      
    2. 如果有要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法。 为什么大费周折?因为在方法中,可以对参数做检查,避免传入无效的参数。

    具体实例如下:

    class Student(object):
        __country = 'china'
        def __init__(self, name, age, score):
            self.name = name
            # 年龄和分数是私有属性
            self.__age = age
            self.__score = score
    
        # 私有方法, 只能在类内部执行;
        def __modify_score(self, scores):
            self.__score = scores
            print(self.__score)
    
        def set_age(self, age):
            if 0<age <150:
                self.__age = age
                print("当前年龄:", self.__age)
            else:
                raise  Exception("年龄错误")
    
        def set_score(self, scores):
            if len(scores) == 3:
                self.__score = scores
            else:
                raise Exception("成绩异常")
    class MathStudent(Student):
        pass
    
    student = Student("Tom", 10, [100, 100, 100])
    # 在类的外部是不能直接访问的;
    print(student.name)
    
    student.set_age(15)
    # Python 解释器对外把  __属性名 改成了  _类名__属性名
    # print(student._Student__age)

    3.多态特性 

    多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。通俗来说: 同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。

    多态的好处就是,当我们需要传入更多的子类,只需要继承父类就可以了,而方法既可以直接不重写(即使用父类的),也可以重写一个特有的。这就是多态的意思。调用方只管调用,不管细节,而当我们新增一种的子类时,只要确保新方法编写正确,而不用管原来的代码。这就是著名的“开放封闭”原则: 

    • 对扩展开放(Open for extension):允许子类重写方法函数    
    • 对修改封闭(Closed for modification):不重写,直接继承父类方法函数

     

    展开全文
  • C++编程之面向对象三个基本特征

    千次阅读 2011-09-14 21:41:41
    面向对象三个基本特征是:封装、继承、多态。 封装 封装最好理解了。封装是面向对象特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的...
  • python 面向对象三特征

    千次阅读 2021-10-12 19:08:05
    Python 是面向对象的语言,也支持面向对象编程大特性:继承、封装(隐藏)、多态。 1、封装(隐藏) 隐藏对象的属性和实现细节,只对外提供必要的方法。 通过“私有属性、私有方法”的方式,实现“封装”。...
  • 面向对象三个基本特征

    万次阅读 2018-09-05 17:11:31
    面向对象三个基本特征是:封装、继承、多态。 封装 封装最好理解了。封装是面向对象特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的...
  • 面向对象重要三个基本特征

    千次阅读 2016-03-08 23:01:41
    面向对象三个基本特征是:封装、继承、多态。
  • 面向对象特征

    千次阅读 2021-05-28 18:22:50
    Java知识点总结:想看的可以从这里进入 3、 面向对象特征 面向对象的特征:继承、封装、多态 3.1、封装 封装是面向对象编程的核心思想,将对象的属性和行为封装隐藏起来。而这些封装起来的属性和行为通常...
  • 面向对象:面向对象编程(Object Oriented Programming,面向对象程序设计)的主要思想是把构成问题的各个事务分解成各个对象,建立对象的目的不是为了完成一步骤,而是为了描叙一事物在整个解决问题的步骤中的...
  • 编程范式是计算机语言编程的一种需要编程者遵循的基本风格与规范模式。如果说每一个编程者进行的编程是在创造一依托于计算机而存在的虚拟世界,那么编程范式就是这虚拟世界所采用的世界观与创造世界的方法论。
  • JavaScript 进阶教程(1)--面向对象编程

    万次阅读 多人点赞 2020-08-16 18:13:37
    1 学习目标 理解面向对象开发思想 掌握 JavaScript 面向对象开发相关模式 ...当实物被抽象成对象,实物之间的关系就变成了对象之间的关系,从而就可以模拟现实情况,针对对象进行编程。 (2) 对象是一.
  • 面向对象编程(OOP)的概念

    万次阅读 2019-07-27 23:56:24
    文章目录一、OOP的全称:二、概念:、面向对象特征:1.封装(Encapsulation)2.继承(Inheritance)3.多态(Polymorphism)4.抽象(Abstraction) 一、OOP的全称: Object Oriented Programming 二、概念: ...
  • 面向对象编程(Python版详解)

    万次阅读 多人点赞 2020-04-03 14:14:18
    面向对象编程介绍二.类和对象.类的构成 一.面向对象编程介绍 如今主流的软件开发思想有两种:一是面向过程,另一是面向对象。面向过程出现得较早,典型代表为C语言,开发中小型项目的效率很高,但是很难适用...
  • 面向对象编程基本概念

    千次阅读 2018-04-18 15:41:53
    面向对象编程(OOP)为软件社区引入了一场革命,以帮助解决这些问题。 OOP专注于模块化,改变容忍度,代码重用,易于理解和分布式开发。今天大多数项目都使用面向对象的概念。由于C ++引入了OOP,因此用户体验已经...
  • 面向对象特征?以及作用

    千次阅读 2017-10-26 11:35:43
    封装:使用访问控制符可以将对象中不允许外部程序直接访问的重要属性隐藏在对象内部,这一过程叫封装(MVC模式中M层就用到的封装) 继承:被继承的类叫父类,继承父类的类叫子类,继承中子类将获得父类的属性和方法...
  • 什么是面向对象编程(OOP)?

    千次阅读 2018-10-23 15:29:44
    Java 程序员第一要了解的基础概念就是:什么是面向对象编程(OOP)
  • c++面向对象三个特点,并简述

    万次阅读 2018-03-24 01:30:33
    C++封装继承多态总结面向对象三个基本特征面向对象三个基本特征是:封装、继承、多态。其中,封装可以隐藏实现细节,使得代码模块化;继承可以扩展已存在的代码模块(类);它们的目的都是为了——代码重用。而...
  • 1.面向对象三个基本特征 面向对象三个基本特征是:封装、继承、多态。 封装 封装最好理解了。封装是面向对象特征之一,是对象和类概念的主要特性。 封装,也就是把客观事物封装成抽象的类,并且类可以把...
  • Kotlin的面向对象编程,深入讨论继承写法的问题

    万次阅读 多人点赞 2019-05-20 08:55:57
    本来计划是准备直播大概一个半小时,最后直播了三个小时还没讲完,因此为了赶时间不得不砍掉了一些本来要讲的内容。 当时提到了一个Kotlin在继承时括号书写的问题,这部分内容比较有疑惑性,不太利于初学者理解。...
  • 简述面向函数编程和面向对象编程的区别? 什么时候使用面向函数编程?什么时候使用面向对象编程? 函数式编程,顾名思义,这种编程是以函数思维做为核心,在这种思维的角度去思考问题。 这种编程最重要的基础是λ...
  • SIMULA 被认为是世界上最早的面向对象编程(OOP,Object-Oriented Programming)的程序设计语言。SIMULA 首次引入了面向对象程序设计语言的基本概念:对象、类、继承、virtual quantities、多线程(准并行的)的程序...
  • 面向对象编程思想

    千次阅读 2018-10-11 07:35:59
    Java面向对象编程思想Java对象什么是对象如何创建对象对象的生命周期继承什么是继承继承语法向上转型继承与初始化多态什么是多态产生正确的行为功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入...
  • 学java的都知道,java语言有三个特性,也可以说是三个优点,就是 1.简单性: java语言相对于C语言,C++来说比较简单。 2.跨平台:java语言编写的代码可以在不同的操作系统运行,即windows、android 、ios、linux等等...
  • 你好呀,我是沉默王二,是《Web 全栈开发进阶之路》的作者,...本篇来谈一谈“面向对象编程”中的所有概念。 因为是第一次做付费专栏,所以有一定的压力,虽然只需要 9.9 元,但我对自己的要求是至少要达到 199 元...
  • 面向对象编程,这种编程是把问题看作由对象的属性与对象所进行的行为组成。基于对象的概念,以类作为对象的模板,把类和继承作为构造机制,以对象为中心,来思考并解决问题。 优点 函数式编程:支持闭包和高阶...
  • 封装性:封装是一种信息隐蔽技术,它体现于类的说明,是对象重要特性。封装使数据和加工该数据的方法(函数)封装为一整体,以实现独立性很强的模块,使得用户只能见到对象的外特性(对象能接受哪些消息,具有...
  • 面向对象编程三大特性------封装、继承、多态

    万次阅读 多人点赞 2016-06-07 11:41:12
    本文是对面向对象编程三大特性(封装、继承、多态)的一学习总结。 封装隐藏了类的内部实现机制,可以在不影响使用的情况下改变类的内部结构,同时也保护了数据。对外界而已它的内部细节是隐藏的,暴露给外界的...
  • Java语言是纯粹的面向对象的程序设计语言,这主要表现为Java完全支持面向对象种基本特征:继承、封装和多态。Java语言完全以对象为中心,Java程序的最小程序单位是类,整个Java程序由一的类组成。 Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 496,671
精华内容 198,668
关键字:

对象编程的三个重要特征