Java学习笔记.docx
《Java学习笔记.docx》由会员分享，可在线阅读，更多相关《Java学习笔记.docx（17页珍藏版）》请在冰豆网上搜索。
Java学习笔记
基础语法
一，数据类型转换问题
1,byte可以直接赋值，旦范围在127之内包含127；
2，bytecharshort->int->long->float->double;
3,容量小的直接向容量大的转化，容量大的向容量小的转化时需要加强制转化符，格式（类型）；
4,类似于1.2的都是double型；
5，多种类型的运算，首先转化为容量大的；
6.类似于123的默认为int；
二，格式问题
1，大括号对齐
2，遇到{缩进，Tab/shift+tab
3,程序块之间加空行
4，并排语句之间加空格
5，运算符两侧加空格
6，{前面有空格
7，成对编程
三，运算符
1，i++先赋值在自增；++i先递增1在赋值；
2，！
非，&与，|或，^异或，&&短路与，||短路或
3，+除用于算数加法运算外，还可以对字符串进行连接操作例如：
Strings="Hello"+"World",就是“HelloWorld”。
4，+运算符两侧的操作数中只要有一个是字符串String类型系统就会自动将另一个操作数转化为字符串然后在进行连接；
例如intc=12;System.out.println（"c="+c）;
5,x?
y:
z表示的意思是若x为true则结果为y的值，否则就是z的值；
四，if和for
1，if
if...else...
if...elseif...
if...elseif...elseif...
if...elseif...elseif...else
2,只有一句话需要执行的语句时，可以省略{}
3，for语句的形式
for（表达式1；表达式2；表达式3）{语句；...；}
执行的过程：
首先执行表达式1，接着执行表达式2，若表达式2为true，则执行语句，接着计算表达式3，在判断表达式2的值；依次重复下去，直到表达式2的值为false
for语句中的三个表达式都可以省略
4，while语句为如下形式：
while（逻辑表达式）{语句；...；}
执行过程：
先判断逻辑表达式的值。
若=true，则执行其后面的语句，然后再次判断条件并反复执行，直到条件不成立为止
5,while语句为如下形式：
do{语句；...；}while（逻辑表达式）；
执行过程：
先执行语句，在判断逻辑表达式的值，true的话执行语句否则结束循环
6，break语句用于终止某个语句块的执行。
用在循环语句体中，可以强行退出循环
例子：
publicclasstest{
publicstaticvoidmain（String[]args）{
intstop=4;
for（inti=1;i<=10;i++）{
if（i==stop）break;
System.out.println（"i="+i）;
}
}
}
打印结果i=1i=2i=3
7，continue语句用在循环语句体中，用于某次循环过程跳过循环体中continue语句下面未执行的循环，开始下一次循环过程
例子：
publicclasstest{
publicstaticvoidmain（String[]args）{
intskip=4;
for（inti=1;i<=10;i++）{
if（i==skip）continue;
System.out.println（"i="+i）;
}
}
}
打印结果i=1i=2i=3i=5
8,switch语句
switch（）{
casexx：
...
casexx：
...
default:
...
}
case穿透要加break
多个case可以合并到一起
java中switch语句只能探测int类型值
面向对象
一，
1，指导性的思想：
首先考虑在这个问题里有哪些类，有哪些对象；然后考虑这些类和对象每一种类和对象有哪些属性和方法；最后考虑类和类之间具备了什么样的关系。
2，类的定义主要有两部分组成--成员变量和方法。
例如：
用class关键字定义一个类
classperson{
privateintid;
privateintage=20;//定义用户变量
publicintgetage（）{returnage;}
publicvoidsetage（inti）{age=i;}
publicintgetid（）{returnid;}//定义方法
}
3，对象的建立和使用
必须使用new关键字创建对象
使用对象（引用）.成员变量或来引用对象的成员变量
使用对象（引用）.方法（参数列表）来调用对象的方法
同一类的每个对象有不同成员变量的存储空间
同一类的每个对象共享该类的方法
4，成员变量和局部变量的区别：
局部变量必须首先声明然后赋值最后才能使用；成员变量不需要进行初始化系统默认自动进行初始化。
5,约定俗成的命名规则
类名的首字母大写
变量名和方法名的首字母小写
运用驼峰标示
6，如果一个方法前面不写static需要new一个对象，然后才能调用
调一个方法必须new一个对象
第三章面向对象中的08内存解析3值得一看
7，方法的重载是值在一个类中可以定义相同的名字，但是参数不同的多个方法，调用时，可以根据参数选择相应的方法。
二，关键字
1，this
在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
实际当中，如果你new一个对象出来，this指的就是当前这个对象。
你对那个对象调这个方法this就指的是谁
当必须指出当前使用方法的对象是谁时要使用this
又是使用this可以处理方法中成员变量和参数重名的情况
This可以看作是一个变量，他的值是当前对象的引用
例子：
PublicclassLeaf{
inti=0;
Leaf（inti）{
this.i=i;//形参和成员变量都是i，this.i指的是成员变量
}
Leafincreament（）{
i++;
returnthis;
}
Voidprint（）{
System.out.println（“i=”+i）;
}
Publicstaticvoidmain（String[]args）{
Leafleaf=newLeaf（100）;
Leaf.increament（）.increament（）.print（）;
}
}
2，static
用static声明的方法是静态方法，在调用该方法时，不会讲对象的引用传递给他，所以在static方法中不可以访问非static的成员。
----静态方法不再针对某个对象调用，所以不能访问非静态成员。
可以通过对象引用或类名（不需要实例化）来访问静态成员。
局部变量在栈里分配，成员变量在堆里分配。
3,package和import
用来解决类的重名问题。
Package必须写在源代码的第一行
包名前面约定俗成的把公司的域名倒过来，后面随便跟，用.跟。
例如：
Packagecom.sxt;
则该文件中所有的类位于,\com\sxt目录下
如果将一个类打包，则使用该类时，必须使用该类的全名（例如：
com.sxt.myclass），java编译器才会找到该类。
打包的类必须位于正确的目录下，即和包得层次完全的一致。
或者可以用import引入即在开头写上importcom.sxt.myclass也可以用*代替所有的类。
注意类的源文件可能会产生影响，所以要删除。
Class文件的最上层包的父目录必须位于classpath下
执行一个类必须写全包名。
Java.lang里的包不需要引入，可以直接用；其他需要引入。
打包语句：
jar–cvfxx.jar*.*
可以将jar包当成路径设在classpath
三，
1，类的继承与权限控制
Java中使用extends关键字实现类的继承机制，其语法规则为：
class[extends]
{……}
通过继承，子类拥有了基类（superclass）的所有成员（成员变量和方法）
Java只支持单继承，不允许多继承。
一个子类只能有一个基类，一个基类可以派生出多个子类。
2，访问控制
访问控制的修饰符有四个：
privatepublicdefaultprotected
Class的权限修饰符只可以用publicdefault
Public类可以在任意地方被访问
Default类只可以被同一个包内部的类访问
3,方法的重写
在子类中可以根据需要对从基类中继承来的方法进行重写。
重写方法必须和被重写方法具有相同的方法名称，参数列表和返回类型
重写方法不能使用比被重写方法更严格的访问权限。
重写最好用copy
4,super关键字
java中使用super来引用基类的成分。
例如：
classFatherclass{
publicintvalue;
publicvoidf（）{
value=100;
System.out.println（“Father.value=”+value）;
}
}
classChildclassextendsFatherclass{
publicintvalue;
publicvoidf（）{//方法重写
Super.f（）;
Value=200;
System.out.println（“Childclass.value=”+value）;
System.out.println（value）;
System.out.println（super.value）;
}
}
5,Object类是所有java类的根基类
如果在声明中没有使用extends关键字指明其基类，则默认其基类是object类。
Publicclassperson{
…
}
等价于：
Publicclasspersonextendsobject{
…
}
6,toString方法
object类中定义有publicStringtoString（）方法，其返回值是String类型，描述当前对象的有关信息。
进行String与其他类型数据的连接操作时，如：
（System.out.println（“info”+person））将自动调用该对象类的toString（）方法。
可以根据需要在用户自定义类型中重写toString（）方法。
7,equals方法
object定义的类中有：
publicbooleanequals（objectobj）方法
提供定义对象是否相等的逻辑
Object的equals方法定义为：
x.equals（y）当x和y是同一个对象的应用时返回true否则返回flase。
8,对象转型（casting）
一个基类的引用类型变量可以指向起子类的对象。
一个基类的引用不可以访问其基类新增加的成员（属性和方法）。
可以使用引用变量instanceof类名来判断该引用型变量所指向的对象是否属于该类或该类的子类。
子类的对象可以当做基类的对象来使用称作向上转型（upcasting）,反之称作向下转型（downcasting）。
9,动态绑定和多态
动态绑定是指在执行期间（而非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
多态要满足三个条件：
1）要有继承
2）要有重写
3）父类引用指向子类对象
10,抽象类
用abstract关键字来修饰一个类时，这个类叫做抽象类，用abstract关键字来修饰一个方法时，这个方法叫做抽象方法。
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。
抽象类不能被实例化。
抽象方法只需声明不需实现。
要自己实验一下
11,Final关键字
Final的值不能被改变
Final的成员变量
Final的局部变量（形参）
Final的方法不能被重写。
Final的类不能不继承。
12,interface（接口）
本质上是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
1）多个无关的类可以实现同一个接口
2）一个类可以实现多个无关的接口
3）与继承关系类似，接口与实现类之间存在多态性
4）定义java类的格式：
class[extends][implements[,]*]{*s}
接口中声明的属性默认为publicstaticfinal
接口中只能定义抽象方法，而且这些方法默认为public
接口举例：
interfacesinger{
publicvoidsing（）;
publicvoidsleep（）;
}
Classstudentimplementssinger{//要用implement而不能用extends，因为上面是interface
PrivateStringname;
Student（Stringname）{
This.name=name;
}
Publicvoidstudy{
Stystem.out.println（“studying”）;
}
PublicstringGetname（）{returnname;}
Publicvoidsing（）{
System.out.println（“studentissinging”）;
}
System.out.println（“studentissleeping”）;
}
异常处理
运行期出现的错误观察错误的名字和行号最重要
1，异常的概念
举例说明：
publicclassTestEx
{
publicstaticvoidmain（String[]args）{
int[]arr={1,2,3};
System.out.println（arr[2]）;
try
{
System.out.println（2/0）;
}
catch（ArithmeticExceptionae）
{
System.out.println（"系统正在维护，请与管理员联系"）;
ae.printStackTrace（）;
}
}
}
2，异常的捕获和处理
try{
//可能抛出的异常语句
}
catch（SomeException1e）{
…
}
catch（SomeException2e）{
…
}
finally{
…
}
Finally段的代码无论是否发生异常都会执行。
本章的五个关键字：
trycatchfinallythrowthrows
注意：
重写方法需要抛出与原来方法所抛出异常类型一致或不抛出异常。
数组
一，数组概述
数组可以看成许多相同数据类型组合，对这些数据的统一管理。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
1，一维数组的声明
方式：
typevar[];或type[]var;
例如：
inta1[];或int[]a2;
doubleb[];
person[]p1;Strings2[];
java语言中声明数组时不能指明其长度（数组中元素的个数），例如：
inta[5];//非法
2，数组对象的创建
Java中使用关键字new来创建数组对象，格式为：
数组名=new数组元素的类型[数组元素的个数]
3，数组的动态初始化
数组定义与为数组元素分配空间和赋值的操作分开进行。
PublicclassTest{
Publicstaticvoidmain（String[]args）{
inta[];
a=newint[3];
a[0]=3;a[1]=9;a[2]=8;
datedays[];
days=newdate[3];
days[0]=newdate（1,4,2004）;
days[1]=newdate（2,4,2004）;
days[2]=newdate（3,4,2004）;
}
}
Classdate{
…
}
4，数组的静态初始化
定义数组的同时就为数组元素分配空间和赋值。
PublicclassTest{
Publicstaticvoidmain（String[]args）{
inta[]={3,9,8};
datedays[]={
newdate（1,4,2004）,
newdate（2,4,2004）,
newdate（3,4,2004）
};
}
}
Classdate{
…
}
5.数组元素的引用
定义并用运算符new为之分配空间后，才可以引用数组中的每个元素，数组元素的引用方式为：
arryName[index]
index为数组元素下标，可以是整型常量和整型表达式。
如：
a[3],b[i],c[6*i]
数组下标从0开始，常速为n的合法下标的取值范围为：
0-n-1
每个数组都有一个属性length指明他的长度，例如
a.length的值为数组a的长度（元素的个数）
6,学会选择排序法和冒泡法
7,二维数组
二位数组可以看成是以数组为元素的数组。
例如：
inta[][]={{1,2},{3,4,5},{6,7,8,9}};
java中多维数组的声明和初始化都是由高维到低维，例如：
inta[][]=newint[3][];
a[0]=newint[2];
a[1]=newint[4];
a[2]=newint[3];
intt1[][]=newint[][4];//非法的
8，二位数组初始化
（1）静态初始化
intintA[][]=newint{{1,2},{3,4},{5,6,7}};
intintB[][]=newint{{1,2},{2,3},{3,4,5}};//非法
（2）动态初始化
inta[][]=newint[3][5];
intb[][]=newint[3][];
b[0]=newint[2];
b[1]=newint[3];
b[2]=newint[5];
9,数组的拷贝
Publicstaticvoidarraycopy（objectsrc,intsrcpos,objectdest,intdestpose,intlength）
可以用于数组src从第srcpos项元素开始的length个元素拷贝到目标数组从destpos开始的length个位置。
升级会员 