java学习笔记.docx

java学习笔记.docx

《java学习笔记.docx》由会员分享，可在线阅读，更多相关《java学习笔记.docx（95页珍藏版）》请在冰豆网上搜索。

java学习笔记

Java学习笔记

Java概述

java语言是解释执行，java源码是通过编译生成一种特殊的.class的中间字解码文件，然后再有JVM进行解释执行。

java语言对指针进行了上层的封装，它保证能够通过这个指针（引用）来访问有效的内存单元。

java语言不允许多继承，使继承关系成树装图，每个类都只能由一个父类。

java语言的开发效率高，但执行效率低。

（相当于c++的55%）

java的垃圾回收机制，在java中new的对象不需要向c++一样进行delete操作，JVM会根据情况回收垃圾对象。

（懒汉机制，等待资源没有的时候才回收）我们只能够建议JVM进行垃圾回收，例如（System.gc（）RunTime.gc（）这两个方法就是建议JVM进行垃圾回收的方法）

JDK，java开发工具包（类库和运行命令），JRE，java运行环境，JVM，java虚拟机（解释执行的核心，对字节码进行翻译成运行环境的机器码，它可以屏蔽平台差异。

JVM是不跨平台的。

）

JAVA_HOME,指明JDK安装的位置，CLASSPATH，指明类文件的位置，PATH，指明命令的可执行文件的位置。

java源文件的文件名必须和文件中定义publicclass的类名（大小写页要相同）相同。

java源代码中的main方法的定义写法。

main方法是程序的入口。

publicstaticvoidmain（String[]args）{

System.out.println（"Helloworld"）；

}

java源文件也要先编译，使用javacxxx.java格式的命令得来编译，使用javaxxx来运行。

定义包结构要放在有效代码的第一行，packagexxx.xxx，包的定义在一个程序中只能由一个，在加上包定义之后编译可以使用javac-d路径xxxx.java,这个-d这个命令行的参数可以指定包结构的位置“.”代表当前目录。

在运行时要使用类的全名

javaxxx.xxx.xxxx用包名以点分隔。

运行时要在包结构的上一层目录来运行。

java中的注释

单行注释//......

多行注释/*.......*/

文档注释/**........

（换行标签）*/,用javadoc命令可以根据原码中的文档注释生成注释文档（html格式）。

文档注释中可以使用html标签。

javadoc-d路径（指定注释文档的保存路径）

文档注释一般写在类定义之前，方法之前，属性之前。

在文档注释中可以用@author表示程序的作者，@version表示程序的版本，前两个注释符号要写在类定义之前，用于方法的注释@param对参数进行注释,@return对返回值进行注释@throws对抛出异常的注释。

jar命令用于打一个xxx.jar文件

用法：

jar{ctxu}[vfm0Mi][jar-文件][manifest-文件][-C目录]文件名...

选项：

-c创建新的存档

-t列出存档内容的列表

-x展开存档中的命名的（或所有的〕文件

-u更新已存在的存档

-v生成详细输出到标准输出上

-f指定存档文件名

-m包含来自标明文件的标明信息

-0只存储方式；未用ZIP压缩格式

-M不产生所有项的清单（manifest〕文件

-i为指定的jar文件产生索引信息

-C改变到指定的目录，并且包含下列文件：

如果一个文件名是一个目录，它将被递归处理。

清单（manifest〕文件名和存档文件名都需要被指定，按'm'和'f'标志指定的相同顺序

示例1：

将两个class文件存档到一个名为'classes.jar'的存档文件中：

jarcvfclasses.jarFoo.classBar.class

示例2：

用一个存在的清单（manifest）文件'mymanifest'将foo/目录下的所有

文件存档到一个名为'classes.jar'的存档文件中：

jarcvfmclasses.jarmymanifest-Cfoo/。

一般在使用使用jarcvf文件名.jar文件所在路径（xxx/xxx/xxx.class）也可以压缩一个目录,只要在制定路径是指定为文件夹，jar命令的命令行参数在使用时可以以“-”开头，也可以不用。

java程序的运行过程，首先是启动java虚拟机，然后就是去找.class文件，先是从系统的类库中找（系统之会在跟目录下查找，所以需要完整类名），如果找不到的话会去CLASSPATH所设置的目录去找。

然后加载到java虚拟机中。

系统会在每个java程序中隐含导入了java.lang这个包，import包名，导入包中的类文件。

java.lang包，这是一个基础包。

java.util包,这个包是工具类的包。

java.io包,这个包是用于输入输出操作的

包,这个包是用于网络编程。

java.awt，java.swing，javax.swing，java.event等包用于图形编程用的包。

applactionjava的应用程序，java应用程序中必须有一个main（）方法。

标识符和关键字

Java代码中的“；”、“{}”、“”

Java语句以分号分隔，Java代码块包含在大括号内，忽略空格.标识符

1）用以命名类、方法和变量、以及包遵守JAVA的命名规范类以每个单词都以大写字母开头。

方法和变量第一个字母不大写，其他照旧。

2）只能以字符、“_”或“$”开头；

3）无长度限制。

java中的关键字

goto和const在java中虽然不再使用但是还作为关键字存在

java中没有sizeof这个关键字了，java中的boolean类型的值只能用true和false，且这两值也是关键字。

java语言中没有无符号这个关键字（unsigned）

java中的数据类型

1）整型

byte1字节8位-128到127

short2字节16位-2^15到2^15-1

int4字节32位-2^31到2^31-1

long8字节64位-2^63到2^63-1

2）浮点类型

float4字节32位

double8字节64位

3）字符类型

char2字节16位

4）布尔型

booleanfalse/true

注：

1）char是无符号的16位整数,字面值必须用单引号括起来；‘a’

2）String是类，非原始数据类型；

3）长整型数字有一个后缀为“L”或“l”，八进制前缀为“0”，十六进制前缀为“0x”；

4）黙认浮点类型为double；

5）float数据类型有一个后缀为“f”或“F”,Double数据类型后可跟后缀“D”或“d“

6）char类型也可以用通用转译字符，但是不能用ASCII码。

可以用“\u0000”这种格式，因为char型中使用的是unicode编码方式。

注：

整型值存放，正数存放原码（二进制码），负数则存放补码（原码按位取反末位加一）。

注：

实型值在存储时会损失精度，所以不要直接比较两个实型值。

系统默认的实型都是double型，要使用时要在数据后加个f，或者强行转换。

强转（占字节数大的类型转到占字节数小的类型）时会放弃高位值只取低位值。

java中的数字数据类型减灾由占字节数小的类型到占字节数大的类型的可以有自动转换，反之则需要强行转换，char型和int型之间可以相互转换。

char和short不能像户转换。

注意：

隐式类型转换；

a运算符b，如果a，b中有任意一个是double型，前面运算的结果就是double型，如果a，b中有任意一个是float型，前面运算的结果就是float型，如果a，b中有任意一个是long型，前面运算的结果就是long型，如果a，b中没有double、float、long型，那么其结果就为int型。

所有基本数据类型在使用时会事先分配空间，只本身就存在空间中，在传递时，就是值传递，不是引用传递。

在类中定义的方法在返回值前加上static修饰符就可以在main方法中调用了。

如果不用static那就需要在main方法中创建对象，使用对象来调用对象的方法。

publicclassTest{

publicstaticvoidmain（String[]args）{

Testt=newTest（）；

intb=1；

intc=2；

int[]a=newint[10]；

t.sqort（a）；

add（b,c）

}

publicint[]sqort（int[]a）{

.......

}

staticintadd（b,c）{

.......

}

}

java中的运算符（java的运算符的优先级和结合性和c++相同）

System.out.println（3/2）按整型计算得1

1）>>=前面是零补零，前面是一补一；

2）>>>=无符号右移（强制右移都会移进一），

>>=和>>>=对于负数不一样

正数：

右移n位等于除以2的n次方

负数：

变成正数。

3）&&短路与，前面为假，表达式为假，后面的操作不会进行，&会对所有条件进行判断。

4）||短路或，前面为真，表达式为真，后面的操作不会进行，|会对所有条件进行判断。

例：

if（a<3&（b=a）==0）b赋值

if（a<3&&（b=a）==0）b不赋值

5）instanceof，是用于判断一个对象是否属于某个类型

6）java中的求余运算符“%”可以对两个实型变量求余

注：

按位与是为了让某些位置一，按位或是令某些位置零，按位异或是令某些位取反。

注：

使用左右位移和无符号右移运算符的使用方法是变量名<<=位移位数，变量名>>=位移位数（前两个运算符是不会忽略整形符号位，也称逻辑位移）,变量名>>>=位移位数

注意：

左右位移和无符号右移运算符只能用于整形及其兼容类型（byte，int，short，long）

注意：

java程序的运行过程，首先是启动java虚拟机，然后就是去找。

class文件，先是从系统的类库中找（系统之会在跟目录下查找，所以需要完整类名），如果找不到的话会去CLASSPATH所设置的目录去找。

然后加载到java虚拟机中。

如果要使用到其他的在JAVA_HOME中没有的类或者是其他公司提供的第三方的。

jar（jar包）文件时，要把它的路径及文件名加到CLASSPATH中。

java的流程控制

控制流

if（）

if（）….else

if（）…..elseif（）….else

注意：

else只是和其上面的同层的最近的if（）来配对。

switch（）{

case'a':

……..

case1:

……break；

default:

…………

}

注解：

switch（）内数据类型为byteshortcharint类型，只有以上四种类型的才可以在switch（）中使用。

case块中不加break时顺序执行下面的语句。

循环语句

for（inti=0；i

while（）{}

do{}while（）；-----------注意加分号

例子：

loop:

for（inti=0；i

{

for（intj=0；j

{

if（3==j）

{

breakloop；//--loop为标签只能用在循环语句中，用于循环跳到外层循环

}

}

}

辨析：

intx,a=6,b=7；

x=a+++b++；//----------a=7,b=8,x=13

intx=6；x=~x；//----------------6的二进制0110取反得11001再转成补码（取反加一）10111＝－7

break，跳出本层循环，执行后面的代码，continue，提前终止本次循环，再一次进行循环或循环条件满足或不满足后退出循环。

break标签名；continue标签名；这两条语句知识表示跳出有标签的循环和提前终止本次有标签的循环，只能用在循环语句（多层循环嵌套）中，循环嵌套中用于跳到外层循环。

注意：

for循环在使用时一定要注意不要忘记（）中的两个"；"，死循环的写法for（；；）{}或者是用

while（true）{}

注意：

System.out.println（"..."+a）在使用这个语句时，它会将其中非字符串（String）的值转换成字符串（不是所有数据类型都可以的）。

java中的数组Array，其包含两个部分，分别是数组的引用和数组的空间两部分。

声明数组

1）一组相同类型（可以是类）数据的集合；

2）一个数组是一个对象；

3）声明一个数组没有创建一个对象；

4）数组能以下列形式声明：

int[]i或inti[]

Car[]c或Carc[]

*C++中只能Carc[]

*JAVA中推荐用Car[]c；

5）数组的定义如：

int[]a（数组引用声明）=newint[10]（数组空间的声明，并把空间首地址赋值给数组的引用）

int[]a；

a=newint[20]；

创建数组

1）创建基本数据类型数组int[]i=newint[2]；

2）创建引用数据类型数组Car[]c=newCar[100]；

3）数组创建后有初始值。

数字类型为0布尔类型为false引用类型为null

注意：

访问没有初始化的数组中的值，是会抛出异常的（NullPointerException）,java中只保证一位数组的地址是连续的，二维数组实际上是一维数组中有存储了一维数组的引用。

初始化数组

1）初始化、创建、和声明分开

int[]i；

i=newint[2]；

i[0]=0；

i[1]=1；

2）初始化、创建、和声明在同一时间

int[]i={0,1}；

Car[]c={newCar（）,newCar（）}；

多维数组

1）有效定义

int[][]i1=newint[2][3]；（同时给定一维，二维的空间）

int[][]i2=newint[2][]；（给定一维的空间，二维空间待定）

i2[0]=newint[2],i2[1]=newint[3]；

*C++中int[][]=newint[][3]；有效

2）无效定义

int[][]i1=newint[][3]；

3）数组长度------------数组的属性length（在二维数组中这个属性只代表第一维的长度）

int[]i=newint[5]；

intlen=i.length；//len=5；

Student[][]st=newStudent[4][6]；

len=st.length；//len=4；

len=st[0].length；//len=6；

数组拷贝

System.arrayCopy（Objectsrc,intsrcPos,Objectdest,intdestPos,intlength）；

src源数组，srcPos从第几位开始拷贝，dest目标数组，destPos目标数组放置的起始位置，length，表示要拷贝的长度。

拷贝一个数组到另一个数组。

类的对象的创建和对象数组

一个xxx.Java文件中可以定义多个类但是只能由一个public修饰的类，也只能以这个类的类名作为.java的文件名。

java中的类的对象的创建，要先创建这个对象的引用，例如：

Carc；然后用new这个关键字创建一个对象的实例（对象的空间）例如：

c=newCar（）；，然后对象的实例的空间首地址赋值给对象的引用。

多个对象的引用可以同时引用自同一个对象的实例，但是对象的引用只能引用一个对象的实例。

对象的引用和对象的实例间就像是牵着气球的线和气球一样。

注意：

只有一个没有被任何对象的引用所引用的对象的实例才会边城垃圾等待被垃圾回收。

对象数组

例：

Car[]c=newCar[3]；

c[0]=newCar（）；

注意：

存放基本类型的数组的数据是直接存放在数组的空间中，而对象的数组在数组空间中存放的则是对象的引用。

定义在类中类的属性是实例变量，定义在类的方法中的变量是局部变量。

实例变量是保存在对象空间中的，而局部变量则是在方法调用的分配空间，调用结束后就释放空间。

注意：

在类的定义中属性的定义和方法的定义必须写在类里。

注意：

系统会自动初始化实例变量，数字类型为0，布尔类型为false，引用类型为null。

局部变量需要初始化，必须赋初值。

如果不赋初值无法通过编译。

Java中的方法调用中参数传递有两种，一个是对于参数是基本类型的使用的是值传递（直接传参数的值），另一个是引用传递，它是用于参数是类的对象，它传递的是这个对象的引用。

面向对象的思想

anythingisObject（万物皆对象）

抽象，从对具体的对象中抽取有用信息。

对象有其固有属性，对象的方法，即对象的行为（对象能做什么）

对象本身是简单的（功能简单），多个对象可以组成复杂的系统（对象之间彼此调用对方的方法）

对象应当是各司其职（功能简单），各尽所能（把自己的功能作到最好）。

（弱耦合性实现了前面所述的对象的特点）

对象的耦合性，是对象之间的联系，对象和系统之间的联系。

对象的耦合性要尽量的弱，也就是对象之间的联系尽可能的弱，对象和系统之间的联系尽可能的弱。

系统的可插入性，是在系统中加入新的对象之后的系统稳定性。

对象的可替换性，是在系统中替换原有的对象之后的系统的稳定性。

复用性，即对象可否被重复使用，对象的功能越简单，复用性就越好。

（对象的耦合性弱，复用性就比较强）

面向过程是先有算法，后又数据结构（怎么解决问题）

面向对象是先有对象（数据结构），后有算法。

（用什么做）

类是某些有着相同属性的集合的抽象。

类是一个类对象的模板，对象是类的具体化。

类是一个新的数据类型，类的对象。

注意：

局部变量的作用范围是在定义他的代码块以内，局部变量要先赋值后使用，在以一个重合的作用于范围内不允许两个局部变量命名冲突。

局部变量局部优先，且在于实例变量同名时会副该局部变量。

变量包括简单变量（原始数据类型），对象变量。

方法的定义：

1，方法的修饰符（多个修饰符出现的顺序无关）|

2，方法的返回值类型|顺

3，方法名|序

4，方法的参数表|向

5，方法中允许抛出的异常|下

java中不能够在返回语句后写任何代码。

JVM+解释器=JRE，JRE+类库=JDK

java中方法的重载（overload）方法名相同，参数表不同，返回值类型可以不同。

调用时要给出明确参数并确定调用某一方法。

在编译时，编译器会根据参数选择适当的方法，所以重载也叫编译时多态。

就近向上匹配原则

如果方法的参数表中的数据类型和调用时给出的参数类型不尽相同时会根据向上匹配的就近原则。

（类型就近向上转化匹配）

注意：

调用时要给出明确参数并确定调用某一方法，否则编译会出错。

对象使用者（调用其他对象的方法）对象（对象中的方法被调用时根据参数进行自己进行选择）

一类方法，但跟据不同的参数会有差异，对象回根据参数判断，对对象调用者透明。

创建对象的过程：

1，分配空间2，初始化属性3，调用构造方法（有前提，不考虑继承关系）

构造方法的写法：

没有返回值类型，构造方法的方法命名必须和类名相同。

如果在类中不写构造方法，系统会提供一个无参的构造方法。

注意：

最好在写类时提供一个无参的构造方法。

获得对象的方式

通过new（在堆空间中申请分配空间），new类名（），可以通过这种形式或的一个对象，这时的对象是无法使用，必须把的他的地址存放近一个对象变量才能够使用。

例如：

Carc=newCar（）；

有参的构造方法在被调用时，在用new关键字或的对象时初始化，例如：

Carc=newCar（"yellow"）

对象变量中存放的是对象的引用（地址的封装形式）

this关键字

表示当前对象（哪个对象调用了方法，哪个对象就是当前对象），可以用来区分实例变量和局部变量。

this（）,他表示掉用本类其他的构造方法，注，只能写在构造方法的第一行。

java中的参数传递，简单类型的变量传递的是数值，对象变量的传递则传递的一个引用（地址）

面向对象的三大特征

封装、继承、多态。

java中的封装

封装，一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。

（对象的属性应当隐藏），一个对象的内部是透明的，就是把对象内部的可透明性和隐藏的特性区分开，该透明的透明，该隐藏的隐藏。

（封装的属性）java中类的属性的访问权限的默认值不是private，要想隐藏该属性或方法，就可以加private（私有）修饰符，来限制只能够在类的内部进行访问。

对于类中的私有属性，要对其给出一对方法（getXxx（）,setXxx（））访问私有属性，保证对私有属性的操作的安全性。

方法的封装

对于方法的封装，该公开的公开，该隐藏的隐藏。

方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），隐藏方法的实现会使实现的改变对架构的影响最小化。

。

封装会使方法实现的改变对架构的影响最小化。

完全的封装，类的属性全部私有化，并且提供一对方法来访问属性。

java中的继承

继承，是对有着共同特性的多类事物，进行再抽象成一个类。

这个类就是多类事物的父类。

父类的意义在于可以抽取多类事物的共性。

java中的继承要使用extends关键字，并且java中只允许单继承，也就是一个类只能有一个父类。

这样就是继承关系呈树状，体现了java的简单性。

子类只能继承在父类中可以访问的属性和方法（实际上父类中私有的属性和方法也会被继承但子类中无法访问罢了）。

访问控制修饰符（可以修饰属性和方法）

private修饰符，表示只有本类内部可以访问。

default修饰符，方法不加修饰符，会默认为default，表示在同一个包中可以访问，父子类在同一包中，子类可以继承父类的相应内容。

（可以修饰类）

protected（保护）修饰符，表示同一包中可以访问，不同包的子类也可以访问继承。

public修饰符，表示公开，在任何地方都可以访问。

（可以修饰类）

修饰符的权限是由上而下逐渐变宽的。

继承的意义

在于