第7章 继承和接口设计 习题

第7章继承和接口设计

一．选择题

1．在C#中，一个类【】。

A) 可以继承多个类B) 可以实现多个接口

C) 在一个程序中只能有一个子类D) 只能实现一个接口

2．【】关键字用于在C#中从派生类中访问基类的成员。

A) new B) super C) this D) base

3．在定义类时，若希望类的某个方法能够在派生类中进一步改进，以满足派生类的不同需要，则应将该方法声明为【】。

A) new B) public C) virtual D) override

4．在C#中，在派生类中对基类的虚方法进行重写，要求在派生类的声明中使用【】。

A) new B) public C) virtual D) override

5．已知类B是由类A继承而来，类A中有一个名为M的非虚方法，现在希望在类B中也定义一个名为M的方法，且两方法的参数个数和类型完全相同，若希望编译时不出现警告信息，则在类B中声明该方法时，应使用【】关键字。

A) static B) new C) override D) virtual

6．假设类B继承了类A，下列说法错误的是【】。

A) 类B中的成员可以访问类A中的公有成员

B) 类B中的成员可以访问类A中的保护成员

C) 类B中的成员可以访问类A中的私有成员

D) 类B中的成员可以访问类A中的静态成员

7．关于多态，下列说法正确的是【】。

A) 多态实际上就是重载，它们本质上是以一样的

B) 多态可以分为编译时多态和运行时多态。前者的特点是在编译时就能确定要调用成

员方法的哪个版本，后者则是在程序运行时才能确定要调用成员方法的哪个版本。

C) 编译时多态是在程序运行时才能确定要调用成员方法的哪个版本，而运行时多态在

编译时就能确定要调用成员方法的哪个版本。

D) 多态和重载是两个完全不同的概念，前者是通过定义虚方法和重写虚方法来实现，

后者是通过对同一函数名编写多个不同的实现代码来实现。

8．下列关于接口的说法，正确的是【】。

A) 接口中定义的方法都必须是虚方法

B) 接口中定义的方法可以编写其实现代码

C) 继承接口的类可提供被继承接口中部分成员的实现代码

D) 接口中的所有方法都必须在其派生类中得到实现。

9．下列关于虚方法的描述中，正确的是【】。

A) 虚方法能在程序执行时动态确定要调用的方法，因此比非虚方法更灵活

B) 在定义虚方法时，基类和派生类的方法定义语句中都要带上virtual修饰符

C) 在重写基类的虚方法时，为消除隐藏基类成员的警告，需要带上new修饰符

D) 在重写基类的虚方法时，需要同时带上virtual和override修饰符

10．在C#中，以下关于抽象类的叙述中错误的是【】。

A) 抽象类可以包含抽象方法B) 含有抽象方法的类一定是抽象类

C) 抽象类不能被实例化D) 抽象类可以是密封类

11．在C#中，以下关于抽象类和接口的叙述中正确的是【】。

A) 抽象类可以包含非抽象方法，而接口不包含任何方法的实现

B) 抽象类可以被实例化，而接口不能被实例化

C) 抽象类不能被实例化，而接口可以被实例化

D) 抽象类能够被继承，而接口不能被继承

12．在C#中，以下关于抽象类和接口的叙述中正确的是【】。

A) 在抽象类中，所有的方法都是抽象方法

B) 继承自抽象类的子类必须实现其父类（抽象类）中的所有抽象方法

C) 在接口的定义中可以有方法实现，在抽象类的定义中不能有方法实现

D) 一个类可以从多个接口继承，也可以从多个抽象类继承

13．以下类和接口的区别中正确的是【】。

A) 类可以继承而接口不可以B) 类不可以继承而接口可以

C) 类可以多继承而接口不可以D) 类不可以多继承而接口可以

14．下列方法定义中，【】是抽象方法。

A) static void func(){ } B) virtual void func(){ }

C) abstract void func(){ } D) overridel void func(){ }

15．下列关于接口的说法，错误的是【】。

A) 一个类可以有多个基类和多个基接口B) 抽象类和接口都不能被实例化

C) 抽象类自身可以定义成员，而接口不可以D) 类不可以多重继承，而接口可以。16．已知类Base、Derived的定义如下：

class Base

{ public void Hello()

{ Sys tem.Console.Write(“Hello in Base!”); }

}

class Derived: Base

{ public new void Hello()

{ System.Console.Write(“Hello in Derived!”); }

}

则下列语句段在控制台中的输出结果是【】。

Derived x=new Derived();

x.Hello();

A) Hello in Base! B) Hello in Base! Hello in Derived!

C) Hello in Derived! D) Hello in Derived!Hello in Base!

17．关于继承，下列说法正确的是【】。

A) 子类将继承父类所有的成员B) 子类将继承父类的非私有成员

C) 子类只继承父类public成员D) 子类只继承父类的方法，而不继承属性

18．下列是抽象类的声明的是【】。

A) abstract class figure{ } B) class abstract figure{ }

C) seald class figure{ } D) static class figure{ } 19．abstract修饰的方法是抽象方法，抽象方法只有声明而无主体，且【】。

A) 只能存在于抽象类中B) 可以在任何类中

C) 只能在接口中D) 只能在密封类中

20．重写一个基类的虚方法时，应与原虚方法的方法名相同，并且【】。

A) 不能改变方法的参数类型、个数和返回值

B) 可以改变方法的参数类型、个数和返回值

C) 可以改变方法的返回值

D) 可以改变方法的参数类型和个数

21．下面有关继承的说法中，正确的是【】。

A) A类和B类均有C类需要的成员，因此可以从A类和B类共同派生出C类

B) 在派生新类时，可以指明是公有派生、私有派生或保护派生

C) 派生类可以继承基类中的成员，同时也继承基类的父类中的成员

D) 在派生类中，不能添加新的成员，只能继承基类的成员

22．为了防止从所修饰的类派生出其他类，可以将此类定义为【】。

A) 抽象类B) 密封类C) 静态类D) 私有类23．若想从派生类中访问基类的成员，可以使用【】。

A) this关键字B) me关键字C) base关键字D) override关键字

24．下面有关派生类的描述中，不正确的是【】。

A) 派生类可以继承基类的构造函数B) 派生类可以隐藏和重载基类的成员

C) 派生类不能访问基类的私有成员D) 派生类只能有一个直接基类25．C#中的多态不能通过【】实现。

A) 接口B) 抽象类C) 密封类D) 虚方法26．下列程序错误的原因是【】。

sealed class SealedClass{ }

class Derived:SealedClass{ }

A) SealedClass类不能被继承B) 没有Main()入口

C) SealedClass没有被实例化D) 以上皆是

27．下面关于接口的叙述中，不正确的是【】。

A) 接口只是由方法、属性、索引器或事件组成的框架，并没有描述任何对象的实例代码

B) 接口的所有成员都被自动定义为公有的，不可使用访问修饰符来定义接口成员

C) 类可以通过在类型定义语句中包括冒号和接口名来表明它正在实现接口

D) 一个类只能实现一个接口

28．接口可以包含一个或多个成员，以下选项中【】不能包含在接口中。

A) 方法B) 属性C) 事件D) 常量

29．下列叙述中，正确的是【】。

A) 接口中可以有虚方法B) 一个类可以实现多个接口

C) 接口能被实例化D) 接口中可以包含已实现的方法

30. 关于虚方法实现多态，下列说法错误的是【】。

A) 定义虚方法使用关键字virtual B) 关键字virtual可以与override一起使

用

C) 虚方法是实现多态的一种应用形式D) 派生类是实现多态的一种应用形式

31. 以下类MyClass的定义中，【】是合法的抽象类。

A) abstract class MyClass { public abstract int getCount(); }

B) abstract class MyClass { public virtual abstract int getCount(); }

C) abstract class MyClass { private abstract int getCount(); }

D) abstract class MyClass { public static abstract int getCount(); }

32. 分析下列程序中类MyClass的定义

class BaseClass

{ public int i; }

class MyClass:BaseClass

{ public new int i; }

则下列语句在Console 上的输出为【】。

MyClass y = new MyClass();

BaseClass x = y;

x.i = 100;

Console.WriteLine("{0}, {1}",x.i,y.i);

A) 0, 0 B) 100, 100 C) 0, 100 D) 100, 0

33. 在C#程序中定义如下IPlay接口，实现此接口代码正确的是【】。

interface IPlay

{ void Play();

void Show();

}

A) class Teacher :Iplay

{ void Play(){ //省略部分代码}

void Show0{ //省略部分代码}

B) class Teacher :Iplay

{ public string Play(){ //省略部分代码}

public void Show0{ //省略部分代码}

C) class Teacher :Iplay

{ public void Play(){ //省略部分代码}

public void Show0{ //省略部分代码}

D) class Teacher :Iplay

{ public void Play();

public void Show0{ //省略部分代码}

34. 以下泛型集合声明中正确的是【】。

A) List f=new List(); B) List f=new List ();

C) List f=new List (); D) List f=new List;

34. 以下关于泛型的叙述中错误的是【】。

A) 泛型是通过参数化类型来实现在同一份代码上操作多种数据类型

B) 泛型编程是一种编程范式，其特点是参数化类型,

C) 泛型类型和普通类型的区别在于泛型类型与一组类型参数或类型变量关联

D) 以上都不对

二．填空题

1．在C#中有两种多态性：编译时的多态性和运行时的多态性。编译时的多态性是通过【虚方法和重写虚方法】实现的，运行时的多态性是通过继承和【重载/隐藏】来实现的。2．在声明类时，在类名前使用【abstract】修饰符，则声明的类只能作为其他类的基类，不能被实例化。

3．在声明类时，在类名前使用【sealed 】修饰符，则声明的类不能作为其他类的基类，不能再派生新的类。

4. 下列程序的运行结果是【AB】。考察类的继承(构造函数是先基类的先构造，析构函数是子类先析构)

class A

{ public A( )

{ Console.WriteLine("A"); }

}

class B:A

{ public B()

{ Console.WriteLine("B"); }

}

class Program

{ public static void Main()

{ B b = new B();

Console.ReadLine();

}

}

5. 分析下列程序的运行结果是【】。考察类的继承中base的使用

class A

{ public int x=100; }

class B:A

{ new public int x;

public B(int y, int z){ x=y; base.x=z; }

public int getx1(){ r eturn base.x; }

public int getx2(){ r eturn x; }

}

class Program

{ public static void Main()

{ B b = new B(3, 6);

int n = b.getx1();

int m = b.getx2();

Console.WriteLine("m={0},n={1}", m, n);

}

}

m=3,n=6

6. 分析下列程序的运行结果是【】。考察类的继承（隐藏和重写）

abstract class BaseClass

{ public void MethodA()

{ Console.WriteLine("BaseClass.MethodA"); }

public virtual void MethodB()

{ Console.WriteLine("BaseClass.MethodB"); }

}

class Class1 : BaseClass

{ new public void MethodA()

{ Console.WriteLine("Class1.MethodA"); }

public override void MethodB()

{ Console.WriteLine("Class1.MethodB"); }

}

class Class2 : Class1

{ new public void MethodB()

{ Console.WriteLine("Class2.MethodB"); }

}

class MainClass

{ public static void Main(string[] args)

{ Class2 a = new Class2();

a.MethodA(); a.MethodB();

Console.Read();

}

}

Class1.MethodA

Class2.MethodB

7．下列程序的运行结果是【AA CC DD DD 】。考察类的继承（隐藏和重写）class A

{ public void F1(){ Console.Write("AA "); }

public virtual void F2() { Console.Write("BB "); }

}

class B : A

{ n ew public void F1(){ Console.Write("CC "); }

public override void F2(){ Console.Write("DD "); }

}

class Test

{ static void Main()

{ B b = new B();

A a = b;

a.F1();

b.F1(); a.F2(); b.F2();

Console.Read();

}

}

8.阅读下列程序，程序的输出结果是【】。考察类的继承

public class A

{ private int speed =10;

public int Speed

{ get { return speed; }

set { speed = value; Console.WriteLine("禁止驶入!"); }

}

}

public class B:A

{ public B()

{ if(this.Speed>=20) Console.Write ("机动车");

else Console.Write ("非机动车");

}

}

class Program

{ public static void Main()

{ B b=new B();

b.Speed = 30;

}

}

非机动车禁止驶入!

9.阅读下列程序，程序的输出结果是【】。考察类的继承

public class Person

{ private int age = 0;

public int Age

{ get

{ return age; }

set

{ if(value>=18) Console.Write("成年人");

else Console.Write("未成年人");

age = value;

}

}

}

public class People : Person

{ public People(int age)

{ Age = age;

Console.WriteLine("不得入内");

}

}

class Program

{ public static void Main()

{ People b = new People (25);

Console .WriteLine("你的年龄是：{0}",b.Age);

Console.Read();

}

}

成年人不得入内

你的年龄是：25

10.阅读下列程序，程序的输出结果是【】。考察接口的映射

interface IA

{ void Hello(); }

class Base:IA

{ public void Hello()

{ Console.WriteLine("Hello in Base!"); } }

class Derived:Base

{ new public void Hello()

{ Console.WriteLine("Hello in Derived!"); } }

class Program

{ public static void Main()

{ Base b=new Base();

Derived d=new Derived ();

IA x;

b.Hello(); d.Hello();

x=b; x.Hello();

x=d; x.Hello();

Console.Read();

}

}

Hello in Base!

Hello in Derived!

Hello in Base!

Hello in Base!

11.阅读下列程序，程序的输出结果是【】。考察接口的映射

interface IA

{ void Hello(); }

class Base:IA

{ public void Hello()

{ Console.WriteLine("Hello in Base!"); } }

class Derived:IA

{ new public void Hello()

{ Console.WriteLine("Hello in Derived!"); } }

class Program

{ public static void Main()

{ Base b=new Base();

Derived d=new Derived ();

IA x;

x=b; x.Hello();

x=d; x.Hello();

Console.Read();

}

}

Hello in Base!

Hello in Derived!

12.阅读下列程序，程序的输出结果是【】。考察接口的映射

interface Ia //接口Ia声明{ double fun1(); //接口成员声明

int fun2(); //接口成员声明

}

class A //声明基类A

{ public int fun2()//隐式实现接口成员fun2 { return 2; }

}

class B : A, Ia //类B从基类A和接口继承

{ double x;

public B(double y) //构造函数

{ x = y; }

public double fun1() //隐式实现接口成员fun1

{ return x; }

}

class Program

{ static void Main(string[] args)

{ B b = new B(2.5);

Console.WriteLine("{0} ", b.fun1());

Console.WriteLine("{0} ", b.fun2());

Console.Read();

}

}

2.5

2

12.阅读下列程序，程序的输出结果是【】。考察类的实现与泛型

class Stack //声明栈泛型类

{ int maxsize; //栈中元素最多个数

T[] data; //存放栈中T类型的元素

int top; //栈顶指针

public Stack() //构造函数

{ maxsize = 10; data = new T[maxsize];

top = -1;

}

public Stack(int n) //重载构造函数{ maxsize = n; data = new T[maxsize];

top = -1;

}

public bool StackEmpty() //判断栈空方法

{ return top == -1; }

public bool Push(T e) //元素e进栈方法

{ if (top == maxsize - 1) return false;

top++; data[top] = e;

return true;

}

public bool Pop(ref T e) //元素出栈方法

{ if (top == -1) return false;

e = data[top]; top--;

return true;

}

}

class Program

{ static void Main(string[] args)

{ int e = 0;

Stack s = new Stack(); //定义整数栈

s.Push(1); s.Push(3); s.Push(2);

Console.Write("整数栈出栈次序：");

while (!s.StackEmpty()) //栈不空时出栈元素

{ s.Pop(ref e); Console.Write("{0} ", e); }

Console.WriteLine();

string e1 = "";

Stack s1 = new Stack(); //定义字符串栈

s1.Push("Mary"); s1.Push("John"); s1.Push("Simth");

Console.Write("字符串栈出栈次序：");

while (!s1.StackEmpty()) //栈不空时出栈元素

{ s1.Pop(ref e1); Console.Write("{0} ", e1); }

Console.ReadLine();

}

}

整数栈出栈次序：2 3 1

字符串栈出栈次序：Simth John Mary

三．改错题

（说明：下列程序中部分下划线的代码有错误，请将有错误的部分改正过来，并说明原因）1．class A

{ public A(int x){ } }

class B:A

{ public B(int x){ } }

答：“public B(int x){ }”应改为“public B(int x):base(x){ }”。因为基类A中没有无参数的构造函数。

2．class A

{ void A(){ }

private A(int x){ }

private A(int y){ }

}

答：“void A(){ }”应改为“A(){}”，因为构造函数不能带任何返回类型修饰符。“private A(int x){ }”和“private A(int y){ }”实际上是同一个构造函数，应删除其中一个。3．interface I

{ int x;

public void f(int x);

void g(int x);

int h(int x){ return 1; }

}

class A:I

{ public void f(int x){ }

public int h(int x){ }

}

答：“int x;”应予以删除，因为接口中不允许存在成员变量。“public void f(int x);”中的修饰符“public”应予以删除，因为接口的方法前不允许存在任何修饰符；“int h(int x){ return 1; }”

应改为“int h(int x)；”，因为不能在接口声明的函数中编写实现代码；应该在类A中添加函数“void g(int x);”的实现代码。

4．class A{ }

class B{ }

class C: A, B { }

答：必须将“class C:A,B”中的“A”或“B”其中之一去掉，因为C#中不允许类进行多重继承。5．class A

{ protected static void f(){ }

protected void g(){ }

}

class B:A

{ new public static void f() { }

new public void g(){ }

public void h()

{ base.f(); base.g(); f(); g(); }

}

答：“base.f();”应改为“A.f();”，原因是类A中的方法“f()”是静态方法，它不能被实例化，只能通过类名来访问。

四．问答题

1．什么是类的继承？怎样定义派生类？

继承是指一个类可以继承另一个类中的相关成员，被继承的类称为基类、超类或父类，继承而形成的类称为派生类或子类

利用继承机制，新的类可以从已有的类中派生。那些用于派生的类称为这些特别派生出的类的“基类”

2．简述创建派生类时，构造函数的调用。

先创建基类的构造函数，在创建自己的构造函数

3．怎样定义基类虚方法，并在派生类中重写基类虚方法？

virtual方法名([参数列表])

{ 语句序列}

override 方法名([参数列表])

{ 语句序列}

4．抽象方法和虚方法有什么异同？

抽象方法是只有定义、没有实际方法体的函数，它只能在抽象函数中出现，并且在子类中必须重写；虚方法则有自己的函数体，已经提供了函数实现，但是允许在子类中重写或覆盖。重写的子类虚函数就是被覆盖了。

5．什么是抽象类？它有什么特点？它和接口有何异同？

在方法声明中使用abstract修饰符的方法即为抽象方法。

6．什么是方法重载？重载的方法有何特点？

是多态性的表达方法名相同，但是参数类型和个数不同

五．编程题

1. 编写一个控制台应用程序项目，实现学生和教师数据输入和显示功能。学生类Student有

编号、姓名、班号和成绩等字段，教师类有编号、姓名、职称和部门等字段。要求将编号、姓名输入和显示设计成一个类Person，并作为Student和Teacher的基类。需用相关数据进行测试。

public class Person //人类

{ private int no; //编号

private string name; //姓名

public void input()

{ Console.Write(" 编号:"); no =

int.Parse(Console.ReadLine());

Console.Write(" 姓名:"); name = Console.ReadLine();

}

public void disp()

{ Console.WriteLine(" 编号:{0}",no);

Console.WriteLine(" 姓名:{0}",name);

}

}

public class Student : Person //学生类

{ private string sclass; //班号

private int degree; //成绩

public void input()

{ base.input();

Console.Write(" 班号:"); sclass = Console.ReadLine();

Console.Write(" 成绩:"); degree =

int.Parse(Console.ReadLine());

}

new public void disp()

{ base.disp();

Console.WriteLine(" 班号:{0}",sclass);

Console.WriteLine(" 成绩:{0}",degree);

}

}

public class Teacher : Person //教师类

{ private string prof; //职称

private string depart; //部门

public void input()

{ base.input();

Console.Write(" 职称:"); prof = Console.ReadLine();

Console.Write(" 部门:"); depart = Console.ReadLine();

}

new public void disp()

{ base.disp();

Console.WriteLine(" 职称:{0}", prof);

Console.WriteLine(" 部门:{0}", depart);

}

}

class Program

{

static void Main(string[] args)

{ Student s1 = new Student();

Teacher t1 = new Teacher();

Console.WriteLine("输入一个学生数据:"); s1.input();

Console.WriteLine("输入一个教师数据:"); t1.input();

Console.WriteLine("显示一个学生数据:"); s1.disp();

Console.WriteLine("显示一个教师数据:"); t1.disp();

}

}

2. 设计一个控制台应用程序项目b，设计一个普通职工类Employee，其工资为基本工资

（1000）加上工龄工资（每年增加30元）。从Employee类派生出一个本科生类UEmployee，其工资为普通职工算法的1.5倍。并用相关数据进行测试，测试效果图如下图所示。

控制台应用程序项目b的执行结果

public class Employee //普通职工类

{

private double bsalary= 1000; //基本工资

private double psalary; //实际工资

private int n; //工作年数

public int pn

{ get { return n; }

set { n = value; }

}

public double compsalary() //计算普通员工工资

{ Console.Write("工作年数:");

pn = int.Parse(Console.ReadLine());

psalary = bsalary+30*pn;

return psalary;

}

}

public class UEmployee : Employee //本科生职工类

{ new public double compsalary()

{ return 1.5 * https://www.wendangku.net/doc/b414145764.html,psalary(); }

}

class Program

{ static void Main(string[] args)

{ Console.WriteLine("普通职工:");

Employee emp1 = new Employee();

Console.WriteLine("该普通职工工资:{0}", https://www.wendangku.net/doc/b414145764.html,psalary());

Console.WriteLine("本科生职工:");

UEmployee emp2 = new UEmployee();

Console.WriteLine("该本科生职工工资:{0}", https://www.wendangku.net/doc/b414145764.html,psalary());

}

}

说明：本题需采用继承方法，用虚函数等均可。

3．定义一个Shape抽象类，在该类中定义两个抽象方法GetArea和GetPerim。然后以Shape 抽象类作为基类派生出Rectangle和Circle类，在这两个类中分别对GetArea和GetPerim 方法进行重写，实现求特定形状的面积和周长。

抽象类方法实现

public abstract class Shape

{ public abstract double GetArea();

public abstract double GetPerim();

}

class Rectangle : Shape //派生出来的Rectangle类

{ private double Width; //矩形的宽度

private double Length; //矩形的长度

public Rectangle(double a, double b) //构造函数

{ Width = a; Length = b; }

public override double GetArea() //重载的求面积方法

{ return (Width * Length); }

public override double GetPerim() //重载的求周长方法

{ return (2 * (Length + Width)); }

}

class Circle : Shape //派生出的Circle类

{ private double Radius;

public Circle(double r) //构造函数

{ Radius = r; }

public override double GetArea() //重载的求面积方法

{ return (Math.PI * Radius * Radius); }

public override double GetPerim() //重载的求周长方法

{ return (2 * Math.PI * Radius); }

}

接口方法实现

public interface Shape

{ double GetArea();

double GetPerim();

}

class Rectangle : Shape //派生出来的Rectangle类

{ public double Width; //矩形的宽度

public double Length; //矩形的长度

public Rectangle(double a, double b) //构造函数

{ Width = a; Length = b; }

public double GetArea() //重载的求面积方法

{ return (Width * Length); }

public double GetPerim() //重载的求周长方法

{ return (2 * (Length + Width)); }

}

class Circle : Shape //派生出的Circle类

{ public double Radius;

public Circle(double r) //构造函数

{ Radius = r; }

public double GetArea() //重载的求面积方法

{ return (Math.PI * Radius * Radius); }

public double GetPerim() //重载的求周长方法

{ return (2 * Math.PI * Radius); }

}

4．设计一个抽象类Calculate（计算）,该类包含OptA、OptB、OptC三个double类型的字段，包含一个带有两个double类型参数的构造函数（用于给字段OptA、OptB赋值）和一个名为SqrtForSum的抽象方法，该方法带有三个double类型参数、返回值类型为double型。再设计一个继承于Calculate的派生类Cal，该类包含一个带有三个double类型参数的构造函数，并重写SqrtForSum方法用于计算三数和的平方根。

public abstract class Calculate

{ protected double OptA, OptB, OptC;

public Calculate(double a, double b)

{ OptA = a; OptB = b; }

public abstract double SqrtForSum(double a,double b,double c);

}

class Cal:Calculate

{ public Cal(double a, double b, double c): base(a, b)

{ OptC = c; }

public override double SqrtForSum(double a, double b, double c)

{ double sum;

sum = a + b + c;

return Math .Sqrt (sum );

}

}

class Program

{ static void Main(string[] args)

{ double a, b, c,sum;

a = Convert.ToDouble(Console.ReadLine());

b = Convert.ToDouble(Console.ReadLine());

c = Convert.ToDouble(Console.ReadLine());

Cal cc = new Cal(a,b,c);

sum=cc.SqrtForSum(a,b,c);

Console.WriteLine("sum={0}", sum);

}

}

5．编写一个通用的人员类（Person），该类具有姓名（Name）、年龄（Age）、性别（Sex）等字段。然后通过对Person类的继承得到一个学生类（Student）。学生类能够存放学生5门课的成绩，具有重载构造函数用于对学生的信息进行赋值（构造函数进行重载，至少给出三种形式），并有求平均成绩的方法和显示学生信息的方法，最后编程对Student 类的功能进行验证。

public class Person

{ public string Name;

public int Age;

public char Sex;

}

public class Student : Person

{ public double[] Score;

public double Aver;

public Student(string xm, int nl, char xb)

{ Name = xm; Age = nl; Sex = xb;

Score = new double[5];

}

public Student()

{ Name = "王平"; Age = 18; Sex = '女';

Score = new double[5];

}

public Student(string xm, int nl, char xb, double[] cj)

{ Name = xm; Age = nl; Sex = xb;

Score = new double[5];

for (int i = 0; i < 5; i++) Score[i] = cj[i];

}

public double CalAver()

{ double sum = 0;

for (int i = 0; i < 5; i++) sum = sum + Score[i];

Aver = sum / 5;

return (Aver);

}

public void display()

{ Console.WriteLine("姓名：{0}", Name);

Console.WriteLine("年龄：{0}", Age);

Console.WriteLine("性别：{0}", Sex);

Console.Write("成绩：");

for (int i = 0; i < 5; i++) Console.Write("{0} ", Score[i]);

Console.WriteLine("\n平均成绩：{0}", CalAver());

}

}

class Program

{ public static void Main()

{ double[] cj = { 87, 78, 90, 67, 89 };

Student stu;

stu = new Student(); stu.display();

stu = new Student("张三", 20, '男'); stu.display();

stu = new Student("张三", 20, '男', cj); stu.display();

Console.Read();

}

}

6．设计一个控制台应用程序，定义如下接口Ia：

interface Ia //声明接口Ia

{ float getarea(); //求面积

}

从它派生Rectangle（长方形类）和Square（正方形）两个类，包含getarea方法的实现。

并分别输出长2宽3的长方形和长5的正方形的面积。

interface Ia //声明接口Ia

{ float getarea();//接口成员声明

}

public class Rectangle : Ia//类Rectangle继承接口Ia

{ float x, y;

public Rectangle(float x1, float y1)//构造函数

{ x = x1; y = y1; }

float Ia.getarea()//显式接口成员实现,带有接口名前缀,不能使用public

{ return x * y; }

}

public class Square : Ia //类Square继承接口Ia

{ float x;

public Square(float x1)//构造函数

{ x = x1; }

float Ia.getarea()//显式接口成员实现,带有接口名前缀,不能使用public

{ return x * x; }

}

class Program

{ static void Main(string[] args)

{ Rectangle box1 = new Rectangle(2.0f, 3.0f); //定义一个类实例

Ia ia = (Ia)box1; //定义一个接口实例

Console.WriteLine("长方形面积: {0}", ia.getarea());

Square box2 = new Square(5.0f); //定义一个类实例

Ia ib = (Ia)box2; //定义一个接口实例

Console.WriteLine("正方形面积: {0}", ib.getarea());

}

}

7．设计一个控制台应用程序，含一个学生类Stud（每个学生有学号xh、姓名xm和分数fs 私有字段），向ArrayList对象中添加若干个学生对象，并按分数从高到低输出所有学生信息。要求比较采用继承Icomparer接口的方式实现。

class Program

{ class Stud

{ int xh; //学号

string xm; //姓名

int fs; //分数

public int pfs //pfs属性

{ get { return fs; } }

public Stud(int no, string name, int degree)

{ xh = no; xm = name; fs = degree; }

public void disp()

{ Console.WriteLine("\t{0}\t{1}\t{2}", xh, xm, fs); }

}

public class myCompareClassfs : IComparer

{ int https://www.wendangku.net/doc/b414145764.html,pare(object x, object y)

{ Stud a = (Stud)x; Stud b = (Stud)y;

if (a.pfs < b.pfs) return 1;

else if (a.pfs == b.pfs) return 0;

else return -1;

}

}

static void disparr(ArrayList m yarr, string str)

{ Console.WriteLine(str);

Console.WriteLine("\t学号\t姓名\t分数");

foreach (Stud s in myarr) s.disp();

}

static void Main(string[] args)

{ int i, n = 4;

IComparer myComparerfs = new myCompareClassfs();

ArrayList myarr = new ArrayList();

Stud[] st = new Stud[4] { new Stud(1, "Smith", 82), new Stud(4, "John",

88),

new Stud(3, "Mary", 95), new Stud(2,

"Cherr", 64) };

for (i = 0; i < n; i++) myarr.Add(st[i]);

myarr.Sort(myComparerfs);

disparr(myarr, "按分数降序排序后:");

}

}

8．设计一个控制台应用程序项目，输入若干个学生的英语和数学成绩，求出总分，并按总分从高到低排序。要求设计一个学生类Student，所有学生对象存放在一个Student对象数组中，通过一个方法对其按照总分进行降序排序，最出输出排序后的结果。要求比较采用继承继承Icomparable接口的方式实现。

public class Student:IComparable

{ private string name;

private int eng, math, sum;

public int psum

{ get { return sum; } }

public void inscore()

{ Console.Write("姓名:"); name = Console.ReadLine();

Console.Write("英语:"); eng = int.Parse(Console.ReadLine());

Console.Write("数学:"); math = int.Parse(Console.ReadLine());

sum = eng + math;

}

public void display()

{ Console.WriteLine("\t{0}\t{1}\t{2}\t{3}", name, eng, math, sum); }

public int CompareTo(object obj) //实现接口方法

{ Student s = (Student)obj;//转换为Student实例

if (psum < s.psum) return 1;

else if (psum == s.psum) return 0;

else return -1;

}

}

class Program

{ static void Main(string[] args)

{ int n, i;

ArrayList myarr = new ArrayList();

Student p; //定义对象引用

Console.Write("输入学生人数:");

n = int.Parse(Console.ReadLine());

for (i = 0; i < n; i++)

{ Console.WriteLine("输入第{0}个学生数据:", i + 1);

p = new Student(); //创建对象引用实例

p.inscore();

myarr.Add(p);

}

Console.WriteLine("排序前:");

Console.WriteLine("\t姓名\t英语\t数学\t总分");

i = 1;

foreach(Student s in myarr)

{ Console.Write("序号{0}:", i++);

s.display();

}

myarr.Sort(); //按总分降序排序

Console.WriteLine("排序后:");

Console.WriteLine("\t姓名\t英语\t数学\t总分");

i = 1;

foreach (Student s in myarr)

{ Console.Write("第{0}名:", i++);

s.display();

}

}

}

java继承与接口实验三

信息与计算科学专业实验报告 课程名称Java课程设计总实验学时： 16 第3 次共6 次 实验项目名称继承与接口本次实验学时数： 3 实验类 型 验证 日期20 12 年 3 月6 日星期二年级 学生姓名学号课任教师 1.实验目的 巩固如下概念：子类的继承性、子类对象的创建过程、成员变量的继承与隐藏、方法的继承与重写；掌握上转型对象的使用；掌握接口回调技术。 2.实验要求 实验前，应事先熟悉相关知识点，拟出相应的实验操作步骤，明确实验目的和要求；实验过程中，服从实验指导教师安排，遵守实验室的各项规章制度，爱护实验仪器设备；实验操作完成后，认真书写实验报告，总结实验经验，分析实验过程中出现的问题。 3.实验内容 1、继承 编写一个Java应用程序，除主类外，该程序中还有4个类：People、ChinaPeople、AmericanPeople和BeijingPeople类。要求如下：People类有访问权限是protected的double 型成员变量：height和weight，以及public void speakHello()、public void averageHeight()、public void averageWeight()方法；ChinaPeople类是People的子类，新增了public void chinaGongfu()方法。要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法；AmericanPeople类是People的子类，新增public void americanBoxing()方法。要求AmericanPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法；BeijingPeople类是ChinaPeople的子类，新增public void beijingOpera()方法。要求BeijingPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法；请按模板要求，将【代码】替换为Java程序代码。 2、上转型对象 编写一个Java应用程序，要求有一个abstract类，类名为Employee。Employee的子类有YearWorker、MonthWorker和WeekWorker。YearWorker对象按年领取薪水，MonthWorker按月领取薪水，WeekWorker按周领取薪水。Employee类有一个abstract方法：public abstract double earnings(); 子类必须重写父类的earnings()方法，给出各自领取报酬的具体方式。有一个

齿轮设计基础知识题库

齿轮设计题库 一 选择题： (1) 一般参数的闭式硬齿面齿轮传动的主要失效形式是 B 。 A. 齿面点蚀 B. 轮齿折断 C. 齿面磨损 D. 齿面胶合 (2) 在闭式齿轮传动中，高速重载齿轮传动的主要失效形式是 C 。 A. 轮齿疲劳折断 B. 齿面疲劳点蚀 C. 齿面胶合 D. 齿面磨粒磨损 E. 齿面塑性变形 (3) 对齿轮轮齿材料性能的基本要求是 A 。 A. 齿面要硬，齿心要韧 B. 齿面要硬，齿心要脆 C. 齿面要软，齿心要脆 D. 齿面要软，齿心要韧 (4) 已知一齿轮的制造工艺过程是：加工齿坯、滚齿、表面淬火和磨齿，则该齿轮的材料是 B 。 A. 20CrMnTi B. 40Cr C. Q235 D. ZCuSn5Pb5Zn5 (5) 对于一对材料相同的软齿面齿轮传动，常用的热处理方法是 D 。 A. 小齿轮淬火，大齿轮调质 B. 小齿轮淬火，大齿轮正火 C. 小齿轮正火，大齿轮调质 D. 小齿轮调质，大齿轮正火 (6) 对于齿面硬度大于350HBS 的钢制齿轮，其加工的工艺过程一般为 C 。 A. 加工齿坯——淬火——切齿——磨齿 B. 加工齿坯——切齿——磨齿——淬火 C. 加工齿坯——切齿——淬火——磨齿 D. 加工齿坯——淬火——磨齿——切齿 (7) 斜齿轮和锥齿轮强度计算中的齿形系数Fa Y 和应力校正系数Sa Y 应按 B 查图表。 A. 实际齿数 B. 当量齿数 C. 不发生根切的最少齿数 (8) 一减速齿轮传动，主动轮1用45钢调质，从动轮2用45钢正火，则它们齿面接触应力的关系是 B 。 A. 2H 1H σσ< B. 2H 1H σσ= C. 2H 1H σσ> D. 可能相等，也可能不等 (9) 一对标准圆柱齿轮传动，已知50,2021==z z ，它们的齿形系数是 C 。 A. 21Fa Fa Y Y < B. 21Fa Fa Y Y = C. 21Fa Fa Y Y > 齿根弯曲应力是 A 。 A. 2F 1F σσ> B. 2F 1F σσ= C. 2F 1F σσ<

直齿锥齿轮传动计算例题

例题10-3试设计一减速器中的直齿锥齿轮传动。已知输入功率P=10kw，小齿轮转速n1=960r/min，齿数比u=3.2，由电动机驱动，工作寿命15年（设每年工作300天），两班制，带式输送机工作平稳，转向不变。 [解]1.选定齿轮类型、精度等级、材料及齿数 （1）选用标准直齿锥齿轮齿轮传动，压力角取为20°。 （2）齿轮精度和材料与例题10-1同。 （3）选小齿轮齿数z1=24，大齿轮齿数z2=uz1=3.224=76.8，取z2=77。 2.按齿面接触疲劳强度设计 （1）由式（10-29）试算小齿轮分度圆直径，即 1) =1.3 计算小齿轮传递的转矩。 9.948 选取齿宽系数=0.3。 查得区域系数 查得材料的弹性影响系数。 [] 由图 由式（ ， 由图10-23查取接触疲劳寿命系数 取失效概率为1%，安全系数S=1，由式（10-14）得 取和中的较小者作为该齿轮副的接触疲劳许用应力，即

2）试算小齿轮分度圆直径 (2) 1 3.630m/s ②当量齿轮的齿宽系数 0.342.832mm 2) ①由表查得使用系数 ②根据级精度（降低了一级精度） ④由表 由此，得到实际载荷系数 3)由式（10-12），可得按实际载荷系数算得的分度圆直径为 及相应的齿轮模数 3.按齿根弯曲疲劳强度设计 （1）由式（10-27）试算模数，即

1）确定公式中的各参数值。 ①试选 ②计算 由分锥角 由图 由图 由图查得小齿轮和大齿轮的齿根弯曲疲劳极限分别为 由图取弯曲疲劳寿命系数 ，由式（10-14）得 因为大齿轮的大于小齿轮，所以取 2)试算模数。 =1.840mm

机械设计习题齿轮

一、选择题 1、一般开式齿轮传动的主要失效形式是＿C＿。 A、齿面胶合 B、齿面疲劳点蚀 C、齿面磨损或轮齿疲劳折断 D、轮齿塑性变形 2、高速重载齿轮传动，当润滑不良时，最可能出现的失效形式是＿A＿。 A、齿面胶合 B、齿面疲劳点蚀 C、齿面磨损 D、轮齿疲劳折断 3、45号钢齿轮，经调质处理后其硬度值约为＿B＿。 A、HRC＝45~50 B、HBS=220~270 C、HBS=160~180 D、HBS=320~350 4、齿面硬度为56~62HRC的合金钢齿轮的加工工艺过程为＿C＿。 A、齿坏加工、淬火、磨齿、滚齿 B、齿坏加工、淬火、滚齿、磨齿 C、齿坏加工、滚齿、渗碳淬火、磨齿 D、齿坏加工、滚齿、磨齿、淬火 5、齿轮采用渗碳淬火的热处理方法，则齿轮材料只可能是＿D＿。 A、45号钢 B、ZG340~640 C、20Cr D、20CrMnTi 6、齿轮传动中齿面的非扩展性点蚀一般出现在＿A＿。 A、跑合阶段 B、稳定性磨损阶段 C、剧烈磨损阶段 D、齿面磨料磨损阶段 7、对于开式齿轮传动，在工程设计中，一般＿D＿。 A、按接触强度设计齿轮尺寸，再校核弯曲强度 B、按弯曲强度设计齿轮尺寸，再校核接触强度 C、只需按接触强度设计 D、只需按弯曲强度设计 8、一对标准直齿圆柱齿轮，已知z1=18，a2=72，则这对齿轮的弯曲应力＿A＿。 A、sF1>sF2 B、sF1

机械设计齿轮传动设计答案解析

题10-6 图示为二级斜齿圆柱齿轮减速器, 第一级斜齿轮的螺旋角 1 β的旋 向已给出。 （1）为使Ⅱ轴轴承所受轴向力较小,试确定第二级斜齿轮螺旋角β的旋向, 并画出各轮轴向力、径向力及圆周力的方向。 （2）若已知第一级齿轮的参数为:Z 1 =19,Z 2 =85,m n =5mm,0 20 = n α,a=265mm, 轮1的传动功率P=,n 1 =275 r/min。试求轮1上所受各力的大小。 解答: 1．各力方向：见题解10-6图。 2．各力的大小：m N 045 . 217 m N 275 25 .6 9550 9550 1 1 1 ? = ? ? = ? =n P T 148 . 11 , 9811 .0 265 2 ) 85 19 ( 5 2 ) ( cos2 1 1= = ? + ? = + =β β a z z n m ； mm 83 . 96 cos 1 1 = =β z n m d； N 883 tan , N 1663 cos tan , N 4483 2000 1 1 1 1 1 1 1 1 1 = = = = = =β β α t a t r t F F n F F d T F ； 题10-7图示为直齿圆锥齿轮-斜齿圆柱齿轮减速器,为使Ⅱ轴上的轴向力 抵消一部分,试确定一对斜齿圆柱齿轮螺旋线的方向;并画出各齿轮轴向力、径向 力及圆周力的方向。 解答：齿轮3为右旋，齿轮4为左旋; 力的方向见题解10-7图。 题解 题

↓ 题10-9 设计一冶金机械上用的电动机驱动的闭式斜齿圆柱齿轮传动, 已知:P = 15 kW,n 1 =730 r/min,n 2 =130 r/min,齿轮按8级精度加工,载荷有严重冲击,工作时间t =10000h,齿轮相对于轴承为非对称布置,但轴的刚度较大,设备可靠度要求较高,体积要求较小。（建议两轮材料都选用硬齿面） 解题分析：选材料→确定许用应力→硬齿面，按轮齿的弯曲疲劳强度确定齿轮的模数→确定齿轮的参数和几何尺寸→校核齿轮的接触疲劳强度→校核齿轮的圆周速度 解答:根据题意,该对齿轮应该选用硬齿面,其失效形式以轮齿弯曲疲劳折断为主。 1. 选材料 大、小齿轮均选用20CrMnTi 钢渗碳淬火（[1]表11-2），硬度为56～62HRC ，由[1]图 11-12 和[1]图11-13查得：MPa 1500,MPa 430lim lim ==H F σσ 2.按轮齿弯曲疲劳强度进行设计 （1）确定FP σ 按[1]式（11-7 P227）计算，取6.1,2min ==F ST S Y ；齿轮的循环次数： 8111038.41000017306060?=???==at n N ,取11=N Y ,则: 538MPa MPa 16 .124301m in lim 1=??== N F ST F FP Y S Y σσ （2）计算小齿轮的名义转矩T 1

精密机械设计基础第7章习题答案资料

习题讲解 题7-6如图7-68所示，有一渐开线直齿圆柱齿轮，用卡尺测量其三个齿和两个齿的公法线长度为W3＝61.83mm和W2＝37.55mm，齿顶圆直径da＝208mm，齿根 圆直径df＝172mm，数得齿数z＝24。要求确定该齿轮的模数m、压力角α、齿*顶高系数ha和径向间隙系数c*。 解法1： 由齿轮公法线测量原理，有： Pb=W3-W2=24.28mm Sb=W2-Pb=13.27mm 由渐开线圆柱齿轮任意圆上的齿厚公式： Si=S?ri-2ri(invαi-invα) r =

=Sbinvm=dadf Pbdb=Pb?z=24.28?24=185.49mm d zππ已知：db

错误解法1： PbP24.28m====8.22 ππ?cosαπ?cos20 Pb24.28m====8.0012 ππ?cosαπ?cos15 α不是已知的。

P 题7-14 已知二级平行轴斜齿轮传递，主动轮1的转向及螺旋方向如图所示。 1) 低速级齿轮3、4的螺旋方向应如何选择，才能使中间轴Ⅱ上两齿轮的轴向力方向相反？ 圆周力Ft的方向：在主动轮上与转动方向相反，在从动轮上与转向相同（驱动力）。 径向力Fr的方向：方向均指向各自的轮心（内齿轮为远离轮心方向）。 轴向力Fa的方问：取决于齿轮的回转方向和轮齿的螺旋方向，可按"主动轮左、右手螺旋定则"来判断。即：主动轮为右旋时，右手按转动方向握轴，以四指弯曲方向表示主动轴的回转方向，伸直大拇指，其指向即为主动轮上轴向力的方向；主动轮为左旋时，则应以左手用同样的方法来判断。主动轮上轴向力的方向确定后，从动轮上的轴向力则与主动轮上的轴向力大小相等、方向相反。 Fa3 FFa1 F所以，齿轮2和齿轮3为左旋，齿轮4为右旋。

面向对象--类继承与接口实验报告

实验十类继承与接口（二） 课程名称：面向对象程序设计 实验项目名称：实验十类继承与接口（二） 学生姓名：专业：学号： 实验地点：实验日期：年月 【实验目的】 1．掌握Java类的继承特点，包括子类声明、对象创建 2. 掌握域的继承与隐藏的特点和用法 3. 掌握方法的继承与重写的特点和用法 【实验内容】 一. 改错题 检查下面代码是否有错，如果有错，写明错误原因，并修正错误。 （1） class Aaa{ int i; Aaa(){i=-1; } Aaa(int a){ i = a;} Aaa(double d){Aaa((int)d);} } 是否出错：是 出错原因（如果出错）：构造器调用构造器不能直接用名 class Aaa{ int i; Aaa(){i=-1; } Aaa(int a){ i = a;} Aaa(double d){this((int)d);} }

（2） class Aaa{ int i; Aaa(){i=-1; } Aaa(int a){ i = a;} Aaa(double a){int b=(int)a;this(b);} } 是否出错：是 出错原因（如果出错）：this放第一行 class Aaa{ int i; Aaa(){i=-1; } Aaa(int a){ i = a;} Aaa(double a){this((int)a);} } （3） class Aaa{ int i; Aaa(int a){ i = a;} } class Bbb extends Aaa{ Bbb(){ } } 是否出错：是 出错原因（如果出错）：父类没有无参构造，子类中药通过super调用父类构造class Aaa{ int i; Aaa(int a){ i = a;} } class Bbb extends Aaa{ Bbb(int a) { super(a); } } （4） class Aaa{ private int i;

机械设计练习题

第三章(1) 一般参数的闭式硬齿面齿轮传动的主要失效形式是。 A 齿面点蚀 B 轮齿折断 C 齿面磨损 D 齿面胶合 (2) 在闭式齿轮传动中，高速重载齿轮传动的主要失效形式是。 A 轮齿疲劳折断 B 齿面疲劳点蚀 C 齿面胶合 D 齿面磨粒磨损 E 齿面塑性变形 (3) 对齿轮轮齿材料性能的基本要求是。 A 齿面要硬，齿心要韧 B 齿面要硬，齿心要脆 C 齿面要软，齿心要脆 D 齿面要软，齿心要韧 (4) 斜齿轮和锥齿轮强度计算中的齿形系数和应力修正系数按查图。 A 实际齿数 B 当量齿数 C 不发生根切的最少齿数 (5) 一减速齿轮传动，主动轮1用45钢调质，从动轮2用45钢正火，则它们齿面接触应力的关系是。 A σH1 < σH2 B σH1 = σH2 C σH1 > σH2 D 可能相同，也可能不同 （6) 一对标准圆柱齿轮传动，已知z1＝20，z2＝50，则它们的齿根弯曲应力是。 A σF1 < σF2 B σF1 = σF2 C σF1 > σF2 D 可能相同，也可能不同 (7) 提高齿轮的抗点蚀能力，不能采用的方法。 A 采用闭式传动 B 加大传动的中心距 C 提高齿面的硬度 D 减小齿轮的齿数，增大齿轮的模数 (8) 在齿轮传动中，为了减小动载荷系数KV，可采取的措施是。 A 提高齿轮的制造精度 B 减小齿轮的平均单位载荷 C 减小外加载荷的变化幅度 D 降低齿轮的圆周速度 （9) 直齿锥齿轮传动的强度计算方法是以的当量圆柱齿轮为计算基础。 A 小端 B 大端 C 齿宽中点处 (10) 直齿圆柱齿轮设计中，若中心距不变，增大模数m，则可以。 A 提高齿面的接触强度 B 提高轮齿的弯曲强度 C 弯曲与接触强度均不变 D 弯曲与接触强度均可提高 (11) 一对相互啮合的圆柱齿轮，在确定轮齿宽度时，通常使小齿轮比大齿轮宽5～10mm，其主要原因是。 A 为使小齿轮强度比大齿轮大些 B 为使两齿轮强度大致相等 C 为传动平稳，提高效率 D 为了便于安装，保证接触线承载宽度 （12) 闭式软齿面齿轮传动的设计方法为。 A 按齿根弯曲疲劳强度设计，然后校核齿面接触疲劳强度 B 按齿面接触疲劳强度设计，然后校核齿根弯曲疲劳强度 C 按齿面磨损进行设计 D 按齿面胶合进行设计 (13) 下列措施中，不利于提高齿轮轮齿抗疲劳折断能力。 A 减轻加工损伤 B 减小齿面粗糙度值 C 表面强化处理 D 减小齿根过渡圆角半径 (1) 钢制齿轮，由于渗碳淬火后热处理变形大，一般须进过加工。 （2) 对于开式齿轮传动，虽然主要实效形式是，但目前尚无成熟可靠的计算方法，目前仅以作为设计准则。这时影响齿轮强度的主要几何参数是。 (3) 闭式软齿面齿轮传动中，齿面疲劳点蚀通常出现在处，提高材料可以增强轮齿抗点蚀的能力。 (4) 在齿轮传动中，若一对齿轮采用软齿面，则小齿轮材料的硬度比大齿轮的硬度高HBS。 (5) 在斜齿圆柱齿轮设计中，应取模数为标准值，而直齿锥齿轮设计中，应取模数

机械设计齿轮习题与参考答案

习题及参考答案 一、单项选择题（从给出的A、B、C、D中选一个答案） 1 一般开式齿轮传动的主要失效形式是C。 A. 齿面胶合 B. 齿面疲劳点蚀 C. 齿面磨损或轮齿疲劳折断 D. 轮齿塑性变形 2 高速重载齿轮传动，当润滑不良时，最可能出现的失效形式是A。 A. 齿面胶合 B. 齿面疲劳点蚀 C. 齿面磨损 D. 轮齿疲劳折断 3 45钢齿轮，经调质处理后其硬度值约为B。 A. 45～50 HRC B. 220～270 HBS C. 160～180 HBS D. 320～350 HBS 4 齿面硬度为56～62HRC的合金钢齿轮的加工工艺过程为C。 A. 齿坯加工→淬火→磨齿→滚齿 B. 齿坯加工→淬火→滚齿→磨齿 C. 齿坯加工→滚齿→渗碳淬火→磨齿 D. 齿坯加工→滚齿→磨齿→淬火 5齿轮采用渗碳淬火的热处理方法，则齿轮材料只可能是D。 A. 45钢 B. ZG340-640 C. 20Cr D. 20CrMnTi 6齿轮传动中齿面的非扩展性点蚀一般出现在A。 A. 跑合阶段 B. 稳定性磨损阶段 C. 剧烈磨损阶段 D. 齿面磨料磨损阶段 7 对于开式齿轮传动，在工程设计中，一般D。 A. 按接触强度设计齿轮尺寸，再校核弯曲强度 B. 按弯曲强度设计齿轮尺寸，再校核接触强度 C. 只需按接触强度设计 D. 只需按弯曲强度设计 8 一对标准直齿圆柱齿轮，若z1=18，z2=72，则这对齿轮的弯曲应力A。 A. σF1＞σF2 B. σF1＜σF2 C. σF1=σF2 D. σ≤σF2 F1 9 对于齿面硬度≤350HBS的闭式钢制齿轮传动，其主要失效形式为

实验11-类继承与接口(三)实验报告

浙江大学城市学院实验报告 课程名称：面向对象程序设计 实验项目名称：类继承与接口（三） 学生姓名专业：学号： 实验地点：实验日期：年月日 【实验目的】 1．巩固Java类继承的相关知识 2．理解对象上转型技术的优点和用途。 3．掌握接口的特点 4．接口与抽象类的异同之处 【实验内容】 一、类继承相关知识强化 1. 执行以下程序，给出执行Bbb的结果，并说明指出类Bbb的this.i与super.i的含义（即它们都对应哪个变量）。 class Aaa{ int i; Aaa(int a){ i = a;} } class Bbb extends Aaa{ int j,k; Bbb(int i){ super(i); j = this.i; k = super.i; } public static void main(String[] args){ Bbb b = new Bbb(18); System.out.println(b.j +"\t" + b.k); } } 执行Bbb的结果:

this.i与super.i的含义（即它们都对应哪个类中定义的变量）: 都对应Aaa类中的变量。 2．接着上面例子，将类Bbb改写为以下代码，请写出程序运行结果，并说明这个例子与上面例子的区别。 class Bbb extends Aaa{ int i= -1,j= -1,k= -1; //比上面例子增加一个实例变量i; Bbb(int i){ super(i); j = this.i; //本语句含义是：Bbb类中的变量i的值赋给j k = super.i; //本语句含义是：访问Aaa类中的变量i并将值赋给k } public static void main(String[] args){ Bbb b = new Bbb(18); System.out.println(b.j +"\t" + b.k); } } 执行Bbb的结果: -1 18 这个例子与上面例子的区别: 在Bbb类中也定义了变量i，将Bbb的直接超类Aaa中的变量i给覆盖掉了。 3.对以下程序，给出执行Bbb的结果，并分析Bbb中main方法中a.show(1), b.show(1), c.show(1)的结果。 class Aaa{ void show(){ System.out.println("Aaa中定义的show()"); } void show(int i){ System.out.println("Aaa中定义的show(int i)"); } } class Bbb extends Aaa{ void show(){ System.out.println("Bbb中定义的show()"); }

齿轮机构及其设计练习题

第十章齿轮机构及其设计 一、填空题 1.一对渐开线齿廓啮合传动时，它们的接触点在____________线上，它的理论啮合线长度为____________。 2.渐开线齿廓上任一点的压力角是指___________，渐开线齿廓上任一点的法线与_________相切。 3.齿轮分度圆是指______________的圆，节圆是指___________的圆。 4.当采用_______________法切制渐开线齿轮齿廓时，可能会产生跟切。 5.一对渐开线斜齿圆柱齿轮的正确啮合条件是___________，___________，________________。 6.一个锥顶角δ=25°，z=16的直齿圆锥齿轮，它的当量齿数z v=____________(写出公式和结果)。 7．一对渐开线直齿圆柱齿轮的重叠系数ε与齿轮的有关，而与齿轮的__________无关。 8．一对渐开线直齿圆锥齿轮的正确啮合条件是、。 9．釆用法切制渐开线齿廓时发生根切的原因是。 10．渐开线齿廓能保证以定传动比传动，其传动比不仅与半径成反比，也与其半径成反比，还与其半径成反比。 11．一对渐开线齿轮正确啮合的条件是相等，亦即两齿轮的 和分别相等。 12．一对蜗杆蜗轮正确啮合条件是。 13．一对斜齿圆柱齿轮传动的重合度由、两部分组成。14．渐开线上各处的压力角等。 15．生产上对齿轮传动的基本要求是。 16．渐开线上任一点的法线与基圆，渐开线上各点的曲率半径是的。 17．按标准中心距安装的渐开线直齿圆柱标准齿轮，节圆与重合，啮合角在数值上等于上的压力角。 18．渐开线斜齿圆柱齿轮的标准参数在面上；在尺寸计算时应按面参数代入直齿轮的计算公式。 19．基本参数相同的正变位齿轮与标准齿轮比较，其分度圆齿厚，齿槽宽，齿顶高，齿根高。 20．决定单个渐开线标准直齿圆柱齿轮几何尺寸的五个基本参数是，其中参数是标准值。 21．用极坐标表示的渐开线方程式为：和。 22．渐开线齿轮上基圆的压力角是，分度圆压力角是或。 23．一斜齿轮法面模数m n=3mm,分度圆螺旋角β=15度，其端面模数m t= 。 24．在设计直齿圆柱齿轮机构时，首先考虑的传动类型是,其次是，在不得已的情况下如，只能选择。25．用同一把刀具加工m,z, 均相同的标准齿轮和变位齿轮，它们的分度圆，基圆和齿距均。

齿轮传动习题(含答案)

齿轮传动 一、选择题 7-1．对于软齿面的闭式齿轮传动，其主要失效形式为________。 A ．轮齿疲劳折断 B ．齿面磨损 C ．齿面疲劳点蚀 D ．齿面胶合 7-2．一般开式齿轮传动的主要失效形式是________。 A ．轮齿疲劳折断 B ．齿面磨损 C ．齿面疲劳点蚀 D ．齿面胶合 7-3．高速重载齿轮传动，当润滑不良时，最可能出现的失效形式为________。 A ．轮齿疲劳折断 B ．齿面磨损 C ．齿面疲劳点蚀 D ．齿面胶合 7-4．齿轮的齿面疲劳点蚀经常发生在________。 A ．靠近齿顶处 B ．靠近齿根处 C ．节线附近的齿顶一侧 D ．节线附近的齿根一侧 7-5．一对45钢调质齿轮，过早的发生了齿面点蚀，更换时可用________的齿轮代替。 A ．40Cr 调质 B ．适当增大模数m C ．45钢齿面高频淬火 D ．铸钢ZG310-570 7-6．设计一对软齿面减速齿轮传动，从等强度要求出发，选择硬度时应使________。 A ．大、小齿轮的硬度相等 B ．小齿轮硬度高于大齿轮硬度 C ．大齿轮硬度高于小齿轮硬度 D ．小齿轮用硬齿面，大齿轮用软齿面 7-7．一对齿轮传动，小轮材为40Cr ；大轮材料为45钢，则它们的接触应力________。 A ．1H σ=2H σ B. 1H σ＜2H σ C ．1H σ＞2H σ D ．1H σ≤2H σ 7-8．其他条件不变，将齿轮传动的载荷增为原来的4倍，其齿面接触应力________。 A ．不变 B ．增为原应力的2倍 C ．增为原应力的4倍 D ．增为原应力的16倍 7-9．一对标准直齿圆柱齿轮，z l = 21，z 2 = 63，则这对齿轮的弯曲应力________。 A. 1F σ＞2F σ B. 1F σ＜2F σ C. 1F σ =2F σ D. 1F σ≤2F σ 7-10．对于开式齿轮传动，在工程设计中，一般________。 A ．先按接触强度设计，再校核弯曲强度 B ．只需按接触强度设计 C ．先按弯曲强度设计，再校核接触强度 D ．只需按弯曲强度设计。 7-7．设计闭式软齿面直齿轮传动时，选择小齿轮齿数z 1的原则是________。

齿轮机构与其设计(全部习题参考答案)

第5章 齿轮机构及其设计 5.1 已知一对外啮合正常齿标准直齿圆柱齿轮123, 1941m mm z ===，z ，试计算这对齿轮的分度圆直径、齿顶高、齿根高、顶隙、中心距、齿顶圆直径、齿根圆直径，基圆直径、齿距、齿厚和齿槽宽。 解： ()1212121219357,413123133,1.253 3.753.7530.75,0.55712390572363, 12323129572 3.7549.5,1232 3.75115.557cos2053.563,123cos20a f a a f f b b d mm d mm h mm h mm c mm a mm d mm d mm d mm d mm d mm d =?==?==?==?====?+==+?==+?==?==?==??==??=－－－115.58339.425mm p ==mm π 5.2 已知一正常齿标准直齿圆柱齿轮20,540m mm z α=?==，，试分别求出分度圆、基圆、齿顶圆上渐开线齿廓的曲率半径和压力角。 解：分度圆上：0.554010020 sin 100sin 2034.20r mm r mm αρα=??====?= 基圆上： 100c o s 2093.97 00 b b b r r c o s m m ααρ=?=??==? = 齿顶圆上：1 1005105cos (/ )26.5 sin 105sin26.546.85a a b a a a a r mm r r r mm αρα-=+=====?= 5.4 在某项技术革新中，需要采用一对齿轮传动，其中心距144a mm =，传动比2i =。现在库 房中存有四种现成的齿轮，已知它们都是国产的正常齿渐开线标准齿轮，压力角都是20°，这四种齿轮的齿数z 和齿顶圆直径a d 分别为： 1a12a23a34a424,=104mm;47,196mm; 48,250mm; 48,200mm. z d z d z d z d ======= 试分析能否从这四种齿轮中选出符合要求的一对齿轮来。 解：根据传动比要求，显然齿轮2不合适。又

Java继承与多态实验报告

西安邮电大学 （计算机学院） 课内实验报告 实验名称：继承与多态 专业名称：计算机科学与技术 班级：计科1405班 学生姓名：高宏伟 学号：04141152 指导教师：刘霞林 实验日期：2016.10.13

一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性，掌握变量的隐藏、方法的覆盖、重载，掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性（成员变量、成员方法、成员变量隐藏）的程序。 2.编写体现类的多态性（成员方法重载）的程序。 3.编写体现类的多态性（构造方法重载）的程序。 4.编写使用接口的程序。 三、实验内容 （一）类的继承 1.创建公共类Student. （1）编写程序文件Student.java，源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } （2）编译Student.java，产生类文件Student.class。 2．创建继承的类Undergraduate

（1）程序功能：通过Student 类产生子类undergraduate，其不仅具有父类的成员变量name（）、number（学号），还定义了新成员变量academy（学院）、department （系）。在程序中调用父类的print 方法。 （2）编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.wendangku.net/doc/b414145764.html,+", "+u.number+", "+u.academy+", "+u.department); } } （3）编译并运行程序 注意：公共类Student 与undergraduate 类要在同一文件夹（路径）。 (二)方法的重载 （1）程序功能：对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 （2）编写Sort.java 文件，源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a

实验二 继承与接口实验

实验二继承与接口 一、实验目的 1.掌握类的继承机制。 2.熟悉类中成员变量和方法的访问控制。 3.掌握接口与包的使用，熟悉方法的多态性。 二、实验内容 1.定义父类及子类，在子类中重写父类的方法 2.练习接口与包的使用 三、.实验步骤与要求 第1题继承 编写一个Java应用程序，除了主类外，该程序中还有4个类：People, ChinaPeople, AmericanPeople 和BeijingPeople类。此四个类的继承关系如下图所示： 要求ChinaPeople，American类均重写其父类People类的speakHello, averageHeight, averageWeight方法，BeijingPeople类重写其父类ChinaPeople类的speakHello, averageHeight, averageWeight方法。 源代码： package people; class people { protected double height ; protected double weight ;

public void speakHello() //问候语的函数 { System.out.println("hello"); } public void averageHeight()//人们的平均身高{ height=170; System.out.println(+height); } public void averageWeight()//人们的平均体重{ weight=120; System.out.println(+weight); } } class Chinapeople extends people { public void speakHello() { System.out.println("你好"); } public void averageHeight() { height=172; System.out.println(+height); } public void averageWeight() { weight=115; System.out.println(+weight); } public void chinaGongfu()//中国功夫的方法 { System.out.println("中国功夫"); } } class Americanpeople extends people { public void speakHello() { System.out.println("hello"); } public void averageHeight()

机械设计基础齿轮传动设计例题

例1 设计用于带式输送机传动装置的闭式单级直齿圆柱齿轮传动。传递功率P=2.7kW ，小齿轮转速n 1=350r/min ，传动比i=3.57。输送机工作平稳，单向运转，两班工作制，齿轮对称布置，预期寿命10年，每年工作300天。 解：1. 选择齿轮精度等级、材料、齿数 1）带式输送机属于一般机械，且转速不高，故初选择8级精度。 2）因载荷平稳，传递功率较小，可采用软齿面齿轮。参考表5-6，小齿轮选用45钢调质处理，齿面硬度220~250HBS ，σHLim1=595MPa ， σFE1=230MPa ；大齿轮选用 45钢正火处理，齿面硬度170~200HBS ， σ HLim2=520MPa ，σFE2=200MPa 。 3）初选小齿轮齿数z 1=24，则z 2=iz 1=3.57×24=85.68，取z 2=87。故实际传动比i=z 2/z 1=87/24=3.62，与要求的传动比3.57的误差小于3%。 对于齿面硬度小于350 HBS 的闭式软齿面齿轮传动，应按齿面接触强度设计，再按齿根弯曲强度校核。 2. 按齿面接触强度设计 设计公式5-48 1d ≥1）查表5-8，原动机为电动机，工作机械是输送机，且工作平稳，取载荷系数K=1.2。 2）小齿轮传递的转矩 11 2.7 9550955073.671 350 P N m n T =?= ?= ? 3）查表5-13，齿轮为软齿面，对称布置，取齿宽系数φd =1。

4）查表5-10，两齿轮材料都是锻钢，故取弹性系数Z E =189.8 MPa 1/2。 5）两齿轮为标准齿轮，且正确安装，故节点区域系数Z H =2.5，取重合度系数Z ε=0.9。 6）计算许用接触应力 N W X HLim H H Z Z Z S σσ??=?? ①应力循环次数 小齿轮N 1=60n 1jL h =60×350×1×(2×8×300×10)=10.08×108 大齿轮N 2= N 1/i=10.08×108/3.62=2.78×108 ②据齿轮材料、热处理以及N 1、N 2，查接触疲劳寿命系数图表，不允许出现点蚀，得接触疲劳寿命系数Z N1=1，Z N2=1，两齿轮均为软齿面故ZW=1，ZX=1。 ③一般传动，取安全系数S H =1.1。 ④计算许用接触应力 11115951540.91.1N W X HLim H H MPa Z Z Z S σσ???===??2222 5201427.71.1N W X HLim H H MPa Z Z Z S σσ???===?? 取小值[σ H2]代入计算。 7）计算 1 81.56mm d 8）计算主要尺寸 ①模数m=d 1/z 1=81.56/24=3.4mm 查表5-2，取标准值m=4mm 。 ②分度圆直径d 1=mz 1=4×24=96mm

机械设计制造基础 第七章 练习题与答案

第七章练习题1.单项选择

1-1 重要的轴类零件的毛坯通常应选择（ ①铸件②锻件 ③棒料④管材 ）。 1-2 普通机床床身的毛坯多采用（ ①铸件②锻件③焊接件 ）。 ④冲压件 1-3 基准重合原则是指使用被加工表面的（）基准作为精基准。 ②设计②工序③测量④装配 1-4 箱体类零件常采用（）作为统一精基准。 ①一面一孔②一面两孔③两面一孔④两面两孔 1-5

②增环的上偏差之和减去减环的下偏差之和 ③增环的下偏差之和减去减环的上偏差之和 ④增环的下偏差之和减去减环的下偏差之和 1-12 （ 直线尺寸链采用概率算法时，若各组成环均接近正态分布，则封闭环的公差等于）。 ①各组成环中公差最大值 ③各组成环公差之和②各组成环中公差的最小值 ④各组成环公差平方和的平方根 1-13 用近似概率算法计算封闭环公差时，k值常取为（ ①0.6～0.8②0.8～1③1～1.2④1.2～1.4 ）。1-14

①上一工序尺寸公差 ②本工序尺寸公差③上一工序表面粗糙度和表面缺陷层厚度 ④上一工序留下的形位误差 2-8 CAPP系统按其工作原理可划分为（）和综合式。 ①全自动式②半自动式③派生式④创成式 2-9目前CAPP系统的零件信息输入方式主要有（ ）。 息①成组编码法②形面描述法③图形识别法④从CAD系统直接获取零件信2-10 采用决策树进行决策的优点是（）。 ①易于理解②易于编程③易于修改④易于扩展 2-11

3-12 3-13 3-14 3-15 工艺尺寸链组成环的尺寸一般是由加工直接得到的。采用CAPP有利于实现工艺过程设计的优化和标准化。派生式CAPP系统具有较浓厚的企业色彩。 创成式CAPP系统以成组技术为基础。 3-16在CAPP专家系统中广泛采用产生式规则表达知识。 3-17在CAPP专家系统中通常采用正向推理的控制策略。 3-18 在工艺成本中可变费用是与年产量无关的费用。 4.分析计算题 4-1试选择习图4-1示三个零件的粗﹑精基准。其中a）齿轮，m=2，Z=37，毛坯为热轧棒料；b）液压油缸，毛坯为铸铁件，孔已铸出。c）飞轮，毛坯为铸件。均为批量生产。图中除了有不加工符号的表面外，均为加工表面。

实验6继承与接口

山西大学计算机与信息技术学院 实验报告 姓名学号专业班级 课程名称 Java实验实验日期成绩指导教师批改日期实验名称实验 6 继承与接口 [实验目的] 1、掌握java 继承中父类及其子类的定义方法。 2、掌握子类重写父类同名方法的方法。 3、掌握接口的用法。 (1) 学习如何定义接口 ; (2) 掌握接口的实现方式 ; (3) 使用实现了接口的类 ; (4) 理解接口与抽象类的区别。 [实验要求] 1、复习理论教学中所学的内容。 2、认真进行实验预习，查阅参考书，书写源程序，书写实验预习报告。 3、认真总结实验并书写实验报告。 [实验内容] 1、类的继承性练习 (1) 程序源代码如下。 public class Student{ protected String xm; //姓名，具有保护修饰符的成员变量 protected int xh;//学号 void setdata(String xm,int xh){ //设置数据的方法 this.xm=xm; this.xh=xh; } public void print(){ //输出数据的方法 System.out.println(xm+", "+xh); } } class TestStudent{//测试类 public static void main(String[] args) { Student s = new Student(); s.setdata("小红", 2010242555); s.print(); }

} (2) 编译源并运行程序。贴图如下 图一 （二）创建将被继承的类 (1) 程序功能：通过Student类产生子类CollegeStudent，其不仅具有父类的成员变量xm（姓名）、xh（学号），还定义了新成员变量xy（学院）、bj（bj）。在程序中调用了父类的print 方法，同时可以看出子类也具有该方法。 程序代码： public class CollegeStudent extends Student{ protected String xy; protected int bj; void setdata(String xm,int xh,String xy,int bj){ super.setdata(xm, xh); this.xy = xy; this.bj = bj; } public void print() { super.print(); System.out.print("学院："+xy+"班级："+bj); } } class TestCollegeStudent{ public static void main(String[] args) { CollegeStudent cs = new CollegeStudent(); cs.setdata("小蓝", 2010242555, "计算机学院", 1); cs.print(); } } 运行结果贴图: