Java学习笔记

CoreJava 胡鑫喆 186******** huxz@https://www.wendangku.net/doc/5c7882969.html,

==========================================================================
1.每个类都默认导入 import https://www.wendangku.net/doc/5c7882969.html,ng.*;
2.如果一个类没有定义构造方法,则默认提供公开无参构造方法
3.在类中,访问成员变量或成员方法,如果不加引用,默认加上"this."
4.在构造方法中,如果第一行不是"this(...)"或"super(...)" ,默认为"super();"
5.在接口中,属性默认为public static final
方法默认为public abstract
6.如果一个类没有指定父类,默认继承https://www.wendangku.net/doc/5c7882969.html,ng.Object
7. JDK5.0 由编译器自动完成基本类型和包装类的转换

==========================================================================
Java 特点
1.简单 和C++
2.面向对象
3.跨平台 先编译后解释 + JVM(屏蔽底层操作系统的差异)

程序的运行:
1.编译 源文件 ------> 编译器 机器码文件 快 无法跨平台
2.解释 源文件 ------> 解释器 逐行翻译并运行 慢 可以跨平台

Java运行机制: 先编译,后解释
.java 源文件 -------> 编译器 .class 字节码文件 -------> 解释器 解释运行

javac 源文件的文件名(包括扩展名 .java) 每个类对应的生成一个.class文件
java 要运行的类名

安装JDK (编译器 虚拟机 解释器 工具 文档 类库)
配置环境变量
Java_Home = JDK安装目录
Path = JDK安装目录/bin
ClassPath = . 提示编译器或JVM,到哪里找所需要的类

公开类类名必须和文件名相同,包括大小写
1个源文件中只能定义1个公开类

包: 和文件夹对应

Java程序的基本结构:
1) package 0-1
2) import 0-n
3) class 1-n 公开类最多只能有一个

=======================================================================
编程习惯
1.注释
描述代码的文字 说明 不参与编译(给人看) 提高程序的可读性 文档习惯

// 单行注释
/*
多行注释 /* */ 不允许嵌套
*/
/**
多行注释 配合JavaDoc工具使用 用来生成API文档
*/

2.缩进
换行和空格 表达程序的结构 可读性
每行一句代码
每进入一个代码块 {} , 缩进一次
同级代码列对齐

3.标识符命名
语法: 字母 数字 _ $ 组成,数字不能开头
大小写敏感
不能使用关键字和保留字(goto const)

习惯: 望文知义
大小写
类名 单词首字母大写 HelloWorld
变量/方法 首单词小写,后面单词首字母大写 helloWorld
包名 全小写 helloworld
常量名 全大写 HELLOWORLD

===========================================================================

变量 存储空间 存储数据
强类型: 变量的类型和变量中数据类型必须一致

定义变量:

变量类型 变量名; int a;
为变量赋值: 变量名=变量值 a = 10;
int a = 10;
int a , b;
int a = 10 , b =20;
int a = 10 , b;

局部变量 : 定义在方法内部的变量
1.先赋值,再使用
2.作用范围:从定义开始,到其所在的代码块结束
3.重合范围内,不允许2个局部变量同名

数据类型
1.简单类型 原始类型 基本类型
byte 1B -128 -- 127
short 2B -32768 -- 32767
int 4B -2147483648 -- 2147483647
12 012(8进制) 0x12(16进制) 0b1011011(2进制 7.0)
long 8B -2的63次方 -- 2的63次方-1 字面值加L
float 4B 字面值加F
double 8B 字面值加D或者不加 1.5e150
boolean 1b 字面值 true false
char 2B 字面值 'A' 65 '\u0041' 和int相通
Unicode 全球统一的编码方法
转义字符:'\n' '\t' '\r' '\\' '\'' '\"'
2.对象类型
String 字面值 "Hello"

低字节数据可以直接赋值给高字节类型变量
高字节数据需要通过强制类型转换赋值给低字节变量
整数可以直接赋值给浮点型变量
浮点型数据需要通过强制类型转换赋值给整型变量

表达式:变量 常量 字面值 用运算符连接而形成的式子
具有固定的值!

Java中运算时类型自动提升规则 a?b
1)如果a或b有double ===> double
2)如果a或b有float ===> float
3)如果a或b有long ===> long
4) ===> int

= 赋值 (a = 2):2
+ - * / %
+= -= *= /= %= a+=2 a=a+2
++ -- a++ a+=1
布尔表达式 true,false
== != a==b a!=b
> < >= <= a>b
&& 逻辑与 || 逻辑或

(布尔表达式)? 值1 : 值2 a = (c>d)?3:2;

位运算
& | ^ ~
11001
10101
& 10001
| 11101
^ 01100
~11001 = 00110

>> 右移 0110 >> 1 = 011 有符号右移 高位补符号位
>>> 右移 无符号右移 高位补0
<< 左移 110 << 1 = 1100

=============================================================================
流程控制
顺序执行流程
条件分支流程

if(布尔表达式) {}
if(布尔表达式) {} else{}

if(表达式1){}
else if(表达式2){}
else if
...
else{}

switch(int型表达式或变量) // byte short int char
{
case 值1:
case 值2:
case 值3:
...
default:
}
break:跳出switch结构

从JDK7.0开始,switch表达式允许采用String


循环流程

while(布尔表达式){循环体} 0-n
do{循环体} while(布尔表达式); 1-n

for(定义循环变量并初始化 ; 循环条件 ; 循环变量变化){循环体}

break : 跳出循环
continue : 跳出本次循环

===========================================================================
函数
程序中独立的过程

函数的语法:
函数的定义
声明 static 返回值类型 函数名

(参数表) 形式参数:形参 在函数内部有效的局部变量
实现 { 语句 }

函数的调用
函数名(参数); 实际参数:实参 为形参赋值
接收返回值

函数的作用:
1. 减少冗余代码,提高程序的可维护性
2. 可重用性 函数库
3. 加强代码的结构化 提高可读性 利于分工

非结构化编程(语句) ---> 结构化编程(函数) ---> 面向对象(类)

数组
一次性定义多个同类型的变量 数组空间在内存是连续的
定义:int[] a;
为数组分配空间 指定长度 a = new int[4];
数组名.length : 表示数组长度

数组元素有默认值
数值类型: 0
boolean:false
对象: null

a = new int[]{1,4,3,2} 显式初始化
a = new int[5]{1,2,3,4,5} 错误

数组变量中存储的是数组的首地址
根据首地址,计算出某个元素的地址 ===> 数组必须是连续的空间,下标从0开始

数组的长度是固定的

二维数组
定义 int[][] a ;
分配空间 a = new int[4][3]; a.length = 4 a[0].length=3
a[0] a00 a01 a02
a[1] a10 a11 a12
a[2] a20 a21 a22
a[3] a30 a31 a32
显式初始化 int[][] a = {{1,2,3,4},{5,6,7,8},{0,0,0,0}}; new int[3][4]

一维数组的一维数组

int[][] a = new int[4][];
a[0] = new int[4];
a[1] = new int[5];
a[2] = new int[3];
a[3] = new int[6];

int[][] a = new int[][5]; // error!

===========================================================================
面向对象 编程思想 从需求出发 从现实世界出发

对象:一切客观存在的事物 什么都是对象

是什么 is a 继承
属性:有什么 has a 关联(聚合)
方法:能做什么 use a 依赖

面向对象思想:先找到解决问题所需的对象,再通过对象间的联系(3种关系)完成需求

计算机中的对象: 数据(连续的存储空间) 代表了生活中的对象
模拟了现实世界中的对象关系


面向对象的优势:
1.各司其职 封装
2.弱耦合性 多态 接口
3.可重用性 封装
4.可扩展性 继承

类:
对象共性的抽象,是人对对象的认识
对象的模板

属性:实例变量 成员变量
1.有默认值 默认值规则等同于数组默认值规则
2.作用范围: 至少是全类内部
3.可以和局部变量发生命名冲突,冲突时局部变量优先

方法:
方法声明: 对象能做什么
修饰符 返回值类型 方法名 (参数表) 抛出的异常
public static void main(String[] args)

方法实现: 对象怎么做

方法的重载(Overload): 方法名相同,参数表不同
参数个数不同,参数类型不同,参数类型排列不同,如果只有形参名不同,不算重载!
由编译器根据实参,去匹配相应形参的方法来调用 (编译时多态)
重载作用:对象同类方法,由于参数表的不同,所造成的差异,对用户屏蔽

构造方法:
1.没有返回值

类型
2.方法名必须和类名相同,包括大小写
3.不允许手工调用,在对象构造过程中,自动调用一次
常常用来为属性赋值

如果一个类没有定义构造方法,则默认提供公开无参构造方法

创建对象: new 类名(构造参数);

简单变量:8种基本类型之一 存值
对象变量:其他类型 引用 存对象的地址

this:
1.this. 引用 当前对象 用来区分局部变量和成员变量
在类中,访问成员变量或成员方法,如果不加引用,默认加上"this."
2.this() 用在构造方法中,调用本类其他构造方法
必须是构造方法的第一条语句

null: 空指针 引用没有指向任何对象

=========================================================================
三大特性
封装
对象要有明确的边界 数据隐藏,保护

访问修饰符
private 私有 只能在对象内部访问 隐藏在对象边界之内
public 公开 任何地方都可以访问 暴露在对象边界之外

属性私有,方法也可以私有
为属性提供对应的get/set 访问方法

继承
一般 - 特殊
父类 子类
子类 is a 父类

共性放在父类,个性放在子类

class 子类 extends 父类

父类哪些属性和方法能继承给子类?
访问修饰符:
private 私有 本类访问 不能继承
(default) 默认 本类+同包 同包子类能继承
protected 受保护 本类+同包+子类 能继承
public 公开 能继承
构造方法不能继承给子类!

方法覆盖(Override)
子类用特殊的方法实现替换父类继承给它的一般的方法实现
语法:方法名、参数表、返回值类型相同；访问修饰符相同或更宽

单继承
一个类只能有一个直接父类 class B extends A
类之间会形成简单的树状结构

super
1. super. : 引用 父类对象
访问父类被遮盖的属性
调用父类被覆盖的方法
2. super(): 用在构造方法中的第一条语句 调用父类构造方法
在构造方法中,如果第一行不是"this(...)"或"super(...)" ,默认为"super();"

对象构造过程:
1) 分配空间 属性被赋以默认值
2) 构造父类对象 (重复2-4)
3) 初始化本类非静态属性 属性被赋以初始值
4) 调用本类构造方法 属性常常被赋以构造参数

多态
子类对象可以赋值给父类引用

1) 对象类型不变
2) 只能对引用,调用其引用类型中声明的方法
3) 运行时,根据对象实际类型,调用子类覆盖之后的方法

子类引用可以直接赋值给父类引用
父类引用必须通过强制类型转换,才能赋值给子类引用,可以通过inst

anceof判断类型是否兼容,从而避免类型转换异常!
不相干的两个类的引用之间,无法赋值!

引用 instanceof 类名 布尔表达式 判断引用中的对象和类名是否兼容
是不是

Animal a = new Dog();
a instanceof Dog true
a instanceof Cat false
a instanceof Animal true

多态的作用: 通用
将不同的子类对象,统一看作父类对象,从而屏蔽不同子类之间的差异

多态的常见用法:
多态用在方法的参数上: 形参为父类引用,实参可以为子类对象
m(A a):该方法可以用A类或A类任何子类对象作为实参
多态用在方法的返回值上:返回值类型为父类,实际返回值可以为子类对象
A m(): 该方法可以返回A类或A类任何子类对象

============================================================================
三个修饰符
public 属性 方法 构造方法 类
protected 属性 方法 构造方法
default 属性 方法 构造方法 类
private 属性 方法 构造方法

static 静态的
1) 属性 类变量 不属于任何对象,全类共有,可以直接用类名访问
类变量在类加载的时候分配空间并初始化,而不是对象创建时
2) 方法 静态方法可以直接用类名调用

静态方法中只能访问类的静态成员(属性+方法) (不能访问this)
非静态方法中可以访问类的静态成员

静态方法之间可以覆盖,但是 没有多态!
对引用调用静态方法,等价于对引用类型调用静态方法

3) 初始代码块 静态初始代码块
类加载的时候执行一次
类加载:当JVM第一次使用一个类时,需要通过ClassPath找到这个类对应的.class文件,并把文件中的类的信息读取到JVM,并保存起来.
类加载的过程:
1.如果需要,先加载父类
2.按照类的定义顺序,初始化静态属性,或执行静态初始代码块

一般情况下,一个类只会加载一次

final
1)变量 常量 一旦赋值,不能改变
常量属性,系统不再提供默认值.由程序员在初始化属性或构造方法中主动赋值

2)方法 不能被覆盖
3)类 不能被继承


abstract 抽象的
1)类 抽象类只能声明引用,不能创建对象
半成品 供子类继承
2)方法 抽象方法只有声明,没有实现

如果一个类中有抽象方法,这个类必须是抽象类;抽象类中未必有抽象方法
子类继承抽象类,如果子类不希望也成为抽象类,就必须实现父类中所有的抽象方法

static private final 不能和abstract联用

========================================================================
接口
特殊的抽象类
1.所有的属性都是公开静态常量 (public static final)
2

.所有的方法都是公开抽象方法
3.没有构造方法

一个类实现接口,如果这个类不希望成为抽象类,就必须实现接口中所有的方法

接口之间可以多继承
一个类在继承一个父类的同时,还可以实现多个接口

接口的作用:
1.多继承
用接口实现多继承,不会破坏类之间树状关系的简单性
接口:次要类型
2.解耦合工具 标准
把标准的使用者和标准的实现者分离
A ---> I ---- B

=========================================================================
内部类 定义在外部类的内部, 编译后是独立存在的类
可以访问外部类的私有成员,且不破坏封装

成员内部类
用"外部类类名.this"访问外部类的当前对象
创建对象:先创建外部类对象,再通过"外部类对象.new 内部类类名"创建内部类对象
静态内部类
只能访问外部类的静态成员
创建对象:直接用"new 外部类类名.内部类类名()"
局部内部类
定义在外部类的方法内部
作用范围:从定义开始到所在的代码块结束 同局部变量
不仅可以访问外部类的成员,还可以访问外部类的局部常量 (加final)
匿名内部类
特殊的局部内部类
1.继承某个类 或者 实现某个接口
2.只会创建一个对象

不仅可以访问外部类的成员,还可以访问外部类的局部常量 (加final)
无法定义构造方法

堆空间 heap :存对象
栈空间 stack :存局部变量

==========================================================================
Object https://www.wendangku.net/doc/5c7882969.html,ng.Object 所有Java类的父类 类继承关系的根

1) Object o; 引用o中可以储存任何对象
2) Object类中的方法是所有Java对象都具有的方法

getClass() : 返回对象的实际类型
判断a和b两个引用是否存储同类对象 a.getClass()==b.getClass()
finalize(): 当垃圾收集器回收垃圾对象时,自动调用
垃圾对象:零引用
垃圾收集时机:内存耗尽
toString(): 返回对象的字符串形式 public String toString()
打印一个对象,就是打印该对象toString()方法的返回值
equals(): 判断2个对象的内容是否相同
public boolean equals(Object o) 判断this和o内容是否相同

== 用于2个引用,判断这2个引用是否指向同一个对象

=========================================================================
包装类 为8种基本类型各自提供对象形式
int ---- Integer
char ---- Character
short ---- Short
double ---- Double
...

自动封箱: JDK5.0 由编译器自动完成基本类型和包装类的转换
Integer i = 12;
Integer i = new Integer(12);

int m = i;
int m = i.intValue();

Integer i = 12;
i++; // i = new Integer(i.

intValue()+1);

日期
获得系统时间
System.currentTimeMillis() 毫秒
System.nanoTime() 纳秒

日期格式化 java.util.Calendar
String
构造方法: new String(char[] cs)
toCharArray() 转成char[]
charAt(int i):返回下标为i的字符
length():长度
toLowerCase()/toUpperCase() 转小写/大写
contains(String str):判断String中是否包含某个子串
indexOf(String str):返回str子串的下标 没有则返回-1
indexOf(String str,start):返回str子串从start下标开始的下标位置
startsWith(String str)/endsWith(String str):判断是否以str子串开头/结尾
replace(String s1, String s2) 将s1子串替换为s2子串
substring(int start,int end)获得字符串中start下标到end下标的子串,结果包含起始下标,不包含结束下标
trim():去掉字符串前后的空格和换行
split(String str)把字符串以str作为分隔符,拆分为String[]


String 类是final的 不能被继承
字符串的值是不可变的
串池 对象共享

intern():返回该字符串在串池中的地址


字符串接口: CharSequence
实现类: String StringBuilder (StringBuffer)
5.0 1.0
不变 可变
当大量字符串连接时,应该用 String --> StringBuilder --> String 做法
========================================================================
集合框架
集合:容器 储存对象的对象 Object[]

接口特点
接口中的常用方法
遍历
实现类

Collection 接口 特点: 元素是Object
常用方法:
add(Object o):将o添加到集合中
addAll(Collection c):将集合c中所有的元素添加到集合中
clear() 清空集合
contains(Object o)判断集合中是否存在元素o
remove(Object o):在集合中删除元素o
size():返回集合的长度 元素的个数
toArray():将集合转成数组
遍历: 迭代

实现类:无

List 接口 特点:Collection的子接口 有顺序(有下标) 可以重复
常用方法:
add(int pos,Object o):把对象o添加到集合pos下标位置
get(int pos):返回pos下标的元素
indexOf(Object o):返回o在集合中的下标,如果不存在则返回-1
remove(int pos):删除pos位置的元素
set(int pos , Object o):将o设置在pos下标位置
遍历:
1) 下标遍历
2) 迭代遍历 for-each
实现类:
ArrayList 数组实现 查询快 增删慢 1.2 线程不安全 快
LinkedList 链表实现 查询慢 增删快
Vector 数组实现 1.0 线程安全 慢

Collections 工具类
reverse(List) 将list中的元素反转
shuffle(List) 将list中的元素随机排列
sort(List) 将list中的元素排序
为对象指定排序规则:对象必须实现 Comparable接口

Set接口 特点:Collection的子接口 无顺序(没有下

标) 元素内容不可重复 唯一
常用方法:无
遍历: 迭代 for-each
实现类:
HashSet 常用 元素存储顺序不一定等于元素添加的顺序
LinkedHashSet HashSet的子类 元素存储顺序等同于元素添加的顺序
TreeSet 实现了SortedSet(Set的子接口) 对元素自动排序
Properties Hashtable的子类,key和value都是String 1.0

自定义的类的对象放入HashSet,为了保证元素内容不重复,就必须:
1.覆盖hashCode方法,保证内容相同的对象返回相同的整数
尽量保证内容不同的对象返回不同的整数
2.覆盖equals方法,保证内容相同的对象返回true

Map 接口 键值对 键key:对象 无顺序 唯一 值value:对象 可以重复
常用方法:
clear():清空集合
containsKey / containsValue 判断 键/值 是否存在
get(Object key):返回key所对应的value
put(Object key,Object value):添加键值对 如果key已经存在,新的value覆盖旧的value
remove(Object key):删除key所对应的键值对
size():返回键值对的数量
遍历:
键遍历: keySet():返回Map中所有key的集合 Set
值遍历: values():返回Map中所有value的集合 Collection
实现类:
HashMap 1.2 线程不安全 快 允许用null作为key或value
Hashtable 1.0 线程安全 慢 不允许用null作为key或value
TreeMap 实现了SortedMap(Map的子接口) 对key自动排序
LinkedHashMap HashMap的子类 元素存储顺序等同于元素添加的顺序


泛型 模板编程
用在集合框架中,可以实现类型安全的集合
指定集合中元素的类型


===========================================================================
异常处理 运行时

try{
插卡
输入密码和金额 2000
余额 -= 2000
吐钱 2000
}
catch(吐钱异常 e){
余额 += 2000
}
finally{
取卡
}

异常的分类: Throwable

Error:错误 严重底层 无法避免 无法处理
Exception：异常 可以处理
RuntimeException及子类：未检查异常 可以避免 可处理可不处理
非RuntimeException子类：已检查异常 无法避免 必须处理

异常对象的产生和传递
throw 异常对象； 抛出一个异常，throw作用等同于return

传递：沿着方法调用链反向传递

异常的处理
throws 声明抛出 throws 已检查异常类名
本方法内部如果出现该类型的异常，本方法不做处理
try-catch 捕获异常 适用于所有异常（未检查+已检查）
可以同时catch子类异常和父类异常，但必须先catch子类异常
try-catch-finally finally:无论如何都会执行 通常用于释放资源
try-finally 没有真正捕获异常！

自定义异常
自己写类 继承Exception或RuntimeException

方法覆盖(Overr

ide)
子类用特殊的方法实现替换父类继承给它的一般的方法实现
语法:方法名、参数表、返回值类型相同；访问修饰符相同或更宽
子类不能抛出比父类更多的异常
子类不能抛出一个父类没有抛出的异常
异常范围只能与父类相同或更少

===========================================================================
I/O 输入(读数据) / 输出(写数据)
流的三种分类

流的方向 输入/输出
数据单位 字节/字符 字符流用来处理文本数据 字节流用来处理一切数据
流的功能 节点/过滤 节点流:传输数据 过滤流:用来为节点流增强功能

创建节点流
封装过滤流
读/写数据
关闭流

字节流
InputStream/OutputStream 字节流的父类 抽象类
FileInputStream/FileOutputStream 文件字节流 节点流
write(int a):将a的最低字节写入文件
write(byte[] bs):将bs数组写入文件
write(byte[] bs , int start,int length):将bs数组的一段写入文件

read():读入一个字节 返回值:读到的数据 返回-1表示结束
read(byte[] bs):读满bs数组 返回值:读到的数据个数 -1结束
read(byte[] bs,int start,int len):读满bs数组的一段

DataInputStream/DataOutputStream 过滤流 读写8种基本类型和String
BufferedInputStream/BufferedOutputStream 缓冲流 flush() 清空缓冲区
PrintStream 带缓冲的输出流 替代BufferedOutputStream

对象序列化: 用I/O流传输对象
ObjectInputStream/ObjectOutputStream 缓冲 读写8种基本类型,String 读写对象
只有实现了Serializable接口的对象,才能序列化
transient 修饰符 修饰属性 临时属性,不参与序列化

字符的编解码
当编码方式和解码方式不统一时,可能发生乱码问题

ASCII 1char ---- 1B
ISO-8859-1 1char ---- 1B 西欧
GB2312/GBK 1char ---- 2B 简体中文
Big5 繁体中文
Unicode 1char ---- 2B 全球统一 char UTF-16
UTF-8 变长 全球统一

字符流
Reader/Writer 字符流的父类 抽象类
FileReader/FileWriter 文件字符流 节点流
InputStreamReader/OutputStreamWriter 桥转换 字节流 --> 字符流
在桥转换时,可以指定编解码方式
BufferedReader/BufferedWriter(PrintWriter) 缓冲

File类 File对象代表了磁盘上的一个文件或者目录
createNewFile():创建新文件
mkdir():创建新目录
delete():删除文件或空目录
exists():判断文件是否存在
getAbsolutePath():获得绝对路径
length():文件长度
isDirectory():判断File对象代表的是不是目录
isFile():判断File对象代表的是不是文件
listFiles():返回目录中的内容 File[]

============================================================================
多线程

进程:OS中并发的一个任务
并发原理:CPU

分时间片交替运行,宏观并行,微观串行 OS负责调度

线程:在一个进程中,并发的一个顺序执行流程

线程的三要素:
1.CPU OS负责调度
2.Data 堆空间共享,栈空间独立
3.Code 程序员

实现线程的2种方式:
1)继承Thread类,覆盖run方法. 直接创建Thread对象
2)实现Runnable接口,实现run方法.先创建Runnable对象,再创建Thread对象

线程的同步
多线程访问同一个对象(临界资源),如果破坏了不可分割的操作(原子操作),则会造成数据不一致的情况.

每个对象都有一个互斥锁标记,用来分配给线程
synchronized 关键字 同步

synchronized(o){} 对o加锁的同步代码块
只有拿到o的锁标记的线程,才能进入对o加锁的同步代码块.
当线程离开对o加锁的同步代码块时,会释放o的锁标记

修饰方法 同步方法 对this加锁的同步代码块
只有拿到o的锁标记的线程,才能调用o的同步方法

Object类:
wait() 等待 线程进入对象的等待队列 (失去CPU 失去锁标记)
notify()/notifyAll() (从对象的等待队列中释放一个/全部线程)
以上2个方法,都要在同步代码块中调用

wait() 来自Object类 失去CPU和锁标记
sleep() 来自Thread类 失去CPU

========================================================================
网络编程
网络:若干主机组成
IP:主机在网络的逻辑地址
Port:每个端口绑定了一个进程 连接端口就是连接在该端口上监听的进程
协议:通信双方制定约定和标准

OSI七层模型 TCP/IP四层模型
应用
表示 应用 (http ftp smtp pop3 bt thunder)
会话
传输 传输 (TCP UDP)
网络 网络 (ip)
数据链路 网络接口
物理

TCP 传输控制协议 面向连接 可靠安全
UDP 用户数据报协议 无连接 不可靠不安全

=========================================================================
反射

类对象:在JVM加载一个类之后,产生的对象.用来存储类的信息

如何获取类对象:
1) 通过类的对象获得类对象 类的对象.getClass()
2) 类名.class 直接获得某个类的类对象
3) Class.forName("类的全名")

Class类: newInstance() 通过类对象获得类的对象
Method类:invoke(Object o):对o调用该方法

=========================================================================
设计模式

单例模式 只能有一个对象