精华内容
下载资源
问答
  • java面向对象三大特征及五原则
    万次阅读 多人点赞
    2019-12-28 17:36:56

    java面向对象

    一、java面向对象的三大特征

    1、封装(Encapsulation)

    封转是指属性私有化

    • 根据需要提供setter和getter方法来访问属性
    • 隐藏具体属性和实现细节,仅对外开放接口
    • 控制程序中属性的访问级别

    目的:增强数据安全性,不能让其他用户随意访问和修改数据,简化编程,使用者不必在意具体实现细节,而只是通过外部接口即可访问类的成员

    2、继承(Extend)

    继承是指将多个相同的属性和方法提取出来,新建一个父类

    • java中一个类只能继承一个父类,且只能继承访问权限非private属性和方法
    • 子类可以重写父类中的方法,命名与父类中同名的属性

    目的:代码复用

    3、多态

    多态(Polymiorph)可以分为两种:设计时多态、运行时多态

    设计(编译)时多态:即重载(Overload),是指java允许方法名相同而参数不同(返回值可以相同也可以不同),同一个类中允许存在一个或多个以上的同名函数,只要参数类型或参数个数不同即可

    运行时多态:即重写(Override)必须是在继承体系中,子类重写父类方法,JVM运行时根据调用该方法的类型决定调用那个方法

    目的:增加代码的灵活度

    总结:

    1、java中应尽量减少继承关系,以降低耦合度

    2、使用多态时,父类在调用方法时,优先调用子类的方法,如果子类没有重写父类的方法,则再调用父类的方法

    3、java访问控制符作用范围表:

    本类本包子类外部包
    public
    protectedX
    defaultXX
    privateXXX

    ✓:可以访问 X:不可访问

    二、java面向对象的五大原则

    单一职责原则:一个类,最好只做一件事,只有一个引起它变化。每个类应该实现单一的职责,如果不是,那就把类拆分

    开放封闭原则:对扩展开放,对修改封闭

    里氏替换原则:子类必须能够替换其基类,里氏替换原则中说,任何基类可以出现的地方,子类一定可以出现

    依赖倒置原则:依赖于抽象接口,不要依赖于具体实现,简单来说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户于与实现模块间的耦合

    接口隔离原则:使用多个小的专门接口,而不是使用一个大的接口

    更多相关内容
  • 面向对象三大特性知识模板 大家好,我是Ziph! 今天分享下面向对象三大特性的知识内容。 结合思维导图学习效果更佳!点击下方链接进入 Java面向对象三大特性思维导图 一、封装 封装的必要性:在对象的外部为对象的...
  • 主要介绍了javascript面向对象三大特征之多态,结合实例形式详细分析了javascript面向对象程序设计中多态的概念、原理,并结合实例形式总结了多态的实现方法与使用技巧,需要的朋友可以参考下
  • 面向对象三大特性

    2020-12-22 01:28:08
    编写类时,你定义一类对象都有的通用行为,基于类创建对象时,每个对象都自动具备这种通用行为,然后可根据需要赋予每个对象独特的个性,使用面向对象编程可以模拟现实情境。根据类来创建对象被称为实例化。 封装 ...
  • 本文主要介绍了面向对象三大特性:封装、继承、多态,提供了简单的示例供大家参考和理解。
  • python 面向对象三大特征

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

    一、面向对象三大特征介绍

    Python 是面向对象的语言,也支持面向对象编程的三大特性:继承、封装(隐藏)、多态。

    1、封装(隐藏)
    隐藏对象的属性和实现细节,只对外提供必要的方法。
    通过“私有属性、私有方法”的方式,实现“封装”。Python 追求简洁的语法
    2、继承
    继承可以让子类具有父类的特性,提高了代码的重用性。从设计上是一种增量进化,原有父类设计不变的情况下,可以增加新的功能,或者改进已有的算法。
    3、多态
    多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是:同样是休息方法,人不同休息方法不同。张三休息是睡觉,李四休息是玩游戏,程序员休息是“敲几行代码”。

    二、继承

    继承是面向对象程序设计的重要特征,也是实现“代码复用”的重要手段。
    如果一个新类继承自一个设计好的类,就直接具备了已有类的特征,就大大降低了工作
    难度。已有的类,我们称为“父类或者基类”,新的类,我们称为“子类或者派生类”。

    1、语法格式

    Python 支持多重继承,一个子类可以继承多个父类。继承的语法格式如下:
        class 子类类名(父类 1[,父类 2,...]):
             类体
    如果在类定义中没有指定父类,则默认父类是 object 类。也就是说,object 是所有类的父
    类,里面定义了一些所有类共有的默认实现,比如:__new__()。
    定义子类时,必须在其构造函数中调用父类的构造函数。调用格式如下:
    父类名.__init__(self, 参数列表)

    class Person:
        def __init__(self,name,age):
            self.name = name
            self.__age = age
    
        def say_age(self):
            print("年龄是:",self.__age)
    
    
    
    class Student(Person):
        def __init__(self,name,age,grade):
            self.grade = grade
            Person.__init__(self,name,age) 
    # 构造函数中包含调用父类构造函数。根据需要,不是必须。 子类并不会自动调用父类的__init__(),我
    # 们必须显式的调用它。
    
    
    if __name__ == '__main__':
        s=Student('诸葛',18,1)
        s.say_age()

    2、类成员的继承和重写

    1. 成员继承:子类继承了父类除构造方法之外的所有成员。
    2. 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”

    class Person:
        def __init__(self,name,age):
            self.name = name
            self.__age = age
    
        def say_age(self):
            print("年龄是:",self.__age)
    
    
    
    class Student(Person):
        def __init__(self,name,age,grade):
            self.grade = grade
            Person.__init__(self,name,age) 
    
        def say_age(self):
            print(self.name,"的年龄是:",self.age)
    # 构造函数中包含调用父类构造函数。根据需要,不是必须。 子类并不会自动调用父类的__init__(),我
    # 们必须显式的调用它。
    
    
    if __name__ == '__main__':
        s=Student('诸葛',18,1)
        s.say_age()

     3、super()获得父类定义

    在子类中,如果想要获得父类的方法时,我们可以通过 super()来做。
    super()代表父类的定义,不是父类对象。

    class A:
        def say(self):
            print("A: ",self)
            print("say AAA")
    class B(A):
        def say(self):
            #A.say(self) 调用父类的 say 方法
            super().say() #通过 super()调用父类的方法
            print("say BBB")
    
    if __name__ =="__main__:
    
        b = B()
        b.say()

    4、设计模式_工厂模式实现

    工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进
    行统一的管理和控制。

    class CarFactory:
        def createCar(self,brand):
            if brand == "1":
                return one()
            elif brand == "2":
                return two()
    
            elif brand == '3':
                return three()
            else:
                return "未知品牌,无法创建"
    class one:
        pass
    class two:
        pass
    class three:
        pass
    factory = CarFactory()
    c1 = factory.createCar("1")
    c2 = factory.createCar("2")
    print(c1)
    print(c2)

    5、设计模式_单例模式实现

    单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一
    个访问该实例的全局访问点。

    单例模式只生成一个实例对象,减少了对系统资源的开销。当一个对象的产生需要比较
    多的资源,如读取配置文件、产生其他依赖对象时,可以产生一个“单例对象”,然后永久
    驻留内存中,从而极大的降低开销。

    class One:
        __obj = None   #  用于存储这个单例
        __init_flag = True
        def __new__(cls, *args, **kwargs):
             # 指的是One这个类里面的  类属性
             if cls.__obj == None:
                   # object 是类的默认父类
                 cls.__obj = object.__new__(cls)
             return cls.__obj
        def __init__(self,name):
            if One.__init_flag:
                print( "init....")
                self.name = name
                One.__init_flag = False
    
    if __name__=='__main__':
        a = One( "aa")
        print(a)
        b = One( "bb")
        print(b)

    展开全文
  • 面向对象三大特征的理解初始理解封装继承多态 初始理解 其实这些知识很早就有接触,而且一些概念也牢记于心了。自己叙述面向对象的特征会是这样的: 面向对象的三大特征是封装、继承和多态。封装是对代码的封装以...

    面向对象三大特征的理解

    初始理解

    其实这些知识很早就有接触,而且一些概念也牢记于心了。自己叙述面向对象的特征会是这样的:
    面向对象的三大特征是封装、继承和多态。封装是对代码的封装以实现迪内聚高耦合的设计,使代码更安全且具有良好的扩展性。继承是父类产生子类的过程,子类可以使用父类的非私有的属性和方法。多态是一个对象在不同时刻可以表现出不同状态的现象。外加Animal和Cat的例子。
    这一段时间敲了不少的Java代码,在敲代码的过程中想了无数次的面向对象这几个概念,对他们有了更深的了解,在这里分享一下。

    封装

    封装确实是对代码的封装,但是只是这样理解却又太肤浅了,至少结合Java来思考一下里面的封装嘛。
    不知道大家有没有想过我们在写JavaBean的时候为什么要将属性的权限修饰为private,其实是为了使我们的代码更安全。分析如下:

    public class Cat {
        //这里通过private修饰属性,外界访问属性需要通过getter和setter方法
        private String name;
        private int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        //假设我们设置age,如果用户恶意将age设置为100
        //众所周知,impossible,因此我们可以通过setter方法进行if判断然后再赋值
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    我们可以考虑一下如果没有setter方法的判断,我们将该类的属性设置为public呢?那么用户的恶意输入,怎样规避呢?
    总之:private是封装的一种体现。
    

    封装还有其他的方法:为了提高代码的复用性可以将公共逻辑抽取成方法,将公共属性抽取成类。例如我们在不同的位置用到了相同的for循环,在idea中我们就可以选中相同的for循环部分,点击快捷键 ctrl + alt + m 将其抽取为方法。

    继承

    继承是面向对象的三大特征之一,过程就是使子类获得父类的属性和方法。
    这个过程较容易理解,关键字是extends,如果我们定义的类没有显式继承某个类,系统默认为我们继承Objects。继承是我们代码的coding量变少了,提高了代码的复用性。
    这里更深的体会是继承提高了代码的维护性。主要表现就是如果方法的代码需要修改,某些情况下我们只需要修改一处就可以实现。
    但是这里还有一点没有想通的继承肯定会增加代码的耦合性,我们为什么还要这样夸大继承呢?我有这种疑问就是陷入了一个思维的误区,可以看这篇文章来解疑:为耦合辩护,为继承伸冤

    多态

    多态的三个必要条件是:

    1. 有继承或实现关系
    2. 有方法的重写
    3. 父类引用指向子类对象
    class Fu {
        int num = 10;
        public void method(){
            System.out.println("Fu.. method");
        }
    }
    class Zi extends Fu {
        int num = 20;
        public void method(){
            System.out.println("Zi.. method");
        }
    }
    public class Test2Polymorpic {
        public static void main(String[] args) {
            Fu f = new Zi();
            System.out.println(f.num);
            f.method();
        }
    }
    

    关于为什么访问成员变量和成员方法的会分别get父类和子类的值和方法,这里有讲解。从虚拟机角度看Java多态->(重写override)的实现原理

    1. 好处:提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作
    2. 弊端:不能使用子类的特有成员
      解决弊端可以通过向下转型:格式为子类型 对象名 = (子类型)父类引用;
    class Fu {
        public void show(){
            System.out.println("Fu..show...");
        }
    }
    class Zi extends Fu {
        @Override
        public void show() {
            System.out.println("Zi..show...");
        }
        public void method(){
            System.out.println("我是子类特有的方法, method");
        }
    }
    public class Test {
        public static void main(String[] args) {
            //向上转型 : 父类引用指向子类对象
            Fu f = new Zi();
            f.show();
            // 多态的弊端: 不能调用子类特有的成员
            // f.method();
            //解决方法:
            // A: 直接创建子类对象
            // B: 向下转型
            //向下转型 : 从父类类型, 转换回子类类型
            Zi z = (Zi) f;
            z.method();
        }
    }
    

    如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException,可以使用instanceOf来解决。

    abstract class Animal {
        public abstract void eat();
    }
    
    class Dog extends Animal {
        public void eat() {
            System.out.println("狗吃肉");
        }
    
        public void watchHome(){
            System.out.println("看家");
        }
    }
    
    class Cat extends Animal {
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
    public class Test4Polymorpic {
        public static void main(String[] args) {
            useAnimal(new Dog());
            useAnimal(new Cat());
        }
    
        public static void useAnimal(Animal a){
            a.eat();
            // 判断a变量记录的类型, 是否是Dog
            if(a instanceof Dog){
                Dog dog = (Dog) a;
                dog.watchHome();
            }
        }
    
    }
    

    最后再来一张图体会一下多态的强大:::::
    equals的参数可以是任意对象类型,这是多态的一种应用

    展开全文
  • 今天小编就为大家分享一篇关于面向对象三大特性的意义讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 本文实例讲述了javascript面向对象三大特征之继承。分享给大家供大家参考,具体如下: 继承 在JavaScript中的继承的实质就是子代可以拥有父代公开的一些属性和方法,在js编程时,我们一般将相同的属性放到父类中,...
  • java面向对象的精髓在于考虑问题的思路是从现实世界的人类思维习惯出发的,只要领会了这一点,就领会了面向对象的思维方法。这里有面向对象三大特征的思维导图帮你清楚的理解java面向对象。
  • 面向对象三大特性:封装、继承和多态。 今天学最后一个特性:多态。 什么叫多态呢?按照字面意思理解就是多种形态的意思。 还是举昨天的那个例子: 动物园里动物都得吃食物,兔子吃胡萝卜,猫吃鱼,狗吃肉。 同一...
  • 面向对象三大特征介绍

    千次阅读 2019-06-18 16:05:20
    面向过程和面向对象区别 我们都常听到软件设计思想有面向对象和面向过程。那么什么是面向对象、什么是面向过程呢? 接下来我举个例子说明一下他们两者的区别。 有一天你想吃鱼香肉丝,怎么办,有两个选择。 第一...

    面向过程和面向对象区别

    我们都常听到软件设计思想有面向对象和面向过程。那么什么是面向对象、什么是面向过程呢?

    接下来我举个例子说明一下他们两者的区别。

      有一天你想吃鱼香肉丝,怎么办,有两个选择。

     第一:自己买鱼、肉丝、调料、胡萝卜等其他配菜,然后洗菜,开炒,装盘。

     第二:去饭店,“老板,给我来一份鱼香肉丝”。

    那么这两种有什么区别呢?很显然,第一种是面向过程思想,第二种是面向对象思想。

    面向对象有什么优势呢?

     首先不需要知道鱼香肉丝是怎么做的,降低了耦合性,如果有一天不喜欢吃鱼香肉丝了,喜欢吃番茄炒蛋的话,对于一来说,有点难了,需要从新买菜。对于第二来说,好,马上换就可以了。提高了可维护性,总的来说,降低了耦合度,提高了可维护性。

    面向对象是具体化的,流程化的,解决一个问题,需要一步一步分析,一步一步实现。

    面向对象是模型化的,只要出现出一个类,密封好,等需要用的时候直接用就可以了,不需要要一步一步实现。

     

    面向过程优点和缺点:

      优点:性能比面向对象好,因为类调用时需要实例化,开销比较大,比较浪费资源。

      缺点:不易维护、不易复用、不易扩展

     

    面向对象优点和缺点:

      优点:易维护、易复用、易扩展、面向对象有封装、继承、多态的特征,可以设计出低耦合的系统,使系统更加灵活、易于维护。

      缺点:性能比面向过程差

     

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

     1、封装

      所谓的封装,就是把客观的事物封装成抽象类,例如把密某个人需要做某件事,我们把某个人看成一个类,把他需要用的工具带在身上,他用到的方法装在脑子里,我不管他是怎么完成这件事的,他只要给我返回这件事的结构就可以了,不需要关心这件事怎么做,这就是封装。

    2、继承

        继承有这样一种能力,就是使用现有允许使用的功能。并不需要重新编写这些类已经有的功能。通过继承创建了新的类成为子类或派生类。被继承的成为基类。继承有两种,一种是实现继承,另一种是接口继承。

             实现继承:可以直接使用基类的属性和方法,无需额外编码。

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

    2、多态

      所谓的多态就是对一个实例的相同方法在不同的情况下有不同表现形式。多态机制使得不同内部结构的对象可以共享相同的外部接口。这意味着,虽然不同类的内部操作不同,但是可以通过一个公共类,他们可以通过相同的方法给与调用。

    展开全文
  • 面向对象三大特征

    千次阅读 2021-05-28 18:22:50
    Java知识点总结:想看的可以从这里进入 3、 面向对象三大特征 面向对象的三大特征:继承、封装、多态 3.1、封装 封装是面向对象编程的核心思想,将对象的属性和行为封装隐藏起来。而这些封装起来的属性和行为通常...
  • java面向对象三大特性

    千次阅读 2021-03-01 19:31:10
    一、面向对象的概念 面向对象是一种符合人类思维习惯的编程思想。现实生活中存在各种形态不同的事物,这些事物之间存在着各种各样的联系。在程序中使用对象来映射现实中的事物使用对象的关系来描述事物之间的联系,...
  • 面向对象三大核心特性简介面向对象开发模式更有利于人们开拓思维,在具体的开发过程中便于程序的划分,方便程序员分工合作,提高开发效率。该开发模式之所以使程序设计更加完善和强大,主要是因为面向对象具有继承...
  • C++面向对象三大特征(四大特征三大特征:封装、继承、多态 四大特征:抽象、封装、继承、多态 一、类和对象 什么是类,什么是对象,类和对象的区别? 类是数据类型,是具有相同属性和服务的一组对象的集合。...
  • Java中面向对象三大特性及其各自的用处:封装,继承,多态 一.封装: 封装把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏,这就是封装。封装是面向对象...
  • php /* * 封装性:面向对象三大特性之一 * * 1.就是把对象的成员(属性,方法)结合成一个独立的相同单位,并尽可能隐藏对象的内部细节 * 访问权限修饰符 public protected private * private:私有的,用这个关键字...
  • 主要介绍了javascript面向对象三大特征之封装,简单描述了封装的基本概念、原理,并结合实例形式详细分析了javascript面向对象程序设计中封装的用法与相关操作注意事项,需要的朋友可以参考下
  • 面向过程和面向对象 区别 面向过程:关注的是过程 中的每一个环节 吃蛋炒饭:买鸡蛋→买米→蒸米→炒蛋→炒米→混合→搅拌→蛋炒饭 面向对象:关注的是让对象 做事情 找一个对象(老公或老婆).做蛋炒饭 ...
  • java练习题chp6 Key Point ●封装/数据隐藏 ●继承的基本语法 ●访问修饰符 ●对象创建过程 ●super 关键字 ●方法覆盖 ●多态的基本语法和使用 ●instanceof●多态用在参数和返回值上
  • 目录C语言面向对象为什么要面向对象什么是面向对象封装继承多态驱动设计名字API功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个...
  • 面向对象三大特性.doc

    2021-09-27 12:25:37
    面向对象三大特性.doc
  • Java面向对象三大特性(封装、继承、多态)

    千次阅读 多人点赞 2021-05-19 20:59:41
    面向对象的语言有三大特性:封装、继承、多态。三大特性面向对象编程的核心。下面就来介绍一下面向对象三大特性。 如果想了解面向对象可以看一下这一篇博客类和对象 一、封装 1.封装的概念 在我们写代码的时候...
  • Java面向对象三大特征

    千次阅读 2022-01-19 21:04:40
    面向对象三大特征之一(封装,继承,多态) 是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作的 封装原则 将类的某些信息隐藏在类内部,不允许外部程序直接访问...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 378,360
精华内容 151,344
关键字:

面向对象的三大特性