例子问题
例子问题1:类的设计
下面哪一行表示数据成员?
1.类动物
2.{
3.公众:
4.动物();
5.空白fetch ();
6.私人:
7.char骨;
8.}
第5行
6号线
第7行
3号线
1号线
第7行
数据成员是在类中创建的变量,通常在private:标签下找到,因为数据成员通常保存在该类的本地。它可以与成员函数区分开来,因为它没有括号()。
例子问题1:类的设计
以下哪一种操作允许您在类定义之外定义函数func1() ?
1.类学校
2.{
3.公众:
4.学校();
5.空白func1 ();
6.私人:
7.字符类;
8.}
->
=
::
;
,
::
func1()的函数模板已经在类定义中定义,但是函数的实现还没有定义。为了指定函数的功能,必须说明
类名::functionname ()
{
}
或者,在我们的例子中,
学校::function1 ()
{
//函数定义在这里
}
问题281:计算机科学
为一个名为Dog的类设计一个外壳,它有3个属性:
- 狗有尾巴吗?
- 这条狗是纯种的吗?
- 狗的一系列明确特征的列表
狗类{
布尔尾巴;
布尔纯种;
列表功能;
}
狗类{
布尔尾巴;
布尔纯种;
}
狗类{
布尔纯种;
列表功能;
}
狗类{
}
狗类{
布尔尾巴;
布尔纯种;
列表功能;
}
在提示中,任何“是”或“否”的问题都应该作为布尔值(即尾,纯种)来处理。任何列表都应该具有列表的类型和名称。这只是一个shell,因此不应该声明变量。
例子问题1:面向对象程序设计
设计一个将用于现有应用程序的类super。类应该扩展父类Man。这个类应该定义衣服、肤色、头发颜色、眼睛颜色、好或坏、是否拥有力量,以及一系列性格特征。类Man支持doGood方法的实现。下面是doGood的方法存根:
doGood(Boolean good);
您的类将需要支持doGood的实现。
选择最好的答案。
类超级英雄{
列表的衣服;
字符串skinColor;
字符串hairColor;
字符串eyeColor;
布尔好;
布尔的权力;
personalityTraits列表;
doGood(布尔值){
String result = "No, do bad!";
If (good == true) {
result =“是的,做得好!”
}
返回结果;
}
}
职业super扩展了Man {
列表的衣服;
字符串skinColor;
字符串hairColor;
字符串eyeColor;
布尔好;
布尔的权力;
personalityTraits列表;
doGood(布尔值){
String result = "No, do bad!";
If (good == true) {
result =“是的,做得好!”
}
返回结果;
}
}
职业super扩展了Man {
列表的衣服;
字符串skinColor;
字符串hairColor;
字符串eyeColor;
doGood(布尔值){
String result = "No, do bad!";
If (good == true) {
result =“是的,做得好!”
}
返回结果;
}
}
职业super扩展了Man {
列表的衣服;
字符串skinColor;
字符串hairColor;
字符串eyeColor;
布尔好;
布尔的权力;
personalityTraits列表;
doGood(布尔值){
}
}
职业super扩展了Man {
列表的衣服;
字符串skinColor;
字符串hairColor;
字符串eyeColor;
布尔好;
布尔的权力;
personalityTraits列表;
doGood(布尔值){
String result = "No, do bad!";
If (good == true) {
result =“是的,做得好!”
}
返回结果;
}
}
这是正确的答案,因为这个类扩展了超级类Man。它还列出了在提示符中定义的所有属性。除了列出所有属性之外,该类还定义了doGood方法的实现,提示符声明该方法由父类定义。其中一个答案选项简单地定义了方法的存根。提示清楚地说明要支持方法的实现。
例子问题2:类的设计
代码示例上面的字母是用于解释的。
用编程语言Swift (iOS)设计一个类来最好地解决这个问题:
我有一个狗公司。我的公司在工作日、周末和节假日收留狗狗。我想让我的网站显示我们什么时候开放,我们还有多少个景点,以及登机的价格。
(C)
类DogBoarding {
内部变量open: Bool
内部变量spotsLeft: Int
内部var价格:双倍
init (open: Bool, spotsLeft: Int, price: Double) {
自我。开放=开放
自我。spotsLeft = spotsLeft
自我。价格=价格
}
内部func getPrice() {
返回self.price
}
内部func getSpotsLeft() {
返回self.spotsLeft
}
内部func isOpen() {
返回self.open
}
}
(B)
类DogBoarding {
private var open: Bool类型
私有变量spotsLeft: Int
私人var价格:双倍
init (open: Bool, spotsLeft: Int, price: Double) {
自我。开放=开放
自我。spotsLeft = spotsLeft
自我。价格=价格
}
private func getPrice() -> Double {
返回self.price
}
私有func getSpotsLeft() -> Int {
返回self.spotsLeft
}
private func isOpen() -> Bool {
返回self.open
}
}
(一)
类DogBoarding {
内部变量open: Bool
内部变量spotsLeft: Int
内部var价格:双倍
init (open: Bool, spotsLeft: Int, price: Double) {
自我。开放=开放
自我。spotsLeft = spotsLeft
自我。价格=价格
}
内部func getPrice() -> Double {
返回self.price
}
内部func getSpotsLeft() -> Int {
返回self.spotsLeft
}
内部func isOpen() -> Bool {
返回self.open
}
}
(D)
类DogBoarding {
init () {
}
内部func getPrice() -> Double {
返回0.0
}
内部func getSpotsLeft() -> Int {
返回0
}
内部func isOpen() -> Bool {
返回假
}
}
(一)
类DogBoarding {
内部变量open: Bool
内部变量spotsLeft: Int
内部var价格:双倍
init (open: Bool, spotsLeft: Int, price: Double) {
自我。开放=开放
自我。spotsLeft = spotsLeft
自我。价格=价格
}
内部func getPrice() -> Double {
返回self.price
}
内部func getSpotsLeft() -> Int {
返回self.spotsLeft
}
内部func isOpen() -> Bool {
返回self.open
}
}
编码样本(A)是正确答案。这是由于类的完整性。类有打开,spotsLeft和价格的getter,这是用户在提示中要求能够在网站上显示它们。
编码样本(B)是不正确的,因为所有内容都设置为private。如果getter函数是私有的,那么用户就不能在网站上使用它们。
编码示例(C)是不正确的,因为函数上没有返回类型。在Swift中,函数必须有返回类型。
编码样本(D)是不正确的,因为它只是类的外壳,并没有实际执行任何功能。
例子问题1:面向对象程序设计
使用静态变量
考虑以下Java代码:
公共类员工
{
静态int nextID = 1;
字符串名称;
int employeeID;
员工(String n) {
name = n;
employeeID = nextID;
nextID + +;
}
公共字符串getName () {
返回名称;
}
公共int getID () {
返回employeeID;
}
public static void main(字符串[]参数)
{
雇员emp3 =新雇员(“Kate”);
雇员emp1 =新雇员("John");
雇员emp2 =新雇员(“Sandy”);
System.out.println(emp1.getName() + " ID: " + emp1.getID());
System.out.println(emp3.getName() + " ID: " + emp3.getID());
}
}
控制台的输出是什么?
约翰ID: 1
桑迪ID: 2
约翰ID: 2
凯特ID: 1
约翰ID: 1
凯特ID: 2
约翰ID: 1
桑迪ID: 1
约翰ID: 2
凯特ID: 1
静态变量与类关联,而不是与该特定类的对象关联。由于我们使用的是静态类变量“nextID”,并在创建新员工时将其赋值给employeeID,然后增加它,因此为整个类更新类变量。
在我们的代码中,我们首先创建了emp3。这意味着创建Kate时使用的employeeID等于nextID的当前值(在本例中为1)。之后,nextID值加1。下一个emp1是用John的名字和一个等于nextID当前值的employeeID创建的(由于创建Kate时增加了值,所以变成了2)。最后,用Sandy的名称和等于nextID当前值(在代码中此时)的employeeID创建emp2。这意味着Sandy的employeID值为3。
因此在第一个系统中。当我们打印emp1时,我们得到:约翰ID: 2
在第二个系统中。当我们打印emp3时,我们得到:
凯特ID: 1
例子问题1:面向对象程序设计
下面代码片段中的类Car和类TwoDoor之间的关系是什么?
class TwoDoor扩展Car {
}
TwoDoor实现汽车
Car是TwoDoor的超类
汽车实现TwoDoor
TwoDoor是Car的超类
Car是TwoDoor的超类
Car是TwoDoor的超类。因为TwoDoor类扩展了Car类,所以TwoDoor可以通过调用super来使用Car中的方法和变量。
提到实现的答案是不正确的,因为实现引用接口。对于TwoDoor实现car,代码看起来像这样:
类TwoDoor实现Car {
}
例子问题1:面向对象程序设计
扩展和实现之间的区别是什么?
您可以扩展接口并实现一个子类。可以根据需要频繁地实现子类,但只能扩展单个接口。
Extend指的是超类和子类之间的关系。实现指的是接口。您可以只实现一个接口,但可以实现多个类。
Extend指的是超类和子类之间的关系。实现指的是接口。您只能扩展一个类,但可以实现多个接口。
Extend指的是超类和子类之间的关系。实现指的是接口。您只能扩展一个类,但可以实现多个接口。
默认情况下,所有类都是Object类的扩展,因此都是扩展单个类。由于这个概念,实现时采用了只能扩展单个类的概念。因此,它们允许您实现无限数量的类。
例子问题1:类的设计
描述重载方法和重写方法之间的区别。
重载方法和重载方法都采用相同的方法,但重载方法返回不同的参数。
重写是相同的方法名和不同的参数。重载就是重写定义的主体。
重载是相同的方法名和不同的参数。重写就是重写定义的主体。
重载是相同的方法名,相同的参数,但参数的名称不同。重写是在同一个类中调用同一个方法。
重载是相同的方法名和不同的参数。重写就是重写定义的主体。
当您覆盖一个方法时,您通过用子类中的方法遮蔽父子类中的方法,从而完全替换了该方法的功能。
重载一个方法只是允许您让相同的方法名具有多种含义或用途。一个例子是'+'操作符。在Java等语言中,可以使用'+'来附加字符串、添加双精度值或添加整数。
例子问题2:类的设计
以下哪一个头语句允许您在使用cout时省略使用std:: ?
# include <标准>
您不需要头语句。
# include < iostream >
# include < cmath >
使用名称空间性病;
使用名称空间性病;
您必须将using命名空间std;在文件的顶部,以避免每次使用cout和cin时都必须键入std::。