最全的java学习笔记(必看)

文章描述:-2022年4月13日发(作者:米志高)最全的java学习笔记(必看)LT234Java技术基础1.1编程语言机器语言:01在硬件直接执行汇编语言:助记符高级语言:(运行比C/C++慢)位为函数,如:C/C++语言。Java1)面向过程的高级语言:程序设计的基本单2)面向对象的高级语言:程序设计的基本单位为类,如:Java、C#。1.2Java的特点平台无关性、简单性、面向对象、健壮性、多线程、自

-

最全的java学习笔记(必看)
2022年4月13日发
(作者:米志高)

最全的java学习笔记(必看)

LT

2

3

4Java技术基础

1.1编程语言

机器语言:01在硬件直接执行

汇编语言:助记符

高级语言:(

运行比C/C++慢)

位为函数,如:C/C++语言。

Java

1)面向过程的高级语言:程序设计的基本单

2)面向对象的高级语言:程序设计的基本单

位为类,如:Java、C#。

1.2Java的特点

平台无关性、简单性、面向对象、健壮性、

多线程、自动内存管理。

平台无关性:指Java语言平台无关,而Java

的虚拟机却不是,需要下载对应平台JVM虚拟机

的。

自动内存管理:

对临时存储的数据自动进行

5

回收,释放内存。如:引用类型的变量没有指向

时,被回收;程序执行完后,局部变量被回收。

1.3Java开发环境

JavaDevelopementKit——Java开发工

具包,简称JDK,是由Sun公司提供的一个免费

的Java开发工具,编程人员和最终用户可以利

用这个工具来编译、运行Java程序。目前版本

有JDK1.0、JDK1.1、JDK1.2、JDK1.3、JDK1.4、

JDK1.5(J2SE5.0)、JDK1.6(J2SE6.0)、JDK1.7

(J2SE7.0)。

JDK结构:JDK

|--开发工具(Tools)命令:

java、javac、jar、rmic...

|--JRE(Java基本运行环境)

|--系统API库,系统类库

|系统带来的标准程序

库,标准API

|--JVMjava虚拟机java语言的执行环境

1.4Java开发环境配置

安装完JDK之后,不能立刻使用,需要设置

环境变量:

1)设置PATH:D:Javajdk1.6.0bin(指

向JDK中bin文件夹,有各种编译命令)。

2)CLASSPATH:告诉Java程序去哪里查

6

第三方和自定义类,如果.class文件和类源文

件在同一文件夹内,则不需要配置classpath,

后续有包,则需要。

A.Windows:在命令行执行

setCLASSPATH=E:workspace1304bin

(临时环境配置)

1

注意事项:

❖E:setclasspath=c:(不加分

号就不当前路径)

=.;c:;d:;(先

classpath,若无,再当前路径)

❖C、D两盘有同名.class文件,

classpath设置为D盘,而命令行窗口

当前盘符为C盘,则JVM现

classpath路径,后当前路径。

B.Linux:在控制台执行

①设置CLASSPATH环境变量,指向package

所在的目录,一般是项目文件夹中的bin目

录。

7

②执行ame(包名

必须写)。

export

CLASSPATH=/home/soft01/workspace/1304/bin

(临时环境配置)

orld

java-cp

/home/soft01/workspace/1304/bin

orld(二合一)

注意事项:

❖Windows根目录是反斜线:

❖Linux根目录是斜线:/

1.5Linux命令与相关知识

1)Linux无盘符,只有一个根目录(root)

2)终端==控制台==命令行窗口

3)pwd:打印当前工作目录,显示当前工作

目录的位置

4)ls:列表显示目录内容,默认显示当前

目录内容

5)cd:改变当前工作目录;cd后不加参数

=返回home文件夹;cd~:返回home;

cd/:切换到根目录;cd..:返回

上一层目录(相对的);

8

6)mkdir:创建文件夹(目录)注意:

目录==文件夹

7)rm:删除文件;rmxxxx:可删多个

文件;

rm–rfxx:-为减号,r表递归,f

表强制

8)catxx:显示文本文件内容

9)启动Java开发工具:cd/opt/eclipse

./eclipse.表当前目录下

10)绝对路径:/home(以/开始为绝对

路径,相对于根目录)相对路径:home(相对于当前工作目

录)

11)home(用户主目录,用户的家):

/home/username如:/home/soft01

12)主目录(home):有最大访问权限:什

么都能干,增删改查、建目录等其他地方:一般只能查看,不能增删改

查、创建目录等

1.6Eclipse/Myeclipse程序结构

Project项目文件

|--src源文件

||--Package包

||--.java源文件

|--bin

|--Package包

9|字节码程序

注意事项:

❖Myeclipse5.5消耗少,Myeclipse6.5最

稳定

10

Java语言基础

2.1基础语言要素

1)标识符:给类、方法、变量起的名字

A.必须以字母或下划线或$符号开

始,其余字符可以是字母、数字、$符号和下划

线。

B.只能包含两个特殊字符,即下划线_

和美元符号$。不允许有任何其他特殊字符。

C.标识符不能包含空格。

D.区分大小写。

2)关键字:只有系统才能用的标识符

注意事项:

❖true、false、null不是关键字!是字

面量。

❖main不是关键字!但是是一个特殊单

词,可以被JVM识别,主函数是固定

格式,作为程序的入口。

3)注释:单行注释://多行注释:/*……

*/文档注释:/**……*/

注意事项:开发中类前、属性前、方法前,

必须有文档注视。

2.2八种基本数据类型

1)四种整数类型(byte、short、int、long):

byte:8位,用于表示最小数据单

位,如文件中数据,-128~127

short:16位,很少用,-32768~

32767

11

(21亿)

int:32位、最常用,-2^31-1~2^31

long:64位、次常用

注意事项:

❖inti=5;//5叫直接量(或字面量),

即直接写出的常数。

❖整数字面量默认都为int类型,所以

在定义的long型数据后面加L或l。

❖小于32位数的变量,都按int结果计

算。

❖强转符比数学运算符优先级高。见常量

与变量中的例子。

2)两种浮点数类型(float、double):float:32位,后缀F或f,1位符号位,8

位指数,23位有效尾数。double:64位,最常用,后缀D或d,1位

符号位,11位指数,52位有效尾数。

注意事项:

❖二进制浮点数:

1010100010=101010001.0*2=1010100

0.10*2^10(2

1010100010*2^1010(10次方)

12

方)=1010100.010*2^11(3次方)=.

❖尾数:.1010100010指数:1010基

数:2

❖浮点数字面量默认都为double类型,

所以在定义的float型数据后面加F

或f;double类型可不写后缀,但在

小数计算中一定要写D或X.X。

❖float的精度没有long高,有效位数

(尾数)短。

❖float的范围大于long指数可以很

大。

❖浮点数是不精确的,不能对浮点数进行

精确比较。

3)一种字符类型(char):

char:16位,是整数类型,用单引号括

起来的1个字符(可以是一个中文字符),使用

Unicode码代表字符,0~2^16-1(65535)。

注意事项:

❖不能为0个字符。

❖转义字符:n换行r回车tTab

字符"双引号表示一个

❖两字符char中间用“+”连接,内部

先把字符转成int类型,再进行加法

运算,char本质就是个数!二进制的,

显示的时候,经过“处理”显示为字符。

4)一种布尔类型(boolean):true真和

13

false假。

5)类型转换:char-->

自动转换:

byte-->short-->int-->long-->float-->d

ouble强制转换:①会损失精度,产生误差,小

数点以后的数字全部舍弃。②容易超过取值范围。

2.3常量和变量

变量:内存中一块存储空间,可保存当前数据。

在程序运行过程中,其值是可以改变的量。

1)必须声明并且初始化以后使用(在同一个

作用域中不能重复声明变量)!

2)变量必须有明确类型(Java是强类型语言)。

3)变量有作用域(变量在声明的地方开始,

到块{}结束)。变量作用域越小越好。

4)局部变量在使用前一定要初始化!成员变

量在对象被创建后有默认值,可直接用。

5

)在方法中定义的局部变量在该方法被加载

时创建。

常量:在程序运行过程中,其值不可以改变的

量。

14

注意事项:

❖字面量、常量和变量的运算机制不同,

字面量、常量由编译器计算,变量由运

算器处理,目的是为了提高效率。

eg:小于32位数的字面量处理

byteb1=1;byteb2=3;

//byteb3=b1+b2;//编译错误,按照

int结果,需要强制转换

byteb3=(byte)(b1+b2);

//byteb3=(byte)b1+(byte)b2;//编

译错误!两个byte、short、char相加还是按

int算

n(b3);//选择结

果:A编译错误B运行异常C4Db3

byteb4=1+3;//字面量运算,编译期

间替换为4,字面量4

//byteb4=4;不超过byte就可以赋

❖不管是常量还是变量,必须先定义,才

15

能够使用。即先在内存中开辟存储空

间,才能够往里面放入数据。

❖不管是常量还是变量,其存储空间是有

数据类型的差别的,即有些变量的存储

空间用于存储整数,有些变量的存储空

间用于存储小数。

2.4运算符与表达式

1)数学运算:+-*/%++--

注意事项:

❖+-*/两端的变量必须是同种

类型,并返回同种类型。

❖%取余运算,负数的余数符号与被模

数符号相同,-1%5=-1,1%-

5=1;um%n,n>0,结果范围[0,n),

是周期函数。

❖注意整除问题:1/2=0(整数的除

法是整除)1.0/2=0.51D/2=

0.5

❖单独的前、后自增或自减是没区别的,

有了赋值语句或返回值,则值不同!

16

eg1:自增自减

inta=1;a=a++;

n("a的值:"+a);

第1步:后++,先确定表达式a++的值(当前

a的值)a++---->1

第2步:++,给a加1

a---->2

第3步:最后赋值运算

,把a++整个表达式的

值赋值给aa---->1

a被赋值两次,第1次a=2,第2次把1赋

值给

1

eg2:自增自减

x,y,z分别为5,6,7计算z+=--y*z++;

//x=5,y=5,z=42

z=z+--y*z++42=7

+5*7从左到右入栈,入的是值

eg3:取出数字的每一位d=num%10;//获取num的最后一位数

17num/=10;//消除num的最后一位

2)位运算:&|~(取反)^(异或)>>

<<>>>

注意事项:

❖一个数异或同一个数两次,结果还是那

个数。

❖|:上下对齐,有1个1则为1;&:上

下对齐,有1个0则为0;(都为二进

制)

❖&相当于乘法,|相当于加法;&:有0

则为0,|:有1则为1,^:两数相

同为0,不同为1。

3)关系运算符:><>=<===!=

4)逻辑运算符:&&||(短路)!&|

eg:短路运算:&&:前为flase,则后面不

计算;||:前为true,则后面不计算

intx=1,y=1,z=1;

if(x--==1&&y++==1||z++==1)//

||短路运算后面的不执行了!

n(“x=”+x+”,

y=”+y+”,z=”+z);//0,2,1

5)赋值运算符:=+=-=*=/=%=

eg:正负1交替

int

18

flag=-1;

n(flag*=-1);……

6)条件(三目)运算符:表达式1?表

达式2:表达式3

注意事项:

❖右结合性:a>b?a:i>j?i:

j相当于a>b?a:(i>j?i:

j)

❖三目运算符中:第二个表达式和第三个

表达式中如果都为基本数据类型,整个

表达式的运算结果由容量高的决定。

如:intx=4;x>4?99.9:9;

99.9是double类型,而9是int类型,

double容量高,所以最后结果为9.9。

7)运算符优先级:括号>自增自减>~!

>算数运算符>位移运算>关系运算>逻辑

运算>条件运算>赋值运算

2.5编程风格

MyEclipse/Eclipse中出现的红叉叉:编译

错误

编译错误:java编译器在将Java源代码编译

为class文件的过程出现的错误,一般是语法使

用错误!当有编译错误时候,是没有class文件

产生,也就不能运行程序。

19

Java程序结构:

2.6流程控制语句

1)选择控制语句

if语句:if、if-else、if-else-if:

可以处理一切分支判断。

格式:if(判断){…}、if(判

断){…}else{…}、if(判断){…}elseif(判

断){…}

switch语句:switch(必须整数类

型){case常量1:…;case常量2:…;….}

注意事项:

❖int类型指:byte、short、int,只能

写long类型,要写也必须强转成int

类型;而byte、short为自动转换成

int。

❖swtich-case:若case中无符合的

数,并且default写在最前(无break时),则为顺序执行,有break或}则退出。

❖swtich-case:若case中无符合的

数,并且default写在最后,则执行

default。

❖swtich-case:若case中有符合的数,

并且default写在最后,并且default

前面的case没有break时,

default

20

也会执行。

2)循环控制语句

①for:最常用,用在与次数有关的循

环处理,甚至只用for可以解决任何循环问题。

注意事项:for中定义的用于控制次数

的循环变量,只在for中有效,for结

束则循环变量被释放(回收)。

②while:很常用,用在循环时候要先

检查循环条件再处理循环体,用在与次数无关的

情况。如果不能明确结束条件的时候,先使用

while(true),在适当条件使用if语句加break

结束循环。

③do-while:在循环最后判断是否结束

的循环。如:使用while(true)实现循环的时

候,结束条件break在while循环体的最后,就

可以使用do-while。do-while的结束条件经

常是“否定逻辑条件”,不便于思考业务逻辑,

使用的时候需要注意。可以利用while(true)

+break替换。

④循环三要素:A.循环变量初值B.循

环条件C.循环变量增量(是循环趋于结束的

表达式)

⑤for和while循环体中仅一条语句,

也要补全{},当有多条语句,且不写{}时,它

们只执行紧跟着的第一条语句。

⑥循环的替换:

while(布尔表达式){}等价

for(;布尔表达式;){}

while(true){}

for(;;)

while(true){}+break替换

21等价

do{}while(布尔表达式);

for(;;)+break替换

do{}while(布尔表达式);

3)跳转控制语句

continue:退出本次循环,直接执行下

一次循环

break:退出所有循环

2.7数组

类型一致的一组数据,相当于集合概念,在

软件中解决一组,一堆XX数据时候使用数组。

1)数组变量:是引用类型变量(不是基本

变量)引用变量通过数组的内存地址位置引用了

一个数组(数组对象),即栓到数组对象的绳子。

eg:数组变量的赋值

int[]ary=newint[3];//

ary----->{0,0,0}<----ary1

int[]ary1=ary;//ary的地址赋值给

ary1,ary与ary1绑定了同一个数组

//ary[1]与ary1[1]是同一个元素,数

组变量不是数组(数组对象)

2)数组(数组对象)有3种创建(初始化)

方式:①newint[10000]给元素数量,适合不

22

知道具体元素,或元素数量较多时②new

int[]{3,4,5}不需要给出数量,直接初始化具

体元素适合知道数组的元素。③{2,3,4}静态

初始化,是②简化版,只能用在声明数组变量的

时候直接初始化,不能用于赋值等情况。

eg:数组初始化int[]ary1=newint[]{2,3,4};//创建数

组时候直接初始化元素int[]ary2={2,3,4};//数组静态初始化,

只能在声明变量的同时直接赋值//ary2={4,5,6};//编译错误,不能用于

赋值等情况ary2=newint[]{4,5,6};

3)数组元素的访问:①数组长度:长度使

用属性访问,获取数组下标。②数

组下标:范围:0~length-1就是[0,length),

超范围访问会出现下标越界异常。③使用[index]

访问数组元素:ary[2]。④迭代(遍历):就是

将数组元素逐一处理一遍的方法。

4)数组默认初始化值:根据数组类型的不

同,默认初始化值为:0(整数)、0.0(浮点数)、

false(布尔类型)、u0000(char字符类型,

显示无效果,相当于空格,编码为0的字符,是

控制字符,强转为int时显示0)、null(string

类型,什么都没有,空值的意思)。

5)数组的复制:数组变量的赋值,是并不

23

会复制数组对象,是两个变量引用了同一个数组

对象。数组复制的本质是创建了新数组,将原数

组的内容复制过来。

6)数组的扩容:创建新数组,新数组容量

大于原数组,将原数组内容复制到新数组,并且

丢弃原数组,简单说:就是更换更大的数组对象。

opy()用于复制数组内容,简化

版的数组复制方法:()方法,但

需JKD1.5+。

2.8字符串

字符串(string):永远用“”双引号(英文状

态下),用字符串连接任何数据(整数),都会默

认的转化为字符串类型。

字符串与基本数据类型链接的问题:如果第一

个是字符串那么后续就都按字符串处理,如

n("(Result)"+6+6);那么

结果就是(Result)66,如果第一个和第二个…第

n个都是基本数据,第n+1是字符串类型,那么

前n个都按加法计算出结果在与字符串连接。如

为3java34。

eg:字符串前后的“+”都是连接符!不是加

法运算符!

24

例中的

n(1+2+”java”+3+4);结果

n("A"+'B'

);//AB

n('A'+'B'

);//131

n(1+2+”j

ava”+3+4);//3java34

注意事项:比较字符串是否相等必须使用

equals方法!不能使用==。"1".equals(cmd)

比("1")要好。

2.9方法三要素

方法:method(函数function=功能)y=f(x)

1)方法的主要三要素:方法名、参数列表、

返回值。

2)什么是方法:一个算法逻辑功能的封装,

是一般完成一个业务功能,如:登录系统,创建

联系人,简单说:方法是动作,是动词。

3)方法名:一般按照方法实现的功能定名,

一般使用动词定义,一般使用小写字母开头,第

二个单词开始,单词首字母大写。如:

25

createContact()。

4)参数列表:是方法的前提条件,是方法执

行依据,是数据。如:

login(Stringid,Stringpwd),参数

的传递看定义的类型及顺序,不看参数名。

5)方法返回值:功能执行的结果,方法必须

定义返回值,并且方法中必须使用return语句

返回数据;如果无返回值则定义为void,此时

return语句可写可不写;返回结果只能有一个,

若返回多个结果,要用数组返回(返回多个值)。

注意事项:递归调用:方法中调用了方法本

身,用递归解决问题比较简练,只需考虑一

层逻辑即可!但是需要有经验。一定要有结

束条件!如:f(1)=1;递归层次不能太深。

总之:慎用递归!

2.10插入排序

将数组中每个元素与第一个元素比较,如果这

个元素小于第一个元素,则交换这两个元素循环

第1条规则,出最小元素,放于第1个位置经

过n-1轮比较完成排序。

26

for(inti=1;i<;i++){intk=arr[i];//取出待插入元素intj;//到插入位置for(j=i-1;j>=0&&k

j--){arr[j+1]=arr[j];//移动元素}arr[j+1]=k;//插入元素n(ng(arr)

);

}

2.11冒泡排序

比较相邻的元素,将小的放到前面。

for(inti=0;i<-1;i++)

{booleanisSwap=false;for(intj=0;j<-i-

27

1;j++){if(arr[j]>arr[j+1]){intt=arr[j];arr[j]=arr[j+1];arr[j+1]=t;isSwap=true;}}if(!isSwap){break;}n(ng(arr)

);

}

2.12冒泡排序:轻气泡上浮的方式

冒泡排序法可以使用大气泡沉底的方式,也可

以使用轻气泡上浮的方式实现。如下为使用轻气

泡上浮的方式实现冒泡排序算法。for(inti=0;i<-1;i++)

28

{booleanisSwap=false;

for(intj=-1;j>

i;j--){

if(arr[j]

arr[j]=arr[j-1];

arr[j-1]=t;

sSwap=true;

}

}

if(!isSwap){break;}

n(ng(arr));

}

2.13二分法查

intlow=0;inthigh=-

29

1;intmid=-1;

while(low<=high){mid=(low+high)/2;if(arr[mid]value){high=

mid-1;}

else{break;}

}

if(low<=high){n("可以到:index="+

mid+"。");

}else{n("无法

到!");}

二分法思想是取中,比较:

1)求有序序列arr的中间位置mid。2)k

为要查的数字。

若arr[mid]==k,查成功;

30

若arr[mid]>k,在前半段中继续进行二分

查;

若arr[mid]

分查。

假如有一组数为3、12、24、36、55、68、75、

88要查给定的值k=24。可设三个变量low、mid、

high分别指向数据的上界,中间和下界,mid=

(low+high)/2.

1)开始令low=0(指向3),high=7(指向88),

则mid=3(指向36)。因为k

段中查。

2)令新的high=mid-1=2(指向24),而low=0

(指向3)不变,则新的mid=1(指向12)。此

时k>mid,故确定应在后半段中查。

3)令新的low=mid+1=2(指向24),而high=2

(指向24)不变,则新的mid=2,此时

k=arr[mid],查成功。

如果要查的数不是数列中的数,例如k=25,

当第四次判断时,k>mid[2],在后边半段查,

令low=mid+1,即low=3(指向36),high=2(指

31

向24)出现low>high的情况,表示查不成功。

2.14Java系统API方法调用

Arrays类,是数组的工具类,包含很多数

组有关的工具方法。如:

1)toString()连接数组元素为字符

串,方便数组内容输出。

2)equals比较两个数组序列是否相

等。

3)sort()对数组进行排序,小到大排

序。

4)binarySearch(names,"Tom")二分

查,必须在有序序列上使用。

2.15二进制基础

1)计算机中一切数据都是2进制的!基本类

型,对象,音频,视频。

2)10进制是人类习惯,计算按照人类习惯利

用算法输入输出。

"10"-算法转化->1010(2)1010-算法转化->"10"

3)16进制是2进制的简写,16进制就是2进

制!

4)计算机硬件不支持正负号,为了解决符号

问题,使用补码算法,补码规定高位为1则为负

数,每位都为1则为-1,如11111111=-1=0xff

5)二进制数右移>>:相当于数学/2(基数),

32

且正数高位补0,负数高位补1;二进制字左移

<<:相当于数学*2(基数),且低位补0;二进

制数无符号右移>>>:相当于数学/2(基数),

且不论正负,高位都补0。

6)注意掩码运算:把扩展后前面为1的情况

除去,与0xff做与运算。

eg1:二进制计算

intmax=0x7fffffff;longl=max+

max+2;n(l);//0

eg2:二进制运算(拼接与拆分)

intb1=192;intb2=168;intb3=1;int

b4=10;intcolor=0xD87455;

intip=(b1<<24)+(b2<<16)+(b3<<8)+b4;

//或者ip=(b1<<24)|(b2<<16)|(b3<<8)

|b4;

intb=color&0xff;//85intg=(color>>>

8)&0xff;//116intr=(color>>>

16)&0xff;//216

2.16Java基础其他注意事项

❖Java程序严格区分大小写。

❖类名,每个单词首字母必须大写(公司规

范!)。

❖一个Java应用程序,有且只有一个main

33

方法,作为程序的入口点。

❖每一条Java语句必须以分号结束。

❖类定义关键字class前面可以有修饰符(如

public),如果前面的修饰符是public,该

类的类名必须要与这个类所在的源文件名

称相同。

❖注意程序的缩进。

❖doublea[]=newdouble[2];//语法可以,

但企业中一定不要这么写,Java中[]建议

放前面。

❖Java中所有范围参数都是包含0,

不包含结

束,如

intn=t(26);//

生成0到26范围内的随机数,不包括26。

❖任何数据在内存中都是2进制的数据,内存

中没有10进制16进制。

❖intn=nt(str);//将字符

串-->int整数。

❖n(ryStrin

g(maxL));Long类型用。

34

❖程序:数据+算法数据即为变量,算法为数

据的操作步骤,如:顺序、选择、循环。

❖字符串按编码大小排序。

35

面向对象

Object:对象,东西,一切皆对象==啥

都是东西

面向对象核心:封装、继承、多态。

3.1类

1)是同类型东西的概念,是对现实生活中

事物的描述,映射到Java中描述就是class定

义的类。类是对象的模板、图纸,是对象的数据

结构定义。简单说就是“名词”。

2)其实定义类,就是在描述事物,就是在

定义属性(变量)和方法(函数)。

3)类中可以声明:属性,方法,构造器;

属性(变量)分为:实例变量,局部变量;实例

变量:用于声明对象的结构的,在创建对象时候

分配内存,每个对象有一份!实例变量(对象属

性)在堆中分配,并作用于整个类中,实例变量

有默认值,不初始化也能参与运算;局部变量在

栈中分配,作用于方法或语句中,必须初始化,

有值才能运算。

4)类与类之间的关系:①关联:一个类作

为另一个类的成员变量:需要另一个类来共同完

成。classA{pulicBb}classB{}②继

承:classBextendsA{}classA{}③

依赖:个别方法和另一个类相关。classA{publicvoidf(Bb){}//参数里有B

publicBg(){}//返回值里有B}classB{}

36

5)null

与空指针异常:引用类型变量用于存

放对象的地址,可以给引用类型赋值为null,

表示不指向任何对象。当某个引用类型变量为

null时无法对对象实施访问(因为它没有指向

任何对象)。此时,如果通过引用访问成员变量

或调用方法,会产生ullPointerException空

指针异常。

注意事项:除了8中基本类型,其他都是引

用类型变量(也叫句柄)。

3.2对象

是这类事物实实在在存在的个体!利用类做为

模板创建的个体实例,本质是数据。

匿名对象:使用方式一:

当对对象的方法只调

用一次时,可用匿名对象来完成,

这样比较简化。

37

如果对一个对象进行多个成员调用,则必须给这

个对象起个名字。使用方式二:可以将匿名对象作为实际

参数进行传递。

3.3包

1)包名必须是小写,多个单词用“.”隔开。

在同一个包中,不能有同名的类!

2)只要在同一个包中,则可直接用extends

(类型互知道在哪),若不在同一个包中,则用

import导入。

3.4方法及其调用

是用于对当前对象数据进行算法计算,实现

业务功能。方法是对象的功能,对象的动作,对

象的行为。总之是动词!方法名没有规定,建议

首单词为小写动词,其他单词首字母大写。必须

定义返回值!可有无参数方法。

方法调用只有两

种方式:①对象引用调用②类名调用

(即静态类

时)。

3.5引用

是对个体的标识名称。

1)是代词,是对象的引用,就像拴着对象

的绳子。

2)引用本身不是对象!引用指代了对象!

3)引用的值是对象的地址值(或叫句柄),

通过地址值引用了对象。

38

4)引用的值不是对象!

注意事项:“.”叫取成员运算,可以理

解为“的”。

3.6访问控制(封装)

封装:将数据封装到类的内部,将算法封装

到方法中。

1)封装原则:将不需要对外提供的内容都

隐藏起来,把属性都隐藏,提供公共方法对其访

问,通常有两种访问方式:set设置,get获取。

2)封装结果:存在但是不可见。

3)public:任何位置可见,可以修饰:类、

成员属性、成员方法、内部类、跨包访问类(需

要使用import语句导入),成员属性==成员

变量。

4)protected:当前包中可见,子类中可见。

可以修饰:成员属性、成员方法、内部类(只能

在类体中使用,不能修饰类)。

5)默认的:当前包内部可见,就是没有任

何修饰词,可以修饰:类、成员属性、成员方法、

内部类,但在实际项目中很少使用。默认类(包

内类)的访问范围:当前包内部可见,不能在其

他包中访问类,访问受限!main方法若定在默

认类中JVM将不到,无法执行,因此必定在

public类中。

6)private:仅仅在类内部可见。可以修饰:

成员属性、成员方法、内部类(只能在类体中使

用,不能修饰类)。私有的方法不能继承,也不

能重写。

注意事项:在企业项目中建议:所有类都是

公用类。封装的类使用内部类!

3.7构造器

用于创建对象并初始化对象属性的方法,叫

“构造方法”,也叫“构造器”;构造器在类中定

义。

39

1)构造器的名称必须与类名同名,包括大

小写。

2)构造器没有返回值,但也不能写void,

也不能写return。

3)构造器的参数:一般是初始化对象的前

提条件。

4)用new调用!且对象一建立,构造器就

运行且仅运行一次。一般方法可被调用多次。

5)类一定有构造器!这是真的,不需要质

疑!

6)如果类没有声明(定义)任何的构造器

,Java编译器会自动插入默认构造器!

7)默认构造是无参数,方法体是空的构造

器,且默认构造器的访问权限随着所属类的访问

权限变化而变化。如,若类被public修饰,则

默认构造器也带public修饰符。

8)默认构造器是看不到的,一旦自己写上

构造器则默认构造器就没有了,自己写的叫自定

义构造器,即便自己写的是空参数的构造器,也

是自定义构造器,而不是默认构造器。

9)如果类声明了构造器,Java编译器将不

再提供默认构造器。若没手动写出无参构造器,

但却调用了无参构造器,将会报错!

eg:默认构造器

publicclassDemo{publicstatic

voidmain(String[]args){Foofoo=newFoo();//调用了

javac自动添加的默认构造器!//Kookoo=newKoo();//编译错

40

误,没有Koo()构造器Kookoo=newKoo(8);}}classFoo{}//Foo有构造器,有无参

数的默认构造器!

classKoo{publicKoo(inta)

{//声明了有参数构造器

n("CallKoo(int)");}}

10)构造器是可以重载的,重载的目的是为

了使用方便,重载规则与方法重载规则相同。

11)构造器是不能继承的!虽说是叫构造方

法,但实际上它不是常说的一般方法。

12)子类继承父类,那么子类型构造器默认

调用父类型的无参数构造器。

41

13)子类构造器一定要调用父类构造器,如

果父类没有无参数构造器,则必须使用super(有

参数的),来调用父类有参的构造器。那么,为

什么子类一定要访问父类的构造器?

因为父类中的数据子类可以直接获取。所以子类

对象在建立时,需要先查看父类是如何对这些数

据进行初始化的,所以子类在对象初始化时,要

先访问一下父类中的构造器。

总之,子类中至少会有一个构造器会访问父类

中的构造器,且子类中每一个构造函数内的第一

行都有一句隐式super()。

3.8super()、super.和this()、this.

1)this:在运行期间,哪个对象在调用this

所在的方法,this就代表哪个对象,隐含绑定

到当前“这个对象”。

2)super():调用父类无参构造器,一定在

子类构造器第一行使用!如果没有则是默认存在

super()的!这是Java默认添加的super()。

3)super.是访问父类对象,父类对象的引

用,与this.用法一致

4)this():调用本类的其他构造器,按照

参数调用构造器,必须在构造器中使用,必须在

第一行使用,this()与super()互斥,不能同

时存在

5)this.是访问当前对象,本类对象的引

用,在能区别实例变量和局部变量时,this可

省略,否则一定不能省!

6)如果子父类中出现非私有的同名成员变

量时,子类要访问本类中的变量用this.;子

类要访问父类中的同名变量用super.。

eg1:方法参数传递原理与this关键字

42

eg2:this.和this()Cellc=newCell();

n(c.x+","+c.y);

classCell{intx;inty;publicCell()

{this(1,1);//调用本类的其他构造器}publicCell(intx,inty){this.x=x;this.y=y;}}

eg3:super()

classXoo{publicXoo(ints){n("Call

构造器中调用父类的构造器

43

Xoo(int)");}}//super()用于在子类

classYooextendsXoo{//publicYoo(){}//

编译错误,子类

publicYoo(){//super();//

编译错误,子类调

用不到父类型无参数构造器super(100);//super(100)

调用了父类Xoo(int)构造器}}

3.9重载和重写

调用不到父类型无参数构造器

1)重写:通过类的继承关系,由于父类中

的方法不能满足新的要求,因此需要在子类中修

改从父类中继承的方法叫重写(覆盖)。

①方法名、参数列表、返回值类型与父

类的一模一样,但方法的实现不同。若方法名、

参数列表相同,但返回值类型不同会有变异错

误!若方法名、返回值类型相同,参数列表不同,

则不叫重写了。

②子类若继承了抽象类或实现了接口,

则必须重写全部的抽象方法。若没有全部实现抽

象方法,则子类仍是一个抽象类!

③子类重写抽象类中的抽象方法或接

口的方法时,访问权限修饰符一定要大于或等于

被重写的抽象方法的访问权限修饰符!

④静态方法只能重写静态方法!

2)重载:方法名一样,参数列表不同的方

法构成重载的方法(多态的一种形式)。

44

①调用方法:根据参数列表和方法名调用不

同方法。

②与返回值类型无关。

③重载遵循所谓“编译期绑定”,即在

编译时根据参数变量的类型判断应调用哪个方

法。eg:重载

char[]ary2={'A','B','C'};

n(ary1);//println(Object

)

//按对象调用,结

果为地址值,没有println(int[])

n(ary2);//println(char[]

)n('

');//println(char)中n((int)'

');//println(int)20013

3.10继承

int[]ary1={'A','B','C'};

父子概念的继承:圆继承于图形,圆是子概

45

念(子类型Subclass)图形是父类型(Super

Class也叫超类),继承在语法方面的好处:子

类共享了父类的属性和方法的定义,子类复用了

父类的属性和方法,节省了代码。

1)继承是isa:“是”我中的一种,一种

所属关系。

2)子类型对象可以赋值给父类型变量(多

态的一种形式),变量是代词,父类型代词可以

引用子类型东西。

3)继承只能是单继承,即直接继承,而非

间接继承。因为多继承容易带来安全隐患,当多

个父类中定义了相同功能,当功能内容不同时,

子类无法确定要运行哪一个。

4)父类不能强转成子类,会造型异常!子

类向父类转化是隐式的。

5)只有变量的类型定义的属性和方法才能

被访问!见下例。

6)重写遵循所谓“运行期绑定”,即在运行

的时候根据引用变量指向的实际对象类型调用

方法。

eg:Shapes,s只能访问Shape上声明的属

性和方法Circlec=newCircle(3,4,5);Shapes=c;//父类型变量s引

用了子类型实例//s和c引用了同一个对象new

Circle(3,4,5)();

n(c.r);n(());//n(());//编译错

误//n(s.r);//

在Shape上没有定义r属性!

7)引用类型变量的类型转换instanceofpublicstaticvoidmain(String[]args){Circlec=newCircle(3,4,5);Rectr

=newRect(3,4,5,6);Shapes=c;Shapes1=r;//Circlex=s;//编译错误,父类型变量

不能赋值给子类型Circlex=(Circle)s;//正常执行//Circley=(Circle)s1;//运行异常,类

型转换异常

47//instaceofinstace:实例of:的//instaceof运算检查变量引用的对象的

类型是否兼容//s引用的是圆对象,sinstanceofCircle

检查s引用的对象是否是Circle类型的实例!n(s

Circle);//n(s1

Circle);//falsetest(c);test(r);}publicstaticvoidtest(Shapes){//多态

的参数//if(sinstanceofCircle)保护了

(Circle)s不会出现异常if(sinstanceofCircle){//实现了安全的

类型转换Circle

"+());

}

48

instanceof

instanceof

c=(Circle)s;

n("这是一个圆,面积if(sinstanceofRect){Rectr=(Rect)s;n("这是一个矩形,面积

"+());}}

8)继承时候对象的创建过程

①Java首先递归加载所有类搭配方法

区。②分配父子类型的内存(实例变量)。③递

归调用构造器。

9)重写方法与重载方法的调用规则

49

10)属性绑定到变量的类型,

由变量类型决定

访问哪个属性;方法动态绑定到对象,

由对象的

类型决定访问哪个方法。

(强转对方法动态绑定

到对象无影响,因为强转的是父类的引用,

而实

例是没变的,

只是把实例当作另一个状态去看而

已。但是强转对属性动态绑定到变量类型有影

响。)其他解释请看多态部分!

eg1:方法动态绑定到运行期间对象的方法

50

-

最全的java学习笔记(必看)

发布时间:2022-04-13 02:51:02
文章版权声明:除非注明,否则均为IT技术网-学习WEB前端开发等IT技术的网络平台原创文章,转载或复制请以超链接形式并注明出处。

发表评论

评论列表 (有 20 条评论,760人围观)

最近发表

随便看看

热门文章

标签列表