抽象类中是否都是抽象方法

正确答案 C

abstract class Shape{
x09abstract double area();
}

class Circle extends Shape {
x09private double r;
x09private final double PI=3.14;

x09public Circle(double r) {
x09x09this.r = r;
x09}

x09@Override
x09double area() {
x09x09return PI*r*r;
x09}
}

class Rectangle extends Shape {
x09private double w;
x09private double h;

x09public Rectangle(double w, double h) {
x09x09this.w = w;
x09x09this.h = h;
x09}

x09@Override
x09double area() {
x09x09return w * h;
x09}
}

class Triangle extends Shape {
x09private double h;
x09private double l;

x09public Triangle(double h, double l) {
x09x09this.h = h;
x09x09this.l = l;
x09}

x09@Override
x09double area() {
x09x09return 0.5 * h * l;
x09}
}

class Square extends Rectangle {
x09public Square(double l) {
x09x09super(l, l);
x09}
}

public class Test {
x09public static void main(String[] args) {
x09x09System.out.println("圆 "+new Circle(1).area());
x09x09System.out.println("矩形 "+new Rectangle(4,2).area());
x09x09System.out.println("正方形 "+new Square(3).area());
x09x09System.out.println("三角形 "+new Triangle(3,4).area());
x09}
}

A

C抽象类是可以实例化的,接口不可以

定义成抽象类是为了以后要其子类来继承的,因为父类里有很多方法是无法定义具体的实现的,只能定义一个原型,让子类来分别实现!所以要定义成抽象的!

class Sharp{
public virtual Sun(){
}
}
class Sharp_Par1:Sharp{
public Point P1,P2,P2;
public overides Sun(){
}
}

1.interface Shape
{
public abstract double area();
public abstract double perimeter();
public abstract double display();
}
2.class Circle implements Shape
{
int x;//横坐标
int y;//纵坐标
x09double a;//半径
x09public Circle (int x,int y,double a)//构造函数
x09{
this.x=x;
this.y=y;
x09x09this.a=a;
x09}
x09public double area()
x09{
x09x09return 3.14*a*a;
x09}
public double perimeter()
x09{
x09x09return 2*3.14*a;
x09}
public void display()
x09{
x09 System.Out.println("此圆的圆心为a("+this.x+","+this.y+")");
System.Out.println("此圆的半径为r="+this.a);
x09}
}
3.4.就不写了,与圆类似,就多了个drow()函数,你可以去找找这个函数的实现
5.public static void main(String[]args)throws IOException
{
Circle C=new Circle(2,3,5);
System.out.println("所求圆的面积S="+C.area());
System.out.println("所求圆的周长L="+C.perimeter());
C.display();
//其他的测试一样
}

B和C都正确.
非抽象类C当然可以实例自己的对象,故C正确.
抽象父类B的对象x1也可以由非抽象的子类C来实例化,故B也正确.这种用法通常用于实现动态多态.

这题目出的不严谨，不过实在没办法，选D吧，因为ABC一定是对的，D其实也不算错。接口里面可以定义变量，但是这个变量必须初始化，而一旦初始化，这个变量会默认加上final修饰，它的值就永远不会再变了，这其实符合常量的定义~~就是说它已经是一个常量

作者：广州智康1对1涂江艳老师 有一类作文题,在小升初（华附就考过这一类的作文）至初中都可能遇到,就是抽象类或诗意化的题目.以下是从本人讲义中摘取的部分内容.虽然所讲文题只是《痕迹》,但是很有代表性.其中融入了本人深思考后总结的方法.如何写《痕迹》 1、审题 审题,说白了,就是弄清题目的基本意思. 所给题目是一个名词.多数人看到“痕迹”这个词,会觉得它很抽象.中考时,也曾考过类似的作文题,如《又见枝头吐新绿》——虽然这篇文章所给标题不是一个名词,而是一个句子.这样的题目,要比一般的记叙文难写.一般的记叙文,就是我们从前写过的叙事类文章.把事情的来龙去脉说清楚,我们写得比较多,相对更为擅长. 那么碰到“抽象”类的词,我们怎么办? 第一步,这是很关键的一步.要弄清楚,“抽象”到底是怎么一回事. 抽象,抽象是从众多的事物中抽取出共同的、本质性的特征,而舍弃其非本质的特征.例如苹果、香蕉、生梨、葡萄、桃子等,它们共同的特性就是水果.得出水果概念的过程,就是一个抽象的过程.要抽象,就必须进行比较,没有比较就无法找到在本质上共同的部分. 共同特征是指那些能把一类事物与他类事物区分开来的特征,这些具有区分作用的特征又称本质特征.因此抽取事物的共同特征就是抽取事物的本质特征,舍弃非本质的特征.所以抽象的过程也是一个裁剪的过程.在抽象时,同与不同,决定于从什么角度上来抽象.抽象的角度取决于分析问题的目的. 为什么特意说“抽象”的概念? 第一是为了让大家更好地明白,抽象的作文题为什么难写.因为抽象是提取过的,它本身就是一个“本质化”或升华过的东西. 第二,在这个概念的基础上,我要给大家加一个概念：抽象和具体是相对的,不是绝对的.譬如,前边说“水果”是对“苹果、香蕉、梨子、桃子”等的抽象.那么,我们可以以此类推,“苹果”是对“红苹果、青苹果、黄苹果”的抽象.从这里可以看到, 具体的东西,在某种前提下,又成了抽象.为什么要说这点呢?就是告诉大家,其实很多名词是既具体（或形象）又抽象的.我们传统的对抽象的定义,某种程度上 束缚了我们的思维.“痕迹”也是既具体又抽象的.怎么认识到这点的呢?想想跟“痕迹”有关的词语就知道,打个比方说,别人重重地打了你一巴掌,那巴掌印还 是鲜活的呢.这“巴掌印”算痕迹吧；踩在沙滩上或泥土上面,留下的印记无疑也算“痕迹”；朱自清《匆匆》里边说,“在逃去如飞的日子里,在千门万户的世界 里的我能做些什么呢?只有徘徊罢了,只有匆匆罢了；在八千多日的匆匆里,除徘徊外,又剩些什么呢?过去的日子如轻烟,被微风吹散了,如薄雾,被初阳蒸融 了；我留着些什么痕迹呢?我何曾留着像游丝样的痕迹呢?我赤裸裸来到这世界,转眼间也将赤裸裸的回去罢?但不能平的,为什么偏要白白走这一遭啊?”这里边提到的“痕迹”是种看不见摸不着的经历或存在,所谓岁月的“痕迹”,成长的“痕迹”,都是如此.但也不尽是看不见摸不着的.我们的照片里就可以看到岁月的 “痕迹”、成长的“痕迹”.为什么要详析这点呢?就是想告诉你,面对多数“痕迹”类的文章,我们要把握它的两面性.认识到具体面,才不至于无从说起；认识到抽象面,文章才可能有深度. 第三,“抽象的角度取决于分析问题的目的”.那么,我们要思考,如果把“痕迹”当作一个抽象名词看,那抽象出“痕迹”来是为了什么呢?对,它是一种本质特征的描述.那对于我们写作者而言,我们为什么要关注这种“痕迹”呢?它有什么意义呢?也就是说,对于“痕迹”类题,都要深思它的象征意义. 第四,还要在此基础上附加一个概念：抽象与具体是相互依存的关系.也就是说,没有“苹果、香蕉”等,我们何从谈“水果”呢?同样,由“水果”,我们可以逆推出很多有类似性质的具体的水果.从具体推导抽象,从抽象逆推具体,双向思维,便于发掘新素材,或者使立意新颖. 2、立意 审题与立意常常被放在一起说.我把它分开,主要为了更清晰地呈现思维过程,也为了使我们的思维过程显得更为缜密.审题,“审视题目”,旨在弄清题目的意思.只有弄清题目本身的含义,才可能更好地“立意”. 1）审题时讲过,“抽象”是相对的,实质一般情况下,一个词语往往既抽象又形象. 在兼有这二个特点的情况下,我们可以分头立意.当我们把“痕迹”当作一个具体化的名词对待时,我们容易想到的,便是我们看得见、摸得着的一些印记,最平常的如留下的手印、脚印；再如“疤痕”,“伤痕”等,也都算痕迹.一抹痕迹背后就有一个故事,写故事总不是难事,选择你熟悉的来写.再由抽象的“痕迹”提示,像成长的“痕迹”与岁月的“痕迹”一样,这种“痕迹”的共性就是一种经历的见证,一种过去存在而留存至今的形式或面貌.那么由此逆推,类似的“痕迹”的见证物是什么呢?譬如,“书”是历史的痕迹 （具体什么书书写怎样的历史,有很多内容可写）；“诗歌”是诗人的痕迹（具体什么诗,是哪个诗人的什么痕迹,可写的内容很多）；“照片”是生活的痕迹（每 一张照片后封存了怎样的生活,又可写很多东西）；“文字”是生命的痕迹.（你用怎样的文字,书写过怎样的时光,怎样的生命……）原来,每一样事物身上都留下过痕迹,甚至,每一样事物本身就是一种动态的痕迹.而且,这种痕迹可能有很厚重的文化或社会意义.想到这,文章容易深刻起来. 2） 审题时,讲到“痕迹”有明显的抽象性.这点我们是由“岁月的痕迹”这类短语想到.这提示我们,任何一种立意,都应由我们想到的相关的具体事物出发,而不是 从抽象概念本身出发.这是打开思维的法宝.那么,我们为什么要写“岁月的痕迹”中的这种痕迹呢?已经说了,它是一种存在,我们活着也是一种存在.但活着的 人也终将成为无,成为空,只有“痕迹”可以见证我们存在的价值或意义.如果说,前面具体的“痕迹”可以体现很多具体的感受,那么这里的抽象的存在就可囊括 以上所有具体感受.这就是所谓抽象与具体的依存关系. 综合以上两种立意法,如果说前者是从具体到抽象；那么后一种就是从抽象到更抽象了. 3、快速构思成文技巧. 通过几个词语快速找到思想的通道. When 什么时候的痕迹.围绕某个时候的痕迹来写. What 什么是痕迹.可参考以上提到的具体的痕迹. Where 在哪里留下的痕迹.如果是太空,那就可写人类探索的痕迹.有新意,有难度. Why 为什么留下痕迹.痕迹后的故事,你重点说说. How 怎么办?怎么对待痕迹?或者有什么意义.可参考以上所提抽象类的“痕迹”的写法. 这几个词很容易记.它便于我们快速组织材料.围绕这几个词去取材、选材,可能会遇到思路交叉的情况.自己综合考虑,找到有利于自己发挥的点来写.同时也要注意选择自己熟悉的、能驾驭的题材来写.

1) BC
2) BC
3) ABD
4) AB

C
如果在派生类中没有对纯虚函数进行了定义,那这个派生类也是抽象类.不能用来定义对象

同一个问题,已答：

class Trapezoid :public Shape
{
private:
x05double top;
x05double bottom;
x05double height;
public:
x05Trapezoid(double t,double b,double h)
x05{
x05x05top = t;
x05x05bottom = b;
x05x05height = h;
x05}
x05double Area()
x05{
x05x05return (top + bottom) * height / 2;
x05}
};
#define PI 3.1415926
class Circle :public Shape
{
private:
x05double r;
public:
x05Circle(double r)
x05{
x05x05this->r = r;
x05}
x05double Area()
x05{
x05x05return PI * r * r;
x05}
};
class Triangle :public Shape
{
private:
x05double bottom;
x05double height;
public:
x05Triangle(double b,double h)
x05{
x05x05bottom = b;
x05x05height = h;
x05}
x05double Area()
x05{
x05x05return bottom * height / 2;
x05}
};

a

public class Cube extends Square implements Volume{
@Override
public double getArea() {
return 6 * width * width;
}
@Override
public double getVolume() {
return width * width * width;
}
public void show() {
System.out.println("长方体的长度=宽度=高度=" + width + ",表面积=" + getArea() + ",体积=" + getVolume());
}

public static void main(String[] args) {
Cube cube = new Cube();
cube.width = 3;
cube.show();
}
}
运行结果如下：
长方体的长度=宽度=高度=3.0,表面积=54.0,体积=27.0

简单工厂模式?
我之前做了个简易计算器的简单工厂模式,效果与你这个是一样的~~~~
你的抽象类Shape里面的方法area（）和perimeter（）,可以参考的计算器的GetResult()
都是虚方法（使用virtual 关键字）,然后在计算面积、周长的子类中分别重写（override关键字）就是了~~~~~~~~~

具体的你看我的 简易计算器工程模式 代码：
C# 简单工厂之简易计算器
总共三个类：Operation.cs OperationFactory.cs Program.cs
Operation.cs 两个操作数,一个运算的虚方法GetResult(),该方法得出运算结果
加减乘除 四个运算类,每个类继承于Operation.cs,每个类都有一个GetResult()方法
,子类的GetResult()用于实现具体的加减乘除运算~~~~~~~~
OperationFactory.cs 实例化 加减乘除 四个运算类~~~~~
Program.cs 里面是main（）调用运算类~~~~~
Operation.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace FactoryPattern
{
///
/// 运算类
///
public class Operation
{
#region 运算类,包含两个操作数,一个虚的运算方法
private double _numberA = 0;
///
/// 操作数A
///
public double NumberA
{
get { return _numberA; }
set { _numberA = value; }
}
private double _numberB = 0;
///
/// 操作数B
///
public double NumberB
{
get { return _numberB; }
set { _numberB = value; }
}
#region 虚方法,得到运算结果
public virtual double GetResult()
{
double result = 0;
return result;
}
#endregion
#endregion
}
///
/// 加法类:继承于运算类
///
public class OperationAdd : Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA + NumberB;
return result;
}
}
///
/// 减法类:继承于运算类
///
public class OperationSub : Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA - NumberB;
return result;
}
}
///
/// 乘法类:继承于运算类
///
public class OperationMul : Operation
{
public override double GetResult()
{
double result = 0;
result = NumberA * NumberB;
return result;
}
}
///
/// 除法类:继承于运算类
///
public class OperationDiv : Operation
{
public override double GetResult()
{
double result = 0;
if (NumberB==0)
{
throw new Exception("除数不能为零!");

}
else
{
result = NumberA / NumberB;
return result;
}

}
}
#region 简单工厂模式结论
/* 若要实现复杂的运算,比如开根号、自然对数、求正余弦等等,
* 只需要：
* （1）增加相应的运算子类
* （2）在工厂的switch子句中添加相应复杂运算的分支
* 就OK了
*/
#endregion
}
OperationFactory.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace FactoryPattern
{
public class OperationFactory
{
///
/// 根据相应的运算符号,工厂就实例化出合适的运算对象
///
/// 加减乘除等运算符号
///
public static Operation createOperation(string operationType)
{
Operation operation = null;
//分别实例化具体的 加减乘除 运算类~~~~~~~~~
switch (operationType)
{
case "+":
operation = new OperationAdd();
break;
case "-":
operation = new OperationSub();
break;
case "*":
operation = new OperationMul();
break;
case "/" :
operation = new OperationDiv();
break;
default:
operation = new Operation();
break;
}
return operation;
}
}
}
Program.cs
调用~~~~~
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace FactoryPattern
{
class Program
{
static void Main(string[] args)
{
double result = 0;
string operationType = "+";
Operation oper = null;
// 【传入运算符,工厂实例化创造一个相应的运算对象】
oper = OperationFactory.createOperation(operationType);
oper.NumberA = 1;
oper.NumberB = 5;
// 【经过多态,返回父类的方式,实现计算结果】
result = oper.GetResult();
Console.WriteLine(result);
operationType = "-";
oper = OperationFactory.createOperation(operationType);
oper.NumberA = 1;
oper.NumberB = 5;
result = oper.GetResult();
Console.WriteLine(result);
operationType = "*";
oper = OperationFactory.createOperation(operationType);
oper.NumberA = 1;
oper.NumberB = 5;
result = oper.GetResult();
Console.WriteLine(result);
operationType = "/";
oper = OperationFactory.createOperation(operationType);
oper.NumberA = 1;
oper.NumberB = 5;
result = oper.GetResult();
Console.WriteLine(result);
Console.ReadKey();
}
}
}

分析：依题意,抽象出一个公共基类CContaineer为抽象类,在其中定义求表面积和体积的虚函数（该抽象类本身没有表面积和体积可言）.抽象类中定义一个公共的数据成员radius,此数据可作为球体的半径、正方形的边长、圆柱体底面积圆半径.由此抽象类派生出要描述的三个类,在这三个类中都具有求表面积和体积的重定义版本.
源程序如下：
#include
class CCt //定义抽象类CContaineer
{protected:
float radius; //公共的数据成员radius
double area,volume; //表面积area,体积volume
public:
virtual void Area()=0; //求表面积的纯虚函数
virtual void Volume()=0; //求体积的纯虚函数
CCt (floata,double b,double c){radius=a;area=b;volume=c;} //基类的构造函数
};
class Square:public CCt //派生类Square
{
public:
Square(float a,double b,double c): CCt (a,b,c)
{}
void Area() //虚函数Area()
{area=6*radius*radius;
cout

//抽象的形状类
public abstract class Shape{ }
//接口
public interface IDisplay{
void display(); //显示图形的基本信息
double getArea(); //计算面积
double getGirth(); //计算周长
}
//三角形类
public class Triangle extends Shape implements IDisplay{
protected double a;
protected double b;
protected double c;
public Triangle(double a, double b, double c){
this.a = a; this.b = b; this.c = c;
}
@Override public double getArea() {
double s = (a + b + c) / 2;
return Math.sqrt(s*(s-a)*(s-b)*(s-c));
}
@Override public double getGirth() {
return this.a + this.b + this.c;
}
@Override public void display() {
System.out.println("三角形");
System.out.println("边长：" + a + ", " + b + ", " + c);
}
}
//矩形类
public class Rectangle extends Shape implements IDisplay {
protected double width; protected double height;
public Rectangle(double width, double height){
this.width = width;
this.height = height;
}
@Override public double getArea() {
return this.width * this.height;
}
@Override public double getGirth() {
return 2 * ( this.width + this.height);
}
@Override public void display() {
System.out.println("矩形");
System.out.println("宽：" + this.width + ", 高：" + this.height);
}
}
//圆类
public class Circle extends Shape implements IDisplay {
protected double radius;
public Circle(double radius){
this.radius = radius;
}
@Override public double getArea() {
return Math.PI * this.radius * this.radius;
}
@Override public double getGirth() {
return 2 * Math.PI * this.radius;
}
@Override public void display() {
System.out.println("圆");
System.out.println("半径：" + this.radius);
}
}

对的！

//抽象方法：只包含方法定义,但没有具体实现的方法,需要其子类或者子类的子类来具体实现. //静态方法不能标记为 override、virtual 或 abstract,即静态方法都必须是具体的 /抽象类：含有一个或多个抽象方法的类称为抽象类,在声明时,类名前须添加"abstract"关键字 //抽象类中可以包含非抽象方法 //抽象类不能够被实例化,这是因为它包含了没有具体实现的方法,即可实例化的类一定不是抽象类,不包含未具体实现的抽象方法. //子类继承抽象父类后,可以使用override关键字覆盖父类中的抽象方法,并做具体的实现.也可以不实现抽象方法,留给后代实现,这时子类仍旧是一个抽象类,必须声明为abstract //继承的抽象方法不可以被隐藏 //隐藏：在子类中创建与父类中的方法具有相同签名（相同的方法名,相同的参数列表--参数类型和次序）的方法(可以带有"virtual"或"override"关键字)即可实现,但建议使用"new"关键字,以明确地隐藏. //只能使用"override"关键字来覆盖(override)父类中标记为"virtual"、"abstract"或"override"的方法,而子类中标记为override的方法,也必须是父类中标记为"virtual"、"abstract"或"override"的方法. //覆盖(override):必须使用override关键字,可以被覆盖的方法包括标记为abstract,virtual,和override的方法； //隐藏:使用new关键字,也可不使用关键字,可以被隐藏的方法包括一般方法,和标记为virtual"或"override"的方法； //重载(overload)：不需要任何特殊的关键字 //静态方法可以被隐藏或重载

前两个是正确的,定义不存在的点要挖掉分区间写;
第3问:
y'=1/(2根号x)+1
所以y'>0恒成立,于是单调递增区间为:
(0,正无穷)