java详细笔记

[color=red]chp1基础[/color]
1、 java语言运行的机制：首先计算机能够直接运行的是计算机指令
计算机指令：一方面与操作系统有关，即Windows系统和linux系统下的指令不同，另一方面跟计算机的硬件有关系，不同的CPU有不同的指令集，直接操作计算机指令，使用的是机器语言以及汇编语言
计算机的高级语言：认为规定的一些语法，然后在遵循这种语言的前提下，写出一个文本文件，最后利用某种方式，把文本文件转换为机器指令进行执行。
编程指的是编写文本文件的这个部分，这个文本文件称谓源文件。
把一个源文件转化为机器指令有两种方式，一是编译型，一是解释型。
编译型：源文件-----》编译器-----》可执行文件----》运行可执行文件------》机器指令
解释型：文本文件----》解释器------》直接翻译成机器指令
Windows中可执行文件一般以.exe为后缀名
java语言兼有编译型和解释型两种语言的特点。java语言运行采用的是先编译后解释的方式运行。首先，java源代码要写在后缀名为.java的源文件中，然后通过一个编译器，变异成.class文件（二进制字节码文件）。
.java源文件----》编译-------》.class字节码文件--------》解释器----------》真正的机器指令。
运行在不同平台上的.class文件内容相同，与所在平台无关。.class文件保存的是一些虚拟的计算机指令，在解释执行.class文件的指令是，需要一个java虚拟机（JVM）.
java语言运行机制：先解释后编译
.java源文件------》编译----》.class字节码文件-----》在JVM中解释执行-----》真正的机器指令
2、 名词解释：
JRE：java的运行环境，包括JVM和java解释器，只能完成从.class到真正的机器指令这一步
JDK：java开发工具包
JDK = JRE + 工具（编译器、调试器、其他工具。。。。）+类库；
安装JDK还需要一些环境变量的配置，配置之后才能进行java程序的开发。
java的三个环境配置：java—home：寻找java安装路径，JDK安装目录
PATH：java安装路径/bin目录
CLASSPATH：“.”
先安装JDK，点击我的电脑，属性，高级，环境变量
运行快捷键：Windows键+R
第一个输入java
第二个输入java_version 版本
第三个输入javac 编译
四、 命令行窗口常用命令：
1、 更换盘符：d:
2、 查看盘符内容：dir
3、 进入文件夹:cd文件夹名称
4、 返回上一级:cd..
5、 清除：cls
6、 删除文件：del文件名称
7、 删除文件夹：rd文件夹名称
8、 新启Dos终端:start
9、 退出exit
五、 第一个应用程序：
1、 创建以.java结尾的源文件
2、 class类
3、 class名称：自定义
4、 main:主函数，主方法，程序入口
5、 输出语句（区分大小写
6、 一行只写一句代码,以;结尾
7、 编译：javac 源文件名称.java
8、 运行 java类名
六、 类的实际用法和阐述
1、 在一个源文件中，可以定义多个类，编译后每个类都会有自己的字节码文件
2、 在一个类中，只能有一个主函数，但是每个类可以有自己的函数
3、 在一个源文件中，只能有一个公开类，类名与文件名必须完全相同
七、 Package
1、 作用：管理类，区分类
2、 语法：package 包名； 必须是源文件的首行
3、 eg: package cn.com.project;
4、 带包编译：java_d.源文件名称.java 自动生成目录结构
5、 带包运行：java 全名.类名
6、 Import 引入包
八、 编写规范
1、 良好的注释习惯
1、 注释不参与编译
2、 单行注释//
3、 多行注释/* */
4、 文档注释/** 注释内容*/ javadoc _d.A.java
2、 良好的格式控制
1、 层次要有缩进 Tab键
2、 一行只写一句代码
3、 不省略; {} () []
3、 良好的标识符命名规范
1、 硬性
a) 字母，数字, _ ，$
b) 数字不能开头
c) java对大小写敏感，严格区分大小写
d) 不能用关键字命名
2、 软性
1、 望文生义，见名知义
2、 类名可以有一个或多个单次组成 首字母大写（帕斯卡命名法）
3、 方法、变量可以有一个或者多个单次组成，首单词首字母小写，拼接词首字母大写（驼峰命名法）
4、 包名全小写，只可以使用特殊字符，并且不以开头或结尾
5、 常量全大写，多个单次用_拼接
九、 变量
1、 概念：一个数据存储空间的表示，他也是存储数据的基本单元
2、 语法：权限声明 数据类型 变量名；
3、 赋值：权限声明 数据类型 变量名；
变量名 = 值;
4、 声明并赋值：权限声明 数据类型 变量名= 值;
5、 同时声明多个变量：权限声明 数据类型 变量名；
变量名 = 值;
变量名 = 值;

6、 数据类型
1、基本数据类型
1、 整数型：byte short int long
2、 小数型: float double
3、 字符型: char
4、 布尔型: true flase
2、 引用数据
1、 string 字符串 无限制
2、 object 对象
3、 Array 数组
十、 类型转换
1、 自动类型转换（两种类型相互兼容，目标类型大于源类型）
2、 强制类型转换 （两种类型相互兼容，目标类型小于源类型）
3、 eg:
1、 整数的长度合适，数据完整 short s=（short）128;
2、 整数长度不合适，数据截断 byte b = (byte) 128;
3、 小数转换成整数，数据截断 int I = (int) d;
4、 字符整数互换，数据完整 char c = (char) I;
5、 boolean不可转换
十一、表达式
1、概念使用运算符连接的变量或者字面值，并可以得到一个最终结果
2、自动类型提升：
1、两个操作数，有一个为double,运算结果提升为double
2、没有double,有一个float，自动提升为float
3、没有float,有一个为long,自动提升为long
4、没有long,有一个为int,自动提升为int.
十二、运算符
1、 算术运算符： + - * / % ++ --
2、 赋值运算符： = += -= *= /= %=
3、 关系运算符： > < >= <= == !=
4、 逻辑运算符：
&&：与，并且：两个表达式同时为真，结果为真
||：或，两个表达式有一个为真，结果为真
！：非。string.equal();
5、 三元运算符：布尔表达式？结果一：结果二；如果布尔表达式为真则等于结果一，为加则等于结果二。

[color=red]chp2条件分支结构[/color]
一、 选择结构
1、 基本if选择结构
if (布尔表达式){
//逻辑代码
}
2、 if else 选择结构
if (布尔表达式){
//布尔表达式的结果为真时，执行次代码
}else{
//布尔表达式的结果为假时，执行此代码
}
3、 多重if选择结构
if (if (布尔表达式1)){
//布尔表达式1的结果为真时，执行次代码
}else if (布尔表达式2){
//布尔表达式2的结果为真时，执行此代码
}else{
//否则
}
[color=orange]注：[/color]条件相互排斥，当有一个条件满足时，其余的均不再执行，适用于区间判断，并且这些条件的顺序是升序，降序。
4、 嵌套if选择结构
if(外层布尔表达式){
if(内层布尔表达式){
//内层逻辑代码
}
}
5、 分支语句
switch(byte/short/int/char){
case 1:
//操作；
break;
case 2:
//操作；
break;
default:
//操作；
break;

}
[color=orange]注[/color]：适用于等值判断，类型为byte/shortint/char.在JDK7.0后可以判断string,所有的case取值不能相同，当某个条件满足时，并不会自动结束整个分支结构，需要增加break跳出循环。

二、局部变量
1、声明在函数内部的变量，先赋值后使用。
2、作用范围，定义开始到定义的代码块结束。
3、避免命名冲突。
三、控制台输入
1、java.util.Scanner类（扫描仪）
//导入包
import java.util.Scanner;
//声明Scanner变量
Scanner imput = new Scanner(System.in);
//使用Scanner类中对应函数（区分数型）
------整型 ------》int i = imput.nextInt();
------字符串------》String s = imput . next();
------字符 ------》char c = imput.next().charAT();
------小数 ------》double d = imput.nextDouble();
2、随机数Java中随机数的生成:
//导入包
import java.util.Random
//声明Random变量
Random r = new Random();
int a = r.nextInt(100): a 0-99的随机数

[color=red]chp3 循环控制[/color]
循环结构
一、概念：通过某个条件，使得某一段代码周而复始的执行
二、组成：初始部分，循环条件，循环操作，迭代部分
三、循环分类
1、while循环：
特点：先判断，后执行
应用场合：循环次数明确
while(布尔表达式){
//循环操作
//迭代部分
}
2、do while循环：
特点：先执行后判断（首次没有入口条件）
应用场合：循环次数不明确
do{
//循环操作
//迭代部分

}while(布尔表达式)
3、for循环
特点：先判断，后执行
应用场合：循环次数明确
for(初始部分，循环操作，迭代部分){
//循环条件
}
四、流程控制
1、break：终止，跳出switch或者循环结构
2、continue：结束本次循环，进入下一循环
五、嵌套循环
1、概念：在一个循环当中，嵌套另外一个完整的循环
2、图形归纳：在打印图形时，外层循环控制行数，内层循环控制列数
3、其他：外层循环控制次数，内层循环控制单次循环操作
4、循环Label标签
5、三重循环，效率低

[color=red]chp4 函数[/color]
函数
函数概念：实现特定功能的一段代码，可重复使用
函数定义：
一、语法：【public static】 返回值类型，函数名（形式参数列表）｛//函数主体｝ 【】里面的东西可以省略 最终的返回值要和返回值类型相匹配
二、 组成：
1、 函数名称：望文生义（驼峰命名法）
2、 函数主体：逻辑代码，完成特定功能
3、 形参列表：可声明一个或多个形参，即是函数的局部变量，只有声明，没有实现。
4、 实参列表：函数调用出，匹配形参列表中的变量，进行赋值
5、 返回值类型：基本数据类型，引用数据类型，void
6、 返回值：
1) return 值； //结合当前函数，并伴有返回值，返回到函数的调用位置，如果产生多条执行路径，必须保证每条执行路径都具有类型匹配的返回值
2) return单独出现，代表结束当前函数，并返回调用位置
3) 规定：一个函数只能有一个返回值
三、 调用
1、 无参调用：函数名称（）；
2、 函数名称（实际参数列表）；//赋予实际值
类型、个数、顺序与形参列表完全一致
3、 数据接收： 数据类型 变量名 = 函数名称（实参列表）；
当调用具备返回值的函数，使用变量存储其结果
4、 执行机制：调用函数时，程序会跳到函数位置，并优先执行函数内部内容，函数之行结束时会携带返回值回到调用位置，继续执行。
四、 总结
1、 一个类中可以定义多个函数，函数之间属于并列关系，不可嵌套
2、 减少冗余代码，提高复用性，提高可读性，提供可维护性，方便分工合作
五、 递归
1、 将大问题拆分成小问题，解决方式相同，有一个固定规律，函数中调用自己。
2、 避免无穷调用
[color=red]chp5 数组[/color]
一、 概念：一组连续的存储空间，存储多个相同类型的值
二、语法：
1、数据类型 [] 数组名//声明数组 int[] arr; arr = new int[5];
数组名 = new 数据类型[长度]; //分配存储空间，并初始化
2、数据类型 [] 数组名 = new 数据类型[长度];
//声明并分配空间 初始化
int [] numbers = new int[3];
3、 数据类型 [] 数组名 = new 数据类型[]{值1，值2。。。。}
4、 但是不能写成这样
int numbers[];
numbers = {100,200,300};
正确的写法是： numbers = new int[]{100,200,300};
5、 数据类型 [] 数组名=｛值1，值2，值3｝；
显示初始化，必须声明在同一行，否则无法通过编译
6、 数组的下标从0开始
7、 数组的默认值
1基本数据类型
int 0
double 0.0
char ‘\u0000’
Boolean false
2引用数据类型
String null
other null
二、 数据的访问
1、 index （索引下标） 有效值：0-----lenth-1；
2、 数组名[索引] 进行鼠族元素的访问；
3、 遍历：从头到尾逐一访问数组元素
4、 长度：数组名.length //获取数组长度
三、 应用
1、 数组的扩充
引用类型的变量名存的是地址
1、 声明：在原数组长度的基础上，重新声明新数组
2、赋值：
1) 、通过循环将原数组中所有元素逐一赋值给新数组元素
2) System.arraycopy(原数组名，原数组起始位置，新数组名，新数组起始位置，长度)； 需先创建新数组
3) dateType[] a = java.util.Arrays.copyof(原数组名,新数组长度); 创建包含原数组元素的新数组
注：java.util.Arrays.copyof(原数组名,新数组长度);完全可以表示一个数组了，也可以写成dateType[] a = java.util.Arrays.copyof(原数组名,新数组长度);
2、 增删元素
1) 将插入位置起的所有元素，依次后移一位
2) 将删除位置后的所有元素，依次前移一位
3、将数组中所有元素倒置
1、 倒置需要元素对调次数： 数组.length / 2 次
2、 对调元素： 数组[ i ] -- 数组[ lenth-1 - i ]
3、 异常
数组下标越界异常：
java . lang . ArrayTndexOutofBoundsException
4、 排序
1) 冒泡排序
相邻的两个数的大小，互换位置（升序：前小后大，降序：前大后小）
b.外层lenth-1 内层 lenth-1 - i
2) 选择排序
固定值与其他值
.外层lenth-1 内层 j = I + 1 ;
3) 自动排序
java.util.Arrays.Sort(数组名)//升序排序
如需降序排序，使用数组元素倒置
5、 二维数组
[color=red]chp6 面向对象基础[/color]
一、 一切客观存在的事物都是对象，类是对象的集合，模板。对象是由类产生的。对象是类的实例，对象是由小对象组成的。类是一个或多个类似的对象具有相同的属性和行为。
一、 面向对象思想
1、 一切客观存在的事物都是对象，万物皆对象
2、 对象一定具备自己的特征（属性）和行为（方法）。
3、 将数据及数据的操作作为一个整体存放在一起，相互依存不可分割的整体
4、 从面向过程编程（从过程开端入手，逐一完成功能）到面向对象编程（分析，构建对象，以多个对象所具备的功能合理调用协同完成功能）。
二、面向对象的特点
1、高内聚：在一个模块中，各个元素彼此结合的紧密程度。指一个软件模块是由相关性很强的代码组成，只负责一项任务，单一职能原则
2、低耦合：也叫块间练习，模块之间的紧密程度。各个模块可独立存在，彼此间不存在必然联系，使用时通过组合来完成任务
3、重用性：不必开发重复的代码
5、 扩展性：重新组合，添加
三、类
1、概念：在多个相同或类似的对象中，抽取出共性的特征和行为，保留所关注的部分
1. 类是对象的集合【模板】
2. 组成：
1、 属性：数据类型 变量名；
成员变量（实例变量）声明在类的内部，当通过当前类构建对象时，所有成员变量都成为当前对象不可分割的特征。写在类中，代表属性。
2、 方法：访问修饰符 返回值类型 方法名 （形参列表）｛//方法主体｝
局部变量 成员变量
定义位置 方法或方法内的结构中 类的内部，方法的外部
默认值 无默认值 字面值（与数组相同）
适用范围 从定义行到包含其结构结束 从定义到本类结束
命名冲突 不允许重名 可与局部变量重名，局部变量优先。
注：如成员变量的声明和赋值分开，则赋值语句必须写在结构内部
int a ; //成员变量
a = 10; //类中不能出现逻辑代码
3、 构造方法：
1、 名称与类名完全相同
2、 没有返回值类型
3、 创建对象时，触发构造方法的调用，不能通过引用手动调用
注：
1、 在类中，如果没有显式定义构造方法；则JVM默认提供无参的构造方法。
2、 如手动添加了构造方法，则无参构造不在默认提供，需个人手动添加。
3、 构造方法也可以重载，多个构造方法要遵循重载的规则
4、 创建对象时，没有传入任何参数，系统会调用无参构造方法
5、 创建对象时，传用实参，则调用匹配的构造方法。
6、 创建对象的同时，为各个属性赋值。Student s = new Student(“张三”,18,”男”);
四、 对象
1、 概念
对象是类的实例，具有多个特征和行为的实体
2、 创建对象
1、 分配空间：栈空间分配变量空间，堆空间分配对象空间
2、 初始化属性：1基本数据类型初始值为字面值 2 引用数据类型初始值为null
3、 构造
五、 方法重载（over load）
1、 概念：方法名称相同，参数列表不同（类型不同，个数不同，顺序不同）
2、 作用：屏蔽使用差异，使用时方便灵活
六、 this关键字
1、引用（当前实例）：当成员变量和局部变量重名时，优先使用局部变量，如需要使用成员变量，应增加this关键字，如：this.name ; this sex;
2、在构造方法中使用，必须在构造方法的首行，在构造方法的内部使用this()或this(实参列表)访问同类中的构造方法。
七、方法参数传递规则
1、基本数据类型为值传递（值的副本），两者间任何一方更改，不影响另一方。
2、引用数据类型为引用传递，（地址传递），两者间任何一方更改会应影响另一方。
[color=red]chp7面向对象三大特性[/color]
一、 封装
1、 概念：尽可能隐藏对象的内部实现细节，控制用户对类的修改和访问的程度及权限
2、 POJO（简单的java对象）：
1私有的属性2公共的访问方法（）；（set/get前缀）3无参构造方法
3、 实现
1) 私有属性：private修饰属性名称
2) 公共方法：public修饰对应的get/set方法
3) 访问形式：
封装前 封装后
赋值 s．age = 18; s.setAge(18);
取值 s.age; a.getAge();
二、继承
1. 类与类之间满足 is a 的关系： 子类（派生类）是一个父类（超类 基类）。
2. 将多个类中共性的特征和行为定义在父类中，实现重用
3. 原则：功能越精细，重合点越多，越贴近直接父类，
功能越粗略，重合点越小，越贴近对象（object） 子类。
4. 继承语法：class 子类 extends 父类｛｝
5. 产生继承关系后，子类可以使用父类的属性和方法，从而提高代码可扩展性
6. java是单继承，一个类只可以有一个直接父类，但可以多级继承，形成树状结构
7. 继承关系初始化：构建子类对象时，先创建父类对象
1) 分配空间
2) 初始化父类属性
3) 执行父类构造方法
4) 初始化子类属性
5) 执行子类构造方法
8. super
1) 在子类中通过super访问父类的属性和方法，
2) super() ，super(实参)显示调用父类的构造方法，必须在子类构造方法的首行
3) 子类构造方法中，如果不显示添加super()，系统默认添加。
9. 不可继承
1) 构造方法
2) private修饰的属性和方法
3) 非同包时以default修饰的属性和方法，不可继承
4) 只有public和default修饰类名，不带表访问权限
本类 同包 非同子类 其他
private 
default  
prodected   
public    

10. 方法的重写
当父类定义的方法无法满足子类需求时，可在子类中声明和父类完全相同的方法进行覆盖
修饰符要求和父类一直，或者比父类权限更宽泛
三、多态
1、概念：父类引用只想子类对象，从而产生多态
编译后，父类引用仅可调用自身声明的属性和方法，不能调用子类独有的方法。
实际运行过程中，优先调用子类重写的方法，如没有重写，调用父类的方法
2语法：
父类类型 应用名称 = new 子类类型（）；
3、应用方式
使用父类作为方法形参实现多态
使用父类作为方法返回值实现多态
4、 作用：
1) 多态应用与参数和返回值，屏蔽子类之间的差异
2) 灵活、耦合度低
3) Class cast Exception
5、 向上转型（装箱） 向下转型（拆箱）
1、父类引用中保存子类真实实例，为向上转型
2、2、父类引用中保存子类真实实例，强制转换为子类类型，为向下转型
3、向下转型时，如子类真实类型与目标类型不匹配，发生类型转换异常。


6、

[color=red]chp8 三个修饰符[/color]
一、 satatic
1、 静态属性（类属性）：所有对象共有的
1) 全类共有的属性，不属于某个实例对象
2) 访问静态属性，可以使用类名.静态属性名，
2、 静态方法（类方法）
1) 全类共有的方法
2) 访问静态方法可以使用类名.静态方法名
3) 静态方法不能直接访问非静态的属性，方法
（因为静态方法是没有对象是可以用的，而非静态方法是创建对象时才会有的
除静态成员外，所有成员都隐式包含this或super前缀。如需访问，需要实例化对象，通过引用访问。）
4) 非静态方法能直接访问静态的属性，方法
5) 静态方法可以继承
6) 所有引用调用静态方法时，转换成类名调用。
Super s = new Sub();
s.test; test为静态方法时，转换成super.test()调用的仅仅是引用的静态方法
3、静态代码块
1) 类加载的时候调用一次，不能手动调用
2) 类加载：JVM首次使用某个类时，需要通过CLASSPATH查找
首次对象（new 对象） 调用静态成员
将类的描述信息包括属性，方法加载到内存中，进行保存
3）优先加载： 类加载时，可谓静态属性赋值，或任何程序必要的初始行为。
4类的加载顺序
1) 父类静态属性
父类静态代码块
2) 子类静态属性
子类静态代码块
3) 父类实例属性
父类动态代码块
4) 父类构造方法
5) 子类实例属性
子类动态代码块
6) 子类构造方法
二、抽象Abstract
1修饰类：不能创建对象
2修饰方法：只能有方法声明，但不能有方法的实现（必须包含在一个抽象类中）
3作用：强制多态
3、 注意：1抽象类中不一定要有抽象方法，而抽象方法的一定是抽象类
2子类继承抽象类后，必须实现父类所有的抽象方法，否则子类还是个抽象类
三、final
[color=red]chp9抽象类和接口[/color]
抽象类是继承中的父类，但与普通的父类不同，因为其不能创建对象，只能通过子类创建对象进行使用。
含有抽象方法的类被定义为抽象类。
但是抽象类不一定必须含有抽象方法，如果一个类中没有抽象方法，也可以被声明为抽象类。
抽象类：修饰符 abstract class{}
抽象方法：修饰符 abstract 返回值类型 方法名(); 只有声明，没有方法体。普通方法的方法体在抽象方法中用;表示。
继承抽象类的子类要么是抽象类，要么复写（实现）继承的抽象方法成为普通类执行。
继承抽象类的子类创建对象的使用一般结合多态。


接口：interface
定义了调用对象的标准。纯粹(特殊)的抽象类，只有抽象方法，并且全部是抽象方法。（不写abstract，在接口中默认为抽象方法。）
接口中的方法为public权限，因为接口可以多继承，所以必须为公共权限，供所有子类子接口实现或继承。子接口或子类方法必须为
public 权限。
接口一般用子类来实现implements,类似于继承中的extends(特殊的继承)，要实现必须要复写成员方法
一个子类可以实现implements多个接口/一个子接口可以继承extends多个接口/接口支持向上转型。
[color=red]chp10进程和线程[/color]
进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。
一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索
new Thread(){}.start(); 调用thread 对象的run方法
new Thread(new Runnable(){}).start(); 调用runnable的run方法
[color=red]chp11集合[/color]
list set map 集合

set,list父接口：collection; map父接口map
set： 无序 不能重复
list: 有序 重复存入
map： 键值对 key不可重复
[color=red]chp12io流[/color]

字节流：inputStream outputStream
字符流:inputStreamReader outputStreamWriter
文件流:filrStreamReader FileStreamWriter