黑马程序员_java基础总结

------- android培训、java培训、期待与您交流！ ----------

 

1.计算机基础知识

省略...

2.Java的基本介绍

1.Java是一门计算机编程语言

高级语言. ->写程序

2.Java 是一个运行环境.

Java程序,JRE  

3.Java平台...

SE

EE

ME

3.搭建Java 的运行和开发环境.

1.运行环境

JRE   ->只运行不需要开发Java程序... 

2.开发环境

JDK  ->继承了   编辑 编译(javac)  运行(java)

bin 目录 

提供了众多的 Java 的开发工具.

jre 目录

运行环境->JDK 自带

demo 

案例

src.zip

源代码

4.path

操作系统中用于保存可执行文件路径的一个环境变量 

1.安装JDK 可以配置path 环境变量  

不配: 必须进入JDK 的bin 目录才可以使用JDK 的开发工具

配置后: 可以再任意路径下使用JDK 的开发工具.  javac.exe java.exe javadoc.exe  javap.exe 

2.配置:

命令在dos控制台 中配置 (临时) 

在我的电脑->配置  (永久)

5.classpath

方便的运行Java程序 (.class)

在任意路径下执行Java 程序, 可以配置该变量.

一般:

运行Java程序时, 进入了Java 程序所在的目录,直接运行. JDK5.0以后不配置,默认就是当前路径.

6.开发Java程序

第一步:

编写源代码

.java 文件

第二步:

编译

.class 字节码文件

第三步:

运行

JVM 加载程序,运行.

7.常见的错误异常

1.语法错误

多了; 少了} ) ]

写错了->编译报错  

2.逻辑错误

int i=3,j=5;

while(i<j);{

 

}

注意: 编译不会报错,但是运行时不会出现想要的结果...

*********************************************

Java基础语法:

1.关键字

Java 赋予了特殊含义的单词... 

public class static void  if else while do for  break continue switch case return 

final  new this  private super  extends  abstract interface  implements 

throw throws try  catch  finally  synchronized  instanceof   ...     

2.标识符

类名,方法名,变量名,数组名...

程序中,自定义的名称.

规则(必须)

单词字符  a-z A-Z _ $  0~9          不能以数字开头,不能使用关键字, 不能有空格...

规范(建议)

变量名:  xxx  xxxYyy 

方法名: 同上

类名:   Xxx XxxYyy

常量名:  XXX   XXX_YYY

包名:全小写.

3.注释

// 单行

/**/ 多行

/***/文本.

4.数据类型

4.1计算机基本的数值单位

计算机存储数据时存储二进制的 0101,每一个二进制位叫做bit(比特)

1byte=8bit

1kb=1024byte

... 

程序=数据+指令+文档.

4.2Java基本数据类型

1)数值

整数  

byte(8位) short(16位,2字节) int(32位 4字节) long(64位,8字节) 

浮点数

float(32位  4个字节)  double(64 8个字节)

2)字符

''  char 2个字节, 可以表示中文字符   Unicode 

3)布尔

boolean  true false  1个字节   1个字节1为  

4.3非基本数据类型

1)数组

[]

2)对象

 

3)接口

5.常量

程序中直接出现的固定不变的值.

整形常量

默认是int 类型.

十进制  八进制  十六进制    

长整形常量

后缀是L(l)

syso(100); //32

syso(100L); //64

浮点数常量

默认是double 类型.

解决内存: 浮点数常量使用float 表示

syso(3.14f(F));

默认的double 双精度浮点数使用更为广泛.

字符常量

计算机无法直接存储字符,计算机只能存储数字(只能表示数字),计算机科学家 字符进行了数字化的转换 (将每一个字符都进行了数字化的编码)

每一个字符都有一个编号   a->97 

码表: ASCII   ISO-8859-1  GBK  Java使用  Unicode(内码)    推荐使用UTF-8  

程序中  单引号 部分''

'10' //无效字符 

'1' '0' 'a'  '中'  有效的

转义字符:

'\t' 

\\ 

\'

\"

\b 退格 

\r  回到一行的开头

\n  新起一行

布尔常量

true false

null 常量

内存没有开辟空间.

String str=null; 

字符串常量

程序中 ""  

syso(100);

6.变量

有名字,可以重复的使用,程序中一块有名字的内存  

1.声明变量

数据类型  变量名;

2.初始化变量

变量名=常量|表达式; 

3.使用变量

取值和赋值

通过变量名,可以去除变量中存储的数据,或者通过变量名让变量存储新的数据.

4. 注意:

一次只能存储一个数据.

局部变量使用前

方法中(方法体),方法上(形参) 语句中...  栈内存

一定要先初始化.

成员变量

类中  堆内存.

默认的值

5.变量的有效的取值范围

byte b=300; // 编译报错.

7.运算符

算数 赋值 比较  逻辑  位 移位

8.流程控制语句

1. 判断

if 

if else

if else if 

2. 选择

switch(byte|short|int|char|枚举(JDK5.0)|字符串(JDK7.0)){

case 常量值1:

语句

break;

case 常量值2:

语句

break;

default:

 

}

3.循环

while(true|false){

循环体; // 满足条件

}

 

do{

语句

}while(true|false);

do while 无论条件是否满足,至少执行一次

while 必须满足条件才会执行.

for(初始化表达式;true|false;循环后语句){

循环体;

}

while 和for 的区别

for 节约内存... 

int i=1;

while(i<3){

i++;

}

syso(i);

for(int j=0;j<3;j++){

 

}

syso(j);

4.其他流程控制语句

break

循环中 结束循环,嵌套:结束当前循环.  

switch 中.

continue

循环中. 跳出本次,继续下一次.

9.函数

一段独立功能的小程序, 可以重复使用(重点)

1. 语法

修饰符  返回值类型  函数名(数据类型  形参1,数据类型  形参2){

方法体;

return 返回值;

}

2.函数需要调用才会执行的.

函数在栈内存执行. 

如果一个程序中有多个函数需要运行.   函数存在着调用关系 -> 压栈和弹栈 .

main 函数入口,最先进入栈最后才出栈.

3.注意:

函数和和函数是平级的, 不能嵌套,只能调用.

void: 当函数没有具体的运算结果, 返回值类型需要一个特殊的标识,就是void .

4.可变长参数

...   函数使用了数组来接收, 

public static void test(int... arr){}

可以接收任意对个相同数据类型的参数, 可以没有,可以一个,可以多个,可以直接传递一个数组.... 

5.重载

overload 

同一个类中, 函数名相同,参数列表不同,和返回值无关.

方便编写和调用函数.

10.数组

容器,可以存储多个相同数据类型的数据.

1.声明

数据类型 [] 数组名;

int []arr; 

2.初始化

开辟空间(堆内存)

数组名=new 数据类型[数组的长度];

3.使用数组存储数据

数组名[角标]=赋值

    取值.数组名[角标]

4.特点:

有角标, 从0开始, 内存地址是连续的. 

声明好数组时候: 长度固定,元素的类型明确了

5.异常

空指针

int[] arr=null; 

arr 不再指向有效的数组了.

角标越界 

访问了不存在的角标

6.实际开发:

int[] arr={1,2,2,3}; // 必须一行完成. 

arr={2,3,4}; // 错误的

int[] arr=new int[]{1,2,3,4,5};

arr=new int[]{5,4,3}; // 正确的.

7.应用

1.遍历

角标,增强for

2.求和

取出所有元素,相加

3.获取最值

4.反转

5.排序

1.自己写(会写一个)

2.Arrays.sort();

6.二分查找

8.二维数组

数组中的元素还是一个数组.

int[][] arr=new int[二维数组长度][小数组的长度];

遍历: 取出每一个元素

求和:

***************************************************

面向对象

1.面向对象

OO  Object Oriented

思想 

对象,万物皆对象.

可以相当有效的表示显示世界的实体

面向对象中: 一个桌子,一个学生, 一个电脑,都是一个对象. 每个对象都是独一无二的. 都具备自己的属性和行为

            可以站在问题的角度,  使用计算机存储图书, 设计一个图书对象即可... 

面向过程: 解决问题,站在计算机的角度思考问题的.  必须考虑计算机能做什么, 必须将问题和计算机能够处理的问题做一个映射. 编程方法... 

  设计一个数组,存储图书的数据  _.设计一个二维数组,存储多个图书的数据... 

设计贪吃蛇:

面向过程: 一个类众多的方法. main 方法调用其他方法即可. 

  核心是方法,设计实现方法,调用方法.

面向对象: 程序中有几个对象? 蛇, 食物, 地图... 都是对象    控制器(控制蛇,食物和地图的), 显示器(图书,控制台显示)

  MVC  

  M Model  模型

  V View  显示 控制台

  C controller 控制器...   

 设计类,创建对象,维护 对象和对象之间的关系的.

 就业班的项目... 

2.面向对象编程

OOP  

Java 就是面向对象编程语言. 完全面向对象    int ->Integer   程序运行加载字节码文件(也是一个对象) 

3.类

类是对象的描述, 对象的模板,图纸. 

描述一个对象: 对象的属性(成员变量)和对象的行为(成员方法)

class 类名{

成员变量;

构造函数;

成员方法;

}

4.对象

可以根据类创建对象.

1.new 操作符,会在堆内存中开辟空间. 保存对象的特有的属性

2.方便使用对象

可以给对象起一个名字,  注意: 对象名持有的是引用,非对象本身

Person p=new Person();

5.使用对象

1.调用对象的特有的方法.

对象名.方法();

2.给对象的属性赋值和取值

赋值:

对象名.成员变量=值;

取值

数据类型   变量名=对象名.成员变量名;

对象的作用: 专业对象做专业的事情...  封装数据... 例如: 设计Book 类, Person  

6.匿名对象

...

7.封装思想

提高对象的属性的数据安全性,过滤非法数据

1.成员变量私有

无法其他类中通过对象名直接访问了

2. 提供公有的get 和set 方法.

set 可以修改对象的属性值.

get 可以获取对象的属性值.

只是封装的一种体现. 

8.构造函数

初始化对象.

函数名和类名相同, 没有返回值, 也没有返回值类型(void 不同)

一个类中可以存在多个构造函数.

是以重载形式存在.

在创建对象时,可以传递不同类型的实参,JVM 会根据具体的实参匹配对应的构造函数.

9.构造代码块

类中

{

 

}

给所有的对象初始化,

只要创建对象,不管调用的什么类型的构造函数,构造代码块都会先执行. 优先于构造函数的

10.this

结合上下文... 

本类, 构造函数(指定对象初始化), 成员函数(必须有对象才能调用).. 静态方法(不能)

对象的引用...  所在函数 所属对象(哪个对象调用了该函数)this就表示该对象... 

11.static

1.成员变量

静态变量(类变量)

不需要创建就可以直接通过类名来调用->随着类的加载而加载的(只加载一次). 只有一份,可以被所有的对象所共享.

不需要在每个对象都维护的, 例如: PI  可以设计为静态的. 对象和对象之间共享.

静态static和final 一起出现的静态变量->有着大量的使用.  ->静态常量

static 静态的,只有一份.

final 最终的,不可变的. 常量

Integer 类 MAX_VALUE  MIN_VALUE 贪吃蛇: 方向...  

例如: Math 类中的PI 都是这么设计的, 只有一份, 并且不可改变的... 

2.成员方法

静态方法

不需要创建对象可以直接通过类名来调用->类加载完毕,就可以直接通过类名来调用了. 

注意: 静态方法不能访问非静态成员变量-> 生命周期   静态方法直接通过类来调用, 此时没有对象创建,无法访问非静态成员变量.

Arrays  

Math

Collections  工具类, 可以禁止创建对象,方法全部设计为静态的,直接通过类名来调用. 

12.继承

描述类和类之间的关系(is a),解决类和类之间重复代码

extends   子类  父类

13.super关键字

1.访问父类的构造函数.

2.访问父类的成员变量(非私有)

3.访问父类的成员方法(非私有)

14.重写

override

子类继承父类,子类可以重写父类的方法, 抽象类和接口中有着大量的使用.

方法名必须相同,形参一致,返回值类型(子类方法的方法返回值必须等于或者小于父类的返回值),修饰符(子类方法修饰符必须大于或者等于父类方法的修饰符)

15.抽象类

IO流   InputStream OutputStream Reader Writer 都是抽象类.

顶层父类,明确是具备某些功能,但是该功能具体的实现不确定的.留给了子类,让子类去具体的实现.

1.特点:

不能创建对象.

可以有成员变量

可以有构造函数-> 不能创建对象 (给子类使用,用于初始化父类的属性)

可以有非抽象方法

一个类中只要有一个抽象方法,那么该类必须声明为抽象类.

一个抽象类中,可以没有抽象方法. ->禁止创建对象.

2.使用

抽象类用用于顶层设计的, 应该有子类继承抽象类,重写抽象类的方法.

1. 子类继承抽象类

要么重写父类中的所有抽象方法

要么子类也设计为抽象类.

16.接口

用于顶层设计的(最上层). 

接口和抽象类似, 看集合体系: Collection 接口, 定义顶层规范     List  ->AbstratList(抽象类)

1.接口的语法

interface  接口名{

成员变量; ->静态常量

成员方法; ->public abstract 方法

}

2.使用接口

implements 

方案一:类可以实现一个以上的接口(实现多个),需要重写接口中的所有的方法. 

方案二: 类实现一个接口与,没有重写接口的方法,该类需要声明为抽象类.

class MyCom implements Comparator{

public int compare(Object o1,Object o2){

 

}

}

核心作用:

类进行功能的扩展,解决单继承的缺陷.  定义规范... 

17.多态

前提:

继承或者实现, 子类和父类  实现类和接口的关系... 

1.体现

父类引用接收类子类对象.

例如: ArrayList 没有使用泛型  add 方法,可以添加任意类型的元素, 使用了多态机制,add 形参是Object 类型.

      没有使用泛型    get 方法 可以取出任意类型的元素... get 返回值类型也是Object 类(多态)

Collection coll=new ArrayList(); 

2.多态用在方法的形参上

可以接收范围更广的形参.

3.多态用在方法的返回值上

可以返回更多的返回值.

4.多态在集合和IO流都有着大量的应用.

好处: 

提高了程序的可维护性,扩展性... 

弊端:

多态下不能使用到子类特有的方法. 

必须进行类类型转换.

注意:

类类型转换时:

instanceof 关键字,检测一个对象是否是摸一个类型的. 否则,直接转换可又能出现 ClassCastExceotion

18.内部类

1.成员内部类

可以被privte 修饰

迭代器实现,就是在集合类的内部,一成员内部类的形式存在的.  ->方便的操作元素.

可以被static 修饰

Map 集合的一个元素使用了一个Entry 封装. 

2.局部内部类

方法中的类.  

注意: 局部内部类是否可以访问所在方法的局部变量? 

是不能访问的, 生命周期, 方法在栈内存,执行完毕就释放,方法中的局部变量也就没有了,但是 在方法中的创建的对象还有可能存活(堆内存) 

如果想要访问, 必须将该局部变量声明为final 的.

interface A{

void print();

}

Demo test(){

final int x=1;

 

class Demo implements A{

void print(){

syso(x);

}

}

 

return new Demo();

}

 

 

A a= test();

a.print();

3.匿名内部类

使用集合TreeSet TreeMap  会使用局部内部类. 

Comparator 接口. 中只需要重写一个方法compare 方法. 

TreeSet 集合的构造函数接收Comparator 接口 类型的对象. 为了简化书写. 

new TreeSet(new Comparator(){

public int compare(Object o1,Object o2){

 

}

});

new File().listFiles(new FileNameFilter(){

public boolean accept(File dir,String name){

 

}

});

// 多线程.

实现Runnable 接口方法.

new Thread(new Runnable(){

public void run(){

// 下城需要执行的任务... 

}

}).start();

4.访问修饰符. 

类修饰饰

public 最大的,可以再其他包中访问, 当然要导包(使用包名.类名 全限定类名)  

默认(default) 

默认的包权限, 只能在同一个包中访问...

方法修饰符   

                  本类                       同一包(其他类)  不同包的(子类)    不同包

public        OK        OK          OK          OK

protected     OK        OK          OK

default       OK        OK          

private       OK

protected default的区别:

default 默认的包权限,只能在同一个包中访问.

protected : 比default 稍微大一些...  在其他包中, 子类继承该类,子类可以使用到protected 修饰的方法. 

                          如果一个方法被protected 修饰,那么该方法在其他包,其他类不能直接方法, 该类的子类才可以访问的... 

*****************************************************************

Java API

1.Object类

hashCode(); 返回对象的哈希码值,默认是根据对象的内存地址计算

equals(); 比较对象是否相等,默认比较== 

toString() 返回对象的描述,返回字符串

自定义类时, 需要重写这3个方法. 

2.String 类

1.该类final 修饰

该类没有子类

2.String 类的对象是不可变的.

操作String 类的方法,无法直接改变String ,返回的是一个新的字符串对象. 

3.字符串常量池.

字符串在程序中非常常见, 为了节约内存,提高效率, 通过直接赋值法创建字符串对象(在字符创常量池保存了字符串对象)

4.字符串创建对象的方式:

1)直接赋值

String s="abc";  会在字符串常量池中

2)通过new

String s=new String("abc");  会在堆内存中.

5.字符串中的方法:

getBytes()  字符串转字节数组

getBytes("码表")  字符串转字节数组

toCharArray()  字符串转字符数组

new String(byte[] datas); 字节数组,转字符串.

new String(byte[] datas,int start,int len); 将字节数组指定部分,转字符串.

new String(byte[] datas,int start,int len,码表); 将字节数组指定部分,转字符串.

new String(char[] ch); 字符数组转字符串.

 

indexOf(); 查找指定字符在字符串中的角标.

        查 找指定子串在字符串中的角标.

lastIndexof(); 倒序查找.

charAt()  获取指定位置的字符...  

length()   获取字符串长度

substring(int start,int end) 截取字串

startsWidth 指定内容开头

endsWidth  指定结尾

matches();

split();

replaceAll();

trim(); 去空格

contains() 包含.

equals () 比较内容

compareTo 比较字符串大小的.

concat() 尾部追加

toUp ...

toLow ...

valueOf() 基本数据类型转字符串   面向对象思想.效率高一些...

3.StringBuilder

字符串缓冲区. 专业操作字符串.

append() 方法, 可以讲指定数据添加到容器中,都变为字符串... 

reverse() 翻转字符串.

StringBuilder

1.5出现,线程不安全. 单线程

 StringBuffer 

1.0出现,线程安全  多线程安全...

Java多线程

并发

一个系统中多个程序可以同时运行... 

进程

系统中正在运行的程序.

线程

进程的具体的执行路径(线程).一个进程中至少有一个线程. 如果只有线程,单线程程序... 如果有多个线程,可以实现多任务同时执行.

多线程

一个进程中可以开启多个线程. 意义: 提高cpu 资源的利用率. 

并不是线程越多越好: 多线程cpu 需要在多个线程之间切换,也会消耗资源的

Java 支持多线程

Java如何开启线程

方式一: 继承Thread 类, 子类重写父类run 方法, run方法添加线程需要执行的任务.

创建子类对象,调用start 方法开启线程

方式二: 实现Runnable 接口,实现类重写run 方法,run 定义线程需要执行的任务. 

创建Thread 类对象(创建线程),通过构造函数接收Runnable 接口实现类对象(任务)  ,调用Thread 类的start 方法开启线程.

推荐使用方式二：　更符合面向对象思想，线程（工人） Runnbale 实现类对象(任务工作) 分离.  

                     保留了继承(Java 只支持单继承,但是是多实现的)

线程安全问题:

多线程下, 多个线程修改共享数据. 会出现安全问题.

可以使用同步机制

方式一:同步代码库

synchronized(对象){

 

}

 

对象的唯一...   当线程A进入同步代码块,持有对象, 对象是唯一的,其他对象就必须等待该线程A 执行完毕代码,释放锁.                        

方式二: 同步函数

public synchronized void test(){

 

}  默认锁对象: this.

public static synchronized void test(){

 

} 默认锁对象是类名.class 类的字节码对象.

解决:

单例设计模式:懒汉式的线程安全问题.

线程的生命周期

线程通信

停止线程...

Java的集合

专业的持有(存储)对象的容器. 

集合只能存储对象. 存储的基本数据类型实际是对象

数组:

长度不可变.  

元素类型确定的. 

集合:

长度可变

可以存储任意类型的元素.

集合体系:

|---Iterable 1.5 出现的   

规范了集合获取迭代器的行为. iterator

|---Collection 接口 

定义了集合的基本的规范.(增,删 ,查,改)

all remove contains size 

|---List 接口

特点: 有序,有角标,元素可重复. 

|---ArrayList 实现类

数组实现, 内存地址连续,查找块, 增删慢(增->扩容|元素的移动)

数组扩容: 1.5倍      10*3/2+1

|---LinkedList

双向链表实现,Node 内存地址不连续. 查找慢(中间慢),增删快

|---Vector

数组实现,1.0就出现类, 线程安全,效率偏低... 方法名过长    addElements   

|---Set

特点: 无序,元素不可重复

|---HashSet

hashCode equals .

HashSet 存储元素时, 调用元素的hashCode 方法,每一个元素都计算出一个哈希值,根据哈希值存储. 在添加新元素时,如果新元素的哈希值和已经添加的元素的哈希值一样.

会调用这两个元素的equals 方法,进行比较,如果equals 也为true, HashSet就视新元素为重复元素,新元素无法添加.

|---LinkedHashSet

是HashSet 子类,底层使用hashCode equals 方法去除重复元素, 按照元素插入的顺序保存位置.

|---TreeSet

Comparable 接口

方式一:元素具备比较性. 

TreeSet 存储的元素,元素具备比较性. 元素(对象)所属的类实现Comparable 接口,重写compareTo方法. 实现元素具备了比较性.

此时TreeSet 集合可以按照元素的比较规则,进行自然排序.

TreeSet 底层调用了元素的compareTo 方法. 根据方法返回的值(正整数(大),0(相等),负整数(小).)

Comparator 接口

方式二:集合TreeSet 具备比较器. 

适合,TreeSet 集合存储的元素,不具备比较性...  

在创建TreeSet 集合可以通过该集合的构造函数,指定一个Comparator 接口的实现类对象. 

|---Map

基于键值对的. 一个元素是两个对象key value  组成. 键不可重复,值可以重复.

|---Hashtable

键不可重复, 不可存储null ,null 值 ,1.0出现线程同步的.

|---Properties 

可以喝IO流进行关联 

|---HashMap

可以存储null 键,null 值. 1.2 出现,线程不同步... 

如何保证键的唯一的. 使用到键(对象)的hashCode和equals方法. 

|----LinkedHashMap

 

|---TreeMap

键不可重复,可以给键进行自然排序.

键(对象),所属的类,实现Comparable 接口,重写compareTo 方法. TreeMap 存储键时,会调用键的compareTo 方法,根据该方法的返回值决定键的位置.

也可以给TreeMap 指定一个比较器. 

通过TreeMap 的构造函数,接收一个Comparator 接口的实现类.给TreeMap 集合的键进行排序

|---Iterator 

接口,定义了迭代器的基本的规范.

public boolean hesNext();

public Object next();

public void remove();

如果一个集合类实现Iterable ,具备自己的迭代器,在JDK5.0可以使用增强for循环... Map 无法直接使用增强for.

*******************************************************************************

JavaIO流

流: 处理设备设备之间的数据传输的. 传输数据的.

字节流

字节输入流

InputStream

方法: skip(); 跳过指定的字节... 

FileInputStream

BufferedInputStream

SequenceInputStream 顺序流

ObjectInputStream  

字节输出流

OutputStream

FileOutputStream

BufferedOuputStream

ObjectOutputStream

PrintStream  打印流

字节流: 读取指定的文件,保存数据到指定的文件. 拷贝文件(拷贝任意的). 

字符流

字符输入流

Reader

InputSteamReader 转换流,字节流到字符流的桥梁. 将一个字节流装换为字符流. 

FileReader 默认码表读取文件. 

BufferedReader

readLine

字符输出流

Writer

OutputStreamWriter 转换流 ,字符流到字节流的桥梁(按照码表),  底层还是一个字节一个字节写出的... 将一个字符串按照指定的码表,将字符解码为直接的字节,在写出.

FileWriter 默认码表写出数据.

BufferedWriter

newLine(); 新建还一个换行符.

字符流: 涉及到字符,读取字符,写出字符(中文的字符... )使用字符流... 虽然可以使用字节流读取和写出字符(但是需要手工的解码和编码,麻烦...)

随机访问流:

RandomAccessFile

是一个特殊的流,该流既可以读取,也可以写出...  read()   write()

void seek(long pos) 

甚至可以指定流内部的指针(位置),读取指定部分的数据,向指定位置写出数据.

想要通过流,将基本数据类型保存到文件中.

可以使用  DataOutputStream   将基本数据类型写出到文件中, 而不再是写出一个仅仅写出一个字节(字符)

可以使用DataInputStream 读取指定文件中的保存的基本数据类型,而不再是一次只读取一个字节 .

JavaSocket

计算机网络

1.互联网协议

IP 第一,互联网中计算机的位置的标识.. .

UDP

无连接,不可靠,速度快.  数据是以数据报包形式发送(64K) 

TCP

建立连接(三次握手),可靠,速度稍慢.

适合文件传输

2.JavaUDP 实现.

DatagramSocket

发送和接收数据包

send 

receive 

DatagramPacket

封装数据包. 

发送端

 

接收端

 

3.JavaTCP 实现

Socket

ServerSocket

 

客户端

Socket 需要连接服务端.

服务端

ServerSocket 等待客户端连接  

accept 方法.

TCP　实现,客户端和服务端会建立连接通道, 可以获取到通道的输入流和输出流,进行读去写出数据的操作.