导图社区 java学习笔记
- 41
- 4
- 2
- 举报
java学习笔记
java学习笔记，适用于预习、复习的参照。适用于考前复习，也可以综合其他资料使用。
编辑于2023-01-11 20:46:50 广东- java学习笔记
- 相似推荐
- 大纲
java学习笔记
Java基础
变量和运算符
数据类型
在Java中，数据类型分为两大类：
基本数据类型：8种基本数据类型
除了8种基本数据类型的变量，其他变量都是引用类型变量。
字符型
char
字符数据类型用于存放单个字符，每个字符占用2个字节（16位二进制）的内存空间，一个字符型数据由单引号括起来，使用"char"关键字来说明数据类型
字符类型是一个16位无符号整数，Java中字符类型的值是对应字符的编码, 是unicode编码，英文部分的值与ascII编码
字符型只表示一个字符，不能表示多个字符，比如'abc'是错的 字符型只能用单引号（'）括起来，用双引号（"）括起来的不是字符，而是字符串（String），比如"a"表示的不是char型字符而是String型字符串。
转义字符
* 转义字符用斜杠"\"打头,后面跟一个字符 * 退格键 \b 表示一次退格 * Tab键 \t 表示一个Tab空格 * 换行符 \n 表示换行 * 回车键 \r 表示回车 * 斜杠 \\ 表示斜杠 * 单引号 \' 表示单引号 * 双引号 \" 表示双引号
布尔型
boolean
布尔数据类型由关键字boolean来表示，布尔型数据的值域只有两个值：true和false。
true和false都是小写 布尔型数据不能用数字0和1来表示真假，只能用true和false； 布尔型数据默认值是false。
数值型
整型
* Java语言的整型常量默认为int型，声明long型后面需加上l或者L，否则会出错。 * 四种表示形式 * 十进制整数：0 ~ 9，注：第一位不能是0 * 十六进制数：0 ~ 9 A ~ F, 注：必须以0x或0X开头 * 八进制整数：0 ~ 7，注：必须以0开头 * 二进制整数：0~1，注：必须以0B开头（在java1.7及以上版本可用） * byte 字节型 1个字节（8位二进制） -128 到 127 * short 短整型 2个字节（16位二进制） -2^15 到 2^15-1 * int 整型 4个字节（32位二进制） -2^31到 2^31-1 * long 长整型 8个字节（64位二进制） -2^63到 2^63-1
浮点型
* Java浮点型常量默认为double型，如要声明一个常量为float型，则需在数字后面加f或F，比如float f = 2.1f； * float 单精度浮点型 4个字节，精度约7位 -3.403E38 ~ 3.403E38 * double 双精度浮点型 8个字节，精度约为17位 -1.798E308 ~ 1.798E308
引用数据类型：存储地址的引用
类
接口
数组
数据类型的转换
Java提供了两种数据类型的转换方式：自动转换和强制转换
自动数据类型转换
自动数据类型转换也称之为隐式类型转换
byte
short
char
int
long
float
* double
强制数据类型转换
强制数据类型转换也称之为显式类型转换
变量=（目标类型）值;
boolean型数据不能和其他基本数据类型进行转换
byte、short、char之间不会相互转换，它们三者在计算时首先会转换为int类型； 在强制类型转换过程中，源类型的值可能大于目标类型，因此可能造成精度降低或溢出
变量
在程序运行中它的值可以发生变化。
变量只有在声明后才有效，声明的作用就是确定该变量要存储的数据类型。 变量在声明后，不能直接访问，只有被赋值的变量才能够被访问。
数据类型 变量名
第一次给变量赋值叫"初始化"
变量名 = 数据值
命名规则
只能包含中文，数字，下滑线，$符号
不能以数字开头
不能以关键字和保留字进行命名
遵循小驼峰命名法
常量
变量值不需要变化的情况，那么这些值不变的变量就叫常量。
用关键字final来表示
final数据类型 常量名 = 初始值;
常量在声明的时候必须初始化，
常量在初始化后值不能再更改，否则会引起错误
运算符
在程序设计中经常会做一些运算，比如算术运算、关系运算和逻辑运算
算术运算符
int m=4; m=m++; System.out.println(m);
原子性
+
加运算符
字符串连接
当操作数中只要有一个是String类型，系统会自动将另一个操作数转换成字符串类型，然后进行连接
-
减运算符
*
乘运算符
除运算符
若是两个整数相除，只保留整数部分
%
取模（取余）运算符
被除数为正数结果都为正，被除数为负数结果都为负
++
自增
变量名++：先用原来的值参与其他操作后，再将自己加1
++变量名：变量在参与其他操作前先将自己加1;
--
自减
变量名--：先用原来的值参与其他操作后，再将自己减1
--变量名：变量在参与其他操作前先将自己减1;
赋值运算符
= 赋值运算符 i=8 8赋值给i
+= 加简捷赋值运算符 i+=8 同i=i+8
-= 减简捷赋值运算符 i-=8 同i=i-8
= 乘简捷赋值运算符 i
=8 同i=i*8
/= 除简捷赋值运算符 i/=8 同i=i/8
%= 取模简捷赋值运算符 i%=8 同i=i%8
关系运算符
关系运算又叫比较运算，用来对两个操作数进行大小、等于的关系比较 真为true假为false
> 大于
>= 大于等于
< 小于
<= 小于等于
== 等于
!= 不等于
逻辑运算符
逻辑运算又叫布尔运算，包括四个运算符，分别是&&、||、！和^，用来进行与、或、非和异或的逻辑运算，逻辑运算的操作数和结果都是布尔类型的值
&&
与运算符 逻辑与
逻辑与 运算符左右两端的操作数都为true，表达式结果才为true，其它情况表达式结果为false
||
或运算符 逻辑或
运算符左右两端的操作数都为false，表达式结果才为false，其它情况表达式结果为true
非运算符 逻辑取反
操作数为true，结果为false；操作数为false，结果为true
三目条件运算符
在三目条件运算中，表达式1和表达式2的值可以是任意一种基本数据类型。
三目条件运算符的语法为：
表达式1 ? 结果1:结果2
运算符的优先级
尽量多的使用括号，括号优先级别最高
按操作数多少划分
一元操作符 > 二元操作符 > 三元操作符
按运算类型划分
算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算符
关于表达式概念
表达式的值：对表达式中操作数进行运算得到的结果称为表达式的值；
表达式的类型：表达式值的数据类型即为表达式的类型；
表达式的运算顺序：应按照运算符的优先级从高到低的顺序进行，优先级相同的运算符按照事先约定的结合方向
流程控制语句
条件语句的使用
条件语句是程序中根据条件是否成立进行选择执行的一类语句
if语句
if语句（单一条件）
如果条件表达式返回真值，则执行功能代码块中的语句；如果条件表达式返回值为假，则不执行功能代码块。
if (表达式) {执行语句块;}
语法说明
if是该语句中的关键字，后续小括号不可省略；
条件表达式返回的结果为布尔型，当返回为真值时才能执行if功能代码；
功能代码块为多行时，应将其放在花括号"{}"中间，当功能代码块为单行时，则不需要花括号；
不论if语句块是单行还是多行，建议都用花括号"{}"括起来；
if()子句后不能跟分号";"。
if语句(二选一)
如果需要返回值为真或假时都执行各自相应操作，就可以使用if-else语句来完成
if(条件表达式){
功能代码块1
}else{ 功能代码块2 }
if-else语句的代码执行过程
当条件表达式返回值为真时，执行功能代码块1，当条件表达式返回值为假时，执行else后面的功能代码2
语法说明
if-else语句的代码执行过程等价于 三目条件运算符。
变量 = 布尔表达式 ? 语句1:语句2
如果布尔表达式的值为true，则执行语句1
如果布尔表达式的值为false，则执行语句2
if语句(多选一)
当条件为多个时，Java提供了专门的多分支if- else if -else语句以实现条件的多重选择
if(条件表达式1){
功能代码块1;
}else if(条件表达式2){ 功能代码块2; }else if(条件表达式3){ 功能代码块3; ... ... }else{ 功能代码块n; }
语法说明
if-else if-else语句的代码执行过程为：
当条件表达式1返回值为真时，则执行功能代码块1；
当条件表达式1返回值为假时且条件表达式2返回值为真时，则执行功能代码块2；
如果条件表达式1、条件表达式2都返回假且条件表达式3返回值为真，则执行功能代码块3，
依次类推，如果所有条件都不成立，则执行else语句的功能代码。
switch语句
switch语句从多种情况中选择一种执行
switch(表达式){
case 取值1: 语句块1; [break;] case 取值2:
......
case 取值n: 语句块n; [break;] default: 语句块n+1; }
语法说明
表达式的类型只能为byte、short、char、int，在Java7中增加了对String类型的支持；
case语句是标号语句，只确定程序的入口；
功能代码部分可以写任意多句；
break关键字结束switch语句，为可选项；
default语句功能类似于if-else语句中的else。
switch语句的代码执行过程
将case语句后的值和表达式的值比较，若相等即从该case语句开始向下执行，如果没有break语句，则一直执行到switch语句的结束，如果遇到break语句，则结束switch语句的执行
循环语句的使用
循环语句
如果某段代码想要反复执行多次，可以使用循环语句
while语句
while(循环条件){
循环体;
while语句的执行流程
首先判断循环条件，如果循环条件为true，则执行循环体代码，然后再判断循环条件，直到循环条件不成立时停止执行。如果首先判断循环条件就为false，则不执行循环体，直接执行while语句后续的代码
语法说明
循环条件的类型为布尔类型，指循环成立的条件；
花括号{}不是必须的，当循环体中只有一条语句时，可以省略；
循环体是需要重复执行的代码
do-while语句
do{
循环体;
}while(循环条件);
语法说明
do-while语句是 "先循环再判断"的流程控制结构。
循环体是重复执行的代码部分，循环条件要求是布尔类型，值为true时执行循环体，否则循环结束，最后整个语句以分号结束；
for语句
for(表达式1;表达式2;表达式3){
循环体; }
for语句的代码执行过程
执行表达式1，实现初始化；
执行表达式2，判断循环条件是否成立，如果循环条件为false，则结束循环，否则执行下一步；
执行循环体；
执行表达式3，完成迭代；
跳转到步骤2重复执行。
语法说明
表达式1用于初始化，一般书写变量初始化的代码，例如循环变量的声明、赋值等，它在for语句中执行且只执行一次。表达式1可以为空；
表达式2是循环条件，要求必须为布尔类型，如果该条件为空，则默认为true，即条件成立；
表达式3为迭代语句，是指循环变量变化的语句，一般书写i++、i--这样的结构。该语句可以为空。
循环体指循环重复执行的功能代码。
花括号{}不是必须的，当循环体部分只有一条语句时可以省略。
死循环
循环语句中如果循环条件永远为真，那么这样的循环就是死循环，
嵌套循环
嵌套循环应用的好，避免了相同代码的重复、以及硬编码，可以进行更好的复用和扩展
循环的中断
break
break语句的作用也是结束循环语句的执行
作用
break语句用于终止某个语句块的执行。用在循环语句体中，可以强行退出循环。
break语句可以出现在while、do...while、for、switch语句体中。
break label语句可以出现在任何语句体中。
带标签的break语句
public class Break_Sample3 { public static void main(String[] args) { label1: for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { System.out.print(j+" "); if (j == 5) { break label1; } } } } }
continue语句
continue语句虽然也完成循环的终止，但与break语句的区别在于：continue语句只跳出本次循环，但还要继续执行下一次循环；
带标签的continue语句
public class Continue_Sample3 { public static void main(String[] args) { label1: for (int i = 0; i < 10; i++) { System.out.print("\n"); for (int j = 0; j < 10; j++) { System.out.print(j + " "); if (j == 5) { continue label1; } } } } } 执行continue语句时，就不再是终止内部循环中的本次循环，而是直接终止外部循环的本次循环，执行i++语句，进入下一次外部循环
数组
遇见数组就遍历
数组是引用类型，具有属性，常用的数组属性就是数组的长度length
数组的长度(length)必须>=0
一个变量存储一组数据·。数据类型必须相同
特点
在内存中开辟连续的空间
储存数据类型是相同的
可以引用存储基本数据类型，引用数据类型
集合只能存入引用数据类型
引用下标，通过下标获取当然位置
下标从0 开始。末尾=长度-1
一维数组
数组是相同类型的数据按照顺序组合后的一种引用类型
数组可以看成是多个相同类型数据的组合，实现对这些数据的统一管理。数组的长度一旦确定后就不能更改，因此它是一个固定长度的结构。数组结构中每个存储的数据叫数组元素，数组元素由索引来定位。索引（或叫数组下标）是指当前元素相对于第一个元素的位移，因此第一个元素的下标就是0，第二个元素的下标就是1
数组的定义
数组声明的语法
数据类型[] 数组名
数据类型 数组名[]
数组的创建
静态初始化
int[] m = {元素1元素2,......};
数组名 = new 数组类型[] {元素1元素2,......};
动态初始化
数组名 = new 数组类型[数组长度];
数组有默认值
数字类型，默认值为0
对于字符型，默认值为‘\u0000' 也就是“”
对于布尔类型，默认值为false
对于对象类型，默认值为null
数组的异常
一种是空指针异常，类名为java.lang.NullPointerException
数组在声明后，但是没有创建前，并没有给它分配具体的内存空间，所以这个时候访问数组会出现NullPointerException异常
数组下标越界异常，类名是 java.lang.ArrayIndexOutOfBoundsException
访问超过范围的下标，就会发生ArrayIndexOutOfBoundsException下标越界异常
数组的操作
数组的复制
Java中的数组的复制使用System.arraycopy方法就可以实现
System.arraycopy(source,srcPos,dest,destPos,length)
复制source数组中从下标srcPos开始的length个元素到目标数组dest，并从目标数组的下标为destPos的位置开始储存 ，其中各个参数的含义如下：
@source： 源数组 srcPos： 源数组中的起始位置
@dest： 目标数组
@destPos：目标数组中的起始位置
@length： 要复制的数组元素的个数
遍历循环
多维数组的内存模型
如果一维数组中的每一个元素也是一个数组，那么就是二维数组。以此类推，还可以有多维数组
数组是存储多个相同类型数据的对象。数组的所有元素保存在堆内存中。 创建一个数组就是在堆中创建一个数组对象。数组创建后立即拥有默认值。索引从0开始。连续分配
方法的定义和调用
方法的定义
方法是程序设计语言中重要的组成部分，可以说程序的功能都是通过方法和方法间的调用来实现的，在面向对象程序设计中，类的方法用来描述类的动作或活动
定义方法就是编写一段有特定功能的代码，在程序中使用同样功能的地方，没有必要重复编写同样的代码，只要调用定义好的方法就可以
方法声明的语法结构
[访问控制符] [修饰符] 返回值类型 方法名( 参数类型 形式参数,参数类型 形式参数,…)
{ 方法体 }
方法的结构
修饰符：修饰符是可选的，它指定了方法的属性并且告诉编译器该方法可以如何调用，public 、static 被称为修饰符（后续会详细讲解它们）。
返回值类型：返回值类型是方法要返回的值的数据类型，例如可以是int，若方法不返回值，则返回值类型为关键字void。
方法名：它作为调用时引用方法的标识。
参数列表：方法可以有一个参数列表，按方法的规范称为形式参数。当方法被调用时，形式参数用变量或数据替换，这些变量或数据称为实际参数。参数是可选的，方法的参数个数可以是0个到多个，每个参数前面要声明参数的数据类型；每个参数要用逗号分开。
方法体：它是一个语句块，执行特定的功能操作。对于有返回值类型的方法，方法体当中最后一个语句是return关键字，它的作用是把方法的执行（运算）结果返回到方法外部。
return 表达式：这里，进一步分析，return后面的表达式就是方法的返回值。需要注意表达式的类型，必须与方法头中声明的“返回类型”相匹配。
方法的分类
根据参数个数
无参方法
有参方法
根据返回值类型
有返回值的方法
根据返回值的类型细分为
* 基本数据类型 * 引用数据类型
无返回值的方法
void
方法的调用
方法只有在被调用后才生效
根据方法是否有返回值，
如果方法返回一个值，对方法的调用通常就当做一个值处理
如果方法返回void，对方法的调用应是当做语句处理
所谓调用方法，其实就是给方法的入口传入一些值（参数），然后在出口得到方法执行的结果（返回值）。给方法传入参数的过程，称为“传参”
形参必须注明数据类型
实参直接写，不需要类型声明 return只能返回一次 遇到return语句，方法结束执行，后续语句不执行 方法的返回值，必须与方法声明中的返回值类型匹配 方法定义，不能写在main()中 方法是不能嵌套的
方法的值传递和引用传值
把对象类型的变量传递给方法和把简单类型传递给方法是有区别的
变量传值
引用类型 传 内存地址
方法的重载
在同一个类中，允许同时存在一个以上同名的方法的现象就叫做方法的重载，也就是说，两个或者两个以上的方法，具有相同的名称和不同的参数列表
方法重载的规则
方法名称相同
2.方法的参数必须不同，参数个数不同或参数类型不同
方法的返回值类型可以相同，也可以不同
面向对象基础
编程思想 面向对象：在开发中关注对象信息和方法 面向过程：在开发过程中关注的事情经过 对象 ：一切客观存在的事物都称为对象 面向对象： 属性：名词：性别，姓名，身高 行为：动词 ：打开：跑，跳，说 类 将具相同属性和行为的一组对象的集合称之为类 类和对象的区别 类是抽象的，对象是具体的 类是对象的集合 必须要将类转化为对象才能操作
类名的定义：大驼峰命名法； 面向对特点{ 继承 封装 javaBeanf 多态 }
类的定义和对象的使用是运用Java语言进行程序设计的核心
类的定义
什么是类
把相似的对象划归成一个类。 在软件设计中，类就是一个模板，它定义了通用于一个特定种类的所有对象的属性（变量）和行为（方法）
类的格式
系统类
系统类就是Java自带的标准类，安装JDK后，在lib目录下
自定义类
类的结构
[public][abstract|final]class 类名[extends父类][implements接口列表] { 属性声明及初始化； 方法声明及方法体； }
关键字class之前出现了多个修饰符
public：表明此类为公有类
abstract：指明此类为抽象类
final：指明此类为终结类
对象的创建和使用
什么是对象
类是创建对象的模板，对象是类的实例
类(class) — 是对某一类事物的描述
对象(object) — 是实际存在的某类事物的个体，也称为实例(instance)
构造方法
什么是构造方法
构造方法是一种特殊的方法，利用构造方法能够初始化对象的属性，构造方法必须与定义它的类有完全相同的名字
Java中，每个类都至少要有一个构造方法
构造方法结构
[修饰符] 类名（参数列表）{
//方法体
构造方法的特点
具有与类相同的名称
不含返回值类型
不能在方法中用return语句返回一个值
一般访问权限为public
如果程序员没有在类里定义构造方法，系统会自动为这个类产生一个默认的访问权限为public且参数列表为空的构造方法。 一旦编程者为该类定义了构造方法，系统就不再提供默认的构造
构造方法是实例化对象时才能调用，不能随意调用
构造方法和普通方法的区别
作用不同 构造方法是为了创建一个类的实例。这个过程只可以在创建一个对象的时候用到。普通方法的作用是为了完成一段业务功能。
修饰符不同 和普通方法一样，构造方法可以有任何访问的修饰：public，protected，private或者没有修饰。不同于普通方法的是，构造方法不能有以下非访问性质的修饰：abstract，final， native，static或者synchronized。
返回值不同 返回类型也是非常重要的。普通方法能返回任何类型的值或者无返回值（void），构造方法没有返回值，也不需要void。
命名不同 构造方法使用和类相同的名字，而普通方法则不同。按照习惯，普通方法通常用小写字母开始，而构造方法通常用大写字母开始。构造方法通常是一个名词，因为它和类名相同；而方法通常更接近动词，因为它说明一个操作
创建对象
声明对象的语法结构
类名 引用 =new 类的构造器（）也可以叫 对象构造器
创建完对象，在调用该对象的方法时，也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫匿名对象
使用对象
对象名.属性名
对象名.方法名
对象创建内存模型
在java中所有的变量、数组、对象都是分配在内存中的，根据变量类型的不同分配的内存也有所不同
内存的类别
栈stack：栈的存取速度比堆快，效率高。在栈内保存基本数据类型的局部变量和对象的引用值。
堆heap：堆可以保存那些对空间要求较大的变量。如对象的属性和数组的元素。在堆内存中开辟空间，只能通过内存分配操作符号new，凡是出现关键字new的地方必定分配了一个堆内存。
我们在实例化一个对象时，同时操作了栈内存和堆内存。在栈内保存对象的首地址，即引用；在堆内存中保存了对象的属性。对对象的所有操作只能通过引用完成，一旦引用出栈释放没有任何引用指向该对象，对象就变成垃圾失效
变量的作用域
变量有作用域，作用域是指变量在程序中的可使用范围
Java中主要有3种类型的变量
局部变量：定义在方法体中的变量；或是方法的形参。
实例变量：即类的属性，也是类内的全局变量。
静态变量：在类中声明为static 的属性
各种类别变量的作用域
类变量：用static修饰的属性，它们在类被载入时创建，只要类存在，static变量就存在
实例变量：类体中声明的属性为全局变量，全局变量在类的整个生命周期中都有效。
局部变量：方法体中声明的变量，方法中的参数，或代码块中声明的变量，都是局部变量，局部变量只在方法调用的过程中有效，方法调用结束后失效
this关键字
引用实例变量
一是方法中的变量与属性重名时
二是在一个构造方法中，调用其它重载的构造方法
三是返回当前对象的引用
引用构造方法
构造方法的this指向同一个类中不同参数列表的另外一个构造方法
在构造方法中，如果要使用关键字this，那么必须放在第一行，否则会导致一个编译错误
垃圾回收机制
使用匿名对象的情况，如果对一个对象只需要进行一次方法调用，Java的垃圾回收机制是自动的，它保证程序健壮的主要手段，同时也避免了回收内存带来的代码繁琐。
垃圾回收机制实际上是JVM内部运行的一个优先级比较低的后台线程，这种多线程的模式使得java 具有更好的性能，完全不用程序员参与。
对象何时变成垃圾呢？
对象的引用被赋值为null
超出生命周期
一次性使用的匿名对象
检查到这些就会调用对象的finalize（）方法进行回收
面向对象高级特性
封装、继承和多态是面向对象的三个基本特征
继承
继承是从已有的类中派生出新的类，新的类能拥有已有类的属性和行为，并能扩展新的属性和行为
子类继承父类的所有属性和方法
子类可以重新定义父类的属性和方法，修改父类的属性和方法
同时也可以增加自己的属性和方法
子类可以添加新的属性和方法，添加父类所没有的；
在Java中，一个类只能有一个父类，不支持多继承
每个类只能有一个直接父类；一个父类可以有多个子类
子类是父类的一种，也可以说“子类就是父类”
子类可以当父类使用
通过关键字extends继承
继承中的构造方法执行顺序
当调用子类的构造方法时，必须先调用父类的构造方法
如果没有调用父类的构造方法，默认在子类的构造方法中的第一句加上super()来调用父类的默认无参构造方法，如果父类中没有无参的构造方法则系统编译出错
然后运行实例变量和静态变量的初始化器
最后才运行构造方法本身
super()的作用是调用父类的构造方法
只能出现在子类的构造方法中，且必须是第一行
super()中的参数，决定了调用父类哪个构造方法
先实例化父类然后实例化子类
如果子类构造方法中没有出现super，那么编译器会默认加上super(),即调用父类的空构造方法
this()的作用是调用本类的构造方法
只能写在构造方法的第一行
同一个构造方法中super()和this()不能同时出现
多态
方法的覆盖、重载与动态绑定构成了多态性
多态是具有表现多种形态的能力的特征，是同一个实现接口，使用不同的实例而执行不同操作
静态联编
它是通过方法重载实现的
动态联编
它是通过继承实现的
优点
简化代码
改善代码的组织性和可读性
易于扩展
封装
使用访问权限修饰符对类的成员进行控制，在java中称为“封装”
封装就是信息的隐藏,隐藏对象的实现细节
隐藏类的实现细节的好处
让使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作
便于修改，增强代码的可维护性
可进行数据检查
构造器访问方法
读取
public 返回值类型 get属性名(){ return 属性名； }
设置
public void set属性名(数据类型参数值){ 属性名 = 参数值；
包的概念
空间划分为更多易管理的块的机制，这种机制就是包
package
import 导入
用途
包允许将类组合成较小的单元
有助于避免命名冲突
包允许在更广的范围内保护类、数据和方法
包可以是类、接口和子包的集合
java 类库中常用的包
java.lang：Java编程语言的基本类库
java.awt：提供了创建用户界面以及绘制和管理图形、图像的类
javax.swing： 提供了一系列轻量级的用户界面组件，是目前Java用户界面常用的包
java.awt.event：图形用户界面事件处理包
java.sql：提供了访问和处理来自于Java标准数据源（通常是一个关系型数据库）数据的类
java.io：提供了通过数据流、对象序列以及文件系统实现的系统输入、输出
java.util：包括集合类、时间处理模式、日期时间工具等各类常用工具包
java.net：提供了用于实现网络通讯应用的所有类
方法的覆盖
子类将从父类中继承下来的方法重新实现，叫做覆盖或者重写，方法覆盖的原因是父类中对应方法的行为不适合子类的需要，因此在子类中进行相应的调整
条件
相同的方法名
相同的参数列表（参数数量、参数类型、参数顺序都要相同）
相同的返回值类型
子类覆盖方法的访问权限要不小于父类中被覆盖方法的访问权限 接下来通过下面的例子来学习一下方法覆盖的应用。
引用数据类型转换
上溯造型
上溯造型，即向上转型指子类转换为父类
自动转换
前提具有继承或实现关系
损失了子类新扩展的属性和方法
仅可以使用从父类中继承的属性和方法
下溯造型
下溯造型，即向下转型称之为强制转换，是将父类对象显式的转换成子类类型
条件
曾经向上转换过的对象，才能再向下转换
instanceof
通过instanceof来判断该经过上溯转型后是哪一个子类的
单例模式要点
public class Singleton { //在自己内部定义自己的一个实例，只供内部调用 private static Singleton instance = new Singleton(); private Singleton(){ //do something } //这里提供了一个供外部访问本class的静态方法，可以直接访问 public static Singleton getInstance(){ return instance; }
某个类只能有一个实例
它必须自行创建这个实例
必须自行向整个系统提供这个实例 单例模式实现方式为
拥有一个私有构造方法
提供一个自身静态私有的成员变量
提供一个公有的静态方法
关键字
静态static
静态方法须注意
静态方法里只能直接访问静态成员，而不能直接访问类中的非静态成员
静态方法中不能使用this、super关键字
静态方法不能被非静态方法覆盖，static不能修饰构造方法
static可以修饰的元素包括：属性、方法和代码块
static修饰的属性称之为静态变量，静态变量是所有对象共享的
static修饰的方法称之为静态方法，静态方法不需要实例化，可以直接访问
static还能修饰静态代码块，一个类中由static关键字修饰的，不包含在任何方法体中的代码块，当类被载入时，静态代码块被执行，且只被执行一次
直接访问：类名.属性
实例化后访问：对象名.属性
final关键字
可以修饰类、方法、属性和局部变量
final修饰的类不能被继承
没必要修改的常量使用
先设置成静态
在设置为final类型
赋值后不能改变
抽象类
创建
[public] abstract class 类名[extends父类][implements接口列表] { 属性声明及初始化； 抽象方法的声明； 非抽象方法声明及方法体； }
定义
修饰抽象类的修饰符有public和默认修饰符两种；
抽象类中可以有抽象方法，也可以有非抽象的方法；
抽象方法是无方法体的方法
定义抽象类时，要在关键字class的前面添加abstract
注意
抽象类不能被实例化；
其包含的抽象方法必须在其子类中被实现，否则该子类只能声明为abstract；
抽象方法不能为static；
在下列情况下，一个类必须声明为抽象类：
当一个类的一个或多个方法是抽象方法时；
当类是一个抽象类的子类，并且没有实现父类的所有抽象方法，即只实现部分；
当一个类实现一个接口，并且不能为全部抽象方法都提供实现时；
接口
[public] interface 接口名 [extends 父接口列表]{ // 属性声明 [public] [static] [final] 属性类型属性名 = 常量值 ; // 方法声明 [public] [abstract] 返回值类型方法名 ( 参数列表 ) ; }
接口是一种用于描述类对外提供功能规范的、能够多继承的、特殊的抽象类
implements 实现接口
class 类名 [extends 父类] [implements 接口列表] { 覆盖所有接口中定义的方法； }
提示
一个类可以同时实现多个接口，但只能继承一个类
类中必须覆盖接口中的所有方法，而且，都是公开的
总结
Java中使用extends关键字实现继承，子类可以继承父类的属性和方法；
在继承关系中，构造方法的调用是先从父类开始；
super代表父类，this代表当前类，要区分this关键字和super关键字；
包(package)是用来保存划分的类名空间；
如果写package语句，那么它必须是文件中第一条非注释语句；
如果写import语句，那么它必须是继package语句后的第一条非注释语句。
可见性修饰符是指定类、方法和属性的访问权限的；
类的可见性修饰符有两种，其中public是包内外都可见，默认的是只能包内可见；
类的成员的可见性修饰符有四种，其中public是包内＋包外可访问，protected是包内＋包外子类可访问，默认的为包内可访问，private是类内可访问；
向上转型（Upcasting）是指子类转换为父类，这是自动转换；向下转型（Downcasting）称之为强制转换，是将父类对象显式的转换成子类类型；
重载和覆盖是多态的两种实现方式。重载方法是提供多于一个方法，这些方法的名字相同，但是参数形式不同；覆盖方法就是在子类定义一个方法，该方法与父类中的方法方法名相同，参数形式也相同，并且返回值类型也相同；
static可以修饰的元素包括：属性、方法和代码块。需要注意的问题是static只能修饰类成员，不能修饰局部变量；
单例模式（singleton）是保证一个类仅有一个实例，并提供一个访问它的全局访问点；
final是一个关键字，可以修饰程序中的多种元素，包括类、方法、属性和局部变量；
使用abstract修饰的类为抽象类，抽象类中可以有抽象方法，也可以有非抽象的方法，抽象方法是无方法体的方法；
.在Java中，接口的声明采用interface关键字，接口不是一个类，没有构造方法，不能被实例化；
接口中只能存在常量和抽象方法；
内部类就是定义在另一个类内部的类。内部类对于同一包中的其它类来说，内部类能够隐藏起来。
异常处理
捕捉异常try
对异常进行处理 catch
无论是否有异常都执行 finally
throws关键字后面，可以跟多个异常，中间用逗号分割
throws关键字抛出的异常，由调用该方法的方法处理。等待有能力的解决
错误问题分为三种
语法错误
逻辑错误
运行时错误
常见工具类
Object
它是所有类的祖先类
public boolean equals(Object obj)
两个引用所指向对象的地址是否相等
public int hashCode()
该方法返回对象的哈希码
哈希码是一个代表对象的十六进制整数
public String toString()
返回对象的字符串表示
包装类
Java中的方法需要将对象作为参数，为了让基本数据类型的这些数据也具有面向对象的特性，Java 编程语言提供了包装类来将基本数据类型看作对象，基本类型和包装类型之间能够互相转换
自动拆装箱的语法，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行
boolean
Boolean
byte
Byte
char
Character
double
Double
float
Float
int
Integer
public static int parseInt(String s)
该方法的作用是将数字字符串转换为int数值
public static int parseInt(String s)
该方法的作用是将数字字符串转换为int数值
public static int parseInt(String s, int radix)
* 转换成几进制
public static String toString(int i)
则实现将字符串按照参数radix指定的进制转换为in
long
Long
short
Short
String
–静态方式（常用）：直接给变量赋值，如：String s1 = "abc"; String s2 = "abc"; –动态方式：使用new运算符动态的给变量赋值，如：String s3 = new String("abc"); String s4 = new String("abc"); 那么这两种方式创建的字符串是同一个字符串对象吗？答案是否定的，这两种方式创建的字符串对象是有区别的
Java中的API，就是JDK提供的具有各种功能的Java类
集合
Collection接口
Collection接口：是集合层次中的一个根接口
Set接口及实现类
Set接口：无序、不包含重复元素的Collection
List接口及实现类
List接口：有序、可包含重复元素的Collection
集合的遍历
迭代器
加强for循环
Map接口及实现类
Map接口：组织映射数据，表示很多数据，每个数据都会包含两部分，一部分是数据，另一部分是键，每个数据称为键/值对（key/value）
相关实现类的比较
泛型的使用
一个泛型类（generic class）就是具有一个或多个类型变量的类。定义一个泛型类十分简单，只需要在类名后面加上<>，再在里面加上类型参数
文件与流
File类
File类的构造方法
public java.io.File(String pathName)
构造方法通过全路径文件名来创建对象，pathName可以是绝对路径也可以是相对的。
public java.io.File(String parent,String fileName)
构造方法通过父目录和文件名来创建对象，fileName是不含路径的文件名。
public java.io.File(File parent,String fileName)
构造方法也是通过父目录和文件名来创建对象，但父目录由一个File对象提供
OutputStream字节输出
所有字节输出流都是OutputStream类的直接或者间接子类
InputStream字节输入流
所有字节输入流都是InputStream类的直接或者间接子类
序列化
将对象写入文件
低级流：FileOutputStream FileInputStream
高级流：ObjectOutputStream ObjectInputStream
对象反序列化
将对象从文件读取出来
ObjectInputStream.readObject()
多线程
继承Thread类
重写run方法
用实例的start方法进行实现
线程运行不确定
只能进行干预
并行
同时执行多条线程
多个内核同时执行
并发
cpu让多条线程交替执行
一个应用程序可以有多个进程
一个进程可以有多个线程
synchronized 为线程加锁保护数据安全
自由主题
修饰符
属性的可见性修饰符
Java中没有全局变量，只有方法变量、实例变量（类中的非静态变量）、类变量（类中的静态变量）。方法中的变量不能够有访问修饰符
[修饰符] 变量类型变量名 [= 变量初始值]；
子主题3
private
只在同一个类
default
统一包的类都可以访问
protected
不同包的子类
public
public公开