java基础知识

目录

1.Java基础...1

Java概述SUN..1

Java语言三种技术架构J2EE.1

Java一些简写JVM..1

Java环境变量配置JAVA_HOME.1

Java名词java.1

主函数，入口函数...1

2.Java语言基础...1

2.1关键字...1

2.2标识符包、类、变量与函数、常量...2

2.3注释//.2

2.4常量与变量...2

2.5算术运算符...3

2.5赋值预算符...4

2.5比较运算符...4

2.5逻辑运算符...4

2.5位运算符...5

2.5位运算符...5

2.6三元运算符...5

2.6程序流程控制判断、选择、循环...5

2.6循环注意for、while.6

2.6其他流程控制语句...6

2.7函数/方法...6

2.7函数的定义...6

2.7函数的重载（overload）...7

2.8数组...7

2.8数组的定义...7

2.8数组内存结构...7

2.8内存结构...7

2.8数组常见问题...8

2.8数组常见操作...8

3.面向对象...8

3.1面向对象概念...8

3.1面向对象开发，设计，特征...9

3.2类与对象的关系...9

3.2类的定义...9

3.2成员变量和局部变量...9

3.2创建对象，使用对象...9

3.2对象内存结构...10

3.2匿名对象...10

3.3封装（Encapsulation）...10

3.4private关键字...10

3.5构造函数...10

3.5this关键字...10

3.6static静态关键字...10

4.继承...11

4.1继承的概述...11

4.2继承特点...11

4.3super关键字...11

4.4函数覆盖（override）...11

4.5子类实例化过程...11

4.6final关键字...11

4.7抽象类概述...11

4.7抽象类的特点...12

4.7抽象类问题...12

4.8接口...12

4.9多态...12

4.10内部类...12

4.10内部类的位置...12

4.11匿名内部类...13

4.12异常...13

4.13Throwable中的方法...13

4.13throws和throw..13

4.14包package.14

4.15import14

4.16Jar包...14

5.多线程...14

5.1线程创建一：继承Thread类个...14

5.2线程创建二：实现Runnable接口...15

5.3线程安全问题...15

5.4同步（synchronized）...15

5.4同步的特点...15

5.5线程间通信...15

5.6停止线程...15

5.7线程的其它方法...16

6.集合...16

6.1String类...16

6.2String类部分方法...16

6.3StringBuffer.16

6.4对象包装JDK1.5之后...16

6.5集合框架的构成及分类...17

6.6集合框架常用接口...17

6.7List接口中常用类...17

6.8迭代...17

6.9迭代注意事项...17

6.10Set接口中常用的类...17

6.11泛型...18

6.12Map集合...18

6.13Map与Collection.18

6.14Map集合常用类...18

6.15自定义存放三元素的Map集合...18

6.16集合框架中的工具类...18

6.17新增for语句...18

6.18函数的另一种表现形式...18

7.IO输入输出...19

7.1IO（Input Output）流...19

7.2IO流常用基类...19

7.3程序IO的书写...19

7.4字符流——创建文件...19

7.5字符流——读取文件...20

7.6字符流的缓冲区...20

8GUI图形用户界面...20

8.1Awt和Swing.20

8.2继承关系图...20

8.3布局管理器...21

8.4建立一个简单的窗体...21

8.5事件监听机制组成...21

8.6事件监听机制流程图...21

8.7菜单的继承体系...21

9.网络编程...22

9.1网络模型...22

9.2网络通讯要素...22

9.3TCP和UDP.22

9.4Socket套接字...22

9.5UDP传输...22

9.6UDP聊天程序...23

9.7TCP传输...23

9.8基本思路（客户端）...23

9.9基本思路（服务端））...23

9.10TCP传输最容易出现的问题...23

 

1.Java基础

Java概述SUN

是SUN（StanfordUniversity Network，斯坦福大学网络公司）1995年推出的一门高级编程语言。

面向对象

Java语言三种技术架构J2EE

（1）J2EE（Java 2Platform Enterprise Edition）企业版

视为开发企业环境下的应用程序提供的一套解决方案。

该技术包含如Servlet、Jsp等，主要针对Web开发

（2）J2SE（StandardEdition）标准版

如Java扫雷、Eclipse、Matlab

（3）J2ME（MicroEdition）

嵌入式设备，如手机应用程序

Java5.0版本后（即JDK1.5之后，全部是大版本号），更名为JAVAEE、JAVASE、JAVAME

Java一些简写JVM

JVM，Java虚拟机：JavaVirtual Machine

JRE，java运行环境：JavaRuntime Environment

JDK，Java开发工具包，JavaDevelopment Kit

JDK包含JRE，其它如编译工具javac.exe和打包工具jar.exe等

Java环境变量配置JAVA_HOME

 

Java名词java

java源文件，可以编译成JVM可以识别的文件，例如javacDemo.class，编译完成生成Demo.class，称为字节码文件，也就是可执行的java的程序。

主函数，入口函数

class Demo

{

     //主函数，是程序的入口

     public static void main(String[] args)

{

       System.out.println(“Helloworld”);

}

 

}

2.Java语言基础

2.1关键字

class interfacebyte short int long float double char boolean

void true falsenull if else switch case default while do for break

continue return

 

private protected public abstract final staticsychronized

extends implements new this super intanceof try catchfinally throw throws package import

native strictfp transient volatile assert

 

2.2标识符包、类、变量与函数、常量

在程序中自定义的一些名称。

由26个英文字母大小写，数字：0-9符号：_ $ 组成

定义合法标识符规则：

1，数字不可以开头。

2，不可以使用关键字。

Java中严格区分大小写。

注意：在起名字的时，为了提高阅读性，要尽量有意 义。

 

2.3注释//

（1）注释不会被JVM（java虚拟机）解释执行

单行注释：//注释文字

多行注释：/*注释文字*/

文档注释：/**注释文字*/

（2）文档注释可以被javadoc所解析成说明文档

（3）代码多注释

2.4常量与变量

（1）进制表示

十进制：0-9

八进制：用0开头表示

十六进制：0-9，A-F，用0x开头表示

（2）负数：对应的正数二进制取反加1

（3）变量的概念

内存中一个存储区域

该区域有自己的名称（变量名）和类型（数据类型）

（4）为什么定义变量

用来不断存放同一类型的常量，并可以重复使用

（5）变量作用范围

变量的作用范围（一对{}之间有效）

初始化值

（6）定义变量的格式

数据类型　变量名 = 初始化值；

（7）Java是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

 

（8）自动类型转换（也叫隐式类型转换）

（9）强制类型转换（也叫显式类型转换）

（10）类型转换的原理

（11）什么时候用强制类型转换

（12）表达式的数据类型自动提升

所有的byte型、short型和char的值将被提升到int型

如果一个操作数是long型，计算结果就是long型

如果一个操作数是float型，计算结果就是float型

（13）System.out.println(‘a’)和System.out.println(‘a’+1)的区别

（14）思考编译出错

byteb1=3,b2=4,b;

b=b1+b2;

b=3+4;

第二句b=b1+b2;这个默认是int，所以编译不通过

直接把byte改成int吧

 

2.5算术运算符

 

 

2.5赋值预算符

（1）示例

int a,b,c;a=b=c=3;

int a=3; a+=5;等同于运算a=a+5;

（2）思考以下有什么区别？？？

short s=3;

s=s+2;

s+=2;

2.5比较运算符

 

注意：比较运算符结果都是boolean型：true/false

比较运算符是，两个等于==

2.5逻辑运算符

 

（1）逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3&x<6

（2）&和&&的区别

单边&，左边无论真假，右边都进行运算

双边&时，如果左边为真，右边参与运算，如果左边为假，右边不参与运算

|和||与上述一样

（3）异或，当左右为true时，则为false

2.5位运算符

 

2.5位运算符

 

（1）最有效率的方式计算出2乘以8等于几？2<<3

（2）对于两个整数变量的值进行互换（不需要第三方变量）

2.6三元运算符

（1）格式：

（条件表达式）?表达式1：表达式2；

如果条件为true，运算后结果表达式是1；

（2）示例：

获取两个数中大数

 

2.6程序流程控制判断、选择、循环

（1）判断结构if(){执行语句;}

 

（2）选择结构

switch(表达式){case 取值1;break;。。。}

（3）循环结构while(true){执行语句}

 

（4）do{执行语句}while(条件表达式);

（5）for(初始化表达式；循环条件；循环后操作){do;}

2.6循环注意for、while

（1）while和for可以互换，区别在于for为了循环而定义的变量在for循环结束就在内存中释放。while循环使用的变量在循环结束后还可以继续使用，还在内存中！

（2）最简单无限循环格式：while(true),for(;;)

它们是根据某些条件来控制循环的

2.6其他流程控制语句

break（跳出）：选择结构和循环结构

continue（继续）：循环结构

2.7函数/方法

（1）函数也称为方法，定义在类中具有特定功能的一段独立小程序

（2）函数格式

修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2）

{

     执行语句；

    return 返回值；

}

 

返回值类型：函数运行后的结果的数据类型

参数类型：是形式参数的数据类型

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值

return：用于结束函数

返回值：该值会返回给调用者

2.7函数的定义

定义函数可以将功能代码进行封装

便于对该功能进行复用，提高代码复用性

函数只有被调用才会被执行

对于函数没有具体返回值，返回类型用void表示

那么该函数中return语句如果在最后一行可以省略不写

注意：函数中只能调用函数，不可以在函数内部定义函数

定义函数时，函数的结果应该返回给调用者，交由调用者处理

两个明确：

（1）明确要定义的功能最后的结果是什么？

（2）明确定义该功能过程中，是否需要未知内容参与运算

示例：

 

2.7函数的重载（overload）

在同一个类中，允许同一个以上的同名函数，只要它们的参数个数或者参数类型不同即可

 

2.8数组

数组的定义

数组的内存分配及特点

数组操作常见问题

数组常见操作

数组中的数组

2.8数组的定义

概念：同一类型数据的集合，其实就是一个容器

好处：自动给数组中的元素从0开始编号，方便操作元素

（1）格式1：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度]

示例：int[] arr = newint[5];

（2）格式2：

元素类型[] 数组名 = new 元素类型[]{元素，元素，...}

int[] arr = newint[]{3,5,6,1};

int[] arr ={3,4,5,8};自动装箱的

2.8数组内存结构

 

2.8内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存

用于存储局部变量，当数据使用完，所占空间会自动释放

堆内存

（1）数组和对象，通过new建立的实例都存放在内存中。

（2）每一个实体都有内存地址

（3）实体中的变量都有默认初始化值

（4）实体不在被使用，会在不确定的时间内被垃圾回收器回收

方法区、本地方法区、寄存器

2.8数组常见问题

（1）数组角标越界异常（ArrayIndexOutOfBoundsException）

int[] arr = newint[2];

System.out.println(arr[3]);

访问到了不存在的角标时，报异常

（2）空指针异常（NullPointerException）

int[] arr =null;

System.out.println(arr[0]);

arr引用没有指向实体，却在操作实体中的元素时。

2.8数组常见操作

二维数组[][]

（1）格式1：int[] arr =new int[3][2];

定义了名称为arr的二维数组

二维数组中有3个一维数组

每一个一维数组中有2个元素

一维数组的名称分别为arr[0],arr[1],arr[2]

给第一个一维数组1脚标位赋值为78写法是：arr[0][1]=78;

（2）格式2：int[][] arr= new int[3][];

二维数组中有3个一维数组

每个一维数组都是默认初始化值null

可以对这三个一维数组分别进行初始化

arr[0] = new int[3];

（3）格式3：int[][]arr={{2,3,3},{2,3},{9,4,5,6}};

     第三个一维数组的长度表示方式：arr[2].length;

注意：

 

3.面向对象

3.1面向对象概念

3.2类与对象的关系

3.3封装

3.4构造函数

3.5this关键字

3.6static关键字

3.7单例设计模式

3.1面向对象概念

面向对象是相对面向过程而言的

面向对象和面向过程都是一种思想

面向过程——强调的是功能行为

面向对象——将功能封装进对象，强调了具备了功能的对象

面向对象是基于面向过程的

 

面向对象的特点：

（1）符合人们思考习惯的思想

（2）可以将复杂的事情简单化

（3）将程序员从执行者转换成了指挥者

（4）完成需求时：

先要去找具有所需的功能的对象来用

如果该对象不存在，那么创建一个具有所需功能的对象

简化开发并提高复用

3.1面向对象开发，设计，特征

开发过程：其实就是不断地创建对象，使用对象，指挥对象做事情

设计过程：其实就是在管理和维护对象之间的关系

面向对象的特征：

封装（encapsulation）

继承（inheritance）

多态（polymorphism）

3.2类与对象的关系

使用计算机语言就是不断的在描述现实生活中的事物。

java描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义

对象即该类事物实实在在存在的个体。

 

3.2类的定义

生活中描述事物无非是描述事物的属性和行为

     如：人有身高、体重等属性，有说话、打球等行为。

Java中用类class来描述事物也是如此

     属性：对应类中的成员变量

     行为：对应类中的成员函数

定义类其实在定义类中的成员（成员变量和成员函数）

3.2成员变量和局部变量

（1）成员变量

成员变量定义在类中，在整个类中都可以被访问

成员变量随着对象的建立而建立，存在于对象所在的堆内存中

成员变量有默认初始化值

（2）局部变量

局部变量只定义在局部范围内，如：函数内，语句内等

局部变量存在于栈内存中

作用的范围结束，变量空间会自动释放。

局部变量没有默认初始化值

3.2创建对象，使用对象

 

3.2对象内存结构

 

3.2匿名对象

匿名对象是对象的简化形式

匿名对象两种使用情况

     当对象方法仅进行一次调用时

     匿名对象可以作为实际参数进行传递

3.3封装（Encapsulation）

封装：指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离、便于使用、提高重用性，提高安全性。

封装原则：

（1）将不需要对外提供的内容隐藏起来

（2）把属性都隐藏，提供公共方法对其访问。

3.4private关键字

private关键字：

是一个权限修饰符

用于修饰成员（成员变量和成员函数）

被私有化的成员只在本类中有效

常用之一：

将变量私有化，对外提供对应的set、get方法对其访问，提高对数据访问的安全性。

3.5构造函数

特点：

（1）函数名与类名相同

（2）不用定义返回值类型

（3）不可以写return语句

作用：

给对象进行初始化

多个构造函数是以重载的形式存在的

3.5this关键字

特点：this代表其所在函数所属对象的引用

即this代表本类对象的引用。

3.6static静态关键字

（1）static关键字：

用于修饰成员（成员变量和成员函数）

（2）被修饰后成员具备以下特点：

随着类的加载而加载

优先于对象存在

被所有对象所共享

可以直接被类名调用

（3）使用注意

静态方法只能访问静态成员

静态方法中不可以写this，super关键字

主函数是静态的

4.继承

4.1继承的概述

4.2继承的特点

4.3super关键字

4.4.函数覆盖

4.5子类的实例化过程

4.6final关键字

4.1继承的概述

多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。

多个类可以直接称为子类，单独这个类称为父类或者超类。

子类可以直接访问父类中的非私有属性和行为

通过extends关键字，让类与类之间产生继承关系

class SubDemoextends Demo{}

继承的出现提高了代码的复用性。

继承的出现让类与类之间产生了关系，提供了多态的前提

4.2继承特点

（1）单继承

（2）多层继承（继承体系）

class A{}

class B extendsA{}

class C extendsB{}

4.3super关键字

super和this用法相同

this是本类

super是父类

当子父类出现同名成员时，可以用super进行区分

子类要调用父类构造函数时，可以使用super语句

4.4函数覆盖（override）

子类中出现与父类一模一样的方法，会出现覆盖操作，也称为重写或复写

父类中的私有方法不可以被覆盖

子类覆盖方法中，还想用父类的可以用super.函数名获取

覆盖注意：子类方法权限大于父类方法权限

静态只能覆盖静态

覆盖的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样即沿袭了父类的功能，又定义了子类特有的内容。

4.5子类实例化过程

4.6final关键字

4.7抽象类概述

（1）抽象定义

抽象就是从多个事物中将共性的，本质的内容抽取出来

例如：狼和狗共性的都是犬科，犬科就是抽象出来的概念。

（2）抽象类

没有方法体的方法

该方法的具体实现由子类完成，该方法称为抽象方法。

包含抽象方法的类就是抽象类

（3）抽象方法的由来

狼和狗都有吼叫的方法，但是吼叫的内容是不一样的，所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。

4.7抽象类的特点

（1）abstract

（2）修饰符abstract 返回值类型 函数名（参数列表）{}

（3）抽象类不可以被实例化，就是不可new

抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。

例如：犬科是一个抽象的概念，真正存在的是狼和狗。

（4）抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

4.7抽象类问题

（1）抽象类中是否有构造函数

（2）抽象关键字abstract不可以和哪些关键字共存？

（3）抽象类中可以不可以没有抽象方法

4.8接口

（1）格式：

interface{}

（2）接口中的成员修饰符是固定的

成员常量：public staticfinal

成员函数：public abstract

（3）接口的出现实现了，多实现

（4）接口特点

接口是对外暴露的规则

接口是程序的功能扩展

接口可以用来多实现

类与接口之间是实现关系，类可继承一个类实现多个接口

接口与接口之间可以有继承关系？？？

4.9多态

（1）定义：某一类事物的多种存在形态

例：动物中的猫，狗

猫这个对象对应的类型是猫类型

     猫 x = new猫（）

同时猫也是动物的一种，也可以把猫称为动物

     动物 y=new猫（）

动物是猫和狗具体事物中抽取出来的父类型。

父类型引用指向了子类对象

（2）体现：父类或者接口的引用指向或者接收自己的子类对象。

作用：多态的存在提高了程序的扩展性和后期可维护性

前提：需要存在继承或者实现关系

要有覆盖操作

（3）成员函数

编译时：要查看引用变量所属的类中是否有所调用的成员

在运行时：要查看对象的所属类中是否有所调用的成员

成员变量：只看应用变量所属的类

4.10内部类

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）

访问特点：

内部类可以直接访问外部类成员，包括私有成员

外部类访问内部类中的成员需要建立内部类的对象

4.10内部类的位置

（1）内部类定义在成员位置上

可以被private static成员修饰符修饰

被static修饰的内部类只能访问外部类中的静态成员

（2）内部类定义在局部位置上

可以直接访问外部类中的成员

同时可以访问所在局部中的局部变量，但是必须被final修饰

4.11匿名内部类

就是内部类的简化写法

前提：内部类可以继承或实现一个外部类或接口

格式：

new外部类名或者接口名()

{

     覆盖类或者接口中的代码，也可以自定义内容;

}

简单理解：

就是建立一个带内容的外部类或者接口的子类匿名对象。

4.12异常

异常的体系

Throwable

（1）Error

通常出现重大问题，如：运行的类不存在或者内存溢出等

不编写针对代码对其处理

（2）Exception

在运行时运行出现的一起情况，可以通过trycatch finally

（3）Exception和Error的子类名都是以父类作为后缀

4.13Throwable中的方法

getMessage();获取异常信息，返回字符串

toString();获取异常类名和异常信息，返回字符串

printStackTrace()

获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。

printStackTrace(PrintStrams)

将异常保存在日志文件中

4.13throws和throw

throws用于标志函数暴露出的异常

throw用于抛出异常对象

throws和throw的区别

throws用在函数上，后面跟异常类名

throw用在函数内，后面跟异常对象

 

 

自定义异常

 

异常细节

 

4.14包package

对类文件进行分类管理

给类提供多层命名空间

卸载程序文件的第一行

类名的全称的是 包名.类名

包也是一种封装形式

 

4.15import

4.16Jar包

5.多线程

进程

线程

5.1线程创建一：继承Thread类个

（1）子类覆盖父类中的run方法，将线程运行的代码存放在run中

（2）建立子类对象同时线程也被创建

（3）通过start方法开启线程

线程的四种状态

 

一个特殊状态：就绪，具备了执行资格，但是还没有获取到资源

5.2线程创建二：实现Runnable接口

（1）子类覆盖接口中的run方法

（2）通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。

（3）Thread类对象调用start方法开启线程

思考：为什么要给Thread类的构造函数传递Runnable的子类对象？

5.3线程安全问题

导致线程安全问题出现的原因：

（1）多个线程访问出现延迟。

（2）线程随机性

5.4同步（synchronized）

格式：

synchronize（对象）

{

       需要同步的代码：

}

同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

5.4同步的特点

同步的前提：

（1）同步需要两个或者两个以上的线程

（2）多个线程使用的是同一个锁

未满足这两个条件，不能称其为同步

同步的弊端：

当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

格式：

在函数上加上synchronized修饰符即可

思考：同步函数用的是哪个锁？

程序验证

5.5线程间通信

 

思考：

wait(),notify(),notifyAll()。用来操作线程为什么定义在了Object类中？

1.这些方法存在与同步中

2.使用这些方法时必须要标志所属的同步的锁

3.锁可以是任意对象，所以任意对象调用的方法一定定义Object类中

思考：

wait(),sleep()有什么区别？

wait()：释放cpu执行权，释放锁

sleep()：释放cpu执行权，不释放锁

5.6停止线程

（1）定义循环结束标记

因为线程运行代码一段都是循环，只要控制了循环即可

（2）使用interrupt（中断）方法

该方法是结束线程的冻结状态，使线程回到运行状态来。

5.7线程的其它方法

setPtiority(intnum)

setDaemon(booleanb)

join()

自定义线程名称

toString()

6.集合

6.1String类

字符串是一个特殊的对象

字符串一旦被初始化就不可以被改变

String str = “abc”;

String str = newString(“abc”);

有什么区别？？？？

6.2String类部分方法

char charAt(intindex);

int length();

char[]toCharArray();

intindexOf(String str);

booleanendsWith(String str);

String[] split(Stringreg);

Stringsubstring(int index)

String(char[]arr);

6.3StringBuffer

字符串的组成原理就是通过该类实现的

StringBuffer可以对字符串内容进行增删

StringBuffer是一个容器

很多方法与String相同

StringBuffer是可变长度

 

6.4对象包装JDK1.5之后

 

6.5集合框架的构成及分类

 

6.6集合框架常用接口

Collection接口有两个子接口

List（列表），Set（集）

 

List：可存放重复元素，元素存取是有序的

Set：不可以存放重复元素，元素存取是无序的

6.7List接口中常用类

Vector：线程安全，但速度慢，已被ArrayList替代

ArrayList：线程不安全，查询速度快

LinkedList：链表结构，增删速度快

取出List集合元素的方式：

get（int index）：通过脚标获取元素

iterator()：通过迭代方法获取迭代器对象

6.8迭代

迭代是取出集合元素中的一种方式

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。

for用法：

for(Iteratoriter =I. iterator();iter.hasNext();)

{

     System.out.println(iter.next());

}

while用法：

Iterator iter =I.iterator();

while(iter.hasNext())

{

     System.out.println(iter.next());

}

6.9迭代注意事项

迭代器在Collection接口中是通用的，它替代了Vector类中的Enumeration（枚举）。

迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException

迭代器的next方法返回值类型是Object，所以要记得类型转换。

思考：

为什么next方法的返回类型是Object的呢？

6.10Set接口中常用的类

（1）HashSet：线程不安全，存取速度快

                         它是如何保证元素的唯一性的呢？

通过equals方法和hashCode方法来保证元素的唯一性

（2）TreeSet：线程不安全，可以对Set集合中的元素进行排序

                                 它的排序如何进行呢？

通过compareTo或者compare方法来保证元素的唯一性。元素是以二叉树的形式存放的。

6.11泛型

JDK1.5以后出现的机制

特点：

（1）提高了程序的安全性

（2）将运行期遇到的问题转移到了编译期

（3）省去了类型强转的麻烦

（4）泛型类的出现优化了程序设计

6.12Map集合

Map与Collection不同的

Map集合存储于取出元素的方式

Map集合的特点

Map集合中常用类

6.13Map与Collection

Map与Collection在集合框架中属并列存在

Map存储的是键值对

Map存储元素使用put方法，Collection使用add方法

Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素

Map集合中键要保证唯一性

6.14Map集合常用类

Hashtable：线程安全、速度慢，不允许存放null键，null值，已被HashMap替代

HashMap：线程不安全即不同步，速度快，允许存放null键，null值，效率高

TreeMap：对键进行排序，排序原理与TreeSet相同

6.15自定义存放三元素的Map集合

6.16集合框架中的工具类

（1）Collections

对集合进行查找

取出集合中的最大值、最小值

对List集合进行排序

（2）Arrays

将数组转成List集合

对数组进行排序

对数组进行二分查找

6.17新增for语句

Collection在JDK1.5后出现的父接口

Iterable就是提供了这个for语句

格式：

for（数据类型 变量名：数组或集合）

{

       执行语句；

}

简化了对数组，集合的遍历

6.18函数的另一种表现形式

返回值类型 函数名（参数类型... 形式参数）

{

     执行语句；

}

其实接收的是一个数组，可以指定实际参数个数。

7.IO输入输出

7.1IO（Input Output）流

IO流用来处理设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的对象都在IO包中

流按操作数据分为两种：字节流与字符流

按流向：输入流，输出流

7.2IO流常用基类

字节流的抽象基类：

InputStream，OutPutStream

字符流的抽象基类

Reader，Writer

注：由这四个类派生出来的子类名称都是以其父类违子类名的后缀

FileInputStream

FileReader

7.3程序IO的书写

导入IO包中的类

进行IO异常处理

在finally中对流进行关闭

思考：

（1）有了垃圾回收机制为什么还要调用close方法进行关闭

（2）为什么IO异常一定要处理

7.4字符流——创建文件

创建流对象，建立数据存放文件

FileWrite fw =new FileWrite(“Test.txt”);

调用流对象的写入方法，将数据写入流

fw.write(“text”);

关闭流资源，并将流中的数据清空到文件中

fw.close();

不写close方法会有什么结果呢？

如果想在原有文件上继续加入新的数据呢？

importjava.io.*;

 

class Demo

{

     public static void main(String[] args)

     {

            FileWriter fw = null;

            try

            {

                   fw = newFileWriter("Test.txt");

                   fw.write("text");                 

            }

            catch(IOException e)

            {

                   sop(e.toString());

            }

            finally

            {

                   if(fw!=null)

                          try{

                                 fw.close();

                          }

                          catch(IOException ex)

                          {

                                 sop(ex.toString());

                          }

            }

     }

    

     public static void sop(Object obj)

     {

            System.out.println(obj);

     }

}

7.5字符流——读取文件

建立一个流对象，将已存在的一个文件加载进流

FileReader fr =new FileReader(“Test.txt”);

创建一个临时存放数据的数组

char[] ch = newchar[1024];

调用流对象的读取方法将流中的数据读入到数组中

fr.read(ch);

思考：

在加载文件的时候是否将文件全部加载进流？

为什么定义数组，要定义多大呢？

7.6字符流的缓冲区

缓冲区的出现提高了对数据的读写效率

对应的类

BufferedWriter

BufferedReader

缓冲区要结合流才可以使用

在流的基础上对流的功能进行了增强

8GUI图形用户界面

GUI：GraphicalUser Interface

CLI：Command lineUser Interface（命令行用户接口）

Java为GUI提供的对象都存在java.Awt和javax.Swing两个包中

8.1Awt和Swing

（1）java.Awt：AbstractWindow ToolKit（抽象窗口工具包），需要调用本地系统方法实现功能属重量级控件

（2）javax.Swing：在AWT的基础上，建立的一套图形界面系统，其中提供了更多的组件，而且完全由Java实现。增强了移植性，属轻量级控件

8.2继承关系图

Container：为容器，是一个特殊的组件，该组件中可以通过add方法添加其他组件进来

 

8.3布局管理器

容器中的组件的排放方式，就是布局

常见的布局管理器：

（1）FlowLayout（流式布局管理器）

从左到右的顺序排列

Panel默认的布局管理器

（2）BorderLayout（边界布局管理器）

东南西北中

Frame是默认的布局管理器

（3）GridLayout（网格布局管理器）

规则的矩阵

（4）CardLayout（卡片布局管理器）

选项卡

（5）GridBagLayout（网络包布局管理器）

非规则的矩阵

8.4建立一个简单的窗体

Container常用子类：WindowPanel（面板，不能单独存在）

Window常用子类：FrameDialog

简单的窗体创建过程：

Frame f = newFrame(“my window”);

f.setLayout(newFlowLayout());

f.setSize(500,400);//设置窗体大小

f.setLocation(300,200);//设置窗体出现在屏幕的位置

f.setVisible(true);

8.5事件监听机制组成

事件源（组件）

事件（Event）

监听器（Listener）

事件处理（引发事后处理方式）

8.6事件监听机制流程图

 

（1）确定事件源（容器或组件）

（2）通过事件源对象的addXXXListener()方法将侦听器注册到该事件源上

（3）该方法中接收XXXListener的子类对象，或者XXXLIstener的子类XXAdapter的子类对象

（4）一般用匿名内部类来表示

（5）在覆盖方法的时候，方法的参数一般是XXXEvent类型的变量接收

（6）事件触发后会把事件打包成对象传递给该变量。（其中包括事件源对象。通过getSource()或者，getComponent()获取）

8.7菜单的继承体系

 

（1）MenuBar，Menu，MenuItem

（2）先创建菜单条，再创建菜单，每一个菜单中建立菜单项

（3）也可以菜单添加到菜单中，作为子菜单

（4）通过setMenuBar()方法，将菜单添加到Frame中

 

 

9.网络编程

9.1网络模型

 

OSI参考模型

TCP/IP参考模型

9.2网络通讯要素

（1）IP地址：InetAddress

本地回环地址：127.0.0.1  主机名：localhost

（2）端口号

用于标识进程的逻辑地址，不同进程的标识

有效端口：0~65535，其中0~1024系统使用或保留端口

（3）传输协议

通讯的规则TCP/UDP

9.3TCP和UDP

（1）UDP

将数据及源和目的封装成数据包中，不需要建立连接

每个数据包的大小限制在64k内

因无连接，是不可靠协议，但是速度快

（2）TCP

建立连接，形成传输数据的通道

在连接中进行大数据两传输

通过三次握手完成连接，是可靠协议

必须建立连接，效率会稍低

9.4Socket套接字

SOcket就是为网络服务提供的一种机制

通信的两端都有Socket

网络通信其实就是Socket间的通信

数据在两个Socket间通过IO传输

9.5UDP传输

DatagramSocket与DatagramPacket

建立发送端，接收端

建立数据包

调用Socket的发送接收方法

关闭Socket

发送端与接收端是两个独立运行程序

（1）发送端

（2）接收端

9.6UDP聊天程序

通过键盘录入获取要发送的信息

将发送和接收分别封装到两个线程中

9.7TCP传输

Socket和ServerSocket

建立客户端和服务端

建立连接后，通过Socket中的IO流进行数据的传输

关闭socket

同样，客户端与服务器是两个独立的应用程序

9.8基本思路（客户端）

（1）客户端要明确服务器的ip地址及端口，这样才可以去试着建立连接，如果连接失败，会出现异常

（2）连接成功，说明客户端与服务端建立了通道，那么通过IO流就可以进行数据的传输，而Socket对象已经提供了输入流和输出流对象，通过getInputStream()，getOutStream()获取即可

（3）与服务通讯结束后，关闭Socket

9.9基本思路（服务端））

（1）服务端需要明确它要处理的数据是从哪个端口进入的。

（2）当有客户端访问时，要明确是哪个客户端，可通过accept()获取已连接的客户端对象，并通过该对象与客户端通过IO流进行数据传输

（3）当该客户端访问结束，关闭该客户端

9.10TCP传输最容易出现的问题

（1）客户端连接上服务端，两端都在等待，没有任何数据传输。

（2）分析可知：read方法或readLine方法是阻塞式的。

（3）解决办法：

自定义结束标记

使用shutdownInput，shutdownOutput方法