j2se 标准版本（学习的目标）

j2ee 企业版本

j2me 移动版本

搭建环境：

jdk（java 的开发工具包）

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

jdk 下载：oracel 的官网上可以下载到新的 java 版本，现在新的是 java9.在官网上可以找到以往版本的下载。

如果要下载比较老的版本，可以到 csdn 上去找。

下载之后，直接安装。

TIPs：环境变量是否配置，看之后我们使用的集成开发工具是否需要，再添加。

集成开发工具：

eclipse

idea

NetBeans

TIPs:

jdk 和集成开发工具好都是 64 位或 32 位。

Java 特有的语法规则：

1.helloworld

了解基本的 java 程序张什么样子？

并且在未来，从这个程序开始扩展我们的代码，直到形成功能，构建成完整的

程序。

完成 HelloWorld 步骤：

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

(创建文件装在 java 源码)

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

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

3.在第二步编写的内容的花括号中，继续编写：

public static void main(String[] args)

(在类型中定义一个主函数，这个主方法是固定格式，他代表 java 程序运行

的入口。)

4.在第三步编写内容的花括号中，编写输出语句：

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

(这里的输出语句，代表着我们具体的功能代码)

TIPs：.java 代表这个文件是一个 java 的源文件，保存着 java 的源代码。

运行：

1.使用 javac 工具，编译源文件，得到.class 文件。

将 java 源码编译成为字节码。

TIPs：编译：1.将 java 源码转换成字节码

2.编译器会帮助我们检查基本的语法错误。

2.使用 java 工具，运行程序。

java 必须运行在 java 虚拟机上，这里调用的 java 工具，就会帮助我们启动 java 虚拟机，并且运行上一步编译好的 java 字节码文件。

TIPs：为什么要先编译成字节码，再由 java 虚拟机运行？

java 的跨平台能力，而这个跨平台能力就是依托于 java 虚拟机来实现的。sun 公司为不同平台提供了不同的虚拟机，虽然虚拟机不同，但是他们有一个共同点，就是都可以运行 java 程序。

包：用来管理 java 源代码。

命名规则：公司域名倒置 + 工作组的名字 + 工程的名字 （建议都是用小写字母）

TIPs：

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

2.如果 java 源文件在 default 包中（没有创建包），那么可以不写。

快捷键：

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

2.在 eclipse 可以智能补全，alt+/。

属性和方法：

属性，就是定义在类型中的变量，用于表示这个类型拥有什么。

TIPs：属性我们通常只写出声明的语法，赋值操作通常由构造器完成。

构造器：是一类比较特殊的方法，格式：

public 类型名称(参数列表){构造器代码块}

作用：初始化属性的数据值。

访问修饰符

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

公开级别

受保护级别

public protected

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

由 protected 修饰类型，属性，方法可以在任意包子类或者

同包的类中使用。

默认级别

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

私有级别

private

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

static 静态修饰符：

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

静态方法属于类，不需要通过对象调用，直接使用类名调用即可。

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。

多态

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

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

Bird bird = new Penguin();

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

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

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

四大特征： ，抽象。

方法：

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

方法体

return 返回值 1；

}

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

多态：

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

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

型的父类型。

异常：

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

异常输出信息：

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

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

3.堆栈信息

集合框架

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

异常处理机制

1.关键类：Throwable Error Exception

Throwable

父类：Object

父接口：Serializable

直接子类：Error Exception

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

Error

父类：Throwable -> Object

父接口：Serializable

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

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

Exception

父类：Throwable -> Object

父接口：Serializable

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

Exception 表示我们自己编程，导致的错误。这些错误是我们可以弥补补救。

我们可以利用异常处理来将这些错误处理掉，防止停止当前程序。

异常的处理：

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 就不会执行：（父类型异常要

在子类型异常之后捕获）

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

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

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

异常处理方式：

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

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

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

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

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

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

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

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

类型：

class ：具体实现类。

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

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

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

内部类：

在一个类中定义类型：

成员内部类

定义格式：

修饰词 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()获取其中的数据。

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，返回下一级目录和文件的对象。

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(锁对象){同步代码}

1.IO 流：

java.io 包

父类：InputStream/OutputStream 字节流

Reader/Writer 字符流

父接口：closeable flushable

序列化：将对象变成流。

File 类型，操作本地文件系统。

2.线程：

java.lang 包

Thread Runnable

工作流程：Thread.start->本地系统->Runnable.run()

线程调度：sleep() (不会丢弃互斥锁)

wait() (会放弃互斥锁) /notify()

join() 等待另一个执行完毕

yield() 让出 cpu

优先级

互斥锁：基于对象实现的。多个线程要同步需要使用同一个锁对象来锁住指定代码块。

网络编程 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