JAVA基础--网络编程与设计模式

一、网络编程

1、网络的概述

              网络就是计算机与计算机之间进行通信 

2、网络编程三要素：IP  端口  协议

       3、IP地址

                    a、它是网络中的设备标识

                   b、不易记忆，可用主机名表示，两者存在映射关系

                           c、本机回环地址：127.0.0.1，主机名为：localhost。

IP地址：Java中对应的是InetAddress类，存在于java.net包中。

                     IP的每一位数不超过256

        (1)IP地址的分类：

            A类 1.0.0.1---127.255.255.254   (1)10.X.X.X是私有地址(私有地址就是在互联网上不使用，而被用在局域网络中的地址) (2)127.X.X.X是保留地址，用做循环测试用的。

            B类 128.0.0.1---191.255.255.254 172.16.0.0---172.31.255.255是私有地址。169.254.X.X是保留地址。

            C类 192.0.0.1---223.255.255.254 192.168.X.X是私有地址

            D类 224.0.0.1---239.255.255.254

            E类 240.0.0.1---247.255.255.254

        (2)IP地址的组成：

        IP地址 = 网络号码+主机地址

        A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码

            256*256*256   --- 16777216

        B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码

            256*256    --- 65536

        C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码

            256

              4、端口号：

a、用于标识进程的逻辑地址，不用进程的标识。

b、有效端口：0 ~65535，系统使用或保留的端口是：0~ 1024

5、传输协议：

                          即通信规则，包含TCP和UDP协议

                     TCP协议的特点：

                     建立连接通道

                     数据无限制

                     面向连接(三次握手)

                     可靠

                     速度慢

                     UDP协议的特点：

                     把数据打包

                     数据有限制

                     面向无连接

                     不可靠

                     速度快

       6、Socket

              Socket是Internet主机上（计算机）提供的服务

              Socket编程 套接字编程  网络编程 

              InetAdress：java中计算机IP对应的类

              publicstatic InetAddress getByName(String host)

              IP地址：public String getHostAddress()           

             主机名：public String getHostName() 

       7、面向UDP协议编程： 

              UDP发送端（理解或者掌握）

                     A:创建发送端Socket服务对象

                     B:创建数据，并把数据打包

                     C:发送数据

                     D:释放资源 

              UDP协议接收数据步骤：

                     A:创建接收端Socket服务对象

                     B:创建数据包(接收容器)

                     C:调用接收方法

                     D:解析数据包,把数据显示在控制台

                     E:释放资源 

              UDP协议发送数据和接收数据的代码改进 

              UDP协议键盘录入数据发送到接收端 

              广播地址

                     每个网段的255的IP就是广播地址

                     比如： 192.168.1.255

                     只要发送端发送的192.168.1.255，如果192.168.1.*都开了接收端，就都能接收到数据

              UDP编程结合线程模拟聊天室

                     开两个线程一个线程写接收端 一个线程写发送端

       面向TCP协议编程： 

              TCP协议客户端的步骤:

                A:创建客户端的Socket对象

                B:建立连接

                C:获取输出流，写数据即可

                D:释放资源 

              TCP协议服务器端的步骤：

                A:创建服务器端Socket对象

                B:监听连接

                C:获取输入流，读取数据，并显示

                D:释放资源 

              TCP服务器端和客户端相互发送数据 

              案例：写出一个服务器，要求该服务器具有将客户端发过来的英文字母转大写的功能 ，

                     并将转大写后的字母发送回客户端

[java]  view plain  copy

1. //发送端  
2. packagecn.itcast_08;   
3. importjava.io.BufferedReader;  
4. importjava.io.BufferedWriter;  
5. importjava.io.IOException;  
6. importjava.io.InputStreamReader;  
7. importjava.io.OutputStreamWriter;  
8. importjava.net.Socket;  
9.    
10. /* 
11.  * 需求：数据来源于键盘录入与，通过服务器转成大写，然后反馈给客户端显示。 
12.  */  
13. public classClientDemo {  
14.        public static void main(String[] args)throws IOException {  
15.               //创建客户端Socket对象  
16.               Sockets = new Socket("192.168.3.100", 22222);  
17.    
18.               //封装键盘录入  
19.               BufferedReaderbr = new BufferedReader(new InputStreamReader(System.in));  
20.               //获取输出流  
21.               //OutputStream os = s.getOutputStream();  
22.               BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(  
23.                             s.getOutputStream()));  
24.    
25.               Stringline = null;  
26.               while((line = br.readLine()) != null) {  
27.                      if ("over".equals(line)) {  
28.                             break;  
29.                      }  
30.    
31.                      bw.write(line);  
32.                      bw.newLine();  
33.                      bw.flush();  
34.    
35.                      // 获取服务器的反馈  
36.                      BufferedReader brServer = newBufferedReader(new InputStreamReader(  
37.                                    s.getInputStream()));  
38.                      String server = brServer.readLine();  
39.                      System.out.println("server:" +server);  
40.               }  
41.    
42.               br.close();  
43.               s.close();  
44.        }  
45. }  
46. //接收端  
47. packagecn.itcast_08;  
48.    
49. importjava.io.BufferedReader;  
50. importjava.io.BufferedWriter;  
51. importjava.io.IOException;  
52. importjava.io.InputStreamReader;  
53. importjava.io.OutputStreamWriter;  
54. import java.net.ServerSocket;  
55. importjava.net.Socket;  
56.    
57. public classServerDemo {   
58.        public static void main(String[] args)throws IOException {  
59.               //创建服务器Socket对象  
60.               ServerSocketss = new ServerSocket(22222);  
61.    
62.               //监听客户端  
63.               Sockets = ss.accept();  
64.    
65.               //获取输入流  
66.               BufferedReaderbr = new BufferedReader(new InputStreamReader(  
67.                             s.getInputStream()));  
68.               BufferedWriterbw = new BufferedWriter(new OutputStreamWriter(  
69.                             s.getOutputStream()));  
70.    
71.               Stringline = null;  
72.               while((line = br.readLine()) != null) {  
73.                      bw.write(line.toUpperCase());  
74.                      bw.newLine();  
75.                      bw.flush();  
76.               }  
77.    
78.               s.close();  
79.               //ss.close();  
80.        }  
81. }  

二、设计模式

设计模式：

       设计模式是一种思想（不是技术，技术是像IO 反射 集合这样的），是一种帮助开发人员完成某些代码上的逻辑，

              使代码的逻辑更严谨，是代码更加简洁，美观。（设计模式并没有提高代码的运行效率和速度，

              如果想要更多的去了解如何提高程序的运行速度的思想，请去了解数据结构的思想

              数据结构的思想：拿空间换时间拿时间换空间）

              通常项目比较庞大的情况下才能体现出设计模式的好处 

       创建型：创建对象。工厂模式，单例模式。

       结构型：对象间的关系。装饰模式。

       行为型：对象能够做什么。模板模式。 

       1、工厂模式：当我们想要获取某个对象的时候，想在获取对象之前做一些初始化的动作就用到了工厂模式          

           简单工厂模式举例：        

[java]  view plain  copy

1. public abstract class Animal {  
2.                  publicabstract void eat();  
3.           }               
4.           public class AnimalFactory {  
5.                  privateAnimalFactory() {  
6.                  }  
7.                  publicstatic Animal createAnimal(String type) {  
8.                         if ("dog".equals(type)) {  
9.                                returnnew Dog();  
10.                         } else if ("cat".equals(type)){  
11.                                returnnew Cat();  
12.                         } else {  
13.                                returnnull;  
14.                         }  
15.                  }  
16.           }  
17.           public static void main(String[] args) {  
18.            
19.                  Animala = AnimalFactory.createAnimal("dog");  
20.                  a.eat();  
21.                   
22.                  a= AnimalFactory.createAnimal("cat");  
23.                  a.eat();  
24.           }  
25.   
26.           public class Cat extends Animal {  
27.                  @Override  
28.                  publicvoid eat() {  
29.                         System.out.println("猫吃老鼠");  
30.                  }  
31.           }  
32.   
33.           public class Dog extends Animal {  
34.                  @Override  
35.                  publicvoid eat() {  
36.                         System.out.println("狗吃骨头");  
37.                  }  
38.           }  

          工厂方法模式举例：

              

[java]  view plain  copy

1. public abstract class Animal {  
2.                      publicabstract void eat();  
3.               }  
4.    
5.               public abstract class AnimalFactory {  
6.                      publicabstract Animal createAnimal();  
7.               }  
8.               public class Cat extends Animal {  
9.                      @Override  
10.                      publicvoid eat() {  
11.                             System.out.println("猫吃老鼠");  
12.                      }  
13.               }  
14.               public class CatFactory extendsAnimalFactory {  
15.                      @Override  
16.                      publicAnimal createAnimal() {  
17.                             return new Cat();  
18.                      }  
19.               }  
20.               public class Dog extends Animal {  
21.                      @Override  
22.                      publicvoid eat() {  
23.                             System.out.println("狗吃骨头");  
24.                      }  
25.               }  
26.               public class DogFactory extendsAnimalFactory {  
27.                      @Override  
28.                      publicAnimal createAnimal() {  
29.                             return new Dog();  
30.                      }  
31.               }  
32.               public class Pig extends Animal {  
33.                      @Override  
34.                      publicvoid eat() {  
35.                             System.out.println("猪吃饲料");  
36.                      }  
37.               }  
38.               public class PigFactory extendsAnimalFactory {  
39.                      @Override  
40.                      publicAnimal createAnimal() {  
41.                             return new Pig();  
42.                      }  
43.               }  
44.               public class AnimalTest {  
45.                      publicstatic void main(String[] args) {  
46.                             // 使用狗工厂  
47.                             AnimalFactory af = new DogFactory();  
48.                             Animal a = af.createAnimal();  
49.                             a.eat();  
50.    
51.                             af = new CatFactory();  
52.                             a = af.createAnimal();  
53.                             a.eat();  
54.    
55.                             af = new PigFactory();  
56.                             a = af.createAnimal();  
57.                             a.eat();  
58.                      }  
59.               }  
60.  <span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">       </span>  

2、单例设计模式：当我们想要在所有程序运行状态中，所用的一个类的对象，都是同一个对象的时候就用单例模式          

           单例饿汉式举例：

            

[java]  view plain  copy

1. public class Student {  
2.                    //把构造方法私有，是为了不让外界随意创建  
3.                    privateStudent() {  
4.                    }  
5.                    //类本身要创建一个对象。  
6.                    //由于静态只能访问静态，所以这里加静态  
7.                    //为了不让外界通过类名直接访问s成员变量，就加私有  
8.                    privatestatic Student s = new Student();  
9.   
10.                    //提供公共的方式让别人使用  
11.                    //为了让外界能够直接通过类名访问该方法，需要对该方法加静态  
12.                    publicstatic Student getStudent() {  
13.                           // return new Student(); //这是有问题的  
14.                           return s;  
15.                    }  
16.             }<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>  

           单例懒汉式举例：

             

[java]  view plain  copy

1. public class Teacher {  
2.   
3.                     privateTeacher() {  
4.                     }  
5.                     privatestatic Teacher t = null;  
6.                     publicsynchronized static Teacher getTeacher() {  
7.                            // t1,t2,t3三个线程过来了  
8.                            // 如果t是null的时候，才创建对象  
9.                            if (t == null) {  
10.                                   //t1进来了,CPU的执行权就被t2抢到了,同理t3  
11.                                   t= new Teacher();  
12.                            }  
13.                            return t;  
14.                     }  
15.              }<span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"> </span>  

       模板设计模式：当我们执行的某些程序时发现执行的所有的程序 外面的框框都不会变，只需要改变同样地方的一些东西的时候，就可以使用模板模式      

            

[java]  view plain  copy

1. public class PrintDemo1 extendsPrintTemplet {  
2.                    @Override  
3.                    publicvoid printHead() {  
4.                           System.out.println("采用第一种方案打印头");  
5.                    }  
6.                    @Override  
7.                    publicvoid printBody() {  
8.                           System.out.println("采用第一种方案打印中间");  
9.                    }  
10.                    @Override  
11.                    publicvoid printBottom() {  
12.                           System.out.println("采用第一种方案打印尾");  
13.                    }  
14.             }  
15.   
16.             public class PrintDemo2 extendsPrintTemplet {  
17.                    @Override  
18.                    publicvoid printHead() {  
19.                           System.out.println("采用第二种方案打印头");  
20.                    }  
21.                    @Override  
22.                    publicvoid printBody() {  
23.                           System.out.println("采用第二种方案打印中间");  
24.                    }  
25.                    @Override  
26.                    publicvoid printBottom() {  
27.                           System.out.println("采用第二种方案打印尾");  
28.                    }  
29.             }  
30.             public abstract class PrintTemplet {  
31.                    publicvoid print() {  
32.                           printHead();  
33.                           printBody();  
34.                           printBottom();  
35.                    }  
36.                    publicabstract void printHead();  
37.                    publicabstract void printBody();  
38.                    publicabstract void printBottom();  
39.             }  
40.             public class PrintTest {  
41.                    publicstatic void main(String[] args) {  
42.                           PrintTemplet pt = new PrintDemo1();  
43.                           pt.print();  
44.                           System.out.println("------------");  
45.                           pt = new PrintDemo2();  
46.                           pt.print();  
47.                    }  
48.             }  

3、装饰者模式：当我们觉得某个类的内容需要拓展一些功能的时候，我们会首先想到继承，确实继承可以解决在原来的基础上拓展功能

                     但是当子类想用原来的功能，就必须要用父类来实现，但是如果某一天父类功能改变了，我还想让子类有同样的功能和拓展功能，

                     这样是不能实现的。

                     所以我们有了装饰者设计模式，建一个装饰类，把被装饰的类作为构造方法的参数传进来，就可以实现功能的拓展，

                     这就是装饰者模式 

           装饰者模式举例：

            

[java]  view plain  copy

1. public interface Phone {  
2.                    publicabstract void call();  
3.             }  
4.             public class PhoneImpl implements Phone {  
5.             @Override  
6.                    publicvoid call() {  
7.                           System.out.println("用手机打电话");  
8.                    }  
9.             }  
10.             public abstract class PhoneDecorateimplements Phone {  
11.                    privatePhone phone;  
12.                    publicPhoneDecorate(Phone phone) {  
13.                           this.phone = phone;  
14.                    }  
15.                    @Override  
16.                    publicvoid call() {  
17.                           this.phone.call();  
18.                    }  
19.             }  
20.   
21.             public class GuangGaoPhoneDecorateextends PhoneDecorate {  
22.                    publicGuangGaoPhoneDecorate(Phone phone) {  
23.                           super(phone);  
24.                    }  
25.                    @Override  
26.                    publicvoid call() {  
27.                           super.call();  
28.                           System.out.println("播放广告");  
29.                    }  
30.             }  
31.   
32.             public class ColorPhoneDecorate extendsPhoneDecorate {  
33.                    publicColorPhoneDecorate(Phone phone) {  
34.                           super(phone);  
35.                    }  
36.                    @Override  
37.                    publicvoid call() {  
38.                           System.out.println("播放彩铃");  
39.                           super.call();  
40.                    }  
41.             }  
42.             public class PhoneTest {  
43.                    publicstatic void main(String[] args) {  
44.                           Phone p = new PhoneImpl();  
45.                           p.call();  
46.                           System.out.println("---------------");  
47.   
48.                           PhoneDecorate pd = newColorPhoneDecorate(p);  
49.                           pd.call();  
50.                           System.out.println("---------------");  
51.   
52.                           pd = new GuangGaoPhoneDecorate(p);  
53.                           pd.call();  
54.                           System.out.println("---------------");  
55.   
56.                           ColorPhoneDecorate cc =newColorPhoneDecorate(p);  
57.                           pd = new GuangGaoPhoneDecorate(cc);  
58.                           pd.call();  
59.                    }  
60.             }  
61.