从6月25号进入广州传智博客学习基础班，转眼就过去了1个月。每天很辛苦，每天很忙碌，每天很充实！追求北京黑马：
java软件学习的最强训练基地，追求人生的理想的实现，追求自我价值的肯定，我还得努力，坚持，自信，充满斗志！
以下是我这个多月来,在老师指导下，经过自己补充的全面基础笔记。
第一阶段java基础复习1
1. 软件开发基础
1.1 开发软件的目的
提高人个计算机之间的交互方式
1.2 软件
软件 = 数据 + 指令 + 文档
1.3 软件开发
学习指令操作数据并编写使用说明书
1.4 交互方式
1. 图形交互方式
如：QQ thunder
2. 命令行交互方式
如：DOS java
运行 --》 cmd
d:
cd
cd ..
cd \
dir
md
rd
echo "数据" > 文件名
del
cls
exit
1.5 软件的分类
1. 系统软件
2. 应用软件(需要开发的)
2. 计算机语言
2.1 计算机语言
是人和计算机交流的载体
2.2 计算机语言的分类
基于过程的计算机语言
C
面向对象的计算机语言
java
3. java语言
3.1 java语言的介绍
SUN Oracle
詹姆斯.高斯林
1995.5.23日
标记：咖啡和公爵
JDK的发展历史
7.0 --> 1.7.0
3.2 语言的特点
1. 面向对象
2. 扩平台的
3. 编译型语言( C java )
解释型语言( javascript )
3.3 环境搭建
1. 下载
http://www.oracle.com
2. 安装
路径中最好不要出现中文、空格
3. 测试
进入到安装目录\bin 在DOS窗口中输入：
java -version
4. 环境变量配置
4.1 永久设置
4.2 临时设置
set
path： 设置java的开发工具所在的根目录(bin) %java_home%\bin;
classpath： 设置要运行的class文件所在的目录
java_home: 为了避免频繁的修改paht环境变量提出来的。一般为JDK的根目录
5. JDK 、 JRE 和 JVM
JDK : Java开发工具集
JRE ：Java运行环境
JVM ：Java虚拟机，主要用于运行java的字节码(class)文件
JDK > JRE > JVM
6. 程序体验
class HelloWorld{
public static void main( String [] args ){
System.out.println( "hello world!!" );
}
}
编译： javac HelloWorld.java
运行： java HelloWorld
4. java的基础语法
4.1 关键字
length 不是关键字
main 不是关键字
staitc 是
关键字严格区分大小写
保留字： goto
4.2 标识符
java源代码中出现的各种名字(类名、包名、属性名、接口名、函数名、变量名、常量名)。
组成：数字、字母、_ 、 $
约束:
1. 不能以数字开头
2. 区分大小写
类名|接口名： 单词首字母大写
属性名|函数名：从第二个单词开始首字母大写
常量：全部大写，单词之间使用_分隔
包名：全部小写，单词之间使用.分隔。每一个单词代表一个文件夹
是域名的反写。
4.3 常量
正数常量 34
小数常量 34.0
布尔常量 true false
字符常量 '\n' '中' '\u0000'
引用常量 null
4.4 常量的表现形式
十进制 默认 16
二进制 0001 0000
八进制 020
十六进制 0x10 F f
进制之间的相互转换
4.5 变量
主要用于存储可变数据的容器。
4.5.1 数据类型：
1. 基本数据类型
整型
byte 1byte -128~127
short 2byte
int 4byte 默认
long 8byte L
浮点型
float 4byte
double 8byte
布尔型
boolean4byte boolean[] 1byte
字符型
char 2byte
2. 引用数据类型
数组类型
类类型
接口
4.5.2 默认的数据类型
小数： double
正数： int
4.6 注释
对程序进行显示的说明，给开发者看的。
1. 单行注释 // 可以嵌套
2. 多行注释 /* */ 不能嵌套
3. 文档注释 /** */ 不能嵌套 javadoc
4.6 操作符
算术运算符
+
-
*
/ 0正数报错 小数无穷大
% 结果的符号取决于第一个操作数
++
--
byte short char在运算的自动提升为int类型
赋值运算符
=
+=
-=
*=
/=
%=
自动的进行强制类型转换
byte a = 1;
a+=1; a = (byte)( a + 1 )
a = a+1; 报错
比较运算符
==
>
<
!=
<=
>=
结果一定是布尔类型 true false
逻辑运算符
&
|
!
^
&& 当第一个表达式为false时候短路第二个表达式
|| 当第一个表达式为true时候短路第二个表达式
位运算符
&
|
~
^
全部采用数值的二进制补码方式进行运算。
原码：
反码：
补码：
正数的原码即为补码
负数的补码 = 反码 + 1
移位运算符
算术移位
>>
<<
最高位为符号位，当右移的时候最高位补全符号位。
左移的时候右边补0
逻辑移位
>>>最高位补0
4.7 语句
每一条java语言后面需要加;
int a , b ;
顺序语句
判断语句
if(){
}
if(){
}else{
}
if(){
}else if(){
}...
当if或else控制的只有一条语句的时候{}可以省略。
选择语句
switch(){
case 1: 语句
break;
case 2: 语句
break;
default: 语句;
}
switch中可以传递的参数只能是byte short int char 枚举(enum)
原理：
先执行case再执行default与顺序无关
使用细节：
break是否存在
循环语句
while(){
}
do{
}while();
for(;;){
}
当循环的时候如果次数清楚，使用for，如果不明确使用while或do{}while();
其他控制语句
break: 停止循环和选择
continue: 继续下一次循环
都可以结合标签使用。
outer: for(;;){
break outer;
}
4.8 代码块
使用{}包含起来的代码称之为代码块
1. 隔离变量的作用域
2. 将功能相同的语句进行封装
代码块的分类：
局部代码块：在函数中
成员代码块：在类的描述中
构造代码块： 主要初始化对象的属性
静态代码块： 主要初始化静态成员
4.9 函数
封装具有独立功能的代码块。
函数定义的格式：
修饰符 返回值类型 函数名( 参数列表 ) 异常的声明{ // 方法签名
// 具备的功能
return 返回值;
}
函数的调用：
[类名|对象名].函数名(实参);
函数的重载：
1. 函数名相同
2. 参数列表不同
顺序不同
类型不同
个数不同
3. 与方法签名的其他部位没有任何的关系
4.10 数组
数组是用来存储多个相同数据类型的变量的容器。
一维数组：
数组定义：
int [] a = new int[4];
数组初始化：
默认初始化：
new int[4] 0 0 0 0
静态初始化：
new int[]{23,45,67};
{45,576,78}
动态初始化：
for(;;){
a[i] = i+1;
}
数组操作常见错误：
1. 数组的角标越界异常
2. null指针异常
3. 数组一旦声明好不可变
4. 数组的是引用类型变量，如果打印数组名，输出类型@哈希值的十六进制形式
5. []可以放在变量的前或后
数组操作：
1. 遍历
for(; i < a.length ;){
}
2. 求最值
遍历和比较
3. 查找
值查找
索引查找
4. 排序
遍历、比较、交换
5. 反序
两个指针、判断、交换
6. 去除重复值
二维数组：(存储一维数组的一维数组)
定义：
int [][] a = new int[4][]; 必须指定一维数组的长度
a[0] = null
初始化：
a = { {},{} };
for(;;){
for(;;){
}
}
重点练习以下打印几何图形。
5. OOP面向对象编程
5.1 类和对象的关系
is a 继承关系
has a 组合或聚合关系
5.2 类的描述
class 类名{
// 属性(变量)
// 方法(函数)
// 构造函数(函数)
}
5.3 对象的创建
new关键字，在堆中开辟空间，存储对象的内容。
对象的成员访问：
对象.属性名;
对象.函数名(实参);
5.4 构造函数
构造函数是特殊的函数。
1. 函数名和类名一致
2. 调用的时候使用new关键字
3. 没有返回值类型也不能用void
4. 构造函数主要用来初始化对象的属性
5. 构造函数可以被重载
6. 构造函数可以使用this和super进行相互调用
this访问本类中的其他构造函数
super访问父类的构造函数
7. 如果描述一个类没有声明构造函数，那么编译器默认添加一个无参数的构造函数
但是如果开发者自己显示的定义了构造函数，那么编译器不会再创建无参数的构造函数。
8. 子类的构造函数中默认在第一行会调用父类的无参数构造函数，可以显示的调用其他构造函数。
9. 构造函数中调用构造函数的语句只能在第一行位置，所以只能调用一次。
5.5 this关键字
代表具体的一个对象，谁调用就代表是哪个对象。
1. 封装的时候如果在函数中形参和成员属性命名冲突了，可以使用this加以区分。
2. 可以调用本类中的其他构造函数
3. 一定不能在静态上下文中使用this和super关键字
4. 类中成员函数如果访问成员属性默认省略了this关键字
5.6 static关键字
static修饰的内容在类装载的时候就被初始化。主要存储在共享区。
static修饰类：该类只能是成员内部类，如果一个成员内部类中包含静态属性，那么该内部类必须声明为静态的
static修饰属性：多个对象之间该属性共享
static修饰方法：对象共享
static修饰代码块：初始化静态属性
static修饰的内容使用类名可以直接访问，但是也可以通过对象来访问。
5.7 对象的初始化(构造代码块)
1. 属性的声明
2. 属性的默认初始化 正数 0 小数 0.0 布尔 false 字符 '\u0000' 引用 null
3. 显示初始化
4. 构造代码块初始化
5. 构造函数初始化
注意：构造代码块初始化和显示初始化的语句默认会按照出现的顺序加载到构造函数中去，
在构造函数本身代码之前。
5.8 封装
为了提高代码的安全性，描述类的属性和方法的时候需要对属性和有些方法进行封装。
封装的实现：
封装属性：
1. 私有化所有的成员属性
2. 提供publie修饰的get和set方法
在设置方法中可以过滤无效数据。
封装方法：
1. 将函数声明为private，此时该方法只能在该类中被使用。
5.9 继承
主要用于解决类和类之间的数据重复，进而提高代码的复用性。
继承的实现：
class A extends B{
}
类A继承类B
继承的特点：
1. 私有的成员子类无法继承
2. 构造函数无法继承
3. 静态的成员也无法继承
4. 继承只能是单继承
5.10 子类对象的初始化过程(super)
子类对象的初始化会先创建父类对象加以属性的初始化。
子类的构造函数中默认第一条语句super()调用父类的无参数构造函数。
注意：描述一个类的时候，一定要显示的定义无参数构造函数。
5.11 函数的重写
前提：必须有继承
子类可以有和父类完全相同的函数。
函数重写的特点：
1. 函数名和参数列表必须相同
2. 子类的修饰符必须大于等于父类的修饰符
3. 子类的返回值类型必须小于等于父类的返回值类型
4. 子类的异常声明类型必须小于等于父类的异常声明类型
5.12 final关键字
final修饰类、属性、方法、形参
类： 该类不能被继承
属性：是常量
方法：不能被重写
形参：函数中不能被修改，可以打印或使用
5.13 抽象类
当一个类在描述的时候如果不清楚函数的具体实现，那么该函数可以被声明为抽象的，而该类一定要
为抽象类。
abstract class{
// 属性
// 构造函数
// 函数
public abstract void print();
}
抽象类中不一定有抽象方法
但是包含抽象方法的类一定是抽象类。
特点：
1. 使用abstract进行描述
2. 不能被创建对象（实例化）
3. 强制子类必须实现父类没有具体实现的函数
4. 抽象类不能和final关键字一同修饰类
5.14 接口
主要使用接口对类进行功能的扩展。
接口的定义：
interface A{
// 静态常量
public static final
// 公有的抽象方法
public abstract
}
接口的特点：
1. 使用interface创建接口
2. 不能被创建对象
3. 需要子类进行实现 implements
4. 接口中可以相互多继承
5. 实现类可以多实现接口
6. 接口中定义的常量一定要初始化
7. 接口中不能显示的定义静态代码块
5.15 多态
前提：继承 、 重写
表现形式：
父类的引用指向子类的对象
多态下访问对象的成员：
如果子类重写了父类的非静态函数，那么调用该函数的时候一定调用子类的，其他访问的
都是父类的。
多态的应用：
1. 形参
2. 返回值类型
5.16 内部类
将声明在一个类中的类称之为内部类。
内部类的分类：
成员内部类：
静态内部类：当内部类中包含了静态成员
私有内部类：当想要封装外部类的时候
局部内部类：
定义在函数中的类。
局部内部类中只能访问函数中fianl的属性。
内部类可以直接访问外部类的所有的成员。
外部类如果要访问内部类的成员，需要创建内部类的对象。
外部类.内部类 a = new 外部类().new 内部类(); // 创建一个非静态的内部类对象
外部类.内部类 a = new 外部类.内部类(); // 创建一个静态内部类对象
匿名内部类：是一种特殊的成员内部类的简写形式。
abstract class A{
int x = 21;
abstract void add();
}
class B{
class C extends A{
public void add(){
}
}
public void print(){
new C().add();
}
}
简写形式：
abstract class A{
int x = 21;
abstract void add();
}
class B{
public void print(){
new A(){
public void add(){
}
}.add();
}
}
5.17 异常
程序中的不正常情况统称为异常，SUN将程序的各种不正常状态描述为不同的类。
异常的体系：
---| Throwable 实现类
toString() getMessage() printStackTrace()
-----| Error
-----| Exception
--------| RuntimeException
该异常在运行时出现后，开发者可以不用处理，编译器直接通过。
--------| 受检异常
该异常是受检异常，如果程序发生了该异常，必须处理，否则编译报错。
异常的处理：
1. 自行处理
try{ //可能发生异常的代码 }catch( 异常类型 变量 ) { // 异常的处理方式 }
特点：
1. try catch语句块不能相互访问，如果要访问，需要将变量写在代码块的外面
2. catch语句块可以是多条
3. 多态catch语句的时候需要由小到大处理异常，否则报错。
2. 抛出处理
函数内部抛出给函数外部用throw 异常的对象;
函数上使用throws将异常声明给调用者，由调用者处理异常，如果没有人处理，
那么最终抛出给JVM，JVM直接打印异常栈信息。
3. throw和throws的区别
使用位置不同： 函数中 函数外
后面接受的类型不同： 异常对象 异常类型
后面接受的内容个数不同： 一个对象 多个类型
throw同一条件下后面不能出现其他语句。
finally：主要用于释放资源
1. try{} catch(){}catch(){}。。。
2. try{} catch(){}finally{ // 释放资源的代码
if( a != null ){
try{
a.close();
}catch(){
}
}
}
3. try{}finally{}
finally代码块中的语句除了虚拟机退出意外其他任何情况都会执行。
异常的自定义
1. 继承异常父类( 受检异常 )
2. 编写无参和带参数的构造函数
受检异常(非运行时异常)和非受检异常(运行时异常)：
受检异常必须处理
非受检异常可以通过开发者的编程习惯解决掉，所以不用处理。
要掌握常见的受检和非受检异常。
如果一个函数中声明了一个异常，那么一般情况下该异常一定是受检异常。
异常类型的转换：
将受检异常转换为非受检异常
new RuntimeException( 受检异常 )
将非受检异常转换为受检异常
new Exception( 非受检异常 )
5.18 包和导包
包： package 包名; 域名反写
导包： import 包名.类名|*;
* : 不会导入子包中的类。
编译： javac -d class的目录(.) java源文件
运行： java 包名.类名
使用细节：
1. package必须是描述类的第一条语句，且是有一条
2. import可以出现多条，但是尽量不要使用*
5.19 访问控制符
public protected default private
本类 true true true true
同一包类 true true true
子类 true true
不同包类 true
注意：protected不能修饰类。
5.20 JDK常见的开发工具
javac 编译源程序
java 运行字节码文件
javap 反编译class文件
javadoc 生成软件说明书( @author @version @param @return @exception )
jar 打包class文件
压缩：
jar -cvf jar文件名 需要打包进来的文件或目录
查看：
jar -tvf jar文件名 [ > 重定向文件名 ]
解压：
jar -xvf jar文件名 解压在当前目录
注意：可运行jar的制作。Main-Class： 主类
第二阶段Java基础复习
6. 多线程
6.1 线程的概念
程序：下载回来的静态的文件数据集合。
进程：运行着的程序。
线程：程序运行的多条路径。
6.2 线程的模型
CPU Thread
代码 run()
数据 run()使用的数据
6.3 线程的实现
方式一： 继承Thread类，并重写run(), 默认是空实现
class MyThread extends Thread{
public void run(){
// 线程的代码
}
}
方式二：实现Runnable接口，并实现run()
class MyThread implements Runnable{
public void run(){
// 线程的代码
}
}
区别：
1. 如果使用继承方式，该类无法继承其他的类
2. 如果使用继承方式，体现不出面向对象的编程思想
3. 如果使用接口实现，可以多实现其他的接口的同时还可以继承其他的类
注意：
1. 线程的启动
start() 内部调用的是重写的run(){}
2. 如果直接调用run方法，不会以线程的方式运行
3. 一个线程的只能启动一次
IllegalThreadStateException 无效线程状态异常
6.4 线程的生命周期
new start() 抢到CPU run()
新建状态 ---------》可运行状态 -----------》运行态 -----------》终止
| |
休眠时间到| | CPU被抢走/sleep()
|------阻塞状态--------|
6.5 线程的常用方法（Thread）
getName()
getPriority() 1~10 5
currentThread()
getId()
sleep(毫秒值)
join()
Object
wait()
notify()
6.6 线程的安全性问题
线程安全问题： 当多个线程并发访问同一资源的时候，会导致同一资源的数据紊乱，称之为线程安全问题。
解决方案：线程同步
同步实现：synchronized
给调用的同一资源的代码加锁：
1. 同步代码块
synchronized(锁对象){ // java中任意对象都可以最为锁 一般是this
// 需要同步的代码
}
2. 同步非静态函数
public synchronized void add(){ // 默认的锁是this关键字
}
3. 同步和静态函数
public synchronized static void add(){ // 默认的锁是所属类的Class对象 Class 类名.class
}
6.7 死锁
前提：
1. 多线程环境下
2. 每个线程完成任务需要获取多个资源
表现：
线程1拿到可以执行任务的一个资源，想获取第二个资源，但是第二个资源被线程二获取了，
而且线程二想获取完成任务的第一个资源，但是第一个资源被线程一加锁了，所以导致死锁。
实现：
......
避免死锁的算法：
银行家算法
6.8 线程的终止
1. 正常死亡
run()被执行完毕
2. 通过标记变量死亡
run(){
while( tag ){
}
}
tag = false
3. 设置为后台线程死亡
setDaemon(boolean on)
当系统中所有的线程为后台线程的时候，JVM退出。
6.9 线程的通信
1. 锁
synchronized(this)
2. wait() 和 notify()
3. 管道流
PipedInputStream
PipedOutputStream
注意：管道流之间数据通信的时候一定要进行管道的连接 connect()
扫一扫
146
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
