Java 学习笔记

开始接触java，内心非常的有压力，但是还有点小激动，因为对java的强大早有耳闻，终于在项目的驱动下，能够进行系统的学习和实践，甚至还有点小激动。
这个博客的学习内容基于菜鸟教程，有需要的同学可以进行自行学习。
随文附上学习链接：https://www.runoob.com/java/java-tutorial.html。

一. java的安装与配置

电脑是mac，所以从官网下载链接下载，选择1.8较为稳定的版本进行下载，mac安装不需要配环境，安装完成即为配置成功，在终端输入java -version来查看是否安装成功，如果能够显示安装的java版本，即为安装成功。

二 java程序的编译

使用的IDE为vscode，需要下载插件Java Extension Pack插件，既能成功编译程序

三 java基础语法

一个java程序可以被认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。
1 简单的几个概念
（1）对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有颜色、名字、品种。行为有摇尾巴、叫、吃等。
（2）类：类是一个模版，它描述一类对象的行为和状态。
（3）方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
（4）实例变量：每个对象都有独特的实例变量，对象的状态由这些实例变量的值决定。
2 基本语法
在编写java程序时，应该注意以下几点：
（1）大小写敏感。java大小写是敏感的。
（2）类名：对于所有的类来说，类名的首字母应该大写。如果类名有若干单词组成，那么每个单词的首字母应该大写，例如MyFirstJavaClass。
（3）方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的那个单词首字母大写。
（4）源文件名：源文件名必须和类名相同。当保存文件时，你应该使用类名作为文件名保存（切记java是大小写敏感的），文件名的后缀为 .java。
（5）主方法入口：所有的java程序由public static void mian(String[]args)方法开始执行。
3 java标识符
java所有的组成部分都需要名字。类名、变量名以及所有的方法名都被称为标识符。
关于java的标识符，有以下几点需要注意：
（1）所有的标识符都应该以字母（A-Z或者a-z）、美元符（$）、或者下划线（-）开始

（2）首字符之后可以是字母（A-Z或者a-z）、美元符（$）、或者下划线（-）或数字的任何字符组合。
（3）关键字不能用作标识符
（4）标识符的大小写是敏感的
4 继承
在java中，一个类可以由其他类派生，如果要创建一个类，而且存在一个类具有你所需要的属性或方法，那么你恶意将新创建的类继承该类。
利用继承的方法，可以重用已存在的类的方法和属性，而不用重写这些代码，被继承的类称为超类（super class），派生类称为子类（subclass）
5 接口
在java中，接口可以理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
接口只定义派生类要用到的方法，但是方法的具体实现完全取决于派生类。

四 java 的对象和类

1 构造方法
每个类都有构造方法。如果没有显示的为类定义构造方法，java编译器将会为该类提供一个默认构造方法。在创建一个对象的时候，至少要调用一个构造方法。构造方法的明证必须与类同名，一个类可以有多个构造方法。

2 创建对象

对象是根据类进行创建的。在java中，使用关键字new来创建一个新的对象。
创建对象需要以下三步

• 声明 ：声明一个对象，包括对象名称和对象类型
• 实例化：使用关键字new来创建一个对象
• 初始化：使用new创建对象时，会调用构造方法初始化对象

下面的代码展示了如何创建对象、如何让访问实例变量和调用成员方法：

public class Puppy{
   int puppyAge;
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是： " + name );
   }
   public void setAge(int age){
      puppyAge = age;
   }
   public int getAge(){
      System.out.println("小狗的年龄为：" + puppyAge );
      return puppyAge;
   }

   public static void main (String[] args){
      //下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy("tommy");
      //通过方法来设定age
      myPuppy.setAge(2);
      //调用另一个方法来获取age
      myPuppy.getAge();
      //你也可以向下面这样访问成员变量
      System.out.println("变量值： " + myPuppy.puppyAge);
   }
}

编译运行上面的程序，产生如下结果：

3. 源文件声明规则

当在一个源文件定义多个类，并且还有import和package语句时，要注意下面的规则。

• 一个源文件中只能有一个public类
• 一个源文件可以有多个非public类
• 源文件的名称应该和public类的类名保持一致。例如：源文件public类的类名Employee,那么源文件应该命名为Employee.java
• 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
• 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
• import语句和package语句对源文件中定义的所有类都有效。在统一源文件中，不能给不同的类不同的包声明。

四 java 基本数据类型

1 基本数据类型
Java语言提供了八种基本类型。
六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
需要注意的是：
！Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。
2 自动类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行计算。
转换从低级到高级

低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

• 不能对boolean类型进行类型转换
• 不能把对象类型转换成不相关类的对象
• 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
• 转换过程中可能导致溢出或损失精度。

五 java 变量类型

在java语言中，所有变量在使用前必须声明。声明变量的基本格式如下：

type identifier [ = value][, identifier [= value] ...] ;

格式说明：type为java数据类型。identifier是变量名。可以用逗号隔开来声明多个同类型变量

java语言支持的变量类型有：

• 类变量：独立于方法之外的变量，用static修饰
• 实例变量：独立于方法之外的变量，不过没有static修饰
• 局部变量：类的方法中的变量

public class Variable{
    static int allClicks=0;    // 类变量
 
    String str="hello world";  // 实例变量
 
    public void method(){
 
        int i =0;  // 局部变量
 
    }
}

成员变量、局部变量、静态变量的区别：

六 java修饰符

java语言提供了很多修饰符，主要分为访问修饰符和非访问修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端。
1 访问控制修饰符
java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。java支持4种不同的访问权限。

• default：（即缺省，什么也不写）在同一包内可见，不使用任何修饰符。
  使用对象：类、接口、变量、方法

• private：在同一类内可见。
  使用对象：变量、方法。 ！！！注意不能修饰类（外部类）。

• public：对所有类可见。
  使用对象：类、接口、变量、方法

• protected：对同一包内的类和所有子类可见。
  使用对象：变量、方法。！！！注意不能修饰类（外部类）。

七 Java 运算符

1 算术运算符

前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算
下面是前后缀自增的实例：

public class Test{
   public static void main(String[] args){
       int a = 5;//定义一个变量；
       int b = 5;
       int x = 2*++a;
       int y = 2*b++;
       System.out.println("自增运算符前缀运算后a="+a+",x="+x);
       System.out.println("自增运算符后缀运算后b="+b+",y="+y);
   }
}

2 位运算符

java定义了位运算符，应用于整数类型（int）、长整型（long）、短整型（short）、字符型（char）和字节型（byte）等类型。

3条件运算符
条件运算符也被称为三元运算符。该运算符有三个操作数，并且需要判断布尔表达式的值，该运算符的主要是决定哪个值应该赋值给变量。

variable x = (expression) ? value if true : value if false

八 java条件语句 - if…else

嵌套的 if…else 语句
使用嵌套的 if…else 语句是合法的。也就是说你可以在另一个 if 或者 else if 语句中使用 if 或者 else if 语句。
语法：

if(布尔表达式 1){
   如果布尔表达式 1的值为true执行代码
   if(布尔表达式 2){
      如果布尔表达式 2的值为true执行代码
   }
}

实例：

public class Test {
 
   public static void main(String args[]){
      int x = 30;
      int y = 10;
 
      if( x == 30 ){
         if( y == 10 ){
             System.out.print("X = 30 and Y = 10");
          }
       }
    }
}

以上代码编译结果：

X = 30 and Y = 10

练习：
输出 200 以内能被 7 整除但是不能被 4 整除的数字，并且每行输出 6 个：
代码：

public class Test{
   public static void main(String[] args){
      System.out.println("输出200以内能被7整除但是不能被4整除的数字");
      //一个计数器，后面用于控制每行打印的个数
      int k = 1;
      //用for循环进行200以内的循环
      for (int i = 0; i <=200;i++){
         //if语句判断是否为题目中的条件，如果满足，则打印
         if (i % 7 == 0 && i % 4 != 0){
            System.out.print(i +"\t");
            //每次循环都将计数器+1
            k++;
            //如果计数器大于6就换行，并且将计数器归一，重新进入下一次循环计算
            if (k > 6){
               System.out.println();
               k=1;
            }
         }
      }
   }
}

输出结果：

输出200以内能被7整除但是不能被4整除的数字
7    14    21    35    42    49    
63    70    77    91    98    105    
119    126    133    147    154    161    
175    182    189

九 java string类

1 字符串长度
用于获取有关对象的信息的方法称为访问器方法。
String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。
2 连接字符串

string1.concat(string2);

返回 string2 连接 string1 的新字符串。

也可以对字符串常量使用 concat() 方法，如：

"我的名字是 ".concat("Runoob");

更常用的是使用’+'操作符来连接字符串，如：

"Hello," + " runoob" + "!"

十 java 数组

Java 语言中提供的数组是用来存储固定大小的同类型元素。
你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，…，number99。

1 声明数组变量
首先必须声明变量，才能在程序中使用数组。
声明数组变量语法：

dataType[] arrayRefVar ;

实例：

double[] myList;   

2 创建数组
java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arrySize];

上面的语法语句做了两件事：

• 使用dataType[arraySize]创建了一个数组
• 把新创建的数组的引用赋值给变量arrayRefVar

还可以用下面的方式创建数组：

dataType[] arrayRefVar = {value0, value1, ....,valuek};

数组的元素是通过索引访问的。数组索引从0开始，所以索引值从0到arrayRefVar.length - 1

数组变量的声明，和创建数组可以用一条语句完成，如下：

dataType[] arrayRefVar = new dataType [arraySize] 

下面的实例展示了如何创建、初始化和操纵数组：

public class Test{
   public static void main (String[] args){
      double[] myList = {1.9, 2.9, 3.4, 3.5};
      
      //打印所有元素的总和
      double total = 0;
      for (int i =0; i < myList.length; i++){
         total += myList[i];
      }
      System.out.println("Total is " + total);
      
      //查找最大元素
      double max = myList[0];
      for (int i = 1; i <myList.length; i++){
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

实例的输出结果为：

Total is 11.7
Max is 3.5

十一 java 方法

1 经常使用的System.out.println() 构成

• printlin() 是一个方法
• System 是系统类
• out 是标准输出对象

这句话的用法是调用系统类System中 的标准输出对象out中的方法println()
2 什么是方法？
java方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被引用

3 方法的命名规则

• 方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。例如addPerson
• 下划线可能出现在JUit测试方法名称中应以分割名称的逻辑组件。
  一个典型的模式是 test_

4 方法的定义
一般情况下，定义一个方法包含以下语法：

修饰符  返回值类型  方法名（参数类型  参数名）{
...
方法体
...
return 返回值；
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

• 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法，定义类该方法的访问类型。
• 返回值类型：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键词void。
• 方法名：是方法的实际名称。方法名和参数共同构成方法签名。
• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数，这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
• 方法体：方法体包含具体的语句，定义该方法的功能。

如static float interest(float principal, int year){...}

注意：在一些其它语言中方法指过程和函数。
一个返回非void类型返回值的方法称为函数
一个返回void类型返回值的方法叫做过程。

5 方法调用

java支持两种调用方法的方式，根据方法是否返回值来选择。
当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用的方法的返回语句执行或者到达方法体闭括号时交还控制权给程序。

• 当方法返回一个值的时候，方法调用通常被当作一个值。
  例如：int larger = max (30,40);
• 如果方法返回值是void，方法调用一定是一条语句。
  例如，方法println 返回void。下面的调用是个语句：

System.out.println ("学java 顺利！");

6 方法的重载
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。
java编译器根据方法签名判断哪个方法应该被调用。
方法重载可以让程序更清晰易读，执行迷人相关任务的方法应该使用相同的名字。
重载的方法必须拥有不同的参数列表，不能仅仅依据修饰符或者返回类型的不同来重载方法。

十二 java封装

在面向对象程序设计方法中，封装（Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程序码更容易理解和维护，也加强了程序码的安全性。

1实现java封装的步骤
（1）修改属性的可见行来限制对属性的访问（一般限制为private），例如：

public class Person {
    private String name;
    private int age;
}

这段代码中，将name和age属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

（2）对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问。

十三 java接口

1基本概念

• 接口（interface），在java中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

• 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法，接口则包含类要实现的方法。

• 除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

• 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在java中，接口类型可用来声明一个变量，它们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

2接口与类相似点

• 一个接口可以有多个方法
• 接口文件保存在 .java 结尾的文件中，文件名使用接口名
• 接口的字节码文件保存在 .class 结尾的文件中
• 接口相应的字节码必须在与包名称相匹配的目录结构中

3接口与类的区别

• 接口不能用于实例化对象
• 接口没有构造方法
• 接口中所有的方法必须是抽象方法
• 接口不能包含成员变量，除了static和final变量
• 接口不是被类继承了，而是要被类实现
• 接口支持多继承

4接口特性

• 接口中每一个方法也是隐式抽象的，接口中的方法会被隐式的指定为 public abstract（只能是 public abstract ， 其它修饰符会报错）
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final变量（并且只能是 public， 用private 修饰会报编译错误）
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法

5抽象类和接口的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
• 接口中不能含有静态代码块以及静态方法（用static修饰的方法），而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

6接口的声明
接口的声明语法格式如下：

[可见度]  interface 接口名称  [extends 其他的接口名]{
				//声明变量
				//抽象方法
}

interface关键字用来声明一个接口。
下面是接口声明的一个简单例子：

//文件名：NameOfInterface.java
import java.log.*;
//引入包

public interface NameOfInterface
{
		//任何类型 final,static字段
		//抽象方法
}

接口具有以下特性：

• 接口是隐式抽象的，当声明一个接口时，不必使用abstract关键字
• 接口中的每一个方法也是隐式抽象的，声明时同样不需要abstract关键字
• 接口的方法都是公用的

7接口的实现
当类实现接口时，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中，implements关键字放在class声明后面。

（1） 实现一个接口的算法，可以使用下面的公式：

...implements  接口名称 [,  其它接口名称， 其它接口名称 ... , ...] ...

（2） 重写接口中声明的方法时，需要注意下面的规则

• 类在实现结构的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型
• 如果实现接口的类是抽象类，那么没必要实现该接口的方法

8java的多继承

在java中，类的多继承是不合法，但接口允许多继承
在接口的多继承extends关键字只需要使用一次，在其后跟着继承接口
如下所示

public interface Hockey extends Sports, Event

以上的程序片段是合法定义的子接口，与类不同的是，接口允许多继承，而Sports及Event可能定义或是继承相同的方法

十四 java泛型

1基本概念
java泛型（generice）是jdk5中引入的一个新特性，泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

假如我们有这样一个需求：写一个排序方法，能够对整形数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？
答案是可以使用java泛型
使用java泛型的概念，我们可以写一个泛型方法来对一个对象数组进行排序。然后，调用该泛型方法来对整型、浮点数数组、字符串数组进行排序。

2泛型方法
可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当的处理每一个方法调用。
下面是定义泛型方法的规则：

• 所有的泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于制定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int， double, char 的等）。

下面的实例演示了如何使用泛型方法打印不同字符串的元素：

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}

编译以上代码，输出结果为：

整型数组元素为:
1 2 3 4 5 

双精度型数组元素为:
1.1 2.2 3.3 4.4 

字符型数组元素为:
H E L L O 

有界的类型参数：
可能有时候，会想限制那些被允许穿到一个类型参数的类型种类范围。例如，一个操作数字的方法可能只希望接收Number或者Number子类的实例，这就是有界类型参数的目的。
要声明一个有界的类型参数，首先列出类型参数的名称，后跟exrends关键字，最后紧跟它的上界。
下面的实例演示了“extends”如何使用在一般意义上的意思“extends”（类）或者 “implements”（接口）。该实例中的泛型方法返回三个可比较对象的最大值。

public class Test
{
   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

编译以上代码，得到的输出结果如下：

3, 4 和 5 中最大的数为 5

6.6, 8.8 和 7.7 中最大的数为 8.8

pear, apple 和 orange 中最大的数为 pear

十五 java 序列化

1基本概念

• java提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中的数据类型。
• 将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。
• 整个过程都是java虚拟机（JVM）独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象。
• 类ObjectInputStream和ObjectOutputStream是最高层次的数据流，它们包含反序列化和序列化对象的方法。
• 一个类要想序列化成功，必须满足两个条件：
  （1）该类必须实现java.io.Serializable对象
  （2）该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的。

如果想知道一个java标准类是否可序列化，可以查看该类的文档。检验一个类的实例是否能序列化很简单，只需要查看该类有没有实现java.io.Serializable接口。

关于序列化，又称为持久化，将其写入磁盘中。
进而对编码规则来说：
任意一个实体都要必须要去实现Serializable接口，方便以后将该类持久化，或者将其用于转为字节数组，用于网络传输。
对于一个实体类，不想将所有的属性都进行序列化，有专门的关键字transient：

private transient String name;

当对该类序列化时，会自动忽略transient修饰的属性

十六 java网络编程

1基本概念

• 网络编程是指编写运行在多个设备（计算机）的程序，这些设备都通过网络连接起来。
• java.net包中J2SE的API包含有类和接口，它们提供低层次的通信细节，可以直接利用这些类和接口，来专注于解决问题，而不用关注通信细节。
• java.net包中提供了两种常见的网络协议的支持：
  （1）TCP：TCP是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称为TCP/IP.
  (2)UDP：UDP是用户数据报协议的缩写，一个无连接的协议。提供了应用程序之间要发送的数据的数据包。

十七 java 多线程编程

1基本概念

• java给多线程提供了内置的支持。一条线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每条线程并行执行不同的任务。
• 多线程是多任务的一种特别的形式，但多线程使用了更小的资源开销。
• 定义一个和线程相关的另一个术语，进程。
  一个进程包括由操作系统分配的内存空间，包含一个或多个线程，一个线程不能独立的存在，它必须是进程的一部分。一个进程一直进行，直到所有的非守护线程都运行结束后才能结束。

2进程和线程的区别

• 进程：应用程序的执行实例，有独立的内存空间和系统资源
• 线程：CPU调度和分配的基本单位，进程中执行运算的最小单位，可完成一个独立的顺序控制流程

3进程和线程的联系

• 一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。线程是操作系统可识别的最小执行和调度单位。
• 资源分配给进程，同一进程的所有线程共享该进程的所有资源。同一进程中的多个线程共享代码段（代码和常量），数据段（全局变量和静态变量），拓展段（堆存储）。但是每个线程拥有自己的栈段，栈段又叫运行时段，用来存放所有局部变量和临时变量。
• 处理机分给线程，即真正在处理机上运行的是线程。
• 线程在执行过程中，需要协作同步。不同的线程间要利用消息通信的办法实现同步。

十八 Lambda 表达式

1基本概念

• Lambda 表达式，也可称为闭包，它是推动java8发布的最重要新特性
• Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法里）。

2语法
Lambda表达式的语法格式如下：

(parameters )  ->  expression
或
（parameters） -> (statements)

以下是Lambda表达式的重要特征：

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号
• 可选的大括号：如果一个主体包含了一个语句，就不需要使用大括号
• 可选的返回关键字：如果一个主体只有一个表达式返回值则编译器会自动返回值，大括号需要指明表达式返回了一个数值。

使用Lambda 表达式需要注意以下两点：

• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。
• Lambda 表达式免去了使用匿名方法的麻烦，并且给予java简单但是强大的函数化的编程能力。