精华内容
下载资源
问答
  • 面向对象编程要素: 类、属性、函数(方法)、对象(实例)类: 一群有着相同属性和函数(方法)的对象(实例)集合,也可以具象化理解为是一群有着相似特征事物集合;用class来声明。抽象类:是一种特殊类,...

    面向对象编程的四要素: 类、属性、函数(方法)、对象(实例)

    类: 一群有着相同属性和函数(方法)的对象(实例)的集合,也可以具象化的理解为是一群有着相似特征的事物的集合;用class来声明。

    抽象类:是一种特殊的类,只能作为父类存在,一旦对象化(或叫实例化)就会报错;一般使用class Classname(metaclass=ABCMeta)来声明。

    类的继承:子类继承父类,子类可以使用父类的属性和函数,同时子类可以有自己独特的属性和函数;子类在生成对象的时候(实例化时),是不会自动调用父类的构造函数的,必须在子类的构造函数中显示的调用父类的构造函数;继承的优势是减少重复代码,降低系统熵值(即复杂度)。

    属性:用"self.属性名"来表示,通过构造函数传入;表示对象(实例)的某个静态特征。

    私有属性:以开头的属性,举例:self.属性名,只能在类内部调用,类外部无法访问。

    公有属性:和函数并列声明的属性,可以理解为常量,一般用全大写表示;在类中通过"self.常量名"来调用,在类外使用"对象名.常量名"或者"类名.常量名"来调用。

    函数:表示对象(实例)的某个动态能力。

    构造函数:用def init(self, args...)声明,第一个参数self代表当前对象的引用,其他参数是在对象化时需要传入的属性值;构造函数在一个对象生成时(即实例化时)会被自动调用。

    成员函数:是正常的类的函数,第一个参数必须是self;可通过此函数来实现查询或修改类的属性等功能。

    静态函数:静态函数和类没有什么关联,第一个参数也没有什么特殊性;一般用来做一些简单独立的任务,既方便测试也能优化代码结构;一般使用装饰器@staticmethod来声明。

    类函数:类函数的第一个参数一般为cls,表示必须传一个类进来;最常用的功能是实现不同的init构造函数;需要装饰器@classmethod来声明。

    抽象函数:一般定义在抽象类中,主要目的是要求子类必须重载该函数才能正常使用;使用装饰器@abstractmethod来声明。

    函数重载:父类的某函数通过raise Exception的方式要求子类必须重写该函数来覆盖父类原有函数。

    对象:类对象化(实例化)后的某一个具体事物。

    class A():

    def init(self):

    print('enter A')

    print('leave A')

    class B(A):

    def init(self):

    print('enter B')

    super().init()

    print('leave B')

    class C(A):

    def init(self):

    print('enter C')

    super().init()

    print('leave C')

    class D(B, C):

    def init(self):

    print('enter D')

    super().init()

    print('leave D')

    D()

    enter D

    enter B

    enter C

    enter A

    leave A

    leave C

    leave B

    leave D

    展开全文
  • C#之面向对象三大要素

    千次阅读 热门讨论 2018-04-29 21:24:50
    一、面向对象1、什么是面向对象?面向对象是一种思想,面向对象是将功能等...无论是在C#还是在VB中,都反复提及到了面向对象,那么为什么要使用面向对象呢?也就是说面向对象有哪些好处呢?面向对象提高了程序可复...

    一、面向对象

    1、什么是面向对象?

    面向对象是一种思想,面向对象是将功能等通过对象来实现,将功能封装进对象之中,让对象去实现具体的细节,在面向对象中,将数据作为第一位,而方法或者说是算法作为其次,这是对数据的一种优化,操作起来更加方便,简化了过程。

    2、为什么要用面向对象?

    无论是在C#还是在VB中,都反复提及到了面向对象,那么为什么要使用面向对象呢?也就是说面向对象有哪些好处呢?

    面向对象提高了程序的可复用性,可扩展性,和灵活性,通过封装,继承和多态把程序的耦合度降低,使程序更加的灵活,容易修改,并且易于复用。

    二、封装

    1、封装定义

    每个对象都包含它能进行操作所需要的所有信息,这个特性就称为封装。

    个人理解:封装其实类似于一个函数,每个对象都可以实现具体特定的功能,将它实现这个功能所需要的代码都写到一起,这个整体就叫做这个对象的封装。

    2、封装的好处

    第一:良好的封装能够减少耦合(比如一个计算器他可以实现计算和显示结果的功能,将计算模块和显示模块分开写,就减少了程序之间的耦合)

    第二:类内部的实现可以自由地修改

    第三:类具有清晰的对外接口

    三、继承

    今天在进行迷你故事topic的时候,平平提到了一个问题:是水果包含的范围大呢?还是苹果包含的范围大呢?

    这个问题让我们联想到了面向对象中的继承,水果提取了所有水果的共性,而苹果是在具备水果特性的基础上进一步扩展了自己的特性,如果这样理解的话,那是不是苹果所包含的范围大呢?

    1、继承的定义

    对象的继承代表了一种‘is a’的关系,如果俩个对象A和B,可以描述为‘B是A’,则表明B可以继承A。

    例如:猫是哺乳动物,就说明了猫与哺乳动物之间的继承与被继承的关系。

    继承者还可以理解为是对被继承者的特殊化,因为他除了具备被继承者的特性外,还具备自己特有的个性。

    继承定义了类如何相互关联,共享特性。继承的工作方式是:定义父类和子类,或叫做基类和派生类,其中子类继承父类的所有特性。子类不但继承了父类的所有特性,还可以定义新的特性。

    2、继承的好处

    如果子类继承父类:

    第一:子类拥有父类非private的属性和功能

    第二:子类具有自己的属性和功能,即子类可以扩展父类没有的属性和功能

    第三:子类还可以以自己的方式实现父类的功能(方法的重写)

    不用继承的话,如果要修改功能,就必须在所有重复的方法中修改,代码越多,出错的可能就越大,而继承的优点是,继承使得所有子类公共的部分都放在了父类,使得代码得到了共享,这就避免了重复,另外,继承可以使得修改或继承而来的实现都比较容易。

    3、继承的缺点

    父类变,则子类不得不变。

    继承会破坏包装,父类实现细节暴露给子类,这其实是增大了俩个类之间的强耦合关系。所以继承就是一种类与类之间强耦合的关系。

    四、多态

    1、多态的定义

    多态表示不同的对象可以执行相同的动作,但要通过他们自己的实现代码来执行。

    2、使用多态需要注意一下几点

    第一:子类以父类的身份出现

    第二:子类在工作时以自己的方式来实现

    第三:子类以父类的身份出现时,子类特有的属性和方法不可以使用

    为了使子类的实例完全接替来自父类的类成员,父类必须将该成员声明为虚拟的,这是通过该成员的返回类型之前添加virtual关键字来实现。

    将父类实现替换为他自己的实现,就是方法的重写(override),或叫方法赋写。

    不同的对象可以执行相同的动作,但是要通过他们自己的实现代码来执行。

    多态的原理是当方法被调用时,无论对象是否被转换为其父类,都只有位于对象继承链最末端的方法实现会被调用。


    最后献上一张非常生动,形象的图!吐舌头


    展开全文
  • 一、重点知识网络参考模型概念七层,我们一般看为四层UDP每个包64kb查看ip命令:ipconfig测试ip指令 ping同一台电脑使用重复端口时,如果两个程序都被启动了会报异常unknowhostexception不识别主机异常,编译时...

    一、重点知识

    网络参考模型概念七层,我们一般看为四层

    UDP每个包64kb

    查看ip命令:ipconfig

    测试ip指令 ping

    同一台电脑使用重复端口时,如果两个程序都被启动了会报异常

    unknowhostexception不识别的主机异常,编译时异常

    一个域名可以有多个主机,用getAllByName()方法获得所有的主机ip地址

    两台机器之前通讯,就是socket通讯

    Serversocket.accept 是一个会阻塞程序继续执行的方法

    实际上在资源关闭中,只关闭socket就好了,再关闭socket时会关闭他创建的流

    二、课堂知识

    2.1、对象流(操作对象的)

    ObjectInputStream

    readObject()--->Object--->子类对象即可。

    ObjectOutputStream

    writeObject(Object obj)

    没有实现Serializable接口报错:java.io.NotSerializableException: com.qf.demo02.Person

    就是说Person这个类,没有被序列化。没有实现Serializable接口。

    java.io.Serializable接口:类要想具有序列化的功能,那么需要实现java.io.Serializable接口的类启用。 如果没有实现该接口,那么类的实例不会具有序列化和反序列化的功能。

    该接口没有任何的方法需要实现。我们称为“标记接口”。

    序列化和反序列化:

    序列化:将对象,转为一系列的二进制编码。p1--->0101010101011....

    反序列化:将二进制数值,再转为对象的过程,就叫反序列化。0101010101011....--->p1

    serialVersionUID,每一个实现java.io.Serializable的类,表示能够被序列化和反序列化。都需要提供一个serialVersionUID序列化的版本号。如果代码中没有显示的提供,那么程序中自动生成(类中的结构:属性,方法)。序列化的对象的serialVersionUID和反序列化回来的时候serialVersionUID要对应上,否则异常:java.io.InvalidClassException

    在每个类实现java.io.Serializable接口的时候,提供一个固定的serialVersionUID。

    构造方法:

    ObjectOutputStream(OutputStream out)

    创建一个写入指定的OutputStream的ObjectOutputStream。

    ObjectInputStream(InputStream in)

    创建从指定的InputStream读取的ObjectInputStream。

    序列化的注意点:对象

    1、对象的属性能够被序列化,static的属性不能被序列化。

    2、transient修饰符,使用该修饰符修饰的属性,不会被序列化的。

    2.2TCP协议和UDP协议

    2.2.1TCP协议

    1、面向连接,数据传递的时候很安全。

    三次握手,四次挥手。

    2、因为面向连接,所以传递的效率较低。

    3、面向连接,数据安全的。可以传递大量的数据。

    4、服务端和客户端

    服务端:提供服务的

    客户端:来访问服务端,获取数据

    客户端登录,数据下载,文件传输。。

    2.2.2UDP协议:

    1、面向无连接,数据传的时候不是很安全。

    2、因为面向无连接,效率很高。

    3、UDP

    4、没有客户端和服务端的概念。叫做发送方,另一个叫接收方。

    2.3、网络编程的三要素

    2.3.1、协议

    理解为是规则,网络上的双方,都要共同遵守的规定。

    TCP/UDP

    2.3.2、IP地址

    在网络中的主机的唯一标识。

    2.3.3、port端口

    网络程序的唯一标识。int类型的整数。0-65535。

    同一台电脑上一个端口只能被一个网络程序所占用。

    A程序:占用端口9527。启动后,正在使用9527端口,那么其他的程序如果还使用9527端口,就会报错,端口已经被占用。

    2.4、网络编程相关的类:

    2.4.1、InetAddress

    Java中用于描述IP的类

    2.4.2、Socket

    基于TCP协议的客户端的表示。

    2.4.3、ServerSocket

    基于TCP协议的服务端的表示。

    2.5、TCP编程的流程

    服务端流程

    step1:创建ServerSocket,一个服务端的程序:

    step2:等待客户端申请链接,accept()接收链接。——>Socket

    step3:创建流:InputStream,OutputStream

    step4:关闭链接,断开资源

    客户端流程

    step1:创建Socket,客户端的程序

    申请链接服务器:(服务器的ip地址和port)

    step2:创建流:InputStream,OutputStream

    step3:关闭链接,断开资源

    展开全文
  • 1.#可以使用randint()函数来表示概率事件,示例见案例一: **2.property修饰器作用,可保护类属性访问安全和便捷,具体应用还不知道如何探索 ??? 详见案例:代码示例1、 2对比!** 案例一: 示例代码: from ...

    代码综合案例

    探索:

    1.#可以使用randint()函数来表示概率事件,示例见案例一:
    **2.property修饰器的作用,可保护类属性访问的安全和便捷,具体应用还不知道如何探索

    ???

    详见案例三:代码示例1、 2对比!**

    案例一:

    示例代码:

    from abc import ABCMeta, abstractmethod
    from random import randint, randrange
    
    
    class Fighter(object, metaclass=ABCMeta):
        """战斗者"""
    
        # 通过__slots__魔法限定对象可以绑定的成员变量
        __slots__ = ('_name', '_hp')
    
        def __init__(self, name, hp):
            """初始化方法
    
            :param name: 名字
            :param hp: 生命值
            """
            self._name = name
            self._hp = hp
    
        @property
        def name(self):
            return self._name
    
        @property
        def hp(self):
            return self._hp
    
        @hp.setter
        def hp(self, hp):
            self._hp = hp if hp >= 0 else 0
    
        @property
        def alive(self):
            return self._hp > 0
    
        @abstractmethod
        def attack(self, other):
            """攻击
    
            :param other: 被攻击的对象
            """
            pass
    
    
    class Ultraman(Fighter):
        """奥特曼"""
    
        __slots__ = ('_name', '_hp', '_mp')
    
        def __init__(self, name, hp, mp):
            """初始化方法
    
            :param name: 名字
            :param hp: 生命值
            :param mp: 魔法值
            """
            super().__init__(name, hp)
            self._mp = mp
    
        def attack(self, other):
            other.hp -= randint(15, 25)
    
        def huge_attack(self, other):
            """究极必杀技(打掉对方至少50点或四分之三的血)
    
            :param other: 被攻击的对象
    
            :return: 使用成功返回True否则返回False
            """
            if self._mp >= 50:
                self._mp -= 50
                injury = other.hp * 3 // 4
                injury = injury if injury >= 50 else 50
                other.hp -= injury
                return True
            else:
                self.attack(other)
                return False
    
        def magic_attack(self, others):
            """魔法攻击
    
            :param others: 被攻击的群体
    
            :return: 使用魔法成功返回True否则返回False
            """
            if self._mp >= 20:
                self._mp -= 20
                for temp in others:
                    if temp.alive:
                        temp.hp -= randint(10, 15)
                return True
            else:
                return False
    
        def resume(self):
            """恢复魔法值"""
            incr_point = randint(1, 10)
            self._mp += incr_point
            return incr_point
    
        def __str__(self):
            return '~~~%s奥特曼~~~\n' % self._name + \
                '生命值: %d\n' % self._hp + \
                '魔法值: %d\n' % self._mp
    
    
    class Monster(Fighter):
        """小怪兽"""
    
        __slots__ = ('_name', '_hp')
    
        def attack(self, other):
            other.hp -= randint(10, 20)
    
        def __str__(self):
            return '~~~%s小怪兽~~~\n' % self._name + \
                '生命值: %d\n' % self._hp
    
    
    def is_any_alive(monsters):
        """判断有没有小怪兽是活着的"""
        for monster in monsters:
            if monster.alive > 0:
                return True
        return False
    
    
    def select_alive_one(monsters):
        """选中一只活着的小怪兽"""
        monsters_len = len(monsters)
        while True:
            index = randrange(monsters_len)
            monster = monsters[index]
            if monster.alive > 0:
                return monster
    
    
    def display_info(ultraman, monsters):
        """显示奥特曼和小怪兽的信息"""
        print(ultraman)
        for monster in monsters:
            print(monster, end='')
    
    
    def main():
        u = Ultraman('骆昊', 1000, 120)
        m1 = Monster('狄仁杰', 250)
        m2 = Monster('白元芳', 500)
        m3 = Monster('王大锤', 750)
        ms = [m1, m2, m3]
        fight_round = 1
        while u.alive and is_any_alive(ms):
            print('========第%02d回合========' % fight_round)
            m = select_alive_one(ms)  # 选中一只小怪兽
            skill = randint(1, 10)   # 通过随机数选择使用哪种技能
            if skill <= 6:  # 60%的概率使用普通攻击
                print('%s使用普通攻击打了%s.' % (u.name, m.name))
                u.attack(m)
                print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
            elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)
                if u.magic_attack(ms):
                    print('%s使用了魔法攻击.' % u.name)
                else:
                    print('%s使用魔法失败.' % u.name)
            else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)
                if u.huge_attack(m):
                    print('%s使用究极必杀技虐了%s.' % (u.name, m.name))
                else:
                    print('%s使用普通攻击打了%s.' % (u.name, m.name))
                    print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
            if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼
                print('%s回击了%s.' % (m.name, u.name))
                m.attack(u)
            display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
            fight_round += 1
        print('\n========战斗结束!========\n')
        if u.alive > 0:
            print('%s奥特曼胜利!' % u.name)
        else:
            print('小怪兽胜利!')
    
    
    if __name__ == '__main__':
        main()
    

    综合案例二

    扑克牌游戏

    import random
    
    
    class Card(object):
        """一张牌"""
    
        def __init__(self, suite, face):
            self._suite = suite
            self._face = face
    
        @property
        def face(self):
            return self._face
    
        @property
        def suite(self):
            return self._suite
    
        def __str__(self):
            if self._face == 1:
                face_str = 'A'
            elif self._face == 11:
                face_str = 'J'
            elif self._face == 12:
                face_str = 'Q'
            elif self._face == 13:
                face_str = 'K'
            else:
                face_str = str(self._face)
            return '%s%s' % (self._suite, face_str)
        
        def __repr__(self):
            return self.__str__()
    
    
    class Poker(object):
        """一副牌"""
    
        def __init__(self):
            self._cards = [Card(suite, face) 
                           for suite in '♠♥♣♦'
                           for face in range(1, 14)]
            self._current = 0
    
        @property
        def cards(self):
            return self._cards
    
        def shuffle(self):
            """洗牌(随机乱序)"""
            self._current = 0
            random.shuffle(self._cards)
    
        @property
        def next(self):
            """发牌"""
            card = self._cards[self._current]
            self._current += 1
            return card
    
        @property
        def has_next(self):
            """还有没有牌"""
            return self._current < len(self._cards)
    
    
    class Player(object):
        """玩家"""
    
        def __init__(self, name):
            self._name = name
            self._cards_on_hand = []
    
        @property
        def name(self):
            return self._name
    
        @property
        def cards_on_hand(self):
            return self._cards_on_hand
    
        def get(self, card):
            """摸牌"""
            self._cards_on_hand.append(card)
    
        def arrange(self, card_key):
            """玩家整理手上的牌"""
            self._cards_on_hand.sort(key=card_key)
    
    
    # 排序规则-先根据花色再根据点数排序
    def get_key(card):
        return (card.suite, card.face)
    
    
    def main():
        p = Poker()
        p.shuffle()
        players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]
        for _ in range(13):
            for player in players:
                player.get(p.next)
        for player in players:
            print(player.name + ':', end=' ')
            player.arrange(get_key)
            print(player.cards_on_hand)
    
    
    if __name__ == '__main__':
        main()
    

    案例三:工资结算系统

    代码示例1:

    """
    某公司有三种类型的员工 分别是部门经理、程序员和销售员
    需要设计一个工资结算系统 根据提供的员工信息来计算月薪
    部门经理的月薪是每月固定15000元
    程序员的月薪按本月工作时间计算 每小时150元
    销售员的月薪是1200元的底薪加上销售额5%的提成
    
    Author:Rose.
    Date: 2019.8.3
    
    """
    
    from abc import ABCMeta,abstractmethod
    
    class Worker(object,metaclass=ABCMeta):
    	#绑定员工的属性,姓名
    	def __init__(self,name):
    		self._name = name
    		
    	@property
    	def name(self):
    		return self._name
    
    	#定义抽象方法salary用来多态方法
    	@abstractmethod
    	def salary(self):
    		pass
    
    class Department_manager(Worker):
    	#默认继承Worker属性:姓名
    	
    	#定义方法salary用来计算department_manager的薪水
    	def salary(self):
    		print('%s 本月的薪水为: 15000 元'% self._name)
    
    class Programmer(Worker):
    	def __init__(self,name,work_hours=0):
    		super().__init__(name)
    		self._work_hour = work_hours
    
    	@property
    	def work_hours(self):
    		return self._work_hours
    
    	@work_hours.setter
    	def work_hours(self,work_hours):
    		self._work_hours = work_hours
    
    	def salary(self):
    		work_hours = int(input('请输入%s 本月有效工作时间: '% self._name))
    		s = work_hours * 150
    		print('%s 本月的薪水为: %d 元'% (self._name,s))
    
    class Salesman(Worker):
    
    	def salary(self):
    		sale = float(input('请输入%s 本月实际销售额: '% self._name))
    		s = 1200 + sale * 0.05
    		print('%s 本月的薪水为:%d 元'% (self._name,s))
    
    def main():
    	workers = [
    	Department_manager('张飞'),Department_manager('B'),
    	Programmer('C'),Programmer('D'),
    	Salesman('E'),Salesman('F')]
    
    	for worker in workers:
    		worker.salary()
    
    if __name__ == '__main__':
    	main()
    

    代码示例2:

    """
    Just for Test.
    
    Author:Rose.
    Date: 2019.7.30
    
    """
    
    from abc import ABCMeta, abstractmethod
    
    
    class Employee(object, metaclass=ABCMeta):
        """员工"""
    
        def __init__(self, name):
            """
            初始化方法
    
            :param name: 姓名
            """
            self._name = name
    
        @property
        def name(self):
            return self._name
    
        @abstractmethod
        def get_salary(self):
            """
            获得月薪
    
            :return: 月薪
            """
            pass
    
    
    class Manager(Employee):
        """部门经理"""
    
        def get_salary(self):
            return 15000.0
    
    
    class Programmer(Employee):
        """程序员"""
    
        def __init__(self, name, working_hour=0):
            super().__init__(name)
            self._working_hour = working_hour
    
        @property
        def working_hour(self):
            return self._working_hour
    
        @working_hour.setter
        def working_hour(self, working_hour):
            self._working_hour = working_hour if working_hour > 0 else 0
    
        def get_salary(self):
            return 150.0 * self._working_hour
    
    
    class Salesman(Employee):
        """销售员"""
    
        def __init__(self, name, sales=0):
            super().__init__(name)
            self._sales = sales
    
        @property
        def sales(self):
            return self._sales
    
        @sales.setter
        def sales(self, sales):
            self._sales = sales if sales > 0 else 0
    
        def get_salary(self):
            return 1200.0 + self._sales * 0.05
    
    
    def main():
        emps = [
            Manager('刘备'), Programmer('诸葛亮'),
            Manager('曹操'), Salesman('荀彧'),
            Salesman('吕布'), Programmer('张辽'),
            Programmer('赵云')
        ]
        for emp in emps:
            if isinstance(emp, Programmer):
                emp.working_hour = int(input('请输入%s本月工作时间: ' % emp.name))
            elif isinstance(emp, Salesman):
                emp.sales = float(input('请输入%s本月销售额: ' % emp.name))
            # 同样是接收get_salary这个消息但是不同的员工表现出了不同的行为(多态)
            print('%s本月工资为: ¥%s元' %
                  (emp.name, emp.get_salary()))
    
    
    if __name__ == '__main__':
        main()
    
    展开全文
  • [](http://img.blog.itpub.net/blog/2020/02/28/56109223f7fc13f5.png?x-oss-process=style/bb)**面向对象三要素:封装、继承、多态**①. 封装:封装意义,在于明确标识出允许外部使用的所有成员函数和数据项,...
  • 封装就是把属于同一类事物共性(包括属性与方法)归到一个类中,以方便使用。1.概念:封装也称为信息隐藏,是指利用抽象数据类型将数据和基于数据操作封装在一起,使其构成一个不可分割独立实体,数据被保护在...
  • VB面向对象的三要素理解。

    千次阅读 热门讨论 2019-10-13 11:02:20
    面向对象比较通俗解释:对象使人们要进行研究任何事物,从最简单整数到复杂飞机等均可以看做对象,他不仅能表示具体...在VB中,所有可见界面元素和部分硬件资源 都可看作对象,最常用的对象是窗体和控...
  • Java三大要素

    千次阅读 2017-11-25 09:13:22
    java三大要素:继承、封装、多态 继承 每个类只能继承一个类,object默认为所有类父类 关键字: 1.extends:表示继承,用法为extends 2.super:表示当前类父类,用super()表示调用父类构造方法 3....
  • Mybatis三大基本要素

    2019-10-03 09:11:25
    1.核心对象 SqlSessionFactoryBuider...一旦使用SqlSessionFactoryBuider创建SqlSessionFactory对象后,SqlSessionFactoryBuider类就不需要存在了,也就是说不需要保持此对象的状态,可以随意任由JVM销毁。因此Sq...
  • 面向对象三大特征之一——多态 多态:同一个引用类型,使用不同实例而执行不同操作 多态两个要素: 1子类重写父类方法  2使用父类类型 实现多态两种形式: 1 使用父类作为方法形参实现多态 2...
  • 类和对象的使用

    2020-06-07 21:48:16
    面向对象三大特征:封装 继承 多态 java类及类的成员: 属性:对应类的成员变量 行为:对应类的成员方法 对象:类的实例化 类和对象的使用: package lry; /*属性=成员变量=field=域,字段 * 方法=成员方法=函数...
  • 实现多态的三要素 ①编写具有继承关系父类和子类 ②子类重写父类方法 ③使用父类引用指向子类的对象(实例)----向上转型 Pet pet = new Dog(); //Pet 父类 Dog 子类 // 自动类型转换 实现多态两种形式 ①...
  • 设计类与创建对象面向对象与面向过程面向过程面向对象要素三条主线java类及其类的成员面向对象三大特征其他关键字设计类类的成员一(属性)类的成员二(方法)类与对象的使用例题第一题.创建一个 Per类,属性:...
  • Java类和对象

    2019-06-04 10:02:48
    本文将关注面向对象的第三大要素:多态。文章开始先介绍多态的使用方法,然后介绍为什么使用多态。使用多态之前需要先知道三种技术 继承 向上转型 复写(override) 我们姑且把这三种技术称为多态的三要素吧,...
  • VB中面向对象

    2019-10-13 09:56:19
    通过几天VB的深入学习,更加的深入了解了VB的使用方法。从中可以了解了VB的面向对象。...2.面向对象三大要素:属性、事件、对象 对象:在VB 中指的的是所有可见界面元素和大部分的硬件资源等等。(其中我们可以...
  • ggplot2绘图三要素 1.data(通常为dataframe形式) 2.图形属性(用aes()函数添加,所绘制数据所对应x,y轴、数据分组所用颜色等属性) 3.几何对象(用geom_someshape()添加。所绘制数据所使用的的几何形状,大小...
  • 方法四个要素是:方法名、参数列表、返回类型和访问修饰符 3、构造方法是一类名称与类同名,且没有返回类型特殊方法 4、对象的创建就是通过构造方法来完成,其功能主要是完成对象的初始化 5、使用对象名.属性...
  • 4对象的组合

    2017-03-25 22:35:44
    在设计线程安全类过程中,需要包含以下个基本要素: 找出构成对象状态所有变量找出约束状态变量所有不变性条件建立对象状态并发访问管理策略 对象状态是有基本数据类型或者引用数据类型域构成。 /...
  • 2、面向对象的三大要素: (1)封装:封装是“一种隐藏信息技术”,它可以将程序细节性部分隐藏起来,用户不需要知道这些执行细节,只需要使用功能。它能够把使用者和编程人员分割开来。 (2)继承: a、新类...
  • 4.4、创建表面 DirectDrawSurface对象表征了驻留在显示内存中一个表面。如果显示内存用完了或者是显式地创建,该表面也可存在于系统内存中。你可以使用IDirectDraw2::CreateSurface方法创建一个或多个表面。调用...
  • 面向对象的三大基本特征:封装,继承,多态,Java面向对象的最终父类是:object(对象)。对象是万物皆为对象。 1,类定义。 类是java中一种复合数据类型,是java程序基本要素。 访问修饰符class 类名 ...
  • 面向对象

    2021-01-11 23:10:24
    面向对象的三大基本特征是:封装、继承、多态 封装隐藏了类内部实现机制,从而可以在不影响使用前提下改变类内部结构,同时保护了数据 继承是为了重用父类代码,同时为实现多态性作准备 多态性是发送消息给...
  • 到目前为止,我们已经介绍了关于线程安全与同步一些基础知识。然而,我们并不希望对每一系内存访问都进行...在设计线程安全类过程中,需要包含以下个基本要素:找出构成对象状态所有变量。找出约束状态变量...
  • 2、面向对象的三大特征:封装性、继承性、多态性 3、其他关键字:this、super、static、final、 abstract、interface、package、import 面向对象的两个要素: 类:对一类事物描述,是抽象,概念上定义 对象:...
  • 三要素:类名(满足驼峰命名法,名词提炼法)、属性、方法。驼峰命名法:CapWords 每个单词首字母大写、单词与单词之间没有下划线。二、面向对象基础语法1.dir内置函数使用内置函数dir传入标识...
  • 在设计线程安全类过程中,需要包含以下个基本要素: 找出构成对象状态所有变量 找出约束状态变量不变性条件 建立对象状态并发访问管理策略 4.1.1 收集同步需求 状态空间越小,就容易判断线程状态...
  • 面向对象基础

    2020-08-11 16:16:38
    的三要素:类名(名词提炼法、满足驼峰命名规则)、属性(对象的特征描述)、方法(对象的行为、动词),先做需求分析,需求没有涉及,不需要考虑; dir 函数可传入 标识符 / 数据 ,用 dir 函数可以查看对象...
  • 面向对象相关介绍

    2021-01-12 23:34:42
    面向对象的三大特征:封装、继承、多态 面向对象是一种自下而上程序设计方法,以数据为中心,类是表现数据单位。 对象是要进行研究任何事物。 对象的两个要素是属性和方法。 封装范围限定词: private 私有...
  • JavaSE之面向对象

    2020-07-01 10:03:44
    2.面向对象的三大特征:封装性、继承性、多态性 3.关键字 二、面向对象的两个要素 类:对一类事物描述,是抽象、概念上定义 对象:是实际存在该类事物每个个体,因而也称为实例 设计类就是设计类...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 285
精华内容 114
关键字:

对象三大要素的使用