精华内容
下载资源
问答
  • 抽象类可不可以定义对象
    万次阅读
    2016-10-09 10:07:50

    可以用一个抽象类定义一个指向该类的指针,但是不能定义或声明对象。

    这个中原因就是,定义一个类的对象是,编译器在编译时需要了解类的所有信息以便准确的为要实例化的对象分配内存;由此可见,定义一个类对象是要生成一个类的实例的,而C++规定抽象类是不能实例化的,所以会报出如下错误:

    error C2259: 'CBase' : cannot instantiate abstract class

    >        due to following members:
    >        'int CBase::func(int)' : is abstract
    public:
     virtual int func(int param) = 0;
    private:
    };
    public:
     CTestA();
     ~CTestA();
     virtual int func(int param);
    private:
     int m_value;
    };
    {
     CBase cb0; //定义或声明一个对象,error
     CBase *cb = new CTestA(); //定义一个指针,OK
    }

     

    但是定义一个指针就不同了,指针是什么?大家都知道,无论它指向的是内部类型还是自己定义的结构体类型还是类的类型变量,它只不过就是一个具有32BIT也就是4个字节内存的空间而已,不需要其他任何信息了,所以能成功定义一个抽象类的指针变量。

     

    class CBase{

    class CTestA:public CBase{

    int _tmain(int argc, _TCHAR* argv[])

     return 0;


    更多相关内容
  • 抽象类为什么能创建对象

    千次阅读 2020-07-10 17:24:06
    在C++中,含有纯虚拟函数的类称为抽象类,它能生成对象;在java中,含有抽象方法的类称为抽象类,同样能生成对象抽象类完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当...

    抽象类是什么?

    抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对一系列看上去不同,但是本质上相同的具体概念的抽象。

    通常在编程语句中用 abstract 修饰的类是抽象类。在C++中,含有纯虚拟函数的类称为抽象类,它不能生成对象;在java中,含有抽象方法的类称为抽象类,同样不能生成对象。

    抽象类是不完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当全局变量的角色。

     通过上面的阐述,大家应该对抽象类有了一个大概的认识吧!但是对纯虚拟函数和抽象方法分别是什么还是有一定的模糊

    纯虚函数:纯虚函数是一种特殊的虚函数,在许多情况下,在基类中不能对虚函数给出有意义的实现,而把它声明为纯虚函数,它的实现留给该基类的派生类去做。这就是纯虚函数的作用。

    纯虚函数也可以叫抽象函数,一般来说它只有函数名、参数和返回值类型,不需要函数体。这意味着它没有函数的实现,需要让派生类去实现。

    抽象方法:java中的抽象方法就是以abstract修饰的方法,这种方法只声明返回的数据类型、方法名称和所需的参数,没有方法体,也就是说抽象方法只需要声明而不需要实现。

    为什么抽象类还不能创建对象? 

    首先与具体的类作比较:

    1. 抽象类不能直接实例化,并且对抽象类使用 new 运算符会导致编译时错误。虽然一些变量和值在编译时的类型可以是抽象的,但是这样的变量和值必须或者为 null,或者含有对非抽象类的实例的引用(此非抽象类是从抽象类派生的)
    2. 允许(但不要求)抽象类包含抽象成员。
    3. 抽象类不能被密封。

     与接口作比较:

    相同点——不能实例化、包含未实现的方法声明、派生类必须实现未实现的方法,抽象类是抽象方法,接口则是所有成员(不仅是方法包括其他成员)

    不同点——

    1. 类可以实现无限个接口,但仅能从一个抽象(或任何其他类型)类继承,从抽象类派生的类仍可实现接口,从而得出接口是用来解决多重继承问题的。
    2. 抽象类当中可以存在非抽象的方法,可接口不能,且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。
    3. 抽象类中的成员变量可以被不同的修饰符来修饰,可接口中的成员变量默认的都是静态常量(static final)
    4. 抽象类是对象的抽象,然而接口是一种行为规范。

    在Java中的应用:

    1. abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface
    2. 在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的。
    3. abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。
    4. 实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法
    5. 接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值
    6. 抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以重新赋值、
    7. 接口中的方法默认都是 public,abstract 类型的
    展开全文
  • 这种情况搞懂,创建对象成功了,是只要把抽象方法给具现化了就能创建吗? ``` abstract class Driver { public abstract void drive(); } public class Test { public static void main(String[] args) ...
  • Java抽象类/抽象方法定义及其特性详解

    千次阅读 多人点赞 2019-09-28 18:37:53
    定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处,而需要重复类的共同特性。这样就使得程序概念层次分明,开发更...

           类的继承结构中,越往上的类越具有通用性,也就越抽象。当它抽象到一定程度,就变成概念成框架,不能再产生实例化的对象了。例如“交通工具”,就无法用它来产生一个实例。
           对应这一现象,Java中提供了抽象类,它只能作为父类,不能实例化。定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处,而不需要重复类的共同特性。这样就使得程序概念层次分明,开发更高效。与抽象类紧密相连的是抽象方法一它总是用在抽象类或接口中。

    一、抽象类的定义

    被关键字“abstract”修饰的类,为抽象类。(而且,abstract只能修饰类和方法)

    abstract class className{
    	类体;
    }
    

    在抽象类中,可以有0个或者多个抽象方法,也可以有普通的实例方法和静态方法,还可以有其他的成员变量和构造方法。如果类中没有任何形式的抽象方法,那么可以由程序员决定是否将类声明成abstract类型,但是只要是下面这些情况之一,那类必定为抽象类,必须加上abstract修饰。

    • 类中明确声明有abstract方法的。
    • 类是抽象类继承下来的,而且没有实现父类中全部的抽象方法。
    • 类实现了一个接口,但没有将其中所有的抽象方法实现。

    抽象类不一定有抽象方法,有抽象方法的类一定是抽象类或者是接口。(这点要铭记,有些文章说含有抽象方法的类就是抽象类,这个是不准确的)


    那么什么是抽象方法呢?

    二、抽象方法的声明

    抽象方法:使用abstract关键字定义的方法,抽象方法没有具体的方法体;抽象类必须也要用abstract关键字定义。

    抽象方法是一种只有方法声明面没有方法体定义的特殊方法。它的声明部分和一般方法并
    没有太大的区别,也有访问权限、返回值类型等,只是需要在前面加上一个关键字“abstract”。通常的形式如下
    abstract 访问权限 返回类型 方法名 ([参数列表]);
    特持别注意它的最后有一个分号“;”,而没有方法体的括号“{ }”。
    例如下面就是一个合法的抽象方法。
    abstract protected void eat();
    而下面这个,虽然方法体为空,但它不是一个合法的抽象方法。
    abstract protected void eat() { }

    声明抽象方法时有以下几个限制,具体原理文章后面会讲到

    • 构造方法不能声明为 abstract
    • 静态方法不能声明为 abstract
    • privale方法不能声明为 abstraet
    • final方法不能声明为 abstract
    • 抽象方法只能出现在抽象类或接口中

    三、抽象类的特点

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

    abstract class 类名 {}
    public abstract void 方法名();
    

    2.抽象类不一定有抽象方法,有抽象方法的类一定是抽象类或者是接口(这点上面讲过,是个易错点)

    3.抽象类不能实例化,那么抽象类如何实例化
    抽象类如果可以实例化的话,那么就可以调用类中的抽象方法,很明显调用抽象方法是没有意义的,所以抽象类不能实例化,如何非要实例化,那就按照多态的方式,由具体的子类实例化。(其实这也是多态的一种,抽象类多态,不能算抽象类实例化

    public class Demo1_Abstract {
    	public static void main(String[] args) {
    		//Animal a = new Animal();			//错误: Animal是抽象的; 无法实例化
    		Animal a = new Cat();				//父类引用指向子类对象
    		a.eat();
    	}
    }
    
    abstract class Animal {						//抽象类
    	public abstract void eat();				//抽象方法
    }
    
    class Cat extends Animal {
    	public void eat() {
    		System.out.println("猫吃鱼");
    	}
    }
    

    运行结果:
    在这里插入图片描述

    4.抽象类的子类

     要么是抽象类
     要么重写抽象类中的所有抽象方法
    

    补充说明
    在这里插入图片描述

    四、抽象类的成员特点

    抽象类的成员特点:

    1. 成员变量:既可以是变量,也可以是常量。(abstract是否可以修饰成员变量?不能修饰成员变量)
    2. 构造方法:有,用于子类访问父类数据的初始化。
    3. 成员方法:既可以是抽象的,也可以是非抽象的。
    abstract class Demo {
    	int num1 = 10;         //定义了变量
    	final int num2 = 20;   //定义了常量
    
    	public Demo(){}		   //构造方法
    
    	public void print() {
    		System.out.println("hello");
    	}
    
    	public abstract void method();    //既有非抽象方法又有抽象方法
    }
    
    class Test extends Demo {
    	public void method() {
    		System.out.println("world");
    	}
    }
    

    抽象类的成员方法特性:

    • 抽象方法:强制要求子类做的事情。
    • 非抽象方法:子类继承的事情,提高代码复用性。

    五、抽象类的一些问题解答

    1、一个抽象类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
    可以,这么做目的只有一个,就是不让其他类创建本类对象,交给子类完成

    2.构造方法为什么不能声明为 abstract?
    构造方法不能被继承,一个抽象的构造方法将永远不会被实现,所以它也不能声明为abstract的。

    3.abstract不能和哪些关键字共存?

    1.abstractstaticabstract修饰的方法没有方法体
        被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
    2.abstractfinalabstract修饰的方法强制子类重写
        被final修饰的不让子类重写,所以他俩是矛盾
    3.abstractprivateabstract修饰的是为了让子类看到并强制重写
        被private修饰不让子类访问,所以他俩是矛盾的
    

    测试如下

    abstract class Demo {
    	//public static abstract void print();	//错误: 非法的修饰符组合: abstract和static
    	//public final abstract void print();	//错误: 非法的修饰符组合: abstract和final
    	private abstract void print();			//错误: 非法的修饰符组合: abstract和private
    }
    
    展开全文
  • 一、抽象类 定义:在普通类的基础上扩充了一些抽象方法 。 1. 抽象方法:只声明而未实现...抽象类中没有具体实现,因此抽象类不能直接实例化对象 abstract class Person{ private String name;//姓名属性 ...

    一、抽象类

    	定义:在普通类的基础上扩充了一些抽象方法 。
    

    1. 抽象方法:只声明而未实现的方法(没有方法体

    • 所有抽象方法使用abstract定义。同时抽象方法所在的类也要用abstract定义,表示抽象类。
    • 举例:定义一个抽象类:

    抽象类中没有具体实现,因此抽象类不能直接实例化对象

    abstract class Person{
    	private String name;//姓名属性
    	public String getName(){
    		return this.name;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    	//{}为方法体,所有抽象方法没有方法体{}
    	public abstract void getPersonInfo();//抽象方法
    }	
    

    2.抽象类的使用原则

    (1)抽象类必须有子类(abstract与final不能同时使用)。
    (2)子类覆写抽象类所有的抽象方法(abstract与private不能同时使用)。
    (3)抽象类实例化对象,必须通过子类向上转型来实例化对象(抽象类无法直接实例化对象)。
    final与abstract不能同时使用
    private与abstract不能同时使用

    //抽象类的标准操作,也是常用操作。
    
    abstract class Person{
    	//姓名属性
    	private String name;
    	//普通方法
    	public String getName(){
    		return this.name;
    	}
    	public void setName(String name){
    		this.name=name;
    	}
    	//抽象方法
    	public abstract void getPersonInfo();
    }
    
    //子类继承抽象类
    class Student extends Person{
    	public void getPersonInfo(){
    		System.out.println("I am a student");
    	}
    }	
    
    public class Test{
    	public static void main(String[] args){
    		//实例化子类,向上转型
    		Person per = new Student();	
    		//被子类所覆写的方法
    		per.getPersonInfo();
    	}
    }
    
    运行结果:I am a student
    
    abstract class Person{
        private String name ; // 属性
        public String getName(){ // 普通方法
            return this.name;
        }
        public void setName(String name){
            this.name = name ;
        }
        
        public abstract void getPersonInfo() ; //抽象方法
    
        public static Person getInstance() { //取得A类对象
        	//定义抽象类的子类 (内部类)
            class Student extends Person {  
                public void getPersonInfo() {
                    System.out.println("I am a student");
                }
            }
            return new Student();
        }
    }
    
    public class Test{
        public static void main(String[] args) {
            Person per = Person.getInstance();
            per.getPersonInfo() ; //被子类所覆写的方法
        }
    }
    
    运行结果:I am a student
    

    3.抽象类的相关规定

    (1)抽象类也提供构造方法,并且子类也遵循对象实例化流程:先调用父类构造方法,再调用子类构造方法

    abstract class Person{
    	private String name;
    	public String getName(){
    		return name;
    	}
    	
    	//父类构造方法
    	public Person(){
    		System.out.println("1.**************");
    	}
    
    	//抽象方法
    	public abstract void fun();
    }
    
    class Student extends Person{
    	//子类构造方法
    	public Student(){
    		System.out.println("2.##############");
    	}
    
    	public void fun(){
    		System.out.println("子类继承抽象类");
    	}
    }
    public class Test{
    	public static void main(String[] args){
    		new Student();//先调用父类构造方法,再调用子类构造方法
    	}
    }
    
    运行结果:
    1.**************
    2.##############
    
    //面试题
    
    abstract class Person{
    	public Person(){//3.调用父类构造
    		this.print();//4.调用被子类覆写的方法
    	}
    	public abstract void print();//抽象方法
    }
    
    class Student extends Person{
    	private int num = 100;//此句在对象new成功后才会用到,此句告诉构造方法要将num赋值为100
    	public Student(int num){//2.调用子类实例化对象
    		// super();//3.隐含这一句,实际要先调用父类构造。此时还未执行“将num赋值为100”的操作,就去调用父类构造了。num默认为int的默认值0。
    		//num=100;//此句在构造方法中隐式实现。
    		//总的来说,构造方法会隐藏  给变量的赋值操作。 
    		
    		this.num=num;//7.为类中属性初始化
    	}
    	public void print(){//5.此时子类对象的属性还没有被初始化
    		System.out.println(this.num);//6.输出其对应数据类型的默认值,为0
    	}
    }
    
    public class Test{
    	public static void main(String[] args){
    		//先调用父类构造方法,再调用子类构造方法。调用父类构造后,调用打印方法,输出num的值0。调用子类构造,在内存中完成num赋值为30,但并未调用打印方法,因而只有一个值。
    		new Student(30);//1.实例化子类对象
    	}
    }
    //父类中num=0,子类中num=30。但由于子类中没有调用打印方法,所以只有一个父类的num值,为0。
    运行结果:0
    

    (2)抽象类中可以不定义抽象方法,但仍然无法直接实例化对象。
    在这里插入图片描述
    (3)abstract与final、private不能一起用。

    • final声明的类不允许有子类,而abstract抽象类必须有子类。
    • 抽象方法必须要被覆写,因此不能用private封装。
      (4)抽象类也分为内部抽象类和外部抽象类。
    • 内部抽象类(了解)可以使用static定义来描述外部抽象类
      在这里插入图片描述
      如果此时在外部抽象类中使用static就会出现语法错误,但是内部抽象类允许使用static
    //内部抽象类使用static修饰
    
    abstract class A{//此结果出现几率很低
    	public abstract void printA();
    	static abstract class B{
    		public abstract void printB();
    	}
    }
    class x extends A.B{
    	public void printB(){}
    }
    
    注意:对象实例化的核心步骤
      ①类加载
      ②类对象的空间开辟
      ③类对象中的属性初始化(构造方法)
    
    方法可以重写,属性不能重写。
    
    展开全文
  • 抽象类的用法以及定义

    万次阅读 2016-07-15 15:07:34
    与具体类比较 1.抽象类不能直接实例化 2.抽象类可以不含抽象方法 ...3.抽象类中含有抽象方法时,如果子类继承该抽象类...7.抽象类含有非抽象方法,而且子类继承该类时,重写了该方法,那么该子类的对象调用该方法时
  • Java抽象类和抽象方法如何定义

    千次阅读 2020-11-18 23:46:06
    具体的类是可以被初始化为对象的,在类的声明前面加上抽象类关键词abstract,则该类就会成为一个抽象类。 abstract public class Canine extends Animal { public void roam () {} } 编译器不会让你初始化抽象类,...
  • JAVA基础知识总结7(抽象类 | 接口)

    千次阅读 2021-03-14 14:54:36
    抽象类:abstract1.抽象:具体,看明白。抽象类表象体现。2.在不断抽取过程中,将共性内容中的方法声明抽取,但是方法一样...抽象类的特点:1:抽象方法只能定义抽象类中,抽象类和抽象方法必须由abstract关...
  • 首先,抽象类可以有构造器、静态方法,抽象类不一定要被其他类继承,直接实例化就使用 抽象类可以有构造器、静态方法。构造器能被子类继承并完成初始化,但不会创建抽象类的实例对象。静态方法的好处是实例...
  • Java:接口和抽象类,傻傻分清楚?

    千次阅读 多人点赞 2019-04-26 07:28:15
    再来聊聊接口和抽象类
  • 抽象类和接口

    千次阅读 2020-11-24 19:38:35
    抽象类 ​ 概述 ​ 父类当中的方法,被他的子类们重写,子类的各自实现又一样。那么父类的方法声明和方法体,只有声明还有意义,而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。...
  • python 如何定义抽象类和抽象方法

    千次阅读 2020-01-10 13:00:05
    文章目录(一)python 如何定义抽象类和抽象方法(二)python中的多态(三)类的组合 (一)python 如何定义抽象类和抽象方法 在python中类 通过继承metaclass = ABCmeta类来创建抽象类抽象类是包含抽象方法的类,...
  • 面向对象——抽象类与抽象方法

    千次阅读 2020-04-13 09:26:04
    如果一个类与具体的食物相联系,而只表达一种抽象的概念,仅是作为其派生类的一个基类,这样的类就是派生类,在抽象类中,声明抽象类中声明抽象方法是,如果加上abstract关键字则为抽象方法。abstract 修饰符...
  • 面向对象编程之继承、多态、封装、抽象类、接口、包继承类的继承格式为什么要继承继承的特点继承的种类及关键字访问权限多态向上转型动态绑定方法重写重写和重载的区别比较多态的优点封装实现Java的封装封装的优点...
  • C#抽象类和抽象方法(很详细,你值得拥有!!!)

    千次阅读 多人点赞 2020-06-18 19:10:32
    什么是抽象类? 什么是抽象方法? 抽象类和抽象方法有什么特性? 抽象类的使用场景? 抽象类的作用? 抽象类和接口的区别? 抽象类和抽象方法怎么声明? 抽象类和抽象方法如何使用?
  • 返回本章节返回作业目录需求说明:不同的动物都有进食的行为,但是在进食前需要捕获到食物后才... 实现思路:定义抽象类动物Animal,在其中定义捕食抽象方法predation()和非抽象进食方法eat(),并在进食方法中调用...
  • 抽象方法必须在抽象类中吗

    千次阅读 2021-03-11 10:44:32
    抽象方法必须在抽象类中吗2020-07-01 15:01:18文/叶丹1、抽象方法必须在抽象类中,所以抽象类中的方法都必须是抽象方法。2、Final类中的属性和方法都必须被final修饰符修饰。3、最终类能派生子类,最终方法能被...
  • 为什么有了接口还要增加一层抽象类

    千次阅读 多人点赞 2021-12-26 14:56:39
    为什么有了接口还要增加一层抽象类
  • JAVA图形面积与周长(抽象类

    千次阅读 多人点赞 2020-01-15 19:18:13
    /*面向对象具有抽象性、封装性、继承性、多态性。抽象性是将具有一致的数据结构(属性)和行为(操作)的对象抽象 ...可以在一个已经存在的的基础之上来进行,把这个已经存在的定义的内容作...
  • 第四章 抽象类与接口

    千次阅读 2020-04-11 21:02:46
    抽象类(Abstract Class)1、定义2、特点3、目的4、实例二.接口(Interface)1、定义2、特点3、目的4、实例三.抽象类与接口区别1、结构2、继承方式3、构造方法4、多/单继承5、速度6、设计举例四.父类的静态方法能...
  • 一、接口、抽象类、继承、实现定义接口 接口是一种比抽象类更加抽象的“类”。这里给“类”加引号是我找到更好的词来表示,但是我们要明确一点就是,接口本身就不是类,从我们能实例化一个接口就可以看出。如new...
  • 3.2、抽象一个和实例化对象

    千次阅读 2018-03-28 19:20:36
    一、抽象一个 二、实例化对象 1、实例化对象 2、对象类型在内存中分配情况 三、$this 四、构造函数和析构函数
  • C++抽象类

    万次阅读 2019-02-27 12:46:52
    带有纯虚函数的类称为抽象类不可实例化 抽象类的作用:将有关的数据和行为组织在一个继承层次结构中,保证派生类具有要求的行为。对应暂时无法实现的函数,可以声明为纯虚函数,留给派生类去实现。 需要注意...
  • book.i只能通过这种形式来访问但是把i弄成静态的就可以直接Book.i内部也一样 上面的肯定能直接访问Book.Book1那又怎么能访问Book.Book1.i呢?他定义了这个i为静态,那肯定应该是支持直接通过类名来访问的,但是...
  • 抽象类 为什么使用抽象类 1:定义Dog类 有颜色属性和叫的方法 2:定义Bird类 有颜色属性和叫的方法 3:定义其父类Animal 1:抽取共性颜色属性和叫的方法 1:颜色的属性可以使用默认初始化值。 2:叫的方法在...
  • 抽象类真的也可以被实例化(Java)

    万次阅读 多人点赞 2017-09-16 16:24:05
    抽象类实例化
  • public class TestClass { private InterfaceA a = new InterfaceA() { @Override public void testA() { ...//成员匿名,例如在Android开发中常用的Handler。 public static void main(St...
  • 3、抽象类可以继承实体类,这是因为抽象类可继承性且有方法。 4、一个接口可以继承多个接口. interface C extends A, B {}是可以的; 5、 一个类可以实现多个接口: class D implements A,B,C{},但是一个类只能继承...
  • 抽象类与具体类区别

    千次阅读 2018-07-07 12:28:00
    abstract 抽象能被直接实例化的、用例、信号、其他元或其他泛化元素,它也可以用来描述没有实现的操作。反义词:具体(concrete)。 见抽象操作(abstract opera

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 524,467
精华内容 209,786
关键字:

抽象类可不可以定义对象

友情链接: m3u8streamtv_2.9_all.rar