精华内容
下载资源
问答
  • C#面向对象基础

    2019-10-08 10:32:59
    Protected 表示继承时子类可以对基类有完全访问权,也就是说,用protected修饰的类成员,对子类公开,但不对其他类公开。 如果在类中的成员没有加修饰符,则被认为是private。 通常字段是private,...

    Public 表示它所修饰的类成员可以允许其他任何类来访问,俗称公有的。

    Private 表示只允许同一个类中的成员访问,其他类包括它的子类无法访问,俗称私有的。

    Protected 表示继承时子类可以对基类有完全访问权,也就是说,用protected修饰的类成员,对子类公开,但不对其他类公开。

    如果在类中的成员没有加修饰符,则被认为是private。

    通常字段是private,即私有变量,而属性是public,即公有变量。

    属性名称一般首字母大写,字段一般首字母小写或前加“_”。

     

    构造方法又叫构造函数,其实就是对类进行初始化。构造方法与类同名,无返回值,也不需要void,在new时候调用。

    所有的类都有构造方法,如果不编码则系统默认生成空的构造方法,若有定义的构造方法,则默认的构造方法就会失效。

     

    方法重载提供了创建同名的多个方法的能力,但这些方法需要使用不同的参数类型或参数个数有所不同。

     

    属性是一个方法或一对方法,但在调用它的代码来看,它是一个字段,及属性适合一字段的方式使用方法调用的场合。字段是存储类要满足其设计需要的数据,字段是与类相关的变量。

     

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

    封装的好处:第一、良好的封装能够减少耦合。

                         第二、类内部的实现可以自由的修改。

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

     

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

    如果子类继承于父类:第一、子类拥有父类非private的属性和功能

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

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

    子类从它的父类中继承的成员有方法、域、属性、事件、索引器。但对于构造方法,它不能被继承,只能被调用。对于调用父类的成员,可以用base关键字。

     

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

    第一、   子类以父类的身份出现。

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

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

    为了使子类的实例完全接替来自父类的类成员,父类必须将该成员声明为虚拟的。这是通过在该成员的返回类型之前添加virtual关键字来实现。子类可以选择使用override关键字,将父类实现替换为它自己的实现,这就是方法重写Override,或者叫做方法覆盖。

    注:通常虚拟的是方法,但其实除了字段不能是虚拟的,属性、事件‘索引器都可以是虚拟的。尽管方法可以是虚拟的,但虚拟方法还是有方法体,可以实际做些事情。

    对象的生命必须是父类,而不是子类,实例化的对象是子类,这才能实现多态。多态的原理是当方法被调用时,无论对象是否被转换为其父类,都只有位于对象继承链最末端的方法实现会被调用。也就是说,虚方法是按照其运行时的类型而非编译时类型进行动态绑定调用的。

    例如:动物 animal=new 狗();

             或者

             狗 dog =new 狗();

             动物 animal=dog();

     

    抽象类需要注意几点:

    第一、   抽象类不能实例化

    第二、   抽象方法是必须被子类重写的方法。其实抽象方法可以看成是没有实现体的虚方法。

    第三、   如果类中包含抽象方法,那么类就必须定义为抽象类,不论是否还包含其他一般方法。

    抽象类通常代表一个抽象概念,它提供一个继承的出发点,当设计一个新的抽象类时,一定是用来继承的,所以,在一个以继承关系形成的等级结构里,树节点应当是具体类,而树枝节点均应当是抽象类。

     

    接口是把隐式公共方法和属性组合起来,以封装特定功能的一个集合。一旦类实现了接口,类就可以支持接口所指定的属性和成员。声明接口在语法上与声明抽象类完全相同,但不允许提供接口中任何成员的执行方式。

    接口不能实例化、不能有构造方法和字段、不能有修饰符、不能声明虚拟的或静态的、实现接口的类就必须实现接口中的所有方法和属性。

    一个类可以支持多个接口,多个类也可以支持相同的接口。

    接口中的方法或属性不能有修饰符,方法没有方法体。

    interface IChange

    {

           string ChangeThing(string thing);

    }

     

    抽象类可以给出一些成员的实现,接口却不能包含成员的实现

    抽象类的抽象成员可被子类部分实现,接口的成员需要实现类完全实现

    一个类只能继承一个抽象类,但可以实现多个接口

    第一、   类是对对象的抽象,抽象类是对类的抽象,接口是对行为的抽象。

    第二、   如果行为跨越不同类的对象,可以使用接口;对于一些相似的类对象,用继承抽象类。

    第三、   从设计角度讲,抽象类是从子类发现公共的东西,泛化出父类,然后子类继承父类,而接口是根本不知子类的存在,方法如何实现还不确定,预先定义。        

     

    数组的优点:在内存中连续存储,因此可以快速而容易地从头到尾遍历元素,可以快速修改元素等等。

    数组的缺点:创建时必须要制定数组变量的大小,还有在两个元素之间添加元素也比较困难。

     

    集合

    ArrayList是命名空间System.Collections下的一部分,它是使用大小可按需要动态增加的数组实现IList接口。ArrayList的容量是ArrayList可以保存的元数据。ArrayList的默认初始容量为0.随着元素添加到ArrayList中,容量会根据需要通过重新分配自动增加。使用整数索引可以访问此集合中的元素。此集合中的索引从零开始。

    ArrayList的优点:可以根据使用大小按需动态增加,不用受事先设置其大小的控制。

                                可以随意添加、插入或移除某一范围的元素,比数组要方便。

    ArrayList的缺点:ArrayList不管是什么对象都接受,所有元素都看成Object,ArrayList不是类型安全的。

                                ArrayList将值类型装箱为Object对象,使用集合元素时需要拆箱操作,带来很大的性能损耗。

    泛型是具有占位符(类型参数)的类、结构、接口和方法,这些占位符是类、结构、接口和方法所存储或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对象的类型的占位符:类型参数作为其字段的类型和其方法的参数类型出现。

     

    委托与事件

    委托是对函数的封装,可以当作给方法的特征制定一个名称。而事件则是委托的一种特殊形式,当发生有意义的事情时,事件对象处理通知过程。

    委托是一种引用方法的类型。一旦为委托分配了方法,委托将与该方法具有完全相同的行为,委托对象用关键字delegate来声明。在发生其他类或对象关注的事情时,类或对象可以通过事件通知它们,事件对象用event关键字声明。

     

    转载于:https://www.cnblogs.com/hlfei/p/3807581.html

    展开全文
  • 修饰符   Private ...只对子类公开 修饰符就是对变量、方法的公开程度的定义、设置权限 属性 类里写属性是要写成方法的、先定义一个变量、然后设置他的读写方法、get和set、如图


    修饰符就是对变量、方法的公开程度的定义、设置权限


    修饰符

     点击查看链接

    Private

     私有

    public

    共有

    Protected

    只对子类公开



    属性:

          类里写属性是要写成方法的、先定义一个变量、然后设置他的读写方法、get和set、如图



    之所以变量定义成私有、写成方法、是因为这样可以控制变量、对其限制、下面是对小猫叫次数的限定




    总结:

         其实修饰符就是定义访问权限、对其进行限制、而写类的属性就是定义一个变量、写成一个方法、方法对这个变量进行读写属性。



    ——————chenchen——————

    展开全文
  • 完全对外公开,只对子类公开,完全不公开,这里对子类的可见性是完全不受继承时的可见性影响的,就是说无论是public,protected还是private继承,父类public protected属性在子类中时永远可见的,private时永远不...

    继承可见性:

    c++中 public protected private 三种可见性可以分别理解为

    完全对外公开,只对子类公开,完全不公开,这里对子类的可见性是完全不受继承时的可见性影响的,就是说无论是public,protected还是private继承,父类public protected属性在子类中时永远可见的,private时永远不可见的。

    那么三种继承的可见性就可以理解为:

    可见的属性继承为public属性(public继承)

    可见的属性继承为protected属性(protected继承)

    可见的属性继承为private属性(private属性)

    参考文档:

    http://www.cnblogs.com/motadou/archive/2010/03/12/1683974.html

    多态:

    父类中声明的虚函数:非纯虚函数和纯虚函数,在子类中进行重写。当使用父类指针的时侯可以根据虚函数表自动调用符合当前对象的函数。抽象地来说就是多态(polymorphism)就是在c++中使用同一份源码编译出来的程序可以在执行的过程中有不同的行为。就目前我的理解来看,多态就是在使用指针的时候可以正确的使用自身类的函数就算是指针类型不是自己的类型。

    只有声明了virtual的函数才能有多态的特性,如果是直接覆盖的话是没有多态的特性的,从外界运行的角度来看,只会调用当前指针所属类型的相应函数。

    在c++11里新增了override保留字,可以在子类重写父类虚函数的时候在函数末尾添加override,同样也可以不添加。功能就是提高了代码的可读性,如果不是重写父类虚函数的时候用了override的时候编译器会直接报错,没有override的时候编译器会认为是一个新的函数而通过编译。

     

     

    在使用的过程中使用同一继承路径下的指针指向另一个对象的时候,比如下面的继承关系:

    A-B-C-D,其中A是父类,D是子类

    A* ptr= &d_obj;

    在这种情况下,在储存的过程中d_obj这个对象仍然是D类。但是在所有外界来看这个ptr就是一个A类的指针,是无法看到BCD派生的部分的,例外的情况仅出现在使用多态的情况下会查找虚函数表,除此之外行为和A类对象,即使是最后的delete操作。

     

    以上纯属个人观点,保证客观正确但不保证概括全面,如果有错误请指出

     

     

    展开全文
  • 接口与抽象

    2015-01-31 11:38:00
    封装:每个对象都包含它能进行操作所需要的信息,而不依赖其它对象来完成...Protected表示继承时子类可以对基类有完全的访问权,对子类公开,但不对其它类公开。子类从它的父类中继承的成员有方法,或,属性,事件...

    封装:每个对象都包含它能进行操作所需要的信息,而不依赖其它对象来完成自己的操作,称为封装。

    封装的好处:良好的封装能减少耦合,类内部的实现可以自由的修改,类具有清晰的对外接口。

    继承者可以完全替换被继承者,反之则不成立。继承定义了如何互相关联,共享特性。

    Protected 表示继承时子类可以对基类有完全的访问权,对子类公开,但不对其它类公开。子类从它的父类中继承的成员有方法,或,属性,事件,索引指示器,但对于构造函数,它不能被继承,只能被调用,对于调用父类的成员,可以用basee 关键字。

    继承有缺点,继承会破坏包装,父类的实现细节会暴露给子类,继承显然是一种类与类之间强耦合的关系。

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

    为了使子类的实例完全接替来自父类的成员,父类必须将该成员声明为虚拟的。即在该成员的返回类型前加上 Virtual 来实现。子类可以用 Override 关键字来重写该方法。

     

    多态的原理是:当方法被调用时,无论对象是否被转换为其父类,都只有位于对象继承链的最末端的方法实现会被调用,也就是说,虚方法是按照其运行时类型而非编译时类型进行动态绑定调用的。

     

    抽象; 

       抽象类不能实例化,抽象方法是必须被子类重写的方法,如果类中包含抽象方法,那么类就必须定义为抽象类,不论是否还包含其它一般方法。

    抽象类应该拥有尽可能多的共同代码,拥有尽可能少的数据。

    抽象类通常代表一个抽象的概念,它提供一个继承的出发点,当设计一个新的抽象类时,一定是用来继承的,所以,在一个以继承关系形成的等级结构里面,树叶节点应该是具体的类,而树枝节点均应当是抽象类。

     

    接口:

      接口是把隐式公共属性和方法组合起来,以封装特定功能的一个集合,一旦实现了接口,类就可以支持接口所指定的所有属性和成员。但不允许提供接口中任何成员的执行方式。

    实现接口的类,必须实现接口中定义的所有方法和属性。

    一个类可以支持多个接口, 多个类可以支持相同的接口。

    接口中的方法或属性前面不能有修饰符,方法没有方法体。

    一个类只能继承一个抽象类,但可以富丽多个接口。类是对对象的抽象,抽象类是对类的抽象,接口是对行为的抽象。接口是对类的局部行为进行抽象,而抽象类是对类整体(字段,属性,方法)的抽象,如果行为跨越不同类的对象,可使用接口,对于一些相似的类对象,使用继承抽象类。从设计角度讲,抽象类是从子类中发现了公共的东西,泛化出父类,然后子类继承父类,而接口是根本不知子类的存在,方法如何实现还不确认,预先定义。

    ArrayList 是 ArrayList 可以保存的元素数,ArrayList 的默认初始容量是0,随着元素添加到ArrayList 中,容量会根据需要重新分配自动增加,使用整数索引可以此集合中的元素。ArrayList 不是类型安全的。对值类型进行装箱时,必须分配并构造一个全新的对象。

    泛型:

    泛型是具有占位符(类型参数)的类,结构,接口和方法,这些占位符是类,结构,接口,方法,所存储或使用的一个或多个类型占位符,泛型集合类可以将类型参数用作它所存储对象的类型的占位符,类型参数作为其字段的类型和其方法的参数类型出现。

    泛型优点类型安全,性能高。

    委托:是对函数的封装,可以当作给方法的特征指定一个名称,而事件则是委托的一种特殊形式,当发生特殊的有意义的事情时,事件对象处理通知过程。

     

    委托是一种引用方法的类型,一旦为委托分配了方法,委托将与该方法具有完全相同的行为。

    事件是说在发生其它类或对象关注的事情时,类或对象可通过对象通知它们。

    转载于:https://www.cnblogs.com/wisdo/p/4263832.html

    展开全文
  • 访问修饰词--Java

    2019-10-01 12:42:43
     权限: 对子类和同包中的其他类公开 default(默认的,可不写)  权限: 对同包中的其他类公开 private(私有的)  权限: 本类公开 public protected default private 本类 √ √ √ ...
  • 浅谈Java访问修饰符

    2019-02-07 13:09:44
    Java提供四种访问控制修饰符 ...2.受保护级别:用protected修饰,对子类和同一个包中的类公开 3.默认级别:对同一个包中的类公开。对子类不公开! 4.私有级别:用private修饰,只有本类能访问,不对外公开 ...
  • Java提供的四种访问控制修饰符

    千次阅读 2016-07-19 11:58:14
    2、受保护级别:用protected修饰,对子类和同一个包中的类公开。 3、默认级别:没有修饰符号,像同一个包的类公开。 4、私有级别:用privte修饰,只有类本身可以访问,不对外公开。 四种访问级别的访问范围 访问...
  • 重温!Java访问修饰符

    2020-07-24 22:53:12
    文章目录重温!Java访问修饰符1、访问控制修饰符2、abstract...对子类以及同一包中的类公开。 无 默认级别。对同一包中的类公开。 private 私有级别。只有当前类本身可以访问,不对外公开 在一个com.demo.mypac
  • 受保护级别:用protected修饰,对子类和同一个包的类公开 默认级别(java中也称为缺省级别,缺省即默认的意思):无修饰符号,向同一个包中的类公开 似有级别:用private修饰,只有类本身才可以访问,不对外公开 ...
  • Java的三大特性

    2020-02-17 22:56:04
    Java中提供了四种权限:public(对外公开),private(只有类本身可以使用),protected(对子类和同一个包中的类公开),default(对同一个包中的类公开)。 继承:将一个已经存在的类的内容作为自己的内容,并且可以...
  • 类的成员不写访问修饰时默认为default。 默认对于同一个包中的其他...受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。 作用域 当前类 同包 子类 其他 public √ √ √ √ pro
  • 访问修饰符public,private,protected 类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当...受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。 总结如下表 ...
  • protected:对子类和同包的类公开 默认(无修饰符):对同包公开 private:类私有,只有类内部可以访问 继承 当多个类存在相同的方法或属性时可以从这些类中抽象出父类,在父类中定义这些属性和方法,有利于代码...
  • 封装 将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法...2.protected:对子类和同一包中的类公开; 3.没有修饰符号(默认不写):对同一个包内公开; 4.private:只有类本身可以访问...
  • 类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开...受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。 总结如下表              ...
  • 学习

    2019-09-14 02:55:30
    访问修饰符public,private,protected,以及不写(默认)时的区别 类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开(public),对于不是同...受保护(protected)对子类相当于公开,对不...
  • 【java】访问修饰符

    2019-05-06 20:33:48
    访问修饰符public,private,protected ...受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。 总结如下表: 类的成员不写访问修饰时默认为default。默认对于...
  • public,private,protected权限问题

    千次阅读 2018-04-09 21:21:03
    public private protected default之间权限的问题 主要分为4种 ...2.默认对于同一个包中的其他类相当于公开(public), ...4.受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于
  • 类的成员不写访问修饰时默认为default。...受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。 总结如下表 转载于:https://www.cnblogs.com/TomJay/p/9571202.html...
  • java修饰符

    2018-01-16 14:28:00
    访问修饰符public,protected,private,default: public>protected>default>private 类的成员不写访问修饰时默认为default。...受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相...
  • 访问修饰符的区别: 修饰符 当前类 同包 子类 其他包 ...类的成员不写访问修饰符默...受保护(protected)对子类相当于公开,对于不是同一个包没有父子关系的类相当于私有。 Java中,外部类的修饰符只能是public或默认
  •  类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开(public),对于不是同一个...受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。 总结如下表 ...
  • 受保护(protected)对子类相当于公开,对于不是同一个包没有父子关系的类相当于私有。 Java中,外部类的修饰符只能是public或默认,类的成员(包括内部类)的修饰符可以是以上四种。 转载于:https://www.cn...
  • 一些基础知识

    2018-01-19 17:49:46
    受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。Java中,外部类的修饰符只能是public或默认 8个基本类型: byte、short、int、long、float、double、char、boo...
  • 开闭原则

    2016-01-20 23:02:52
    开闭原则讲的是变化与不变的一种折中,这里变化我这里讲的主要是接口,抽象类等父类的方法对子类公开或者可修改等的变化,当然任何设计都无法做到完美,必须是一种折中。 睡觉了。
  • 1、不要为抽象类提供公开的构造方法  抽象类可以有构造方法,但是抽象类不能实例化。如果编程人员没有制定构造方法,编译器会自动生成一个默认的protected构造方法。...抽象类只需对子类可见即可。 2、可见字段
  • ## Java面向对象的三大特性:封装、继承、多态之封装 ...2.受保护级别:用protected修饰,对子类和同一个包中的类公开。 3.默认级别:没有修饰符号,向同一个包的类公开。 4.私有级别:用private修饰
  • java访问级别

    2013-04-23 16:30:47
    private 仅类中可见 默认(不写) 同一个类/同一个包中的类 可见 protected 同一个类/同一个包中的类/不同包中的子类可见 public 对外公开(所有地方都可见) ...同一个包中对子类
  • [C++_7]继承_1

    2014-03-02 21:17:06
    继承方式对子类内部没啥影响,对外界有影响 父类公开成员 父类保护成员 父类私有成员 公开继承 子类内部 可访问(公开属性) 可访问(保护属性) 不可访问 外界 可访问 不可...

空空如也

空空如也

1 2
收藏数 36
精华内容 14
关键字:

对子类公开