精华内容
下载资源
问答
  • A:static成员变量在对象构造时候生成 ...答案:c 解释,(1)的static成员变量属于该抽象,需要在定义时初始化,不可以在对象的构造函数中初始化。(2) static成员函数在对象成员函数中可以调用,同属于

    A:static成员变量在对象构造时候生成

    B: static成员函数在对象成员函数中无法调用

    C: 虚成员函数不可能是static成员函数

    D: static成员函数不能访问static成员变量

    答案:c   解释,(1)类的static成员变量属于该抽象类,需要在类定义时初始化,不可以在对象的构造函数中初始化。(2) static成员函数在对象成员函数中可以调用,同属于一个类作用域 (3)正确,static成员函数不可以声明为const和virtual,详见C++ primer  (4)static成员函数只能够访问static 成员变量。

    答案c在标准中的解释:


    ISO/IEC 14882:2003(E)  ISO/IEC
    10.3 Virtual functions 

    7 [Note: the virtual specifier implies membership, so a virtual function cannot be a nonmember (7.1.2)function.  Nor can a virtual function be a static member, since a virtual function call relies on a specific object for determining which function to invoke.  A virtual function declared in one class can be declared a friendin another class.  ]




    #include "stdafx.h"
    #ifndef TEST_H
    #define TEST_H
    #include <stdio.h>
    class test
    {
    private:
    int submember;
    static int  member;
    public:
    static void writesubtest(int member)
    {
    //test::submember = member; //error:非静态成员引用必须与特定对象相对


    }


    virtual static void writetest(int member) //error:仅非静态成员函数可以是虚拟的
    {
    test::member = member;


    }
    static void display(int count)//static成员函数,属于抽象类,不属于类对象
    {
    printf("the count number is %d \n",count);
    }
    void readtest(int mem)  //对象成员函数
    {
    printf("helllo %d \n",test::submember);
    // test::writetest(mem);// static成员函数在对象成员函数中可以调用,同属于一个类作用域,但是,static函数不能包含对stati成员的操作,否则出现错误
    display(8);
    }
    };
    #endif
    int _tmain(int argc, _TCHAR* argv[])
    {

    int aa = 2;
    test a ;
    a.writetest(10);
    a.readtest(aa);
    return 0;
    }

    展开全文
  • 类和对象作业及答案

    千次阅读 2018-12-20 08:56:53
    类和对象作业 一、 填空题 是组成Java程序的基本要素,体有两部分构成:一部分是变量的定义,另一部分是 的定义。 执行Person p = new Person();语句后,将在___________中给Person对象分配空间,并在栈内存中...

    类和对象作业

    一、 填空题

    1. 类是组成Java程序的基本要素,类体有两部分构成:一部分是变量的定义,另一部分是 的定义。
    2. 执行Person p = new Person();语句后,将在___________中给Person对象分配空间,并在栈内存中给引用变量p分配空间,存放Person对象的引用。
      3._______是一种特殊方法,它的名字必须与它所在的类的名字完全相同,并且不书写返回值类型,在创建对象实例时由new运算符自动调用。
    3. 局部变量的名字与成员变量的名字相同,若想在该方法内使用成员变量,必须使用关键字 。
    4. 使用关键字 来调用同类的其它构造方法,优点同样是以最大限度地代码的利用程度 ,减少程序的维护工作量。
    5. 用关键字 修饰的成员变量是类变量,类变量是指不管类创建了多少对象,系统仅在第一次调用类的时候为类变量分配内存,所有对象共享该类的类变量。
    6. 使用static修饰的变量称为静态变量,静态变量可以有两种访问方式,分别是类名.静态变量名和_______________________。
    7. 在一个类文件中的关键字package,import,class出现的可能顺序是______________________________。
      9.______关键字作为Java源文件的第一条非注释性语句,指明该源文件定义的类所有的包。
      10._______包是Java语言的核心类库,它包含了运行Java程序必不可少的系统类,使用该包下的类和接口不需要使用import导入。

    二、 选择题

    1. 在Java中,以下程序编译运行后的输出结果为( )。(选择一项)
      public class Test {
      int x, y;
      Test(int x, int y) {//一个带参构造器
      this.x = x;
      this.y = y;
      }
      public static void main(String[] args) {
      Test pt1, pt2;
      pt1 = new Test(3, 3);
      pt2 = new Test(4, 4);
      System.out.print( pt1.x+pt2.x);
      }
      }

      A 6
      B. 34
      C. 8
      D. 7

    2. 分析如下Java程序的代码所示,则编译运行后的输出结果是( )。(选择一项)
      public class Test {
      int count=9;
      public void count1(){
      count=10;
      System.out.println(“count1=”+count);
      }
      public void count2(){
      System.out.println(“count2=”+count);
      }
      public static void main(String[ ] args) {
      Test t=new Test();
      t.count1();
      t.count2();
      }
      }

      A count1=9;
      count2=9;
      B. count1=10;
      count2=9;
      C. count1=10;
      count2=10;
      D. count1=9;
      count2=10;

    3. 以下语句中关于Java构造方法的说法错误的是( )。(选择一项)

      A. 构造方法的作用是为创建对象进行初始化工作,比如给成员变量赋值
      B. 一个Java类可以没有构造方法,只能提供1个构造方法
      C. 构造方法与类同名,不能书写返回值类型
      D. 构造方法的第一条语句如果是super(),则可以省略,该语句作用是调用父类无参数的构造方法

    4. 在Java中关于静态方法,以下说法中正确的是( )。(选择两项)

      A 静态方法中不能直接调用非静态方法
      B. 非静态方法中不能直接调用静态方法
      C. 静态方法可以用类名直接调用
      D. 静态方法里可以使用this

    5. 下列选项中关于Java中类方法的说法错误的是( )。(选择二项)

      A 在类方法中可用this来调用本类的类方法
      B. 在类方法中调用本类的类方法时可直接调用
      C. 在类方法中只能调用本类中的类方法
      D. 在类方法中调用实例方法需要先创建对象

    三、 判断题

    1. 类可以看成一类对象的模板,对象可以看成该类的一个具体实例。( )
    2. 如果没有为类中的某些成员赋初始值,Java会为类成员赋予固定的初始值,如数值变量的值为0,布尔变量的值为true//false,未初始化的引用为null。( )
    3. Java中所有的变量,不管是成员变量还是局部变量,在使用前都必须进行初始化。( )
    4. 在Java中对象可以赋值,只要使用new关键词调用构造器创建该类的一个实例,( )
    5. System.out.println(“Hello java!”)中out是System类的一个静态成员变量。( )
    6. 构造方法用于创建对象,一般不允许有任何返回值,因此需要在构造方法返回类型处标注为void。( )
    7. Java语言为所有的Java程序自动导入包“java.lang”,因此Java程序可以直接用“java.lang”中的类和接口。( )

    四、 简答题

    1. 面向过程和面向对象的区别。(5分)
    2. 类和对象的关系
    3. 构造方法的作用和特征
    4. this关键字的作用和用法
    5. 简述static关键字的作用。
      提示:从static可以修饰变量,方法,代码块,内部类四个方面来回答。(5分)

    五、 编码题

    1. 请定义一个交通工具(Vehicle)的类其中有: 属性: 速度(speed)、 体积(size)等,方法:移动(move())、设置速度(setSpeed(int speed))、加速 speedUp()、减速 speedDown()等。最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速的方法对速度进行改变。

    2. 编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。 该类中应该有两个【】私有]属性: 姓名 (name) 和年龄 (age) 。定义构造方法用来初始化数据成员。再定义显示(display()) 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。

    3. 定义一个圆类——Circle,在类的内部提供一个属性:半径®,同时 提供 两个 方 法 : 计算 面积 ( getArea() ) 和 计算 周长(getPerimeter()) 。 通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。

    4. 构造方法与重载:定义一个网络用户类,要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入, 其中用户 ID 和用户密码必须写,如果email缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。

    六、 可选题

    1. 定义一个类 Calculaion, 其中包含四个方法: 加(add()) 、 减(sub()) 、乘(times()) 和除(div()) 。 创建一个具有 main()函数的类。 在 main()函数中创建一个 Calculation 的实例对象并对其中的方法进行调用。

    2. 定义一个类 Draw , 在 类 中 提供 3 个 方法:输出直角三角形(drawTrian()) 、 输出矩形(drawRec()) 及平行四边形(drawPra()) 。通过方法可以输出由“*” 组成的一个图形。 同时在类中包含两个属性:星号的个数(count) 、行数(lines) 。最后在测试类中进行调用。

    3. 创建一个空调,并调用制冷、制热、通风功能。空调包含的属性有品牌、匹数、温度,功能有加热、制冷、通风等功能。

    4. 定义一个表示学生信息的类 Student,要求如下:
      (1)类 Student 的属性如下:
      sNO 表示学号; sName 表示姓名; sSex 表示性别; sAge 表示
      年龄;sJava:表示 Java 课程成绩。
      (2)类 Student 带参数的构造方法:
      在构造方法中通过形参完成对成员变量的赋值操作。
      (3)类 Student 的方法成员:
      getNo():获得学号;
      getName():获得姓名;
      getSex():获得性别;
      getAge()获得年龄;
      getJava():获得 Java 课程成绩
      (4) 根据类 Student 的定义,创建五个该类的对象,输出每个学生的信息,计算并输出这五个学生 Java 语言成绩的平均值,以及计算并输出他们 Java 语言成绩的最大值和最小值。

    类和对象作业答案

    一、 填空题

    1. 方法
    2. 堆内存
    3. 构造方法
    4. this
    5. this
    6. static
    7. 对象名.静态变量名
    8. package import class
    9. package
    10. java.lang

    二、 选择题

    1. D
    2. C
    3. B
    4. AC
    5. AC

    三、 判断题

    1. ×
    2. ×
    3. ×
    4. ×

    四、 简答题

    答案略

    五、 编码题

    1. 请定义一个交通工具(Vehicle)的类其中有: 属性: 速度(speed)、 体积(size)等,方法:移动(move())、设置速度(setSpeed(int speed))、加速 speedUp()、减速 speedDown()等。最后在测试类 Vehicle 中的 main()中实例化一个交通工具对象并通过方法给它初始化 speed,size 的值并且通过打印出来。另外调用加速、减速的方法对速度进行改变。
      public class Vehicle {
      private int size;
      private int speed;
      public static void main(String[] args) {
      Vehicle ve = new Vehicle();
      ve.setSize(10);//设置初始体积
      ve.setSpeed(30);//设置初始速度
      ve.move();//调用移动方法
      ve.speedUp();//给交通工具减速
      ve.speedDown();//加速

      }
      /** 行进 /
      public void move(){
      System.out.println("行进中…,速度 "+speed+“km/h” );
      }
      /
      * 设置速度 /
      public void setSpeed(int speed){
      this.speed = speed;
      System.out.println(“初始速度设置为:”+speed+" km");
      }
      /
      * 设置体积 /
      public void setSize(int size){
      this.size = size;
      System.out.println(“初始体积设置为:”+size+" m^3");
      }
      /
      * 加速20 /
      public void speedUp(){
      this.speed+=20;
      System.out.println(“速度增加20后为:”+speed+" km");
      }
      /
      * 减速10 */
      public void speedDown(){
      this.speed-=10;
      System.out.println(“减速10后为:”+speed+" km");
      }
      }

    2. 编写 Java 程序用于显示人的姓名和年龄。定义一个人类Person。 该类中应该有两个私有属性: 姓名 (name) 和年龄 (age) 。定义构造方法用来初始化数据成员。再定义显示(display()) 方法将姓名和年龄打印出来。在 main 方法中创建人类的实例然后将信息显示。
      public class Person {
      private String name;
      private int age;
      /** 在构造器中初始化成员变量 /
      public Person(String name,int age){
      this.name = name;
      this.age = age;
      }
      public static void main(String[] args) {
      Person p = new Person(“张三”,18);
      p.display();
      }
      /
      * 显示姓名和年龄 */
      public void display(){
      System.out.println(“姓名:”+name);
      System.out.println(“年龄:”+age);
      }
      }

    3. 定义一个圆类——Circle,在类的内部提供一个属性:半径®,同时 提供 两个 方 法 : 计算 面积 ( getArea() ) 和 计算 周长(getPerimeter()) 。 通过两个方法计算圆的周长和面积并且对计算结果进行输出。最后定义一个测试类对 Circle 类进行使用。
      public class Circle {
      private int r;
      /** 无参构造 /
      public Circle(){}
      /
      * 有参构造,初始化半径*/
      public Circle(int r){
      this.r=r;
      }
      /** 也可以使用setR方法初始化半径 */
      public void setR(int r){
      this.r = r;
      }
      /计算 面积 /
      public void getArea(){
      double area = Math.PI * r * r;//从Math工具类得到π的值
      System.out.println(“圆的面积为:”+area);
      }
      /
      计算 周长 /
      public void getPerimeter(){
      double zc = Math.PI * 2 * r;
      System.out.println(“圆的周长为:”+zc);
      }
      }
      /
      测试 */
      public class Test {
      public static void main(String[] args) {
      Circle c = new Circle(4);//初始半径为4,使用构造初始化
      c.getArea();
      c.getPerimeter();
      }
      }

    4. 构造方法与重载:定义一个网络用户类,要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入, 其中用户 ID 和用户密码时必须缺省时 email地址是用户 ID 加上字符串"@gameschool.com"。
      public class People {
      private String id;
      private String password;
      private String email;
      /** 无参构造 */
      public People(){

      }
      /** 全参构造 */
      public People(String id,String password,String email){
      this.id = id;
      this.password=password;
      this.email = email;
      }
      public People(String id,String password){
      this.id = id;
      this.password=password;
      this.email=id+"@gameschool.com";
      }
      public void show() {
      System.out.println(“编号:”+this.id);
      System.out.println(“密码:”+this.password);
      System.out.println(“邮件:”+this.email);
      }
      public static void main(String[] args) {
      //调用全参构造
      People p1 = new People(“sxt0001”,“123456”,"zhangsan@163.com");
      p1.show();
      //调用无参构造
      People p2 = new People(“sxt0002”,“654321”);
      p2.show();
      }
      }

    六、 可选题

    1. 定义一个类 Calculaion, 其中包含四个方法: 加(add()) 、 减(sub()) 、乘(times()) 和除(div()) 。 创建一个具有 main()函数的类。 在 main()函数中创建一个 Calculation 的实例对象并对其中的方法进行调用。

    public class Calculaion {
    private double a;
    private double b;
    public Calculaion(double a,double b){
    this.a=a;
    this.b=b;
    }
    public void add(){
    System.out.println(“a加b :”+(a+b));
    }
    public void sub(){
    System.out.println(“a减b :”+(a-b));
    }
    public void times(){
    System.out.println(“a乘b :”+(a*b));
    }
    public void div(){
    System.out.println(“a除以b :”+(a/b));
    }
    public static void main(String[] args) {
    Calculaion c = new Calculaion(7.0,3.0);
    c.add();
    c.sub();
    c.times();
    c.div();
    }
    }

    1. 定义一个类 Draw , 在 类 中 提供 3 个 方法:输出直角三角形(drawTrian()) 、 输出矩形(drawRec()) 及平行四边形(drawPra()) 。通过方法可以输出由“*” 组成的一个图形。 同时在类中包含两个属性:星号的个数(count) 、行数(lines) 。最后在测试类中进行调用。
      public class Draw {
      private int count, lines;
      public Draw(){}
      public Draw(int count, int lines){
      this.count=count;
      this.lines=lines;
      }
      /** 直角三角形 /
      public void drawTrina() {
      for (int i = 0; i < lines; i++) {//共lines行
      for (int j = 0; j < i; j++) {//每次增加1
      System.out.print("
      ");
      }
      System.out.println();//换行
      }
      }
      /** 输出矩形 /
      public void drawRec(){
      for (int i = 0; i < lines; i++) {
      for (int j = 0; j < count; j++) {//每行数量固定
      System.out.print("
      ");
      }
      System.out.println();
      }
      }
      /** 平行四边形 /
      public void drawPra(){
      for (int i = 0; i < lines; i++) {
      for(int k=0;k<i;k++){
      System.out.print(" “);
      }
      for (int j = 0; j < count; j++) {
      System.out.print(”
      ");
      }
      System.out.println();
      }
      }
      public static void main(String[] args) {
      Draw d = new Draw(5,5);
      //d.drawTrina();
      //d.drawRec();
      d.drawPra();
      }
      }

    2. 创建一个空调,并调用制冷、制热、通风功能。空调包含的属性有品牌、匹数、温度,功能有加热、制冷、通风等功能。
      public class AirConditioning {
      // 空调属性
      String name;
      String pinpai;
      String hp;// 匹数
      int tempeture;
      // 定义制冷行为
      void cool() {
      tempeture–;
      }
      // 定义加热行为
      void hot() {
      tempeture += 7;
      }
      //通风功能
      void ventilate(){
      System.out.println(“空气通畅,温度不变”);
      }
      // 主函数
      public static void main(String[] args) {
      AirConditioning kt = new AirConditioning();
      kt.hp = “2匹”;
      kt.tempeture = 20;
      kt.pinpai = “格力”;
      kt.cool();
      System.out.println(“空调的温度是” + kt.tempeture);
      kt.hot();
      System.out.println(“空调的温度是” + kt.tempeture);
      kt.ventilate();
      }
      }

    3. 定义一个表示学生信息的类 Student,要求如下:
      (1)类 Student 的属性如下:
      sNO 表示学号; sName 表示姓名; sSex 表示性别; sAge 表示
      年龄;sJava:表示 Java 课程成绩。
      (2)类 Student 带参数的构造方法:
      在构造方法中通过形参完成对成员变量的赋值操作。
      (3)类 Student 的方法成员:
      getNo():获得学号;
      getName():获得姓名;
      getSex():获得性别;
      getAge()获得年龄;getJava():获得 Java 课程成绩
      public class Student {
      String sNO ;
      String sName;
      String sSex;
      int sAge;
      int sJava;
      public Student(String sNO, String sName, String sSex, int sAge, int sJava) {
      this.sNO = sNO;
      this.sName = sName;
      this.sSex = sSex;
      this.sAge = sAge;
      this.sJava = sJava;
      }
      public String getsNO() {
      return sNO;
      }
      public String getsName() {
      return sName;
      }
      public String getsSex() {
      return sSex;
      }
      public int getsAge() {
      return sAge;
      }
      public int getsJava() {
      return sJava;
      }
      }
      (4) 根据类 Student 的定义,创建五个该类的对象,输出每个学生的信息,计算并输出这五个学生 Java 语言成绩的平均值,以及计算并输出他们 Java 语言成绩的最大值和最小值。
      public class Test {
      public static void main(String[] args) {
      Student s1 = new Student(“sxt0001”, “张三”, “男”,18,90);
      Student s2 = new Student(“sxt0002”, “李四”, “女”,15,92);
      Student s3 = new Student(“sxt0003”, “王五”, “男”,17,93);
      Student s4 = new Student(“sxt0004”, “赵六”, “男”,21,95);
      Student s5 = new Student(“sxt0005”, “钱七”, “男”,19,97);

    System.out.println("\t学号\t姓名\t姓别\t年龄\t成绩");
    System.out.println("\t"+s1.getsNO()+"\t"+s1.getsName()
    +"\t"+s1.getsSex()+"\t"+s1.getsAge()+"\t"+s1.getsJava());
    System.out.println("\t"+s2.getsNO()+"\t"+s2.getsName()
    +"\t"+s2.getsSex()+"\t"+s2.getsAge()+"\t"+s2.getsJava());
    System.out.println("\t"+s3.getsNO()+"\t"+s3.getsName()
    +"\t"+s3.getsSex()+"\t"+s3.getsAge()+"\t"+s3.getsJava());
    System.out.println("\t"+s4.getsNO()+"\t"+s4.getsName()
    +"\t"+s4.getsSex()+"\t"+s4.getsAge()+"\t"+s4.getsJava());
    System.out.println("\t"+s5.getsNO()+"\t"+s5.getsName()
    +"\t"+s5.getsSex()+"\t"+s5.getsAge()+"\t"+s5.getsJava());
    int d = (s1.getsJava()+ s2.getsJava()+ s3.getsJava()
    + s4.getsJava()+ s5.getsJava())/5;
    System.out.println(“java语言平均成绩:”+d);
    }
    }

    展开全文
  • Pb语言中的类和对象

    千次阅读 2017-03-26 13:24:24
    类和对象是相关但不相同的概念。对象是一个的实例,而可以有零个或多个实例。对象(object)是相关函数数据的一个包。只是一个模板,从中可以创建特定的实例。用户在PowerBuilder中创建的所有窗口都属于...

    类和对象是相关但不相同的概念。对象是一个类的实例,而类可以有零个或多个实例。对象(object)是相关函数和数据的一个包。类只是一个模板,从中可以创建特定的实例。用户在PowerBuilder中创建的所有窗口都属于类Window。对象是类的实际物理表示,是用户创建和取消的内容。
    PowerBuilder将每个类——系统类以及用户所创建的类——定义为一个数据类型并将它们作为一个层次结构来维护。
    使用Object Browser,用户可以设置希望缩放的特定类的类型。
    这里写图片描述

    创建和删除类

    可以用Create语句生成对象类的一个实例。必须使用该语句的唯一类就是不可视用户对象,如标准类(例如transaction和error)或弹出式菜单。可视的用户对象和窗口应该用相应的Open()函数创建。在用户访问对象的特性和方法前必须用Create语句实例化一个对象变量。例如,要创建Error对象的一个本地版本,代码为:

    //对象变量eMyError,对象类Error
    Error eMyError
    eMyError = Create Error
    eMyError.Line = 1
    

    例如,要创建一个可视化的用户窗口类w_about的实例,代码为:

    Open(w_about)
    
    //或用局部变量wInstance1指向这个实例
    w_about wInstance1
    Open(wInstance1,"w_about")

    警告:如果用Create来建立窗口类的一个非可视实例,则不触发Open事件。事实上,与可视窗口相关联的所有事件都不会触发,因为窗口的图形组件无法生成。

    当用户使用Create语句时,PowerBuilder为该对象分配内存。该内存一直保持到由Destroy语句释放它为止。例如,在上述示例的脚本的结尾,要求的代码为:

    Destroy eMyError

    类和实例池

    PowerBuilder维护了三个独立的内存池用于跟踪类、实例和Windows显示信息
    当首次对一个特定类实例化时,将把类定义调入类池中,然后在实例池中创建一个实例。该对象随后的实例化将直接从类池中提取其定义。根据实例化对象的方式,该实例的一个指针要么在全局内存中,要么位于所使用变量的作用域层。PowerBuilder用另一个池——Windows池保存某个对象的实际Windows显示方面的信息。最后这个Windows池仅用于可视类,如窗口、菜单和用户对象。

    展开全文
  • 对于刚接触不久面向对象的真小白童鞋来说,对象对象的实例,对象的引用,引用变量的问题以及莫过于没得对象虽然博主也没得对象,本文将逐个逐个讲解!...“按照通俗的说法,每个对象都是某个(class)的...

    对于刚接触不久面向对象的真小白童鞋来说,类的对象,对象的实例,对象的引用,引用变量的问题以及莫过于没得对象虽然博主也没得对象,本文将逐个逐个讲解!

    1.何谓对象?

    在Java中有一句比较流行的话,叫做“万物皆对象”,这是Java语言设计之初的理念之一。要理解什么是对象,需要跟类一起结合起来理解。下面这段话引自《Java编程思想》中的一段原话:

    “按照通俗的说法,每个对象都是某个类(class)的一个实例(instance),这里,‘类’就是‘类型’的同义词。”

    从这一句话就可以理解到对象的本质,简而言之,它就是类的实例,比如所有的人统称为“人类”,这里的“人类”就是一个类(物种的一种类型),而具体到每个人,比如张三这个人,它就是对象,就是“人类”的实例。

    2.何谓对象引用?

    我们先看一段话,这段话同样来自于《Java编程思想》:

    “每种编程语言都有自己的数据处理方式。有些时候,程序员必须注意将要处理的数据是什么类型。你是直接操纵元素,还是用某种基于特殊语法的间接表示(例如C/C++里的指针)来操作对象。所有这些在
    Java
    里都得到了简化,一切都被视为对象。因此,我们可采用一种统一的语法。尽管将一切都“看作”对象,但操纵的标识符实际是指向一个对象的“引用”(reference)。”

    很显然,从这段话可以看出对象和对象引用不是一回事,是两个完全不同的概念。举个例子,我们通常会用下面这一行代码来创建一个对象:

     Person per = new Person("张三");
    

    有小白童鞋会说,这里的per是一个对象,是Person类的一个实例。也有小白童鞋会说,这里的per并不是真正的对象,而是指向所创建的对象的引用。到底哪种说法是对的?我们先不急着纠结哪种说法是对的,再看两行代码:

     Person person;
      person = new Person("张三");
    

    这两行代码实现的功能和上面的一行代码是完全一样的。大家都知道,在Java中new是用来在堆上创建对象用的,如果per是一个对象的话,那么第二行为何还要通过new来创建对象呢?

    由此可见,per并不是所创建的对象,是什么?上面的一段话说的很清楚,“操纵的标识符实际是指向一个对象的引用”,也就是说per是一个引用,是指向一个可以指向Person类的对象的引用。真正创建对象的语句是右边的new Person("张三");因此这里的per是一个引用,是指向一个可以指向Person类的对象的引用。

    简单来说,对象的引用意思是定义一个变量,这个变量指向的是一个对象

    Object  obj=new Object();
    //Object:类
    //obj:对象的引用
    //new Object():对象
    

    3.何谓对象实例?

    首先,没有“对象的实例”这一说法,只有类的实例,而类的实例,指的就是类的对象,说白了就是对象。
    但是还是有很多人这样叫,那怎么理解对象实例呢?比如说人类中有个叫宜春的程序员,宜春就是人类的一个实例

    String s = new String("YiChun");
    

    s 就是 String类中的一个实例

    关于对象实例官方没有给其概念,其实有很多概念官方都没有给的,什么父类声明指向子类对象、方法签名等概念都是没有的 ,只是人们经常这么用这么说就习惯了。因此关于实例对象大体可以理解为对象引用的意思

    4.何谓引用变量?

    引用变量就是用引用类型声明的变量,这种变量叫引用类型变量。如:

    People people;  //其中people就是引用变量,People是一个类属于引用类型
    

    5、对象与对象引用碰撞火花

    从对象引用出发:

    一个对象引用可以指向零个或一个对象

    从对象出发:

    一个对象可以被一个或多个对象引用

    怎么理解捏?小白童鞋脑壳逐渐变大…

    5、1. 从对象引用出发:一个对象引用可以指向零个或一个对象

    首先先来理解第一句话:从对象引用出发:一个对象引用可以指向零个或一个对象

    public static void main(String[] args) {
          Two t; //一个对象引用可以指向零个对象
          t=new Two();//一个对象引用可以指向一个对象
          t=new String();//一个对象引用不可以指向 >1个对象
        }
    

    试想一下这样的代码会出现啥情况?是的,它会编译失败
    在这里插入图片描述
    看完上面这个例子就能说明了么?我们接着看下面这个代码:

     public static void main(String[] args) {
            String str;
            str=new String("string1");
            str=new String("string2");
        }
    

    我们知道,凡是new都能创建出一个对象,我们发现上面代码String对象引用str一个new了两次,而且上面代码编译也不报错,的的确确是创建了两个对象,那这怎么说?小白童鞋还没说完,把博主按在马桶盖盖上…

    别急,我们再看看上面代码输出啥

      public static void main(String[] args) {
            String str; 
            str=new String("string1");
            str=new String("string2");
            System.out.println(str);
        }
        
     运行结果: string2
    

    这说明啥?说明现在str是下一个对象的引用。上一个对象被垃圾回收了,因为上一个对象(也就是string1)不能被再次使用了。因此上面这个程序可以这样理解:

     public static void main(String[] args) {
       String str;//一个对象引用str指向零个对象
       str=new String("string1");//一个对象引用str指向一个对象string1
       str=new String("string2");//注意:这里对象引用str并不是指向第二个对象string2,而是将之前指向第一个对象string1的引用重新指向了另一个对象string2
    }
    

    对象引用str并不是指向第二个对象string2,而是将之前指向第一个对象string1的引用重新指向了另一个对象string2,因此从对象引用出发:一个对象引用可以指向零个或一个对象!

    这个时候,小白童鞋渐渐松开了把博主按在马桶盖盖上的双手…

    5、2. 从对象出发:一个对象可以被一个或多个对象引用

    我们再来理解一下第二句话:从对象出发,一个对象可以被一个或多个对象引用

    小白童鞋同样不解,于是又用双手把博主按在马桶盖盖上…

    看下面这个程序:

       Demo demo1,demo2,demo3;
       demo1=new Demo();
       demo2=demo1;
       demo3=demo2;
    

    怎么理解?看的有点晕?会不会感觉后面两句代码就是对象引用=对象引用…

    其实要弄清除这个,首先你得弄清楚java虚拟机内存,弄清楚变量(对象引用)和对象是如何存储的,对象引用是存储在栈内存中,而对象是存储在堆内存中。分析如下:

    Demo demo1,demo2,demo3;//创建多个对象引用,都存储在栈中
    demo1=new Demo();//创建一个Demo对象,存储在堆中,并将demo1指向这个对象,相当于加了一个链
    demo2=demo1;//demo2与demo1一样,都指向堆中Demo对象
    demo3=demo2;//demo3与demo2一样,都指向堆中Demo对象
    

    首先,每个对象只有一个地址值,new Demo()是创建了一个对象,demo1是这个对象的地址值,用来找到这个对象,demo2=demo1是把new Demo()这个对象的地址值由demo1改为了demo2,后面的demo3=demo2也是只改变了对象的地址值,对象本身的空间大小都没有变化,变的,是这个对象的地址值,也就是c里面所谓的指针。

    这个时候,小白童鞋渐渐松开了把博主按在马桶盖盖上的双手…

    最后,我们再看看一个网上关于对象与对象引用很流行的程序与分析,代码如下:

    UserType ut = new UserType();  // ut是引用,实际的对象在内存里。
    ut = new UserType(); /*现在ut是另一个对象的引用,先前的对象被垃圾回收了(因为先前的对象不能被再次使用了)。*/
    UserType ut2;  // 定义了一个引用ut2,他不引用任何对象,不能使用。。。。
    ut2 = new UserType(); // 然ut2成为一个对象的引用。
    UserType ut3 = new UserType();
    UserType ut4 = new UserType();
    ut3 = ut4;   // 现在ut3引用ut4的对象,这里不是赋值。。。
    int a = 5;
    int b = 4;
    a = b;  // 这里是赋值。 a b 依然引用不同的对象
    

    6、最后要相信的真理

    对于面向对象语言,如java,首先,请小白童鞋相信一句话:一切皆为对象。然后相信另一句话:变量只是一个零时的储存地点。引用类型的变量只是一个普通变量,储存了引用类型的地址。对象的创建是直接在内存中分配一个内存。

    最后再梳理一下

    引用类型变量 就 相当于 电脑上的快捷方式; 对象就相当于 你 磁盘里面 安装的游戏,它 实实在在 占用你的空间内存; 而变量 只是快捷方式

    说白了基本数据类型变量就像是直接放在柜子里的东西,而引用数据类型变量就是这个柜子对应编码的钥匙。钥匙号和柜子对应。

    到这里文章就结束了喔,小白童鞋,你何识着咩啊~

    最后,若有不足或者不正之处,欢迎指正批评,感激不尽!

    欢迎各位关注我的公众号,一起探讨技术,向往技术,追求技术…

    在这里插入图片描述
    小白童鞋关注了我的公众号之后,又用双手把博主按在马桶盖盖上…

    展开全文
  • 在C++中,把一个经常用的写成静态。但是在编译的时候无法通过,提示:“ 错误: 只能为对象和函数指定存储 ” 可能是C++确实没有提供静态一说 在用C#时,有静态说法
  • 【含答案】第二章 对象--2.2-1-声明与对象创建 (1)单选题 对象的关系是: A 对象的抽象 B 对象的抽象 C 对象的子类 D 对象的具体实例 (2)单选题 关于Java中的声明,下面哪个...
  • 关于JAVA堆,下面说法错误的是()? A.所有的实例和数组都是在堆上分配内存的 B.堆内存由存活死亡的对象,空闲碎片区组成 C.数组是分配在栈中的 D.对象所占的堆内存是由自动内存管理系统回收 正确答案:C 一句...
  • 关于类的序列化,下列说法哪些是正确的:答案在文末 A. 的序列化与serialVersionUID毫无关系。 B. 如果完全不兼容升级,不需要修改serialVersionUID值。 C. POJO的serialVersionUID不一致会编译出错。 D. POJO...
  • 关于c++静态说法

    千次阅读 2014-11-21 08:44:27
    一个是对一个概念的描述,的本质是它维护了一个不变式,也就是说它有一个状态,它所有的接口都是为了访问或者获取这个状态以及跟状态相关的操作。一个静态没有状态,因此就没有必要成为一个。在C++中静态...
  • 下面关于枚举类型,说法错误的是: A 枚举值是对象 B 枚举中可以定义数据方法 C 枚举的values()方法用于获得枚举类型的枚举值的数组 D 枚举类型可以有public的构造函数 (3)单选题 下面程序的输出结果是...
  • 下面关于Java接口的说法错误的是() A、一个Java接口是一些方法特征的集合,但没有方法的实现 B、Java接口中定义的方法在不同的地方被实现,可以具有完全不同的行为 C、Java接口中可以声明私有成员 D、Java接口不能...
  • java -面向对象编程-对象

    千次阅读 2017-01-01 15:38:07
    而今天说讲的内容,就是你学习面向对象编程的第一步:对象。这是面向对象编程中最基础的一个部分,也可以说是必须掌握的一个部分。话不多说,让我们开始学习吧! 首先,以一个问题作为入门:汽车有什么品牌?...
  • Python 中什么是一等对象 first-class object(第一类对象)? 文章目录Python 中什么是一等对象 first-class object(第一类对象)?0. 参考资料1. 定义 0. 参考资料 1. 定义 闲话:很多资料把 first-...
  • 【含答案】第二章 对象--2.3-1-对象初始化 (1)单选题 下列哪一项不是构造方法的特点: A构造方法名必须与类名相同 B构造方法不具有任何返回类型 C任何一个都含有构造方法 D构造方法修饰词只能是public (2...
  • 类和面向对象习题

    万次阅读 2017-04-13 21:49:31
    3.4 精选习题 一、单项选择题 1.下列不属于面向对象编程的特性的是( )。 A.封装 B.继承 C.抽象 D....2.(*)下述概念中不属于面向对象的是( )。...A.对象、消息 B....C.、封装 
  • Java对象和实例的理解

    千次阅读 多人点赞 2017-11-29 20:50:42
    的引用、对象和实例
  • 正确答案: A 你的答案: A (正确) 构造函数不可以是私有的(private) 一个中可以有多个构造函数 无论何时,只要对象被创建,就会执行构造函数 构造函数没有返回类型 ...
  • java面试题37 关于对象成员占用内存的说法哪个正确?( ) A 同一个对象共用同一段内存 B 同一个对象使用不同的内存段,但静态成员共享相同的内存空间 C 对象的方法不占用内存 D 以上都不对 蒙蔽树...
  •  (2分)重载函数中不允许使用默认参数重载函数中编译根据参数表进行选择不要使用重载函数来描述毫无相干的函数构造函数重载将会给初始化带来多种方式2-3在下面声明中,关于生成对象不正确的是( )。class point{ ...
  • 对象

    千次阅读 2012-10-06 19:43:02
    定义了的元素(属性方法),实际上,也可理解为带方法的类型。 1.抽象: 抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面。抽象包括两个方面,一是过程抽象,二
  • 【含答案】第二章 对象--2.2-2-数据成员 (1)单选题 下面关于变量的说法,哪个是不正确的: A 实例变量是的成员变量 B 变量用关键字static声明 C 变量可以用<实例名>.<变量名>访问 D ...
  • vfp对象和类

    千次阅读 2004-08-17 10:59:00
    第一讲 对象和类--本章简单说明一些对象和类的基本概念特征一.基本概念 什么是对象?在 VFP 中,所有用户界面元素(表单,表格,文本框,标签等)都是对象,还有用于控制的,在运行时不可见的 Custom 也是对象对象拥有...
  • 关于类对象成员的构造函数和类自身构造函数的执行顺序的问题,我们通过一段简单的程序来验证,测试代码如下: #include <stdio.h> class A { public: A() { printf("AAAAA\n"); }; ~A(){}; ...
  • 【含答案】第二章 对象--2.1-面向对象方法的特性 (1)单选题 面向对象的程序设计方法采用了什么样的抽象方法构建程序的对象: A 过程抽象 B 数据抽象 C 过程抽象与数据抽象 D 没有采用任何的抽象方法 (2...
  • 不可变对象和类

    千次阅读 2014-11-20 18:58:41
    要使一个
  • 通过接口抽象“创建”对象

    千次阅读 2018-08-21 21:36:24
    前言 首先声明,用接口或者抽象实例化一个对象是不可能的,错误的。 接口、抽象实现注意点 ...现在,我们动手解释下为什么用接口或者抽象实例化对象是错误的,以及该如何重新理解这句话。 ...
  • 在其他语言中比如(Java,c#)可以直接判断对象是否是null来判断对象是否为空,但是在c++中由于指针的存在,不能直接判断对象,而应该判断指向对象的指针是否为空。  C++语言中,对象没有空不空的...
  • java中,StringBuilderStringBuffer的区别,下面说法错误的是? AStringBuffer是线程安全的 BStringBuilder是非线程安全的 CStringBuffer对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 125,216
精华内容 50,086
关键字:

关于类和对象错误的说法是