精华内容
下载资源
问答
  • 类声明本身并不能改变程序的行为,它定义了类的对象包括了什么,以及可以在这个对象上执行哪些操作。 例如,我们使用关键字 class 定义 Box 数据类型,如下所示: class Box { // 成员属性 double length; // ...

    1. 类的定义

    类定义是以关键字 class 开头,后跟类的名称。并在它后面依次包含类名,一组放在 {} 内的成员属性和成员函数,以及结尾的分号。

    类声明将类本身及其属性告诉编译器。类声明本身并不能改变程序的行为,它定义了类的对象包括了什么,以及可以在这个对象上执行哪些操作。

    例如,我们使用关键字 class 定义 Box 数据类型,如下所示:

    class Box
    {
       	// 成员属性
        double length;   // 盒子的长度
        double breadth;  // 盒子的宽度
        double height;   // 盒子的高度
        // 成员函数
        double getVolume(void); // 返回体积
    };
    

    有时候也会把类成员的函数叫做“方法”。

    2. 类实例对象的定义

    类相当于蓝图,仅声明类并不会对程序的执行产生影响。在程序执行阶段,对象是类的化身。要使用类的功能,通常需要创建其实例——对象,并通过对象访问成员方法和属性。

    声明类的对象,就像声明基本类型的变量一样。

    double pi= 3.1415; 
    Box Box1;          // 声明 Box1,类型为 Box
    Box Box2;          // 声明 Box2,类型为 Box
    

    对象 Box1 和 Box2 都有它们各自的数据成员。

    就像可以为其他类型(如 int )动态分配内存一样,也可使用 newBox 对象动态地分配内存:

    int* a = new int; 
    delete a; 
    Box* box = new Box(); 
    delete box; 
    

    3. 访问类成员

    类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。示例:

    #include <iostream>
    using namespace std;
     
    class Box
    {
      public:
        double length;
        double width;
        double height;
    };
    
    int main()
    {
      Box box1; // box1,类型为 Box
      Box box2;
      double volume = 0.0;
    
      box1.length = 1;
      box1.width = 2;
      box1.height = 3;
    
      box2.length = 4;
      box2.width = 5;
      box2.height = 6;
    
      volume = box1.length * box1.width * box1.height;
      cout << "box1 vloume is " << volume << endl;
    
      volume = box2.length * box2.width * box2.height;
      cout << "box2 vloume is " << volume << endl;
    
      return 0;
    }
    

    如果有一个指针 box,它指向 Box 类的一个实例,则可使用指针运算符 -> 来访问成员,也可使用间接运算符 * 来获取对象,再使用句点运算符来访问成员:

    Box* box = new Box();
    (*box).getVolume();
    

    4. 类成员函数

    类的成员函数是指那些把定义和原型写在类定义内部的函数,就像类定义中的其他变量一样。类成员函数是类的一个成员,它可以操作类的任意对象,可以访问对象中的所有成员。

    成员函数可以定义在类定义内部,或者单独使用范围解析运算符 :: 来定义。在类内部定义中定义的成员函数把函数声明为内联的(关于内联,请参考https://www.runoob.com/w3cnote/cpp-inline-usage.html),即便没有使用 inline 标识符。所以您可以按照如下方式定义 getVolume 函数:

    class Box
    {
       public:
          double length;      // 长度
          double breadth;     // 宽度
          double height;      // 高度
       
          double getVolume(void)
          {
             return length * breadth * height;
          }
    };
    

    也可以在类的外部使用范围解析运算符 :: 定义该函数,如下所示:

    double Box::getVolume(void)
    {
        return length * breadth * height;
    }
    

    在这里,需要强调一点,在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符 . ,这样它就能操作与该对象相关的数据,如下所示:

    Box myBox;          // 创建一个对象
     
    myBox.getVolume();  // 调用该对象的成员函数
    

    使用上面提到的概念来设置和获取类中不同的成员的值:

    #include <iostream>
    using namespace std;
     
    class Box
    {
      public:
        double length;
        double width;
        double height;
    
        // 类成员函数声明
        double getVolume(void);
        void setLength(double len);
        void setWidth(double wid);
        void setHeight(double hei);
    };
    
    double Box::getVolume()
    {
      return length * width * height;
    }
    
    void Box::setHeight(double hei)
    {
      height = hei;
    
    }
    
    void Box::setLength(double len)
    {
      length = len;
    }
    
    void Box::setWidth(double wid)
    {
      width = wid;
    }
    
    int main()
    {
      Box box1; // box1,类型为 Box
      Box box2;
      double volume = 0.0;
    
      box1.setLength(1);
      box1.setWidth(2);
      box1.setHeight(3);
    
      box2.setLength(4);
      box2.setWidth(5);
      box2.setHeight(6);
    
      volume = box1.getVolume();
      cout << "box1 vloume is " << volume << endl;
    
      volume = box2.getVolume();
      cout << "box2 vloume is " << volume << endl;
    
      return 0;
    }
    

    5. 类访问修饰符

    数据封装是面向对象编程的一个重要特点,它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 publicprivateprotected 来指定的。关键字 publicprivateprotected 称为访问修饰符。

    一个类可以有多个 publicprotectedprivate 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private

    class Base {
     
       public:
      // 公有成员
     
       protected:
      // 受保护成员
     
       private:
      // 私有成员
     
    };
    

    5.1 公有(public)成员

    公有成员在程序中类的外部是可访问的。可以不使用任何成员函数来设置和获取公有变量的值,如下所示:

    #include <iostream>
    using namespace std;
     
    class Line
    {
        public:
          double length;
          void setLength(double len);
          double getLength(void);
    };
     
    // 成员函数定义
    double Line::getLength(void)
    {
        return length;
    }
     
    void Line::setLength(double len)
    {
        length = len;
    }
     
    // 程序的主函数
    int main( )
    {
       Line line;
     
       // 设置长度
       line.setLength(6.0); 
       cout << "Length of line : " << line.getLength() <<endl;
     
       // 不使用成员函数设置长度
       line.length = 10.0; // OK: 因为 length 是公有的
       cout << "Length of line : " << line.length <<endl;
       return 0;
    }
    

    5.2 私有(private)成员

    私有成员变量或函数在类的外部是不可访问的,甚至是不可查看的。只有类和友元函数可以访问私有成员。

    默认情况下,类的所有成员都是私有的。例如在下面的类中, width 是一个私有成员,这意味着,如果您没有使用任何访问修饰符,类的成员将被假定为私有成员:

    class Box
    {
       double width;
       public:
          double length;
          void setWidth( double wid );
          double getWidth( void );
    };
    

    实际操作中,我们一般会在私有区域定义数据,在公有区域定义相关的函数,以便在类的外部也可以调用这些函数,如下所示:

    #include <iostream>
    using namespace std;
     
    class Box
    {
       public:
          double length;
          void setWidth(double wid);
          double getWidth(void);
     
       private:
          double width;
    };
     
    // 成员函数定义
    double Box::getWidth(void)
    {
        return width ;
    }
     
    void Box::setWidth(double wid)
    {
        width = wid;
    }
     
    // 程序的主函数
    int main( )
    {
       Box box;
     
       // 不使用成员函数设置长度
       box.length = 10.0; // OK: 因为 length 是公有的
       cout << "Length of box : " << box.length <<endl;
     
       // 不使用成员函数设置宽度
       // box.width = 10.0; // Error: 因为 width 是私有的
       box.setWidth(10.0);  // 使用成员函数设置宽度
       cout << "Width of box : " << box.getWidth() <<endl;
     
       return 0;
    }
    

    5.3 保护(protected)成员

    保护成员变量或函数与私有成员十分相似,但有一点不同,保护成员在派生类(即子类)中是可访问的。

    从下面的实例中,我们从父类 Box 派生了一个子类 smallBox。下面的实例与前面的实例类似,在这里 width 成员可被派生类 smallBox 的任何成员函数访问。

    #include <iostream>
    using namespace std;
     
    class Box
    {
       protected:
          double width;
    };
     
    class SmallBox:Box // SmallBox 是派生类
    {
       public:
          void setSmallWidth( double wid );
          double getSmallWidth( void );
    };
     
    // 子类的成员函数
    double SmallBox::getSmallWidth(void)
    {
        return width ;
    }
     
    void SmallBox::setSmallWidth( double wid )
    {
        width = wid;
    }
     
    // 程序的主函数
    int main( )
    {
       SmallBox box;
     
       // 使用成员函数设置宽度
       box.setSmallWidth(5.0);
       cout << "Width of box : "<< box.getSmallWidth() << endl;
     
       return 0;
    }
    

    参考:
    https://www.runoob.com/cplusplus/cpp-class-access-modifiers.html

    展开全文
  • c#类以及类成员的访问修饰符 ​ 在面试中最容易考察到基础知识点非访问修饰符莫属,...(2)权限范围:(这个目标)可以被哪些对象在什么地方可以访问到合格目标中的数据 那么我们就来认识一下类的访问修饰符有哪些

    c#类以及类成员的访问修饰符

    在面试中最容易考察到基础知识点非访问修饰符莫属,所以今天我来给大家分享一下c#中访问修饰符的知识点,此文章具有一定的参考价值,需要的朋友可以来参考鉴赏。如果说此文章写的不是太好,对大家造成了误导,或者说有一些不足指出,还请各位朋友能够指出,在下方评论,我期待大家一起的成长。


    1、什么是访问修饰符?

    (1)访问修饰符就是用来控制封装这个目标的权限范围

    (2)权限范围:(这个目标)可以被哪些对象在什么地方可以访问到合格目标中的数据

    那么我们就来认识一下类的访问修饰符有哪些,并且有哪些作用


    2、类的访问修饰符以及组合访问修饰符有些那些

    当我们在命名空间中定义元素的时候我们可用的只有public和internal来那种。
    在这里插入图片描述提示可知,在命名空间中直接声明只能用public和internal,且默认什么都不加的情况下是internal
    我给大家总结出来:

    修饰符 说明
    public 表示公共的,访问完全不受限制
    internal(默认的) 表示内部的,仅本项目中可以访问,本程序表示同一个程序或同一个程序集中
    abstract 或 internal abstract 类只能在当前项目中访问,不能实例化,只能继承
    public abstract 类可以在任何地方访问,不能实例化,只能继承
    sealed 或 internal sealed 类只能在当前项目中访问,不能派生,只能实例化
    public sealed 类可以在任何地方访问,不能派生,只能实例化

    3、成员的访问修饰符

    修饰符 说明
    public 表示公共的,访问完全不受限制
    internal 表示内部的,仅本项目中可以访问,本程序表示同一个程序或同一个程序集中
    private(默认的) 表示私有的,仅本类中可以使用,其他地方无法访问,包括它的子类也不能访问,并且类的实例都不可以访问
    protected 表示受保护的,仅本类和笨类的子类可以访问,可以跨程序集访问,并且类的实例都不能访问
    protected internal 表示受保护的内部(即受保护或内部),仅当前的项目中或者该类的子类可以访问到

    4、各类型中的成员访问修饰符

    枚举类型(enum) 访问修饰符
    枚举类型(enum) 枚举成员默认为public修饰符,且不能显示使用修饰符
    结构(struct) 机构成员默认为private修饰符。结构成员无法声明为protected成员,因为结构不支持继承
    类(class) 构造函数默认为public修饰符。析构函数不能显示使用访问修饰符且默认为private访问修饰符。类的成员默认访问修饰符为private。
    接口(interface) 接口成员访问修饰符默认为public,且不能显示使用访问修饰符
    嵌套类型 嵌套类型的默认访问修饰符为private,和类、结构的成员默认访问类型一致

    以上是本人查阅相关资料总结的,其中第4个各类型中的访问修饰符目前还没学到,是在查阅资料时意外收获的内容,希望对在学的各位朋友能够起到或大或小的帮助。如果本篇文章有什么纰漏或者不足之处,还请各位远方的朋友能够指出,我期待大家的进步!

    展开全文
  • Java访问权限的修饰符public,private,protected,缺省(default)一个类中的成员变量和成员方法(非静态)被访问分为两种场景,一是在该类中,或其子类中访问,二是创建该类的对象进行访问。假设:有三个类 class ...

    Java访问权限的修饰符public,private,protected,缺省(default)

    一个类中的成员变量和成员方法(非静态)被访问分为两种场景,一是在该类中,或其子类中访问,二是创建该类的对象进行访问。

    假设:有三个类  class A ,class B extends C,class C     

    一、在类中访问

    首先,在B类中,可以访问到B类中定义的任意权限的成员变量/方法。然后C类中哪些成员变量/方法可以被访问,需要根据B和C是否在同一个包内来看。如果同包,则可以访问的权限有,public,缺省,protected。否则,访问的权限只有public,protected。

    总结:B继承C,B可以访问C内成员变量的权限。

    访问权限同包不同包
    publicYY
    protectedYY
    缺省YN
    privateNN

    二、对象的访问权限

    假设在A类中创建了对象B,那么可以访问到B以及B继承的类(这里是C)中哪些权限的成员变量/方法。这个必须根据A,B,C所在包的情况判断。

    访问权限A,B,C同包A,B同包A,C同包

    A与BC不同包

    publicB,CB,CB,CB,C
    protectedB,CBC 
    缺省B,CB  
    private    




    展开全文
  • 类的定义  类是C++核心特性,通常被称为用户...这实际上并没有定义任何数据,但它定义了类的名称意味着什么,也就是说,它定义了类的对象包含了什么,以及可以在这个对象上执行哪些操作。 类定义是以关键字class...

    类的定义

       类是C++核心特性,通常被称为用户定义的类型。类用于指定对象的形式,它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。

       定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,也就是说,它定义了类的对象包含了什么,以及可以在这个对象上执行哪些操作。

    类定义是以关键字class开头,后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如我们使用关键字class定义Box数据类型。

    class Box
    {
       public:
          double length;   // 盒子的长度
          double breadth;  // 盒子的宽度
          double height;   // 盒子的高度
    };

    C++对象

    类提供了对象的蓝图,所以基本上,对象是根据类来创建的。声明类的对象,就像声明基本类型的变量一样。下面的语句声明了类Box的两个对象

    Box Box1;          // 声明 Box1,类型为 Box
    Box Box2;          // 声明 Box2,类型为 Box

    对象Box1和Box2都有它们各自的数据成员。

    访问数据成员

    类的对象的公共数据成员可以使用直接成员访问运算符(.)来访问

    #include <iostream>
     
    using namespace std;
     
    class Box
    {
       public:
          double length;   // 长度
          double breadth;  // 宽度
          double height;   // 高度
    };
     
    int main( )
    {
       Box Box1;        // 声明 Box1,类型为 Box
       Box Box2;        // 声明 Box2,类型为 Box
       double volume = 0.0;     // 用于存储体积
     
       // box 1 详述
       Box1.height = 5.0; 
       Box1.length = 6.0; 
       Box1.breadth = 7.0;
     
       // box 2 详述
       Box2.height = 10.0;
       Box2.length = 12.0;
       Box2.breadth = 13.0;
     
       // box 1 的体积
       volume = Box1.height * Box1.length * Box1.breadth;
       cout << "Box1 的体积:" << volume <<endl;
     
       // box 2 的体积
       volume = Box2.height * Box2.length * Box2.breadth;
       cout << "Box2 的体积:" << volume <<endl;
       return 0;
    }

    运行结果

    Box1 的体积:210
    Box2 的体积:1560

    类的继承

    面向对象程序设计中最重要的一个概念就是继承,继承允许我们依据另一个类来定义一个类,这使得创建和维护一个应用程序变得更容易,这样做,也达到了重用代码功能和提高执行时间的效果。

    当创建一个类时,你不需要重新编写新的数据成员和成员函数,只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类,新建的类称为派生类。

    一个类可以派生自多个类,这意味着,它可以从多个基类继承数据和函数。定义一个派生类,我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名,形式如下:

    class derived-class: access-specifier base-class

    其中,访问修饰符access-specifier是public,protected或private其中的一个,base-class是之前定义过的某个类的名称。如果未使用访问修饰符access-specifier,则默认为private.每个基类之间用逗号分隔。

    #include <iostream>
     
    using namespace std;
     
    // 基类 Shape
    class Shape 
    {
       public:
          void setWidth(int w)
          {
             width = w;
          }
          void setHeight(int h)
          {
             height = h;
          }
       protected:
          int width;
          int height;
    };
     
    // 基类 PaintCost
    class PaintCost 
    {
       public:
          int getCost(int area)
          {
             return area * 70;
          }
    };
     
    // 派生类
    class Rectangle: public Shape, public PaintCost//派生类Rectangle同时继承了两个类Shape和PaintCost
    {
       public:
          int getArea()
          { 
             return (width * height); 
          }
    };
     
    int main(void)
    {
       Rectangle Rect;
       int area;
     
       Rect.setWidth(5);
       Rect.setHeight(7);
     
       area = Rect.getArea();
       
       // 输出对象的面积
       cout << "Total area: " << Rect.getArea() << endl;
     
       // 输出总花费
       cout << "Total paint cost: $" << Rect.getCost(area) << endl;
     
       return 0;
    }
    

    一个指向C++类的指针与指向结构的指针类似,访问指向类的指针的成员,需要使用成员访问运算符->,就像访问指向结构的指针一样。与所有的指针一样,必须在使用指针之前,对指针进行初始化。

     

    #include <iostream>
    #include <string>
    using namespace std;
    class Student
    {
    public:
    	//static int number;
    	int number;  
    	string name;
    //public:
    	Student()
    	{
    
    	}
    	void set(string str)
    	{
    		name=str;
    		number++;//调用静态数据成员
    	}
    	void print()//类成员函数print()
    	{
    		std::cout<<name<<":The number of the students is"<<number<<"numbers."<<endl;//调用静态数据成员
    	}
    };
    int main()
    {
    	Student *s1;//对于类Student,定义了一个指针,是一个内存地址,指向内存中存放的的类对象(包括一些成员变量所赋的值,在定义s1的时候并没有分配内存,只有执行new后才会分配内存,且为内存堆。
    	//类的指针,用的是内存堆,是个永久变量,除非你释放它,需要用new运算符分配内存
    	s1=new Student();//注意,用new,一定要delete
    	s1->set("tom");//指针用->操作符引用成员
    	Student s2;//对于类Student,定义了一个对象,利用类的构造函数在内存中分配一块内存(包括一些成员变量所赋的值)
    	//类的对象,用的是内存栈,是个局部的临时变量
    	s2.set("wang");//对象引用成员,用.操作符
    	s1->print();
    	s2.print();
    	return 0;
    }

     

     

     

    C++的精髓之一就是多态性,只有指针或者引用可以达到多态,对象不行。

    用指针,第一可以实现多态,第二,在函数调用时,传指针参数,不管你的对象或结构参数多么庞大,用指针,传过去的就是4个字节,如果用对象,参数传递占用的资源就大了。

    展开全文
  • 我看书上写对私有部分的访问可以是公共部分的成员函数,也可以是友员函数,那么可以直接对私有部分静态成员进行初始化吗? 我来答 分享 举报 4个回答 #热议#抗疫期间,身边哪些平凡人做了不平凡事? ...
  • 一、什么是嵌套类嵌套类是指被定义在另一个类的内部的类。嵌套类存在的目的应该只是为他的外围类提供服务。...最好把他看做是普通类,只是碰巧被声明在另一个类的内部而已,它可以访问外围类的所有成员,包括哪些...
  • 1、字段、方法、属性(后面讲)都可以叫做类的成员Member,它们都需要定义访问级别。访问级别的用处在于控制成员哪些地方可以访问,这样达到面向对象中“封装”的目的。程序中不要“摄魂大法”,否则代码会非常...
  • 面向对象的封装就是把描述一个对象的属性和行为代码封装在一个“模块”中,也就是一个中,属性用变量定义,行为用方法定义,方法可以直接访问同一个对象属性。通常情况下,只要记住记住让变量和访问这个变量...
  • 对象

    2020-11-29 17:01:41
    一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类的成员变量。 通过关键字new来实例化对象。 一个类可以实例化多个对象。 问题:如何访问类当中的成员属性? 对象名.成员属性 如果...
  • 类的访问控制符有四种: l public l protect l default默认(即不加任何修饰符) l private 在一个类的内部,所有的成员可以相互访问,访问控制符是...l 通过类对象访问类内部成员 public 可以通过外部访问方式...
  • 内部类内部类概述 内部类:就是在一个类中定义一个类,举例:在一个类A的内部定义一个类B,类B就被称为内部类 内部类访问特点:内部类可以直接访问外部类的成员,包括私有,外部类要访问内部类的成员,必须创建对象 ...
  • 1. 只是一个模型一样东西,限定了哪些成员. 2. 一个类可以实例化出多个对象,实例化出的对象占用实际物理空间,存储成员变量。 创建: class Person{ //成员属性 public String name ; //访问...
  • 展开全部封装性、继承性、多态性。1、封装性:具备封装性...封装是通过限制只有特定类的对象可以访问这一特定类的成员,而它们通常利用接口实现消息的传入传出。通常来说,成员会依它们的访问权限被分为3...
  • 成员变量可以被 public,private,static 等修饰符所修饰,而局部变量不能被访问控制修饰符及 static 所修饰;但是,成员变量和局部变量都能被 final 所修饰。 2.从变量在内存中存储方式来看:如果成员变量是使用 ...
  • java对象

    2019-08-19 20:56:33
    目录 对象和java 类成员 匿名对象 源文件声明规则 ...访问修饰符 ...对象和java ...现在让我们深入了解什么是对象。...•对象的行为(behavior)——可以对象施加哪些操作,或可以对象施加哪些方法? ...
  • java语言定义了public、protected、private、abstract、static和final这6常用修饰词外还定义了5个不太常用修饰词,...private使用对象成员介绍:成员可以在定义它的类中被访问3。static使用对象、方法、...
  • 今日内容内部类引用类型内部类以前2个类是独立分开定义的概述把类定义在...}内部类的访问规则 A:可以直接访问外部类的成员,包括私有 B:外部类要想访问内部类成员,必须创建对象内部类的分类 A:成员内部类B:局部内...
  • 从语法形式上,看成员变量是属于类的,而局部变量是在方法中定义的变量或是方法的参数;成员变量可以被public,private,static等修饰符所修饰,而局部变量不能被访问控制修饰符及static所修饰;但是,成员变量和局部...
  • 友元类通常是为了方便存取另一个类的私有数据成员而声明的,例如A是B的友元类,A可以存取B中的私有成员,但是类A与类B可以说是没有任何关系的,友元类A并不属于类B的一部分。类的组合是用来描述一类复杂的对象。将...
  • 任何项目中都会使用到静态类、静态方法、静态成员和实例成员了。那么这几个名词到底有哪些区别呢? 1、静态成员和实例成员 ...一般情况下,我们都是对类的实例化来进行访问操作。如果实例不存在,那么也就无法访...
  • java类的访问修饰符

    2019-05-23 16:18:13
    访问控制修饰符主要用于定义类及其成员的作用域,可以哪些范围内访问类及其成员。 2. 类型说明符主要用于定义类及成员是否可被修改,是属于对象还是属于类 - 用来修饰类的有public.abstract.final...
  • Java内部类总结有哪些?没有基础该怎么学Java?互联网时代,掌握一门潮流的... 内部类与外部类的关系:内部类可以访问外部类的所有成员,外部类需要创建内部类的对象才能访问内部类的成员。 内部类的被访问方式:...
  • C++对象重点概要

    2020-05-28 16:20:53
    一:C++中struct和class区别 ...1.只是一个模型一样东西,限定了哪些成员,定义出一个并没有分配实际内存空间来存储它。 2. 一个类可以实例化出多个对象,实例化出的对象占用实际
  • C++学习——对象

    2020-02-12 16:42:13
    1、类的访问控制有哪些? 公有成员:以关键字public指明。 私有成员:以关键字private指明。 保护成员:以关键字protected指明。 2、拷贝构造函数的作用是什么? 用一个已经存在的对象初始化本类的对象。 3、友元...
  • 本文目标掌握PHP中数据访问的3种方式的定义和作用1、public2、protected3、private(一)、数据...受保护的类成员● 定义该类的类(自身)● 该类的子类3、Private:私有的类成员● 只有自身才可以访问总结:从上到下约束...
  •  内部类与外部类的关系:内部类可以访问外部类的所有成员,外部类需要创建内部类的对象才能访问内部类的成员。  内部类的被访问方式:  1)内部类是在成员的位置上的被访问方式,可以被修饰符修饰。  2)如内部...
  • scala 教程 scala 是多范式编程语言。多范式,就是多种编程方法...伴生和伴生对象要在同一个源文件中定义,伴生对象和伴生类可以互相访问其私有成员。不与伴生同名单例对象称为孤立对象。 scala 对象程序...
  • Java内部类总结有哪些?没有基础该怎么学Java?互联网时代,掌握一门潮流的...内部类与外部类的关系:内部类可以访问外部类的所有成员,外部类需要创建内部类的对象才能访问内部类的成员。 内部类的被访问方式:...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 356
精华内容 142
关键字:

对象可以访问类的哪些成员