java笔记.docx
《java笔记.docx》由会员分享，可在线阅读，更多相关《java笔记.docx（18页珍藏版）》请在冰豆网上搜索。
java笔记
Javaday01
1.程序：
一组命令构造指令，一组有序的指令构成程序。
2.Java体系：
JAVASEjava标准版，JAVAEEjava企业版（体现在网页设计上）
3.Java虚拟机：
JVM，跨平台使用，软件模拟最小硬件环境、
4.Java运行的步骤：
编写得到java文件，编译得到class文件（二进制字节码文件给jvm虚拟机读取的），运行程序得到结果
Java结构：
publicclass类名{
Publicstaticvoidmain（string[]args）{
编码内容}}
说明：
需要设置类为public类中需要有main类名必须和程序名相同，每个java程序至少有一个main程序。
System.out.println与System.out.print的区别在于ln换行
转义字符：
赋予单词（字母）特殊的意义，\单词\n换行
注释：
单行//，多行注释/***/
编码规范：
编码中要注意的规则
代码建议要缩进：
点击右键，source-formate
代码一定要以；结尾
变量：
存储数据的空间，
变量名，变量为了方便称呼取得名字
变量值，变量的内容
变量类型（数据类型），数据类型决定了内存存储数据的空间大小
11.常见数据类型的分类：
数值型：
整形int，浮点型double
非数值型：
字符型char,字符串型string
12.变量的使用：
变量的声明：
变量类型变量名
变量的赋值：
变量类型变量名=值
13.变量名的命名规则：
变量名必须由字母，数字，下划线”_”,”$”组成，数字不能第一位
建议首字母为小写，后面单词首字母建议大写，不能以关键字作为变量名，作用域中变量名不能重复
预习：
变量类型，强制类型转换，运算符，条件结构
IDE：
Tools.jar:
G:
\app\evil\product\11.2.0\dbhome_1\jdk\lib
Javaday02
1.赋值运算符：
=从右向左
逻辑运算符，&&真真为真，||有真则真，！
真为假，假为真
算术运算符：
+-*/%
比较运算符：
==！
=><>=<=
表达式：
操作数与操作符的组合
2.取余
3.自动类型转换
4.
ASCII码：
65----A90----Z97----a122-----z
5.完整的数据类型
整形：
byte----1字节
Short----2字节
Int-----4字节
Long----8字节
浮点型：
float4字节double8字节
6.布尔类型：
TRUEFALSE
7.If条件结构：
if（布尔结果）{代码}
If条件中，只有一条分支可以执行
8.比较运算符：
>，<,>=,<=,==（判断是否相等），！
=（不等于）
9.逻辑运算符：
&&，||，！
Inta=（（7+8）>4）?
（2+9）:
（4*3）;三元运算符返回结果a=11
10.ifelse：
分支选择只能选择其一连续区间
If-elseif分支中重新开辟新的分支
If嵌套，if分支中重新定义新的分支
字符串比较，接受控制到的字符串sc.next（）,比较字符串使用“结果”.equals（字符串变量）
作业：
编写三元运算符可以被ifelse替代
Javaday03
1.switch（整形或字符型）：
本质是ifelseif，主要用于等值判断
switch（整形或字符型）{
Case常量（整形或字符型）：
代码；break；
}
Case只判断一次，
2.循环：
重复执行的动作（操作）
循环条件：
开始条件，结束条件
循环操作：
重复的动作
循环变量：
为了方便循环改变条件
3.while（条件）{循环体}--------先判断后执行
Do{循环体}while（条件）；------先执行后判断
Javaday04
1.for循环：
用于固定次数的循环
for（初始化循环变量;循环条件；循环变量的改变）{
循环操作}
For当中的；必不可少，for执行顺序：
初始化循环变量（在循环开始前只执行一次），循环条件，循环操作，循环变量的改变
For（）中的初始化，条件，变量的改变都可以不写
For循环中的变量不可以超过for循环本身的范围，如果需要使用for循环中的变量，必须在外面
不定次数：
2.break：
作用于switch与循环中，在循环中中断循环
3.Continue：
作用于循环中，中止当前循环，进入下一次循环
Javaday05
1.数组：
存储相同数据类型的一组数据
2.数组名：
变量名
下标（索引）：
元素在数组中的顺序
元素：
数组中的每一个内容就是元素
数组类型：
数据类型
3.声明数组：
数组类型[]数组名
分配空间：
数组名=new数组类型[数组长度]
赋值数组名[下标]=值
使用数组名[下标]
数组分配是必须要有长度
索引是数组在数组中的顺序编号
数组的初始化：
数组类型[]数组名={值1，值2，。
。
。
。
。
。
}；
数组类型[]数组名=new数组类型[]{值1，值2，。
。
。
。
。
。
}；
4.数组越界：
数组使用的下标超过了超过了最大下标
Week02
Day01
1.多重循环：
循环体内还有其他的循环
2.双重循环：
外层变化一次，内层遍历一遍
3.冒泡排序，选择排序
Day02
1.对象：
用来描述客观事物的实体，由一组属性与方法构成
属性：
对象具有的静态特征，本身具有的信息
方法：
对象具有的动态特征，对象的功能【publicvoid方法名（）{}；
2.类与对象：
类是具有相同属性和方法的对象的集合，类是模板，对象是模板的产出物。
3.Java中的类：
class（java文件）
创建对象：
类名对象名（变量名）=new类名（）；【scannerinput=newscanner（）；】
使用对象：
对象名.属性
对象名.方法（）；
变量：
局部变量，成员变量（属性）
成员变量默认有初始值整形默认值是0浮点型默认0.0字符串默认是null
Day03
1.方法的返回类型：
只需要执行方法不需要返回类型void方法名（）{代码}
需要知道执行之后的结果信息返回类型方法名{代码return返回值}
注意：
方法的返回类型有且只有一种
在void中可以增加return关键字，但return后不能有返回值。
中断方法的执行
2.方法的结构：
访问修饰符（public）返回类型方法名（）{方法体}
3.方法内部调用：
同一类中方法内部之间调用直接使用方法名（），方法不可以嵌套定义
4.方法的调用中，void类型只能单独成行。
方法的内部：
方法都在一个类中
方法的外部：
方法不在一个类中（通过对象名.方法名，调用）
5.成员变量（类的属性）：
作用域在整个类中
局部变量：
作用域在定义的范围内
成员变量与局部变量发生命名冲突，以调用的位置就近原则
6.对类与方法进行注释（文档注释）Alt+shift+J
Day04
1.方法：
参数列表（参数类型参数名，参数类型参数名......）
2.带参数的方法中注意点：
参数类型一定要匹配，参数数量，顺序一定要匹配，参数本身可以被方法当做已经赋值的变量使用，赋值是在参数调用的时候
方法定义中的参数称为形参，方法调用中的参数称为实参（只需要参数里面实际的值）。
实参和形参名可以一致。
Publicvoid方法名（形参.......）
对象名.方法名（实参）；
3.基本数据类型与引用数据类型作为参数的不同
基本数据类型作为参数，是复制自己的值给予形参
引用数据类型作为参数，是让实参与形参指向同一个地址
结果是基本数据类型无法保留参数中改变的值，引用数据类型可以保留参数的改变
Day05
1.String类：
indexOf（）length（）
2.字符串的连接：
+concat
3.判断字符串是否相等：
equalsequalsIgnorecase
比较大小：
Compare（comparetoIgnorecase）
截取：
Substring（起始位置，结束为止-1）
替换：
replace（旧，新）
分割：
split（分隔符）（返回类型是数组）
去空格：
trim（）去两端空格
4.StringBuffer:
append（）添加，字符串变成添加后的字符串
5.插入：
insert（字符，位置）
6.Date:
java.util.*获取当前时间newdate（）;
显示当前时间toString（）,显示本地当前时间toLocalhostString（）
getTime（）获取时间的毫秒数，计算当前时间的前后。
时间1.before/after（时间2），判断前后
Week3
Day01
1.Calendar类比date得到的信息更多，比较灵活
Calendar.getInstancne（）通过get（时间单位）得到对应的时间值
单例：
私有化构造方法，私有的静态对象，共有的方法调用
获取当前时间的月份：
对象.get（Calendar.MONTH）;月份从0开始
时间单位：
Calendar.时间单位
日历转换为日期日历对象.getTime（）;
日期转换为日历日历对象.setTime（）;
2.时间格式化：
importjava.text.SimpleDateFormate
格式化:
对象.format（日期对象）
格式化:
对象.parse（字符串）把字符串转为日期对象
格式化的模板:
（yyyy年MM月dd日hh:
mm:
ss）
3.随机数Random类随机对象.nextInt（可以给定范围）随机的整数（包含负数）
nextDouble随机浮点数0-1之间
4.Big系列：
带小数点的四舍五入的值db1.divide（db2,保留小数位，声明除数的规则）
BigDecimal.ROUND_HALF_UP:
四舍五入
声明：
BigDecimal.roundhalfup
取得商与余数BigInteger
5.正则表达式；匹配字符串的规则
匹配数字/d匹配数字字母下划线/w匹配一个或多个+
Java.util.regex.Pattern匹配的模板
Java.util.regex.Matcher匹配的规则
6.构造方法：
方法名必须和类名相同构造方法没有返回类型，没有void（普通方法也称为实例方法）
7.方法的重载：
同一个类中，方法名相同，参数列表不同
有参的构造方法被定义后，默认的无参构造方法被取消
8.封装：
隐藏信息，
实现封装：
提供公有方法（get/set）访问私有属性
This:
本类对象this.成员变量名，避免重名的问题
this调用构造方法必须放在第一行
Day02
1.继承：
抽取重复的内容形成父类，可以被子类继承
继承的关键字extends父类（超类），子类访问父类的关键字super：
访问父类的属性和方法super.属性或方法名，super（）只能放在调用的第一句
构造方法在继承关系中的调用：
先访问父类的构造方法，
子类完全可以继承父类的“所有”，私有的，访问修饰符权限不允许的，构造方法都不能被继承
当多个类中有重复且反复使用的内容时就可以使用继承
继承优点：
减少代码，增加了复杂度
访问修饰符：
private本类2.单根继承（有且只有一个父类），Object类默认是所有类的父类
3.构造方法中，this和super只能用一个
重写：
子类与父类具有相同的方法名，参数列表要一致（属于面向对象的多态）
父类的访问修饰符权限要比重写的子类访问修饰符范围要小
4.抽象类：
抽象类本身不希望被实例化，希望被继承。
抽象类的关键字abstractclass类名
抽象方法：
abstract返回类型方法名（参数列表）；抽象方法没有方法体
抽象类与方法：
抽象类中未必有抽象方法，但是有抽象方法的类一定是抽象类
抽象类的子类必须重写父类的抽象方法，除非它本身也是一个抽象类
抽象类对象名=new抽象子类（）；//一定要有继承关系，更加灵活使用。
抽象子类代替父类不能使用子类独有的方法
若父子类具有相同方法，调用的是子类
若父类没有的不能使用该对象名调用，应重新给子类实例化一个对象
5.final：
修饰类代表该类不能被继承
修饰方法代表该方法不能被重写
修饰变量代表不能被修改（final变量实际上是常量）
Day03
1.多态：
程序中，同一个引用类型不同的实例，结果也不同（父类引用子类对象）
方法重写。
包装类，类型转换
向上转型：
父类父类对象=new子类（）；
向下转型：
子类子类对象=（子类）父类对象；
2.接口interface：
是一种特殊的抽象类，不要写class，接口中的所有方法默认是公共且抽象的，抽象类的方法可以是抽象也可以是实例的。
接口中的属性是常量，抽象类的属性可以是常量也可以是变量
3.接口不能被实例化，但是可以被实现implements
4.接口可以被多个类实现，抽象类只能被单个类继承
5.接口是一种规范，要求实现类遵循这种规范
6.接口中没有构造方法，没有方法体
7.接口可以多实现，抽象类只能单继承
Day04
1.static:
修饰属性，该属性为全局变量（在所有的对象中都是公用）
2.静态方法不能调用非静态属性和方法
3.静态方法可以直接用类名.方法名，类名.属性名调用
4.Static不能修饰类，构造方法和局部变量
5.代码块优先级：
静态>普通>构造静态代码块只执行一次
6.多个类中，静态代码块是必须执行，普通与构造依赖于
7.单例模式：
构造方法私有化，内部构造静态对象，通过公有静态方法调用，永远只有一个对象存在
8.内部类：
类中类
外部类名.内部类目对象名=外部类对象.new内部类名
Outerout=newOuter（）;
Outer.Innerin=out.newInner（）;
Outer.Innerin=newOuter（）.newInner（）;
newOuter（）是匿名对象
9.方法不能嵌套方法，但能定义一个类，该类中又可以定义方法
10.匿名内部类
Week4
Day01
1.国际化：
通过语言资源文件根据需求切换语言
Java.util.ResourceBundle获取资源文件
Java.util.Local本地化类语言与区域
Java.text.MessageFormate资源信息格式化
2.Arrays的使用，binarySearchfill
3.Timer:
定时器类timer.Schedule（任务，启动的时间间隔）
4.异常：
异常不是错误，异常是对可能发生错误的处理方式，也称为异常机制
Try{可能发生异常的代码块}catch捕获异常（异常类型异常对象）{}
注意：
发生异常，执行catch语句块的内容，不发生异常，不执行catch
Try中发生异常，发生异常
5.多重catch：
只能执行一个catch块，Exception的异常不能放在异常的子类前面。
6.Finally代码块：
是一定要执行的代码块，除非程序system.exit
（1）
7.Throw：
抛出异常（谁调用谁处理）throws声明异常（让调用者知道这里有异常）
8.异常的分类：
Throwable:
所有异常的父类
Error:
严重到程序本身没办法解决的异常死循环
Exception：
非常严重异常，运行时异常runtimeException,检测异常（写好后要求马上处理的异常）
9.自定义异常：
继承自Exception的子类
Day02
1.集合框架：
两大类CollectionMap
集合不需要考虑长度问题
Collection：
不唯一，且无序
List:
不唯一，有序
Set：
唯一，无序
有序：
可使用索引直接标示
无序：
不能使用索引（哈希表）
Map：
一组键值对的数据
2.ArrayList：
长度可变的数组，遍历以及随机访问的效率较高，插入与删除效率较低
LinkedList:
链表结构，遍历以及随机访问的效率低，插入与删除的效率高
Arrayslist：
定义ListArrayList
赋值：
add
删除：
取值：
get（索引）
遍历：
for（inti=0;i<集合名.size（）;i++）
插入：
add（索引，值）
LinkedList:
addFirstaddLastremoveFirstremoveLast
遍历中，取出集合的元素时常常需要转换类型
3.Map:
和collection不是一个接口，map本身是无序的，遍历通过迭代器来实现
Map的添加：
put（键，值）
Map的取值：
get（键）
Map的迭代：
获取map的键的集合map.ketSet（）;通过键的集合set.iterator（）;
Map的删除；remove（键）；
Map中存放对象：
map.put（键，对象名）
4.迭代器：
对集合中的元素遍历的处理
5.泛型：
取值的时候不需要强制类型转换List
6.集合的排序：
Day3
1.Set:
唯一且无序hashsettreeset
2.Vector:
addElementinsetElement
3.Map.Entry:
将map的键值对作为对象处理
4.TreeMap排序键的MapfirstKeyheadMapsubMap（）
重点：
ArrayList有序的，分配的是连续的空间，异步，线程非安全，增长50%
linkedList不一定连续，同步，
Vector同步，线程安全，容量增量一倍
HashTable，旧的，继承Dictionary类，线程安全
HashMap，新的，实现Map接口，线程非安全，键和值组成，键唯一值不唯一
TreeMap可以排序的Map集合，按集合中的key排序
hashMap旧的，实现Map接口，线程非安全【区别是hashmap无序。
Treemap可以排序】
List：
set：
Map：
重点练习：
Map.Entry
5.栈：
先进后出
队列：
先进先出
6.排序比较：
Comparble:
写在比较需要的类中，实现compareTo（）方法【固定写法，只有一种比较的规则】（一个参数）
Comparetor:
写在需要比较的类外面,实现compare方法（两个参数），灵活，可以有多个实现的方式
Collections:
排序之前，一般需要有比较的实现
7.对象的比较:
equals（）hashcode（）
如果没有散列的信息（比如对象存放在有序的数组中）equals
equals相等，对象不一定相等，equals不等，对象一定不等
Day04
1.File:
创建文件creatNewFile（）mikdir（）deleteexistslistFiles
2.IO:
字节流与字符流
Bytechar
写出：
OutputStreamFileOutputStreambyet[]write
WriteFileWritechar[]
读入：
ReaderFileReaderchar[]
3.
Day05
1.XML:
标记语言，特殊格式的字符串具有特定的格式与语义
Person:
xml的标记（元素）
Name:
属性
张三：
属性值
XML：
树形结构
2.DOMSAXJDOMDOM4J
DOM:
原解析，解析的基本原理
SAX：
性能优秀，SAX不需要节点，SAX面向对象解析
SAX比较复杂
JDOM:
整合了DOM与SAX的有电
DOM4J：
具有所有JDOM的优点，而且表现，写法都比JDOM方便
3.线程：
线程是程序执行的一条路径，分支
多线程：
让程序“同时”执行多个任务
一个进程包含多个线程，一个线程属于进程中的一条路径
4.多线程的两种实现方式：
1.继承自Thread类，重写run方法直接调用start
2.实现Runnable接口实现run方法，将实现类作为参数传递给Thread对象，然后调用start
5.
升级会员 