实验五 方法的重载和静态成员

F f4(4,12);
cout<<f3<<endl;
cout<<F::maxcd(9,6)<<endl;
cout<<f3+f4<<endl;
cout<<f3*f2<<endl;
return 0;
}
常量和临时值必须要用const
2.临时对象
如果对象变量只用到一次，就直接用匿名对象，编译器可以对匿名对象进行优化，减少对象的创建 ，提高效率。
bool age;
double salary;
date birth;
Person(){cout<<"创建Person对象在"<<this<<endl;}
~Person(){cout<<"释放Person对象在"<<this<<endl;}
};
bool F::operator!()const
{
return (n==0); //或者return !n;
}
int main()
{
F f1; //输出0/1
F f2(3); //3传递给第一个参数，结果是3/1
F f3(6,12); //结果是6/12
{
if(d==0) throw "分母不能为0";
if(d<0) this->d=-d,F::n=-n;
reduce();
cout<<"F("<<n<<'/'<<d<<")\n";

实验五静态路由配置一、实习背景：假设有如下一个网络，要求通过静态路由方式实现远端网络“172.16.1.*”和“172.16.3.*”的互连。

二、实习目的：1．理解静态路由的作用；2．掌握静态路由和缺省路由的配置方法，并通过静态路由方式实现网络的连通性。

三、实习内容与实习过程：网络拓朴如下：参考配置命令：Red-Giant(config)#hostname A（注：将主机名配置为“A”）A(config)#interface serial 0A(config-if)#ip address 172.16.2.2 255.255.255.0注：设置路由器serial 0 的IP 地址为172.16.2.2，对应的子网掩码为255.255.255.0A(config)#interface fastethernet 0A(config-if)#ip address 172.16.3.1 255.255.255.0注：设置路由器fastethernet 0 的IP 地址为172.16.3.1，对应的子网掩码为255.255.255.0A(config)#interface serial 0A(config-if)clock rate 64000注：设置接口物理时钟频率为64KbpsA(config)#ip route 172.16.1.0 255.255.255.0 172.16.2.1 注：配置静态路由或：A(config)#ip route 172.16.1.0 255.255.255.0 serial 0show ip int briefshow ip route四、实习要求：各路由器应该看到全网路由。

主机172.16.3.2 能够访问主机172.16.1.2。

五、思考题：1．静态路由和缺省路由有何区别？2．如果只在路由器A上配置了静态路由，而在路由器B上没有配置任何路由，此时主机A和主机B是否能互相ping通？。

//输出true //输出false //输出true //输出true
}
构造方法的重载
class Student{ public int id = 2; public string name = "Tom"; 含有三个参数的构造方法 public int age = 21; public Student(int id, string name, int age) { this.id=id; =name; this.age=age; } 含有二个参数的构造方法 public Student(int id, string name) { this.id=id; //以下是主方法中的操作 =name; public static void main(String[]args) } { public Student(){} Student stu1=new Student(); } Student stu2=new Student(103,"Mike"); Student stu3=new Student(107,"Mary",18); 无参构造方法 }
方法的重载
• 方法名相同，但方法中参数的个数、类型 及顺序不同，即为重载 • 方法的返回值不参与重载。如下：
void fun(int x); int fun(int x); void fun(int x); int fun(int x, int y);
不是重载，编译报错
是重载，可以使用 是重载，可以使用
void fun(int x, double y); void fun(double y, int x);
构造方法（I）
• 完成对类实例对象的初始化工作。一般 （通过方法的参数）用来对类的成员变量 进行初始化操作。有以下几点特征：

成员方法的引用与使用成员方法的重载成员方法是面向对象编程中的重要概念，可以用来实现对象的行为和功能。

在Java中，成员方法分为实例方法和静态方法两种。

实例方法属于对象，只能由对象进行调用；静态方法属于类，可以通过类名直接调用。

成员方法引用是一种语法糖，可以简化函数式接口的Lambda表达式。

它允许我们直接引用现有类的方法，而不需要再声明一个Lambda表达式来调用方法。

成员方法引用使用::符号来表示，格式为类名::方法名。

首先，需要创建一个类，并在类中定义一个成员方法。

接下来，可以使用成员方法引用来引用该方法。

例如，假设有一个Animal类，其中定义了一个getName(方法：```class Animalprivate String name;public String getNamreturn name;}```可以使用成员方法引用来引用getName(方法：```Animal animal = new Animal(;Supplier<String> supplier = animal::getName;```在这个例子中，使用animal::getName引用了Animal类的getName(方法。

这样，supplier.get(就会返回该方法的执行结果。

成员方法重载是指在同一个类中定义多个方法名相同但参数列表不同的方法。

重载方法可以有不同的参数类型、不同的参数个数或者不同的参数顺序。

在调用时，编译器会根据传递的参数类型和数量来确定调用哪个重载方法。

例如，假设有一个Calculator类，其中定义了两个重载方法add(，分别接收两个整数和两个浮点数：```class Calculatorpublic int add(int a, int b)return a + b;}public double add(double a, double b)return a + b;}```在使用时，根据传递的参数类型选择调用相应的重载方法：```Calculator calculator = new Calculator(;int sum1 = calculator.add(2, 3); // 调用add(int, int)方法double sum2 = calculator.add(2.5, 3.5); // 调用add(double, double)方法```通过重载方法，可以在不同情况下使用相同的方法名来实现不同的功能。

方法重载的条件什么是方法重载方法重载（Method Overloading）是指在同一个类中，允许存在多个方法名称相同但参数类型、参数个数或参数顺序不同的方法。

为什么需要方法重载方法重载的主要作用是提高代码的可读性和可维护性。

通过方法重载，我们可以为同一个操作提供不同的参数类型或参数个数的处理方式，让代码更加灵活、易于理解和维护。

方法重载的条件在Java中，方法重载需要满足以下条件：方法名称相同方法名称必须相同，否则不能称之为重载。

参数列表不同参数列表必须不同，包括参数的个数、类型或者顺序。

只有参数列表不同，才能称之为方法重载。

返回值类型可以相同也可以不同方法的返回值类型可以相同，也可以不同。

如果只是返回值类型不同，而参数列表相同，则不能称之为方法重载。

访问修饰符可以相同也可以不同方法的访问修饰符可以相同，也可以不同。

对于方法重载来说，访问修饰符不是决定因素。

可变参数与方法重载可变参数是Java 5引入的特性，允许在声明方法时指定一个参数数量可变的参数，通过省略号（…）来表示。

当参数类型、参数个数和方法名称相同时，可变参数方法与普通方法之间是重载关系，但当参数类型、参数个数或者参数顺序不同时，则不构成重载关系。

例子演示下面通过一些例子来说明方法重载的条件。

例子1：参数个数不同public class Example {public void message(String msg) {System.out.println("Message: " + msg);}public void message(String msg, int count) {for (int i = 0; i < count; i++) {System.out.println("Message: " + msg);}}public static void main(String[] args) {Example example = new Example();example.message("Hello"); // 调用参数个数为1的方法example.message("World", 3); // 调用参数个数为2的方法}}输出结果：Message: HelloMessage: WorldMessage: WorldMessage: World在上面的例子中，通过方法重载，我们定义了两个message方法，一个接受一个字符串参数，另一个接受一个字符串参数和一个整数参数。

什么是方法重载方法重载是面向对象编程中的一个重要概念，它允许在同一个类中定义多个同名方法，但这些方法的参数列表必须不同。

在Java、C++、C#等编程语言中，方法重载是一种静态多态性的体现，它能够提高代码的灵活性和可读性，使得程序员能够更加方便地调用不同版本的同名方法。

方法重载的实现原理是根据方法的参数列表来区分不同的方法。

当调用一个重载方法时，编译器会根据传入的参数类型和数量来确定到底调用哪个版本的方法。

这种静态多态性的特性使得程序在编译阶段就能确定调用哪个方法，避免了运行时的性能损耗。

方法重载的条件包括方法名相同、参数列表不同，参数列表不同可以通过参数的个数、类型、顺序来区分。

例如，可以定义一个计算两个整数相加的方法add(int a, int b)，也可以定义一个计算两个浮点数相加的方法add(float a, float b)，这两个方法就是方法重载的典型例子。

方法重载的好处在于可以提高代码的复用性和可读性。

通过方法重载，可以使用相同的方法名来实现不同的功能，这样可以减少类中方法的数量，使得类的结构更加清晰。

同时，程序员在调用方法时也更加方便，不需要记住很多不同的方法名，只需要记住方法名和对应的参数即可。

另外，方法重载还可以使得程序更加灵活。

当我们需要对不同类型的参数进行相同的操作时，可以通过方法重载来实现，而不需要为每种类型都定义一个新的方法。

这样可以减少代码的冗余，提高代码的可维护性。

需要注意的是，方法重载并不是通过返回类型来区分的。

因为Java等语言不支持通过返回类型来区分方法，所以在进行方法重载时只需要考虑参数列表。

在使用方法重载时，需要遵循一些规则。

首先，方法重载不能只通过参数的名称或者参数的修饰符来区分，必须通过参数列表的类型、数量、顺序来区分。

其次，方法重载不能只通过返回类型来区分。

最后，方法重载不能只通过参数的可变性来区分，例如不能通过参数为int和参数为int[]来进行方法重载。

实验三、静态成员一、目的要求1. 熟练掌握C++语言中静态成员的定义、实现方法。

2. 掌握静态成员在类中的作用。

二、实验内容1. 阅读并运行示例代码，记录输入和运行结果，完成下列内容：①程序目前有一处错误，不能编译运行，将错误语句和改正后的语句写在实验报告上。

②解释print_task类中的三个静态成员变量都起到什么作用，print_task类的构造函数和析构函数都执行了什么功能。

③解释printer类构造函数和析构函数都执行了什么功能。

④解释语句content= task_count+'a';完成的功能。

⑤成员变量content存储了要打印的内容，为程序简单，目前是一个字符。

事实上它应该是一个指向要打印内容的指针，它是否应该被声明为private类型，为什么？⑥为何要在程序顶部加class printer;简短声明？2. 当前用对象数组表示了打印任务，方法比较笨拙，修改print_task类，将打印任务用链表表示。

（供学有余力者选作）3. 这个程序执行时，实际上假设当前系统只有一台打印机，如何让每个打印任务被不同打印机打印，思考应当如何修改程序。

（供学有余力者课后思考）#include "stdafx.h"#include <iostream>using namespace std;//如在VC6中运行，删去上面两行，去掉下面一行的注释//#include <iostream.h>class printer;class print_task{public:static int task_count;static bool printer_status;static print_task* task_list;static void print();print_task(){content= task_count+'a'; task_count++;}~print_task(){ task_count--;}char content;};int print_task::task_count=0;print_task::printer_status = false;print_task* print_task::task_list=0;class printer{public:printer(){print_task::printer_status=true;}~printer(){print_task::printer_status=false;}static void print(){int i;for (i=0; i<print_task::task_count; i++)cout<< (print_task::task_list+i)->content << endl;}};void print_task::print(){if(printer_status)printer::print();elsecout<< "打印机未启动\n";}int main(){int count;cout<< "请输入要建立的打印任务数量\n";cin >> count;print_task::task_list = new print_task[count];print_task::print();printer prt;print_task::print();delete [] print_task::task_list;return 0;}三、实验提示1. VC6开发环境的使用l创建工程：点击菜单File(文件)→new（新建），在弹出的对话框内选择Win32 Console Application，在右侧右侧Project Name下输入项目名，并在Location文本框输入，或点击其右侧按钮，选择项目文件存储的目录，完成后单击OK按钮。

实验五方法的重载和静态成员【实验目的】1.巩固掌握构造方法的作用和定义；2.掌握方法重载的意义和实现方式；3.掌握静态成员的使用方法。

【实验准备】复习配套教材相关章节的内容；【实验内容】项目一：1.定义一个游戏中Hero 英雄的类，在该类中定义英雄的名字，生命值和等级3 个属性，定义一个无参构造方法完成对名字、生命值和等级的初始化，分别赋初值为“无名英雄”、100和1。

同时实现名字和英雄信息的输出。

public class Hero {String name;int healthPower;int grade;public Hero() { ="无名英雄";this.healthPower = 100;this.grade=1;}void showInfo() {System.out.println("——英雄信息——");System.out.println("名字：" + );System.out.println("生命值：" + this.healthPower);System.out.println("类型：" + this.grade);}}2.在上一步的基础上，为英雄再定义拥有一个参数的构造方法，第一个参数传入英雄的名字,第二个参数传入一个英雄类型的值，如果为1，则为普通英雄，生命值为100；如果该值为2，则为高级英雄，生命值初始化为200；如果该值为3，则为超级英雄，生命值初始化为300。

public Hero(String name, int grade) { = name;if (grade == 3) {this.healthPower = 300;this.grade = 3;} else if (grade == 2) {this.healthPower = 200;this.grade = 2;} else {this.healthPower = 100;this.grade = 1;}}3.为英雄添加一个基本战斗的方法，该方法拥有一个英雄类类型的参数，当传入另一个英雄时，能降低对方10点血。

第1篇摘要本实验报告旨在总结方法重载的实验过程，通过实际操作验证方法重载的概念、规则及其在编程中的应用。

实验涉及C++语言，通过编写简单的类和函数，演示了方法重载的原理和实践。

以下是对实验的详细总结。

一、实验目的1. 理解方法重载的概念和规则。

2. 掌握C++语言中实现方法重载的方法。

3. 通过实例验证方法重载的灵活性和实用性。

二、实验原理方法重载（Method Overloading）是面向对象编程中的一种特性，允许在同一个类中存在多个同名的方法，只要这些方法的参数列表（参数类型和数量）不同即可。

方法重载使程序员能够使用相同的函数名来执行相似的操作，从而提高代码的可读性和易用性。

三、实验材料与工具1. 编程语言：C++2. 开发环境：Visual Studio、Code::Blocks等3. 硬件设备：计算机四、实验步骤1. 创建一个新的C++项目：选择一个合适的开发环境，创建一个新的C++项目。

2. 定义一个简单的类：在项目中定义一个类，该类包含几个方法，用于演示方法重载。

```cppclass Calculator {public:int add(int a, int b) {return a + b;}double add(double a, double b) {return a + b;}};```3. 编写测试代码：在主函数中创建类的实例，并调用不同的重载方法。

```cppint main() {Calculator calc;cout << "整数加法: " << calc.add(3, 4) << endl;cout << "浮点数加法: " << calc.add(3.5, 4.2) << endl;return 0;}```4. 编译和运行程序：编译并运行程序，验证方法重载是否成功。

第1篇一、实验目的1. 理解函数重载的概念和原理。

2. 掌握函数重载的使用方法。

3. 通过实验加深对函数重载的理解和应用。

二、实验环境1. 操作系统：Windows 102. 编译器：Visual Studio 20193. 编程语言：C++三、实验内容函数重载是指在同一作用域内，允许存在多个名称相同但参数类型或数量不同的函数。

当调用函数时，编译器会根据参数列表的不同来选择合适的函数执行。

1. 实验一：基本函数重载（1）实验目的验证基本函数重载的实现和调用。

（2）实验步骤1）创建一个名为“FunctionOverload”的C++文件。

2）定义两个同名函数，但参数类型不同。

3）在主函数中调用这两个函数，并观察输出结果。

```cppinclude <iostream>using namespace std;void print(int num) {cout << "打印整数：" << num << endl;}void print(double num) {cout << "打印浮点数：" << num << endl;}int main() {print(10);print(3.14);return 0;}```（3）实验结果```打印整数：10打印浮点数：3.14```2. 实验二：重载函数的参数个数（1）实验目的验证重载函数的参数个数对函数调用的作用。

（2）实验步骤1）在“FunctionOverload”文件中添加两个同名函数，但参数个数不同。

2）在主函数中调用这两个函数，并观察输出结果。

```cppvoid print(int num1, int num2) {cout << "打印两个整数：" << num1 << "和" << num2 << endl;}void print(int num) {cout << "打印一个整数：" << num << endl;}int main() {print(1, 2);print(3);return 0;}```（3）实验结果```打印两个整数：1和2打印一个整数：3```3. 实验三：重载函数的参数类型（1）实验目的验证重载函数的参数类型对函数调用的作用。

一、实验目的1. 理解运算符重载的概念和原理。

2. 掌握C++中运算符重载的方法和规则。

3. 通过实例，实现自定义类型对运算符的重载。

4. 分析运算符重载在实际编程中的应用和优势。

二、实验环境1. 编程语言：C++2. 开发环境：Visual Studio 20193. 操作系统：Windows 10三、实验内容1. 运算符重载的概念和原理2. 运算符重载的方法和规则3. 自定义类型运算符重载实例4. 运算符重载的实际应用四、实验步骤1. 概念和原理运算符重载是指为已有的运算符赋予新的功能，使其能够应用于自定义类型的数据。

在C++中，运算符重载可以通过成员函数或友元函数实现。

2. 方法和规则- 成员函数重载：在自定义类型中定义一个成员函数，该函数的名称与要重载的运算符相同。

- 友元函数重载：在自定义类型外部定义一个友元函数，该函数的名称与要重载的运算符相同，并在函数声明中添加类名和作用域解析运算符。

运算符重载规则：- 运算符重载的函数必须返回与操作数相同的类型。

- 运算符重载的函数不能改变原有运算符的操作数个数。

- 运算符重载的函数不能改变原有运算符的优先级。

- 运算符重载的函数不能改变原有运算符的结合性。

3. 自定义类型运算符重载实例假设我们有一个自定义类型`Point`，表示二维平面上的一个点，其坐标为`(x, y)`。

```cppclass Point {public:int x, y;Point(int x, int y) : x(x), y(y) {}// 成员函数重载加法运算符Point operator+(const Point& p) const {return Point(x + p.x, y + p.y);}// 友元函数重载加法运算符friend Point operator-(const Point& p1, const Point& p2);};// 实现友元函数重载减法运算符Point operator-(const Point& p1, const Point& p2) {return Point(p1.x - p2.x, p1.y - p2.y);}```4. 运算符重载的实际应用运算符重载在实际编程中具有以下优势：- 提高代码可读性：使用自定义类型时，可以像操作基本数据类型一样使用运算符，提高代码的可读性。

java方法重载实验报告Java方法重载是指在一个类中，可以有多个方法拥有相同的名称，但是参数列表不同。

通过方法重载，可以使代码更加简洁和灵活，提高代码的复用性和可读性。

在Java中，方法重载的条件是：方法名相同，但是参数列表必须不同。

参数列表可以通过参数的类型、个数、顺序来区分。

返回值类型和访问修饰符不是方法重载的条件。

方法重载的好处是：可以根据不同的参数类型和个数，实现不同的功能。

例如，我们可以定义一个计算两个整数之和的方法，也可以定义一个计算两个浮点数之和的方法，通过方法重载可以实现这个功能。

下面我们来具体实验一下方法重载的用法。

我们定义一个类，命名为"MethodOverload"。

```javapublic class MethodOverload {// 定义一个计算两个整数之和的方法public int add(int a, int b) {return a + b;}// 定义一个计算两个浮点数之和的方法public double add(double a, double b) {return a + b;}// 定义一个计算三个整数之和的方法public int add(int a, int b, int c) {return a + b + c;}// 定义一个计算两个字符串拼接的方法public String add(String a, String b) {return a + b;}}```在上面的代码中，我们定义了四个不同的方法，它们的方法名都是"add"，但是参数列表不同。

第一个方法是计算两个整数之和的方法，第二个方法是计算两个浮点数之和的方法，第三个方法是计算三个整数之和的方法，第四个方法是计算两个字符串拼接的方法。

接下来，我们可以在主方法中调用这些方法进行测试。

```javapublic class Main {public static void main(String[] args) {MethodOverload method = new MethodOverload();int sum1 = method.add(1, 2);System.out.println("两个整数之和：" + sum1);double sum2 = method.add(1.5, 2.5);System.out.println("两个浮点数之和：" + sum2);int sum3 = method.add(1, 2, 3);System.out.println("三个整数之和：" + sum3);String str = method.add("Hello", "World");System.out.println("两个字符串拼接结果：" + str); }}```以上代码的输出结果为：```两个整数之和：3两个浮点数之和：4.0三个整数之和：6两个字符串拼接结果：HelloWorld```通过上面的实验，我们可以看到，通过方法重载，我们可以实现不同类型和个数的参数的方法调用，从而实现不同的功能。

题目1：定义一个复数类，通过重载运算符：*，/，直接实现二个复数之间的乘除运算。

编写一个完整的程序，测试重载运算符的正确性。

要求乘法“*”用友元函数实现重载，除法“/”用成员函数实现重载。

源程序1/*******************第1题*******************//******************单森汉*****************//******************2012-5-1*****************/#include<iostream>using std::cout;using std::endl;class Complex{float Real, Image;public:Complex(float r=0,float i=0) { Real=r;Image=i;}void Show(){cout <<"Real="<<Real<<'\t'<<"Image="<<Image<<'\n';}friend Complex operator *(Complex &, Complex &);Complex operator /(Complex &); //重载运算符+Complex operator +( Complex &);friend Complex operator -(Complex &, Complex &);};Complex operator *( Complex &c1,Complex &c2){Complex t;t.Real=c1.Real * c2.Real - c1.Image * c2.Image;t.Image = c1.Image*c2.Real +c1.Real* c2.Image;return t;}Complex Complex::operator /(Complex &c){Complex t;t.Real =(Real *c.Real+ Image * c.Image)/(c.Real*c.Real+ c.Image * c.Image);t.Image = (Image *c.Real - Real * c.Image)/(c.Real*c.Real+ c.Image * c.Image);return t;}Complex Complex::operator + ( Complex &c){Complex t;t.Real = Real + c.Real;t.Image = Image + c.Image;return t;}Complex operator -(Complex &c1, Complex &c2){Complex t;t.Real=c1.Real-c2.Real;t.Image=c1.Image-c2.Image;return t;}void main(){Complex c1(1,2),c2(3,4),c3;c3=c1*c2;cout<<"两个复数的乘法c3=c1*c2:";c3.Show();c3=c1/c2;cout<<"两个复数的除法c3=c1/c2:";c3.Show();Complex c4(1,2),c5(3,4),c6,c7(1,2),c8(3,0),c9; c6=c4+c5;cout<<"两个复数的加法c6=c4+c5:";c6.Show();c6=c4-c5;cout<<"两个复数的减法c6=c4-c5:";c6.Show();c9=c7+c8;cout<<"一个复数与一个实数的加法c9=c7+c8:"; c9.Show();c9=c7-c8;cout<<"一个复数与一个实数的减法c9=c7-c8:"; c9.Show();}运行结果截图题目2：定义一个向量（一维数组）类，通过重载运算符实现向量之间的加法和减法。

静态方法可以重载静态方法可以重载，即定义多个具有相同名称但参数不同的静态方法。

当调用这些重载的静态方法时，根据传递的参数类型和数量，编译器会选择调用合适的方法。

在Java中，静态方法是属于类而不是对象的，因此可以直接通过类名来调用。

静态方法不依赖于类的实例，可以直接在类上调用，不需要创建对象。

与之相对的是实例方法，实例方法必须通过实例化对象后才能调用。

静态方法的重载可以实现不同参数的处理逻辑，方便在不同场景下使用。

当调用静态方法时，编译器会根据调用时传递的参数类型和数量来选择合适的方法。

若参数类型和数量与某个静态方法完全匹配，则调用该方法；若参数不匹配，则编译器会尝试进行类型转换，若存在能够进行隐式类型转换的方法，则调用该方法；若仍无法找到匹配的方法，则编译器会报错。

以下是一个示例，演示了静态方法的重载：javapublic class StaticMethodOverload {public static void main(String[] args) {int a = 10;double b = 1.5;String c = "Hello";调用不同重载方法MethodOverload.print(a);MethodOverload.print(b);MethodOverload.print(c);}}class MethodOverload {public static void print(int num) {System.out.println("这是一个整数: " + num);}public static void print(double num) {System.out.println("这是一个浮点数: " + num);}public static void print(String str) {System.out.println("这是一个字符串: " + str);}}在上面的示例中，`MethodOverload`类中定义了三个重载的静态方法`print`，分别接收整数、浮点数和字符串类型的参数。

简述心理学实验中常用的五种控制额外变量的方法
心理学实验中常常会遇到一些可能影响实验结果的额外变量,需要采取一些方法进行控制。

以下是常用的五种控制额外变量的方法:
1. 重复测量:在多个时间点或多个受试者之间进行测量,以便排除任何时间或受试者身上的随机效应。

2. 多重记录:记录多个数据点,以便对任何可能的随机效应进行评估。

3. 控制基线:在实验开始前,对受试者进行基线评估,以确保他们的心理状态和生理状态处于基线水平,以避免任何可能的额外效应。

4. 隔离机制:将受试者进行隔离,以确保他们不会因为其他实验参与者或外部因素的影响而产生额外的效应。

5. 随机分配:将受试者随机分配到不同的实验组或对照组中,以确保实验组和对照组之间的差异是由于实验因素引起的,而不是其他随机因素。

这些方法可以帮助心理学实验研究人员控制实验中的额外变量,从而确保实验结果的准确性和可靠性。

此外,这些方法也可以帮助研究人员更好地理解实验结果,并进一步研究心理学领域的相关现象和问题。

图5.4
（2）运行结果如图5.5所示。
图5.5
3．This、super和super()的使用
（1）程序功能：说明this、super和super()的用法。程序首先定义Point（点）类，然后创建点的子类Line（线）。最后通过LX3_4类输出线段的长度。
（2）使用this、super和super()的程序文件LX3_4.java，源代码如下图5.6所示。
多态是一种编程技巧它增加论了程序的可扩展性
2．接口有什么作用？如何实现系统接口。
接口的作用就是把使用接口的人和实现接口的人分开，实现接口的人不必要关心谁去使用，而使用接口的人也不用关心谁实现的接口，由接口将他们联系在一起。接口的用处在于整个程序段中相同类型的类有个统一的规范。
3.如何创建一个自定义接口？如何在一个类中实现这个接口？
图5.6
（3）编译并运行程序，结果如图5.7所示。
图5.7
二、类的多态性练习
1．方法的重载
方法的重载是指对同名方法的不同使用方式。
（1）程序功能：对不同的数进行排序输出。在IntSort类中定义3个同名的方法sort，
（1）编写构造方法RunDemo的重载程序文件LX3_12，源代码如下。
（2）编译并运行程序，结果如图5.4所示。
【思考题】
1.说明类的继承和多态用的一种形式，实现这种形式的方法是从现有的类建立新类，新类继承了现有类的方法和属性，同时新类又可以定义自己的方法和属性。软件复用缩自短了开发时间。继承的魅力在于能够添加基类没有的特点从而对基类进行改进。
子类继承后可以重写，也可以不重写，看需要决定。如果重写的话在实例中调用的是新写的方法，如果不重写的话在实例中调用的是父类的方法。
创建接口:public interface myFirstInterface(){

实验五静态路由配置实验目的1、熟悉模拟器Packet tracer的使用环境；2、掌握路由器的几种工作模式及模式之间的切换；3、掌握路由器常见端口的配置步骤；4、理解路由表的查找原理，理解静态路由的概念；5、掌握设置静态路由和默认路由的方法；实验环境Packet tracer 5.0实验步骤1、使用模拟器Packet tracer构建如下的网络拓扑：注意：路由器和路由器之间，路由器和计算机之间应该采用哪种电缆？2、PC机的IP配置进入PC机配置环境，按照图中的要求配置IP地址、子网掩码和网关。

3、路由器模式切换Router>enable /用户模式进入特权模式Router#configure terminal /特权模式进入配置模式用户模式用户只能查看路由器的一些基本状态，不能进行设置；特权模式用户可以使用show 和debug命令进行配置检查，还不能进行路由器配置的修改；配置模式用户才能真正修改路由器的配置，比如配置路由器的静态路由表，详细的配置命令需要参考路由器配置文档。

如果想配置具体端口，还需要进入第4级。

4、路由器端口配置Router3:Router(config)#interface s0/0/0 //进入端口模式，配置串口Router(config-if)#ip add 192.168.2.1 255.255.255.0//配置串口IP Router(config-if)#no shutdownRouter(config-if)#interface f0/0 //进入端口模式，配置以太网接口Router(config-if)#ip add 192.168.1.1 255.255.255.0Router(config-if)#no shutdownRoute4：Router(config)#interface s0/0/0Router(config-if)#ip add 192.168.2.2 255.255.255.0Router(config-if)#clock rate 64000 //配置时钟Router(config-if)#no shutdownRouter(config-if)#interface f0/0Router(config-if)#ip add 192.168.3.1 255.255.255.0Router(config-if)#no shutdown配置完成后，在PC机上使用PING命令测试PC机和路由器各端口以及PC和PC 之间的连通情况，并思考为什么是这种情况？5、静态路由配置给Router3配置一条静态路由信息Router(config)#ip route 192.168.3.0 255.255.255.0 192.168.2.2给Router2配置一条静态路由信息Router(config)#ip route 192.168.1.0 255.255.255.0 192.168.2.1配置完成后，在PC机上使用PING命令测试PC机和路由器各端口以及PC和PC 之间的连通情况，并思考为什么是这种情况？6、查看路由器的路由信息在特权模式下查看路由器的路由信息：Router#show ip route观察路由表中的各条路由信息，并解释。