精华内容
下载资源
问答
  • 抽象类定义

    千次阅读 2017-05-26 15:40:25
    抽象类定义  普通类可以直接产生实例化对象,并且在普通类中可以包含构造方法、普通方法、static 方法、常量、变量的内容。而所谓抽象类就是指在普通类的结构里面增加抽象方法的组成部分,抽象方法指的是没有...
    抽象类定义
           普通类可以直接产生实例化对象,并且在普通类中可以包含构造方法、普通方法、static 方法、常量、变量的内容。而所谓抽象类就是指在普通类的结构里面增加抽象方法的组成部分,抽象方法指的是没有方法体的方法,同时抽象类方法还必须使用abstract关键字定义。拥有抽象方法的类一定属于抽象类,抽象类要使用abstract声明。
    定义抽象类:
    abstract class A{    //定义一个抽象类,使用abstract声明
        public void fun(){  //普通方法
           System.out.println("存在又方法体的方法");  
    //此方法没有方法体的声明,并且存在abstract关键字,表示抽象方法
        public abstract void print();
     }
    }
    在本程序的类中定义了一个抽象方法print(),既然类中有抽象方法,那么类就必须定义为抽象类,所以使用了“abstract class”来定义。但是一定要记住:抽象类只是比普通类多了抽象方法的定义,其他结构与普通类完全一样。

    注意:抽象类不能直接实例化对象

    范例:错误的实例化抽象类的操作。
    public class TestDemo{
        public static void main(String[] args){
           A a = new a();  //A是抽象的,无法实例化
      }
    }

    如果要想使用抽象类,必须遵守如下原则。
    1.抽象类必须有子类,即每一个抽象类一定要被子类所继承(使用extends关键字),但是在“java”中每一个子类只能够继承一个抽象类,所以具备单继承局限;
    2.抽象类的子类(子类不是抽象类)必须覆写抽象类中的全部抽象方法(强制子类覆写);
    3.依靠对象的向上转型概念,可以通过抽象类的子类完成抽象类的实例化对象操作。


    范例:错误的实例化抽象类的操作。
    abstract class A{	//定义一个抽象类,使用abstract声明
    		public void fun(){	//普通方法
    			System.out.println("存在有方法体的方法!");
    	}
    	//此方法并没有方法体的声明,并且存在abstract关键字,表示抽象方法
    	public abstract void print();
    }
    //一个子类只能够继承一个抽象类,属于单继承局限
    class B extends A{   //B类是抽象类的子类,并且是一个普通类
        public void print(){ //强制要求覆写的方法
           System.out.println("Hello World !");
      }    
    }
    
    public class TestDemo{
      public static void main(String[] args){
         A a = new B();  //向上转型
         a.print();          //被子类覆写过的方法
      }
    }

    
    本程序为抽象类定义了一个子类B,而子类B(是一个普通类)必须要覆写抽象类中的全部抽象方法,而在主方法中依靠子类对象的向上转型实现了抽象类A对象的实例化操作,而调用的print()方法由于被子类所覆写,所以最终调用的是在子类B中覆写过的print()方法。

    展开全文
  • 可以用一个抽象类定义一个指向该类的指针,但是不能定义或声明对象。 这个中原因就是,定义一个类的对象是,编译器在编译时需要了解类的所有信息以便准确的为要实例化的对象分配内存;由此可见,定义一个类对象是要...

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

    这个中原因就是,定义一个类的对象是,编译器在编译时需要了解类的所有信息以便准确的为要实例化的对象分配内存;由此可见,定义一个类对象是要生成一个类的实例的,而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;


    展开全文
  • 抽象类定义?为什么要使用抽象类?

    千次阅读 2018-07-16 20:18:15
    为什么要使用抽象类? 有什么好处? 答案:1 现实中一些父类中的方法没必要写 各个子类中的方法会有所不同 所以没必要在父类中写 2 看被人代码时候会注意这是抽象方法...5 含有抽象方法的类必须定义抽象类 ...

    为什么要使用抽象类? 有什么好处?

    答案:1  现实中一些父类中的方法没必要写  各个子类中的方法会有所不同 所以没必要在父类中写

    2  看被人代码时候会注意这是抽象方法 会有个提示作用

    3 当看到一个类是抽象的,要关心他的抽象方法, 因为他的子类一定会重写他,然后去找抽象类的引用,,会有多态性的体现

    4  面向对象复杂但是是为了方便解决问题 

    5  含有抽象方法的类必须定义为抽象类

    6 不能使用 abstract修饰属相或者局部变量

    7 抽象类中可以同时含有抽象方法和非抽象方法

    8 在抽象类里定义的抽象方法只有方法头没有方法体,但这个抽象方法如果被多个子类所调用的时候,各子类可以根据各自需要实例化出不同的对象 并且重新定义不同的方法体上去,从而通过它来实现多态

    9  抽象类可以有方法体 就是抽象工厂

    10  抽象类中定义抽象方法不能有方法体(未实现)

    11  demo 

    抽象类是在接口和实体类之间的一个桥梁
    例如
    做一个接口叫做飞行FlyAnimalAction,里面定义一个方法叫做flying,再定义一个方法叫做eat
    做一个类叫做蚊子实现接口,蚊子要实现flying方法,实现自己的eat方法
    做一个类叫做苍蝇实现接口,苍蝇也要实现flying方法,实现自己的eat方法
    你发现所有会飞的动物都要实现这个接口,很麻烦,不如
    做一个抽象类FlyAnimal,然后实现上面的接口
    在里面实现flying这个方法,因为大部分的飞行动作是一样的,而eat方法则继续写成抽象方法,因为大部分的动物吃东西是不一样的
    下面你再写蚊子类就简单了,可以直接继承这个抽象类,然后实现自己的吃方法就行了
    而且苍蝇类的制作也是一样,这个时候抽象类的功能就显示出来了,当然抽象类的功能远远不是这些,只是初期理解到这里就够了。

    展开全文
  • 一、抽象类 定义:在普通类的基础上扩充了一些抽象方法 。 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(){}
    }
    
    注意:对象实例化的核心步骤
      ①类加载
      ②类对象的空间开辟
      ③类对象中的属性初始化(构造方法)
    
    方法可以重写,属性不能重写。
    
    展开全文
  • 一、抽象类与抽象方法的定义 抽象类:只在普通类的基础上扩充了一些抽象...抽象类中包含抽象方法,抽象方法不包含方法体,即抽象类中没有具体实现,所以抽象类中不能直接产生实例化对象 举例:创建一个简单的抽象...
  • 首先我们知道,一个类如果是抽象类,我们就不能用这个类实例化一个对象。什么样的类是抽象类呢? C++没有C Sharp中的关键字abstract,但是当一个类中有一个或多个纯虚函数的时候,这个类就自动成为了抽象类,即不...
  • 抽象类定义与使用

    万次阅读 多人点赞 2019-04-03 14:38:22
    抽象类不能直接产生实例化对象,因为抽象类是“半成品”,无法直接使用。不能直接new **抽象方法:**使用abstract 关键字定义并且没有方法体的方法。抽象方法所在类一定是抽象类。 abstract class Person{ ...
  • 定义抽象类的作用是将一类对象的共同特点抽象出来,成为代表该类共同特性的抽象概念,其后在描述某一具体对象时,只要添加与其他子类对象的不同之处,而不需要重复类的共同特性。这样就使得程序概念层次分明,开发更...
  • java实例化一个抽象类对象

    千次阅读 2019-07-16 16:23:09
    不对啊,根据我的知识一个抽象类不能直接实例化一个对象出来,面向对象期末考试的卷子还有专门一道让你改错的题,一般抽象类直接实例化对象都是每年必考的错误点。那这个对象从哪实例化,国家分配的吗?先不管,结果...
  • 这就让我很郁闷了,自己定义类也并非抽象类,怎么还不能实例化对象了呢?抽象类:在C++中,当一个类中具有一个或多个纯虚函数的时候,这个类就是抽象类,不能进行实例化。 一般来说,具有纯虚函数的类,被称为抽象...
  • 抽象类的用法以及定义

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

    万次阅读 多人点赞 2018-08-25 19:24:40
    抽象类的基本概念 抽象方法,只声明而未实现的方法我们称为抽象方法,所有的抽象方法都需要用abstract关键字声明,包含抽象方法的类也需要使用abstract关键字声明,抽象类和普通类相比,区别在于抽象类带有抽象...
  • 关于C++抽象类建立对象的问题

    千次阅读 2017-02-04 10:18:06
    抽象类是无法建立对象、但可以定义指针、该指针可以指向它的派生类,进而实现多态性
  • Java抽象类不能创建对象

    万次阅读 2017-03-06 14:35:21
    人们使用抽象类和接口只是为了说明要干什么事,而让他们的实现类去根据自己的需要去实现这些方法,比如说抽象类定义一个eat()方法, 它并没有说这个方法具体怎么做,羊就可以吃草,虎就可以吃肉,羊和虎都实现了这...
  • java中抽象类的子类可以定义抽象类吗?比如我可以在在抽象子类中再扩展抽象方法
  • 用C#语言编写一段程序,满足以下要求: 1.定义抽象类Pet(宠物)类,作为基类。...4.定义包含主方法的类MainClass,通过抽象类对象调用派生类的覆写方法。 using System; using System.Collections.Generic; usin...
  • 接口和抽象类定义规则

    千次阅读 2010-05-24 23:24:00
    接口interface关键字用来声明一个接口,它可以产生一个完全抽象,并且不提供任何具体实现。一旦定义完,任何都可以实现接口,另外,可以实现任意数目的接口。一个要实现一个接口,必须创建由接口定义的...
  • 抽象类定义和使用

    千次阅读 2018-11-19 12:48:04
    抽象类与普通类的区别在于抽象类中包含了抽象方法。... 所有的抽象方法、抽象类都要使用abstract关键字来定义。 abstract class Person{  private String name;  public String getName(){  return this....
  • package Test5_1_zxj; import javax.swing.*; import java.awt.*;...Shape(形状)类是一个抽象类,包含4个数据成员(坐标x,y,颜色c,图形对象g(Graphics类对象)) // ,一个构造方法和两个抽象方法(求面积area...
  • python 如何定义抽象类和抽象方法

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

    千次阅读 2020-04-13 09:26:04
    如果一个类不与具体的食物相联系,而只表达一种抽象的概念,仅是作为其派生类的一个基类,这样的类就是派生类,在抽象类中,声明抽象类中声明抽象方法是,如果加上abstract关键字则为抽象方法。abstract 修饰符可...
  • Java抽象类 详解

    万次阅读 多人点赞 2016-10-05 00:06:35
    一、抽象类的基本概念普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。...
  • 接口可以继承接口。 抽象类并不能继承接口,但可以实现接口。 抽象类可以继承具体类...抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性和方法, 其中属性方.
  • 抽象类为什么不能创建对象

    千次阅读 2020-07-10 17:24:06
    在C++中,含有纯虚拟函数的类称为抽象类,它不能生成对象;在java中,含有抽象方法的类称为抽象类,同样不能生成对象抽象类是不完整的,它只能用作基类。在面向对象方法中,抽象类主要用来进行类型隐藏和充当...
  • C# 允许把类和函数声明为abstract。... 类是一个模板,那么抽象类就是一个不完整的模板,我们不能使用不完整的模板去构造对象。  当一个类出现抽象方法时,这个类也必须定义抽象类。  继承一个抽象类的时候 ,
  • Java笔试面试-抽象类与接口

    万次阅读 多人点赞 2019-09-15 22:29:50
      在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。简单来说,使用关键字 ...
  • JAVA面向对象抽象类和接口

    千次阅读 2015-12-25 16:19:44
    抽象类 接口 抽象类与接口比较前面为大家介绍了类的相关概念以及使用方式,在Java中有两种特殊的类,分别为抽象类和接口(本质上还是类),这一片博客就为大家介绍一下抽象类以及接口的使用。对这两种特殊的类进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 677,562
精华内容 271,024
关键字:

抽象类定义对象