育才学习网c中定义抽象类怎么写
1.C++中抽象类的定义
定义：
在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”。[cpp] view plaincopyprint?virtual void funtion1()=0
virtual void funtion1()=0。
2.c#中定义一个抽象类,里边有两个虚方法,虚函数,分别求周长和面
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication2
{
public abstract class Shape
{
// 面积
public abstract double Area();
// 周长
public abstract double Circumference();
}
public class Circle : Shape
{
private float radius;
public Circle(float radius)
{
this.radius = radius;
}
// 圆面积
public override double Area()
{
return Math.PI * radius * radius;
}
// 圆周长
public override double Circumference()
{
return Math.PI * 2 * radius;
}
}
class Program
{
static void Main(string[] args)
{
Circle c = new Circle(10);
Console.WriteLine（"面积为：{0}", c.Area());
Console.WriteLine（"周长为：{0}", c.Circumference());
}
}
}
3.用C++编写 抽象类的问题
#include<iostream>
using namespace std;
class shape
{
private:
double edge;
public:
virtual double area()=0;
void printArea（)//输出面积函数在基类中，由子类继承
{
cout<<this->area()<<endl;
}
};
class circle :public shape
{
private:
double radius；//半径
public:
circle(){}
circle(double r)
{
radius=r;
}
double area()
{
double s=3.14*radius*radius;
return s;
}
};
class rectangle:public shape
{
private:
double len,wid;
public:
rectangle(double l,double w)
{
len=l;
wid=w;
}
double area()
{
double s=len*wid;
return s;
}
};
class triangle:public shape
{
private:
double height,edge;
public:
triangle(double h,double e)
{
height=h;
edge=e;
}
double area()
{
double s=height*edge/2;
return s;
}
};
int main()
{
circle a(3.0);
rectangle b(3.0,4.0);
triangle c(4.0,3.0);
a.printArea（)；//圆形面积
b.printArea（)；//矩形面积
c.printArea（)；//三角形面积
return 0;
}
4.这个抽象类怎么写
设置名字和长度2个成员变量 然后在构造方法里用this关键字传值就可以了
public abstract class Ship {
//这2个是序列化用的
public static final int HORIZONTAL = 0;
public static final int VERTICAL = 1;
//设置2个成员变量
private String name;
private int length;
//这个是你定义的带参构造方法
public Ship(String name, int length) {
//this关键字传值
this.name=name;
this.length=length;
}
}//你这里少了一个括号
--------------------------------------------------------------------
你把这个类定为抽象类 我不知道你后面还有没有代码 也可能你有抽象方法没有放上来……如果没有的话不建议使用abstract 修饰该类 因为抽象类不能实例化
5.求一个c编程定义一个抽象类容器类,其中定义了若干纯虚函数,实现
#includeusing namespace std;const double pi=3。
14； //π的值double a=0； //表面积double v=0； //体积class Container{ //声明抽象类protected: double radius;public: Container(double r) //构造函数 {radius=r; } virtual double area()=0； //纯虚函数，求表面积 virtual double volume()=0； //纯虚函数，求体积 virtual void print()=0； //纯虚函数，输出相关信息}；class Cube:public Container{ //声明正方体的派生类public: Cube(double r):Container(r) {} double area（) //定义虚函数area { return a=6*radius*radius; } double volume（) //定义虚函数volume { return v=radius*radius*radius; } void print() { coutarea（)； //既然已经定义了print（)输出信息了，这就不用cout，直接在p->print即可输出信息，以下类同 p->volume(); p->print(); coutarea(); p->volume(); p->print(); coutarea(); p->volume(); p->print(); cout}分不好拿啊。
抽象类的子类要怎么写代码
1.java抽象类的创建及其子类的创建
public abstract class Fruit {
private String name;
private String color;
public Fruit(String name, String color) {
this.name = name;
this.color = color;
}
public abstract void pirntShape();
public void printInfo(){
System.out.println(name);
System.out.println(color);
}
}
public class Apple extends Fruit{
public Apple(String name, String color) {
super(name, color);
}
@Override
public void pirntShape() {
System.out.println("Apple");
}
}
public class Kiwi extends Fruit{
public Kiwi(String name, String color) {
super(name, color);
}
@Override
public void pirntShape() {
System.out.println("Kiwi");
}
}
2.子类调用 抽象类里的普通方法
抽象类不能被实例化，想调用里面的普通方法要通过继承，然后实例化子类调用抽象类的普通方法，下面有一段示例代码供你参考
定义一个抽象类 A
public abstract class A {
abstract int getSum(int a,int b)；//抽象方法
int getSum2(int b)
{
int b;
return b;
}；//普通方法
}
定义B类继承A类
public class B extends A {
int getSum(int a,int b) { //必须实现父类中的抽象方法的具体细节
int sum=a+b;
return sum;
}
public static void main(String a[]){ //主方法
System.out.println(new B().getSum2(90)）；//调用普通方法
System.out.println(new B().getSum(2,6)）；//调用抽象方法也相同
}
}
代码你不要复制，因为标点有中文状态下的可能会报错
希望能解决你的疑问，不过抽象类还有一个特例“接口”，接口要通过implements 关键字实现
3.java如何定义继承性抽象类并实现抽象类中抽象方法的子类,比如动
动物类：
public abstract class Animal{
抽象方法 吃：
public abstract void eat();
}
狗类：
class Dog extends Animal{
完成父类的抽象方法 吃（狗）：
public void eat(){
system.out.println("dog is eating。");
}
}
4.求JAVA代码~~~~~~~~~~：编写一个应用抽象类的程序
public class text_1 {
/**
*
* @param args
* @author lovefang
* @功能：介绍类
* @时间：2011/5/8
*/
public static void main(String[] args){
Compute compute=new Compute();
Camera camera1=new Camera();
Phone phone1=new Phone();
compute.useUsb(camera1);
compute.useUsb(phone1);
}
}
//接口
//定义Usb接口，抽象类
interface Usb{
int a=1;
//声明两个方法，state表示开始工作，stop表示停止工作
public void start();
public void stop();
}
//编写相机类，相机实现usb接口
//一个重要的原则：当一个类实现了一个接口，则要求该类把这个接口中的方法全部实现
class Camera implements Usb{
public void start(){
System.out.println（"我是相机，开始工作了"）；
}
public void stop(){
System.out.println（"我是相机，不工作了"）；
}
}
//编写手机类，手机实现usb接口
class Phone implements Usb{
public void start(){
System.out.println（"我是手机，开始工作了"）；
}
public void stop(){
System.out.println（"我是手机，不工作了"）；
}
}
//接口继承别的接口
interface Tt{
}
interface Tt1 extends Tt{
}
//计算机类
class Compute{
public void useUsb(Usb usb){
// 开始使用Usb
usb.start();
usb.stop();
}
}
c抽象类怎么写
1. 这个抽象类怎么写
设置名字和长度2个成员变量 然后在构造方法里用this关键字传值就可以了
public abstract class Ship {
//这2个是序列化用的
public static final int HORIZONTAL = 0;
public static final int VERTICAL = 1;
//设置2个成员变量
private String name;
private int length;
//这个是你定义的带参构造方法
public Ship(String name, int length) {
//this关键字传值
this.name=name;
this.length=length;
}
}//你这里少了一个括号
--------------------------------------------------------------------
你把这个类定为抽象类 我不知道你后面还有没有代码 也可能你有抽象方法没有放上来……如果没有的话不建议使用abstract 修饰该类 因为抽象类不能实例化
2. 用C++编写 抽象类的问题
#include 哥哥你发错地方了=。 =发到java去~ 以下来自百度百科： 抽象类与接口紧密相关，它们不能实例化，并且常常部分实现或根本不实现。抽象类和接口之间的一个主要差别是：类可以实现无限个接口，但仅能从一个抽象（或任何其他类型）类继承。 从抽象类派生的类仍可实现接口。可以在创建组件时使用抽象类，因为它们使您得以在某些方法中指定不变级功能，但直到需要该类的特定实现之后才实现其他方法。 抽象类也制定版本，因为如果在派生类中需要附加功能，则可以将其添加到基类而不中断代码。 在实现抽象类时，必须实现该类中的每一个抽象方法，而每个已实现的方法必须和抽象类中指定的方法一样，接收相同数目和类型的参数，具有同样的返回值。 抽象类不能被实例化，也就是不能用new关键字去产生对象 抽象方法只需声明，而不需实现 抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类. 以下来自：/z/q727512424.htm?si=1&wtp=wk 理解抽象类 abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？ 在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。 正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。 在面向对象领域，抽象类主要用来进行类型隐藏。 我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。 模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。 熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。 从语法定义层面看abstract class和interface 在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。 使用abstract class的方式定义Demo抽象类的方式如下： abstract class Demo { abstract void method1(); abstract void method2（)； … } 使用interface的方式定义Demo抽象类的方式如下： interface Demo { void method1(); void method2（)； … } 在abstract class方式中，Demo可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。 从编程的角度来看，abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。 首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。 也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。 其次，在abstract class的定义中，我们可以赋予方法的默认行为。 但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会 增加一些复杂性，有时会造成很大的麻烦。 在抽象类中不能定义默认行为还存在另一个比较严重的问题，那就是可能会造成维护上的麻烦。 因为如果后来想修改类的界面（一般通过abstract class或者interface来表示）以适应新的情况（比如，添加新的方法或者给已用的方法中添加新的参数）时，就会非常的麻烦，可能要花费很多的时间（对于派生类很多的情况，尤为如此）。但是如果界面是通过abstract class来实现的，那么可能就只需要修改定义在abstract class中的默认行为就可以了。 同样，如果不能在抽象类中定义默认行为，就会导致同样的方法实现出现在该抽象类的每一个派生类中，违反了"one rule,one place"原则，造成代码重复，同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。 从设计理念层面看abstract class和interface 上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层。 抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。 通常在编程语句中用 abstract 修饰的类是抽象类。在C++中，含有纯虚拟函数的类称为抽象类，它不能生成对象；在java中，含有抽象方法的类称为抽象类，同样不能生成对象。 抽象类是不完整的，它只能用作基类。在面向对象方法中，抽象类主要用来进行类型隐藏和充当全局变量的角色。 只要把这些东西对应到生活中的概念就明白面向对象的设计本身来源于生活，我们对事物的理解本身都是一样的哲学，理解概念之后怎么写代码就更容易掌握。抽象类是表示部分地实现功能，比如把某些已经确定的功能实现了，而抽象的功能则表示未实现，因为不能确定子类用什么方式实现它或者说把可能性和机会留给子类，比如对于宠物这个抽象类"睡觉“这个方法就是抽象的，因为子类的实现方法各有差异，狗经常待在墙边阴凉处睡觉，而猫则爬到树上睡觉，我们父类中不能把这个”个性“的东西放入”共性“的父类中，“共性”是它们都会睡觉，但具体怎么睡觉则是”个性“，因此只能把它弄成抽象的，把机会留给子类来实现它。 抽象类和抽象方法的目的是相同的。当子类实现这些抽象方法后就是叫”实现“，如果这个方法在父类中已经实现了不是抽象的而子类再来实现一次就是“覆盖”或“重写“了父类的方法，这2个都叫实现了”多态“特性。 “多态”就是某个“共性”在各个子类中表现出不同的“个性”，但都同时保留着“共性”。Pet[] pets = new Pet[] { new Dog(), new Cat()};for(int i = 0;i < pets.length; i++) { pets[i].doSleep（)； // 这时每个个体的”个性“表现出现了，就是”多态“。 程序是在用它们声明的”共性“ doSleep 来调用这个方法的。这里面就是用"实现”/”覆盖“/"改写”父类方法达到的。 覆盖了的方法在调用时会找对应的子类的方法而不是直接用父类提供的，在这里猫会按猫的习惯睡觉，狗会按狗的习惯睡觉。}。 1抽象类 （1） 抽象方法只作声明，而不包含实现，可以看成是没有实现体的虚方法 （2） 抽象类不能被实例化 （3） 抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类 （4） 具体派生类必须覆盖基类的抽象方法 （5） 抽象派生类可以覆盖基类的抽象方法，也可以不覆盖。 如果不覆盖，则其具体派生类必须覆盖它们。如：using System;public abstract class A //抽象类A { private int num=0; public int Num //抽象类包含属性 { get { return num; } set { num = value; } } public virtual int getNum（) //抽象类包含虚方法 { return num; } public void setNum(int n) // //抽象类包含普通方法 { this.num = n; } public abstract void E（)； //类A中的抽象方法E }public abstract class B : A //由于类B继承了类A中的抽象方法E，所以类B也变成了抽象类 { }public class C : B { public override void E（) //重写从类A继承的抽象方法。 如果类B自己还定义了抽象方法，也必须重写 { //throw new Exception("The method or operation is not implemented."); } }public class Test { static void Main() { C c = new C(); c.E（)； } }二、接 口 （1） 接口不能被实例化 （2） 接口只能包含方法声明 （3） 接口的成员包括方法、属性、索引器、事件 （4） 接口中不能包含常量、字段（域）、构造函数、析构函数、静态成员。如：public delegate void EventHandler(object sender, Event e);public interface ITest { //int x = 0; int A { get; set; } void Test(); event EventHandler Event; int this[int index] { get; set; } }(5) 接口中的所有成员默认为public，因此接口中不能有private修饰符 （6） 派生类必须实现接口的所有成员 （7） 一个类可以直接实现多个接口，接口之间用逗号隔开 （8） 一个接口可以有多个父接口，实现该接口的类必须实现所有父接口中的所有成员三、抽象类和接口 相同点： （1） 都可以被继承 （2） 都不能被实例化 （3） 都可以包含方法声明 （4） 派生类必须实现未实现的方法 区 别： （1） 抽象基类可以定义字段、属性、方法实现。 接口只能定义属性、索引器、事件、和方法声明，不能包含字段。 （2） 抽象类是一个不完整的类，需要进一步细化，而接口是一个行为规范。 微软的自定义接口总是后带able字段，证明其是表述一类“我能做。 ” （3） 接口可以被多重实现，抽象类只能被单一继承 （4） 抽象类更多的是定义在一系列紧密相关的类间，而接口大多数是关系疏松但都实现某一功能的类中 （5） 抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定， 因此反映的是事物的外部特性 （6） 接口基本上不具备继承的任何具体特点，它仅仅承诺了能够调用的方法 （7） 接口可以用于支持回调，而继承并不具备这个特点 （8） 抽象类实现的具体方法默认为虚的，但实现接口的类中的接口方法却默认为非虚的，当然您也可以声明为虚的 （9） 如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法。 using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication2 { public abstract class Shape { // 面积 public abstract double Area(); // 周长 public abstract double Circumference(); } public class Circle : Shape { private float radius; public Circle(float radius) { this.radius = radius; } // 圆面积 public override double Area() { return Math.PI * radius * radius; } // 圆周长 public override double Circumference() { return Math.PI * 2 * radius; } } class Program { static void Main(string[] args) { Circle c = new Circle(10); Console.WriteLine（"面积为：{0}", c.Area()); Console.WriteLine（"周长为：{0}", c.Circumference()); } } } 1抽象类 （1） 抽象方法只作声明，而不包含实现，可以看成是没有实现体的虚方法 （2） 抽象类不能被实例化 （3） 抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类 （4） 具体派生类必须覆盖基类的抽象方法 （5） 抽象派生类可以覆盖基类的抽象方法，也可以不覆盖。 如果不覆盖，则其具体派生类必须覆盖它们。如：using System;public abstract class A //抽象类A { private int num=0; public int Num //抽象类包含属性 { get { return num; } set { num = value; } } public virtual int getNum（) //抽象类包含虚方法 { return num; } public void setNum(int n) // //抽象类包含普通方法 { this.num = n; } public abstract void E（)； //类A中的抽象方法E }public abstract class B : A //由于类B继承了类A中的抽象方法E，所以类B也变成了抽象类 { }public class C : B { public override void E（) //重写从类A继承的抽象方法。 如果类B自己还定义了抽象方法，也必须重写 { //throw new Exception("The method or operation is not implemented."); } }public class Test { static void Main() { C c = new C(); c.E（)； } }二、接 口 （1） 接口不能被实例化 （2） 接口只能包含方法声明 （3） 接口的成员包括方法、属性、索引器、事件 （4） 接口中不能包含常量、字段（域）、构造函数、析构函数、静态成员。如：public delegate void EventHandler(object sender, Event e);public interface ITest { //int x = 0; int A { get; set; } void Test(); event EventHandler Event; int this[int index] { get; set; } }(5) 接口中的所有成员默认为public，因此接口中不能有private修饰符 （6） 派生类必须实现接口的所有成员 （7） 一个类可以直接实现多个接口，接口之间用逗号隔开 （8） 一个接口可以有多个父接口，实现该接口的类必须实现所有父接口中的所有成员三、抽象类和接口 相同点： （1） 都可以被继承 （2） 都不能被实例化 （3） 都可以包含方法声明 （4） 派生类必须实现未实现的方法 区 别： （1） 抽象基类可以定义字段、属性、方法实现。 接口只能定义属性、索引器、事件、和方法声明，不能包含字段。 （2） 抽象类是一个不完整的类，需要进一步细化，而接口是一个行为规范。 微软的自定义接口总是后带able字段，证明其是表述一类“我能做。 ” （3） 接口可以被多重实现，抽象类只能被单一继承 （4） 抽象类更多的是定义在一系列紧密相关的类间，而接口大多数是关系疏松但都实现某一功能的类中 （5） 抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外部调用而定义的一个功能约定， 因此反映的是事物的外部特性 （6） 接口基本上不具备继承的任何具体特点，它仅仅承诺了能够调用的方法 （7） 接口可以用于支持回调，而继承并不具备这个特点 （8） 抽象类实现的具体方法默认为虚的，但实现接口的类中的接口方法却默认为非虚的，当然您也可以声明为虚的 （9） 如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法。 没看懂C的意思 ，如果A说的没有方法是指没有方法体 则选A 如果不是选C 凡是包含纯虚函数的类都是抽象类。 抽象类是不完整的，并且它只能用作基类。它与非抽象类的不同： 1、抽象类不能直接实例化，并且对抽象类使用 new 运算符是编译时错误。虽然一些变量和值在编译时的类型可以是抽象的，但是这样的变量和值必须或者为 null，或者含有对非抽象类的实例的引用（此非抽象类是从抽象类派生的）。 2、允许（但不要求）抽象类包含抽象成员。 3、抽象类不能被密封。 当从抽象类派生非抽象类时，这些非抽象类必须具体实现所继承的所有抽象成员，从而重写那些抽象成员。在下边的示例中： 设置名字和长度2个成员变量 然后在构造方法里用this关键字传值就可以了 public abstract class Ship { //这2个是序列化用的 public static final int HORIZONTAL = 0; public static final int VERTICAL = 1; //设置2个成员变量 private String name; private int length; //这个是你定义的带参构造方法 public Ship(String name, int length) { //this关键字传值 this.name=name; this.length=length; } }//你这里少了一个括号 -------------------------------------------------------------------- 你把这个类定为抽象类 我不知道你后面还有没有代码 也可能你有抽象方法没有放上来……如果没有的话不建议使用abstract 修饰该类 因为抽象类不能实例化 哥哥你发错地方了=。 =发到java去~ 以下来自百度百科： 抽象类与接口紧密相关，它们不能实例化，并且常常部分实现或根本不实现。抽象类和接口之间的一个主要差别是：类可以实现无限个接口，但仅能从一个抽象（或任何其他类型）类继承。 从抽象类派生的类仍可实现接口。可以在创建组件时使用抽象类，因为它们使您得以在某些方法中指定不变级功能，但直到需要该类的特定实现之后才实现其他方法。 抽象类也制定版本，因为如果在派生类中需要附加功能，则可以将其添加到基类而不中断代码。 在实现抽象类时，必须实现该类中的每一个抽象方法，而每个已实现的方法必须和抽象类中指定的方法一样，接收相同数目和类型的参数，具有同样的返回值。 抽象类不能被实例化，也就是不能用new关键字去产生对象 抽象方法只需声明，而不需实现 抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类. 以下来自：/z/q727512424.htm?si=1&wtp=wk 理解抽象类 abstract class和interface在Java语言中都是用来进行抽象类（本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分）定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？ 在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。 正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。 在面向对象领域，抽象类主要用来进行类型隐藏。 我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。 模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体，因此它可以是不允许修改的；同时，通过从这个抽象体派生，也可扩展此模块的行为功能。 熟悉OCP的读者一定知道，为了能够实现面向对象设计的一个最核心的原则OCP(Open-Closed Principle)，抽象类是其中的关键所在。 从语法定义层面看abstract class和interface 在语法层面，Java语言对于abstract class和interface给出了不同的定义方式，下面以定义一个名为Demo的抽象类为例来说明这种不同。 使用abstract class的方式定义Demo抽象类的方式如下： abstract class Demo { abstract void method1(); abstract void method2（)； … } 使用interface的方式定义Demo抽象类的方式如下： interface Demo { void method1(); void method2（)； … } 在abstract class方式中，Demo可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface方式的实现中，Demo只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在interface中一般不定义数据成员），所有的成员方法都是abstract的。从某种意义上说，interface是一种特殊形式的abstract class。 从编程的角度来看，abstract class和interface都可以用来实现"design by contract"的思想。但是在具体的使用上面还是有一些区别的。 首先，abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。 也许，这是Java语言的设计者在考虑Java对于多重继承的支持方面的一种折中考虑吧。 其次，在abstract class的定义中，我们可以赋予方法的默认行为。 但是在interface的定义中，方法却不能拥有默认行为，为了绕过这个限制，必须使用委托，但是这会 增加一些复杂性，有时会造成很大的麻烦。 在抽象类中不能定义默认行为还存在另一个比较严重的问题，那就是可能会造成维护上的麻烦。 因为如果后来想修改类的界面（一般通过abstract class或者interface来表示）以适应新的情况（比如，添加新的方法或者给已用的方法中添加新的参数）时，就会非常的麻烦，可能要花费很多的时间（对于派生类很多的情况，尤为如此）。但是如果界面是通过abstract class来实现的，那么可能就只需要修改定义在abstract class中的默认行为就可以了。 同样，如果不能在抽象类中定义默认行为，就会导致同样的方法实现出现在该抽象类的每一个派生类中，违反了"one rule,one place"原则，造成代码重复，同样不利于以后的维护。因此，在abstract class和interface间进行选择时要非常的小心。 从设计理念层面看abstract class和interface 上面主要从语法定义和编程的角度论述了abstract class和interface的区别，这些层。 abstract（抽象）修饰符，可以修饰类和方法 1,abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。 2,abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以"；"代替。需要子类继承实现（覆盖）。 注意：有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。 abstract修饰符在修饰类时必须放在类名前。 abstract修饰方法就是要求其子类覆盖（实现）这个方法。调用时可以以多态方式调用子类覆盖（实现）后的方法，也就是说抽象方法必须在其子类中实现，除非子类本身也是抽象类。 注意：父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（抽象类）的构造方法。 举个简单的例子下面有一个抽象类 abstract class E{ public abstract void show();//public abstract 可以省略 } 然后其它类如果继承它通常为了实现它里面的方法 class F extends E{ void show(){ //写具体实现的代码 } } 最后再主方法里面定义一个父类引用指向子类对象，就会发生多态现象，比如 E e=new F(); e.show(); 实际调用了子类里面的show（)方法 这是从网上粘贴的，不知道符不符合你的意思 class Animal{ private: float weight; int age; float length; public: void setWeight(float w){ weight=w; } void setAge(int a){ age=a; } void setLength(float l){ length=l; } float getWeight(){ return weight; } int getAge(){ return age; } float getLength(){ return length; } void speak()=0; }; class Dog: public Animal{ public: Dog(){} void speak(){ cout << "wang wang。." << endl; } }; class Cat:public Animal{ public: Cat(){} void speak(){ cout << "miao miao。." << endl; } }; int main(){ /* 这里就不写了，苦力劳动 主要就是分别创建Dog和Cat类，用set方法设置每个属性， 然后用get方法得到每个属性 用speak方法输出不通动物的叫声 */ return 0; } class Animal{ private: float weight; int age; float length; public: void setWeight(float w){ weight=w; } void setAge(int a){ age=a; } void setLength(float l){ length=l; } float getWeight(){ return weight; } int getAge(){ return age; } float getLength(){ return length; } void speak()=0; }; class Dog: public Animal{ public: Dog(){} void speak(){ cout << "wang wang。." << endl; } }; class Cat:public Animal{ public: Cat(){} void speak(){ cout << "miao miao。." << endl; } }; int main(){ /* 这里就不写了，苦力劳动 主要就是分别创建Dog和Cat类，用set方法设置每个属性， 然后用get方法得到每个属性 用speak方法输出不通动物的叫声 */ return 0; } 转载请注明出处育才学习网 » 抽象类怎么写单元测试3. 什么是抽象类,为什么要写抽象类
4. c++中抽象类到底有什么用处
5. c抽象类和接口的区别
6. c#中定义一个抽象类,里边有两个虚方法,虚函数,分别求周长和面
7. c抽象类和接口的区别
8. 什么是抽象类
抽象类怎么写
1. 这个抽象类怎么写
2. 什么是抽象类,为什么要写抽象类
3. abstract怎么写
4. 编写一个抽象类
5. 编写一个抽象类