黑马程序员JAVA学习第八节

黑马程序员JAVA学习第八节

（视频链接黑马程序员全套Java教程_Java基础入门教程，零基础小白自学Java必备教程_哔哩哔哩 (゜-゜)つロ 干杯~-bilibili）

本节主要内容是网络编程入门，Lambda 表达式，接口组成更新， 方法引用。对应视频340-372。

网络编程入门

1 .网络编程概述

1）计算机网络
是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。
2）网络编程
在网络通信协议下，实现网络互连的不同计算机上运行的程序间可以进行数据交换

2.网络编程三要素

1)IP 地址
要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
2)端口
网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识
3)协议
通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议

3 .IP地址

1)IP地址：是网络中设备的唯一标识
2)IP 地址分为两大类
IPv4 ：是给每个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每
个IP地址长32bit，也就是4个字节。例如一个采用二进制形式的IP地址是“11000000 10101000
00000001 01000010”，这么长的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制
的形式，中间使用符号“.”分隔不同的字节。于是，上面的IP地址可以表示为“192.168.1.66”。IP地址的这
种表示法叫做“点分十进制表示法”，这显然比1和0容易记忆得多
IPv6 ：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发
紧张。为了扩大地址空间，通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8
组十六进制数，这样就解决了网络地址资源数量不够的问题

3)DOS 常用命令：
ipconfig ：查看本机IP地址
ping IP 地址：检查网络是否连通

4)特殊 IP地址：
127.0.0.1 ：是回送地址，可以代表本机地址，一般用来测试使用

4.InetAddress 【应用】

    InetAddress address = InetAddress.getByName("192.168.1.66");
    //public String getHostName()：获取此IP地址的主机名
    String name = address.getHostName();
    //public String getHostAddress()：返回文本显示中的IP地址字符串
    String ip = address.getHostAddress();
    System.out.println("主机名：" + name);
    System.out.println("IP地址：" + ip);

5.端口和协议

1)端口
   设备上应用程序的唯一标识
2)端口号
   用两个字节表示的整数，它的取值范围是 0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败
3)协议
   计算机网络中，连接和通信的规则被称为网络通信协议
4)UDP 协议
    用户数据报协议 (User Datagram Protocol),UDP 是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台
计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
由于使用 UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议通常采用 UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在
传输重要数据时不建议使用UDP协议.
5)TCP 协议
     传输控制协议 (Transmission Control Protocol):TCP 协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数
据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”
三次握手： TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
   第一次握手，客户端向服务器端发出连接请求，等待服务器确认
   第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
   第三次握手，客户端再次向服务器端发送确认信息，确认连接
完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等.

6.UDP 通信程序

1)Java 中的UDP通信
UDP 协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念Java 提供了DatagramSocket类作为基于UDP协议的Socket

2)方法

3）发送数据的步骤

   创建发送端的 Socket对象(DatagramSocket)
   创建数据，并把数据打包
   调用 DatagramSocket对象的方法发送数据
   关闭发送端

    //创建发送端的Socket对象(DatagramSocket)
    // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口
    DatagramSocket ds = new DatagramSocket();
    //创建数据，并把数据打包
    //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
    //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。
    byte[] bys = "hello,udp,我来了".getBytes();
    DatagramPacket dp = new
DatagramPacket(bys,bys.length,InetAddress.getByName("192.168.1.66"),10086);
    //调用DatagramSocket对象的方法发送数据
    //void send(DatagramPacket p) 从此套接字发送数据报包
    ds.send(dp);
    //关闭发送端
    //void close() 关闭此数据报套接字
    ds.close();

4）UDP接收数据

1）接收数据的步骤
   创建接收端的 Socket对象(DatagramSocket)
   创建一个数据包，用于接收数据
   调用 DatagramSocket对象的方法接收数据
   解析数据包，并把数据在控制台显示
   关闭接收端

2）方法

    //创建接收端的Socket对象(DatagramSocket)
    DatagramSocket ds = new DatagramSocket(12345);
    while (true) {
      //创建一个数据包，用于接收数据
      byte[] bys = new byte[1024];
      DatagramPacket dp = new DatagramPacket(bys, bys.length);
      //调用DatagramSocket对象的方法接收数据
      ds.receive(dp);
      //解析数据包，并把数据在控制台显示
      System.out.println("数据是：" + new String(dp.getData(), 0,      
                dp.getLength()));

7.TCP 通信程序

1）TCP发送数据

Java 中的TCP通信
    Java 对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
   Java 为客户端提供了Socket类，为服务器端提供了ServerSocket类

（1）方法

（2）发送数据步骤

（1）创建客户端的Socket对象（Socket）

（2）获取输出流，写数据

（3）释放资源

    //创建客户端的Socket对象(Socket)
    //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号
    Socket s = new Socket("192.168.1.66",10000);
    //获取输出流，写数据
    //OutputStream getOutputStream() 返回此套接字的输出流
    OutputStream os = s.getOutputStream();
    os.write("hello,tcp,我来了".getBytes());
    //释放资源
    s.close();

2）TCP接收数据

（1）接受数据的步骤

    创建服务器端的Socket对象（ServerSocket）

    获取输入流，读数据，并把数据显示在控制台

    释放资源

（2）方法

//创建服务器端的Socket对象(ServerSocket)
    //ServerSocket(int port) 创建绑定到指定端口的服务器套接字
    ServerSocket ss = new ServerSocket(10000);
    //Socket accept() 侦听要连接到此套接字并接受它
    Socket s = ss.accept();
    //获取输入流，读数据，并把数据显示在控制台
    InputStream is = s.getInputStream();
    byte[] bys = new byte[1024];
    int len = is.read(bys);
    String data = new String(bys,0,len);
    System.out.println("数据是：" + data);
    //释放资源
    s.close();
    ss.close();

Lambda 表达式

1.函数式编程思想概述
函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现

2.方式比较

//方式一
//    MyRunnable my = new MyRunnable();
//    Thread t = new Thread(my);
//    t.start();
    //方式二
//    new Thread(new Runnable() {
//      @Override
//      public void run() {
//        System.out.println("多线程程序启动了");
//      }
//    }).start();
    //方式三
    new Thread( () -> {
      System.out.println("多线程程序启动了");
   } ).start();

3.Lambda表达式的标准格式
1）格式：
(形式参数) -> {代码块}
     形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
     -> ：由英文中画线和大于符号组成，固定写法。代表指向动作
     代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
2）组成 Lambda表达式的三要素：
     形式参数，箭头，代码块

4.Lambda表达式的省略模式
省略的规则
 1）参数类型可以省略。但是有多个参数的情况下，不能只省略一个
2）如果参数有且仅有一个，那么小括号可以省略
3）如果代码块的语句只有一条，可以省略大括号和分号，和 return关键字

//    useAddable((int x,int y) -> {
//      return x + y;
//    });
    //参数的类型可以省略
    useAddable((x, y) -> {
      return x + y;
   });
//    useFlyable((String s) -> {
//      System.out.println(s);
//    });
    //如果参数有且仅有一个，那么小括号可以省略
//    useFlyable(s -> {
//      System.out.println(s);
//    });
    //如果代码块的语句只有一条，可以省略大括号和分号
    useFlyable(s -> System.out.println(s));
    //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
    useAddable((x, y) -> x + y);

5.Lambda表达式的注意事项
1）使用 Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
2）必须有上下文环境，才能推导出 Lambda对应的接口
      （1）根据局部变量的赋值得知 Lambda对应的接口
                   Runnable r = () -> System.out.println("Lambda表达式");
      （2）根据调用方法的参数得知 Lambda对应的接口

                  new Thread(() -> System.out.println("Lambda 表达式")).start();

6.Lambda表达式和匿名内部类的区别

1）所需类型不同
     匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
     Lambda 表达式：只能是接口
2）使用限制不同
      如果接口中有且仅有一个抽象方法，可以使用 Lambda表达式，也可以使用匿名内部类
      如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用 Lambda表达式
3）实现原理不同
       匿名内部类：编译之后，产生一个单独的 .class字节码文件
       Lambda 表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

接口组成更新

1.接口的组成

1）常量 public static final

2）抽象方法  public abstract

3）新加方法：默认方法 (Java 8)，静态方法 (Java 8)，私有方法 (Java 9）

2.接口中默认方法

1)格式
public default 返回值类型 方法名(参数列表) { }

2)代码

public default void show3() {
}

3）注意事项
默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉 default关键字，public 可以省略，default不能省略

3.接口中静态方法

1）格式  public static 返回值类型 方法名(参数列表) { }

2）

public static void show() {
}

3）注意事项

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
public 可以省略，static不能省略

4.接口中私有方法

1）格式 

格式 1 private 返回值类型 方法名(参数列表) { }

格式 2 private static 返回值类型 方法名(参数列表) { }

2）代码

private void show() { //格式1
}
private static void method() { //格式2
}

3）注意事项

默认方法可以调用私有的静态方法和非静态方法
静态方法只能调用私有的静态方法

 方法引用

1.方法引用符

1）   :: 该符号为引用运算符，而它所在的表达式被称为方法引用

2）推导与省略
如果使用 Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
如果使用方法引用，也是同样可以根据上下文进行推导，方法引用是 Lambda的孪生兄弟

    //在主方法中调用usePrintable方法
//    usePrintable((String s) -> {
//      System.out.println(s);
//    });
  //Lambda简化写法
    usePrintable(s -> System.out.println(s));
    //方法引用
    usePrintable(System.out::println);

2.引用类方法

1）引用类方法，其实就是引用类的静态方法
2）格式   类名::静态方法
3）范例 Integer::parseInt
Integer类的方法：public static int parseInt(String s) 将此String转换为int类型数据

4）使用说明
Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

3.引用对象的实例方法

引用对象的实例方法，其实就引用类中的成员方法
1)格式 对象::成员方法
2)范例  "HelloWorld"::toUpperCase 
String类中的方法：public String toUpperCase() 将此String所有字符转换为大写

3)使用说明  Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

4.引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法
1)格式 类名::成员方法
2)范例 String::substring
public String substring(int beginIndex,int endIndex)   从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex

3)使用说明  Lambda表达式被类的实例方法替代的时候 第一个参数作为调用者 后面的参数全部传递给该方法作为参数

5.引用构造器

引用构造器，其实就是引用构造方法
1)格式  类名::new
2)范例 Student::new

3)使用说明  Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数