java入门

2021-05-13  本文已影响0人  张_何

类名需要与文件名相同，大小写也要一样
public class 后面定义一个类的名称，类是java中所有源代码的基本组织单位。
main方法表示程序执行的起点

public class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello World !!!");
  }
}

关键字：
1、完全小写的字母

标识符：
1、可以包含字母、数字、$、_、且不能以数字开头，不能是关键字

命名规范：
类：大驼峰
变量和方法名：小驼峰

常量：
1、字符串常量：凡是用双引号引起来的部分叫做字符串常量 “abc”、“1234”
System.out.println("Hello World !!!");
2、整数常量：直接写上整型数字的，例如：100， 2，9
System.out.println(2);
3、浮点数常量：直接写上浮点型数字的，例如：1.9，34.0
System.out.println(3.0);
4、字符常量：凡是用单引号引起来的字符：‘a’，‘中’，‘3’
System.out.println(‘d’); // 单引号不能连着，哪怕中间有个空格也行
5、布尔常量：取值为true、false的
System.out.println(true);
6、空常量：null，代表没有任何数据，不能直接打印

变量：
数据类型 变量名称；// 创建变量
变量名称 = 数据；// 赋值
数据类型 变量名 = 数据； // 创建变量并赋值
没有赋值的变量不能使用，一定要先赋值后才能使用
变量的使用不能超出作用域的范围

数据类型：
基本数据类型
1、整型： byte、short、int、long，整型默认是int型，如果一定要是哟还能改long型，需要加一个后缀L
2、浮点型： float、double，浮点型可能是一个近视值，并非精确的值，浮点型默认是double，如果要使用float型，需要后面加一个后缀F。
3、字符型： char
4、布尔型：boolean

引用数据类型
1、字符串
2、数组
3、类
4、接口
5、Lambda

数据类型转换
当数据类型不一样时，将会发生数据类型转换
自动类型转换（隐式）
1、特点：代码不需要进行特殊处理，自动完成
2、数据范围从小到大
long num = 100；// 左边是long右边是int，符合从小到大的要求，这一行代码将发生自动类型转换
强制类型转化
1、特点：代码需要进行特殊的格式处理，不能自动完成
2、格式：范围小的类型 变量名 = （范围小的类型）原本范围大的数据
int num = （int）100L;

注意事项
1、强制类型转换一般不推荐使用，因为有可以能发生精度损失，数据溢出
2、byte、shor、char这三种类型都可以发生数学运算，在运算的时候，都会首先提升称为int类型，然后计算
3、boolean类型不能发生数据转换
4、对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过其范围，java编译器将会自动隐含地为我们补上一个（byte）（short）（char），如果超过了其范围编译器直接报错

int num = （int）3.99；
System.out.println(num); // 输出3，这里不是四舍五入，是直接舍弃小数部分

char zifu = ‘A’；
System.out.println(zifu + 1); // 输出66，这里A的Ascii码值对应65 ，会将字符A转换成65处理，字符一旦进行数学运算，会被处理成数字

任何数据类型和字符串相加+，结果都会变成字符串

一元运算符：自加、自减、取反、
二元运算符：+， - 、* 、/ 、% 、=
三元运算符：三目运算

switch case 后面的数据类型只能是： byte/short/char/int/ String/ enum/

intellij IDEA 中文创建的package会根据名称中的.分隔成父目录和子目录，例如shangcai.donghong.zhanglongwuhuibe 其文件结构就是shangcai文件夹中有一个donghong的文件夹，东洪文件夹中有个zhanglongwu的文件夹

intellij ide -->preferences-->keyMap-->点击设置按钮选duplicate--> main menu --> code--> code completion --> basic 修改成option + /, 设置成功后在写代码时输入快捷字符后，如果没有提示，只需要按一下option + / 就会出现提示；

alt + enter： 导入包，自动修正代码
ctrl + alt + l: 格式化代码
ctrl + shift + /: 选中代码注释，多行注释，

5.for 可以快速实现for循环

调用的三种方式：
单独调用
输出调用
赋值调用

方法重载：
多个方法名称一样，但是参数列表确不一样
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同
4.与参数名称无关
5.与方法的返回值无关

在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式

数组：
1.数组中类型必须统一
2.长度在程序运行期间不可改变
初始化
1.动态初始化（指定长度）：数据类型[] 数组名称 = new 数据类型[数组长度]；可分两步写 数据类型[] 数组名称；数组名称 = new 数据类型[数组长度]；
2、静态初始化（指定内容）：数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，元素3, ...}；可分两步写 数据类型[] 数组名称；数组名称 = new 数据类型[] {元素1，元素2，元素3}；
静态初始化的省略格式：数据类型[] 数组名称 = {元素1， 元素2，...};
静态初始化的省略格式不能分两步写；

如果不确定数组当中的具体内容，用动态初始化，已经确定了具体的内容，用静态初始化。

直接打印数组名称，得到的是数组对应的内存地址哈希值

访问数组元素的格式：数组名[索引值]

动态初始化数组的时候，其中的元素将会自动拥有一个默认值，规则如下：
如果是整数类型默认是0
如果是浮点类型默认是0.0
如果是字符类型默认是‘\u0000’
如果是布尔类型默认是false
如果是引用类型默认是null

java的内存需要划分为5个部分
1.栈（stack）：存放的都是方法中的局部变量，方法的运行一定要在栈当中运行。
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超出作用域，立刻从栈内存当中消失
2.堆（Heap）：凡是new出来的东西，都在堆当中
堆内存里面的东西都有一个地址值：16进制
堆内存里面的数据，都有默认值，规则：
如果是整型 默认为0
如果是浮点型 默认为0.0
如果是字符 默认为'\u0000'
如果是布尔 默认为false
如果是引用类型 默认为null
3.方法区（Method Area）存储class相关信息，包含方法的信息
4.本地方法栈（Native Method Stack）：与操作系统相关
5.寄存器（pc Register）：与CPU 相关

所有引用类型都可以赋值一个null值
数组必须进行new初始化才能使用其中的元素，如果只是赋值了一个null，没有进行new创建，那么将会发生空指针异常 NullPointerException

面向过程：当需要实现一个功能的时候，每一个具体的步骤都需要亲力亲为，详细处理每一个细节
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事

面向对象三大特点：继承、封装、多态

成员方法没有static 关键字
public void eat(){}

局部变量没有默认值；
成员变量会有默认值；

private关键字作用及使用

对于boolean类型的属性的getter方法要写成 isXxx，而set方法不变

this关键字

构造方法时专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称(参数类型 参数名称){
方法体
}
注意事项：
1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2.构造方法不要写返回值类型，连void也不要写
3.构造方法不能return 一个具体的返回值
4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体什么事情都不做。public Student(){}
5.一旦编写了至少一个构造方法，那么编译器将不再赠送
6.构造方法也是可以重载的

code-->generate 可以快捷生成getter setter 构造方法等

java 标准类 由下面四部分组成
1.所有的成员变量都要使用private关键字修饰
2.为每一个成员变量编写一对getter/setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法

导包
import 包路径.类名称
如果要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写
只有java.lang包下的内容不需要导包，其他的包都需要import 语句

从键盘输入
Scanner sc = new Scanner(System.in);// System.in表示从键盘输入
int num = sc.nextInt;

匿名对象

ArrayList
数组的长度是不可以发生改变的
ArrayList的长度是可以随意变化的
对ArrayList来说有一个尖括号<E>代表泛型
泛型，也就是装在集合当中的所有元素全都是统一的类型
注意：泛型只能是引用类型，不能是基本类型
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容，如果内容是空，得到的是[]
list.get(2);
如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的"包装类"
基础类 包装类(引用类型，包装类都位于java.lang包下)
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
具体用法
ArrayList<Integer> list = new ArrayList<>();
list.add(100); //这里就把100看做Integer类型
list.add(200);
int num = list.get(0); // 这里取出来的就把它当做int类型

自动装箱： 基本类型---> 包装类型
自动拆箱： 包装类型--> 基本类型

所有用双引号括起来的都是字符串
字符串内容永不可变，因为字符串不可变，所以可以共享使用
字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组

创建字符串的3+1种方式
三种构造方法
public String(), 创一个空白字符数组，不含任何内容
String str = new String();
public String(char[] array) 根据字符数组的内容来创建对应的字符串
char[] charArray = {'A','B','C'};
String str = new String(charArray); // 输出 ABC
public String(byte[] array) 根据字节数组的内容来创建对应的字符串
byte[] byteArray = {97,98,99};
String str = new String(byteArray); // 输出abc ，根据字符转换的二进制码来的
直接创建 String str = “Hellow”；

程序中直接写上双引号的字符串，都是存在字符串常量池中的，在堆内存有一块空间存放字符串常量池，所有用双引号括起来的相同的字符串在常量池都是同一个对象

equals 方法比较两个字符串时只有参数是一个字符串并且内容相同时才会返回true，也就是equals是内容比较

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享一份数据

一旦使用static修饰了成员方法，那么这个方法就变了静态方法

静态方法不能访问非静态成员变量，静态方法不能使用this

image.png

静态代码块
静态代码块的格式是
public class 类名 {
static {
// 静态代码块的内容
}
}
特点： 当第一次用到本类时，静态代码块执行唯一的一次
静态内容总是优于非静态，所以静态代码块比构造方法先执行。
用途： 用来一次性地对静态成员变量进行赋值

java.util.Arrays 是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组的常见操作

数学工具类java.util.Math

继承
在父子类的继承关系中，如果成员变量重名时：
直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找
间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找

局部变量直接写
本类的成员变量 this.成员变量名
父类的成员变量 super.成员变量名

public>protected>(default)>private default 不是关键字，而是什么都不写
重写时子类方法的访问权限必须大于等于父类的方法访问权限

继承关系中，父子类构造方法的访问特点：
1、子类构造方法当中有一个默认隐含的super()调用，所以一定是先调用的父类构造，后执行子类构造。
2、子类构造可以通过super关键字来调用父类重载构造
3、super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造
总结：子类必须调用父类构造方法，不写则赠送super(),写了则用写的指定的super调用，super只能有一个，还必须是第一个

java是单继承的

抽象类 使用abstract关键字修饰

public abstract class Animal {
    public abstract void eat();
    
    public void normalMethod(){
    
    }
}

不能创建抽象类对象
抽象类中可以有构造方法，是供子类创建对象时初始化父类成员使用的
一个抽象类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类既可
抽象类的子类，必须重写抽象父类中所有的抽象方法，否者编译器报错，除非该子类也是抽象类

抽象方法所在的类必须是抽象类才行，
抽象方法没有方法实现，使用abstract关键字修饰

public interface 接口名 {
// 接口内容...
// 接口中的默认方法，可以解决接口升级问题
// 格式
public default 返回值类型 方法名称(参数列表) {
// 方法体
}
}
接口中的内容可以包含：
1、常量
2、抽象方法
3、默认方法
4、静态方法
5、私有方法

注意事项：
1.接口当中的抽象方法，修饰符必须是两个固定的关键字， public abstract ，这两个关键字修饰符可以选择性的省略

使用步骤：
1.接口不能直接使用，必须有一个实现类来实现该接口。
格式：
public class 实现类名称 implement 接口名称{
// ...
}
2.接口的实现类必须覆盖重写(实现)接口中所有的抽象方法
实现去掉abstract 关键字，加上方法体大括号
3.创建实现类的对象，进行使用
注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

java8 开始 接口当中允许定义静态方法
格式：
public static 返回值类型 方法名称(参数列表){
// 方法体
}

java 9开始 接口中允许定义私有方法
1.普通私有方法，解决多个默认方法之间重复代码问题
格式：
private 返回值类型 方法名称(参数列表) {
// 方法体
}
2.静态私有方法，解决多个静态方法之间重复代码问题
格式：
private static 返回值类型 方法名称(参数列表) {
// 方法体
}

接口当中也可以定义“成员变量”，但是必须使用 public static final 三个关键字进行修饰
接口当中的常量可以省略 public static final ，不写默认也是这三个

intellij idea 中代码中的灰色的关键字是可以省略的

接口中的常量名称，完全使用大写字母，用_链接

注意事项：
1、接口是没有静态代码块，构造方法的
2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口，接口之间使用逗号隔开
3、如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
5、如果实现类所实现的多个接口当中，存在重复的默认方法，那么现实类一定要对冲突的默认方法进行覆盖重写
6、一个类如果直接父类当中的方法和接口当中的默认方法产生冲突，优先用父类当中的方法。

多态
成员变量： 编译看左边，运行也看左边
成员方法： 编译看左边，运行看右边

判断某个实例对象是否是某个类的对象
格式：对象 instanceof 类名称
例如：animal instanceof Cat

final的四种用法：
1、可以用来修饰一个类
用final修饰的类不能有任何子类
2、可以用来修饰一个方法
当final修饰一个方法时，该方法不能被重写
3、可以用来修饰一个局部变量
使用final修饰的变量只能赋值一次
4、可以用来修饰一个成员变量
final修饰的成员变量，要么直接赋值，要么通过构造方法赋值

注意事项：
对于类和方法 final不能和abstract 同时使用，同时使用会冲突

public protected default privat
同一个类 YES YES YES YES
同一个包 YES YES YES NO
不同包子类 YES YES NO NO
不同包非子类 YES NO NO NO

内部类

外部类名称.内部类名称 对象名 = new 外部类名称().内部类名称()

内部类和外部类成员变量同名时,内部类调用外部类成员变量 Out.this.name

如果一个类是定义在一个方法内部的,那么就是一个局部内部类,
如果希望局部内部类访问所在方法的局部变量,那么这个局部变量必须是有效的 final 的,可以不用 final修饰,但是一定要不能变

匿名内部类
如果接口的实现类(或者父类的子类)只需要使用唯一的一次
那么这种情况就可以省略掉该类的定义而改为使用匿名内部类
格式
接口名称 对象名 = new 接口名称{
// 覆盖重写所有抽象方法
}

接口也可以做为成员变量
接口也可以作为方法的参数和返回值

list 集合(Vector、ArrayList、LinkedList)特点
1.有序的集合
2.允许存在重复元素
3.有索引,可以使用普通的 for 循环
set (TreeSet、HashSet、LinkedHashSet)集合
1.不允许存储重复元素
2.没有索引(不能使用 for 循环遍历)

数组的特点:
查询快:数组的地址是连续的,我们通过数组的首地址可以找到数组,通过数组的索引可以快速查找某个元素
增删慢:数组的长度是固定的,想要增删一个元素,必须将删除或增加索引后的数据一次挪动,或者创建一个新数组,把源数组的数据复制过来

链表的特点:
查询慢:链表中的地址不是连续的,每次查询都需要从头开始查询
增删快:链表结构增删元素,对链表整体结构没有影响

单向链表:链表中只有一条链子,不能保证元素的顺序

双向链表:链表中有两条链子,有一条是专门记录元素的顺序,是一个有序集合

平衡树:左子树和右子树相等

重地 和 通话 的 hash 值是一样的,两个不同的元素的 hash 值相同,称为 hash 冲突

为什么 HashSet 中不能存放重复元素?
首先我们要知道 哈希表 是由 数组+链表/红黑树 组成的.
每当我们我们向hashset 中添加一个元素A时,底层会求得 元素 A的 hash 值 m,并在集合中查找是否已有 m 值,如果没有,则把 m 的值存到数组中,并将元素 A 挂m 值下;如果发现列表中已有 m值,则将要存入的元素 A 与以后值使用 equals 方法比较,如果相等则忽略,如果不相等通过链表的形式挂在 m 值下面

HashSet 存储自定义类型的元素时,必须重写 hashCode 和 equals 方法

LinkedHashSet 特点:
底层是一个哈希表(数组+ 链表/红黑树) +链表,多了一条链表(记录元素的顺序),保证元素有序;

可变参数注意事项:
1、一个方法的参数列表,只能有一个可变参数
2、如果方法的参数有多个,那么可变参数必须写在参数列表的末尾
3、可变参数列表数据类型是一致的
可变参数的原理是一个数组

java.util.Map<k,v>集合
Map 集合的特点:
1.Map 集合是一个双列集合,一个元素包含两个值(一个 key,一个 value)
2.Map 集合中的元素,key 和 value 的数据类型可以相同,也可以不同
3.Map 集合中的元素,key 是不允许重复的,value 值是可以重复的
4.map 集合中的元素,key 和 value 是一一对应的
java.util.HashMap<k,v>集合 implements Map<k,v> 接口
HashMap 集合的特点:
1.HashMap 集合底层是哈希表,查询速度特别的快
JDK1.8 之前:数组+单向链表
JDK1.8 之后:数组+单向链表/红黑树(链表的长度超过 8)提高查询速度
2.hashMap 集合是一个无序的集合,存储元素和取出元素的顺序有可能不一致
java.util.LinkedHashMap 特点:
1.LinkedHashMap集合底层是哈希表+;链表(保证迭代顺序)
2.LinkedHashMap集合是一个有序的集合,存储元素和取出元素是一致的

HashMap 中存储自定义类型,需要自定义类型重写 hashCode 和 equals 方法

java.util.hashtable<k,v>集合 implements Map<K,V> 接口
Hashtable:底层也是一个哈希表,是一个线程安全的集合,是单线程集合,速度慢
HashMap:底层是一个哈希表,是一个线程不安全的集合,是多线程的集合,速度快
HashMap 集合:可以存储 null 值,null 键
hashtable 集合,不能存储 null 值,null 键

finally 代码块: 无论出现什么异常,都会走 finally 代码块
不能单独使用,必须和 try 一起使用,一般用于资源释放

自定义异常类一般以 Exception 结尾,说明该类是一个异常类
自定义异常类必须继承 Exception 或者runtimeException,继承 Exception 就是一个编译期异常;继承 runtimeException 就是一个运行期异常类

线程调度:

子线程会开辟新的栈空间执行任务,所以线程之间互不影响

自定义线程,需要重写 run 方法, 线程对象通过调用 start 方法来调用 run 方法

另一种实现多线程的方式:
1.创建一个 Runnable 接口的实现类
2.在实现类中重写 Runnable 接口中的 run 方法,设置线程任务
3.创建一个 Runnable 接口的实现类对象
4.创建 Thread 类对象,构造方法中传递 Runnable 接口的实现类对象
5.调用 Thread 类中的 start 方法,开启新的线程执行 run 方法

RunnableImpl run = new RunnableImpl();
Thread t = new Thread(run);
t.start();

其好处是:
1.避免单线程的局限性
2.增强了程勋的扩展性,降低了程序的耦合性

解决线程安全的方式一:同步锁
1.在会产生线程安全的代码块外声明一个锁对象, Object obj = object();
2.将会产生代码安全的代码块放到 synchronized(obj){ } 代码块中

同步锁的技术原理:
同步锁也叫对象锁,也叫对象监视器
多个线程一期抢夺 cpu的执行权,谁抢到了谁执行任务
线程 0 抢到了 CPU 执行权,执行任务,遇到synchronized代码块,这时线程 0 会检查synchronized代码块是否有所对象,发现有,就会获取到锁对象,进入到同步中执行

线程 1 抢到了 cpu 的执行权,执行任务,遇到synchronized代码块时,就会检查synchronized是否有锁对象,发现没有,线程 1 就会进入到阻塞状态,会一直等待线程 0 归还锁对象,一直到 t0 线程执行完同步中的代码,会把锁对象归还给同步代码块,线程 1 才能获取到锁对象进入到同步中执行.

总结:同步中的线程,没有执行完毕不会释放锁,同步外的线程没有锁进不去同步

同步保证了只能有一个线程在同步中执行共享数据,保证了安全,程序频繁的判断锁,获取锁,释放锁,程序的效率就会降低

解决线程安全的方式二:同步方法
格式:
修饰符 synchronized 返回值 方法名() {
//同步任务
}
同步方法的锁对象就是 实现类对象 也就是 this

解决线程安全的方式二:静态方法
格式:
修饰符 static synchronized 返回值 方法名() {
//同步任务
}

Lock 锁
unlock 方法可以放到 try catch 中的 finally 中,这样不论程序是否异常,都会把锁释放

线程的六种状态:
当线程被创建并启动以后,它既不是已启动就进入了执行状态,也不是一直处于执行状态.在线程的生命周期中,有下面六种状态

线程状态 导致状态发生条件
NEW(新建) 线程刚被创建,但是并未启动,还没有调用 start 方法
Runnable(可运行) 线层可以在 java 虚拟机中运行的状态,可能正在运行自己代码,也可能没有,这取决与操作系统处理器
Blocked(锁阻塞) 当一个线程试图获取一个对象锁,而该对象锁被其他线程持有,则该线程进入 Blocked 状态,当该线程持有锁时,该线程将变成 Runnable 状态
Waiting(无限等待) 一个线程在等待另一个线程执行一个(唤醒)动作时,该线程进入 waiting 状态.进入这个状态后是不能自动唤醒的,必须等待另一个线程调用 notify 或者 notifyall方法才能唤醒
Timed Waiting(计时等待) 通 waiting 状态,有几个方法有超时参数,调用他们讲进入 Timed Waiting 状态.这一状态将一直保持到超时期满或者接收到唤醒通知.带有超时参数的常用方法有 Thread.sleep、Object.wait
Teminated(被终止) 因为 run 方法正常退出而死亡,或者因为没有捕获的异常终止了run方法而死亡
image.png

线程池
反复的创建销毁线程会消耗性能,这时可以把线程放到线程池中,当线程执行完任务时将其放入到线程池,这样线程不会被销毁,下次需要的时候直接从线程池中取出来使用

Lambda 表达式

File 类: java.io.file
路径分隔符:
windows 上是反斜杠
Linux 上是正斜杠/
路径不区分大小写
反斜杠是转义字符,两个反斜杠代表一个普通的反斜杠

Java 支持中文类名

1 个中文字符CBK 编码下占用两个字节,UTF-8 编码下占用 3 个字节

目前主要的软件结构主要有:

网络通信协议:协议中对数据的传输格式、传输速率、传输步骤等做了统一规定,通信双方必须同时遵守,最终才能完成数据交换.

TCP/IP 协议:传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是 Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它 的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的 协议来完成自己的需求。'


分层模型.png

TCP: 传输控制协议 (Transmission Control Protocol)。TCP协议是面向连接的通信协议，即传输数据之前， 在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。
第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
第三次握手，客户端再次向服务器端发送确认信息，确认连接。
完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可 以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

UDP: 用户数据报协议(User Datagram Protocol)。UDP协议是一个面向无连接的协议。传输数据时，不需 要建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个 数据包的大小限制在64k以内。它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。日常应 用中,例如视频会议、QQ聊天等。

网路编程三要素:
1、协议
2、IP地址
3、端口号

IP地址: 指互联网协议地址（Internet Protocol Address），俗称IP。IP地址用来给一个网络中的计算机设 备做唯一的编号。假如我们把“个人电脑”比作“一台电话”的话，那么“IP地址”就相当于“电话号码”。IP 地址分为 IPv4 和 IPV6 两种

IPv4：是一个32位的二进制数，通常被分为4个字节，表示成 a.b.c.d 的形式，例如 192.168.65.100 。其 中a、b、c、d都是0~255之间的十进制整数，那么最多可以表示42亿个

IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。 有资料显示，全球IPv4地址在2011年2月分配完毕。 为了扩大地址空间，拟通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进 制数，表示成 ABCD:EF01:2345:6789:ABCD:EF01:2345:6789 ，号称可以为全世界的每一粒沙子编上一个网 址，这样就解决了网络地址资源数量不够的问题。

查看本机 IP 地址: ifconfig
检查网络是否连通: ping 域名或 IP 地址
本机 IP 地址: 127.0.0.1、localhost

端口号:
网络通信的本质是两个进程(应用程序)的通信,每台计算机都有很多的进程,那么在网络通信时,如果区分这些进程呢?
如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。
端口号：用两个字节表示的整数，它的取值范围是065535。其中，01023之间的端口号用于一些知名的网 络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会 导致当前程序启动失败。
利用 协议 + IP地址 + 端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其 它进程进行交互。

函数式接口:有且只有一个抽象方法的接口称之为函数式接口,当然接口中可以包含其他方法(默认、静态、私有)
可以使用@FunctionInteface 注解

stream 流只能使用一次,使用后就关闭了

方法引用

反射: 框架设计的灵魂
框架:半成品软件,可以在框架的基础上进行软件开发,简化编码
反射:将类的各个组成部分封装为其他对象,这就是反射机制
反射的好处:
1、可以在程序运行过程中,操作这些对象
2、可以解耦来提高程序的可扩展性

获取 class 对象的三种方式:
1、通过 Class.forName("全类名"); // 全类名就是包含包的类名,比如 com.baidu.home.Person
2、类名.class 比如:Person.class
3、通过对象的 getClass() 方法

Class 对象的功能:
1.获取所有成员变量:
Field[] getField(); 获取所有 public 修饰的成员变量
Field[] getField(String name); 获取指定名称的 public 修饰的成员变量
Field[] getDeclaredFields() 获取所有的成员变量,不考虑修饰符
Field getDeclaredField(String name) 或者指定的成员变量
2.获取所有构造方法
3.获取所有构造方法
4.获取类名

setAccessible(true);忽略访问权限修饰符的安全检查,包里反射

注解:说明程序的,给计算机看的,它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元数据进行说明,注释.
格式:@注解名称

JDK 中预定义的一些注解
1.@Override: 检测被该注解标注的方法是否是继承自父类(接口)的
2.@Deprecated: 该注解标注的内容,表示已过时
3.@SuppressWarnings: 压制警告,一般传递参数"all"

自定义注解:
格式:
元注解
public @interface 注解名称{}

注解本质上就是一个接口,该接口默认继承 Annotation 接口
public interface *** extends java.lang.annotation.Annotation{}

MySQL

JDBC: Java DataBase Connectivity ,

上一篇下一篇

猜你喜欢

热点阅读