精华内容
下载资源
问答
  • 类声明构造函数声明实例化继承方法重载抽象类 一、类声明 使用class关键字声明类,查看其声明格式: : modifiers ("class" | "interface") SimpleName typeParameters? primaryConstructor? (":" ...

    kotlin--类和继承


    主要内容

    • 类声明
    • 构造函数声明
    • 实例化
    • 继承
    • 方法重载
    • 抽象类

    一、类声明

    使用class关键字声明类,查看其声明格式:

    : modifiers ("class" | "interface") SimpleName
      typeParameters?
      primaryConstructor?
      (":" annotations delegationSpecifier{","})?
      typeConstraints
      (classBody? | enumClassBody)

    最简略的类声明至少包括 modifiers class SimpleName,如:

    class Empty
    modifiers

    包括 classModifier 和_accessModifier_:

    • classModifier: 类属性修饰符,标示类本身特性。

        abstract //抽象类标示  
        final  //标示类不可继承,默认属性
        enum  //标示类为枚举
        open  //类可继承,类默认是final的
        annotation  //注解类
    • accessModifier: 访问权限修饰符

        private //仅在同一个文件中可见
        protected //同一个文件中或子类可见
        public //所有调用的地方都可见
        internal //同一个模块中可见

    二、构造函数声明

    可以声明一个主构造函数(primary constructor)和多个次级构造函数(secondary constructor),二者都是可选的。

    primary constructor声明

    作为类声明的头部存在,类声明结构:

    class User constructor(name:String)

    当constructor前无修饰符(如:private)时,constructor可以省略:

    class User(name:String)

    当是无参构造函数时,整个构造函数部分也可以省略,省略的构造函数默认是public的:

    class User

    primary constructor 初始化

    由于primary constructor不能包含任何代码,因此使用 init 代码块对其初始化,同时可以在初始化代码块中使用构造函数的参数:

    class User(name:String){
        init{
            //初始化..    
        }
    }

    可以类中初始化属性:

    class User(name:String){
        var customName = name.toUpperCase() //初始化属性
    }

    secondary constructor声明

    使用constructor前缀声明,且必须调用primary constructor,使用this关键字:

    class User(name:String){
    
        /**secondary constructor**/
        constructor(name:String,age:Int):this(name){
            //初始化...
        }
    }

    声明构造函数时,允许指定参数默认值,若所有参数都被指定默认值然后编译,编译器会生成一个额外的无参构造函数来使用初始化属性为初始值。

    class User(name:String = "")

    作为校验,上述声明方式允许如下调用:

    var user = User()
    
    var anotherUser = User("jason")

    若构造函数中并非所有参数都有默认值,则不会生成默认无参构造函数:

    class User(name:String = "",age = Int)
    
    var user = User() //将无法编译通过 
    
    var anotherUser = User("jason",18) //合法声明

    三、实例化

    无需new关键字,即可实例化对象:

    var user = User()

    四、继承(Inheritance)

    Any

    所有类都继承该类,提供默认的三个函数:

    equals()
    
    hashCode()
    
    toString()

    继承声明

    在类的构造函数之后使用 : 标示继承:

    class Student(name:String,age:Int):User(name,age){
    
    }

    当类未声明构造函数时,继承其他类时,也不需要在primary constructor中显示的声明构造函数,必须在secondary constructor中显示调用父类构造函数,若父类有多个构造函数,可选择其一进行调用:

    /**用户基类**/
    open class User(name:String){
    
        /**secondary constructor**/
        constructor(name:String,age:Int):this(name){
            //初始化
        }
    }
    
    /**子类继承User类**/
    class Student:User{
    
        /**构造函数**/
        constructor(name:String):super(name){
    
        }
    
        /**另外一个构造函数**/
        constructor(name:String,age:Int):super(name,age){
    
        }
    }

    所有类定义时默认是final属性,不可被继承。若需要继承,使用open关键字进行修饰。

    方法重载

    方法默认是final的,不可被子类重载,若需要被重载,使用关键词 open 进行修饰,子类重载方法使用 override 关键词:

    open class User{
    
        open fun study(){}
    
        fun run(){}
    }
    
    class Student:User{
        override fun study(){}
    }

    override修饰的方法,默认是可以被继承的。若希望不被继承,可以使用 final 关键词修饰。

    final override fun study(){}

    重载规则

    当类同时继承类和实现接口,且有相同方法,且相同方法都有实现时,需要在重载方法中调用所继承的方法,使用关键词 super<T> ,T表示所继承或实现的接口:

    open class User{
        open fun study(){}
    }
    
    interface Reading{
        fun study(){}
    }
    
    class Student:User(),Reading{
        override fun study(){
            super<User>.study() 
            super<Reading>.study() //与上者至少二选其一
        }
    }

    当接口未实现方法时,默认为父类User的study方法,不需要调用所继承的方法:

    interface Reading{
        fun study()
    }
    
    class Student:User(),Reading{
        override fun study(){
            //do nothing
        }
    }

    抽象类

    Kotlin中的抽象类允许有abstract修饰的成员方法,非抽象类不允许有抽象方法;

    abstract class User{
        abstract fun study()
    }
    
    class Person{
        abstract fun study() // 编译错误
    }

    抽象类默认是可被继承的,接口是特殊的抽象类,允许有抽象方法:

    interface Reading{
        abstract fun reading()
    }
    展开全文
  • java 抽象类 和接口 构造函数

    千次阅读 2010-07-16 11:09:00
    否则这个子类还是个抽象类接口的特征接口内有构造方法接口中声明变量均为final,static,和public得接口中定义的方法均为抽象的和公共的接口里的数据成员必须初始化,且数据成员均为常量interface Truck{ void ...

    1、抽象类和接口有什么区别

    抽象类特征如下:

    抽象类和抽象方法都必须用abstract关键字修饰

    抽象类不能被实例化,也就是不能用new关键产生对象

    抽象方法只需声明而无需事先

    抽象方法必须定义的抽象类中,抽象类的子类必须实现父类中的抽象方法,否则这个子类还是个抽象类

    接口的特征

    接口内有构造方法

    接口中声明变量均为final,static,和public得

    接口中定义的方法均为抽象的和公共的

    接口里的数据成员必须初始化,且数据成员均为常量

     

    interface Truck{
     void sound();
    }
    interface Bus{
     void sound();
    }
    interface Car extends Truck, Bus{
     Cart car = new Cart("hongqi","china");
    }
    class Cart implements Car{
     private String name;
     private String production;
     public String getName(){
      return name;
     }
     public String getProduction(){
      return production;
     }
     public Cart(String name, String production){
      this.name = name;
      this.production = production;
     }
     public void sound(){
      car = new Cart("benchi","America");//这行是错误的。几口中定义的成员变量必须初始化,且都是final类型的。所以只能调用,不能修改值,此句企图修改car值
      System.out.println(car.getName()+","+car.getProduction());
      
     }
    }

     

    构造函数

     

    注意:1构造函数具有和类名相同的名称。

    2他没有返回值,也没有返回类型

    3 每个类可以有多个构造函数,即构造函数可以重载

    4构造函数在创建对象时自动执行,一般不能显示的调用

    5构造方法不能重写,也就是子类不能继承父类的构造方法

    6子类继承父类时,会先自动调用父类的无参构造方法,为父类成员赋初值

     

    关于构造函数下面哪些是正确的?

    1super()或this()必须放在构造函数的第一句

    2如果父类的构造函数没有参数,那么子类的构造函数一定没有参数

    3 构造函数不能被继承

    4构造函数不能被重写

     

    正确的为13

     

    找出下面代码的错误位置

     /*在同一个类的不同构造方法中调用该类的其他构造方法需要使用this(...)
     * 的形式,而且必须是在构造方法的第一行调用,this(name,age);此句错误在于把成员
     * 变量作为参数被构造函数引用,构造方法是一个类对象实例化的起点,实例化的目的就是为
     * 了给类成员初始化,所以引用的参数值应该是常量而不是变量,因此构造方法中
     * 不能将成员作为参数引用*/
    class Woman{
     String name, address;
     int age;
     public Woman(String n){
      name = n;
     }
     public Woman(String n, String a){
      name = n;
      address = a;
     }
     public Woman(String n, String ar, int a){
      this(name,age);
      address = ar;
     }
     
    }

     

     /*如果子类中指定了调用父类中的哪个构造函数,则不再调用默认的无参构造函数,
    super必须放在第一句,是因为子类需要先初始化父类*/

    public class TestClass {
     public static void main(String[] args) {
      System.out.println("创建父类对象:");
      FatherClass sc0 = new FatherClass();
      System.out.println("/n 创建第一个子类对象:");
      SonClass sc1 = new SonClass();
      System.out.println("/n 创建第二个子类对象:");
      SonClass sc2 = new SonClass(1);  
     }
    }
    class FatherClass{
     FatherClass(){
      System.out.println("父类的构造函数");
     }
     FatherClass(int i){
      System.out.println("父类的构造函数2");
     }
    }
    class SonClass extends FatherClass{
     SonClass(){
      super(1);
      System.out.println("子类的第一个构造函数");
     }
     SonClass(int i){
      System.out.println("子类的第二个构造函数");
     }
    }

     

    输出:

    创建父类对象:
    父类的构造函数

     创建第一个子类对象:
    父类的构造函数2
    子类的第一个构造函数

     创建第二个子类对象:
    父类的构造函数
    子类的第二个构造函数

    展开全文
  • 构造函数可写,也可以不写;如果不写,系统将当做写了一个无参构造函数处理; 3.不能写返回值类型; 抽象类: 1.先继承,再使用;不能直接实例化,通过非抽象类继承后,才能实例化对象。 2.类中含有抽象方法,那...

    Java基础——构造函数、抽象类、父类构造方法初始化

    ——小实例快速成长

    构造函数:

    1.在对象初始化时调用,方法名与类名完全相同;

    2.构造函数可写,也可以不写;如果不写,系统将当做写了一个无参构造函数处理;

    3.不能写返回值类型;

    4.不能使用static修饰符。

    5.一个类可以同时存在多个构造函数,这些构造函数之间呈重载关系——即函数名相同,参数类型或参数个数不同。

    6.如果类中已写了构造函数,那在对象初始化时,系统将去搜索符合条件的对应构造函数。

    7.特注:如果类中已写有参构造函数,没重载无参构造函数。在初始化时,却去调用无参构造函数(如例中的第3句代码),编译将无法通过,报错“实际参数列表和形式参数列表长度不同”。

     

    抽象类(关键字abstract):

    1.先继承,再使用;不能直接实例化,通过非抽象类继承后,才能实例化对象。

    2.类中含有抽象方法,那这个类需要声明为抽象类。(含有抽象方法的类,必须为抽象类)

    3.抽象方法:只声明,不含方法体;

    4.在子类中必须实现父类(肯定是抽象类)所有抽象方法。

     

    父类构造方法初始化(关键字super)

    1.显示调用父类构造方法——用super()

    2.若显示调用,必须将super()方法写在最前面;

    3.若不显示调用,则要求父类必须写了‘无参构造函数’,系统会自动调用,否则报错“实际参数列表和形式参数列表长度不同”。


    示例代码:

    <pre name="code" class="java">public class TestBase
    {
      public static void main(String[] args)
      {
          //Cat cat1 = new Cat();  //提示“实际参数列表和形式参数列表长度不同”的错误
          Cat cat2 = new Cat("波斯");
          Wolf wolf1 = new Wolf();
          Wolf wolf2 = new Wolf("蒙古狼");
          Tiger tiger = new Tiger();
          tiger.eat("肉");
      }
    }
    //抽象类
    abstract class Animal
    {
      String Food;
      protected String Name;
    
      //无参构造函数
      public Animal(){
    	System.out.println("父类 无参构造方法!\n");
    	}
    
      //有参构造函数
      public Animal(String name){
    	this.Name = name;
    	System.out.println(Name + "的 父类 有参构造方法!\n");
    	}
    
      //抽象方法
      abstract void eat(String food);
    }
    
    //继承 父类Animal 
    class Cat extends Animal
    {
      //有参构造函数
      public Cat(String name){
    	//初始化父类构造方法
    	super(name);
    	System.out.println("子类Cat有参构造函数!\n");
    	}
    
      public void eat(String food) {
    	//成员变量Food继承自父类——protected成员变量
    	this.Food = food;
    	System.out.println("猫以"+food+"为食!\n");
    	}
    }
    //继承 父类Animal
    class Wolf extends Animal
    {
      //无参构造方法
      public Wolf(){
    	//非显示调用父类构造方法,当程序使用本无参构造方法是,系统将自动调用父类无参构造方法
    	
    	//检验————无参构造函数调用的时机
    	System.out.println("调用了Wolf类的无参构造方法!\n");
    	}
    
      public Wolf(String name){
    	//非显示调用父类构造方法,当程序使用本有参构造方法是,系统将自动调用父类无参构造方法
    	
    	//成员变量Name继承自父类——public成员变量
    	this.Name = name;
    	System.out.println("子类Wolf有参构造函数!\n");
    	}
      public void eat(String food) {
    	//成员变量Food继承自父类——protected成员变量
    	this.Food = food;
    	System.out.println("狼以"+food+"为食!\n");
    	}
    }
    
    //继承 父类Animal
    class Tiger extends Animal
    {
      public void eat(String food) {
    	this.Name = "东北虎";
    	System.out.println("我的名字叫:" + Name + "; 我以" + food + "为食!\n");
    	}
    }
     
    

    运行效果图:


    展开全文
  • c++和对象,构造函数函数重载,复合。 1. 面向过程和面向对象主要区别可以简单概括为:面向过程的编程是一种直接的编程方法是按照编 程语言的思路考虑问题;面向对象的编程是一种抽象度更高的编程方法,它的...

    c++类和对象,构造函数,函数重载,复合类。

    1.

    面向过程和面向对象主要区别可以简单概括为:面向过程的编程是一种直接的编程方法是按照编
    程语言的思路考虑问题;面向对象的编程是一种抽象度更高的编程方法,它的目标是使
    模块的抽象度更高,可复用性更好。
    2.
    面向对象的三大特征:封装性、继承性和多态性。
    3.
    封装:隐藏对象的属性和实现细节,仅对外提供公共访问方式。
    继承:子类继承父类的属性和方法,实现代码的复用。
    多态:C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。
    4.
    类和对象的关系:类是对象的抽象类型,而对象是类的具体实例。
    5.
    结构体和类的区别:结构体成员默认是public,类成员默认是private.
    6.
    //定义一个圆类。属性:圆心坐标以及半径,操作:对圆的信息进行读取、设
    //置以及打印,计算两个圆之间的距离。
    #include <iostream>
    #include <math.h>
    using namespace std;
    class Cicle
    {
        float x;
        float y;
        float r;
    public:
        void set(float a,float b,float c)
        {
            x=a;
            y=b;
            r=c;
        }
        float getx()
        {
            return x;
        }
        float gety()
        {
           return y;
        }
        float getr()
        {
            return r;
        }


        void print()
        {
            cout <<"(" << x <<"," << y << ")" << endl;
        }
        float d(Cicle s)
        {
            
            return sqrt((x-s.x)*(x-s.x)+(s.y-y)*(s.y-y));
        }
    };


    int main(int argc, const char * argv[]) {
        Cicle a,b;
        a.set(1.0, 1.0, 1.0);
        b.set(2.0, 2.0, 2.0);
        cout << a.getx() <<endl;
        cout << a.gety() <<endl;
        cout << a.getr() <<endl;
        cout << b.getx() <<endl;
        cout << b.gety() <<endl;
        cout << b.getr() <<endl;


        cout <<a.d(b) <<endl;
        a.print();
        b.print();
        return 0;
    }
    7。
    三、构造函数
    3.1 构造函数特点
      构造函数是一种比较特殊的成员函数,用于创建并初始化对象。声明对象时构造函
    数会被编译器自动调用。
    构造函数的四个特点:
    (1)构造函数的访问权限必须为公有(public); (2)构造函数名和类名相同; (3)构造函数没有返回值; (4)构造函数可以带参数,用于初始化成员变量;
    3.2 默认构造函数
    默认构造函数分两种: 1、构造函数不带参数;2、构造函数带参数但参数都有默认 值。
       Example codes:
    Circle(); // Circle(float a=0,float b=0,float c=0);// Circle(float a,float b,float c); //
      默认构造函数是指在声明对象时,可以不传递参数,使用空值或默认值对对象进行
    初始化,而普通构造函数在声明对象时必须传递参数(实参),否则构造函数的参数(形 参)没有值,编译出错。
      如果程序员一个构造函数都没写,编译器将提供一个空的默认构造函数,它不会对
    数据成员进行初始化。一旦程序员提供了构造函数,编译器将不提供默认构造函数。对
    于每个类都写一个默认构造函数,是程序员的一个好习惯。
    
    #include <iostream>
    using namespace std;
    class Thing
    {
    public:
    Thing( int a=10, int b=20, int c = 30)//
    { x=a; y=b; z=c; }//,,
        void printThing() {
            cout<<"x="<<x<<" y="<<y<<" z="<<z<<endl;
    } private:
        int x;
        int y;
        int z;
    };


    int main(int argc, const char * argv[]) {
        Thing t;
        t.printThing();
    Thing s(1);// s.printThing();
        Thing r(1,2);
        r.printThing();
        Thing v(1,2,3);
        v.printThing();
        return 0;
    }
    示例分析: 声明t对象时,没有传递参数,那么编译器将会调用默认构造函数,而类中刚好提供
    了一个默认构造函数。 假如将Thing( int a=10, int b=20, int c = 30)的三个默认 值都去掉Thing( int a, int b, int c),再次编译程序会发现,声明t对象、s对象、r
    No matching constructor for initialization of ‘Thing’ 而v对象不会出错。
    8.
    函数重载
    1.1 函数重载的概念
    什么是函数重载?在同一个作用域中,可以有一组具有相同函数名,不同参数列表 的函数,这组函数被称为重载函数。参数列表不同是指参数的个数或参数的类型不同。 如:
        void f();
        void f(int x);
        void f(int x,float y);
      如果仅仅是函数的返回值类型不同,不能是函数的重载:
         void f(int x);
         int  f(int x);  //error: Functions that differ only in their return
                         //       type cannot be overloaded.
      这两个函数不是函数的重载,在同一个作用域内是不能共存的,因为在函数调用时
    不知道该调用哪一个函数。
    例1-1】构造函数重载
    #include <iostream>
    using namespace std;
    class Thing
    {
    public:
        Thing( ) {x =0; y= 0; z=0;}  //default constructor
        Thing(int a) { x=a;}
        Thing(int a, int b) {x=a;y=b;}
        Thing(int a, int b, int c) { x=a; y=b; z=c; }
        void printThing() {
            cout<<“x=“<<x<<",y="<<y<<",z="<<z<<endl;
    }
    private:
        int x;
    int y;
    int z; };
    int main(int argc, const char * argv[]) {
        Thing t;
        t.printThing();
        Thing s(1);
        s.printThing();
        Thing r(1,2);
        r.printThing();
        Thing v(1,2,3);
        v.printThing();
        return 0;
    }
    示例分析: (1)类中可以定义多个构造函数,但是必须能够构成函数重载;
    (2)声明对象时的参数类型和个数要与构造函数的参数进行匹配。 16年7月22日 星期五
    二、初始化列表
    在使用C++编程的过程当中,常常需要在构造函数中对类的成员变量进行初始化,通 常的方法有两种:
      第一种方法:在构造函数体内通过赋值语句初始化
           Thing(int a,int b,int c){ x = a; y = b; z = c; }
      第二种方法:使用初始化列表形式初始化
           Thing(int a,int b,int c):x(a), y(b), z(c) { }
    程序中为什么要使用初始化列表? (1)对于类类型的成员,使用初始化列表效率更高。
    (2)有些类型的成员变量必须使用初始化列表的形式初始化,如const成员、引用 成员。
    (3)在继承时,子类的构造函数中初始化父类的成员时。
    例2-1】初始化列表的使用
    // Created by Mr_lee on 16/7/22.
    // Copyright © 2016 . All rights reserved.
    #include <iostream>
    using namespace std;
    class Thing
    {
    public:
        Thing(int _x,int _y) : x(_x), y(_y){ }
        void print() {
            cout<<"x="<<x<<",y="<<y<<endl;
        }
    private:
        int x;
    int y; };
    int main(int argc, const char * argv[]) {
        Thing t(1,1);
    t.print();
    return 0; }
    三、复合类
    复合类也称为组合类,是指将一个类的对象作为另一个类的成员变量。 例3-1】复合类示例


    #include <iostream>
    using namespace std;
    class Point
    {
    public:
        Point();
        Point(float _x,float _y);
        void print();
    private:
        float x;
    float y; };
    Point::Point(){ }
    Point::Point(float _x,float _y) {
        x = _x;
    y = _y; }
    void Point::print() {
        cout<<"("<<x<<","<<y<<")"<<endl;
    }
    //—————————————— ———————————————// class Circle
    { public:
        Circle();
        Circle(float x,float y,float r);
        void setCircle(float r,Point p);
        void print();
    private:
        float radius;
        Point center;
    };


    
    Circle::Circle(){} //center
    //Point Circle::Circle(float x,float y,float r):center(x,y),radius(r) { }
    void Circle::setCircle(float r,Point p) {
        radius = r;
    center = p; }
    void Circle::print() {
        cout<<"radius:"<<radius<<endl;
        center.print();
    }
    int main(int argc, const char * argv[]) {
        Point p(5,7);
        p.print();
        Circle c;
        c.setCircle(1, p);
        c.print();
        return 0;
    }
    展开全文
  • 对C++中的一些特性做些常识性的总结,增强...分析了构造函数和析构函数的性质,函数重载以及this指针。需要注意理解的是 以及 的对象 两者之间的关系,希望能更好的体会面向对象以及提升编程中抽象事物的能力。
  • 接口 类 抽象类 继承 构造函数 方法重写 方法重载 自动转型 多态 引用传递
  • 的赋值构造函数和复制构造函数

    千次阅读 2016-10-31 22:41:49
    C++的初学者经常会对复制构造函数一知半解,我曾经对复制构造函数和赋值函数就很是迷茫。闲来无事,整理一下,一个对象的赋值构造函数和赋值构造函数。整体的说一下,复制构造函数和赋值构造函数的相同点是: 赋值...
  • 关于抽象类构造函数的一些学习

    千次阅读 2014-02-21 14:58:53
    子类在创建实例后,初始化方法会调用父类的初始化方法(除了java.lang.Object,因为java.lang.Object没有父类),而这种调用会逐级追述,直到java.lang.Object的初始化方法。 这个地方我说的是初始化方法,而...
  • 可以使同一功能适用于各种类型的数据,它是声明两个以上的同名方法,实现对不同数据类型进行相同的处理 方法重载的要求 1、 重载的方法名称必须相同 2、 重载的方法,其形参个数或类型必须不同   如我们定义...
  • 抽象类与纯虚函数

    多人点赞 2014-11-11 10:53:24
    抽象类与纯虚函数
  • 首先从构造函数说起,在C++面向对象的设计中,每一个对象代表一个抽象集合的实体,此时每一个实体在当前运行的进程中是需要对应的内存空间,即对象存在则有空间。为此,C++引入构造函数来实例化对象,并让编译器为该...
  • struct: 默认public(结构体是一种特殊的) class: 默认private 数据成员和成员函数对外不能被访问 在c++中结构体和是...每个都必须有一个构造函数,如果自己没有写,那么c++会提供一个默认的构造函数用于创
  • 抽象类 & 接口 一、抽象类: ...另外,抽象类可以派生自一个抽象类可以覆盖基类的抽象方法也可以不覆盖,如果不覆盖,则其派生类必须覆盖它们。 二、接口:  接口是引用类型的,类似于类,和抽象
  • 众所周知,三层的D层主要是对数据的处理,而...首先是一个带参数返回值为bool的函数,在写一个不带参数返回值为bool的函数,还有一个不带参数返回值为datatable的函数,最后是一个带参数返回值为datatable的函数,如果
  • C++多态性,虚函数重载抽象类

    千次阅读 2016-07-21 14:55:17
    1,C++多态性,虚函数重载,比较有意思,,,,,, 在面向对象的程序中,当不同的对象接受到相同的消息产生不同的动作,这种性质称为多态性。
  • 【C++】C++和对象、构造函数和析构函数

    千次阅读 多人点赞 2018-06-03 20:32:37
    是对某一事物的抽象描述,具体地讲,是C++中的一种构造的数据类型。它即可包含描述事物的数据,又可包含处理这些数据的函数在程序运行时是被用作样板来建立对象的。所以要建立对象,首先必须定义。 定义...
  • 2-1在的定义中,用于为对象分配内存空间,对的数据成员进行初始化并执行其他内部管理操作的函数是 C A 友元函数 B 虚函数 C 构造函数 D 析构函数 2-2的析构函数的作用是 D A 一般成员函数的初始化 B 的初始...
  • 默认构造函数指不带参数或者所有参数都有缺省值的构造函数!...每个只有一个析构函数和一个赋值函数,但可以有多个构造函数(包含一个拷贝构造函数,其它的称为普通构造函数)。对于任意一个A,如果不编写上述
  • 关于组合构造函数调用的分析

    千次阅读 2020-04-05 10:18:57
    关于组合构造函数调用的分析 组合相关的概念 一种包含与被包含的关系。 例如,用一个来描述计算机系统.首先可以把它分解为硬件和软件 硬件包含中央处理单元(CPU)存储器、输入设备和输出设备,软件可以包括系统...
  • 一、拷贝构造函数 1、 仅当准备用按值传递的方式传递对象时,才需要拷贝...3、 如果允许编译器为派生生成拷贝构造函数,它将首先自动地调用基类的拷贝构造函数,然后再是各成员对象的拷贝构造函数。 二、运算符重
  • 文章目录一、派生类构造函数与基类构造函数二、创建与销毁派生类对象时,构造函数和析构函数的调用三、派生类和基类之间的特殊关系四、公有继承(一)、何为公有继承(二)、多态公有继承(三)、虚函数的工作原理...
  • 抽象类、纯虚函数、虚函数

    千次阅读 2017-08-08 17:01:22
    抽象类、纯虚函数、虚函数
  • 利用构造函数对象进行初始化

    千次阅读 2017-05-01 20:25:22
    9.1利用构造函数对象进行初始化 9.1.1对象的初始化 在程序中常常需要对变量赋初值,即对其初始化。 那么,怎样使他们得到初值呢?有人试图在声明时对数据成员初始化。如 class Time { hour=0; minute=0...
  • 嵌入式Linux下QT程序设计;本章主要内容#include ... class Complex { //复数定义 public: //外部接口 Complex(double r = 0.0, double i = 0.0) : real(r, imag(i) { } //构造函数 Complex operator + (const Com
  • 内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚函数、模板和包容器...
  • C++继承派生类构造函数的写法

    千次阅读 2019-06-16 22:51:01
    C++有三大思想:抽象与封装、继承与派生、多态性,是c++开发人员面对对象编程必须掌握的知识。 初学者对子类继承中构造函数的写法有时会存在一些问题。即子类继承基类时,子类的...②再执行派生类构造函数本身(...
  • C++中class默认属性为private, struct默认属性为public 构造函数:  1....  2.创建对象;... 由于虚函数是建立在对象的基础上的,... 每个对象都有一个默认构造函数.当一个对象被在堆上创建的时候,第一步先执行new
  • C++的函数重载

    万次阅读 多人点赞 2018-07-11 13:44:56
    ——每个现象后面都隐藏一个本质,关键在于我们是否去挖掘 ...函数重载的重要性不言而明,但是你知道C++中函数重载是如何实现的呢(虽然本文谈的是C++中函数重载的实现,但我想其它语言也是类似的)
  • [Java基础]Java中抽象类和接口中有构造方法吗?

    万次阅读 多人点赞 2017-07-05 10:56:13
    2.问题描述:Java中抽象类和接口中有构造方法吗? 3.问题解答: (1)Java中抽象类和接口中有构造方法吗? ①在接口中 不可以构造方法 在接口里写入构造方法时,编译器提示:Interfaces ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 88,505
精华内容 35,402
关键字:

抽象类可以进行构造函数重载