Java面向对象 网络编程 上



知识概要:

                    (1)网络模型

(2)网络通讯要素

(3)UDP TCP 概念

(4)Socket

(5)UDP TCP 传输

(6)编写一个聊天程序。

网络模型

         网络模型 

           

              • OSI参考模型

              • TCP/IP参考模型

网络通讯要素

 IP地址:InetAddress

•  网络中设备的标识

        • 不易记忆,可用主机名

        • 本地回环地址:127.0.0.1  主机名:localhost

 端口号

• 用于标识进程的逻辑地址,不同进程的标识

        • 有效端口:0~65535,其中0~1024系统使用或保留端口。

传输协议

• 通讯的规则 

       • 常见协议:TCP,UDP

TCP和UDP

 UDP

        • 将数据及源和目的封装成数据包中,不需要建立连接

        • 每个数据报的大小在限制在64k内

        •  因无连接,是不可靠协议

        • 不需要建立连接,速度快

  TCP 

       • 建立连接,形成传输数据的通道。 

       • 在连接中进行大数据量传输

       • 通过三次握手完成连接,是可靠协议

       • 必须建立连接,效率会稍低

Socket

  Socket就是为网络服务提供的一种机制。

  通信的两端都有Socket。

  网络通信其实就是Socket间的通信。

  数据在两个Socket间通过IO传输。

UDP传输

  DatagramSocket与DatagramPacket

  建立发送端,接收端。

   建立数据包。

调用Socket的发送接收方法。

 

关闭Socket。

发送端与接收端是两个独立的运行程序。

ip代码示例:

  1. import java.net.*;
  2.  
  3. class IPDemo
  4. {
  5. public static void main(String[] args) throws Exception
  6. {
  7. InetAddress i = InetAddress.getLocalHost();
  8.  
  9. System.out.println(i.toString());
  10. System.out.println("address:"+i.getHostAddress());
  11. System.out.println("name:"+i.getHostName());
  12.  
  13. InetAddress ia = InetAddress.getByName("thinkpad-sl400");
  14. System.out.println("address:"+ia.getHostAddress());
  15. System.out.println("name:"+ia.getHostName());
  16.  
  17. }
  18. }

UDP传输

  1. import java.net.*;
  2.  
  3. /*
  4. 需求:通过udp传输方式,将一段文字数据发送出去。,
  5. 定义一个udp发送端。
  6. 思路:
  7. 1,建立updsocket服务。
  8. 2,提供数据,并将数据封装到数据包中。
  9. 3,通过socket服务的发送功能,将数据包发出去。
  10. 4,关闭资源。
  11.  
  12. */
  13.  
  14. class UdpSend
  15. {
  16. public static void main(String[] args) throws Exception
  17. {
  18. //1,创建udp服务。通过DatagramSocket对象。
  19. DatagramSocket ds = new DatagramSocket(8888);
  20.  
  21. //2,确定数据,并封装成数据包。DatagramPacket(byte[] buf, int length, InetAddress address, int port)
  22.  
  23. byte[] buf = "udp ge men lai le ".getBytes();
  24. DatagramPacket dp =
  25. new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.254"),10000);
  26.  
  27. //3,通过socket服务,将已有的数据包发送出去。通过send方法。
  28. ds.send(dp);
  29.  
  30. //4,关闭资源。
  31.  
  32. ds.close();
  33.  
  34. }
  35. }
  36.  
  37. /*
  38. 需求:
  39. 定义一个应用程序,用于接收udp协议传输的数据并处理的。
  40.  
  41. 定义udp的接收端。
  42. 思路:
  43. 1,定义udpsocket服务。通常会监听一个端口。其实就是给这个接收网络应用程序定义数字标识。方便于明确哪些数据过来该应用程序可以处理。
  44. 2,定义一个数据包,因为要存储接收到的字节数据。因为数据包对象中有更多功能可以提取字节数据中的不同数据信息。
  45. 3,通过socket服务的receive方法将收到的数据存入已定义好的数据包中。
  46. 4,通过数据包对象的特有功能。将这些不同的数据取出。打印在控制台上。
  47. 5,关闭资源。
  48.  
  49. */
  50.  
  51. class UdpRece
  52. {
  53. public static void main(String[] args) throws Exception
  54. {
  55. //1,创建udp socket,建立端点。
  56. DatagramSocket ds = new DatagramSocket(10000);
  57. while(true)
  58. {
  59. //2,定义数据包。用于存储数据。
  60. byte[] buf = new byte[1024];
  61. DatagramPacket dp = new DatagramPacket(buf,buf.length);
  62.  
  63. //3,通过服务的receive方法将收到数据存入数据包中。
  64. ds.receive(dp);//阻塞式方法。
  65.  
  66. //4,通过数据包的方法获取其中的数据。
  67. String ip = dp.getAddress().getHostAddress();
  68.  
  69. String data = new String(dp.getData(),0,dp.getLength());
  70.  
  71. int port = dp.getPort();
  72.  
  73. System.out.println(ip+"::"+data+"::"+port);
  74.  
  75. }
  76. //5,关闭资源
  77. //ds.close();
  78.  
  79. }
  80. }
  1. /*
  2. 编写一个聊天程序。
  3. 有收数据的部分,和发数据的部分。
  4. 这两部分需要同时执行。
  5. 那就需要用到多线程技术。
  6. 一个线程控制收,一个线程控制发。
  7.  
  8. 因为收和发动作是不一致的,所以要定义两个run方法。
  9. 而且这两个方法要封装到不同的类中。
  10.  
  11. */
  12. import java.io.*;
  13. import java.net.*;
  14. class Send implements Runnable
  15. {
  16. private DatagramSocket ds;
  17. public Send(DatagramSocket ds)
  18. {
  19. this.ds = ds;
  20. }
  21.  
  22. public void run()
  23. {
  24. try
  25. {
  26. BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  27.  
  28. String line = null;
  29.  
  30. while((line=bufr.readLine())!=null)
  31. {
  32.  
  33. byte[] buf = line.getBytes();
  34.  
  35. DatagramPacket dp =
  36. new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.255"),10002);
  37.  
  38. ds.send(dp);
  39.  
  40. if("886".equals(line))
  41. break;
  42. }
  43. }
  44. catch (Exception e)
  45. {
  46. throw new RuntimeException("发送端失败");
  47. }
  48. }
  49. }
  50.  
  51. class Rece implements Runnable
  52. {
  53.  
  54. private DatagramSocket ds;
  55. public Rece(DatagramSocket ds)
  56. {
  57. this.ds = ds;
  58. }
  59. public void run()
  60. {
  61. try
  62. {
  63. while(true)
  64. {
  65. byte[] buf = new byte[1024];
  66. DatagramPacket dp = new DatagramPacket(buf,buf.length);
  67.  
  68. <span style="color:#ff0000;"> ds.receive(dp);
  69. </span>
  70.  
  71. String ip = dp.getAddress().getHostAddress();
  72.  
  73. String data = new String(dp.getData(),0,dp.getLength());
  74.  
  75. if("886".equals(data))
  76. {
  77. System.out.println(ip+"....离开聊天室");
  78. break;
  79. }
  80.  
  81. System.out.println(ip+":"+data);
  82. }
  83. }
  84. catch (Exception e)
  85. {
  86. throw new RuntimeException("接收端失败");
  87. }
  88. }
  89. }
  90.  
  91. class ChatDemo
  92. {
  93. public static void main(String[] args) throws Exception
  94. {
  95. DatagramSocket sendSocket = new DatagramSocket();
  96. DatagramSocket receSocket = new DatagramSocket(10002);
  97.  
  98. new Thread(new Send(sendSocket)).start();
  99. new Thread(new Rece(receSocket)).start();
  100.  
  101. }
  102. }

TCP传输

Socket和ServerSocket

建立客户端和服务器端

 建立连接后,通过Socket中的IO流进行数据的传输,

关闭socket

同样,客户端与服务器端是两个独立的应用程序。

基本思路(客户端)

  客户端需要明确服务器的ip地址以及端口,这样才可以去试着建立连接,如果连接失败,会出现异常。

   连接成功,说明客户端与服务端建立了通道,那么  通过IO流就可以进行数据的传输,

而Socket对象已 经提供了输入流和输出流对象,通过 getInputStream(),getOutputStream()获取即可。

   与服务端通讯结束后,关闭Socket。

基本思路(服务端)

 服务端需要明确它要处理的数据是从哪个端口进入的。 

     当有客户端访问时,要明确是哪个客户端,可通过accept()获取已连接的客户端对象,并通过该对象与客户端通过

IO流进行数据传输。当该客户端访问结束,关闭该客户端。

客户端

通过Socket建立对象并指定要连接的服务

    端主机以及端口。

     Socket s = new Socket(“192.168.1.1”,9999);

     OutputStream out = s.getOutputStream();

     out.write(“hello”.getBytes());

     s.close();

服务端

 建立服务端需要监听一个端口

ServerSocket ss = new ServerSocket(9999);

     Socket s = ss.accept (); 

     InputStream in = s.getInputStream();

     byte[] buf = new byte[1024];

     int num = in.read(buf);

     String str = new String(buf,0,num);

     System.out.println(s.getInetAddress().toString()+”:”+str);

     s.close();

     ss.close();

  1. /*
  2. 演示tcp传输。
  3.  
  4. 1,tcp分客户端和服务端。
  5. 2,客户端对应的对象是Socket。
  6. 服务端对应的对象是ServerSocket。
  7.  
  8. */
  9.  
  10. /*
  11. 客户端,
  12. 通过查阅socket对象,发现在该对象建立时,就可以去连接指定主机。
  13. 因为tcp是面向连接的。所以在建立socket服务时,
  14. 就要有服务端存在,并连接成功。形成通路后,在该通道进行数据的传输。
  15.  
  16. 需求:给服务端发送给一个文本数据。
  17.  
  18. 步骤:
  19. 1,创建Socket服务。并指定要连接的主机和端口。
  20.  
  21. */
  22. import java.io.*;
  23. import java.net.*;
  24. class TcpClient
  25. {
  26. public static void main(String[] args) throws Exception
  27. {
  28. //创建客户端的socket服务。指定目的主机和端口
  29. Socket s = new Socket("192.168.1.254",10003);
  30.  
  31. //为了发送数据,应该获取socket流中的输出流。
  32. OutputStream out = s.getOutputStream();
  33.  
  34. out.write("tcp ge men lai le ".getBytes());
  35.  
  36. s.close();
  37. }
  38. }
  39.  
  40. /*
  41. 需求:定义端点接收数据并打印在控制台上。
  42.  
  43. 服务端:
  44. 1,建立服务端的socket服务。ServerSocket();
  45. 并监听一个端口。
  46. 2,获取连接过来的客户端对象。
  47. 通过ServerSokcet的 accept方法。没有连接就会等,所以这个方法阻塞式的。
  48. 3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流来读取发过来的数据。
  49. 并打印在控制台。
  50.  
  51. 4,关闭服务端。(可选)
  52.  
  53. */
  54. class TcpServer
  55. {
  56. public static void main(String[] args) throws Exception
  57. {
  58. //建立服务端socket服务。并监听一个端口。
  59. ServerSocket ss = new ServerSocket(10003);
  60.  
  61. //通过accept方法获取连接过来的客户端对象。
  62. while(true)
  63. {
  64. Socket s = ss.accept();
  65.  
  66. String ip = s.getInetAddress().getHostAddress();
  67. System.out.println(ip+".....connected");
  68.  
  69. //获取客户端发送过来的数据,那么要使用客户端对象的读取流来读取数据。
  70. InputStream in = s.getInputStream();
  71.  
  72. byte[] buf = new byte[1024];
  73. int len = in.read(buf);
  74.  
  75. System.out.println(new String(buf,0,len));
  76.  
  77. s.close();//关闭客户端.
  78. }
  79. //ss.close();
  80. }
  81. }
  1. /*
  2. 演示tcp传输。
  3.  
  4. 1,tcp分客户端和服务端。
  5. 2,客户端对应的对象是Socket。
  6. 服务端对应的对象是ServerSocket。
  7.  
  8. */
  9.  
  10. /*
  11. 客户端,
  12. 通过查阅socket对象,发现在该对象建立时,就可以去连接指定主机。
  13. 因为tcp是面向连接的。所以在建立socket服务时,
  14. 就要有服务端存在,并连接成功。形成通路后,在该通道进行数据的传输。
  15.  
  16. 需求:给服务端发送给一个文本数据。
  17.  
  18. 步骤:
  19. 1,创建Socket服务。并指定要连接的主机和端口。
  20.  
  21. */
  22. import java.io.*;
  23. import java.net.*;
  24. class TcpClient
  25. {
  26. public static void main(String[] args) throws Exception
  27. {
  28. //创建客户端的socket服务。指定目的主机和端口
  29. Socket s = new Socket("192.168.1.254",10003);
  30.  
  31. //为了发送数据,应该获取socket流中的输出流。
  32. OutputStream out = s.getOutputStream();
  33.  
  34. out.write("tcp ge men lai le ".getBytes());
  35.  
  36. s.close();
  37. }
  38. }
  39.  
  40. /*
  41. 需求:定义端点接收数据并打印在控制台上。
  42.  
  43. 服务端:
  44. 1,建立服务端的socket服务。ServerSocket();
  45. 并监听一个端口。
  46. 2,获取连接过来的客户端对象。
  47. 通过ServerSokcet的 accept方法。没有连接就会等,所以这个方法阻塞式的。
  48. 3,客户端如果发过来数据,那么服务端要使用对应的客户端对象,并获取到该客户端对象的读取流来读取发过来的数据。
  49. 并打印在控制台。
  50.  
  51. 4,关闭服务端。(可选)
  52.  
  53. */
  54. class TcpServer
  55. {
  56. public static void main(String[] args) throws Exception
  57. {
  58. //建立服务端socket服务。并监听一个端口。
  59. ServerSocket ss = new ServerSocket(10003);
  60.  
  61. //通过accept方法获取连接过来的客户端对象。
  62. while(true)
  63. {
  64. Socket s = ss.accept();
  65.  
  66. String ip = s.getInetAddress().getHostAddress();
  67. System.out.println(ip+".....connected");
  68.  
  69. //获取客户端发送过来的数据,那么要使用客户端对象的读取流来读取数据。
  70. InputStream in = s.getInputStream();
  71.  
  72. byte[] buf = new byte[1024];
  73. int len = in.read(buf);
  74.  
  75. System.out.println(new String(buf,0,len));
  76.  
  77. s.close();//关闭客户端.
  78. }
  79. //ss.close();
  80. }
  81. }
  1. /*
  2.  
  3. 需求:建立一个文本转换服务器。
  4. 客户端给服务端发送文本,服务单会将文本转成大写在返回给客户端。
  5. 而且客户度可以不断的进行文本转换。当客户端输入over时,转换结束。
  6.  
  7. 分析:
  8. 客户端:
  9. 既然是操作设备上的数据,那么就可以使用io技术,并按照io的操作规律来思考。
  10. 源:键盘录入。
  11. 目的:网络设备,网络输出流。
  12. 而且操作的是文本数据。可以选择字符流。
  13.  
  14. 步骤
  15. 1,建立服务。
  16. 2,获取键盘录入。
  17. 3,将数据发给服务端。
  18. 4,后去服务端返回的大写数据。
  19. 5,结束,关资源。
  20.  
  21. 都是文本数据,可以使用字符流进行操作,同时提高效率,加入缓冲。
  22.  
  23. */
  24. import java.io.*;
  25. import java.net.*;
  26.  
  27. class TransClient
  28. {
  29. public static void main(String[] args) throws Exception
  30. {
  31. Socket s = new Socket("192.168.1.254",10005);
  32.  
  33. //定义读取键盘数据的流对象。
  34. BufferedReader bufr =
  35. new BufferedReader(new InputStreamReader(System.in));
  36.  
  37. //定义目的,将数据写入到socket输出流。发给服务端。
  38. //BufferedWriter bufOut =
  39. //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  40. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
  41.  
  42. //定义一个socket读取流,读取服务端返回的大写信息。
  43. BufferedReader bufIn =
  44. new BufferedReader(new InputStreamReader(s.getInputStream()));
  45.  
  46. String line = null;
  47.  
  48. while((line=bufr.readLine())!=null)
  49. {
  50. if("over".equals(line))
  51. break;
  52.  
  53. out.println(line);
  54. // bufOut.write(line);
  55. // bufOut.newLine();
  56. // bufOut.flush();
  57.  
  58. String str =bufIn.readLine();
  59. System.out.println("server:"+str);
  60.  
  61. }
  62.  
  63. bufr.close();
  64. s.close();
  65.  
  66. }
  67. }
  68. /*
  69.  
  70. 服务端:
  71. 源:socket读取流。
  72. 目的:socket输出流。
  73. 都是文本,装饰。
  74.  
  75. */
  76.  
  77. class TransServer
  78. {
  79. public static void main(String[] args) throws Exception
  80. {
  81. ServerSocket ss = new ServerSocket(10005);
  82.  
  83. Socket s = ss.accept();
  84. String ip = s.getInetAddress().getHostAddress();
  85. System.out.println(ip+"....connected");
  86.  
  87. //读取socket读取流中的数据。
  88. BufferedReader bufIn =
  89. new BufferedReader(new InputStreamReader(s.getInputStream()));
  90.  
  91. //目的。socket输出流。将大写数据写入到socket输出流,并发送给客户端。
  92. //BufferedWriter bufOut =
  93. //new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  94.  
  95. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
  96.  
  97. String line = null;
  98. while((line=bufIn.readLine())!=null)
  99. {
  100.  
  101. System.out.println(line);
  102.  
  103. out.println(line.toUpperCase());
  104. // bufOut.write(line.toUpperCase());
  105. // bufOut.newLine();
  106. // bufOut.flush();
  107. }
  108.  
  109. s.close();
  110. ss.close();
  111.  
  112. }
  113. }
  114. /*
  115. 该例子出现的问题。
  116. 现象:客户端和服务端都在莫名的等待。
  117. 为什么呢?
  118. 因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等
  119. 而导致两端,都在等待。
  120.  
  121. */
  1. import java.io.*;
  2. import java.net.*;
  3.  
  4. class TextClient
  5. {
  6. public static void main(String[] args) throws Exception
  7. {
  8. Socket s = new Socket("192.168.1.254",10006);
  9.  
  10. BufferedReader bufr =
  11. new BufferedReader(new FileReader("IPDemo.java"));
  12.  
  13. PrintWriter out = new PrintWriter(s.getOutputStream(),true);
  14.  
  15. String line = null;
  16. while((line=bufr.readLine())!=null)
  17. {
  18. out.println(line);
  19. }
  20.  
  21. s.shutdownOutput();//关闭客户端的输出流。相当于给流中加入一个结束标记-1.
  22.  
  23. BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
  24.  
  25. String str = bufIn.readLine();
  26. System.out.println(str);
  27.  
  28. bufr.close();
  29.  
  30. s.close();
  31. }
  32. }
  33. class TextServer
  34. {
  35. public static void main(String[] args) throws Exception
  36. {
  37. ServerSocket ss = new ServerSocket(10006);
  38.  
  39. Socket s = ss.accept();
  40. String ip = s.getInetAddress().getHostAddress();
  41. System.out.println(ip+"....connected");
  42.  
  43. BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
  44.  
  45. PrintWriter out = new PrintWriter(new FileWriter("server.txt"),true);
  46.  
  47. String line = null;
  48.  
  49. while((line=bufIn.readLine())!=null)
  50. {
  51. //if("over".equals(line))
  52. //break;
  53. out.println(line);
  54. }
  55.  
  56. PrintWriter pw = new PrintWriter(s.getOutputStream(),true);
  57. pw.println("上传成功");
  58.  
  59. out.close();
  60. s.close();
  61. ss.close();
  62.  
  63. }
  64. }


Java面向对象 网络编程 上的更多相关文章

  1. Java面向对象 网络编程 下

    Java面向对象 网络编程  下 知识概要:                   (1)Tcp 练习 (2)客户端向服务端上传一个图片. (3) 请求登陆 (4)url 需求:上传图片. 客户端:   ...

  2. 第78节:Java中的网络编程(上)

    第78节:Java中的网络编程(上) 前言 网络编程涉及ip,端口,协议,tcp和udp的了解,和对socket通信的网络细节. 网络编程 OSI开放系统互连 网络编程指IO加网络 TCP/IP模型: ...

  3. JAVA的网络编程

    网络编程 网络编程对于很多的初学者来说,都是很向往的一种编程技能,但是很多的初学者却因为很长一段时间无法进入网络编程的大门而放弃了对于该部分技术的学习. 在 学习网络编程以前,很多初学者可能觉得网络编 ...

  4. Java Socket 网络编程心跳设计概念

    Java Socket 网络编程心跳设计概念   1.一般是用来判断对方(设备,进程或其它网元)是否正常动行,一 般采用定时发送简单的通讯包,如果在指定时间段内未收到对方响应,则判断对方已经当掉.用于 ...

  5. 【转】JAVA之网络编程

    转自:火之光 网络编程 网络编程对于很多的初学者来说,都是很向往的一种编程技能,但是很多的初学者却因为很长一段时间无法进入网络编程的大门而放弃了对于该部分技术的学习. 在 学习网络编程以前,很多初学者 ...

  6. JAVA的网络编程【转】

    JAVA的网络编程[转] Posted on 2009-12-03 18:04 火之光 阅读(93441) 评论(20) 编辑 收藏 网络编程 网络编程对于很多的初学者来说,都是很向往的一种编程技能, ...

  7. Java基础——网络编程(二)

    一.套接字 Socket 网络驱动程序提供给应用程序编程的接口和一种机制,可以比喻成一个港口码头 应用程序只要把货放在这,就算完成了货物的运送.它在应用程序中创建,通过一种绑定机制与驱动程序建立关系, ...

  8. java基础-网络编程(Socket)技术选型入门之NIO技术

    java基础-网络编程(Socket)技术选型入门之NIO技术 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.传统的网络编程 1>.编写socket通信的MyServer ...

  9. Java复习——网络编程

    Java从最开始就是支持网络编程的,也正是网络使Java得到发展繁荣.在这里我记录一下如何使用Java进行网络编程,什么是Socket以及Java实现TCP,UDP的编程模型. InetAddress ...

随机推荐

  1. 基于CAS的SSO(单点登录)实例

    第一步 部署CAS-Server(服务端) 1.从CAS官方网站(http://developer.jasig.org/cas/)下载最新版本的CAS-Server(当前最新版本cas-server- ...

  2. Mysql介绍和实践总结

    本文首先介绍mysql的安装和基本使用.进阶操作.讲解mysql的导入导出和自动备份,然后介绍安全模式修改密码和mysql的全文本搜索功能,最后记录了个人使用mysql中遇到的问题集. 开始安装: s ...

  3. 2017 ACM/ICPC Asia Regional Shenyang Online spfa+最长路

    transaction transaction transaction Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 132768/1 ...

  4. MPLS LDP随堂笔记2

    前一天排错 Acl 1 匹配所有ospf的数据包 (目的 ospf建立邻居关系 传递路由条目) 2 放行UDP报文 让LDP邻居能互相收发HELLO包 4 放行TCP报文 让LDP邻居能够建立TCP会 ...

  5. 【深入Java虚拟机】之八:Java垃圾收集机制

    转载请注明出处:http://blog.csdn.net/ns_code/article/details/18076173 对象引用 Java中的垃圾回收一般是在Java堆中进行,因为堆中几乎存放了J ...

  6. 201521123084 《Java程序设计》第5周学习总结

    第5周-继承.多态.抽象类与接口 1. 本周学习总结 1.1 尝试使用思维导图总结有关多态与接口的知识点. 2. 书面作业 1. 代码阅读:Child压缩包内源代码 1.1 com.parent包中C ...

  7. 团队作业八——第二次团队冲刺(Beta版本)第5天

    团队作业八--第二次团队冲刺(Beta版本)第5天 一.每个人的工作 (1) 昨天已完成的工作 完成界面跳转界面. (2) 今天计划完成的工作 简单模式逻辑代码涉及与相关功能的具体实现 (3) 工作中 ...

  8. 201521123119《Java程序设计》第4周学习总结

    1. 本周学习总结 2.书面作业 1.注释的应用 使用类的注释与方法的注释为前面编写的类与方法进行注释,并在Eclipse中查看.(截图) 2.面向对象设计(大作业1,非常重要) 2.1 将在网上商城 ...

  9. 201521123010 《Java程序设计》第1周学习总结

    1. 本周学习总结 第一次接触java,在与以前不同的环境下运行,初步只接触了其中的冰山一角,但也发现了java身后庞大的资源,因此也想通过对java的学习来丰富自己对编程,甚至资源的认识.本周通过学 ...

  10. 201521123013 《Java程序设计》第9周学习总结

    1. 本章学习总结 2. 书面作业 Q1.常用异常题目5-1 1.1 截图你的提交结果(出现学号) 1.2 自己以前编写的代码中经常出现什么异常.需要捕获吗(为什么)?应如何避免? 经常出现Class ...