精华内容
下载资源
问答
  • 对象具有属性和行为 对象的行为包括具有的功能及具体的实现 对象具有状态 对象分为类对象和实例对象两大类: 类对象是具有相同属性和行为的实例对象的抽象 类对象就是实例对象的模板,实例对象是由类...

    1. 面向对象编程概述

    面向对象编程是一种编程方式,这种编程方式需要使用对象来实现
    在这里插入图片描述

    1.1 对象的特征

    • 世间万物皆是对象
    • 每个对象都是唯一的
    • 对象具有属性和行为
      对象的行为包括具有的功能及具体的实现
    • 对象具有状态
    • 对象分为类对象实例对象两大类:
      1. 类对象是具有相同属性和行为的实例对象的抽象
      2. 类对象就是实例对象的模板,实例对象是由类对象创建出来的
      3. 同一个类对象的所有实例对象具有相同的属性,表明它们的属性含义是相同的,但是它们的状态不一定相同,也就是户型不一定相同

    1.2 面向对象编程的大体步骤

    1. 抽象出类对象
    2. 抽象出类对象的属性
    3. 抽象出类对象的行为(方法)
    4. 根据类对象创建实例对象
    5. 通过实例对象访问属性和方法

    1.3定义类对象的语法格式

    class 类名(object):
        #属性与方法
    

    eg:

    >>> class Cat(object): #Cat是类对象
    >>>     pass
    

    注:object表示该类对象继承自python内置的类对象object,python中所有的类对象都继承自一个统一的基类:object

    1.4 初识属性

    构造方法:用两个双下划线表示的函数

     >>> class Cat(object):
     >>>     # 构造属性
     >>>     def __init__(self, breed, name, sge, health): #第一个self必须写
     >>>         self.breed = breed #品种
     >>>         self.name = name
     >>>         self.sge = sge
     >>>         self.health = health
    

    1.5 初识类的方法

    行为(方法)是类中特殊的函数

    • 类的方法与函数的区别
      方法就是定义在类对象中的函数
      1. 定义方法时,方法的第一个形参表示调用该方法的实例对象,第一个形参的名称通常是self,也可以是其它名称
      2. 调用方法时,系统自动将调用该方法的实例对象作为实参传递给第一个形参。第一个实参会传递给第二个形参,第二个实参会传递给第三个形参,以此类推
    >>>     def run(self):
    >>>         print("Cat is running")
    >>>     def miao(self):
    >>>         print("Cat is maioing")
    >>>     def eat(self):
    >>>         print("Cat id eating")
    

    注:def与1.4中的def对齐

    1.6 根据类对象创建实例对象语法格式:

    类名([实参])
    eg:

     >>> #cat是实例对象  Cat是类对象
     >>> cat = Cat("波斯猫","喵咪", 1, "健康")
     >>> print(cat.breed)
     >>> cat.run()
    

    2. 实例对象属性

    2.1 实例属性

    • 实例对象所绑定的属性

    • 绑定实例属性的方法:

      1. 在类对象的内部(方法中):
        语法格式:
        self.属性名 = 属性值
        (推荐在__init__中进行绑定,这样在创建实例对象后会自动调用特殊方法__init__对实例对象进行初始化,从而绑定实例属性。如果在其他方法中进行绑定,可能需要手动调用方法后才会绑定)
      2. 在类对象外部:
        python是动态语言,所以在类对象创建之后可以对其动态地进行绑定
        语法格式:
        实例对象.属性名 = 属性值
        如果指定名称的实例属性已经存在,则是对类属性进行修改
    • 访问实例属性的方式:

      1. 在类对象的内部(方法中)
        语法格式:
        self.属性名
      2. 在类对象外部
        语法格式:
        实例对象.属性名
        添加前缀“self”或“实例对象”是为了表明实例属性被哪个实例对象所绑定
    >>> class MyClass(object):
    >>>     def __init__(self):
    >>>         # 在类对象内部绑定实例属性
    >>>         self.ia1 = 18
    >>>     def do_sth1(self):
    >>>         # 在类对象内部访问实例属性
    >>>         print(self.ia1)
    >>>     def do_sth2(self):
    >>>         print(self.ia2)
    >>>     def do_another(self):
    >>>         self.ia2 = 56
    >>>     def do_sth3(self):
    >>>         print(self.ia3)
    >>> #绑定(创建)实例对象
    >>> mc = MyClass()
    
    >>> # 在类对象外部绑定实例属性
    >>> mc.ia3 = 66
    >>> # 在类对象外部访问实例属性
    >>> mc.do_sth3()
    
    >>> #同一个类对象所绑定的另一个实例对象
    >>> mc2 = MyClass()
    
    

    2.2 实例对象. __ dict __

    可获得该实例对象所绑定的所有属性及其值的字典
    具体见博客 python面向对象编程——new()、getitem()、call()与callable()、doc__与__dict:https://blog.csdn.net/weixin_43799652/article/details/92589216

    >>> mc.__dict__
    {'ia1': 18, 'ia3': 66, 'ia2': 56}
    

    3. 类对象属性

    3.1 类属性

    类属性指的是类对象所绑定的属性

    • 绑定类属性的方法:
      1. 在类对象的内部(方法外):
        语法格式:
        属性名 = 属性值
      2. 在类对象外部:
        python是动态语言,所以在类对象创建之后可以对其动态地进行绑定
        语法格式:
        类对象.属性名 = 属性值
        如果指定名称的雷属性已经存在,则是对类属性进行修改
    • 访问类属性的方法:
      1. 在类对象的内部(方法中)
        语法格式:
        类对象.属性名
      2. 在类对象外部
        语法格式:
        实例对象.属性名类对象.属性名

    注:类对象的所有实例中都有一个指向类对象的指针,所以类对象的所有实例对象都可以访问类属性。添加前缀“类对象”是为了表明类属性被哪个类对象所绑定。

    >>> class MyClass(object):
    >>>     #在类对象内部(方法外)绑定类属性
    >>>     ca1 = 66
    >>>     def do_sth(self):
    >>>         #在类对象内部(方法中)访问类属性
    >>>         print(MyClass.ca1)
    >>>     def do_another(self):
    >>>         #在类对象内部(方法中)访问类属性
    >>>         print(MyClass.ca2)
    >>> mc = MyClass()
    >>> #在类对象的外部绑定类属性
    >>> MyClass.ca2 = 88
    >>> print(MyClass.ca2)
    >>> print(mc.ca2)
    >>> #在类对象的外部修改类属性
    >>> MyClass.ca2 = 99
    >>> print(MyClass.ca2)
    >>> print(mc.ca2)
    >>> #在类对象外部调用类方法,使得在类对象内部访问类属性
    >>> mc.do_another()
    

    4. 实例方法

    实例方法:指只有实例对象才能调用的方法

    • 实例对象调用实例方法的两种调用方式:
      • 1.在类对象内部
        语法格式:self.方法名([实参])
      • 2.在类对象的外部
        语法格式:实例对象.方法名([实参])
    class MyClass(object):
        #在类对象中定义实例方法
        def im1(self, p1, p2):
            print(p1,p2)
        def im2(self):
            #在类对象内部调用实例方法
            self.im1(1,2)
    mc = MyClass()
    #在类对象外部调用实例方法
    mc.im1(1,2)
    

    注:

    1. 类对象不能直接调用实例对象
    2. 实例方法可以在实例对象或类对象创建以后绑定
    3. 同一个类对象的不同实例对象之间绑定的实例方法不会相互影响,也就是说在一个实例对象绑定的实例方法不会在另一个实例对象里起作用
    4. 想要让同一类对象中的实例对象都能够调用某一实例方法,可以给类对象绑定该实例方法
    >>> # 注 2
    
    >>> #定义一个实例方法
    >>> def do_sth(self, a, b):
    >>>     print(a,b)
        
    >>> #导入标准库types中的类MethodType
    >>> from types import MethodType
    >>> #给实例对象mc动态地绑定实例方法
    >>> mc.do_sth = MethodType(do_sth, mc)
    >>> #调用绑定的实例方法
    >>> mc.do_sth(1, 2) #do_sth()被调用了
    1 2
    
    >>> #注 3
    
    >>> #创建另一个实例对象
    >>> mc2 = MyClass()
    
    >>> def im3(self):
    >>>     print("im3()被调用了")
    
    >>> #给类对象动态地绑定实例方法
    >>> MyClass.im3 = im3
    
    >>> #一个实例对象可以调用
    >>> mc.im3()
    >>> #另一个实例对象可以调用
    >>> mc2.im3()
    im3()被调用了
    im3()被调用了
    
    展开全文
  • 1、封装,将现实中事物抽象成计算机领域中的对象对象同时具有属性和行为,这就是封装。在封装中,数据隐藏,对象只对外提供与其他对象交互的接口,把自身的一些属性和实现细节对外是隐藏的。这样对象内部数据就有...

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

    1、封装,将现实中事物抽象成计算机领域中的对象,对象同时具有属性和行为,这就是封装。在封装中,数据隐藏,对象只对外提供与其他对象交互的接口,把自身的一些属性和实现细节对外是隐藏的。这样对象内部数据就有不同级别的保护,防止了程序中某些部分被意外改变或者错误引用了对象的私有属性。

    2、继承,实现对象复用性的一个方法,可以在不重复编写以实现某个功能的前提下,对功能进行复用或者拓展。

    继承的实现有两种:实现继承和接口继承

    实现继承就是直接使用基于类的属性和方法,无需额外的编码

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

    3、多态(可替代性),当前在继承关系时,允许把父类对象看成和它一个或者多个子类对象同等。因此可以根据当前赋给父对象的子对象中具体特性以不同的方式运行。

    多态的前提条件:

    1)要有继承关系

    2)要有方法重写

    3)要有父类引用指向子类对象

    多态的优势:

    1)提高了代码的维护性

    2)提升了代码的扩展性

    但是多态中不能使用子类的特有属性和方法

    面向对象的原则

    单一功能原则:一个类的功能要单一,不要保罗万象;

    开放封闭原则:一个类在扩展性方面应是开放的,而在更改方面应是封闭的。

    例如在一个类中,原本只是实现服务端的功能,现在需要添加客户端功能。则应该在不修改服务端功能的前提下增添实现客户端功能的代码。那么在最初功能设计时应该把所有功能分开,公共部分抽离出来。

    替换原则:子类可以替换父类并出现在父类能够出现的地方

    依赖原则:具体依赖抽象,上层依赖下层。

    比如:在A手机和B手机中,B手机无卡,但是B手机要用A手机中的网络,这时候B手机就不能直接使用A手机的网络(具体类);B手机应当设置打开WiFi,连接A手机的网络(B定义抽象接口,由A来实现,B仅仅是使用该抽象接口)

    接口分离原则:模块间要通过抽象接口隔离开,而不是通过具体的类强耦合起来

    对象之间的关系

    1、聚合关系,

    2、组合关系,

    3、继承关系。

    4、依赖关系。

    展开全文
  • 面向对象方法中的类,是具有相同属性和服务的一组对象的集合。 3.封装 封装是面向对象方法的一个重要原则,就是把对象属性和服务结合成一个独立的系统单位,并尽可能隐蔽对象的内部细节。 4.继承

    面向对象的基本概念

    1.对象

    面向对象方法中的对象,是系统中用来描述客观事物的一个实体,他是用来构成系统的一个基本单位。

    对象由一组属性和一组行为组成。

    2.类

    分类依据的原则时抽象。

    面向对象方法中的类,是具有相同属性和服务的一组对象的集合

    3.封装

    封装是面向对象方法的一个重要原则,就是把对象的属性和服务结合成一个独立的系统单位,并尽可能隐蔽对象的内部细节。

    4.继承

    特殊类的对象拥有其一般类的全部属性和服务,称作特殊类对一般类的继承。

    5.多态

    多态性是指在一般类中的属性和行为,被特殊类集成之后,可以具有不同的数据类型或表现出不同的行为。
    展开全文
  • java面向对象属性

    2021-01-02 17:14:57
    面向对象的方法主要是把事物给对象化,包括其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程,面向过程抽象成类,然后封装,方便使用就是面向对象,(万物皆对象)。” 类和...

    什么是面向对象?

    面向对象的方法主要是把事物给对象化,包括其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程,面向过程抽象成类,然后封装,方便使用就是面向对象,(万物皆对象)。”

    类和对象是什么?

    • 类是抽象笼统的概念,描述的是一类事物,肯定是具有相同的行为特征
    • 对象是类的具体的某一个

    类能描述什么?

    • 具有静态描述的特征称之为属性
    • 具有动态动作的行为(做事情)称之为方法

    如何在计算机中利用面向对象的思想来做事?

    1. 需要先自己定义(描述)一个类(型)
    2. 想要做事情需要在描述的类中创建一个具体的个体(对象)出来
    3. 通过对象做事情

    如何在计算机中创建(描述)一个类

    1. 先创建一个类
    2. 利用属性或方法去描述这个类

    创建一个Person类

    public class Person {
        //创建当前类来描述它长成什么样子(属性和方法不是必须有的)
    
    
        //属性--静态描述特点
        // (它的必要组成部分 1.修饰符(不写它默认有权限修饰符,在同包或当前类中可以访问,特征修饰符可有可无) 2.数据类型 3.属性的名字)
        // 属性可以赋初始值,但是这样赋值并不合理,它是用来描述一个类的,不应该是固定死的属性,应该让它的对象去赋值
        //属性用相应的默认值,引用类型的默认值为null,基本类型的默认值为0,false,0.0等等
        //结构: 权限修饰符 [特征修饰符] 数据类型 属性名 
        public String name;
        public int age;
        public String sex;
    
        //方法--描述可以做什么事情
    }
    

    如何创建一个对象做事情

    1. 创建一个当前类的对象,让对象调用属性/方法做事情
    2. 对象的创建在哪都可以,可以在当前类,也可以另起一个类,因为程序的入口是main函数,它不属于任何一个类,是通过虚拟机来调用的,让它如何执行。
    3. 对象的创建可以有N多个

    测试类

    public class TestMain {
        //main函数程序的入口
        public static void main(String[] args) {
            //创建一个Person类对象,
            //1.由于这个Person类是我们自己创建的类型,属于引用类型,通过new关键字来创建
            //2.一般来说需要找一个空间来接收,如果想直接创建完对象调用它的属性/方法后不需要它了,可以不需要接收
            Person person = new Person();
            //person是一个对象的引用,通过对象. 去调用属性或方法做事情
            //存值
            person.name="chenhui";
            person.sex="男";
            person.age=22;
            //取值
            System.out.println(person.name+"今年"+person.age+"岁,性别为"+person.sex);
    
            //可以创建好多个Person对象
            Person person1 = new Person();
            Person person2 = new Person();
        }
    }
    

    通过内存图来描述以上过程

    在这里插入图片描述

    对象的引用存在栈内存中,new关键字创建的对象在堆内存中,new了多少个对象就在堆内存中开辟多少个空间

    展开全文
  • 面向对象程序的最小单元是类,类代表了客观世界中具有某一特征的一类事物,封装了这类事物所具有属性和行为。所以,类定义=成员变量(属性)+方法(行为)。面向对象程序设计与人类的思维习惯一致,比如希望完成“兔子...
  • 只不过,面向对象语言不同的实现不同而形式不一样,比如静态语言就是用类型这个事物来使得对象具有某种属性,在实例化以后可以通过改变属性的值来改变对象的状态。而行为的动态变化特征对于使用类型模板技术的静态...
  • 1.面向对象面向过程:当需要实现一个功能的时候,每一个具体的步骤...2.类和对象的关系类:是一组相关属性和行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述类事物。属性:就是该事物的...
  • 某一个具体的个体 *类:具有相同行为和共同特征对象的集合,类是人类脑海中一个抽象的概念,通过类创建对象 *类中的成员:1.成员属性(描述外部特征) 2.成员方法(描述功能行为)* 如何定义一个类: * [修饰符] class...
  • 一、Java是面向对象语言,面向对象... 继承:实现代码的复用,所有的子类共有的属性和行为抽象成一个父类,继承具有单一性和传递性 多态: 在程序中定义的引用变量所指向的具体类型和该引用变量调用的方法在编译期...
  • 简单来讲: 将现实世界的事物抽象成计算机领域中的对象,对象同时具有属性和行为,这种抽象就是封装. 封装的一个重要特性: 数据隐藏. 对象只对外提供与其它对象交互的必要接口,而将自身的某些属性和实现细节对外隐藏, ...
  • 类是面向对象的一个重要概念,类是很多个具有相同属性和行为特征对象抽象出来的,对象是类的一个实例。类具有三个属性:继承、封装和多态。封装:通过把程序模块化、对象化,通过把这些具体事物的特性属性和通过...
  • 类是具有共同状态和行为对象的集合,是构造对象的模版,类构造对象的过程称为创建类的实例,实例就是具体的对象。 抽象是指抽取出一些事物共同的状态和行为并定义成一个类的过程,状态可以用类的属性(字段)来...
  •  封装:将对象属性和行为封装起来,载体就是类,类通常对用户隐藏其实现细节  继承:基本思想是基于某个父类的扩展,制定出新的子类,子类可以继承父类原有的属性和方法,与可以在子类上增加父类不具有的属性和...
  • 一个对象应当具有属性和行为两个要素。 - 属性:描述静态特征 - 行为: 描述动态特征。 2. 类 类: 对所有具有共同特征的事物归为一类。 是一个抽象的概念,而对象是一个类中某个具体实体。对象是类的一个...
  • 将现实世界的事物抽象成计算机领域中的对象,对象同时具有属性和行为,这种抽象就是封装可以在确保正常交互的前提下,保证了安全性. 2.继承 面向对象的一个重要特性是复用性.继承是实现复用性的一个重要手段.可以在...
  • 简单来讲:将显示世界事物抽象成计算机领域中的对象对象同时具有属性和行为,这种抽象就是封装。 封装的一个重要特征:数据隐藏。对象之对外提供与其他对象交互的必要接口,而将自身的某些属性和实现细节对外隐藏...
  • 属性:对象具有的各种特征 每个对象的每个属性都有特定值;例如小红和小明的年龄,姓名不一样 方法:对象执行的操作 类:--------抽象 类是对象概括,是对象的分类 具有相同属性和方法的一组对象的集合 是概念...
  • 对象属性、方法、 封装与继承

    千次阅读 2017-10-03 22:09:40
    属性:对象具有的各种特征,每个对象的每个属性都拥有特定值 方法:对象执行的操作 类图详解: 如图 类的产出 从对象中归纳、抽象出类 根据"对象"抽象出"类" 类 具有相同属性和方法的一组对象的集合 类是模子...
  • 面向对象程序的最小单元是类,类代表了客观世界中具有某一特征的一类事物,封装了这类事物所具有属性和行为。所以,类定义=成员变量(属性)+方法(行为)。面向对象程序设计与人类的思维习惯一致,比如希望完成...
  • 面向对象的三大特征

    2020-09-26 19:36:58
    两层含义:一层是把对象属性和行为看成一个密不可分的整体,将这两者封装在一个对象中 另一层含义:信息隐藏,把不需要让外界知道的信息隐藏起来,有些对象的属性及行为允许外界用户指导和使用,但不允许更改,...
  • 面向对象特征

    2018-06-27 08:44:26
    三大特征:封装,继承,多态封装: 定义:将具体的事物抽象成计算机中的对象,这个对象同时具有属性和行为,这种抽象就是封装.(抽象包括过程抽象和数据抽象,) 形式:是将过程和数据包围起来,对象只对外提供与其他对象交互的...
  • 分类性是指将具有一致的数据结构(属性)和行为(操作)的对象抽象成类。一个类就是这样一种抽象,它反映了与应用有关的重要性质,而忽略其他一些无关内容。任何类的划分都是主观的,但必须与具体的应用有关。 (3)继承...
  • Java面相对象属性

    2020-05-25 15:58:09
    类:具有相同特征行为的一类事物 静态描述特征属性 动态动作行为:方法 对象:由类中具体的方法和属性引用出来 需要先有一个具体的类,才能由类创建出一个具体的对象来做事 案例 Person.java public class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,060
精华内容 824
关键字:

对象具有属性和行为特征