实验_实验设计 - CSDN
精华内容
参与话题
  • 实验1:框架设计者

    千次阅读 2019-11-22 01:48:38
    实验3:框架设计者 目的】本实验的编程任务,是编写并测试冒泡排序framework.temp.BubbleSort,然后在此基础上编写(或者说获得)排序的测试框架,用简单的例子破除人们对框架的神秘感。同时,说明依赖倒置原则是...

    最后编辑2019.11.21【有同学说,本博客看不懂。我搞详细一点。晕】

    【实验3:框架设计者 目的】本实验的编程任务,是编写并测试冒泡排序framework.temp.BubbleSort,然后在此基础上编写(或者说获得)排序的测试框架,用简单的例子破除人们对框架的神秘感。同时,说明依赖倒置原则是垃圾。

    下面先给出最简单粗暴的代码,即在编写完了排序算法后,将测试相关的代码也直接地放在BubbleSort中。

    package chap1.temp;//将被重构 –移动
    public class BubbleSort  {
        public int[] sort(int[] arr){//本书通常不关注算法!
            for(int i = 0 ; i< arr.length-1; i++){
                for(int j = 0 ; j < arr.length-i-1;j++){
                    if(arr[j] > arr[j+1]){ //冒泡
                        swap(arr ,j, j+1);
                    }
                }
            }
            return arr;
        }
        
        //移到父类型中
        public static void swap(int[] arr ,int one, int two){
            if(one == two){return;}
            int temp = arr[one];
            arr[one] = arr[two];
            arr[two] = temp;
        }
    
        //移到SortTest中
        public static void  simpTest(int[] array) {        
            array = new BubbleSort().sort(array);
            pln(array);
        }
        public static void pln(int[] array) {
            System.out.println(java.util.Arrays.toString(array));
        }
    
        public static void main(String[] args){//BlueJ中可以省略本方法。
            simpTest(new int[]{5, 8, 5, 4, 3, 5, 2, 7, 5, 9});
        }  
    }
    

    temp(临时文件夹)这个包名,意味着BubbleSort代码的结构,有许多值得改进的地方,后面将简略地说明,为什么需要改进以及如何改进。本实验一共包括五个步骤的变化。其中→表示依赖/使用关系,<=表示继承关系。

    1. SortTest→BubbleSort。客户SortTest依赖具体的服务BubbleSort,这是不好的设计。
    2. SortTest→IntSort<=BubbleSort。应用程序SortTest遵循针对接口编程/依赖抽象类型原则,它依赖抽象类型IntSort,而BubbleSort自然地依赖父类型。
    3. 【SortTest→IntSort】。这一步很关键。在需要的时候,可以将SortTest设计成框架,于是将控制模块SortTest和它必须依赖的抽象类型IntSort打包(最好能够为该包提供JavaDoc)。从应用程序(上层模块)变为框架(下层模块)过程中,建议将IntSort的方法名sort 改成soooooort——体现控制反转。
    4. Main→【SortTest→IntSort】<=BubbleSort。(其他程序员)使用框架。
    5. 带main的BubbleSort,BubbleSort→【SortTest →IntSort】<=BubbleSort。与第一步“依赖倒置”。

    1.单一职责原则、针对接口编程/抽象依赖原则

    在temp.BubbleSort中,存在编程初学者最常见的问题——把所有的功能都写在一个类里。比如说temp.BubbleSort既有排序相关的代码,如sort()和swap();也有测试相关的代码,如simpTest()。恰当的面向对象的设计方案,是将不同的职责由不同的类型封装。

    package framework.temp; 
    public interface IntSort { //仅对int进行排序
        public int[] sort(int[] arr);
        public static void swap(int[] arr ,int one, int two){     /*略*/    }
    }
    
    package framework.temp; 
    import static yqj2065.util.Print.pln;
    public class SortTest{
        public static void  simpTest (IntSort s, ,int[] array){
            array = s.sort(array);
            pln(array);
        } 
        //或者,成员变量等待setter参数传入 ;或者依赖注入
        private IntSort s;    
        public static void setIntSort(IntSort s){
            this.s =s;
        }
        public static void  simpTest ( int[] array){
            array = s.sort(array);
            pln(array);
        } //main(String[])略
    }
    //Main
        public static void main(){
            framework.temp.IntSort obj = new framework.temp.BubbleSort();
            framework.temp.SortTest.setIntSort(obj);
            framework.temp.SortTest.simpTest(new int[]{5, 8, 5, 4, 3, 5, 2, 7, 5, 9});
        }
    

    注意:import static yqj2065.util.Print.pln;不可用时,直接用下面的工具方法。

        public static void pln(int[] array) {
            System.out.println(java.util.Arrays.toString(array));
        }

    SortTest 的方法,需要依赖IntSort。方法simpTest 修改成: public static void  simpTest (IntSort s, ,int[] array)

    2.设计框架

    现在聚焦SortTest,它是测试流程的控制模块。当应用程序员编写SortTest,他感觉一切都在他的(代码的)控制之下。也就是说,应用程序员决定控制模块SortTest要干什么、测试程序的流程是什么;最为关键的是,应用程序员还决定SortTest依赖的类型名为IntSort、IntSort的接口名为sort(),等等。

    考虑编写SortTest的另外一种场景。假设SortTest中提供了完善的测试逻辑——如比较被测算法与JDK排序算法的一致性(保证排序正确)、大规模测试的时间复杂度的图形绘制等等重要而有用的代码,因此希望SortTest能够被广泛地复用。或者说,SortTest和IntSort是老师预先提供的测试工具并打包提供给学生,学生随后编写自己的某种排序算法并被要求复用该包。

    这种场景,可以称为对排序测试的框架的复用

    为了体现框架的独立性,下面将排序测试框架涉及到SortTest和IntSort打包,表示为【SortTest→IntSort】。

    在BlueJ中创建另一个项目tool,包名为yqj2065.util,【永远记住:不要在默认包中编写代码

    将SortTest和IntSort移动到该包,打包为一个jar文件(文件名随意,如123. jar)。SortTest的方法改名为test()。将IntSort对方法改名为soooooooort。【可以可以将包名、修改后的函数名复制粘贴到某处备用。】

    将打包的jar添加到应用程序项目的依赖库中,就能够方便地复用它们。【打包、添加第三方包的方式,见《编程导论》 6.2.2 类路径和第三方包 】

    3.应用程序员的工作

    将打包的jar添加到应用程序项目的依赖库中,应用程序员通过import语句,就能够方便地复用它们。【import语句也可以不要,程序中直接写类全名。import语句和jar的文件名无关。我为什么要你用123.jar,当你import 123时,会感觉不对劲,因为Java中数字不能够作为标识符】

    应用程序员编写IntSort的子类型BubbleSort,以及Main。表示为Main->【SortTest->IntSort】<=BubbleSort。

    说明:什么是控制反转,什么是框架;

    体会:什么是策略模式

     

    4.何谓控制反转

    拜托,在我的术语表中没有控制反转(Inversion of Control,英文缩写为IoC)这个垃圾术语,我不知道它是什么东西。【考试的时候,你要知道!】

    控制反转/Ioc,即框架控制一切,应用程序员提供支持代码。IoC反映了某些应用程序员的失落心情:从自由自在变为受控于人。IoC描述了一种现象:软件设计决定的控制权,由应用程序员转移到框架设计者手中。除此之外,IoC没有任何其他含义

    记住,永远不要问“哪些方面的控制被反转了呢?”这种愚蠢的问题——像Martin Fowler那样。因为框架的设计者从来不考虑这种问题,他们不谈控制——他们只考虑SortTest应该如何进行完美的测试,没有反转——他们不知道框架的使用者要测试什么排序算法,但是必须是IntSort的子类型。

     

    同学们不清楚的地方,可以在博客下面提问。

     

     

     

     

     

     

     

     

     

     

     

     

     

    ---------------------------------------------------------------------

    下面的文字先不要管。

    本文介绍何谓框架,并提供了一个最简单的框架——对两个double操作后返回一个double值。

    1、何谓框架

    框架/framework是在底层/下层模块中定义的一个骨架式方案,处理各种应用中面临的共同的底层细节;而应用开发者可以按照自己的需求使用框架,给出自己的功能实现——只需要填入自己的东西/flesh。如果是applet或GUI框架,就有太多底层细节需要处理,因而最简单的框架util.DoubleOP仅仅说明这是一个骨架式方案——对两个double操作后返回一个double值。在这个骨架式方案,本框架处理了....大量的技术细节,不过代码被省略了。

    本框架可以使你对两个double进行各种操作,如相加,比较、求幂等等,你具体如何应用,需要你按照自己的需求提供代码。

     

    package util;
    /**
     *框架/framework的目的,是定义一个骨架式方案,处理各种应用中面临的共同的底层细节;
     * @author yqj2065
     * @version 2016.7
     */
    @FunctionalInterface 
    public interface  DoubleOP {
        //对两个double操作后返回一个double值.可以使你对两个double进行各种操作,如相加,比较、求幂等等
        double op(double m,double n) ;
    }

    嗯,最简单的框架就是一个函数接口,它对两个double操作后返回一个double值。类似于JUnit,我们还设计了一个包含main(String[] args)启动本框架的类Main。使用本框架时,请在配置文件my.properties中指定将要创建的对象,键为2065

     

    package util;
    import tool.God;
    public class Main{
        /**
         * 命令行启动本框架。
         * @param args 至少两个double
         */
       public static void main(String[] args){
            DoubleOP f = (DoubleOP)God.create("2065");
            double d =f.op(Double.parseDouble(args[0]),Double.parseDouble(args[1]));
            System.out.println(d);
        }
        /**
         * 和JUnit一样,提供App调用的方式。
         */
        public static double runFramework(DoubleOP f,double x,double y){
            return f.op(x,y);
        } 
    }

    注意,框架一般使用的技术就是反射和回调

     

    • tool.God利用反射和配置文件创建某个对象,
    • Main调用 f.op(double,double),具体的方法体由上层代码提供。

     

    ok,框架已经设计完成。


     

    2.如何使用框架

    现在是我们应用程序员干活的时候了。快哭了应用程序员最开始当然写HelloWorld,来熟悉框架..

    .HelloWorld不能够和高傲的框架在一个包中,principle.callback.lowe,你可以想象它被打包为一个jar。

    框架的使用者,通常进行填空式编程

    这就是库与框架的区别——上层模块的程序员直接调用的,属于库函数;要求上层模块的程序员提供的回调函数的,属于框架。

     

    package abc;
    public class HelloWorld implements util.DoubleOP{
        public double op(double m,double n){
            return m+n;
        }
    }

    第二步,按照框架的要求,自己写好配置文件。于是我们在my.properties中加上下面的键值对:

    2065=principle.callback.HelloWorld

    第三步,在命令行中运行和测试框架,例如:

    E:\designPattern>java principle.callback.lower.Main 1.2 3.4
    4.6

    通常,我们应用程序员不会在控制台直接启动或调用框架,而是在应用程序中启动或调用框架,这就是框架的Main提供

    runFramework(MyFramework ,double,double)的意义。框架的设计者真的很贴心。我们的应用程序如下:

     

    package abc;
    import tool.God;
    import <span style="font-family: Arial, Helvetica, sans-serif;">util.DoubleOP</span>;
    import util.Main;
    public class App{
        public static void main(String[] args){
            DoubleOPf = (DoubleOP)God.create("2065");
            double d = Main.runFramework(f,1.2,3.4);
            System.out.println(d);
        }
    }

    既然HelloWorld也在本包中,应用程序App可以直接使用它而不用反射。我们也可以在App使用匿名类、λ表达式直接描述自己的需求——不定义太多的HelloWorld这样的类。

     

     

    package abc;
    import tool.God;
    import util.DoubleOP;
    import util.Main;
    public class App{
        public static void main(String[] args){
            DoubleOP f = (DoubleOP)God.create("2065");
            double d = Main.runFramework(f,1.2,3.4);
            System.out.println(d);
        }
        public static void test(){
            double d = Main.runFramework(new HelloWorld(),1,3);
            System.out.println(d);
            
            DoubleOP f = (double m,double n)->{return m * n ;};
            d = Main.runFramework(f,1,3);
            System.out.println(d);
            
            f = (m,n)->{return m +2*n ;};
            d = Main.runFramework(f,1,3);
            System.out.println(d);
    
            d = Main.runFramework((m,n)->{return m-n ;},1,3);
            System.out.println(d);
        }
    }

    运行test()输出:

     

    4.0
    3.0
    7.0
    -2.0

     

    展开全文
  • 实验2 行为参数化

    千次阅读 2020-10-20 08:47:40
    实验2:行为参数化】要求输出0-x之间符合“某种”条件的数。由此讨论行为参数、高阶函数、闭包(closure)等概念, 注:上机实验前,我删除了本文章中需要你编写等一些代码。考试前,也不会添加进来。 求解问题:...

    【实验2:行为参数化】要求输出0-x之间符合“某种”条件的数。由此讨论行为参数、高阶函数、闭包(closure)等概念

    注:上机实验前,我删除了本文章中需要你编写等一些代码。考试前,也不会添加进来。

    求解问题:编写函数filter (int x),输出0-x之间 3的倍数而且含5的数,如15,54,555等等。【《编程导论(Java)•3.1.2方法》中,通过该例程介绍程序设计中基础性的功能抽象技术——功能分解或结构化分解(structured decomposition),如例程所示,很容易编写函数解决上述特定问题。

    package chap2;
    public class Demo{
         private static boolean isMultipleOf3(int n) { //n 是否3的倍数
            return (n % 3 == 0);
        }
        private static boolean isInclude5(int n) { //n  是否包含5
            while (n != 0) {
                if (n % 10 == 5) {
                    return true;
                }
                n /= 10;
            }
            return false;
        }
        public static void filter(int x) {
            for (int i = 0; i < x; i++) {
                if (isMultipleOf3(i) && isInclude5(i)) {
                    System.out.print(" " + i);
                }
            }
        }
    }
    

    假设需要解决的问题为:

    • 输出0-x之间为 7的倍数的数。
    • 输出0-x之间为2的倍数,而且含5含7的数。

    如何使得函数filter()更具有一般性,能够解决上述各种问题呢?

     

    上机练习的要求:

    1.编写接口类型Condition,它有boolean test(int n)。将filter方法中可以变化的、例如if( is3X(i) && isInclude5(i))中的判断条件,用Condition的实现类型实现。

    2.假定仅仅进行单一测试,在Demo中编写重载方法filter(int x, Condition c)——行为参数化

    3.思考条件如何组合.

    4.为Condition添加defaule方法and,or【参考java.util.function.Predicate的源代码。用Predicate替代类型Condition】。

    行为参数化与设计模式

    当函数中存在可变部分(如各种测试)时,可以将变化的部分抽取出来,由一个抽象方法boolean test(int n)来描述进行"何种"测试。假定仅仅进行单一测试,可以使用C语言实现。

    funcPointer.c文件
    #include <stdbool.h>
    typedef _Bool (*Test)(int); //
    _Bool isMultipleOf3(int n) { //n 是否3的倍数
    	return (n % 3 == 0);
    }//其他条件函数 略
    void filter(int x,Test test) {
    	for (int i = 0; i < x; i++) {
    		if (test(i)) {
    			printf("%d ",i);
    		}
    	}
    }
    
    main.c文件(头文件 略)
    #include "code.h"
    int main(void){
    	filter(100, &isMultipleOf3);
        return 0;
    }
    

    如果使用Java语言,则需要定义接口Condition,起到C语言中函数指针的作用。可以将例程2 -1中的isInclude5(int)函数封装为Condition的子类型。【编写Condition的独立子类IsInclude5,而判断 是否3的倍数用匿名类。】

    仅仅进行单一测试时,可以在Demo中编写重载方法filter(int x, Condition c)

     

    ★行为参数化是指将一个(模板)方法中可变部分设计成该方法/函数的参数,使得该函数具有通用性,遵循OCP。

    行为参数化的意义,使得高阶函数filter符合OCP。(行为参数化的实现技术,就是在[1.3.1回调机制]中介绍的C语言的函数指针、Scheme的高阶函数。从实现技术上看,描述行为参数化的最佳术语或许是高阶函数。)

     

    当使用Java实现时,使用一个抽象方法boolean test(int n)来描述进行"何种"测试,但会出现若干不同的结构。

    Ø        抽象方法放在Demo类中。参见传统的[模板方法模式]

    Ø        抽象方法由一个接口Condition封装,Condition作为Demo的成员变量;策略模式

    Ø        Condition作为函数filter()的参数。行为参数化

    虽然从程序设计的角度,区别这3种结构意义不大,但是反映了一个问题:某些教条主义的设计模式研究者可以为不同实现贴上不同的标签。本质上,行为参数化就是设计模板方法。

    条件的组合

    假定需要进行多种测试,filter(int x, Condition… c)并不能有效地解决条件组合问题。合适的解决方案则是Condition本身提供and(Condition)、or(Condition)和not(Condition)方法,能够将自己和其他对象进行组合。

     

     

    请参考java.util.function.Predicate源代码编写default方法and、or,也可以使用Predicate替代类型condition。

        static void foo(int x,Predicate<Integer> condition){
            for(int i=1;i < x;i++){           
                if( condition.test(i) ){
                    System.out.print(" "+i);
                }
            }
        }

    使用Predicate<Integer> condition的例子:

        static void main(){       
            Predicate<Integer> p1 =( n)->{
                while ( n != 0){
                    if (n % 10 == 7) return true;
                    n /=10;
                }                
                return false;
            };
            foo(100,p1.and((n)-> ( n%3 == 0)));
            
        }

     

    附加题:输出7的倍数,而且该数含7或是3的倍数【 7 21 42 63 70 77 84】

     

     

     

     

    展开全文
  • 一、实验目的: 学习和掌握并发进程同步的概念和方法。 二、实验要求: 1、程序语法  philosopher [ -t ]  是哲学家进餐和沉思的持续时间值,缺省值为2秒。 2、五个哲学家的编号为0~4,分别用五个进程独立...

    一、实验目的:

    学习和掌握并发进程同步的概念和方法。

    二、实验要求:

    1、程序语法

                  philosopher   [ -t <time> ]

       <time>是哲学家进餐和沉思的持续时间值,缺省值为2秒。

    2、五个哲学家的编号为0~4,分别用五个进程独立模拟。

    3、程序的输出要简洁,仅输出每个哲学家进餐和沉思的信息。例如,当编号为3的哲学家在进餐时,就打印:

                  philosopher 3 iseating

    而当他在沉思时,则打印:

                 philosopher3 is thinking

    除此之外不要输出其他任何信息。

    4、利用课堂已教授的知识而不使用线程或IPC机制进行同步。

    5、程序应该一直运行,直到人为地终止它(按Ctrl-C或Ctrl-\)。不允许出现僵尸进程。

    三、实验过程:

      用for循环和fork函数生成5个哲学家进程,如果是前4个哲学家,思考<time>秒后,锁住左手边和右手边的叉子,然后开始用餐,进餐<time>秒后,释放两边的叉子,然后到下一个哲学家,用lock判断能否同时拿起两边的叉子,要是不能同时拿起则一直等待。第5个哲学家最后应拿起第4把叉子和第0把叉子,用while(1)循环使程序一直运行。

    四、实验程序:

    #include "apue.h"

    #include <sys/wait.h>

    #include <fcntl.h>

    #include "lock.h"

    #include <stdlib.h>

    int

    main(int argc,char *argv[])

    {

     pid_t pid[5];//5个哲学家进程

     int i,fd,time;

     char*filename[]={"file0","file1","file2","file3","file4"};//定义5把叉子

     if(argc==1)

            time=2;//时间缺省值

     elseif(argc==3&&strcmp("-t",argv[1])==0)

            time=atoi(argv[2]);

     else err_sys("Inputerror");

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

            initlock(filename[i]);

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

     {

      pid[i]=fork();

      if(pid[i]==0)

      {

       while(1)

       {

              if(i==4)//最后一个哲学家使用第4把叉子和第0把叉子

              {

              printf("philosopher 4 isthinking\n");

           sleep(time);

           lock(filename[0]);

           lock(filename[4]);

           printf("philosopher 4is eating\n");

           sleep(time);

           unlock(filename[4]);

           unlock(filename[0]);

              }

          else

             {

           printf("philosopher%d is thinking\n",i);

           sleep(time);

           lock(filename[i]);

           lock(filename[i+1]);

           printf("philosopher%d is eating\n",i);

           sleep(time);

           unlock(filename[i]);

           unlock(filename[i+1]);

             }

       }

      }

     }

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

     {

     if(waitpid(pid[i],NULL,0)!=pid[i])

       err_sys("waitpiderror");

     }

     exit(0);

    }

    五、实验结果:

       用gcc philosopher.c error2e.clock.c -ophilosopher编译生成可执行文件,命令行只有一个参数philosopher时,每过2秒就能确定下个哲学家的状态,运行结果如下:(Ctrl + C或者ctrl + \ 结束)

    命令行有三个参数时,每过5秒就能确定下个哲学家的状态.

    运行程序如下:(Ctrl + C或者ctrl + \ 结束)

     

    六 .实验小结

    通过本实验学习了学习使用lock对共享资源加锁,进行互斥操作。对并发进程的同步有更切实的了解。

    展开全文
  • 实验4 数据库的连接查询 4.1实验目的及要求 掌握简单表的数据查询、数据排列和表链接查询的操作方法 4.2实验内容 简单查询操作和连接查询操作。 4.3实验步骤 4.3.1连接查询 1.查询每个学生及选秀课程情况 Select ...

    实验4 数据库的连接查询

    4.1实验目的及要求
    掌握简单表的数据查询、数据排列和表链接查询的操作方法

    4.2实验内容
    简单查询操作和连接查询操作。

    4.3实验步骤

    4.3.1连接查询
    1.查询每个学生及选秀课程情况
    Select student.,sc. from student,sc where student.sno=sc.sno;
    在这里插入图片描述

    比较:笛卡尔集:select student.*,sc.*from student,sc;
    在这里插入图片描述

    自然连接:select student,sno,sname,ssex,sdept,cno,grade from student,sc where student.sno=sc.sno;
    在这里插入图片描述

    2.查询每一门课程的间接先行课(只求两层即先行课的先行课);
    Select First.cno,Second.cpno 间接先行课 from course First,course Second where First.cpno=Second.cno;
    在这里插入图片描述

    比较:select First.cno,Second.cpno 间接先行课 from course First,course Secnod where First.cpno=Second.cno;
    在这里插入图片描述

    3.查询每个学生及其选修课程的情况,用左外连接完成。
    select student.sno,sname,ssex,sage,sdept,cno,grade from student left outer join sc on student.sno=sc.sno;
    左外连接(=),将返回左表的所有行;若没有匹配行,则在,则在相关联的结果集行中右表的所有选择列表列均为空值(null)
    在这里插入图片描述
    右连接(=
    ),right(left)outer join 将返回右表的所有行
    在这里插入图片描述
    复合条件连接:WHERE 子句中可以有多个连接条件:

    4.查询每个学生的学号,姓名,选修的课程名和成绩:
    Select s.sno,sname,cname,grade from student S,course C,sc SC where S.sno=SC.sno and C.cno=SC.cno;
    在这里插入图片描述
    5.查询选修2号课程且成绩在90分以上的所有学生
    Select student.sno,sname from student,sc where student.sno=sc.sno and sc.sno and sc.cno=’2’ and sc.grade>90;

    在这里插入图片描述思考:
    如何求出不及格学生的学号,姓名,不及格的课程名以及成绩。
    select student.sno, sname ,grade from student,sc where student.sno and student.sname and sc.cname and sc.grade<60;

    展开全文
  • bufbomb实验心得及详细步骤

    万次阅读 2017-04-01 10:11:17
    bufbomb是一个很有意思的,带有游戏性质的缓冲区溢出实验, 能够帮助你加深理解《Computer Systems A Programmer’s Perspective》书中第三章《Machine-Level Representation of Programs》中的内容。
  • 实验

    2020-08-03 20:02:29
    要求: 1、如图连接拓扑,合理规划IP地址,R1、R5、R6、R7各自创建一个环回,IP地址分别为192.168.1.0 、192.168.2.0、192.168.3.0、192.168.4.0 2、AS 100内使用IGP协议为OSPF ,如图运行动态路由协议 ...
  • 计算机组成原理实验

    千次阅读 2019-05-23 23:14:20
    (1)实验之前,应认真准备,写出实验步骤和具体设计内容,否则实验效率会很低,一次实验时间根本无法完成实验任务; (2)应在实验前掌握所以控制信号的作用,写出实验预习报告并带入实验室; (3)实验过程中,应...
  • 操作系统实验(一)

    千次阅读 2019-03-28 16:46:58
    操作系统实验 hello,我是橘子 最近突然发现我以前写的操作系统实验,然后分享给大家吧,就是自己写的代码也不是很好,希望大家见谅哈 实验目的 一、进程控制 ●基本要求:利用简单的结构和控制方法模拟进程结构、...
  • 实验一:基础汇编语言程序设计实验 1.实验目的:     ~~~~     1.学习和了解TEC-XP+教学实验监控命令的用法;     ~~~~     2.学习...
  • PIM-DM实验

    2020-06-20 23:20:00
    本篇是IP组播中的PIM-DM实验笔记!
  • 1.实验一 先来先服务FCFS和短作业优先SJF进程调度算法 下载地址:http://download.csdn.net/download/xunciy/10237052 FCFS SJF 2.实验二 时间片轮转RR进程调度算法 下载地址:...
  • gre over ipsec隧道实验(eNSP测试)

    万次阅读 2020-03-14 22:24:23
    1、实验拓扑 2、实验配置# 3、实验效果 在AR1的G0/0/1口捉包,PC2对PC2进行ping操作,以下是捉包看到的IP,已经给加密了,看不到两端实际的通信IP了。 1 该实验实在上个实验基础上拓展的,建议先看上个实验-...
  • 计算机组成原理-存储器实验

    万次阅读 2017-06-01 10:32:29
    实 验 报 告 课程名称: 计算机组成原理 系 (院): 信息工程学院 班 级: 计科 学生姓名: ...实验日期 2016.4.27 实验项目名称 存储器实验 实验地点 1#605 实验类型 √验证型 □设计型 □
  • 据说加班非常变态,无休止的加班加班,但是相应的福利待遇也很好。另外就是在项目之间会有较长时间的调整期,总体来看对于提升自己还是很不错的,但是不知道是不是大家都能坚持住?...
  • 一、实验目的: 1.学会使用Ping、IPConfig、TraceRt、Netstat、ARP等常用网络命令。2.学会配置网络接口IP属性(IP地址、子网掩码、默认网关)。 二、实验环境: 装有cisco packet tracer student的电脑。 三、...
  • Traditional method for scratch wound closure 通常统计的是划痕的面积随着时间的变化,以及伤口愈合的百分比。 那么其在imagej中如何实现? 详见附件。...
  • 《网络通信软件综合实验实验教学大纲一、大纲说明课程编号:课程名称(中文):网络通信软件综合实验课程名称(英文):Computer Network Communication Software Experiment适用专业:计算机科学与技术专业、网络...
  • 《计算方法》实验教学大纲

    万次阅读 2008-09-25 20:05:00
    《计算方法》实验教学大纲一、大纲说明课程编号:课程名称(中文):计算方法课程名称(英文):Numerical Method适用专业:A计算机科学与技术专业 / B网络工程专业 / C软件工程专业课程属性:学科专业课课程性质:...
  • Linux进程控制实验报告

    万次阅读 2018-05-30 23:03:27
    一、实验目的:进一步认识并发(并行)执行的概念,区别顺序执行和并发(并行)执行。分析进程争用临界资源的现象,学习解决进程排斥的方法。二、实验环境:一台至少具有256MB内存的计算机,并安装Red Hat Linux 9的...
  • 实验一:流水灯实验

    万次阅读 2017-05-29 08:36:09
    一、实验目的 1、掌握KEIL51和proteus软件的使用方法 2、掌握51单片机并行口的输出方式的编程。 3、掌握延时程序的编写和应用。 二、实验设备及软件 1、PC机 2、KEIL51 3、proteus 三、实验任务...
1 2 3 4 5 ... 20
收藏数 1,148,860
精华内容 459,544
关键字:

实验