javase刚学完,udp传参出现错误,我已经束手无策,求大神救我吧。真的我是没辙了

自己的路哭着也要走完 发布于 2017/08/03 22:25
阅读 77
收藏 0

老师好,下面是我跟视频的练习代码,是TankWar的游戏程序,有个bug怎么也调不过来,就是每添加一台新的坦克,坦克的方向dir传到服务器莫名其妙的就是0.想请高手帮忙解决此难题,我已经找了好多遍 束手无策了。求帮忙谢谢

如果代码不够清晰请回复我,我加注释。多数代码都不重要,主要是udp连服务器传参错误

 

import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.List;

//主窗口类,由此运行

public class TankClient extends Frame {

    public static final int GAME_WIDTH = 800;
    public static final int GAME_HIGH = 600;

    List<Missile> Missiles = new ArrayList<Missile>();
    List<Tank> Tanks = new ArrayList<Tank>();
    Tank myTank = new Tank(50, 50, this, false, Dir.STOP);

    List<Explode> explodes = new ArrayList<Explode>();

    public static final int SEVER_PORT = 8888;

    NetClient nc = new NetClient(this);

    public static void main(String[] args) {
        // TODO 自動生成されたメソッド・スタブ
        TankClient t = new TankClient();
        t.startFrame();

    }

    void startFrame() {
        MyFrame mf = new MyFrame();
        mf.lauchFrame();
        RepaintThread rt = new RepaintThread();
        Thread t = new Thread(rt);
        t.start();

    }

    @Override
    public void paint(Graphics g) {

        for (int i = 0; i < Tanks.size(); i++) {
            Tank t = Tanks.get(i);

                t.draw(g);


        }

        for (int i = 0; i < explodes.size(); i++) {
            explodes.get(i).draw(g);
        }


            myTank.draw(g);
            Color c1 = g.getColor();
            g.setColor(Color.LIGHT_GRAY);
            g.drawString(String.valueOf(myTank.id), myTank.x, myTank.y-5);
            g.setColor(c1);


        for (int i = 0; i < Missiles.size(); i++) {
            Missile m = Missiles.get(i);

            m.hitTanks(Tanks);

            m.draw(g);

            if (!m.live) {
                Missiles.remove(i);
            }

        }
        Color c = g.getColor();
        g.setColor(Color.LIGHT_GRAY);

        g.drawString("missiles counts" + Missiles.size(), 20, 40);
        g.drawString("missiles counts" + explodes.size(), 20, 50);
//        g.drawString("ID" + id, 20, 60);
        g.setColor(c);

    }

    Image offScreenImage = null;

    @Override
    public void update(Graphics g) {
        // TODO 自動生成されたメソッド・スタブ
        super.update(g);

        if (offScreenImage == null) {
            offScreenImage = this.createImage(GAME_WIDTH, GAME_HIGH);
        }

        Graphics gOffScreen = offScreenImage.getGraphics();
        Color c = gOffScreen.getColor();
        gOffScreen.setColor(Color.BLACK);
        gOffScreen.fillRect(0, 0, GAME_WIDTH, GAME_HIGH);
        gOffScreen.setColor(c);
        paint(gOffScreen);
        g.drawImage(offScreenImage, 0, 0, null);

    }

    class MyFrame {

        void newTank() {

        }

        void lauchFrame() {

            setBounds(400, 300, GAME_WIDTH, GAME_HIGH);
            setVisible(true);
            setBackground(Color.BLACK);
            setTitle("TankWar");
            setResizable(false);

            addWindowListener(new WindowAdapter() {

                @Override
                public void windowClosing(WindowEvent e) {

                    super.windowClosing(e);
                    setVisible(false);
                    System.exit(0);
                }

            });

            addKeyListener(new keyPressed());

            nc.connect("127.0.0.1", SEVER_PORT);

        }

        class keyPressed extends KeyAdapter {
            @Override
            public void keyReleased(KeyEvent e) {
                // TODO 自動生成されたメソッド・スタブ
                myTank.keyReleased(e);

            }

            // System.out.println("key adapter");
            @Override
            public void keyPressed(KeyEvent e) {
                // TODO 自動生成されたメソッド・スタブ

                myTank.keyPressed(e);
            }

        }

    }

    class RepaintThread implements Runnable {

        @Override
        public void run() {
            // TODO 自動生成されたメソッド・スタブ
            while (true) {
                repaint();

                // }
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    // TODO 自動生成された catch ブロック
                    e.printStackTrace();
                }
            }
        }

    }

}
___________________________________________________________________________________________

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;

//链接服务器类,坦克类通过这个NetClient()类链接到服务器

public class NetClient {

    private static int UDP_PORT_START = 2224;

    TankClient tc = null;

    DatagramSocket ds = null;

//    NetClient(TankClient tc) {
//        udpPort = UDP_PORT_START ++;
//
//        this.tc = tc;
//    }

    NetClient(TankClient tc) {

        this.tc = tc;
        try {
            ds = new DatagramSocket(UDP_PORT_START);
        } catch (SocketException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        }
    }

    void connect(String Ip, int port) {
        Socket s = null;

        try {
            s = new Socket(Ip, port);
System.out.println("Connected to sever");
            DataOutputStream dos = new DataOutputStream(s.getOutputStream());
            DataInputStream dis = new DataInputStream(s.getInputStream());
            dos.writeInt(UDP_PORT_START);
            int id = dis.readInt();
            tc.myTank.id = id;
            send();


        } catch (UnknownHostException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        } catch (IOException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        } finally {
            if(s != null) {
                try {
                    s.close();
                } catch (IOException e) {
                    // TODO 自動生成された catch ブロック
                    e.printStackTrace();
                }
                s = null;
            }
        }

        UDPRcevThread udp = new UDPRcevThread();
        new Thread(udp).start();
    }

    void send() {

        TankNewMsg msg = new TankNewMsg(tc.myTank, tc);

        msg.send(ds, "127.0.0.1", 6666);
    }


    class UDPRcevThread implements Runnable {

        byte[] buf = new byte[1024];

        @Override
        public void run() {
System.out.println("UDPRcevThread   " + ds.getLocalPort());
            try {
                while(ds != null) {
                    DatagramPacket dp = new DatagramPacket(buf, buf.length);
                    ds.receive(dp);
                    parse(dp);

System.out.println("recevied massage from sever");

                }

            } catch (IOException e) {
                // TODO 自動生成された catch ブロック
                e.printStackTrace();
            }
        }

    }


    public void parse(DatagramPacket dp) {
        // TODO 自動生成されたメソッド・スタブ
        ByteArrayInputStream bais = new ByteArrayInputStream(dp.getData(), 0, dp.getLength());
        DataInputStream dis = new DataInputStream(bais);
        TankNewMsg msg = new TankNewMsg(NetClient.this.tc);
        msg.parse(dis);
    }
}
__________________________________________________________________________________________

//枚举类型,坦克的方向
public enum Dir {
    UP, DOWN, LEFT, RIGHT, UPLEFT, UPRIGHT, DOWNLEFT, DOWNRIGHT, STOP
}
__________________________________________________________________________________________

import java.awt.Color;
import java.awt.Graphics;

//爆炸效果类,不重要

public class Explode {
    int x, y;
    int[] ints = {6, 10, 16, 20, 28, 36, 42, 70, 45, 20, 5};
    TankClient tc = null;
    boolean live = true;
    int num = 0;
    public Explode(int x, int y, TankClient tc) {
        super();
        this.x = x;
        this.y = y;
        this.tc = tc;
    }

    void draw(Graphics g) {
        if(this.live == false) {
            tc.explodes.remove(this);
        }

        Color c = g.getColor();
        g.setColor(Color.ORANGE);

        if(this.live == false) {
            return;
        }
        if(num < ints.length) {
            g.fillOval(x, y, ints[num], ints[num]);
            num ++;
        }
        if(num >= ints.length) {
            num = 0;
            live = false;
        }
        g.setColor(c);
    }
}
______________________________________________________________________________________

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.util.List;

//炮弹类,不重要,问题不在这

public class Missile {

    public Missile(int x, int y, Dir dir, TankClient tc) {
        super();
        this.x = x;
        this.y = y;
        this.dir = dir;
        this.tc = tc;
    }

    public static final int WIDTH = 10;
    public static final int HIGH = 10;
    int x, y;

    public static final int XSPEED = 2, YSPEED = 2;
    Dir dir;
    boolean live =  true;
    TankClient tc = null;
    boolean isBad = false;

    void draw(Graphics g) {
        if(this.live == false) {
            return;
        }

        Color c = g.getColor();
        g.setColor(Color.WHITE);
        g.fillOval(x, y, WIDTH, HIGH);
        g.setColor(c);
        move();
        if(x < 0 || x >TankClient.GAME_WIDTH  || y < 0 || y > TankClient.GAME_HIGH) {
            live = false;
        }
//        if(e != null && e.live == true) {
//            e.draw(g);
//
//        }
//        if(e.live == false) {
//            e = null;
//        }
    }

    void move() {
        switch(dir) {
            case UP :
                y -= YSPEED;
                break;
            case DOWN :
                y += YSPEED;
                break;
            case LEFT :
                x -= XSPEED;
                break;
            case RIGHT :
                x += XSPEED;
                break;
            case UPLEFT :
                y -= YSPEED;
                x -= XSPEED;
                break;
            case UPRIGHT :
                y -= YSPEED;
                x += XSPEED;
                break;
            case DOWNLEFT :
                y += YSPEED;
                x -= XSPEED;
                break;
            case DOWNRIGHT :
                y += YSPEED;
                x += XSPEED;
                break;
        }


    }

    public Rectangle getRec() {
        Rectangle r = new Rectangle(x, y, WIDTH, HIGH);
        return r;
    }

    boolean hitTank(Tank t) {

        boolean b = this.getRec().intersects(t.getRec());
        if(b && t.live == true) {

            this.live = false;
            t.setLive(false);

            Explode e = new Explode(x, y, tc);
            tc.explodes.add(e);
            return true;
        }
            return false;

    }

    boolean hitTanks(List<Tank> Tanks) {
        for(int i=0; i<Tanks.size(); i++) {
            Tank k = Tanks.get(i);
            return hitTank(k);
        }
        return false;
    }
}

_____________________________________________________________________________________

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;

//坦克类,生成坦克以及坦克的方法都在这里

public class Tank {


    int id;
    int x, y;
    TankClient tc = null;
    public static final int XSPEED = 1, YSPEED = 1;
    public static final int WIDTH = 30, HIGH = 30;

//    enum Dir {UP, DOWN, LEFT, RIGHT, UPLEFT, UPRIGHT, DOWNLEFT, DOWNRIGHT, STOP};
    Dir dir = null;
    Dir ptDir = dir.DOWN;
    private boolean bUp = false, bDown = false, bLeft = false, bRight = false;

    boolean isBad = false;
    boolean live = true;


    public void setLive(boolean live) {
        this.live = live;
    }

    public Tank(int x, int y, TankClient tc, boolean isBad, Dir dir) {
        super();
        this.x = x;
        this.y = y;
        this.tc = tc;
        this.isBad = isBad;
        this.dir = dir;
    }

    public boolean isLive() {
        return live;
    }

    public boolean isBad() {
        return isBad;
    }

    public void setBad(boolean isBad) {
        this.isBad = isBad;
    }


    public Dir getDir() {
        return dir;
    }

    public void setDir(Dir dir) {
        this.dir = dir;
    }


    public void draw(Graphics g) {
        // TODO 自動生成されたメソッド・スタブ
        if(live == false) {
            tc.Tanks.remove(this);
            return;
        }
        if(this.isBad && this.isLive()) {
            Color c = g.getColor();
            g.setColor(Color.YELLOW);
            g.fillOval(x, y, 30, 30);
            g.setColor(c);
        } else if(!this.isBad && this.isLive()){
            Color c = g.getColor();
            g.setColor(Color.RED);
            g.fillOval(x, y, 30, 30);
            g.setColor(c);
        }


        move();
        ptDirction(g);

    }


    void direction() {
        if(!bUp && !bDown && !bLeft && !bRight) {
            dir = Dir.STOP;
        } else if(bUp && !bDown && !bLeft && !bRight) {
            dir = Dir.UP;
        } else if(!bUp && bDown && !bLeft && !bRight) {
            dir = Dir.DOWN;
        } else if(!bUp && !bDown && bLeft && !bRight) {
            dir = Dir.LEFT;
        } else if(!bUp && !bDown && !bLeft && bRight) {
            dir = Dir.RIGHT;
        } else if(bUp && !bDown && bLeft && !bRight) {
            dir = Dir.UPLEFT;
        } else if(bUp && !bDown && !bLeft && bRight) {
            dir = Dir.UPRIGHT;
        } else if(!bUp && bDown && bLeft && !bRight) {
            dir = Dir.DOWNLEFT;
        } else if(!bUp && bDown && !bLeft && bRight) {
            dir = Dir.DOWNRIGHT;
        } else if(bUp && bDown && bLeft && bRight) {
            dir = Dir.STOP;
        }
    }

    void ptDirction(Graphics g) {
        switch(ptDir) {
            case UP :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x + WIDTH/2, y);
                break;
            case DOWN :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x + WIDTH/2, y + HIGH);
                break;
            case LEFT :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x, y + HIGH/2);
                break;
            case RIGHT :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x + WIDTH, y + HIGH/2);
                break;
            case UPLEFT :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x, y);
                break;
            case UPRIGHT :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x + WIDTH, y);
                break;
            case DOWNLEFT :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x, y + HIGH);
                break;
            case DOWNRIGHT :
                g.drawLine(x + WIDTH/2, y + HIGH/2, x + WIDTH, y + HIGH);
                break;

        }

    }

    void move() {
        switch(dir) {
            case UP :
                y -= YSPEED;
                break;
            case DOWN :
                y += YSPEED;
                break;
            case LEFT :
                x -= XSPEED;
                break;
            case RIGHT :
                x += XSPEED;
                break;
            case UPLEFT :
                y -= YSPEED;
                x -= XSPEED;
                break;
            case UPRIGHT :
                y -= YSPEED;
                x += XSPEED;
                break;
            case DOWNLEFT :
                y += YSPEED;
                x -= XSPEED;
                break;
            case DOWNRIGHT :
                y += YSPEED;
                x += XSPEED;
                break;
        }

        if( x < 0 ) {
            x = 0;
        } else if( x + WIDTH > TankClient.GAME_WIDTH) {
            x = TankClient.GAME_WIDTH - WIDTH;
        } else if(y < 0) {
            y = 0;
        } else if(y + HIGH > TankClient.GAME_HIGH) {
            y = TankClient.GAME_HIGH - HIGH;
        }

    }

    public void keyPressed(KeyEvent e) {
        // TODO 自動生成されたメソッド・スタブ

        int key = e.getKeyCode();

        switch (key) {
        case KeyEvent.VK_F1:
            Tank t = new Tank(50, 50, tc ,false, Dir.STOP);
            tc.Tanks.add(t);
            break;
        case KeyEvent.VK_F2:
            Tank enemy = new Tank(500, 500, tc, true, Dir.STOP);
            tc.Tanks.add(enemy);
            break;
        case KeyEvent.VK_X:
            openFire();
            break;
        case KeyEvent.VK_UP :
            bUp = true;
            break;
        case KeyEvent.VK_DOWN :
            bDown = true;
            break;
        case KeyEvent.VK_LEFT :
            bLeft = true;
            break;
        case KeyEvent.VK_RIGHT :
            bRight = true;
            break;
        }
        direction();
        if(dir != Dir.STOP) {
            ptDir = dir;
        }
    }
    public Rectangle getRec() {
        Rectangle r = new Rectangle(x, y, WIDTH, HIGH);
        return r;
    }


    public void keyReleased(KeyEvent e) {
        // TODO 自動生成されたメソッド・スタブ
        int key = e.getKeyCode();

        switch (key) {
        case KeyEvent.VK_UP :
            bUp = false;
            break;
        case KeyEvent.VK_DOWN :
            bDown = false;
            break;
        case KeyEvent.VK_LEFT :
            bLeft = false;
            break;
        case KeyEvent.VK_RIGHT :
            bRight = false;
            break;
        }
        direction();
    }

    Missile openFire() {

        int i = x + WIDTH/2 - Missile.WIDTH/2;
        int j = y + HIGH/2 - Missile.HIGH/2;
        Missile s = new Missile(i, j, ptDir, tc);

        s.isBad = isBad;
        tc.Missiles.add(s);
        return s;
    }
}

_________________________________________________________________________________

import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

//向服务器发送新建一个坦克的消息类,问题出现类。

/*详细说一下,这个类在发送之前我检查所有变量都没问题,但是通过链接类NetClient链接到服务器,UDP方式,服务器接受ID,位置X,Y,坦克 方向dir(有问题),坦克的敌我。这几条数据只有方向传出去是enum下标值的0,我在发出去之前怎么测试都是8.我用ds.writeInt(8)这样手动写出去个int8 服务器接收的仍然是0。通过各种方式无解。求大神赐教。我真的束手无策了,帮帮我吧。刚学完javase。新生

**/

public class TankNewMsg {
    Tank tank = null;
    TankClient tc = null;


    TankNewMsg() {

    }
    TankNewMsg(TankClient tc) {
        this.tc = tc;
    }

    TankNewMsg(Tank tank, TankClient tc) {
        this.tank = tank;
        this.tc = tc;
    }

    void send(DatagramSocket ds, String ip, int port) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);

        try {
            dos.writeInt(tc.myTank.id);
            dos.writeInt(tc.myTank.x);
            dos.writeInt(tc.myTank.y);
            int i = tc.myTank.dir.ordinal();
            System.out.println("tc.myTank.dir.ordinal() is " + i);
            dos.writeInt(i);
            dos.writeBoolean(tc.myTank.isBad);
System.out.println("DOS---------id-" + tc.myTank.id + "-x=" + tc.myTank.x + "-y=" + tc.myTank.y + "-dir=" + i + tc.myTank.dir + "-isBad=" + tc.myTank.isBad);
        } catch (IOException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        }
        byte[] buf = baos.toByteArray();
        DatagramPacket dp = new DatagramPacket(buf, buf.length, new InetSocketAddress(ip, port));
        try {
            ds.send(dp);
        } catch (IOException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        }
    }


    public void parse(DataInputStream dis) {
        // TODO 自動生成されたメソッド・スタブ
        try {
            int id = dis.readInt();
            if(id == tc.myTank.id) {
System.out.println(id + "is return");
                return;
            }

            int x = dis.readInt();
            int y = dis.readInt();
            int i = dis.read();
System.out.println("int i = dis.read(); " + i);
            Dir dir = Dir.values()[i];
            boolean isBad = dis.readBoolean();
            Tank t = new Tank(x, y, tc, isBad, dir);
            t.dir = dir;

                tc.Tanks.add(t);
System.out.println(tc.Tanks.size() + " Tanks,size");

//System.out.println( "-dir=" + i + dir);

System.out.println("id-" + id + "-x=" + x + "-y=" + y + "-dir=" + i + dir + "-isBad=" + isBad);
        } catch (IOException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        }
    }


}
__________________________________________________________________________________________

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;

//这就是链接的服务器类

public class TankSever {
    List<Clients> TankClients = new ArrayList<Clients>();
    public static final int TCP_PORT = 8888;
    public static final int UDP_PORT = 6666;
    private static int id = 100;

    ServerSocket ss = null;

    public static void main(String[] args) {
        TankSever ts = new TankSever();
        ts.start();
    }
    class Clients {

        String udpIP = null;
        int port = 0;
        int id = 0;

        Clients(String udpIP, int port, int id) {
            this.udpIP = udpIP;
            this.port = port;
            this.id = id;
        }

        @Override
        public String toString() {

            String s = "udpIP--" + udpIP + "==UDPport==" + port +"  " + " #TankID# " + id;

            return s;
        }

    }

//这个info方法是测试用的,看参数

    void clientsInfo() {
        for(int i=0; i<TankClients.size(); i++) {
            Clients c = TankClients.get(i);
            System.out.println(c);
            System.out.println(TankClients.size() + "size");
        }
    }

    void start() {

        UDPRcevThread ut = new UDPRcevThread();
        new Thread(ut).start();
        try {
            ss = new ServerSocket(TCP_PORT);


            while(true) {
                Socket s = ss.accept();
System.out.println("A client has been Connected -" + s.getInetAddress() + ":" + s.getPort());


                DataInputStream dis = new DataInputStream(s.getInputStream());
                DataOutputStream dos = new DataOutputStream(s.getOutputStream());
                String udpIP = s.getInetAddress().getHostAddress();
                int port = dis.readInt();

                Clients t = new Clients(udpIP, port, id);
                TankClients.add(t);
                dos.writeInt(id);
                id++;
                s.close();
                clientsInfo();


            }

        } catch (IOException e) {
            // TODO 自動生成された catch ブロック
            e.printStackTrace();
        } finally {
            if(ss != null) {
                try {
                    ss.close();
                } catch (IOException e) {
                    // TODO 自動生成された catch ブロック
                    e.printStackTrace();
                }
                ss = null;
            }
        }


    }

//这个内部线程类是接受udp发来数据的,问题在这里

    class UDPRcevThread implements Runnable {

        @Override
        public void run() {
            DatagramSocket ds = null;
            byte[] buff = new byte[1024];
            // TODO 自動生成されたメソッド・スタブ
System.out.println("UDP_SEVER start");

            try {
                ds = new DatagramSocket(UDP_PORT);
            } catch (SocketException e) {
                // TODO 自動生成された catch ブロック
                e.printStackTrace();
            }
            while(ds != null) {

                DatagramPacket dp = new DatagramPacket(buff, buff.length);
                try {

                    ds.receive(dp);
System.out.println("Sever ds.receive(dp);");
                    testParse(dp);
                    for(int i=0; i<TankClients.size(); i++) {
                        Clients c = TankClients.get(i);
                        String udp = c.udpIP;
                        int port = c.port;
                        System.out.println(port + "---PORT" + udp + "---udpip");

                        dp.setSocketAddress(new InetSocketAddress(udp, port));
                        try {
                            ds.send(dp);
                        } catch (IOException e) {
                            // TODO 自動生成された catch ブロック
                            e.printStackTrace();
                        }
                    }
                } catch (IOException e) {
                    // TODO 自動生成された catch ブロック
                    e.printStackTrace();
                }
System.out.println("a packet recevied");
            }

        }


    }

//这个test方法是我做测试用的,查看传来的参数是多少。

    public void testParse(DatagramPacket dp) {
        // TODO 自動生成されたメソッド・スタブ
        ByteArrayInputStream bais = new ByteArrayInputStream(dp.getData());
        DataInputStream dis = new DataInputStream(bais);

            try {
                int Testid = dis.readInt();

                int x = dis.readInt();
                int y = dis.readInt();
                int i = dis.read();
    System.out.println("int i = dis.read(); " + i);
                Dir dir = Dir.values()[i];
                boolean isBad = dis.readBoolean();

System.out.println("id-" + Testid + "-x=" + x + "-y=" + y + "-dir=" + i + dir + "-isBad=" + isBad);
            } catch (IOException e) {
                // TODO 自動生成された catch ブロック
                e.printStackTrace();
            }


    }
}
 

加载中
返回顶部
顶部