精华内容
下载资源
问答
  • 封装继承多态的理解 封装 即把对象的属性和方法包裹起来, 只能通过约定好的接口实现访问 封装是一种信息隐藏技术,在java中通过关键字private实现封装。 封装的作用: ① 对象的数据封装特性彻底消除了传统结构...

    对封装继承多态的理解

    封装

    • 即把对象的属性和方法包裹起来, 只能通过约定好的接口实现访问
    • 封装是一种信息隐藏技术,在java中通过关键字private实现封装。

    封装的作用:

    ① 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题,提高了程序的可复用性和可维护性,降低了程序员保持数据与操作内容的负担。
    ②对象的数据封装特性还可以把对象的私有数据和公共数据分离开,保护了私有数据,减少了可能的模块间干扰,达到降低程序复杂性提高可控性的目的。

    继承

    继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力。
    为什么要继承呢:

    1、反映现实的真实关系

    2、减少代码冗余

    3、对父类的属性和方法进行扩展和重写
    继承中,子类不可以选择性的继承父类的东西,而是全部继承父类的属性和方法。其中父类又叫超类或基类,子类又叫派生类。父类是子类的一般化,子类是父类的特化(具体化)。java中不支持多继承,一个类最多只能有一个父类。而在java中多继承是通过接口实现的。

    抽象类和接口的区别

    抽象了和接口都不能直接实例化,子类继承/实现,抽象类/接口必须实现所有方法,否则子类只能是一个抽象类或接口

    接口中的方法定义默认为public abstract类型,接口中的成员变量类型默认为public static final。

    1. 抽象类中可以有构造方法,接口中不能
    2. 抽象类可以有普通成员变量(public,protected,private),接口只能有静态变量默认为public static final
    3. 抽象类可以有普通方法,接口所有方法必须是抽象的
    4. 抽象类中可以有静态方法,并且能调用,接口不能有静态变量(JDK1.8后接口也可以有可调用的静态变量
    5. 类只能单继承,接口可以多继承

    多态

    多态主要是基于继承和重写,最终可以实现相同的类型调用相同的方法,结果不相同

    例如:有一个动物类,里面有一个方法输出,动物吃食物

    小猫继承动物类后,重写这个方法输出,小猫吃鱼干

    小狗继承动物类后,输出小狗吃骨头

    展开全文
  • 学的差不多了,是时候对于学习的内容弄个总结,在这里写一下对于封装继承多态的理解,本人小白,有说的不对和不详细的地方勿喷,主要是对自己的一个总结 一.封装 本人觉得封装就像是一种包装,将类的内部的一些隐藏...

    前言
    学的差不多了,是时候对于学习的内容弄个总结,在这里写一下对于封装继承多态的理解,本人小白,有说的不对和不详细的地方勿喷,主要是对自己的一个总结

    一.封装

    本人觉得封装就像是一种包装,将类的内部的一些隐藏信息隐藏起来,让外界的程序不能直接访问,只能通过类提供的一些方法来进行访问,最常见的就是set或者get方法,这就是封装的“开闭原则”,
    即禁止外部直接访问类内部信息

    二.继承

    对于继承呢,其实这就是一种类与类之间的一种关系,即子类拥有父类所有的方法和属性,但是除了父类中private修饰的属性,这样可以形成代码的复用

    三.多态

    多态分为引用多态和方法多态,其中引用多态表示父类既可以引用自己本类对象,又可以引用子类对象。
    方法多态就是对于子类重写了父类的方法,方法之间还可以进行重载,子类对象调用不同的方法从而表现出多态。
    多态本人理解为一个对象表现出不同的行为就是多态。

    展开全文
  • 1.封装封装的定义:首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有属性和动作隐藏起来,只保留特定方法与外界联系为什么需要封装封装符合面向对象设计原则第一条:单一性原则,一个类把自己该做...

    1.封装

    封装的定义:

    首先是抽象,把事物抽象成一个类,其次才是封装,将事物拥有的属性和动作隐藏起来,只保留特定的方法与外界联系

    为什么需要封装:

    封装符合面向对象设计原则的第一条:单一性原则,一个类把自己该做的事情封装起来,而不是暴露给其他类去处理,当内部的逻辑发生变化时,外部调用不用因此而修改,他们只调用开放的接口,而不用去关心内部的实现

    举例:

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    public class Human

    {

    private int age;

    private String name;

    public int getAge()

    {

    return age;

    }

    public void setAge( int age ) throws Exception

    {

    //封装age的检验逻辑,而不是暴露给每个调用者去处理

    if( age > 120 )

    {

    throw new Exception( "Invalid value of age" );

    }

    this.age = age;

    }

    public String getName()

    {

    return name;

    }

    public void setName( String name )

    {

    this.name = name;

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    2. 继承

    Java的类可以分为三类:

    类:使用class定义,没有抽象方法

    抽象类:使用abstract class定义,可以有也可以没有抽象方法

    接口:使用inerface定义,只能有抽象方法

    在这三个类型之间存在如下关系:

    类可以extends:类、抽象类(必须实现所有抽象方法),但只能extends一个,可以implements多个接口(必须实现所有接口方法)

    抽象类可以extends:类,抽象类(可全部、部分、或者完全不实现父类抽象方法),可以implements多个接口(可全部、部分、或者完全不实现接口方法)

    接口只能extends一个接口

    继承以后子类可以得到什么:

    子类拥有父类非private的属性和方法

    子类可以添加自己的方法和属性,即对父类进行扩展

    子类可以重新定义父类的方法,即多态里面的覆盖,后面会详述

    关于构造函数:

    构造函数不能被继承,子类可以通过super()显示调用父类的构造函数

    创建子类时,编译器会自动调用父类的 无参构造函数

    如果父类没有定义无参构造函数,子类必须在构造函数的第一行代码使用super()显示调用

    类默认拥有无参构造函数,如果定义了其他有参构造函数,则无参函数失效,所以父类没有定义无参构造函数,不是指父类没有写无参构造函数。看下面的例子,父类为Human,子类为Programmer。

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    public class Human

    {

    //定义了有参构造函数,默认无参构造函数失效

    public Human(String name)

    {

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    public class Programmer

    extends Human

    {

    public Programmer()

    {

    //如不显示调用,编译器会出现如下错误

    //Implicit super constructor Human() is undefined. Must explicitly invoke another constructor

    super( "x" );

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    为什么需要继承:

    代码重用是一点,最重要的还是所谓想上转型,即父类的引用变量可以指向子类对象,这是Java面向对象最重要特性多态的基础

    3. 多态

    在了解多态之前,首先需要知道方法的唯一性标识即什么是相同/不同的方法:

    一个方法可以由:修饰符如public、static+返回值+方法名+参数+throw的异常 5部分构成

    其中只有方法名和参数是唯一性标识,意即只要方法名和参数相同那他们就是相同的方法

    所谓参数相同,是指参数的个数,类型,顺序一致,其中任何一项不同都是不同的方法

    何谓重载:

    重载是指一个类里面(包括父类的方法)存在方法名相同,但是参数不一样的方法,参数不一样可以是不同的参数个数、类型或顺序

    如果仅仅是修饰符、返回值、throw的异常 不同,那这是2个相同的方法,编译都通不过,更不要说重载了

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    //重载的例子

    public class Programmer

    extends Human

    {

    public void coding() throws Exception

    {

    }

    public void coding( String langType )

    {

    }

    public String coding( String langType, String project )

    {

    return "";

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    //这不是重载,而是三个相同的方法,编译报错

    public class Programmer

    extends Human

    {

    public void coding() throws Exception

    {

    }

    public void coding()

    {

    }

    public String coding()

    {

    return "";

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    何谓覆盖/重写:

    覆盖描述存在继承关系时子类的一种行为

    子类中存在和父类相同的方法即为覆盖,何谓相同方法请牢记前面的描述,方法名和参数相同,包括参数个数、类型、顺序

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    public class Human

    {

    public void coding( String langType )

    {

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    public class Programmer

    extends Human

    {

    //此方法为覆盖/重写

    public void coding( String langType )

    {

    }

    //此方法为上面方法的重载

    public void coding( String langType, String project )

    {

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    覆盖/重写的规则:

    子类不能覆盖父类private的方法,private对子类不可见,如果子类定义了一个和父类private方法相同的方法,实为新增方法

    重写方法的修饰符一定要大于被重写方法的修饰符(public > protected > default > private)

    重写抛出的异常需与父类相同或是父类异常的子类,或者重写方法干脆不写throws

    重写方法的返回值必须与被重写方法一致,否则编译报错

    静态方法不能被重写为非静态方法,否则编译出错

    理解了上述知识点,是时候定义多态了:

    多态可以说是“一个接口,多种实现”或者说是父类的引用变量可以指向子类的实例,被引用对象的类型决定调用谁的方法,但这个方法必须在父类中定义

    多态可以分为两种类型:编译时多态(方法的重载)和运行时多态(继承时方法的重写),编译时多态很好理解,后述内容针对运行时多态

    运行时多态依赖于继承、重写和向上转型

    上例子:

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    class Human

    {

    public void showName()

    {

    System.out.println( "I am Human" );

    }

    }

    //继承关系

    class Doctor

    extends Human

    {

    //方法重写

    public void showName()

    {

    System.out.println( "I am Doctor" );

    }

    }

    class Programmer

    extends Human

    {

    public void showName()

    {

    System.out.println( "I am Programmer" );

    }

    }

    public class Test

    {

    //向上转型

    public Human humanFactory( String humanType )

    {

    if( "doctor".equals( humanType ) )

    {

    return new Doctor();

    }

    if( "programmer".equals( humanType ) )

    {

    return new Programmer();

    }

    return new Human();

    }

    public static void main( String args[] )

    {

    Test test = new Test();

    Human human = test.humanFactory( "doctor" );

    human.showName();//Output:I am Doctor

    human = test.humanFactory( "programmer" );

    human.showName();//Output:I am Programmer

    //一个接口的方法,表现出不同的形态,意即为多态也

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    向上转型的缺憾:

    只能调用父类中定义的属性和方法,对于子类中的方法和属性它就望尘莫及了,必须强转成子类类型

    总结概括:

    当超类对象引用变量引用子类对象时,被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,但是这个被调用的方法必须是在超类中定义过的,也就是说被子类覆盖的方法,但是它仍然要根据继承链中方法调用的优先级来确认方法,该优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)

    稍微复杂的例子:

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    class Human {

    public void fun1() {

    System.out.println("Human fun1");

    fun2();

    }

    public void fun2() {

    System.out.println("Human fun2");

    }

    }

    class Programmer extends Human {

    public void fun1(String name) {

    System.out.println("Programmer's fun1");

    }

    public void fun2() {

    System.out.println("Programmer's fun2");

    }

    }

    public class Test {

    public static void main(String[] args) {

    Human human = new Programmer();

    human.fun1();

    }

    /*

    * Output:

    * Human fun1

    * Programmer's fun2

    */

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    Programmer中的fun1(String name) 和Human中的fun1(),只是方法名相同但参数不一样,所以是重载关系

    Programmer中的fun2()和Human中的fun2()是相同的方法,即Programmer重写了Human的fun2()方法

    把Programmer的对象向上转型赋值个Human后,human.fun1()会调用父类中的fun1()方法,子类的fun1(String name)是不同的方法

    在human的fun1()中又调用了fun2()方法,该方法在Programmer中被重写,实际调用的是被引用变量Programmer中的fun2()方法

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    package test;

    class A {

    public void func() {

    System.out.println("func in A");

    }

    }

    class B extends A {

    public void func() {

    System.out.println("func in B");

    }

    }

    class C extends B {

    public void func() {

    System.out.println("func in B");

    }

    }

    public class Bar {

    public void test(A a) {

    a.func();

    System.out.println("test A in Bar");

    }

    public void test(C c) {

    c.func();

    System.out.println("test C in Bar");

    }

    public static void main(String[] args) {

    Bar bar = new Bar();

    A a = new A();

    B b = new B();

    C c = new C();

    bar.test(a);

    bar.test(b);

    bar.test(c);

    /*

    func in A

    test A in Bar

    func in B

    test A in Bar

    func in B

    test C in Bar

    */

    }

    }

    48304ba5e6f9fe08f3fa1abda7d326ab.png

    展开全文
  • python中面对对象 封装 继承 多态的理解封装封装就是把对象的属性和行为结合成一个独立的整体,把内部的实现细节隐藏起来,不能被外界所看见,调用的人只能执行,而看不到实现的细节,保证了代码的安全性继承:从...

                          python中面对对象 封装 继承 多态的理解


    封装:封装就是把对象的属性和行为结合成一个独立的整体,把内部的实现细节隐藏起来,不能被外界所看见,调用的人只能执行,而看不到实现的细节,保证了代码的安全性

    继承:从已有类中派生出新的实例对象,子类继承父类的属性和方法,并且自己可以拓展出自己独有的属性和方法。保证了代码的复用率

    多态:指的是不同的对象对相同的属性或者方法做出不同的响应。多态可以提高代码的灵活度

    展开全文
  • 数据封装继承多态是面向对象三大特点。数据封装:在某个类中,比如Student类(初始化有name和score两个属性),每个实例都拥有各自name,score这些数据。我们可以通过函数来访问这些数据,比如打印一个学生...
  • 一:封装将类某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供方法来实现对隐藏信息操作和访问,常见实现方式就是:getter、setter。封装遵循了“开闭原则”,禁止外部直接访问和修改类...
  • 虽然是基础,但是我们要明白,所有东西都是要在基础上发展,没有基础就去学其他,那么你肯定是很容易失败,那么应该怎样能够用傻瓜式方法去理解Java面向对象的封装继承多态呢?现在我们先来说说什么是面向...
  • 房子有户型,总面积和家具名称列表新房子没有任何家具2.家具有名字和占地面积,其中床:占4平米衣柜:占2平米餐桌:占1.5平米3.将以上三件家具添加到房子中4.打印房子时,要求输出:户型,总面积,剩余面积,家具...
  • 个人对OOP的理解封装继承多态 封装 权限修饰符public,private,protected以及缺省(不声明它的权限)声明了一个类中的拥有的属性和方法的可访问性。 public:开放程度最高。 private:只能在类内访问。 ...
  • 面向对象编程(Object Oriented Programming,OOP,面向对象...面向对象三大特性是指:封装继承多态1、封装第一步:将内容封装到某处self 是一个形式参数:当执行obj1 = Foo('wupeiqi', 18 ) 时,self 等于 obj...
  • 今天为大家带来内容是:Python 面向对象时多项操作实例分析(封装继承多态)本文内容主要介绍了Python 面向对象之封装继承多态操作,结合实例形式分析了Python面相对象程序设计中封装继承多态相关操作...
  •  降低了层序耦合性,增加了层序易维护性 继承关系具有传递性例如a有父类b,b有父类c,则c也可以称为a父亲 方法重写当子类出现和父类一模一样方法时,子类对象调用该方法,会运行子类方法内容,如同...
  • 一、怎么理解JAVA中封装继承多态他是一个“司机”,他的...用汉字来打个比方,很显然,比如“开”这个字,在不同的时候各有的意思,比如“开门”、继承多态 继承,先说说我对类的理解,类起到的作用有:分类...
  • 封装 继承 多态 抽象的理解
  • 继承的好处:1,提高了代码复用性。2,让类与类之间产生了关系,给第三个特征多态提供了前提。java中支持单继承,一个子类织女呢个有一个直接父类。java支持多层继承,当要使用一个继承体系时,1,查看该体系中...
  • C++封装继承多态理解

    2020-12-29 19:33:05
    面向对象三个基本特征: 封装继承多态 简单概括三大特性作用: 封装是为了代码模块化和增加安全性 继承是为了重用和扩展现有代码模块 多态是为了接口复用 封装: 保护数据成员,不让类以外程序...
  • 体现面向对象三个特征:封装继承多态 封装 提高了代码复用性 提高安全性 隐藏实现细节 给外部提供一个可以访问方式(get/set方法也就是赋值和取值过程) 便于调用者使用 封装就像机箱一样把电脑...
  • 怎么理解封装继承多态 理解封装:将类属性和操作属性方法封装起来,访问时候,访问自己封装接口。 理解继承: 子类从父类继承所有信息,但不能访问父类私有属性和方法; 子类可有新属性和方法;也可以...
  • Java 封装继承多态1.封装封装的理解:将类的某些信息隐藏在类的内部,不允许外部程序直接访问,并通过该类提供的方法来实现对隐藏信息的操作和访问。(简单的说就是隐藏对象的信息,留出访问的接口)。特点:1....
  • 封装是通过限制只有特定类对象可以访问这一特定类成员,而它们通常利用接口实现消息传入传出。具备封装性(Encapsulation)面向对象程序设计隐藏了某一方法具体执行步骤,取而代之是通过消息传递机制...
  • 面向对象编程特点封装继承多态重写重载抽象 封装 将方法和数据绑定,对数据访问只能通过自定义接口。编写类就是一个封装过程。封装就是将里面内容全部隐藏,只提供调用接口。比如遥控器。 继承 继承...
  • 封装继承多态封装概念:将一个对象数据隐藏在对象内部,不让在外界直接访问,而是通过对象提供方法来访问这些隐藏起来数据,这样就可以在访问方法中添加访问条件限制,目的是对数据有效组织和数据安全性...
  • Java封装继承多态及面向对象一些理解 Java基本特性三个:封装、继承、多态。但是初看这三个字面意思非常难理解其精髓。即使看了很多例子也是一知半解感觉。本文主要就自己理解说一下这三个特性含义。 ...
  • java 封装 继承 多态

    千次阅读 2019-03-16 21:15:08
    面向对象编程(Object Oriented Programming)有三大特性:封装继承多态。在这里,和大家一起加深对三者的理解封装 封装可以拆开理解,装,是把数据和方法放进了类里;封,把装进去的数据和成员方法加上访问...
  • 封装继承多态举例

    千次阅读 2017-03-16 21:50:19
    大家都知道php是面向对象,面向对象就少不了封装继承多态。 1.什么时候封装函数?1.内容重复利用2.单独功能,不同功能可以封装成不同函数其实每个功能都可以封装成一个函数,封装好了这样方便在主函数中调用,...
  • 对C++继承封装多态的理解

    千次阅读 2018-09-01 19:56:32
    C++是一款面向对象的语言,拥有面向对象语言的三大核心特性:继承封装多态。每一个特性的良好理解与使用都会为我们的编程带来莫大的帮助。下面我就这三个特性讲一下我对C++的理解。   继承  学过面向对象...
  • 封装继承多态

    千次阅读 2019-04-29 22:17:46
    封装的目的 增强安全性和简化编程,使用者不必了解具体实现细节,而只要通过对外公开访问方法,来使用类成员。...可以理解为,在一个现有类基础之上,增加新方法或重写已有方法,从而产生...
  • Java中的封装继承多态封装什么是封装为什么要封装封装详细理解继承相关关键字其他继承相关参考 封装 什么是封装 下面是来自百度百科解释:  封装是把过程和数据包围起来,对数据访问只能通过已定义...

空空如也

空空如也

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

封装继承多态的理解