java培训笔记.docx
《java培训笔记.docx》由会员分享，可在线阅读，更多相关《java培训笔记.docx（28页珍藏版）》请在冰豆网上搜索。
java培训笔记
java区分大小写
类名开头要大写
set查看环境变量
setclasspath=c:
\windows设置临时变量
一个java源文件是一个编译单元，会将其中的所有类编译
如果没有public修饰的类的源文件，其源文件名称可以随意起
如果源文件中有一个类用public修饰，则源文件名与该类名相同
charc='J';单引号
单行注释//
多行注释/**/
文档注释/***/放在共有类，或者共有方法上面，隐藏细节，又体现功能
0x开头表示16进制
0开头表示8进制
+可以作字符串连接符，也作数学运算符
循环名称
out:
for（）
inner:
for（）
{}
breakout;
数组：
int[]ii;//声明数组
ii=newint[10];//创建
ii[0]=1;//初始化
声明
创建
初始化
publicstaticvoidmain（Stringarg[]）
System.out.println（arg[1]）;获取参数
javatestabc
全局变量（类变量）不用初始化就可以使用
局部变量（方法里的变量）必须初始化，否则编译出错
voidfunction（）{
return;}
void函数加return语句是合法的
voidfunction（Stringstr）//方法的签名只要签名不同则编译通过方法名加参数
打回车直接换行不影响编译
构造方法前面只能加关键字public也没有返回值
ClassName.FunctionName（）;//静态方法调用
ClassNameobjectName=newClassName（）;//创建对象
publicstaticvoidfunction（）注意关键字的顺序
重载构造方法以后必须调用重载后的构造方法，否则报错
包的命名规则.qbe.projectName
F:
\temp>javacom.qbe.Product运行带包的类文件
F:
\temp>javac-d.Product.java指定存放类文件的目录自动根据包名创建目录
java.util.Random;
java.util.*;
javac-d.*.java编译当前目录中的所以java文件
类中，静态方法无法访问非静态的变量或者成员因为类名可以直接调用类方法，所以类方法不能调用非静态变量
成员的访问控制：
成员方法和成员变量都有下面四个修饰符
public同一个类，同一个包中的类，其他包中的类，子类
private同一个类子类不可以继承
protected同一个类，同一个包中的类，子类
default同一个类，同一个包中的类
类的访问控制：
public所有类
default同一个包中类
成员方法的定义：
修饰符返回值类型方法名（参数列表）
构造方法的定义：
修饰符方法名——与类名完全一致（参数列表）
重写了构造方法以后，若想调用虚拟机自动提供的默认构造方法必须显示声明！
游离代码化，每创建一个对象都执行一次
{
}
最先执行，在构造函数执行前就执行了。
完成一些变量赋值操作
静态代码化：
static
{}
当虚拟机加载这个类时运行，并且只运行一次！
做准备工作
1先静态变量初始化，2再执行静态代码块（类加载时执行一次），3一般的变量，4再执行游离代码块（每次创建对象都执行），5再执行构造方法
类的复用：
1.组合：
新的类中创建已有类的对象例：
类A由类B的对象组成hasa
2.继承：
按照现有类创建新的类isa
成员变量的隐藏：
当父类与子类的成员变量相同时
子类调用重写后（父类与子类的方法签名相同）的方法
方法重写：
如果在子类中定义一个方法，其名称、返回值类型及参数签名正好与父类的相匹配，则子类方法重写父类方法，又称覆盖父类方法。
并且权限不能降低如果父类的
方法是静态的，则不可以被子类重写即使子类的方法也是静态的，也不可以重写！
子类方法不可以抛出比父类方法更多的异常！
方法重载：
在一个类中，多个具有方法名称相同，参数列表不同的方法，形成方法重载，与返回值，权限无关。
父类的引用可以指向子类的对象
子类的引用不能指向父类的引用，除非强制类型装换，勉强通过编译，但不能运行
静态方法不可以被继承
super（）显示的调用父类的无参构造方法，虚拟机默认加载到父类构造方法中
this（）调用当前对象的无参的构造方法，可以放在有参数的构造器中
子类在创建对象时默认调用父类的无参构造方法
子类对象创建时一定先创建了父类的对象，因为调用父类的构造方法和继承了父类的一些成员变量。
final加在类前面：
类不能被继承
final加在方法前面：
方法不能被重写和重载
final修饰的变量成为常量。
方法只能调用不能改变。
起一个变量保护的作用
不带方法体的方法叫做抽象方法publicabstractvoidtest（）;
含有抽象方法的类叫做抽象类publicabstractclassMan可以包含不抽象的类，也可以没有抽象类
抽象方法必须包含在抽象类中
从抽象类继承来的子类必须重写父类的抽象方法，否则该子类也为抽象类
抽象类不能创建实例，因为抽象类的抽象方法没有方法体，不是一个完整的类
抽象类的引用可以指向子类对象
绑定：
将一个方法调用同一个方法主体联系起来叫做绑定.调用的方法确定了。
前期绑定：
编译时已经绑定
后期绑定:
执行时才确定方法体是什么。
运行时绑定多态一个概念
Class是一种高级数据类型
接口：
只有抽象方法
抽象类:
可以有抽象方法也可以有非抽象方法
非抽象类：
全是非抽象方法
instanceof检测指定对象是否为被测对象sinstanceofString
08.09.12
构造方法可以用private修饰，只是在此类外面就无法用此方法构建对象用于实现单例或单态例子：
publicClassPerson
{
privatePerson（）{}
PrivatestaticPersonp=newPerson（）；
PublicstaticPersongetsignalPerson（）{returnPerson；}
用==比较这样的Person对象时返回TRUE返回的hashCode也是一样的默认的equals（）与==相同的比较方法即内存地址
}
能用接口的地方就不要用类
接口是可以多继承的如：
Publicinterfaceyyextendsrunnable，serialized{}但类是不可以多继承的
接口内的成员变量应该在接口确定后就不能改变,所以为publicstaticfinal型的反编译查看
协变返回类型水果：
苹果，香蕉返回子类或其实现的对象
内部类：
将一个类的定义放在另一个类的内部编译生成Outer+$+Inner.class可以解决java中不能多继承的缺点
在main方法中创建内部类的对象
Outerout=newOuter（）;//创建外部类的对象
Outer.Innerin=out.newInner（）;//用外部类的对象创建内部类的对象
其他方法中可以直接用内部类定义对象
如果是静态的内部类则：
Outer.Innerin=newOuter.Inner（）;
System.out.println（this.id）;//在内部类引用内部类的成员变量
System.out.println（Outer.this.id）;//在内部引用外部类的成员变量
内部类引用外部类：
Outer.thisOuter.this.nameOuter.this.function（）
非静态内部类被外部类当作非静态成员使用，所以可以用四个修饰符修饰：
protected，public，private，default
在外部类创建内部类的对象可以直接这样创建，如下：
publicvoidgo（）
{
Innerinn=newInner（）;
inn.fun（）;
}
在方法里的内部类：
局部内部类
publicclassOuter{
publicFruitfun（）{//定义一个Fruit方法
classAppleimplementsFruit{//Fruit是一个接口，有抽象方法showFruit（）
publicvoidshowFruit（）{
System.out.println（"我是水果：
苹果"）;
}
}
returnnewApple（）;
}
publicstaticvoidmain（Stringarg[]）{
Outerout=newOuter（）;
（out.fun（））.showFruit（）;
}
匿名类：
b.addActionListener（newActionListener（）{
publicvoidactionPerformed（ActionEvente）
{
}
}）;
ActionListener是一个接口创建一个没有名字的ActionListener的实现类的对象
基于实现的多态：
接口并有实现类实现接口中抽象方法接口的引用可以指向实现该接口的类的对象！
基于继承的多态：
继承重写父类的引用指向子类的对象
静态内部类：
用static修饰的内部类，表示与外部类没有联系Outer.Innerin=newOuter.Inner（）;创建静态内部类的对象
throwable:
错误error硬件问题
异常exception检查时异常一定要处理否则编译不通过
运行时异常runtimeexception可以不处理编译没问题，存在风险
finally{用于释放资源等操作}
范围小的异常类放在代码的前面，首先得到匹配
多处代码抛出相同的异常，只需要捕捉一次就可以了
publicvoidrun（）throwsArithmeticException（）此方法抛出异常给调用此方法的对象
catch（ArithmeticExceptione）
{
System.out.println（"捕捉到"）;
throwe;//将捕获的异常再次抛出
}
try不能单独出现可以跟多个或零个catch至多一个finally
如果一个方法可能出现检查异常，要么用try…catch捕获处理异常，要么用throws抛出异常，否则导致编译错误。
自定义异常：
继承exception异常，默认为检查时异常.一般含有两个构造方法：
子类抛出的异常不能比父类方法抛出的异常多
一个是无参的publicMyException（super（）;）{}，一个是有参数的publicMyException（Stringmsg）{super（msg）;}
publicString（Stringoriginal）初始化一个新创建的String对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。
由于String是不可变的，所以无需使用此构造方法，除非需要original的显式副本。
参数：
original-一个String。
08.09.16
char[]c=newchar[12];数组定义
数组有length属性
字符串有length（）方法
s1.equals（s2）;比较两个字符串的内容是否相同
s1==s2;比较两个字符串对象的引用是否相同就是两个对象的内存地址
Strings1="abc";
Strings2="abc";
s1==s2;//值为true因为虚拟机对String的特殊处理，单独的存放在特殊的区域，相同的对象相同的引用，s1与s2是一个对象的引用
Strings2=newString（"jcm"）;
Strings2=newString（"jcm"）;
s1==s2;//值为false因为new出来的对象肯定是不同的对象，不同的引用
StringBuffer字符缓冲区，可以追加，自动扩充容量，线程安全的，效率要低一些
StringBuilder所以的方法都是同步的，线程都是不安全的，效率高一些
正则表达式：
\反斜杠
/正斜杠
（\\w）+@（\\w）+\\.（\\w）匹配邮箱的正则表达式
Pattern模板Matcher匹配器
importjava.util.regex.*;//包
Pattern.matches（"regex","String"）;//一种匹配方法
Patternp=Ppile（"regex"）;//另一中方法
Matcherm=p.matcher（“string”）;
booleanb=m.matches（）;
包装类：
四类八种基本数据都对应有一个包装类，这些包装类封装了一个相应的基本数据类型数值，并为其提供了一系列的操作。
String[]f;
for（Stringf:
ff）
java中的配置文件
配置文件：
.xml成对出现<><>
.properties键值对
获取当前系统时间：
system.currenttime（）
date（）
Calendarc=Calendar.getInstance（）;
java.sql.Date.valueOf（s）解析字符串到date
SimpleDateFormat.parse（s）也可以解析字符串到date，需要先定义模板，例：
SimpleDateFormatsdf=newSimpleDateFormat（"yyyy年MM月dd日"）;
08.09.17
io流：
stream
相对于应用程序来讲有：
输入流:
输出流:
按照传输单位有：
字符流：
字节流：
inputstream所以输入字节流的父类
按功能不同有：
节点流：
一个流直接操作
处理流：
通过嵌套处理
inputstreamreader将字节流转换为字符流
fileoutputstream可以创建不存在的文件，但是不能创建目录
filewrite可以创建不存在的文件，但是不能创建目录
对异常的处理方式：
catch
throw
catch（Exceptione）
throwsException
在io里，用字节流处理事情时是比较安全的，如文件复制等，复制一张图片，音乐，视频是不能用字符流的
GB2312简体
GBK简体繁体
GB18030简体繁体日韩
bufferedwrite写数据时一定用要用bw.flush（）;//一定刷新缓冲区
FileNotFoundException是IOException的子类
只有输出流才有flush（）函数
Filef=newFile（"F:
/temp/9.17/jcm.txt"）;
FileOutputStreamfos=newFileOutputStream（f）;
OutputStreamWriterosw=newOutputStreamWriter（fos）;
osw.close（）;
fos.close（）;//放在后面
专门处理数据的两个io类：
DataInputStream
DataOutputStream
下面的代码可以让输出内容到文件
FileOutputStreamfos=newFileOutputStream（"F:
\\temp\\9.18/jcm.txt"）;
PrintStreamps=newPrintStream（fos）;
System.setOut（ps）;
system.out.println（）;//输出内容到文件
08.09.18
反射：
java.lang.reflect
1在运行时判断任意一个对象所属的类
2在运行时构造任意一个类的对象
3在运行时调用任意一个对象的方法
4在运行时判断任意一个类具有的成员变量和方法，注解
ClassMethodFieldContruct
获取某个类的Class实例：
四种方法
1.
Classcla=Class.forName（"完整的类名：
有包名"）;
2.
ClassName.class
3.
ClassNamecn=newClassName（）;
Classcla=cn.getClass（）;
4.
基本数据类型的包装类：
Double.Type
通过反射创建对象：
1.
TestReflectiontrobj=TestReflection.class.newInstance（）;
2.
ClassclassType=objectName.getClass（）;
objectobjectCopy=classType.getConstructor（newClass[]{}）.newInstance（newobject[]{}）;
获取构造器参数参数
String.class"jcm"
3.
通过反射调用方法：
javaBean：
一个类，属性设为private，并提供共有的set、get方法，POJO
08.09.19
对象序列化：
实现Serializable的接口的类的对象可以被保存到硬盘，或在网络上传输
ObjectOutputStream对象writeObject（Objectobj）通过在流中使用文件可以实现对象的持久存储
ObjectInputStream对以前使用ObjectOutputStream写入的基本数据和对象进行反序列化
transient修饰的字段在序列化是不被保存到硬盘只能用在Serializable中
实现Externalizable接口，序列化的工作自己来做，虚拟机不管
两者的不同：
Serializable反序列化时，直接从二进制代码转化成对象，不经过构造器
Externalizable反序列化时，通过默认的构造器创建对象，再赋值，恢复自己控制，但很少用
注意：
只保存变量值，不保存修饰符
保证先写先读的顺序
不能保存静态变量
swith（）---------int,char,enum,short,byte,
枚举类的定义：
publicenumjcm{A,B,C,D,E,F}
08.09.20
Collections操作集合的类
Map容器底层是数组实现的没有实现迭代接口，没有add方法
HashMap：
用数组实现，并且是一个一维数组，entry数组，entry键值对：
privateObjectkey键不可以重复，
privateObjectvalue
LinkedHashMap维护顺序
TreeMap可以实现自然排序
Mapmap=newHashMap（）;
接口名称实现类
Map.Entryen=（Map.Entry）iter2.next（）;Entry是Map的一个内部类！
！
！
！
两种遍历Map的方法：
一.拿到所有的entry通过Map.Entry的方法遍历
Setset2=map.entrySet（）;
Iteratoriter2=set2.iterator（）;
while（iter2.hasNext（））
{
Map.Entryen=（Map.Entry）iter2.next（）;
System.out.println（en.getKey（）+"--->"+en.getValue（））;
}
二.拿到所有的key
Setset=map.keySet（）;
Iteratoriter=set.iterator（）;
while（iter.hasNext（））
{
StringKey_t=（String）iter.next（）;
Stringvalue=（String）map.get（Key_t）;
System.out.println（Key_t+"----->"+value）;
}
散列，散列码：
设计hashCode：
对于相同对象，不论何时都是相同的值
注释：
///**//***/
注解：
@override//我要重写父类的方法，请编译器帮我检查一下，我重写的对不对
HashMap的性能因子：
Array读快改慢
linkedlist改快读慢
HashMap两者之间
数组或集合名
for（Strings:
sa）
{
}
将sa的第一项给s，然后第二项，第三项。
。
。
。
。
hashmap快速查找
treemapkey自然排序
linkedmap插入顺序可以存储
08.09.22
泛型：
java绝配：
泛型+容器
switch+enum
Listelement
List<类>ld=newArrayList<类>（）;可以放置各种类型
ListldnewArrayList（）;约束类型
ArrayList遍历三种方法：
迭代foreachfor+size
Mapmap=newHashMap（）;
泛型类：
Test
Testt=newTest（）;
通配符：
？
注解：
@Xxxx
@SuppressWarningg（"unchecked"）;忽略此警告
@Override对重写的方法进行检查
@interface声明注解
public@interfaceTest{}
元注解：
@Target（value=ANNOTATION_TYPE）：
表示注解在什么地方用----------帮助文档
@Retention（value=RUNTIME）
@Documented在文档中
@Inherited允许继承
在编写自己的注解时要加上两个元注解
publicMethodgetMethod（Stringname,Class
>...parameterTypes）
getMethod（"fun",newNewClass[]{String.getclass（）,String.getClass（）}）
08.09.23
进程大于线程，一个进程可以启动多个线程进程间不会相互干扰，拥有独立空间，不用通信
同一时刻cpu只能执行一个程序
线程：
当进程中多个线程同时运行时叫做并发线程间共享存储空间
java多线程是抢占式vm启动时默认由main方法定义一个线程，即主线程
java线程的创建：
1扩展java.lang.thread
2实现runable接口
继承thread：
重写run（）方法
start（）启动线程
可以利用标致结束线程
线程让步：
yiel
升级会员 