Java

2024-09-19 17:52:01   5  举报





AI智能生成

Java是一种广泛使用的计算机编程语言，由James Gosling在Sun Microsystems开发并于1995年发布。Java是一种面向对象的编程语言，旨在提供"编写一次，随处运行"的功能，使其成为开发跨平台应用程序的理想选择。Java源代码文件通常具有.java扩展名，并在编译后生成.class文件。Java程序可以通过Java虚拟机（JVM）在不同类型的计算机和设备上运行，使其具有高度的可移植性。Java广泛应用于企业级应用程序、Web开发、移动应用程序、游戏开发等多个领域。

Java基础

JavaSE

Java

Java语言程序设计

作者其他创作

大纲/内容

JavaSE

Java语言概述

Java历史

链接

Java版本

 1991年 Green项目，开发语言最初命名为Oak (橡树)
 1994年，开发组意识到Oak 非常适合于互联网
 1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作
 1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最
 1998年，发布JDK 1.2，同年发布企业平台J2EE
 1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生
 2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0
 2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME
 2009年，Oracle公司收购SUN，交易价格74亿美元
 2011年，发布JDK 7.0
 2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本
 2017年，发布JDK 9.0，最大限度实现模块化

Java三大版本

Java SE(Java Standard Edition)标准版

支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核
心API，此版本以前称为J2SE

Java EE(Java Enterprise Edition)企业版

是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如
:Servlet 、Jsp等，主要针对于Web应用程序开发。版本以前称为J2EE

Java ME(Java Micro Edition)小型版

对比C++

舍弃了C语言中容易引起错误的指针

增加了垃圾回收器功能

java语言特点

简单的

面向对象

安全的

分布式

健壮的

去掉了指针

开源

跨平台

Java的虚拟机

jdk: java开发工具包

Java编译器等工具

jre: java运行时环境

Java类库

JVM: Java虚拟机

jdk安装和环境变量配置

JAVA_HOME

path

HelloWorld: 第一个Java程序

编写源代码

打开cmd, 切换到源代码所在目录

javac HelloWorld.java

编译源代码

java HelloWorld

运行java程序

扩展

用public修饰的类，类名一定要和文件名一致，

在一个文件中可以定义多个java类，但是最多只能有一个类用public进行修饰

常见错误

后缀 .java.txt

单词的大小写

中文符号

基础语法

关键字

在java中有特殊含义的单词就是关键字

特点

所有的关键字都是小写字母组成的单词

在特殊的编辑器中能够高亮显示

notepadd++

eclipse

标识符

在java中所有起的名字就是标识符

类名

变量

方法名

包名

语法规范

只能由字母数字下划线 $组成，不能包含其他的特殊字符

数字不能开头

不能起java中的关键字

标识符区分大小分

案例：

#asc

weiwei5

kaven weiwei

3weiwei

public

public5

Public

开发规范

见名知意

遵循驼峰命名法

类命名

每个单词首字母都要大写，其他小写

给方法和变量起名

第一个单词首字母小写，从第二个单词开始每个单词的首字母大写

包

所有字母都要小写

注释

单行注释

多行注释

/*

*/

文档注释

/**

*/

常量

含义

在运行的过程中值不能变化的量叫做常量

分类

字面量

5,10,5.0，true,"weiwei"

自定义常量

没学，后面会学

变量

含义

在运行过程中值可以变化的量叫做变量

说明：

java是一种强类型的语言，也就是说在java中定义的所有变量都要指定数据类型

使用

声明或者是声明的同时赋值

声明

数据类型变量名

案例： int a;

声明的的同时赋值

数据类型变量名 = 值；

案例： double d = 5.5;

同时声明多个变量

int a,b;

两个int型的变量

int a, b = 5;

a变量没有赋值，b变量的值是5

错误写法

int a = b = 5;

b变量没有定义

正确的写法

int b;
int a = b = 5;

赋值

变量名 = 值；

案例： a = 10;

使用

直接通过变量名就可以使用

案例：System.out.println(a);

注意：变量一定是先声明，再赋值，最后才能使用

数据类型和类型转换

数据类型

分类

基本数据类型（8种）

整数

byte

1个字节

-2^7 ~~ 2^7 -1

short

2个字节

int

4个字节

long

8个字节

- 2^ 63 ~~ 2^63 -1

值

2进制

0b1001

8进制

017

表示的数是15

16进制

0xa7

表示167

浮点

float

4个字节

-3.4* 10^38

值要在后面加 F/f

有效位数是6位

double

8个字节

值的后缀是 d，可以省略

有效位数是15位

字符

char

2个字节

值

‘5’

‘s’

'中'

'\u4e2d'

unicode编码

布尔型

boolean

true

false

引用数据类型

除了基本数据类型，剩下的全是引用数据类型

String

数组

java给我们提供的一些类

我们自己定义的java类

类型转换（基本数据类型）

原则

1：布尔类型不能和其他的7种数据类型相互转换

2：其他的七种数据类型之间都可以进行转换

自动转换

在java中把表数范围小的数据类型转换成表数范围大的数据类型，java能帮我们自动完成转换

表数范围从小到大依次为

byte < short < int < long < float < double

char < int < long < float < double

注意：在自动类型转换时，byte不能转换成char类型

byte b = 5;
int i = b;

byte b = 10;
short s = b;

long l = 100;
float f = l;

在进行算数运算时的类型转换

1： byte short char 这三种数据类型，在进行运算时，首先要转换 int类型，再进行运算

错误案例

byte b1 = 5;
byte b2 = 10;
byte b3 = b1 + b2; //这种写法错误，因为byte类型在运算时要转换成int类型再运算，运算的结果也是int类型
b1 = b1 + 20; //这种写法也是错误的，原因同上

正确的案例

byte b1 = 5;

byte b2 = 10;

byte b3 = （byte）(b1 + b2); //这种写法是正确的

b1 += 20; ///java对 += 进行了优化，b1 = (byte)(b1 + 20);
b1++; //这种写法也是中确的相当于 b1 = (byte)(b1 + 1)

2: 表数范围小的数据类型和表数范围大的数据类型运算时，最后结果的数据类型一定是表数范围大的是那个数据类型，如果两个的数据类型相同，运算的结果就是他们的数据类型

强制类型转换

如果我们要把表数范围大的转换为表数范围小的，java不能帮我们自动完成转换，需要我们进行强制类型转换 (数据类型)

错误案例

int i = 5;
byte b = i;

正确案例：

int i = 5;

byte b = (byte)i;

注意：强制类型转换有可能会造成数据溢出

运算符

算数运算符

+ - * / % ++ --

a++

先把a的值拿出来使用，然后在进行加 1

++a

先把a的值拿出来加 1 ，然后再使用加1之后的值

关系运算符

> < >= <= != ==

关系运算符的运算结果一定是布尔类型，一班用在 if语句，循环中

逻辑运算符

&& || !

& | ^

赋值运算符

= += -= *= /=

位运算符

右移，相当于整数除以2

左移，相当于乘以2

其他

（）

优先级

小括号的运算符最高

单目运算符 > 双目运算符

int a = 5;
int b =10;
int c = a + ++b;

算数运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符

boolen b = 7 - 5 > 4+3 && 7 > 6+2

三元运算符

子主题

语句

顺序结构

代码从上到下执行

分支结构

if语句的三种格式

if( 条件表达式){
执行代码块；
}

图片

if( 条件表达式){
执行代码块1;
}
else{
执行代码块2;
}

图片

子主题

if( 条件表达式1){
执行代码块1;
}else if ( 条件表达式2){
执行代码块2;
}
……
else{
执行代码块n;
}

图片

if语句使用说明

条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量

语句块只有一条执行语句时，一对{}可以省略，但建议保留

if-else语句结构，根据需要可以嵌套使用

当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略

当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓

当多个条件是“包含”关系时，“小上大下 / 子上父下”

if语句课堂练习

课堂练习

if语句作业

作业

switch

语法

switch( 表达式){
case 常量1:
语句1;
// break;
case 常量2:
语句2;
// break;
……
case 常量N:
语句N;
// break;
default:
语句;
// break;
}

switch语法规则

switch(表达式)中表达式的值必须是下述几种类型之一：byte ，short，
char ，int，，举枚举 (jdk 5.0) ，String (jdk 7.0)；

case子句中的值必须是常量，不能是变量名或不确定的表达式值；

同一个switch语句，所有case子句中的常量值互不相同；

break语句用来在执行完一个case分支后使程序跳出switch语句块；如
果没有break，程序会顺序执行到switch结尾

default子句是可任选的的。同时，位置也是灵活的。当没有匹配的case时，
执行default

作业

循环结构

说明

在某些条件满足的情况下，反复执行特定代码的功能

循环结构分类

for

语法

for ( ① 初始化部分; ② 循环条件部分; ④ 迭代部分)｛
③ 循环体部分;
｝

执行过程

①-②-③-④-②-③-④-②-③-④-.....-②

说明

②循环条件部分为boolean类型表达式，当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔

作业

1.打印1~100之间所有奇数的和

2.打印1~100之间所有是7的倍数的整数的个数及总和（体会设置计数

器的思想）

3.输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数

字立方和等于其本身。

例如： 153 = 1*1*1 + 3*3*3 + 5*5*5

循环嵌套

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，
for ,while ,do…while均可以作为外层循环或内层循环。

练习

请输出一个4行5列的星星(*)图案。

请输出如下图形
*
**
***
****
*****

在控制台输出九九乘法表

for循环说明

可以初始化多个变量

i++ 可以写成 i = i+2

for循环中的每一项都可以省略，但是分号不能省略，

for循环小括号中的三个语句分别是

初始化语句

循环条件语句

循环控制语句

while

语法

① 初始化部分
while(②循环条件部分)｛
③ 循环体部分;
④迭代部分;
}

执行过程

①- ②- ③- ④- ②- ③- ④- ②- ③- ④-...-②

局部变量的作用域

就是从定义的位置开始，到它所定义的{}结束为止

do while

语法

①分初始化部分;
do{
③ 循环体部分
④ 迭代部分
}while(②循环条件部分);

执行过程

①- ③- ④- ②- ③- ④- ②- ③- ④-...②

说明

do-while 循环至少执行一次循环体

跳转语句：

continue

只能用在循环当中，可以结束本次循环

break

只能用在switch和循环中，用来结束循环或者switch语句

return

可以用在任何语句中，用来结束整个方法

break案例

从1加到100，如果和超过了2000，就退出循环，并打印加到的那个数

无限循环

最简单“ 无限” ” 循环：格式：while(true) , for(;;), 无限循环存在的原因是并不
知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。

案例：循环输入一个数字，统计正数和负数的个数，当输入 0 时，程序结束

作业

扫描器Scanner的使用

导入这个类

创建一个扫描器对象

调用扫描器的扫描方法从控制台把数据读入程序中

数组

概念

地址连续的相同数据类型的数据的集合

为什么需要数组？

对很多数据进行统一的保存和查询等处理

把全班的成绩存起来，一个题看错了，进行统一修改

数组的分类

一维数组

数组的声明

数据类型[] 变量名

int[] a;

boolean[] b;

String[] s;

数据类型变量名[]

int a[];

float m[];

char c[];

数组的创建赋值和初始化

动态初始化

int[] arr = new int[3];

int[] arr;
arr = new int[3];

arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

静态初始化

int[] arr = new int[]{ 3, 9, 8};

int[] arr;
arr = new int[]{5,8,2};

简化方式

int[] arr = {3,9,8};

注意：简化方式只能在声明的时候赋值，不能先声明再赋值

错误写法

int[] arr;
arr = {8,2,5};

练习

从键盘读入学生成绩，找出最高分，
并输出学生成绩等级。
成绩>=最高分-10 等级为’A’
成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’
其余等级为’D’
提示：先读入学生人数，根据人数创建int数组，
存放学生成绩。

数组遍历(依次输出数组中的每一个元素)
数组获取最值(获取数组中的最大值最小值)
数组元素逆序 (就是把元素对调)
数组查表法(根据键盘录入索引,查找对应星期)
数组元素查找(查找指定元素第一次在数组中出现的索引)

基本类型和引用类型的区别

基本数据类型的变量中存放的就是数据

引用数据类型存放的是地址

画图演示

java的内存区域

栈区

堆区

常量池

二维数组

动态初始化

第一种方式

int[][] arr = new int[3][2];

第二种方式

int[][] arr = new int[3][];

错误写法

int[][]arr = new int[][3];

静态初始化

int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

常见异常

ArrayIndexOutOfBoundsException

NullPointerException

方法

含义

方法就是完成特定功能的代码块，其实就是给一段代码起一个名字，方便调用

好处

提高代码的重用性

方便维护

可读性高

可以进行团队开发

语法

[修饰符] 返回值类型方法名([参数数据类型参数名1, 参数数据类型参数名2.....]) {
方法体，也就是调用方法时要执行的代码
}

如果方法没有明确的返回值，则，返回值类型为：void

案例：

定义一个求两数之和的方法

调用方式

单独调用，如果有返回值，这个值就接收不到了

输出调用，可以，但是也不太好，我拿到结果了不一定输出

赋值调用

注意事项

方法不调用不执行
方法与方法是平级关系，不能嵌套定义
方法定义的时候参数之间用逗号隔开
方法调用的时候不用在传递数据类型
如果方法有明确的返回值，一定要有return带回一个值，并且值的数据类型和方法声明的返回类型必须一致

练习

有明确返回值

键盘录入两个数据，返回两个数中的较大值

键盘录入两个数据，比较两个数是否相等

键盘录入三个数据，返回三个数中的最大值

没有明确返回值

键盘录入行数和列数，输出对应的星形

键盘录入一个数据n(1<=n<=9)，输出对应的nn乘法表

方法的重载

在同一个类中，方法名相同，参数列表不相同的方法，称为方法的重载

参数列表不同

参数个数不同

参数的数据类型不同

参数数据类型的顺序不同

注意

方法重载跟返回值没关系，如果两个方法只有返回值不同，不算方法重载

作业

1.定义一个方法，获取某个数组中的最小值
2. 给定一个整型数组，数组成员10个,求该数组中第二大的数的下标
3. 定义数组，存放5个学生的成绩【成绩值自己设定】，将成绩从大到小排序，获得成绩之和，平均成绩，最小成绩，最大成绩
4. 定义一个长度为10的int数组,统计数组中的最大值、最小值、以及奇数和偶数的个数
5. 提取一个方法，将指定数组中的数组元素进行反转
例如：{10,23,2,45,6}—>{6,45,2,23,10}

面向对象编程

面向对象思想概述

面向过程编程，按步骤执行

关注的是类和类的关系

鸡窝可以通过面向过程的方式设计，汽车不行

面向对象开发

就是不断的创建对象，使用对象，指挥对象做事情

面向对象设计

其实就是在管理和维护对象之间的关系

面向对象特征

封装

继承

多态

类和对象

概念

类

对一类事物的描述，是抽象的、概念上的定义

程序设计的目的就是把现实中的事物在计算机中进行描述，就像画家把现实中的风景通过画笔映射到纸上，java中是通过类来描述现实中的事物

现实中的事物进行抽象，现实中的事物都有静态属性和动态的行为

变量

表示现实中事物的属性

方法

表示现实中的行为

对象

对象是实际存在的该类事物的每个个体，因而也称为实例

万事万物皆对象

类和对象的创建

类的创建

创建一个人类

变量

name

age

sex

方法

吃饭(eat)

走路(walk)

显示人员信息（display）

当我们创建完了人这个类，java中就多了一种数据类型，我们管这种类型叫做自定义类型

对象的创建和赋值

类名变量名 = new 类名();

因为这个变量名指向的是一个对象，所以我们也可以叫做对象名

类名变量名;
变量名 = new 类名();

调用变量和方法

变量调用

对象名.变量名;

方法调用

对象名.方法名(实际参数);

练习

定义一个学生类

两个维度

学生练习

定义一个手机类

定义一个矩形的类

画内存图

一个对象

两个对象

成员变量和局部变量区别

在类中的位置不同

成员变量类中方法外

局部变量方法内或者方法声明上（参数）

在内存中的位置不同

成员变量堆内存

局部变量栈内存

生命周期不同

局部变量随着方法的调用而存在，随着作用范围执行完毕而消失，

成员变量随着对象的存在而存在，随着对象的消失而消失

初始化不同

成员变量有默认的初始化值

局部变量没有默认的初始化值，必须先定义，赋值，才能使用

形参的问题

基本类型作为形参

引用类型作为形参

匿名对象

就是没有变量接收的对象

一般很少使用，两种情况下可能会用

对象调用方法仅仅一次的时候

作为实际参数传递

封装

概述

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

属性的封装

将属性设置为私有，通过getter和setter进行访问

方法的封装

对于方法的调用者来说，不用关心方法实现的细节，只要知道

方法的作用

方法名

方法的参数

方法的返回值

private关键字

被private修饰的成员只在本类中才能访问

把成员变量用private修饰
提供对应的getXxx()/setXxx()方法

this关键字

方法被哪个对象调用，this就代表那个对象

应用场景

局部变量和成员变量重名时，通过this访问成员变量

调用其他的构造方法：等讲完构造方法在说

构造方法

特点

构造方法名和类名一致

构造方法没有返回值类型，连void也没有

构造方法只能通过 new 的方式进行调用

作用

创建对象

对成员变量进行初始化

注意事项

如果没有显示的提供构造方法，系统会自动提供一个参数为空的构造方法

如果你提供了构造方法，系统将不再提供

构造方法也有方法重载

可以通过this调用其他的构造方法

课堂练习

创建一个汽车的类，
属性：品牌价格排量颜色最大时速
行为：前进后退加速减速
构造方法：
可以根据品牌和价格进行创建，默认的最大时速：200
也可以根据品牌价格，速度进行创建
还可以根据所有属性进行创建，
没有属性也可以创建

对象的初始化过程

Student s = new Student();在内存中做了哪些事情?

加载Student.class文件进内存

在栈内存为s开辟空间

在堆内存为学生对象开辟空间

对学生对象的成员变量进行默认初始化

对学生对象的成员变量进行显示初始化

通过构造方法对学生对象的成员变量赋值

学生对象初始化完毕，把对象地址赋值给s变量

课堂练习

定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试了Test，进行测试。

定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。

定义一个员工类,自己分析出几个成员，然后给出成员变量，构造方法，getXxx()/setXxx()方法，以及一个显示所有成员信息的方法。并测试。

定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。

static

可以修饰成员变量和成员方法，被static修饰的方法叫做静态方法，被static修饰的变量叫做静态变量，静态变量和静态方法是属于类而不是某个对象

特点

被类的所有对象共享

随着类的加载而加载

优先于对象存在

可以通过类名调用

注意

静态方法只能访问静态的成员变量和静态的成员方法

在静态方法中是没有this关键字的

静态的内容存在于方法区的静态区

静态变量和成员变量的区别

所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对象名调用

main方法中的各个关键字讲解

public static void main(String[] args) {}

public 被jvm调用，访问权限足够大。
static 被jvm调用，不用创建对象，直接类名访问
void被jvm调用，不需要给jvm返回值
main 一个通用的名称，虽然不是关键字，但是被jvm识别
String[] args 以前用于接收键盘录入的

代码块

局部代码块

限定变量生命周期，及早释放，提高内存利用率

用的非常少

构造代码块

多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

静态代码块

在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次

继承

概述

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

关键字： extends

class 子类名 extends 父类名 {}

有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员

案例

通过一个具体案例来演示代码

案例1：学生类和老师。定义两个功能(吃饭，睡觉)

案例2：加入人类后改进。

继承的好处

提高了代码的复用性，多个类相同的成员可以放到同一个类中

提高了代码的维护性，如果功能的代码需要修改，修改一处即可

让类与类之间产生了关系，是多态的前提，其实这也是继承的一个弊端：类的耦合性很强

继承的特点

Java只支持单继承，不支持多继承。

class SubDemo extends Demo{} //ok

class SubDemo extends Demo1,Demo2...//error

Java支持多层继承(继承体系)

class A{}

class B extends A{}

class C extends B{}

注意

子类只能继承父类所有非私有的成员(成员方法和成员变量)

子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。

使用场景

继承中类之间体现的是：”is a”的关系

继承中成员变量的关系

首先在子类局部范围找

然后在子类成员范围找

最后在父类成员范围找(肯定不能访问到父类局部范围)

如果还是没有就报错。(不考虑父亲的父亲…)

super关键字

super的用法和this很像，this代表当前对象的引用，super表示父类对象的引用

用法

访问成员变量

this.成员变量

super.成员变量

访问成员方法

this.成员方法()

super.成员方法()

访问构造方法

this(…)

super(…)

注意

子类中所有的构造方法默认都会访问父类中空参数的构造方法

每一个构造方法的第一条语句默认都是：super()

原因

因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

方法重写

概述

子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写

应用场景

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

注意事项

父类中私有方法不能被重写

子类重写父类方法时，访问权限不能更低

子类方法的返回值类型要和父类方法的返回值相同或者是返回值类型是父类方法返回值类型的子类

@Override

面试题

方法重写和方法重载的区别?方法重载能改变返回值类型吗?

this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

final关键字

概念

最终的意思，可以修饰类，成员变量，成员方法

特点

修饰类，类不能被继承

修饰变量，变量就变成了常量，只能被赋值一次

成员变量

final修饰变量的初始化时机
被final修饰的成员变量一定要给一个初始值，在对象构造完毕前即可

声明时初始化

构造方法初始化

构造代码块初始化

局部变量

被final修饰的局部变量在使用之前要赋值

被final修饰的形参，在方法中不能被修改

修饰方法，方法不能被重写

可以修饰的东西

类

不能被继承

方法

不能被重写

变量

概述

一旦被赋值就不能被修改，所以被final修饰的变量叫做常量

成员变量

创建对象之前进行赋值（原因：成员变量有默认值）

赋值的时机

声明时

构造方法中

构造代码块中

局部变量

声明时赋值

先声明再赋值

形参变量

不能再方法中进行赋值，因为方法的调用者一定会给这个形参传递一个实际的数据

多态

概念

某一个事物，在不同时刻表现出来的不同状态

同一个变量传入的对象不同，执行的代码也也不同

向上转型

猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种，也可以把猫称为动物。
动物 d = new 猫();

父类引用（变量）可以指向子类对象

向下转型

instanceof

判断某个对象的真实类型

instanceof关键字前后的对象和类必须是本类或者要有父子关系，

多态的前提

继承

重写

父类引用指向子类对象

多态的原理

变量的数据类型是动态的，编译的时候变量的类型看左边，执行的时候变量的数据类型看右边

抽象类

为什么要有抽象类

有些类是不应该创建对象的，比如动物类

概念

被 abstract 修饰的类叫做抽象类

子主题

特点

抽象类不能被创建对象，是用来被继承的

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

几个问题

一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

abstract不能和哪些关键字共存

private 冲突

final 冲突

static 无意义

接口

语法

interface 接口名 {}

特点

接口不能实例化

接口中的方法必须都是抽象方法

接口中的变量的默认修饰符是 public static final，也就是静态常量

接口没有构造方法

接口和类的关系

类可以实现接口，关系跟继承类似

接口的子类要么是抽象类，要么重写接口中的所有抽象方法

成员变量

只能是常量

默认的修饰符是 public static final

成员方法

只能是抽象方法

默认修饰符是 public abstract

类与类,类与接口以及接口与接口的关系

类与类

继承关系，只能单继承，但是可以多层继承

类与接口

实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

接口与接口

继承关系，可以单继承，也可以多继承

案例

教练和运动员案例

乒乓球运动员和篮球运动员。

乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关的人员都需要学习英语。

请用所学知识：

分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

邮局案例

包

概念

相当于文件系统中的文件夹，对类进行分类管理

定义方式

package 包名;

多级包用.分开即可

注意

package语句必须是程序的第一条可执行的代码

package语句在一个java文件中只能有一个

如果没有package，默认表示无包名

包名必须和从classpath根路径开始，类的路径一致

开发中包的命名规范

公司域名反写.[模块名].功能名

案例

com.neuedu.controller

控制层

com.neuedu.service

服务层

com.neuedu.dao

DAO层

com.neuedu.po

实体类

com.neuedu.util

工具类层

导入包

import 包名.类名;

import 包名.*

严重不建议

只有java.lang包下的类不用导入，这个包是java核心包

命名

语法规范

符合java的命名规范就可以

多层包通过 . 进行分隔

开发规范

所有字母都要小写

起名时用公司域名的反写

com.neuedu.controller

控制层

com.neuedu.service

服务层

com.neuedu.dao

DAO层

com.neuedu.po

实体类

com.neuedu.util

权限修饰符

图片

权限修饰符

类和类的成员可以用的修饰符

类

默认，public，final，abstract

我们自己定义：public居多

成员变量

四种权限修饰符均可,final,static

我们自己定义：private居多

构造方法

四种权限修饰符均可,其他不可

我们自己定义：public 居多

成员方法

四种权限修饰符均可，fianl,static,abstract

我们自己定义：public居多

内部类

概念

把类定义在其他类的内部，这个类就被称为内部类

举例：在类A中定义了一个类B，类B就是内部类

特点

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

外部类要访问内部类的成员，必须创建对象

内部类可以访问外部类的所有属性，包括私有

内部类分类

成员内部类

特点

可以定义非静态属性和方法

int a = 0;//非静态变量

不可以定义static修饰的属性和方法

static int b = 0;//静态变量【报错！！】

可以定义static final修饰的编译期变量【不用加载类的字节码】

static final int c = 0;//编译期常量，不需要类加载

static final Integer d = new Integer(2);//非编译期常量，需要类加载【报错！！】

成员内部类可以访问外部类的所有属性，包括私有

内外类数据相互访问

内部类访问外部类

直接使用外部类中的成员变量和方法名进行访问

外部类.this.外部类的成员变量和方法

这个是用在子类和父类变量或者方法重名的情况下

每个子类中都有一个引用外部类.this 用来指向外部类对象

外部类的外面访问内部类

访问普通的成员变量和方法

new 外部类对象().new 内部类对象().成员变量

访问静态常量

外部类名.内部类名.变量名

在外部类中访问内部类

直接new 一个内部类的对象，通过对象访问内部类的成员变量和方法

成员内部类对象的创建

在外部类中创建

内部类变量名 = new 内部类()

this.new 内部类

在其他类中创建

外部类.内部类变量名 = new 外部类().new 内部类();

静态内部类

说明

被定义在一个类下，且被static修饰

静态内部类下可以定义静态和非静态的属性和方法

内外类数据相互访问

静态内部类访问外部类

不能访问外部类非静态的属性和方法

访问外部类的静态属性和方法

直接写属性名

外部类.属性名

外部类访问静态内部类的静态变量

内部类.成员变量

外部类.内部类.成员变量

局部内部类

位置

定义在代码块里和方法里的类

说明

类不能被访问修饰符修饰

内部类的成员变量和成员方法能被访问修饰符修饰，不能被sttaic修饰

内外类数据相互访问

内部类访问外部类

在普通方法里的内部类可以访问外部类的全部成员

在静态方法里的内部类只能访问外部类的静态成员

局部内部类只能访问final修饰的局部变量

根本原因：内部类和局部变量的生命周期不同导致的

内部类是类级别的，它不会因为定义在方法里就随着方法执行完毕而销毁，因此，可能会出现方法执行完毕销毁，而内部类还未销毁，内部类访问了一个不存在的局部变量
为了解决这个问题，内部类会把该局部变量备份成为自己的成员变量，表面上是方法中的局部变量，实际上是访问的备份。但是这样必须保持两者一致，也就是局部变量不能发生变化，因此需要加final

外部类访问内部类

在外部类中不能实例化内部类对象，内部类对象只能在该方法中实例化，外部类只能调用该方法

匿名内部类

概念

所谓的匿名内部类就是一个没有显式的名字的内部类

匿名内部类产生的条件

必须要有一个父类或者一个接口进行实现

格式

new 类名/接口/抽象类(){

}

本质

匿名内部类会隐式的继承一个类或者实现一个接口，或者说，匿名内部类是一个继承了该类或者实现了该接口的子类匿名对象。

好处

不用显示的定义一个个的类了

案例

定义一个计算器的接口，里面只有一个计算的方法

interface computer{
public static final int compute(int a, int b);
}

形参和返回值

形式参数

基本数据类型

引用类型

返回值

基本数据类型

引用类型

Java常用类

javaAPI

Application Programming Interface

像接口似的，把类名和里面的方法的说明提取出来，没有源码

Object

概述

类层次结构的根类，所有类都直接或者间接的继承自该类

方法

public final Class getClass()

返回此 Object 的运行时类

可以通过Class类中的一个方法，获取对象的真实类的全名称

public int hashCode()

返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算

不同对象的，hashCode()一般来说不会相同，但是，同一个对象的hashCode()值肯定相同

不是对象的实际地址值，可以理解为逻辑地址值

public boolean equals(Object obj)

public String toString()

返回该对象的字符串表示

它的值等于： getClass().getName() + '@' + Integer.toHexString(hashCode())

由于默认情况下的数据对我们来说没有意义，一般建议重写该方法

手动重写

自动生成

protected void finalize()

不重要，基本不会用

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法

垃圾回收器不会马上回收垃圾，但是我们可以建议它尽快回收垃圾。(System.gc()方法)

主要针对堆内存

protected Object clone()

创建并返回此对象的一个副本，这种克隆机制十分高效，而且二者之间完全隔离

自定义类实现克隆步骤

自定义类实现Cloneable接口，这是一个标记性接口，实现这个接口的类的对象可以实现自我克隆

自定义类中重写Object类的clone()方法

重写clone()方法时通过super.clone()调用Object类的clone()方法来得到该对象的副本，并返回该副本

注意

克隆和两个引用指向同一个对象的区别?

B:Object类clone()方法虽然简单，易用，但仅仅是一种”浅克隆”,它只克隆该对象所有的Field值，不会
对引用类型的Field所引用的对象进行克隆

String

概述

字符串是由多个字符组成的一串数据(字符序列)
字符串可以看成是字符数组

构造方法

public String()
public String(byte[] bytes)
public String(byte[] bytes,int offset,int length)
public String(char[] value)
public String(char[] value,int offset,int count)
public String(String original)

方法

判断功能

boolean equals(Object obj) ; //判断两个字符串是否相等
boolean equalsIgnoreCase(String str) //忽略大小写
boolean contains(String str) 字符串是否包含某个子串
boolean startsWith(String str) 是否以某个字符串开始
boolean endsWith(String str) 是否以某个字符串结尾
boolean isEmpty() 是否空字符串

获取功能

int length() 字符串长度
char charAt(int index) 获取某个下标的字符
int indexOf(int ch) 某个字符的下标
int indexOf(String str) 某个子串的下标
int indexOf(int ch,int fromIndex) 从某个下标开始查找，获取某个字符的下标
int indexOf(String str,int fromIndex) 从某个下标开始查找，获取某个子串的下标
String substring(int start) 从某个下标开始到字符串结尾，截取字符串
String substring(int start,int end) 从某个左闭右开的范围截取字符串

转换功能

byte[] getBytes() 转字节数组
char[] toCharArray() 转字符数组
static String valueOf(char[] chs) 字符数组转字符串
static String valueOf(int i) 整数转字符串
String toLowerCase() 转小写字母
String toUpperCase() 转大写字母
String concat(String str) 字符串拼接

其他功能

替换功能

String replace(char old,char new) 替换字符串的字符，替换所有的旧字符为新的字符
String replace(String old,String new) 替换字符串中所有匹配的子串，不支持正则表达式
String replaceAll(String old,String new) 全部替换，支持正则

去除字符串两端空格

String trim()

按字典顺序比较两个字符串

int compareTo(String str)
int compareToIgnoreCase(String str)

字符串分隔

public String[] split(String regex)

String类练习

把数组中的数据按照指定个格式拼接成一个字符串

举例：int[] arr = {1,2,3}; 输出结果：[1, 2, 3]

字符串反转

举例：键盘录入”abc” 输出结果：”cba”

统计大串中小串出现的次数

woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun”中java出现了5次

面试题

字符串是常量,它的值在创建之后不能更改

String s = “hello”; s += “world”; 问s的结果是多少?

String s = new String(“hello”)和String s = “hello”;的区别?

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3==s4);
System.out.println(s3.equals(s4));
String s5 = "hello";
String s6 = "hello";
System.out.println(s5==s6);
System.out.println(s5.equals(s6));
String s7 = "hello" + "world";
String s8 = "helloworld";
System.out.println(s7==s8);

System.out.println(s7.equals(s8));

StringBuffer

概述

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，
既耗时，又浪费空间。而StringBuffer就可以解决这个问题

StringBuffer和String的区别?

构造方法

public StringBuffer()
public StringBuffer(int capacity)
public StringBuffer(String str)

方法

添加

public StringBuffer append(String str)
public StringBuffer insert(int offset,String str)

删除功能

public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)

替换功能

public StringBuffer replace(int start,int end,String str)

反转功能

public StringBuffer reverse()

截取

public String substring(int start)
public String substring(int start,int end)

练习

String和StringBuffer的相互转换
把数组拼接成一个字符串
把字符串反转
判断一个字符串是否是对称字符串
例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串

StringBulider

方法同StringBuffer

同StringBuffer的区别

StringBuffer线程安全，性能差

StringBulider线程不安全，性能好点

Arrays

概述

针对数组进行操作的工具类。
提供了排序，查找等功能。

成员方法

public static String toString(int[] a)
public static void sort(int[] a)
public static int binarySearch(int[] a,int key)

包装类

概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
常用的操作之一：用于基本数据类型与字符串之间的转换。

基本类型和包装类的对应

int

Integer

byte

Byte

short

Short

long

Long

char

Character

float

Float

double

Double

boolean

Boolean

Integer

进制转换

public static String toBinaryString(int i)
public static String toOctalString(int i)
public static String toHexString(int i)

字符串转int

public static int parseInt(String s,int radix)

int转字符串

public static String toString(int i,int radix)

int a = 5;
String s = a + "";

面试题

Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3 == i4);
System.out.println(i3.equals(i4));
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5 == i6);
System.out.println(i5.equals(i6));
Integer.valueOf(127);
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7 == i8);
System.out.println(i7.equals(i8));

Character

构造方法

public Character(char value)

方法

public static boolean isUpperCase(char ch)
public static boolean isLowerCase(char ch)
public static boolean isDigit(char ch) 判断这个字符是否数字字符 ‘5’
public static char toUpperCase(char ch)
public static char toLowerCase(char ch)

自动拆装箱

JDK1.5以后，简化了定义方式

Integer x = new Integer(4);可以直接写成
Integer x = 4;//自动装箱。
x = x + 5;//自动拆箱。通过intValue方法。

Math

概述

子主题

方法

public static int abs(int a)
public static double ceil(double a)
public static double floor(double a)
public static int max(int a,int b)
public static double pow(double a,double b)
public static double random()
public static int round(float a)
public static double sqrt(double a)

Random

概述

生成随机数

构造方法

public Random()
public Random(long seed)

方法

public int nextInt()
public int nextInt(int n)

日期类型

概述

时间的本质就是通过计算机记录特定的瞬间，从1970年到现在所经过的毫秒数

Date

构造方法

public Date()
public Date(long date)

方法

public long getTime()
public void setTime(long time)
。。。

DateFormat

概述

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间
是抽象类，所以使用其子类SimpleDateFormat

构造方法

public SimpleDateFormat()
public SimpleDateFormat(String pattern)

方法

public final String format(Date date)
public Date parse(String source)

BigInteger

概述

CPU原生提供的整型最大范围是64位long型整数。使用long型整数可以直接通过CPU指令进行计算，速度非常快。

如果我们使用的整数范围超过了long型怎么办？这个时候，就只能用软件来模拟一个大整数。java.math.BigInteger就是用来表示任意大小的整数。
BigInteger内部用一个int[]数组来模拟一个非常大的整数

构造方法

BigInteger(String val)

将字符串转换为BIgInteger类型

BigInteger(String val, int radix)

radix设置进制，默认是10进制

方法

public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)

BigDecimal

概述

和BigInteger类似，BigDecimal可以表示一个任意大小且精度完全准确的浮点数。

构造方法

BigDecimal(String val)

方法

public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
public BigDecimal divide(BigDecimal divisor,int scale,
int roundingMode) scale: 保留几位小数， roundingMode: 四舍五入的模式

Java集合

概述

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类

特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象

和数组的区别

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

Collection接口

概述

Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。
一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。

方法

boolean add(E e)
boolean remove(Object o)
void clear()
boolean contains(Object o)
boolean isEmpty()
int size()
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
Object[] toArray()
Iterator iterator()

子接口

List

概述

线性数据结构

特点

有序

可重复

方法

void add(int index,E element)

E remove(int index)

E get(int index)

E set(int index,E element)

ListIterator listIterator()

实现类

ArrayList

概述

底层维护的是数组

随机查询快

中间插入慢

方法

同List接口

LinkedList

概述

底层维护的是链表

特点

遍历慢

插入快

特有方法

public void addFirst(E e)及addLast(E e)

public E getFirst()及getLast()

public E removeFirst()及public E removeLast()

Set

概述

集合

特点

无序

不可重复

方法

同Colleaction

实现类

HashSet

添加功能底层依赖两个方法

int hashCode()

boolean equals(Object obj)

迭代器

Iterator

概述

对 collection 进行迭代的迭代器

方法

boolean hasNext()
E next()

Map

概述

将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值

方法

V put(K key,V value)
V remove(Object key)
void clear()
boolean containsKey(Object key)
boolean containsValue(Object value)
boolean isEmpty()
int size()
V get(Object key)
Set<K> keySet()
Collection<V> values()
Set<Map.Entry<K,V>> entrySet()

遍历方式

根据键找值

获取所有键的集合
遍历键的集合，获取到每一个键
根据键找值

根据键值对对象找键和值

获取所有键值对对象的集合
遍历键值对对象的集合，获取到每一个键值对对象
根据键值对对象找键和值

实现类

HashMap

概述

键是哈希表结构，可以保证键的唯一性

案例

HashMap<String,String>
HashMap<Integer,String>
HashMap<String,Student>
HashMap<Student,String>

"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

Collections

概述

针对集合操作的工具类

方法

public static <T> void sort(List<T> list)
public static <T> int binarySearch(List<?> list,T key)
public static <T> T max(Collection<?> coll)
public static void reverse(List<?> list)
public static void shuffle(List<?> list)

泛型

概述

就是将数据类型作为变量

计算器类

分类

泛型类

把泛型定义在类上

格式:public class 类名<泛型类型1,…>

注意:泛型类型必须是引用类型

泛型方法

把泛型定义在方法上

格式:public <泛型类型> 返回类型方法名(泛型类型 .)

泛型接口

把泛型定义在接口上

格式:public interface 接口名<泛型类型1…>

异常类

概述

异常就是Java程序在运行过程中出现的错误。

异常由来：问题也是现实生活中一个具体事务，也可以通过java 的类的形式进行描述，并封装成对象。其实就是Java对不正常情况进行描述后的对象体现。

异常结构

Throwable

Error

错误，虚拟机发生的错误，程序没法处理

Exception

RuntimeException

运行时异常

可以不用处理

其他子类

检查异常(编译时异常)

必须要进行处理

常见异常（举例）

数学异常

数组下标越界

空指针

两大类异常

所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常

编译时异常

Java程序必须显示处理，否则程序就会发生错误，无法通过编译

运行时异常

无需显示处理，也可以和编译时异常一样处理

异常处理的方式和抛出异常

try catch finally

当前方法进处理

throws

定义功能方法时，需要把出现的问题暴露出来让调用者去处理。那么就通过throws在方法上标识。

throw

在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

Throwable中的方法

getMessage()

获取异常信息，返回字符串

toString()

获取异常类名和异常信息，返回字符串

printStackTrace()

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

throws和throw的区别

throws

用在方法声明后面，跟的是异常类名

可以跟多个异常类名，用逗号隔开

表示抛出异常，由该方法的调用者来处理

throws表示出现异常的一种可能性，并不一定会发生这些异常

throw

用在方法体内，跟的是异常对象名

只能抛出一个异常对象名

表示抛出异常，由方法体内的语句处理

throw则是抛出了异常，执行throw则一定抛出了某种异常

我们到底该如何处理异常呢

原则

如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws

区别

后续程序需要继续运行就try

后续程序不需要继续运行就throws

finally的特点作用及面试题

finally的特点

被finally控制的语句体一定会执行

finally的作用

用于释放资源，在IO流操作和数据库操作中会见到

自定义异常

继承

Exception

RuntimeException

注意事项

子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)

如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常

如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

IO流和File类

File类

概述

文件和目录路径名的抽象表示形式

构造方法

public File(String pathname)

public File(String parent,String child)

public File(File parent,String child)

方法

创建功能

public boolean createNewFile()

public boolean mkdir()

public boolean mkdirs()

删除功能

public boolean delete()

判断功能

public boolean isDirectory()
public boolean isFile()
public boolean exists()
public boolean canRead()
public boolean canWrite()
public boolean isHidden()

基本获取功能

public String getAbsolutePath()
public String getPath()
public String getName()

高级获取功能

public String[] list()
public File[] listFiles()

IO流

概述

IO流用来处理设备之间的数据传输
上传文件和下载文件
Java对数据的操作是通过流的方式
Java用于操作流的对象都在IO包中

分类

按照数据流向

输入流读入数据

输出流写出数据

按照数据类型

字节流

字节输入流基类

InputStream

字节输出流

OutputStream

字符流

字符输出流基类

Writer

字符输入流基类

Reader

注意

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。

字节文件流

FileInputStream

构造方法

FileInputStream(File file)
FileInputStream(String name)

方法

public int read()
public int read(byte[] b)

代码

字节流复制练习

把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

把c:\\a.txt内容复制到d:\\b.txt中

把e:\\林青霞.jpg内容复制到当前项目目录下的mn.jpg中

把e:\\哥有老婆.mp4复制到当前项目目录下的copy.mp4中

FileOutputStream

构造方法

FileOutputStream(File file)
FileOutputStream(String name)
FileOutputStream(String name, boolean append) append为true，表示追加

方法

public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)

复制

代码1

代码2

字节缓冲流

概述

通过定义数组的方式确实比以前一次读取一个字节的方式快很多，所以，看来有一个缓冲区还是非常好的

既然是这样的话，那么，java开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。

为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?

原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

字节缓冲输出流：BufferedOutputStream

代码

字节缓冲输入流：BufferedInputStream

代码

复制

代码

转换流

OutputStreamWriter 字符输出流

public OutputStreamWriter(OutputStream out) 根据默认编码把字节流的数据转换为字符流
public OutputStreamWriter(OutputStream out,String charsetName) 据指定编码把字节流数据转换为字符流
把字节流转换为字符流。

代码

InputStreamReader 字符输入流

public InputStreamReader(InputStream in)
public InputStreamReader(InputStream in,String charsetName)

代码

复制

代码

字符流

FileWriter

FileReader

字符缓冲流

BufferedWriter

BufferedReader

操作基本数据类型的流

DataInputStream

DataOutputStream

代码

序列化流（对象流）

概述

对象序列化是将对象状态转换为可保持或传输的过程。一般的格式是与平台无关的二进制流，可以将这种二进制流持久保存在磁盘上，也可以通过网络将这种二进制流传输到另一个网络结点。
对象反序列化，是指把这种二进制流数据还原成对象。
使用transient关键字声明不需要序列化的成员变量

序列化流：ObjectOutputStream

反序列化流：ObjectIutputStream

代码

设计模式

枚举类

概述

枚举类型是Java 5中新增特性的一部分，它是一种特殊的数据类型，之所以特殊是因为它既是一种类(class)类型却又比类类型多了些特殊的约束，
但是这些约束的存在也造就了枚举类型的简洁性、安全性以及便捷性

说明

枚举类的理解：类的对象只有有限个，确定的。我们称此类为枚举类

当需要定义一组常量时，建议使用枚举类

如果枚举类中只一个对象，则可以作为单例模式的实现方式

自定义枚举

无成员变量

代码

带成员变量

代码

java定义的enmu关键字进行定义

枚举类型Week中分别定义了从周一到周日的值，这里要注意，值一般是大写的字母，多个值之间以逗号分隔

无参数枚举类型

一周

四季

定义变量

代码

定义方法

代码

开发环境

IDEA

idea常用配置

设置

进入设置页面

settings: 针对某个项目进行设置

file-----settings

default settings: 针对所有项目进行设置

flie---- other settings ---- default settings

设置的目录介绍

Appera......

外观和行为

keymap

快捷键

plugins

插件

version controller

版本控制

Build,Execution,Deployment

构建，执行，部署

Lanauage,......

语言和框架

Tools

工具集

配置

设置主题

Appearance

Theme

设置窗体及菜单的字体及字体大小

Appearance

设置鼠标滚轮修改字体大小

Editor - General

Mouse选项组下的 change font size ....... 勾选

设置鼠标悬浮提示

Editor - General

other选项组下的show quick documentation ...... 勾选

设置自动导包

Editor - General--auto import

java选项组----Insert imports on paste选择 All

Add unam..... 勾选

在我们书写代码的时候自动帮我们导入需要用到的包。但是对于那些同名的包，还是需要手动 Alt + Enter 进行导入的

Optimize....... 勾选

书写代码的时候自动帮我们优化导入的包，比如自动去掉一些没有用到的包

设置显示行号和方法间的分隔符

Editor - General -- Appearance

show line number

Show method separators

显示方法分隔线。这种线有助于我们区分开方法，所以建议勾选上

忽略大小写提示

Editor - General -- Code completion

Case Sensitive completion 选择 none

IntelliJ IDEA 的代码提示和补充功能有一个特性：区分大小写。如上图标注所示，默认就是 First letter 区分大小写的。
区分大小写的情况是这样的：比如我们在 Java 代码文件中输入 stringBuffer， IntelliJ IDEA 默认是不会帮我们提示或是代码补充的，但是如果我们输入StringBuffer 就可以进行代码提示和补充。
如果想不区分大小写的话，改为 None 选项即可

设置取消单行显示 tabs 的操作

Editor - General -- edit tabs

show tabs in single row 取消勾选

如上图标注所示，在打开很多文件的时候，IntelliJ IDEA 默认是把所有打开的文件名 Tab 单行显示的。但是我个人现在的习惯是使用多行，多行效率比单行高，因为单行会隐藏超过界面部分 Tab，这样找文件不方便

设置默认的字体、字体大小、字体行间距

Editor – Font

设置自动编译

Build,Execution,Deployment-----compiler

Builder project automatically 勾选

compile independent modules in ...... 勾选

破解码

快捷键

CTRL + ALT + T 把选中的代码放在 TRY{} IF{} ELSE{} 里
* CTRL + / 单行注释
* CTRL + SHIFT + / 多行注释
* CTRL + D 复制本行（不需要选中），选中一段CTRL + D复制本段相当于CTRL + C 然后 CTRL +V
* 10.fori 递增循环
* 10.forr 递减循环
* arr.for增强for
* iter 自动生成增强for 循环
* 10.var 生成 = 左端
* itit 自动生成iterator 迭代
* home将光标移动到行尾
* end 将光标移到行首
* F2 或Shift+F2 高亮错误或警告快速定位
* SHIFT+ENTER 另起一行
F2不管用，就加上FN键 FN的作用就是消除你电脑自定义F2属性