精华内容
下载资源
问答
  • 20155328 《Java程序设计》 实验二(Java面向对象程序设计) 实验报告 单元测试 一、单元测试和TDD 编程时需理清思路,将编程需求等想好,再开始编。此部分可用伪代码实现。 用编程语言将伪代码翻译一下,就是产品...

    20155328 《Java程序设计》 实验二(Java面向对象程序设计) 实验报告

    单元测试

    一、单元测试和TDD

    • 编程时需理清思路,将编程需求等想好,再开始编。此部分可用伪代码实现。

    • 用编程语言将伪代码翻译一下,就是产品代码了。伪代码是产品代码最好的注释。

    • 写了产品代码,还要写测试代码来证明自己的代码没有问题。Java编程时对类实现的测试叫单元测试。

    关于单元测试的练习

    需求:在一个MyUtil类中解决一个百分制成绩转成“优、良、中、及格、不及格”五级制成绩的功能。

    根据需求撰写伪代码

    百分制转五分制:
       如果成绩小于60,转成“不及格”
       如果成绩在60与70之间,转成“及格”
       如果成绩在70与80之间,转成“中等”
       如果成绩在80与90之间,转成“良好”
       如果成绩在90与100之间,转成“优秀”
       其他,转成“错误”

    用Java程序语言翻译伪代码为产品代码

    package experiment2;
    public class MyUtil {
        public static String percentage2fivegrade(int grade){
            //如果成绩小于0,转成“错误”
            if (grade<0) return "错误";
            //如果成绩小于60,转成“不及格”
            if (grade<60) return "不及格";
            //如果成绩在60到70之间,转成“及格”
            else if (grade<70) return "及格";
            //如果成绩在70到80之间,转成“中等”
            else if (grade<80) return "中等";
            //如果成绩在80到90之间,转成“良好”
            else if (grade<90) return "良好";
            //如果成绩在90到100之间,转成“优秀”
            else if (grade<=100) return "优秀";
            //其他,转成“错误”
            else return "错误";
        }
    }

    接下来就是撰写测试代码,判断自己的产品代码有没有出错了: 选中MyUtil,在左边出现的小灯泡下拉菜单中选择Create Test:
    1065527-20170422173351306-113551788.png

    接着在创建出的MyUtilTest撰写测试代码:

    import junit.framework.TestCase;
    import org.junit.Test;
    public class MyUtilTest extends TestCase {
        @Test
        public void testNormal() {
            assertEquals("不及格", MyUtil.percentage2fivegrade(55));
            assertEquals("及格", MyUtil.percentage2fivegrade(65));
            assertEquals("中等", MyUtil.percentage2fivegrade(75));
            assertEquals("良好", MyUtil.percentage2fivegrade(85));
            assertEquals("优秀", MyUtil.percentage2fivegrade(95));
        }
    
        @Test
        public void testException(){
            assertEquals("错误",MyUtil.percentage2fivegrade(105));
            assertEquals("错误",MyUtil.percentage2fivegrade(-55));
        }
    
        @Test
        public void testBoundary(){
            assertEquals("不及格",MyUtil.percentage2fivegrade(0));
            assertEquals("及格",MyUtil.percentage2fivegrade(60));
            assertEquals("中等",MyUtil.percentage2fivegrade(70));
            assertEquals("良好",MyUtil.percentage2fivegrade(80));
            assertEquals("优秀",MyUtil.percentage2fivegrade(90));
            assertEquals("优秀",MyUtil.percentage2fivegrade(100));
        }
    }

    以上测试代码中的testNormal()方法用于测试一般情况,而testException()和testBoundary()则是对意外情况和边界进行测试。如果三种测试中的一种没有通过,IDEA会提示是哪一块出错,以及出了什么错误:

    1065527-20170422212556556-2110347239.png

    我们可以从图中看出是边缘测试没有通过,原本应该显示“优秀”的显示了“错误”。于是回去看MyUtil类:

    1065527-20170422212628462-799783964.png

    发现是设置“优秀”的范围时没有包含100分(我刚刚改的),所以100分便被归到了“错误”中。修改以后再次运行MyUtilTest,可看到三个测试都通过:

    1065527-20170422212653587-1992347332.png

    由此可看出,除了对普通数据的测试之外,边界情况和非法情况的测试也十分重要。

    以TDD的方式研究学习StringBuffer

    在老师的博客《积极主动敲代码,使用JUnit学习Java》中,给出了一个用于学习StringBuffer几个方法的程序:

    public class StringBufferDemo{        
       public static void main(String [] args){    
           StringBuffer buffer = new StringBuffer();    
           buffer.append('S');     
           buffer.append("tringBuffer");     
           System.out.println(buffer.charAt(1));     
           System.out.println(buffer.capacity();     
           System.out.println(buffer.indexOf("tring"));    
           System.out.println("buffer = " + buffer.toString());    
      }    
    }  

    了解这几个方法以后,选择了charAt(),length(),capacity()这三个方法,开始撰写产品代码:

    public class StringBufferDemo {
        StringBuffer buffer=new StringBuffer();
        public Character charAt(int i){
            return buffer.charAt(i);
        }
        public int length(){
            return buffer.length();
        }
        public int capacity(){
            return buffer.capacity();
        }
    }

    接着是撰写测试代码,来测试这三个方法是否正确:

    import junit.framework.TestCase;
    import org.junit.Test;
    
    public class StringBufferDemoTest extends TestCase {
        StringBuffer a=new StringBuffer("yesterday");
        StringBuffer b=new StringBuffer("tomorrowisnotnow");
        StringBuffer c=new StringBuffer("liveherenowtodayisneccessary");
        
        @Test
        public void testcharAt(){
            assertEquals('y',a.charAt(0));
            assertEquals('r',b.charAt(5));
            assertEquals('n',c.charAt(8));
        }
        
        @Test
        public void testlength(){
            assertEquals(9,a.length());
            assertEquals(16,b.length());
            assertEquals(28,c.length());
        }
        
        @Test
        public void testcapacity(){
            assertEquals(25,a.capacity());
            assertEquals(32,b.capacity());
            assertEquals(44,c.capacity());
        }
    }

    在测试代码中,我设定了三个长度逐渐增加的字符串。运行后,显示测试成功。

    以TDD的方式开发一个复数类Complex

    要求:定义属性并生成getter,setter;定义构造函数;定义公有方法(加减乘除)。

    测试代码:

    import junit.framework.TestCase;
    import org.junit.Test;
    
    public class ComplexTest extends TestCase {
        Complex a=new Complex(1,2);
        Complex b=new Complex(-2,-1);
        Complex c=new Complex(4,-2);
        Complex d=new Complex(4,-2);
        @Test
        public void testequals(){
            assertEquals(false,a.equals(b));
            assertEquals(false,b.equals(c));
            assertEquals(true,c.equals(d));
        }
    
        @Test
        public void testAdd(){
            assertEquals(new Complex(-1,1),a.ComplexAdd(b));
            assertEquals(new Complex(5,0),a.ComplexAdd(c));
        }
    
        @Test
        public void testSub(){
            assertEquals(new Complex(3,3),a.ComplexSub(b));
            assertEquals(new Complex(-3,4),a.ComplexSub(c));
        }
    
        @Test
        public void testMulti(){
            assertEquals(new Complex(0,-5),a.ComplexMulti(b));
            assertEquals(new Complex(8,6),a.ComplexMulti(c));
        }
    
        @Test
        public void testDiv(){
            assertEquals(new Complex(0,0.5),a.ComplexDiv(c));
            assertEquals(new Complex(-0.3,-0.4),b.ComplexDiv(c));
        }
    }

    产品代码:

    public class Complex {
        // 定义属性并生成getter,setter
        private double r;
        private double i;
        // 定义构造函数
        public Complex(double r,double i){
            this.r=r;
            this.i=i;
        }
        public static double getRealPart(double r){
            return r;
        }
        public static double getImagePart(double i){
            return i;
        }
    
        //Override Object
        public boolean equals(Object obj){
    
            Complex complex=(Complex) obj;
            if (complex.r!=r) {
                return false;
            }
            if(complex.i!=i){
                return false;
            }
            return true;
        }
        public String toString(){
            String str=new String();
            if (i==0) str=r+"";
            else if(i<0) str=r + ""+i+"i";
            else str=r+""+"+"+i+"i";
            return str;
        }
    
        // 定义公有方法:加减乘除
        Complex ComplexAdd(Complex a){
            return new Complex(r+a.r,i+a.i);
        }
        Complex ComplexSub(Complex a){
            return new Complex(r-a.r,i-a.i);
        }
        Complex ComplexMulti(Complex a){
            return new Complex(r*a.r-i*a.i,r*a.i+i*a.r);
        }
        Complex ComplexDiv(Complex a){
            return new Complex((r*a.r+i*a.i)/(a.r*a.r+a.i*a.i),(i*a.r-r*a.i)/(a.r*a.r+a.i*a.i));
        }
    }

    测试成功截图:

    1065527-20170423092948397-91212633.png

    二、面向对象三要素

    面向对象的三要素是封装、继承与多态。为借助抽象思维用好三要素:SOLID原则给出了指导。

    • SRP,单一职责原则;

    • OCP,开放-封闭原则;

    • LSP,替换原则;

    • ISP,接口分离原则;

    • DIP,依赖倒置原则。

    练习,体会OCP原则和DIP原则的应用

    老师给出的设计模式示例代码如下:

    // Server Classes 
    abstract class Data { 
        abstract public void DisplayValue(); 
    }
    class Integer extends  Data {    
        int value; 
        Integer() {
             value=100; 
        }  
        public void DisplayValue(){
            System.out.println (value);
        } 
     } 
    // Pattern Classes 
    abstract class Factory { 
       abstract public Data CreateDataObject(); 
    }
    class IntFactory extends Factory { 
       public Data CreateDataObject(){
         return new Integer(); 
       } 
    } 
    //Client classes 
    class Document {    
        Data pd; 
        Document(Factory pf){ 
           pd = pf.CreateDataObject(); 
        } 
        public void DisplayData(){
           pd.DisplayValue(); 
       } 
     } 
     //Test class
     public class MyDoc {
        static Document d;
        public static void main(String[] args) {
                d = new Document(new IntFactory()); 
                d.DisplayData(); 
        }   
    }

    用我的学号(28)模6取余,得到4,须根据以下结果进行代码扩充:让系统支持Float类,并在MyDoc类中添加测试代码表明添加正确。

        abstract class Data {
            abstract public void DisplayValue();
        }
        class Integer extends  Data {
            int value;
            Integer() {
                value=100;
            }
            public void DisplayValue(){
                System.out.println (value);
            }
        }
        class Float extends Data{
            float value;
            Float(){
                value=20155328;
            }
            public void DisplayValue(){
                System.out.println(value);
            }
        }
        // Pattern Classes
        abstract class Factory {
            abstract public Data CreateDataObject();
        }
        class IntFactory extends Factory {
            public Data CreateDataObject(){
                return new Integer();
            }
        }
        class FloatFactory extends Factory{
            public Data CreateDataObject(){
                return new Float();
            }
        }

    测试代码如下:

        //Test class
        public class MyDoc {
            static Document d;
            public static void main(String[] args) {
                d = new Document(new FloatFactory());
                d.DisplayData();
            }
        }

    使用StarUML进行建模,画类图

    1065527-20170423091531647-1982519760.png

    三、实验中遇到的问题及解决方式

    • 问题1:对StringBuffer的capacity()方法理解不太清晰。

    • 解决方法:参考StringBuffer的Capacity详解及实践,知StringBuffer的默认大小是16,即如果长度小于16则默认容量为16,当StringBuffer达到最大容量时,会将最大容量增加到原来容量的两倍再加2.

    • 问题2:在测试Complex类时,出现了这样的red bar:

    1065527-20170423094610257-1615570195.png

    • 解决方法:由图可知是equals()方法的撰写出现了问题,于是回到Complex中重新撰写如下:
        public boolean equals(Object obj){
    
            Complex complex=(Complex) obj;
            if (complex.r!=r) {
                return false;
            }
            if(complex.i!=i){
                return false;
            }
            return true;
        }

    然后再次测试,显示测试成功。

    四、实验体会

    相比起第一次实验,觉得这次实验让自己受益匪浅。在实验课前花了不少的时间跟着老师的step by step教程慢慢学习,体会到了单元测试的实用性。以前写代码就算会自己带一些测试之类的东西来看看是否正确,但一旦结果出错也需要耗费较长的时间去找出错误,而单元测试就可以通过red bar和错误提示很快找到错误源头,然后解决。希望自己以后可以更好更熟练的掌握TDD编程方法吧。

    转载于:https://www.cnblogs.com/zyqzyq/p/6747415.html

    展开全文
  • 关于Java语言程序设计基础篇的实验报告
  • 这是我这学期做的java web期末测试题,有关于网上花店实现,希望对你们有用。用户管理:创建一个名为user数据Bean,用于存放user表数据,创建一个名为UserDao业务Bean,封装对user表查询、修改、删除操作。...
  • JAVA简单记事本程序设计实验报告(带源码) 课题:学生成绩管理 4.功能要求: 编写一个简单记事本程序,要求包含以下菜单项 文件 新建、打开、保存、退出 编辑 剪切、拷贝、粘贴、查找 帮助 关于 5.实现文件和编辑...
  • JAVA实验报告

    2012-01-01 14:22:10
    JAVA实验报告,有关于JAVA语言程序设计基础的实验报告
  • 设计一个java程序,从键盘输入若干整数,以0作为结束标志,计算其中最大值、最小值及平均值 由于要求输入若干整数,并未给定一个数组范围,所以决定采用“动态数组”ArrayList。 当我准备对ArrayList进行求和时,...

    这个周在完成学校的java实验报告,其中几个实验遇上了一些小问题。
    实验之一:
    设计一个java程序,从键盘输入若干整数,以0作为结束标志,计算其中的最大值、最小值及平均值

    由于要求输入若干整数,并未给定一个数组范围,所以决定采用“动态数组”ArrayList。

    在这里插入图片描述
    当我准备对ArrayList进行求和时,编译器提示“+=” 操作对int,和object类型定义。
    所以,决定将转化为数组。
    在这里插入图片描述
    当我试图求平均值时,发先所求出的平均值并不正确。
    在这里插入图片描述
    经过排查,发现是用Int类型的数相除时,如果不能除尽,也会得到一个整数,则造成错误。例如上图中3/2本来是等于1.5,略等于成整数1了。
    java做除法运算,为什么除不开时也会得到整数呢?
    java除法运算(保留小数)
    解决方法有:
    1.将除数和被除数都声明为double类
    2.采用 DecimalFormat 类,再规定小数精确位数。

    在这里插入图片描述
    采用后,得到一个正确的结果

    在这里插入图片描述

    展开全文
  • java实验报告

    2013-06-21 11:47:55
    java课程设计友谊各项进解释 并且了解多线程定义 其中有关于某些小程序的相近剖析
  • JavaFx/Java 大作业 五子棋 实验报告

    千次阅读 2020-07-01 17:50:36
    Java大作业五子棋实验报告 实验目的 通过此次实验,对这一学期学习内容尤其是界面开发部分做了一个很好回顾,看似简单五子棋程序设计好也确实费了我一点功夫 功能模块简介和系统结构图 ChessGame类 作为布局...

    Java大作业五子棋实验报告

    实验目的

    通过此次实验,对这一学期学习的内容尤其是界面开发部分做了一个很好的回顾,看似简单的五子棋程序,设计好也确实费了我一点功夫

    功能模块简介和系统结构图

    ChessGame类

    作为布局的基类,设置一些基本的按钮,用于启动程序,接收一些基本参数的传入(如谁先行)

    ChessPane类

    本类主要保存一些关于界面的基本信息,起到绘制界面,绘制棋子的功能

    UserPlay类

    本类存储一些关于用户动作的基本信息,接受并处理PlayAction传回的动作信息

    PlayAction类

    本类用于接收用户传入的关于棋局的动作信息

    系统结构图

    图片

    系统主界面设计及运行说明

    主界面设计

    如下图所示
    图片

    图片

    运行说明

    启动程序后,先选择先行方,如果不选择,默认黑棋先行,此后,双方轮流下子,直到一方先连成五子,游戏结束。

    主要的源程序代码

    使用到的包

    import javafx.application.*;
    import javafx.geometry.Insets;
    import javafx.geometry.Pos;
    import javafx.scene.*;
    import javafx.scene.control.Alert;
    import javafx.scene.control.Button;
    import javafx.scene.control.Dialog;
    import javafx.scene.input.MouseEvent;
    import javafx.scene.paint.Color;
    import javafx.stage.*;
    import javafx.scene.layout.*;
    import javafx.scene.text.*;
    import javafx.scene.canvas.*;
    import javafx.event.*;
    

    ChessGame类

    public class ChessGame extends Application {
        public static void main(String[] args) {
            Application.launch(args);
        }
    
        @Override
        public void start(Stage primaryStage) throws Exception {
            //新建棋盘实例
            ChessPane chessPane = new ChessPane();
            BorderPane borderPane = new BorderPane();
            UserPlay userPlay = new UserPlay();
            PlayAction playAction = new PlayAction(chessPane, userPlay);//将chessPane实例与playAction相关联
            chessPane.setOnMouseClicked(playAction);//将chessPane实例添加鼠标事件
    
    
            //把棋盘定位在边界面板中央
            borderPane.setCenter(chessPane);
    
            //todo 构造一个Vbox放按钮
            VBox vBoxButton = new VBox();
            vBoxButton.getChildren().addAll();//添加结点
            borderPane.setRight(vBoxButton);//将vbox放在面板右侧
            vBoxButton.setSpacing(100);//设置按钮间的距离为100
            vBoxButton.setAlignment(Pos.CENTER);//设置vbox居中
            vBoxButton.setPadding(new Insets(0, 30, 0, 0));//设置右边距
    
            //todo 重玩按钮
            Button buttonReplay = new Button("Try again");
    
            //设置按钮格式
            buttonReplay.setPrefHeight(50);
            buttonReplay.setPrefWidth(100);
            buttonReplay.setStyle("-fx-background-color:linear-gradient(to right,#00fffc,#fff600);-fx-background-radius:25 ;-fx-border-radius:25;-fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.7), 10, 0, 0, 1);");
    
    //        vBoxButton.getChildren().add(buttonReplay);
    
            buttonReplay.setOnMouseClicked(event -> {
                primaryStage.close();
            });
    
    
            //todo 退出按钮
            Button buttonExit = new Button("Exit");
            vBoxButton.getChildren().add(buttonExit);
    
            //设置按钮格式
            buttonExit.setPrefHeight(50);
            buttonExit.setPrefWidth(100);
            buttonExit.setStyle("-fx-background-color:linear-gradient(to right,#d580ff,#80d5ff);-fx-background-radius:25 ;-fx-border-radius:25;-fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.7), 10, 0, 0, 1);");
            //设置退出事件
            buttonExit.setOnMouseClicked(event -> {
                primaryStage.close();
            });
    
            //todo 切换AI 人人对战按钮
    
    
            Scene scene = new Scene(borderPane, 800, 800);
            primaryStage.setScene(scene);
            primaryStage.setTitle("五子棋");
            primaryStage.show();
    
            //todo 初始是谁先下
            BorderPane borderPaneFirst = new BorderPane();
            Scene sceneFirst = new Scene(borderPaneFirst, 300, 300);
            HBox hBoxFirst = new HBox();
            borderPaneFirst.setCenter(hBoxFirst);
    
            hBoxFirst.setAlignment(Pos.CENTER);
            hBoxFirst.setSpacing(50);
    
            Button buttonFirstBlack = new Button("black first");
            buttonFirstBlack.setPrefWidth(100);
            buttonFirstBlack.setPrefHeight(50);
            buttonFirstBlack.setStyle("-fx-background-color:linear-gradient(to right,#00fffc,#fff600);-fx-background-radius:25 ;-fx-border-radius:25;-fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.7), 10, 0, 0, 1);");
            hBoxFirst.getChildren().add(buttonFirstBlack);
    
            Button buttonFirstWhite = new Button("white first");
            buttonFirstWhite.setPrefHeight(50);
            buttonFirstWhite.setPrefWidth(100);
            buttonFirstWhite.setStyle("-fx-background-color:linear-gradient(to right,#FFFFCC,#FFCCFF);-fx-background-radius:25 ;-fx-border-radius:25;-fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.7), 10, 0, 0, 1);");
            hBoxFirst.getChildren().add(buttonFirstWhite);
    
            Stage stageWhoFirst = new Stage();
            stageWhoFirst.setScene(sceneFirst);
            stageWhoFirst.setTitle("Who first?");
            stageWhoFirst.show();
    
            buttonFirstBlack.setOnMouseClicked(event -> {
                userPlay.setCurrentSide(1);
                stageWhoFirst.close();
            });
    
            buttonFirstWhite.setOnMouseClicked(event -> {
                userPlay.setCurrentSide(2);
                stageWhoFirst.close();
            });
    
        }
    
    }
    
    

    UserPlay类

    //用户操作类
    class UserPlay extends ChessPane {
    
    
        private int sideLength = getSideLength();//设定边长
        private double width = getWidth();//棋盘宽
        private double height = getPaneHeight();//棋盘高
        private double cellLen = getCellLen();//每个方格的长度
        /**
         * currentside 表示当前的玩家
         * 如果是黑为1
         * 白为2
         */
        private int currentSide = 1;
    
        public int getCurrentSide() {
            return currentSide;
        }
    
        public void setCurrentSide(int currentSide) {
            this.currentSide = currentSide;
        }
    
        private int[][] chess = new int[sideLength + 10][sideLength + 10];//定义数组存棋盘
    
        void initChess() {
            for (int i = 0; i <= sideLength; i++) {
                for (int j = 0; j <= sideLength; j++) {
                    chess[i][j] = 0;
                }
            }
        }
    
        /**
         * 得到x,y坐标后
         * 判断应该填在数组的哪个方格
         */
    
        public int realX, realY;//应该填的位置
    
        public int getRealX(int x) {
            boolean isRealX = false;//是不是找到了应该填的位置
            int RangeX = (int) getAlign();
            //在x的范围以10为左右边界找对应列
            System.out.println(RangeX + getCellLen() * getSideLength());
            for (int i = RangeX, j = 0; i < RangeX + getCellLen() * getSideLength(); i += getCellLen(), j++) {
                if ((x >= i - 10) && (x <= i + 10)) {
                    realX = j;
                    isRealX = true;
                    break;
                }
            }
            //debug in function
            System.out.println("xinf: " + x);
            System.out.println("realX: " + realX);
            if (isRealX) return realX;
            else return -1;
        }
    
        public int getRealY(int y) {
            boolean isRealY = false;//是不是找到了应该填的位置
            int RangeY = (int) getAlign();
            //在y的范围以10为左右边界找对应行
            for (int i = RangeY, j = 0; i < RangeY + getCellLen() * getSideLength(); i += getCellLen(), j++) {
                if ((y >= i - 10) && (y <= i + 10)) {
                    realY = j;
                    isRealY = true;
                    break;
                }
            }
            //debug in function
            System.out.println("yinf: " + y);
            System.out.println("realY: " + realY);
            if (isRealY) return realY;
            else return -1;
        }
    
        /**
         * 判断是否越界 越界为true 不越界为false
         */
        public boolean isOverArea(int findX, int findY) {
            return findX == -1 || findY == -1;
        }
    
        /**
         * 落子,如果不符合范围,则显示警告信息
         */
        public boolean dropDownTheChess(int x, int y) {
    
            if (!isOverArea(x, y) && chess[x][y] == 0) {
                chess[x][y] = currentSide;
                //debug chess
                System.out.println("chessxy  " + chess[x][y]);
                return true;
            } else {
                //显示提示错误框
                Alert alert = new Alert(Alert.AlertType.ERROR);
                alert.setTitle("错误");
                alert.setContentText("棋子不可以下在这里");
                alert.showAndWait();
                return false;
            }
        }
    
        /**
         * 换边
         */
        public void changeSide() {
            if (currentSide == 1) currentSide = 2;
            else currentSide = 1;
        }
    
        /**
         * 判断游戏是否结束
         * true 结束游戏
         * false 继续游戏
         */
        public boolean judgeGame(int row, int col, int chessColor) {
            int plane = plane(row, col, chessColor);
            int vertical = vertical(row, col, chessColor);
            int left = leftOblique(row, col, chessColor);
            int right = rightOblique(row, col, chessColor);
            changeSide();//换边
            //debug
            System.out.println("currentsideinjudge" + currentSide);
            System.out.println("plane" + plane);
            System.out.println("vertical" + vertical);
            System.out.println("left" + left);
            System.out.println("right" + right);
    
            if (plane >= 5 || vertical >= 5 || left >= 5 || right >= 5) {
                return true;
            } else return false;
        }
    
        /**
         * 判断有没有出界
         */
        public boolean judgementOverArea(int x, int y) {
            if (x >= 0 && x <= getSideLength() && y >= 0 && y <= getSideLength()) {
                return false;
            } else return true;
        }
    
        /**
         * 水平线上是否连成五子
         *
         * @param row
         * @param col
         * @param chessColor
         * @return
         */
        public int plane(int row, int col, int chessColor) {
            int line = 1;
            int i = row - 1;
            for (; !judgementOverArea(i, col) && chess[i][col] == chessColor; i--)
                line++;
            for (i = row + 1; !judgementOverArea(i, col) && chess[i][col] == chessColor; i++)
                line++;
            return line;
        }
    
        /**
         * 检查棋子在垂直竖线上是否连成五子
         *
         * @param row
         * @param col
         * @param chessColor
         * @return
         */
        public int vertical(int row, int col, int chessColor) {
            int line = 1;
            int j = col - 1;
            for (; !judgementOverArea(row, j) && chess[row][j] == chessColor; j--)
                line++;
            for (j = col + 1; !judgementOverArea(row, j) && chess[row][j] == chessColor; j++)
                line++;
            return line;
        }
    
        /**
         * 检查左倾斜线上的棋子是否连成五子
         *
         * @param row
         * @param col
         * @param chessColor
         * @return
         */
        public int leftOblique(int row, int col, int chessColor) {
            int line = 1;
            int i = row - 1, j = col - 1;
            for (; !judgementOverArea(i, j) && chess[i][j] == chessColor; i--, j--)
                line++;
            for (i = row + 1, j = col + 1; !judgementOverArea(i, j) && chess[i][j] == chessColor; i++, j++)
                line++;
            return line;
        }
    
        /**
         * 检查右倾斜线上的棋子是否连成五子
         *
         * @param row
         * @param col
         * @param chessColor
         * @return
         */
        public int rightOblique(int row, int col, int chessColor) {
            int line = 1;
            int i = row - 1, j = col + 1;
            for (; !judgementOverArea(i, j) && chess[i][j] == chessColor; i--, j++)
                line++;
            for (i = row + 1, j = col - 1; !judgementOverArea(i, j) && chess[i][j] == chessColor; i++, j--)
                line++;
            return line;
        }
    }
    

    ChessPane类

    /**
     * 面板类——做基类——定义基本信息
     */
    class ChessPane extends Pane {
    
        public Canvas canvas;//创建一个画板
        public GraphicsContext graphicsContext;
    
        private double cellLen = 40;//这里定义cell的长度
        private double align = 70; //定义一个边界值,表示棋盘离程序边框的边界,从而使棋盘居中
        private double paneWidth = 560;//棋盘宽
        private double paneHeight = 560;//棋盘高
        private int sideLength = 15;//设定边长
    
        // todo 可以将这个ChessPane再放到一个边界面板的中心,top部位放操作按钮
    
    
        public void setAlign(double align) {
            this.align = align;
        }
    
        public void setCanvas(Canvas canvas) {
            this.canvas = canvas;
        }
    
        public void setCellLen(double cellLen) {
            this.cellLen = cellLen;
        }
    
        public void setGraphicsContext(GraphicsContext graphicsContext) {
            this.graphicsContext = graphicsContext;
        }
    
        public void setPaneHeight(double paneHeight) {
            this.paneHeight = paneHeight;
        }
    
        public void setPaneWidth(double paneWidth) {
            this.paneWidth = paneWidth;
        }
    
        public void setSideLength(int sideLength) {
            this.sideLength = sideLength;
        }
    
        public Canvas getCanvas() {
            return canvas;
        }
    
        public double getCellLen() {
            return cellLen;
        }
    
        public double getPaneHeight() {
            return paneHeight;
        }
    
        public double getPaneWidth() {
            return paneWidth;
        }
    
        public int getSideLength() {
            return sideLength;
        }
    
        public double getAlign() {
            return align;
        }
    
        public ChessPane() {
            draw();
            getChildren().add(canvas);//将画板添加到自定义面板的结点上
        }
    
        public void draw() {
            canvas = new Canvas(700, 700);
            //制图环境
            this.graphicsContext = canvas.getGraphicsContext2D();
    
    
            graphicsContext.setFill(Color.BURLYWOOD);//将画布底色改为木色
            graphicsContext.fillRect(align - 15, align - 15, 560 + 30, 560 + 30);//绘制填充矩形
    
            //画横线
            for (int i = 0; i < 15; i++) {
                graphicsContext.strokeLine(align, i * cellLen + align, 560 + align, i * cellLen + align);
            }
            //画竖线
            for (int i = 0; i < 15; i++) {
                graphicsContext.strokeLine(i * cellLen + align, align, i * cellLen + align, 560 + align);
            }
    
            for (int i = 3; i <= 14; i += 4)
                for (int j = 3; j <= 14; ) {
                    graphicsContext.setFill(Color.BLACK);
                    //画天元
                    if (i == 7) {
                        j = 7;
                        graphicsContext.strokeOval(i * cellLen + align - 4, j * cellLen + align - 4, 8, 8);
                        graphicsContext.fillOval(i * cellLen + align - 4, j * cellLen + align - 4, 8, 8);
                        break;
                    }
                    //画星位
                    else {
                        graphicsContext.strokeOval(i * cellLen + align - 4, j * cellLen + align - 4, 8, 8);
                        graphicsContext.fillOval(i * cellLen + align - 4, j * cellLen + align - 4, 8, 8);
                        j += 8;
                    }
                }
    
            //边框加粗设计
            graphicsContext.setLineWidth(3.0f);//改变绘制的边线粗细
            graphicsContext.strokeRect(align, align, 560, 560);//绘制一个正方形覆盖原先的矩形
    
    //        graphicsContext.setFill(Color.BLACK);
    //        graphicsContext.strokeOval(getAlign() + 1 * cellLen - cellLen / 2, getAlign() + 0 * cellLen - cellLen / 2, cellLen, cellLen);
        }
    
        /**
         * 画棋子
         */
        public void paintChess(int x, int y, int currentSide) {
            System.out.println("xinPaintChess" + x);
            System.out.println("yinPaintChess" + y);
            if (currentSide == 1) {
                graphicsContext.setFill(Color.BLACK);
            } else {
                graphicsContext.setFill(Color.WHITE);
            }
            System.out.println(getAlign() + x * cellLen);
            System.out.println(getAlign() + y * cellLen);
            System.out.println("currentsideinPaintChess" + currentSide);
            //大棋子
    //        graphicsContext.strokeOval(getAlign() + x * cellLen - cellLen / 2, getAlign() + y * cellLen - cellLen / 2, cellLen, cellLen);
    //        graphicsContext.fillOval(getAlign() + x * cellLen - cellLen / 2, getAlign() + y * cellLen - cellLen / 2, cellLen, cellLen);
    
            //小棋子
            graphicsContext.strokeOval(getAlign() + x * cellLen - cellLen / 3, getAlign() + y * cellLen - cellLen / 3, cellLen - 10, cellLen - 10);
            graphicsContext.fillOval(getAlign() + x * cellLen - cellLen / 3, getAlign() + y * cellLen - cellLen / 3, cellLen - 10, cellLen - 10);
        }
    
    }
    

    PlayAction类

    class PlayAction extends UserPlay implements EventHandler<MouseEvent> {
        private ChessPane chessPane;
        private UserPlay userPlay;
    
        public PlayAction(ChessPane chessPane, UserPlay userPlay) {
            this.chessPane = chessPane;
            this.userPlay = userPlay;
        }
    
        @Override
        public void handle(MouseEvent event) {
            double cellLen = getCellLen();
    
            //定位
            int x = (int) (event.getX());
            int y = (int) (event.getY());
    
            //debug 鼠标定位
            System.out.println("x: " + x);
            System.out.println("y: " + y);
    
            //如果位置合法就画出棋子
            int realX, realY;
            realX = getRealX(x); //将x,y坐标回传
            realY = getRealY(y);
            if (userPlay.dropDownTheChess(realX, realY)) {
                chessPane.paintChess(realX, realY, userPlay.getCurrentSide());
                if (userPlay.judgeGame(realX, realY, userPlay.getCurrentSide())) {
                    Alert alert1 = new Alert(Alert.AlertType.INFORMATION);
                    alert1.setTitle("Author's smile");
                    String winner;
                    if (userPlay.getCurrentSide() == 1) {
                        winner = "white side";
                    } else winner = "black side";
                    alert1.setContentText("Game over " + winner + " is winner!");
                    alert1.showAndWait();
                }
            }
    
        }
    
    

    实验总结

    收获

    通过此次实验,我在写代码的过程中体会到了动手实践对于Java编程学习的重要性,学到了以下知识

    1. CanavaJavaFx界面开发中绘制图形的应用

    https://blog.csdn.net/u010164507/article/details/89106632

    1. 使用this显式激活构造方法
    2. Alert的基本使用(show!)
    3. Button的简单美化

    创新

    1. 精确的将鼠标位置和数组值相联系

    存在的不足

    1. 没有实现重玩的按钮,在前期设计中对于初始化不便
    2. 没有实现AI和人的对战

    需要改进的地方

    1. 整体的系统架构不尽合理,有需要改善的空间,在写代码时,函数与变量的调用多有不便,参数回传较为凌乱
    展开全文
  • Java Applet程序设计

    2014-03-17 18:41:34
    这是关于Java Applet小程序实验的实验报告,希望能帮助到你们
  • 实验目的:对教材排序和查找内容进行补充,参考博客内容对相关方法进行实现,对已经实现代码进行重构和打包,并结合这两周所学习的关于树、堆、桶等知识进行组合,学以致用。 实验要求: 1.完成教材P302 Searching...

    实验名称:排序与查找
    实验目的:对教材排序和查找内容进行补充,参考博客内容对相关方法进行实现,对已经实现的代码进行重构和打包,并结合这两周所学习的关于树、堆、桶等知识进行组合,学以致用。
    实验要求:
    1.完成教材P302 Searching.Java ,P305 Sorting.java中方法的测试
    不少于10个测试用例,提交测试用例设计情况(正常,异常,边界,正序,逆序),用例数据中要包含自己学号的后四位
    2.重构你的代码
    把Sorting.java Searching.java放入 cn.edu.besti.cs1623.(姓名首字母+四位学号)  包中
    把测试代码放test包中
    重新编译,运行代码,提交编译,运行的截图(IDEA,命令行两种)
    3.对searching类进行方法的补充,添加顺序、分块、树表、二分、插值、哈希、斐波那契等几种查找方法,并进行测试。
    4.补充实现课上讲过的排序方法:希尔排序,堆排序,桶排序,二叉树排序等
    测试实现的算法(正常,异常,边界)
    实验日期:2017.11.6
    指导老师:娄老师、王老师

    实验过程:
    1.对教材上的Searching和Sorting类进行编译,教程中这两个类已经基本实现了方法,只需要编写一个测试类,测试运行即可。这里的测试类可以通过定义整型数来实现,需要使用integer方法,通过if语句来判断查找的返回值,并输出结果:
    String found = new String();
    if (found == null)
    System.out.println("");
    else
    System.out.println(" " + found);
    这里可以看出,当查找的内容不存在时,会返回空。
    integer整数值的代码:
    Integer[] n = {23,38,12,34,254,86,91,116,144,149,120,2309};
    Integer o = (Integer) Searching.linearSearch(n, 3);
    Integer p = (Integer) Searching.linearSearch(n, 8);
    Integer q = (Integer) Searching.linearSearch(n, 2309);
    Integer r = (Integer) Searching.linearSearch(n, 120);
    Integer s = (Integer) Searching.linearSearch(n, 12);
    Integer t = (Integer) Searching.linearSearch(n, 91);
    查找部分可以通过此方法实现。
    排序部分的实现方法是通过比较长度来判断顺序的,具体实现方法如下:
    for (int i = 0; i < n1.length; i++)
    System.out.print(n1[i]+" ");
    System.out.println();
    sorting.selectionSort(n2);
    for (int i = 0; i < n2.length; i++)
    System.out.print(n2[i]+" ");
    System.out.println();
    sorting.insertionSort(n3);
    for (int i = 0; i < n3.length; i++)
    System.out.print(n3[i]+" ");
    System.out.println();
    sorting.mergeSort(n5,3,n5.length-1);
    for (int i = 0; i < n5.length; i++)
    对输入的数进行判断即可实现方法。
    1066526-20171108111247856-730077195.png

    2.重构代码,将代码分别导入到包内,并重新测试,同时需要在cmd命令行下运行。
    这个过程就相对比较简单了,在idea方便的操作系统下,只需要在src目录下新建一个包,再将相应的java文件拖进去就可以了。
    同时在命令行下运行和在idea上运行没有太大的区别,只是需要编译过程,这里可以使用mkdir命令新建一个文件夹,在新建的目录里运行
    1066526-20171108122943044-102963999.png

    1066526-20171108122953575-1958990228.png

    3.实验3的内容相对较多,需要补充较多的方法,根据博客内容进行改进。
    实验三是对searching类的改进,分别需要补充顺序、树表、分块、斐波那契、二分、哈希、插值这几种查找方法,博客里给到了实现思路和c语言的实现方法,作为java语言的类比,可以对这些方法进行编写。
    代码实现过程(关键部分):
    private static int Insert_Search(int[] num, int key) {
    int low, high, mid;
    low = 0;
    high = num.length - 1;
    while (low <= high) {
    mid = low + (high - low) * (key - num[low])/ (num[high] - num[low]);
    // 插值查找  
    if (key < num[mid])
    high = mid - 1;
    else if (key > num[mid])
    low = mid + 1;
    else
    return mid;
    }
    return -1;
    }
    public final static int MAXSIZE = 20;
    插值查找的实现可以通过上述方法,首先需要了解插值查找的基本原理:
    首先考虑一个新问题,为什么一定要是折半,而不是折四分之一或者折更多呢?
    打个比方,在英文字典里面查“apple”,你下意识翻开字典是翻前面的书页还是后面的书页呢?如果再让你查“zoo”,你又怎么查?很显然,这里你绝对不会是从中间开始查起,而是有一定目的的往前或往后翻。
    同样的,比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5, 我们自然会考虑从数组下标较小的开始查找。
    经过以上分析,折半查找这种查找方式,还是有改进空间的,并不一定是折半的!
    mid = (low+high)/ 2, 即 mid = low + 1/2 * (high - low);
    改进为下面的计算机方案(不知道具体过程):mid = low + (key - a[low]) / (a[high] - a[low]) * (high - low),也就是将上述的比例参数1/2改进了,根据关键字在整个有序表中所处的位置,让mid值的变化更靠近关键字key,这样也就间接地减少了比较次数。

    分析:从时间复杂度上来看,它也是o(n),但是对于表长较大,而关键字分布又比较均匀的查找表来说,插值查找算法的平均性能比折半查找要好的多。反之,数组中如果分布非常不均匀,那么差值查找未必是很合适的选择。
    插值查找是一种有序查找,需要判断有序,关键实现方法也是需要if判断语句:‘
    mid = low + (high - low) * (key - num[low])/ (num[high] - num[low]);  
    if (key < num[mid])
    high = mid - 1;
    else if (key > num[mid])
    low = mid + 1;
    else
    这里如果等于则直接还回下标值 ,则为:
    return mid;
    }
    return -1;
    }
    }
    在输入数组后就可以运行了。
    1066526-20171108163720419-735454562.png

    其次的一个关键点是斐波那契查找,受限需要了解什么是斐波那契查找:
    斐波那契数列,又称黄金分割数列,指的是这样一个数列:1、1、2、3、5、8、13、21、····,在数学上,斐波那契被递归方法如下定义:F(1)=1,F(2)=1,F(n)=f(n-1)+F(n-2) (n>=2)。该数列越往后相邻的两个数的比值越趋向于黄金比例值(0.618)。
    斐波那契查找就是在二分查找的基础上根据斐波那契数列进行分割的。在斐波那契数列找一个等于略大于查找表中元素个数的数F[n],将原查找表扩展为长度为Fn,完成后进行斐波那契分割,即F[n]个元素分割为前半部分F[n-1]个元素,后半部分F[n-2]个元素,找出要查找的元素在那一部分并递归,直到找到。
    斐波那契查找的时间复杂度还是O(log 2 n ),但是 与折半查找相比,斐波那契查找的优点是它只涉及加法和减法运算,而不用除法,而除法比加减法要占用更多的时间,因此,斐波那契查找的运行时间理论上比折半查找小,但是还是得视具体情况而定。
    对于斐波那契数列:1、1、2、3、5、8、13、21、34、55、89……(也可以从0开始),前后两个数字的比值随着数列的增加,越来越接近黄金比值0.618。比如这里的89,把它想象成整个有序表的元素个数,而89是由前面的两个斐波那契数34和55相加之后的和,也就是说把元素个数为89的有序表分成由前55个数据元素组成的前半段和由后34个数据元素组成的后半段,那么前半段元素个数和整个有序表长度的比值就接近黄金比值0.618,假如要查找的元素在前半段,那么继续按照斐波那契数列来看,55 = 34 + 21,所以继续把前半段分成前34个数据元素的前半段和后21个元素的后半段,继续查找,如此反复,直到查找成功或失败,这样就把斐波那契数列应用到查找算法中了。
    1066526-20171108164238200-1249422210.png

    从图中可以看出,当有序表的元素个数不是斐波那契数列中的某个数字时,需要把有序表的元素个数长度补齐,让它成为斐波那契数列中的一个数值,当然把原有序表截断肯定是不可能的,不然还怎么查找。然后图中标识每次取斐波那契数列中的某个值时(F[k]),都会进行-1操作,这是因为有序表数组位序从0开始的,纯粹是为了迎合位序从0开始。
    实际上的代码实现:
    public static int[] fibonacci(){
    int[] f = new int[20];
    int i =0;
    f[0] = 1;
    f[1] = 1;
    for(i=2;i<MAXSIZE;i++){
    f[i] = f[i-1]+f[i-2];
    }
    return f;
    }
    首先需要定义斐波那契数组,需要定义长度。
    然后是具体的方法实现:
    public static int fibonacciSearch(int[] data,int key){
    int low = 0;
    int high = data.length-1;
    int mid = 0;

        int k = 0;
    
    
        int i=0;
    
    
        int[] f = fibonacci();
    
    
        while(data.length>f[k]-1){
            k++;
        }

    和二叉查找树类似,定义一个key值可以便于方法的实现,在比较长度的方法上,斐波那契查找重点是需要确定查找元素的位置,在比较过程中,key值的作用就可以体现出来了:
    for(i=data.length;i<f[k]-1;i++){
    temp[i]=temp[high];
    }
    for(int j:temp){
    System.out.print(j+" ");
    }
    System.out.println();

        while( low <= high )
        {
            mid = low + f[k-1] - 1;

    写完测试类就可以运行了:
    1066526-20171108170507091-351696459.png

    二分、分块在时现方法上是一个递进的过程,实现过程可以类比。希尔查找需要用到希尔函数,在使用上可以建立希尔函数,同样可以输入key值,通过位置查找:
    public static int searchHash(int[] hash, int hashLength, int key) {
    // 哈希函数  
    int hashAddress = key % hashLength;

        while (hash[hashAddress] != 0 && hash[hashAddress] != key) {
            hashAddress = (++hashAddress) % hashLength;
        }
    
        if (hash[hashAddress] == 0)
            return -1 ;
        return hashAddress;
    
    }

    定义函数后,方法就很好实现了。
    4.关于排序的补充:
    实验四是对排序方法的各种补充,包括桶排序、堆排序、希尔排序和二叉树排序,几种排序方法都可以通过教材上的相关方法实现。
    首先是最近课上所补充的堆排序方法:
    同样需要先设一个范围(heapsize)
    1066526-20171108224233138-1783106537.png

    然后需要建立堆,以及最大堆:
    public void BuildMaxHeap()
    {
    for(int i=heapsize/2-1;i>=0;i--)
    {
    Maxify(i);
    }
    }
    public void HeapSort()
    {
    for(int i=0;i<heap.length;i++)
    {

            int tmp=heap[0];
            heap[0]=heap[heapsize-1];
            heap[heapsize-1]=tmp;
            heapsize--;
            Maxify(0);
        }
    }

    接下来就是通过比较进行排序的过程了,同样需要和最大值进行比较:
    int l=Left(i);
    int r=Right(i);
    int largest;

        if(l<heapsize&&heap[l]>heap[i])
            largest=l;
        else
            largest=i;
        if(r<heapsize&&heap[r]>heap[largest])
            largest=r;
        if(largest==i||largest>=heapsize)
            return ;
        int tmp=heap[i];
        heap[i]=heap[largest];
        heap[largest]=tmp;
        Maxify(largest);

    最后是定义返回值,得到结果:
    private int Parent(int i)
    {
    return (i-1)/2;

    }
    private int Left(int i)
    {
    
        return 2*(i+1)-1;
    }
    private int Right(int i)
    {
    
        return 2*(i+1);
    }

    桶排序也可以借鉴上面的过程,只是方法需要改变,使用桶排序的方法;
    桶排序 (Bucket sort)或所谓的箱排序,是一个排序算法,工作的原理是将阵列分到有限数量的桶子里。每个桶子再个别排序(有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序)。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候,桶排序使用线性时间(Θ(n))。但桶排序并不是 比较排序,他不受到 O(n log n) 下限的影响。
    两个特征:
    待排序列所有的值处于一个可枚举的范围之类;
    待排序列所在的这个可枚举的范围不应该太大,否则排序开销太大。
    排序的具体步骤如下:
    (1)对于这个可枚举范围构建一个buckets数组,用于记录“落入”每个桶中元素的个数;
    (2)将(1)中得到的buckets数组重新进行计算,按如下公式重新计算:
    buckets[i] = buckets[i] +buckets[i-1] (其中1<=i<buckets.length);
    桶式排序是一种非常优秀的排序算法,时间效率极高,它只要通过2轮遍历:第1轮遍历待排数据,统计每个待排数据“落入”各桶中的个数,第2轮遍历buckets用于重新计算buckets中元素的值,2轮遍历后就可以得到每个待排数据在有序序列中的位置,然后将各个数据项依次放入指定位置即可。
    实验具体实现方法:
    public static void bucketSort(int[] a, int max) {
    int[] buckets;

        if (a==null || max<1)
            return ;
    
        buckets = new int[max];
    
    
        for(int i = 0; i < a.length; i++)
            buckets[a[i]]++;
    
    
        for (int i = 0, j = 0; i < max; i++) {
            while( (buckets[i]--) >0 ) {
                a[j++] = i;
            }
        }
    
        buckets = null;
    }

    在编写完测试类后就可以运行了
    1066526-20171108232812575-1934209566.png

    完成了测试后就可以很得到结果了。
    实验总结:这次实验总体上是对学过知识的回顾和整合,并和最近所学的新内容相结合,总体上起到了一个系统考察的效果。

    转载于:https://www.cnblogs.com/Metwox/p/7801850.html

    展开全文
  • 实验二 面向对象程序设计 (一)单元测试 写一段关于分数标准代码,如下: public class MyUtil{ public static String percentage2fivegrade(int grade){ //如果成绩小于60,转成“不及格” if (grade < ...
  • ---恢复内容开始--- 20172325 2017-2018-2 《程序设计与数据结构》实验一报告 课程:《程序设计与数据...1.java开发环境的熟悉以及典型例题的实验; 2.IDEA以及JDK的安装和调试 二、实验过程及结果 关于习题PP3....
  • 20165332 2017-2018-2《Java程序设计》课程总结 一、每周作业及实验报告链接汇总 我期望师生关系 学习基础和c语言基础调查 Linux安装及命令入门 第一周学习总结 第二周学习总结 第三周学习总结 第四周学习总结 第...
  • 2016-2017-2 《Java程序设计》课程总结 - 20155214 目录 一、每周学习总结及实验报告链接汇总 二、代码托管 给出statistic.sh运行结果,说明本学期代码量目标达到没有? 加点代码,改点代码是理解最好方式...
  • 这周最开心事情是自己完成了实验报告,当然,还有老师例程帮助。通过模仿和自己理解,慢慢理解了继承和抽象类,还有子类和父类关系。 以前不懂该怎样在子类中去实现抽象父类里方法和属性,现在基本都...
  • 20165304 2017-2018-2《Java程序设计》学习总结 一、每周作业及实验报告链接汇总 1.我期望师生关系 2.20165304学习基础和C语言基础调查 3.linux系统安装 4.第二周学习总结 5.第三周学习总结 6.第四周学习总结 7.第...
  • 20155303 2016-2017-2 《Java程序设计》课程总结 目录 一、每周作业及实验报告链接汇总 二、关于博客 自认为写得最好一篇博客是?为什么? 作业中阅读量最高一篇博客是?谈谈经验。 作业中与师生交互最多一篇...
  • 20165308 2017-2018-2 《Java程序设计》课程总结 一、每周作业及实验报告链接汇总 我期待师生关系 学习基础和c语言调查 Linux 安装及学习 第三周学习总结 第四周学习总结 第五周学习总结 第六周学习总结 第七周...
  • 这是一个关于模拟时钟的java课程设计,内附源程序实验报告
  • java实训报告结束语下文是关于java实训报告结束语相关内容,希望对你有一定帮助:【篇一】:java上机实验心得体会报告北京联合大学信息学院“面向对象程序设计”课程上机实验报告题目: JAVA上机实验心得体会姓名...
  • 实验名称:关于java相关内容学习 实验目的:学习课本关于树结构和二叉树使用相关知识,通过决策树进行程序设计和程序开发;学习通过使用二叉树相关知识来解决实际问题,包括几种二叉树方法实现,...
  • 编写一个执行适当操作选项的Java程序。该程序必须满足以下要求: 应该将其打包到可执行jar归档文件中。 必须根据数学表达式计算来评估表达式(必须遵守操作顺序等)。 该程序必须使用Java标准库中数学函数。 ...
  •  本书可作为高等院校“网页设计与开发”类课程教材,也可作为网站制作、Web程序设计培训教材,还可作为网页设计与Web编程爱好者自学参考书。  本书特点  ●构思清晰,结构合理。  ●内容全面系统,语言简洁...
  • java认证所有课程

    2009-08-27 15:13:59
    然而,有时一个程序的设计要求同一程序的多个不相关部分对于同一事件作出反应。这种情况是有可能,例如,将一个上下文敏感帮助系统加到一个已存在的程序中。 监听者机制允许你调用addXXXlistener方法任意多次...
  • 丛书名: 图灵程序设计丛书 数据库 出版社:人民邮电出版社 ISBN:9787115215147 上架时间:2009-10-30 出版日期:2009 年10月 开本:16开 页码:451 版次:1-1 所属分类: 计算机 > 数据库 > Oracle ...
  • 直接以调试工具和调试方法为目标,讲述调试工具本身的设计思路、存在问题和解决方法,包括Windows系统内核调试通信问题和Windows 8解决方法(第19章),Android系统跨机器调试Java应用程序的方法(第20章),...
  • 而 KCP是为流速设计的(单个数据包从一端发送到一端需要多少时间),以10%-20%带宽浪费的代价换取了比 TCP快30%-40%的传输速度。TCP信道是一条流速很慢,但每秒流量很大的大运河,而KCP是水流湍急的小激流。KCP有...

空空如也

空空如也

1 2
收藏数 34
精华内容 13
关键字:

关于java程序设计的实验报告

java 订阅