java7  (新的是java9)

语言学习: 基础语法 -> 数据结构 -> IO流 -> 多进程与线程编程 -> 网络编程  

j2se(标准版本) j2ee(企业版本 web开发) j2me(移动版本)

　搭建环境：jdk(java的开发工具包）　

　　　　　　jre(java的运行时环境)　java程序编写好了之后，需要在java虚拟机上运行，但                                   凡拥有java虚拟机的设备，都可以运行java代码。

　　　　　　jdk下载：oracel的官网上可以下载到新的java版本，现在新的是java９，老                     版本需要到csdn下载，下载之后，直接安装

　　　　　　TIPS:环境变量是否配置，看之后使用的集成开发工具是否需要，再添加

　集成开发工具：eclipse 

                idea

                Netbeans

            TIPS:jdk和集成开发工具好统一，都是64位或32位

基本语法规则(与其他语言相似的部分): 

1.程序 = 算法 + 数据

数据: ①持有数据: 定义变量: 数据类型 变量名称 = 初值 ;

             ⑴值的类型应与变量类型匹配

             ⑵不要重复定义同名变量

        java变量实质是C语言的指针,装的实质都是地址

        数据类型分两大类: 基本数据类型 , 引用数据类型

        基本数据类型: 4211  

                      4种整形 byte short int long 

                      2种浮点 float double 

                      1种字符 char

                      1种布尔 boolean

    (由于java是一种强类型语言,值的类型一定要与变量类型一致,不能用0或1的整形来表示真假,仅表示数据,只能用布尔类型表示真假)

　　　　

　　　　引用数据类型：（除了基本数据类型之外的所有类型都是引用数据类型）   

　　　　　　　　tips: 驼峰标识：java中默认的命名规则：

　　　　　　　　　　　　　　　　名称中所有单词的首字母都大写，其余小写：Helloworld

　　　　　　　　　　　　　　　　变量名和函数名，第一个单词的首字母小写：helloWorld

　　　　　　　　　　　　　　　　　　　

        标识符: 定义变量,函数名等内容。

                范围：a-z， A-Z， 0-9，$, _（数字不作为开头,不能是关键字或保留字）

　　　　　　　　定义变量：byte b = 1;

                          short s = 1;

                          int i =1;

                          long l = 1L; long类型的值准确描述后面要添加字母（ｌ／Ｌ）

　　　　　　　　　　　　　float f = 1.0F; float类型的值后面必须添加字母（ｆ／Ｆ）

　　　　　　　　　　　　　double d = 1.0; 

                          char c = 'a'; 在java中代表字符，如为双引号　表示字符串

　　　　　　　　　　　　　　　　　＂ａ＂与'a'不同

　　　　　　　　　　　　　boolean = 只有true和false两种

               自动转型:目前针对基本类型

                 byte->short->int->long

                   char-int

                  float->double

                  强类型转换byte b = (byte)130

　　　②操作数据　：　运算符　

　　　　　　　　算术运算符　+ - * / %

                赋值运算符　= += -= *= /= %=

                逻辑运算符　& && 逻辑与　| ||　逻辑或

　　　　　　　　关系运算符　！取反　== >= <= > <

                位运算符　&按位与　｜按位或　~按位取反　>>有符号右移　>>>无符号右移

　　　　　　　Tips:有符号，无符号，在java中，整型和浮点型的高位是符号位０负１正

　              三目运算符　变量 = 关系判断表达式？true的结果：false的结果；

　　　　　　　解释：关系判断表达式中返回true，就将？后面的：前面的表达式结果进行返　　　　　　　　　　回，如果关系判断表达式返回false,就将：后面的表达式结果进行返回

　　　　　　

　　　③流程控制语句

　　　　　　if()...else...;

　　　　　　　　　　if(表达式)

　　　　　　　　　　{　　

　　　　　　　　　　　代码块１

　　　　　　　　　　　}

　　　　　　　　　  else

                    {

                      代码块２

                     }

　　　　　　TIPS:1.表达式结果必须是布尔类型的

　　　　　　　　 2.代码块1和代码块2如果只有一句代码，可以省略外面的{}

　　　　　　switch(){case}

                   switch(表达式)

　　　　　　　　　　　{

　　　　　　　　　　case 结果1:

                         代码块1；

                         break;

                    case 结果2:

                         代码块2；

                         break;

                    default:

                         代码块3;

　　　　　　　　　　　　　}

　　　　　 TIPS:1.表达式的结果类型:byte short int char string

                2.通过表达式得到的结果,选择对应的case后面的语句进行执行。执行完毕后                  ,break整个执行完毕

                3.如没有对应的case,就执行default中的代码,当然switch语句没有default                  语句块也可以

      ④循环语句:

          while(表达式){循环体}

          do{循环体}while(表达式)

          for(表达式1;表达式2;表达式3){循环体}

          

       完成HelloWorld步骤:

          1.创建文件HelloWorld,文件后缀修改为.java

            (创建文件装在java源码)

          2.编写内容:public class HelloWorld{}

            (定义类型HelloWorld,属于引用数据类型,java程序小的程序单元就是类,java是一款纯面向对象的语言,所以程序运行必须依赖于类,java的代码写在类中)

          3.第二步编写的花括号中,继续编写:

                public static void main(String[] args)

            (在类型中定义一个主方法,这个主方法是固定格式,他代表java程序运行的入口)

          4.在第三部编写内容的花括号中,编写输出语句:

                System.out.printIn("Hello,Java!");

          5.运行javac工具,编译源文件,得到.class文件

            (将java源码编译成为字节码,检查源码中出现的错误)

          6.使用java工具，运行程序

            (java必须运行在java虚拟机上,这里调用的java工具会启动java虚拟机,并且运行上一步编译好的java字节码文件)

          TIPs:为什么要先编译成字节码,再由java虚拟机运行?

            java的跨平台能力,而这个跨平台能力就是依托于java虚拟机来实现

            sun公司为不同平台提供了不同的虚拟机,虽然虚拟机不同,但是他们有一个共同点,就是都可以运行java

          

java特有的语法规则:

1.包:用来管理java源代码

           命名规则: 公司域名倒置 + 工作组的名字 + 工程的名字 (建议都用小写字母)

     TIPS:1.在java工程中,java源文件放入包中之后,必须在第一行通过package关键字明确当            前所在的包

          2.如果java源文件在default包中(没有创建包),那么可以不写.

     快捷键

          1.在eclipse中发现错误,要修改,可以使用快捷键 ctrl+1,来快速处理错误

 2.在eclipse中可以快速补全,alt+/

     使用import关键字,加上目标类型的包名和名字,可将其他包中的类型,引入到本类使用

          例如 import com.farsight.g1711.project3.bear

2.注释

          1.单行注释://

          2.多行注释:/**/

          3.文本注释:/***/ (使用文本注释可以使鼠标指在变量上时,显示对应的注释)

3.类      类这个概念是面对对象编程的核心,编写java程序,实质就是编写类型

          编写类型的格式

 public class 类名{类的内容}   

          主要类名应与文件名相同(包括大小写)

          一个源文件可以不止编写一个类,但是除了与文件名相同的类型可以用public修饰外           其他类不能使用public

          类的内容:1.成员属性(变量)  在类中直接定义或声明一个变量,就是为这个类型设                                     定一个属性

                   2.成员方法(函数)  在类中定义一个函数,就是为这个类型设定一个方法

                                      

     快捷键:

修改快捷键:alt+shift+R

          如何使用类:

          1.创建类型,得到对象:    类名称 变量 = new 类名称();

             例如Class1 b = new Class1();

            TIPS:同一个类型可以创建多个对象.

                 Class1 b2 = new Class1();

          2.通过对象使用属性或方法  对象通过.符号,使用类定义的属性及方法

             例如b.a=10;

                 b.function();

4.对象:   java面向对象编程,对象是由类型所产生的,类型相当于构建起对象的图纸.java程序          运行的过程就是对象执行操作的过程

          

          TIPS:java程序的执行必须依赖对象来执行

         在java中加号前后如果是字符串,则作为字符串连接符使用

(如果在前面用了加号作字符串连接符,后面想在输出语句中用加号表达数值相加,需要把结果括号括起来,不然会产生奇怪的输出结果)

         例如:System.out.printIn("b.a="+b.a);

         

属性通常只写出声明的语法,表示此类型拥有什么

         构造器是一种特殊的"方法"，格式： public 类名称(参数列表)｛构造器代码块｝

                                           初始化属性的数据

   ⑴构造器名称与类名一致

   ⑵如果要重载构造器,参数列表的类型不能一致

   ⑶构造器专门用于属性初始化

           TIPS:1.在一个类型中,我们可以不去设置构造器,这个时候,会由编译器自动添加一          个空参构造器(public bear(){}).但凡我们手动增加了一个构造以后,编译  器就不再自动添加空参构造器

                2.在一个类型中,可以拥有多个构造器(不同参数),一个类型拥有多个构造器          叫做构造器的重载

                3.多个构造器,会导致某些属性无法被构造器初始化,这里将有编译器帮忙初                    始化,整形赋值0,浮点型赋值0.0f,0.0,字符型赋值"/u0",布尔型赋值  false,引用数据类型赋值NULL

方法：

格式：访问修饰符 返回值类型 方法名称(参数列表){方法代码块}

TIPs：方法也可以重载：同名不同参。

作用：类型能干什么。

     对属性进行set&&get操作。

     按照属性来执行我们的业务逻辑。

5.访问修饰符

java中有4个级别的访问权限，但是只有3个访问修饰符.

公开级别      public    由public修饰类型，属性，方法可以在任意包、类中使用

受保护级别    protected 由protected 修饰类型，属性，方法可以在任意包子类或者同包的类中使用。

默认级别       由默认权限修饰类型，属性，方法可以在同包的类中使用。

私有级别      private   由private修饰类型，属性，方法只能在本类中使用。

TIPs：在编写当前的类型时，只能使用public和默认两种权限。

6.static静态修饰符：

静态修饰符，将属性或者方法，从属于对象的部件变化为属于类型的部件，从而让这个类型的所有对象公用此属性或方法。

静态方法属于类，不需要通过对象调用，直接使用类名调用即可。(静态类在类型构造时自动形成一个类对象,所以可以直接使用)

7.final终态修饰符：

对类修饰：

对方法修饰：

对属性修饰：定义为常量，不可被修改。

类型相关的语法：

1.继承：一个类型获取另一个类型的属性和方法。减少额外的代码编写，提高代码的重复利用。

语法格式：

A类要使用B类的属性和方法：

class B{

int speed ;

public void run(){}

}

class A extends B{

//这里会拥有B类的run方法。

}

TIPs:1.两个类型不能互相继承

     2.java中不允许实现多重继承

 如果当我们开始编写代码的时候就想要发现继承的关系：

一个类型是否属于另一个类型。

eq: 狗是否属于动物 -是-> 狗-继承->动物

           子类      父类

 继承的语法细节：

属性：

1.子类能够继承到父类的属性，但是如果此属性是私有的，那么子类是无法访问到。

2.对于私有属性的初始化，我们会依赖构造器。

TIPs:

构造器第一行必须调用父类构造器或者其他本类构造器。如果父类有空参的构造器，那么子类第一行可以省略不写父类构造器。

父类与子类使用的关键字：

this/super

this代表本类当前对象。

使用：调用本对象属性：this.age = 100 ;

     调用本对象方法：this.run() ;

     调用本对象构造器：this(参数列表) ;

super代表当前的父类对象。

使用：调用父类对象的属性：super.age = 100 ；

     调用父类对象的方法：super.run() ;

     调用父类构造器：super(参数列表) ;

TIPs:this与super不可以在static修饰的方法中使用。

方法：

1.子类会自动拥有父类的方法。如果子类不满意父类方法的具体实现，可以利用重写，来重新定义这个方法的内容。

TIPs：在自动完成的重写方法上有一个@Override的注解，这个注解用于检测下面的方法是否是合法的重写。如果你不想检测，可以去除这个注解。

     重写可以让子类重新定义父类方法的实现，也可以让子类在父类功能的基础上扩展此方法。

2.有时候，父类不想要子类去修改他定义某些方法，我们可以通过final修饰我们关键的方法，让子类无法重写此方法。如果整个类被final修饰，那么这个类不能被继承。

Interface接口

java中定义类型的一种方式。

格式：

1.声明格式：public interface 接口名称(类型名称) {接口内容}

2.接口的内容：

常量(默认会自动添加 public static final的修饰)

抽象方法：public void run();

TIPs:java8之后，接口也可以拥有实现方法。

接口是不能创建对象的，只能被其他类型作为父类型使用。

TIPs：这里接口作为父类型不能够使用extends来完成而要使用implements(实现接口)关键字实现，和extends继承不冲突。

TIPs：1.子类实现父接口时，必须实现父接口的抽象方法。

     2.可以实现多个父接口。

TIPs：有了接口和父类型之后，我们整个程序在新增功能的时候，可以利用继承父类，实现父接口的方式，通过父类型+父接口来组合成为新的功能类型。

多个接口也可以通过继承(extends)的方式来组合到一起：形成父接口与子接口的关系。

TIPs：多个父接口如果有同名方法，子类型只需要实现一次即可。

     父类型与父接口有同名方法，子类型只需实现一次或不在子类重写都可以。

Object：

在java中无论是否显示去写出extends Object语句，这个类型都一定是Object的子类型。

1.写extends Object，这个类型继承于Object类。

2.没有extends语句，这个类型继承于Object类。

3.extends OtherClass，这个类型继承于OtherClass,而OtherClass一定是直接或间接地继承了Object，所以这个类型也会间接继承到Object。

java中一切引用数据类型都继承Object。

方法：

      *clone  创建一个完全一样的新对象。

      *equals 方法逻辑比较相等。

finalize 对象被销毁时，调用，释放资源。

hashCode 提供hash算法

toString 在输出某个对象时，我们会自动调用toString来返回一个字符串，将这个字符串输出到控制台。

public boolean equals(Object anObject) {

//如果比较的同一个对象，那么一定相同

        if (this == anObject) {

            return true;

        }

//判断anObject指向的对象是否属于String这个类型或者他的子类型

        if (anObject instanceof String) {

            String anotherString = (String)anObject;

            int n = value.length;

   //比较两个字符串长度是否相等

            if (n == anotherString.value.length) {

                char v1[] = value;

                char v2[] = anotherString.value;

                int i = 0;

                while (n-- != 0) {

   //比较两个字符串对应位置的字符是否相等

                    if (v1[i] != v2[i])

                        return false;

                    i++;

                }

                return true;

            }

        }

        return false;

    }

1.多态

类型(对象)体现多种状态

表现形式：父类引用(父类型变量)指向子类对象。

                  父类型的变量可以持有子类对象,父类型的返回值类型可用于返回子类对象

 Bird bird = new Penguin();

                   

        可以用类似pulbic Object Function(){

                     class A{

                           A a = new A();

                           retrun a;}

                           }

                   来进行多态操作,强制返回父类类型

             

TIPs:但是在使用的时候，由于是通过父类型变量使用，我们只能使用这个子类对象中继承父类的部分内容。

    虽然是通过父类型变量来使用，但是依然调用的子类自己的方法。

2.面向对象编程三大特征：封装，继承，多态。

              四大特征：                ，抽象。

              五个原则：1.开闭原则(对扩展开放,对修改关闭)

                        2.单一职能原则(一个类型就负责一种功能)

                        3.接口隔离原则

4.liv氏替换原则

5.依赖倒置原则(使用对象的时候,尽量不要依赖具体的实现类,而依赖抽象类型)

方法：

    返回值类型 方法名(参数列表){

方法体

return 返回值1；

}

返回值类型 变量 = f(x) ;

多态：

当一个方法需要返回多种类型的数据时，我们就需要找到这些数据的类型的共同点：是否继承自同一个父类型。 java中可以把一个父类型的所有子类型看做这个父类型来使用。

所以当我们一个方法要返回多种类型的数据时，我们需要在返回值类型这里填写这些类型的父类型。

3.异常：

java程序出现问题，就会执行异常处理代码。

异常输出信息：

1.“main”表示出错的线程。

2.java.lang.NullPointerException 这是一个异常类。java中一切皆对象。

3.堆栈信息

4.集合框架

java已经帮助我们将一些常见的数据结构，封装成了集合类，我们在操作数据时，可以非常方便的创建出某一种需要的数据结构去使用。

1.异常处理机制

1.关键类：Throwable  Error  Exception

Throwable

父类：Object

父接口：Serializable

直接子类：Error Exception

Throwable是java中出现的异常类的大父类型。他定义了java中所有异常类都会使用的方法：例如获取异常的信息，异常发生时的堆栈信息等，异常类携带的这些信息，可以帮助我们解决当前遇到的问题。

Error

父类：Throwable -> Object

父接口：Serializable

直接子类：各种各样的严重错误

Error是指非常严重的错误，这些错误我们没有办法通过当前的代码来弥补错误，需要停止当前程序。

Exception 

父类：Throwable -> Object

父接口：Serializable

直接子类：各种各样由于我们自己编写的代码所导致的错误。

Exception表示我们自己编程，导致的错误。这些错误是我们可以弥补补救。我们可以利用异常处理来将这些错误处理掉，防止停止当前程序。

2.异常的处理：

try{

//我们要监控，可能发生错误的代码块

}catch(异常1){

//处理异常

}catch(异常2){

//处理异常2

}catch...

finally{

//后必须执行的代码

}

TIPs：

1.try语句块后面可以跟一个或多个catch语句块，在catch语句块后面的()中我们要设定这个语句块要捕获的异常类型，并设置一个变量接收这个异常对象：(IllegalClassFormatException exception),之后再{}就可以去处理这个异常对象。

2.finally语句块可以省略不写，无论try{}catch{}语句块是否发生异常，都必须在执行完毕后，执行一次finally语句块。

3.try语句块中一旦发生异常，这个语句块错误发生一行及之后的代码都不会再执行。

4.catch语句块中，我们可以使用父类型的异常来捕获子类型的异常对象。但是要注意，catch语句块在捕获时，有先后顺序，前面写的catch先捕获，后面写的catch后捕获，如果前面的catch已经将此错误捕获，那么后面的catch就不会执行：（父类型异常要在子类型异常之后捕获）

3.我们可以依据Exception的使用方式，依照我们需求去扩展Exception的子类。

发出异常：throw关键字+异常对象 .

TIPs：运行时异常：继承Exception的子类RuntimeException。这种异常，不是必须设置处理代码。

     非运行时异常：直接继承Exception，当发生异常时，必须要处理。

异常处理方式：

1.try...catch...  弥补这个错误。

2.甩锅：在方法声明的语句末尾添加throws+异常类型，将方法中发生的错误，抛出去，给方法调用者去处理。

abstract修饰词：修饰类型与方法。

修饰类型：表示这个类型是抽象类。

修饰方法：表示这个方法是抽象方法。

用于标注那些我们只是用于做父类型的类，使用abstract修饰修饰后，这种类叫抽象类，他不可以被实例化(不可以直接用它创建对象)。

抽象类，也可以像接口一样，在类中定义抽象方法。我们的父类型有时候没有办法去具体实现子类的功能，所以在父类这里我们可以设置抽象方法，规范子类的功能，但是具体实现由子类自己完成。

TIPs:抽象方法的定义是需要添加修饰词abstract。接口中可以省略这个修饰词，但是在抽象类中定义抽象方法，是不可以省略的。

类型：

class ：具体实现类。

abstract class ：常用于规范实现类。

interface ：常用于规范实现类所需要的功能。

Native修饰词：用语修饰方法，表示这个方法是一个本地方法，实现在本地语言中实现。（JNI）

内部类：

在一个类中定义类型：

成员内部类

定义格式：

修饰词 class 类名 {}

TIPs: 访问修饰词 4种权限都可以使用。

内容与正常类型没有区别。

意义：内部类，可以直接调用外不类的所有成员。private也一样。

成员内部类的使用：

1.创建对象：new 外部类().new 内部类() ;

2.在java中内部类与外部类创建出来的对象不会有区别，都是存放在java堆中，所以在使用中外部类对象与内部类对象没有区别。

静态内部类的使用：

1.创建对象：

TIPs:如果加载成员内部类需要依靠外部类对象太麻烦，我们可以利用static来让我们的内部类跟随外部类一起加载（而不更随对象），这样我们就可以直接创建。static也会带来一些问题，例如静态内部类中不能访问外部类的非静态成员。

TIPs：成员内部类，不可以拥有静态成员。静态内部类可以拥有静态成员。

在方法中定义类型：

局部内部类：不能使用访问控制修饰符修饰。

使用：创建对象：在方法中类定义之后创建。

TIPs:局部内部类只处理当前方法中的逻辑，所以一般都比较短小：(通常不会超过10行代码)

        有内部类的方法,需要创建内部对象才能使用,不能直接静态调用方法。

        可以将内部类也定义成静态的，就可以将有内部类的方法定义成静态的。

在属性中定义类型：并不是在属性中创建类型，而是这种匿名内部类没有名字，在实现类型时，就会创建对象，并且我们通常需要使用一个变量来接收这个对象。

TIPs：通常在定义匿名内部类时，使用的类型和名字其实都是匿名内部类的父类或父接口的名字。

TIPs：除了匿名内部类以外，其他的内部类在继承与实现的语法上与外部类没有区别。而内部类的继承可以让我们变相地实现多重继承的效果。

java中的数据结构：

java已经定义了很多类似于我们编写的船坞类这样装载数据的类型，这些类型叫做：集合类。

目前我们要学习的结合类，基本都放在java.util包中，其中有很多类型，每个类型都实现了一种数据结果，用于操作数据。

1.ArrayList 

 父类型：Object->AbstractCollection->AbstractList

 父接口：Serializable 序列化接口

 Cloneable    代表可以克隆

 Iterable     迭代器

 RandomAccess 是一个空接口，标记性接口，代表这个类型的子类型可以快速随机访问。

 List       表示有序的数据容器

 Collection   是整个java集合框架基础的父接口

          创建：

构造器-->属性

ArrayList() 

 使用：

方法：

增：add()，将数据加入尾部。

删：clear() 删除所有。remove(index) remove(obj)。

改：set(),指定下标替换数据。

查：iterator迭代器。 get()获取其中的数据。 

2.LinkedList

  父类型：Object->AbstractCollection->AbstractList

        ->AbstractSequentialList

  父接口：Serializable 序列化接口

 Cloneable    代表可以克隆

 Iterable     迭代器

 List       表示有序的数据容器

 Collection   是整个java集合框架基础的父接口

 Deque

 Queue

   创建：

构造器--》属性

LinkedList()

   使用：

方法：

增：add()

删：remove() clear()

改：set()

查：get()

疑问:

   在使用中，ArrayList与LinkedList几乎没有差异。

   为什么要创建两个类型？

   1.ArrayList 内部使用数组来完成数据的管理。

     LinkedList内部使用双向链表完成数据的管理。

    TIPs:内部实现的数据结构不同，会导致效率上的差异。

    TIPs:虽然内部实现不同，但是由于有相同的父类型，所以我们在使用上是没有区别的。

   父类引用指向子类对象：

//具体实现

List list = new ArrayList() ; / new LinkedList() ;

// 使用一致

list.add() ;

list.set() ;

list.get() ;

    将具体实现与我们的使用分开，当我们发现当前的具体实现不适合这个使用方式的时候，我们可以灵活地变换具体实现。

  从这些内容学习我们就知道，目标类型有哪些功能，我们只需要从父类型或父接口入手，了解功能的使用。具体的逻辑实现，不同的子类型有不同的实现方式，适应不同的软件系统的需求。

    

  TIPs：学习这些集合框架中的类型，从他们的父接口了解他们的功能即可。在具体使用的时候，再查询api找到适合的实现子类，来使用即可。

     

集合框架：

接口进行功能声明：

Iterable 接口：表示此类型拥有iterator()可以返回一个迭代器。

Collection 接口：对所有集合类，的增加，删除，查询方法进行了定义。

List接口:针对于顺序列表，做了一些修改：增加了改(set)查(get)

set接口:针对于数学概念的集合，内容不重复。

抽象父类对功能进行部分实现：

AbstractCollection

AbstractList

具体实现类：

ArrayList

LinkedList

RoleList

...

HashSet

父类型：AbstractCollection

代表他的add() clear() remove()这些功能和前面List使用是一样的。

TIPs：这里并没有提供get方法来获取数据。这里其实Collection接口为所有子类型都提供了一种统一的数据查询、遍历方式：迭代器Iterator。

TIPs：实现数学集合的功能，内容不重复。

 泛型: 就在定义类型时，使用<字母/单词>来表示会使用一种类型，但是定义时，不能确定这种类型，要在创建对象时，明确具体类型。

定义泛型：在类定义时，类名后直接添加<E>.

使用泛型：在创建带有泛型的类型的对象时，使用<具体类型>来将泛型进行替换。

HashMap

父类：Object->AbstractMap<K,M>

父接口：Serializable, Cloneable, Map<K,V>

TIPs：从父接口Map我们能了解到HashMap是以键值对的形式存储数据。

方法：增：put(key，value)

     删：remove()  clear()

     改：put(key，value)

     查：get()

内部实现：哈希表(数组)+链表

io流

  java流：字节序列。

  常用类：FileInputStream/FileOutputStream  

  关键父类型：InputStream/OutputStream   字节流 

 InputStreamReader/OutputStreamWriter

 BufferedReader/BufferedWriter

关键父类型：Reader/Writer       字符流

  FileInputStream/FileOutputStream 

 文件输入输出流

 FileInputStream

父类：Object->InputStream

接口：Closeable

创建 构造器：

FileInputStream(String name) 

使用 方式：

read()

 FileOutputStream

父类：Object->OutputStream

接口：Closeable Flushable

创建 构造器：

FileOutputStream(String name) 

使用 方法：

write() ;

 InputStreamReader

父类：Object->Reader

接口：Closeable，Readable

创建：基于inputstream来构建对象

使用：read 读取字符。

 OutputStreamWriter

父类：Object->Writer

接口：Closeable, Flushable, Appendable

创建：基于OutputStream来构建对象

使用：write 写字符

 TIPs: 装饰模式：构建类型A 类型B。B类型基于A类型来创建对象，并且A的功能也要基于B的功能来实现。

 File

为了方便对本地文件系统进行操作，提供了一个类型：File。

父类：Object

接口：Serializable（可序列化）

     Comparable 

创建：File(String pathname) 

方法：创建文件：createNewFile(文件) mkdirs(文件夹)

     删除文件：delete

     文件信息：文件信息的操作（getXXX）

遍历文件系统的方法：listFiles，返回下一级目录和文件的对象。

TIPs：由于不同系统中路径名和路径分隔符不一致，所以File类型为我们提供了相关常量来使用：pathSeparator、separator来进行区分。

window:c:\test\g1711;c:\test

linux : /test/g1711:/test

java  :C:\test+File.separator+g1711

 Serializable

这个接口是一个标志性接口，不包含方法，就是用于告知实现此接口的子类型可以被序列化和反序列化。

序列化会将非临时(non-transient)和非静态(non-static)的属性，输入流。

修饰词修饰不想被序列化的属性：transient，static

自定义序列化

方式1：在类中实现下列方法：

private void writeObject(java.io.ObjectOutputStream stream)throws IOException;

  private void readObject(java.io.ObjectInputStream stream)throws IOException, ClassNotFoundException;

方式2：实现自定义序列化接口：Externalizable

 readExternal

 writeExternal

进程与线程

由于java语言特性，这里主要是提供对线程进行操作的api：Thread，Runnable。

TIPs：这两个类型存在于java.lang包中，而这个包在使用无需引包操作。

Thread

父类：Object

父接口：Runnable->run()

创建：Thread(Runnable target) 

Thread启动线程，线程再执行runnable的run方法。

方法：run()

     sleep()  让当前线程休眠xx毫秒

     yield()  终止当前的运行，从新让cpu进行调度

     join()   等待该线程终止

     setPriority()  优先级，优先级越高cpu执行的几率更大。大10，小1，普通5.

     Object.wait()/Object.notify() wait可以让线程停止运行开始等待，等待notify方法被调用，来唤醒等待线程。wait()方法调用时，会释放当前语句块的锁。

线程的同步问题：java通过互斥锁来实现同步，而互斥锁由对象来实现，java中每个对象都拥有一个独立的互斥锁。

synchronized+一个对象(锁)

对一块代码实现同步操作：

格式：synchronized(锁对象){同步代码}

网络编程api：

TCP

  

  ServerSocket 服务器套接字

  服务器套接字的使用：

  1.创建服务器套接字

  2.绑定ip及端口

  3.监听端口

  4.接收客户端套接字

  5.建立连接，通过流来进行通信

  6.关闭连接

  Socket 客户端套接字

  1.创建套接字

  2.建立连接

  3.通信

  4.关闭连接

UDP

  API:DatagramSocket DatagramPacket

  无所谓服务器或客户端，都是用DatagramSocket发送和接受，数据发送和接受都要依赖于DatagramPacket.

HTTP

  是TCP的应用层协议，广泛运用于当前的web项目中。

  HTTP协议总是客户端请求服务器，服务器响应客户端。

  API:HttpURLConnection