CoreJavaWord文档格式.docx
《CoreJavaWord文档格式.docx》由会员分享,可在线阅读,更多相关《CoreJavaWord文档格式.docx(50页珍藏版)》请在冰豆网上搜索。
SRC――――――-类库
BIN―――――――应用程序
基础知识
配置环境
LINUX系统(修改环境配置文件)
1打开shell
2vi.bash_profile
3JAVA_HOME=JAVA目录路径
4PATH=$JAVA_HOME/bin:
其他路径
5CLASSPATH=.
6exportJAVA_HOMECLASSPATH
Windows系统
我的电脑属性―――>
环境变量
设置环境变量:
JAVA_HOME=路径
PATH=%PATH%;
c:
\j2sdk1.4.2_05\bin;
CLASSPATH=.;
Java中基本概念
1)源文件
在最顶层只包括一个public类型的类/接口,文件名与类/接口名同并以.java作为文件后缀。
2)包(package,在源文件中thisidentify只能放在第一行,且最多只能是一行)
一个将类和接口组织在一块的实体,在文件系统中以目录/文件夹型式呈现。
定义,关键字和类型
注释的三种形式
//单行注释
/*一或多行注释*/
/**文档注释*/
Java代码中的“;
”、“{}”、“”
Java语句以分号分隔;
Java代码块包含在大括号内;
忽略空格。
标识符
1)用以命名类、方法和变量、以及包;
遵守JAVA的命名规范
类以每个单词都以大写字母开头。
方法和变量第一个字母不大写,其他依旧
2)以字符、“_”或“$”开头;
3)无长度限制。
数据类型
1)整型
byte1B8位-128到127
short2B16位-2^15到2^15-1
int4B32位-2^31到2^31-1
long8B64位-2^63到2^63-1
2)浮点类型
float4B32位
double8B64位
3)字符类型
char2B16位
4)布尔型
booleanfalse/true
注:
1)char是无符号的16位整数,字面值必须用单引号括起来;
‘a’
2)String是类,非原始数据类型;
3)长整型数字有一个后缀为“L”或“l”,八进制前缀为“0”,十六进制前缀为“0x”;
4)黙认浮点类型为double;
5)float数据类型有一个后缀为“f”或“F”,Double数据类型后可跟后缀“D”或“d“
命名规则
1)类/接口名首字母大写;
2)方法、变量名第一个字母小写,其余首字母大写;
3)常量名称全部大写;
4)包名全部小写。
表达式和控制流
变量和作用域
1)局部变量
定义在方法内部,其作用域为所在代码块,也称为临时变量、栈变量。
存在于栈中。
2)实例变量
定义在类内部方法之外,其作用域为整个类。
如未定义初值,系统会自动为其赋黙认值。
存在于堆中
默认数值
类型黙认值
byte0
short0
int0
long0L
float0.0f
double0.0d
char'
\u0000'
空格
booleanfalse
*Allreferencetypesnull
操作符
System.out.println(3/2)按整型计算得1
1)>
>
前面是零补零,前面是一补一;
2)>
无符号右移;
3)&
&
短路与,前面为假,表达式为假,后面不须计算;
4)||短路或,前面为真,表达式为真,后面不计算;
例:
if(a<
3&
(b=a)==0)b赋值
(b=a)==0)b不赋值
数字类型之间的转换
1)byte——→short——→int——→long
2)char——→int---→float
3)float——→double
4)long---→float
5)long---→double
6)int——→double
1)实箭头表示无信息损失的转换,虚箭头表示转换可能引起损失;
2)int和float同为32位,但float要有几位表示幂的位数,在精度位数上要比int要小,所以有可能会有损失。
long转为double同理;
3)char和short同为16位,但char属无符号数,其范围为0~2^16,short的范围为-2^15~2^15-1,所以char和short不能相互转换;
4)byte、short、char属child型,在计算时会自动转为int型,然后转为更大范围类型(long、short、double)。
强制类型转换
1)语法:
圆括号中给出要转换的目标类型,随后是待转换的变量名。
例:
doublcx=9.997;
intnx=(int)x;
2)如果试图强制转换的类型超出了目标类型的范围,结果是一个被截取的不同的数值;
3)不能在布尔值和任何数字类型间强制类型转换,如确要转换,可使用条件表达式,例:
b?
1:
0。
转换的二种类型
1)赋值
doublea=1.0f
int=‘j’;
2)方法调用
doubleconverValue(intvalue){
returnvalue;
}
3)数值计算转换-9.232e20+1;
控制流
if()
if()….else
if()…..elseif()….else
switch(){
casevariable:
……..
default:
…………
注解:
switch()内数据类型为child类型byteshortchar自动转换为int
case块中不加break时顺序执行下面的语句。
循环语句
for(inti=0;
i<
n;
i++){}
while(){}
do{}while();
-----------加分号
例子:
loop:
i++){
for(intj=0;
j<
m;
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
数组
声明数组
1)一组相同类型(可以是类)数据的集合;
2)一个数组是一个对象;
3)声明一个数组没有创建一个对象;
4)数组能以下列形式声明:
int[]i或inti[]
Car[]c或Carc[]
*C++中只能Carc[]
*JAVA中推荐用Car[]c;
创建数组
1)创建基本数据类型数组int[]i=newint[2];
2)创建引用数据类型数组Car[]c=newCar[100];
3)数组创建后有初始值。
数字类型为0布尔类型为false引用类型为null
初始化数组
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;
请问以下哪段代码哪个可正确执行?
(a,c)
1.achar[]i={'
a'
'
b'
};
i=newchar[]{'
c'
bchar[]i={'
i={'
cchar[]i=newchar[2];
dchar[]i=newchar[2];
数组拷贝
System.arrayCopy(Object
src,int
srcPos,Object
dest,int
destPos,int
length);
拷贝一个数组到另一个数组。
对象和类
面向对象与面向过程
为什么要使用面向对象:
首先,面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的,只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数,也可能有返回值。
注意区分:
对象(本身)、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象,类是对象的抽象。
其次,采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低(比如不同硬盘和不同主板之间的关系)。
这样才能使每个对象本身做成最好的。
对于对象的要求:
高内聚、低耦合,这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性(复用性好是因为高内聚)。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想:
面向过程的思想:
由过程、步骤、函数组成,以过程为核心;
面向对象的思想:
以对象为中心,先开发类,得到对象,通过对象之间相互通信实现功能。
面向过程是先有算法,后有数据结构。
面向对象是先有数据结构,然后再有算法。
在用面向对象思想开发的过程中,可以复用对象就进行复用,如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法,来实现复杂的功能。
从语法上来看,一个类是一个新的数据类型。
在面向对象编程中,除了简单数据类型,就是对象类型。
定义类的格式:
classStudent{
代码
注意类名中单词的首字母大写。
对象的概念
什么是对象:
EVERYTHINGISOBJECT(万物皆对象)
所有的事物都有两个方面:
1.有什么(属性):
用来描述对象。
2.能够做什么(方法):
告诉外界对象有那些功能。
后者以前者为基础。
*一个对象的属性也可以是一个的对象。
这是一种对象的关联(associate)
publicclassStudent{
privateStringname;
---------对象
privateintage;
---------------基本类型
privategender;
publicvoidstudy(){}---------方法
成员变量和局部变量
1.实例变量:
定义在类中但在任何方法之外。
(New出来的均有初值)
实例变量中对象默认值为null。
实例变量的作用域在本类中完全有效,当被其他的类调用的时候也可能有效。
2.局部变量:
定义在方法之中的变量。
局部变量要先赋值,再进行运算,而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
局部变量不允许范围内定义两个同名变量。
实例变量和局部变量允许命名冲突,但在局部变量的作用域内局部变量优先,访问实例变量是使用this.variableName。
成员方法
方法定义
1)格式<
modifiers>
<
return_type>
name>
([argument_list>
])[throws<
exception>
]{<
block>
}
例如:
publicStringgetName(){returnname;
}
2)当没有返回值时,返回类型必须被定义为void。
3)构造方法没有返回类型。
4)返回类型必须与方法相邻,其他修饰符号可以调换位置。
参数传递
Java语言总是使用传值调用。
这意味着方法得到的只是所有参数值的拷贝。
因此,方法不能修改传递给它的任何参数变量的内容。
对于对象类型的参数传递的也是该对象的引用值,方法中并不能改变对象变量,但能通过该变量调用对象的方法或修改对象的成员。
This关键字
1)this是个隐式参数,代表被构造的对象;
publieclassPerson{
privateStringname;
publicvoidsetName(Stringname){
this.name=name;
-------------this.name为成员变量
2)如果构造器的第一个语句具有形式this(...),那么这个构造器将调用同一类中的其他构造器。
3)在构造器中this()必须放在方法的第一行。
*Super关键字也是个隐形参数,代表被构造对象的父类。
同样也必须在构造方法的第一行
访问控制符
权限高
public全部可见
protected本类可见,同包可见,子类可见
default本类可见,同包可见
private本类可见
权限低
构造方法
构造方法是在生成对象的过程中调用的方法,但构造方法并不能创建对象。
其特点为:
1.构造方法没有返回值。
2.构造方法的方法名与类名相同。
格式为:
publicClassName(){}
构造方法也可以是其他的限制符――privateprotecteddefaultprivate一般用在singleton模式中。
在一个对象的生成周期中构造方法只用一次,一旦这个对象生成,那么这个构造方法失效。
*接口不能创建实例,因为没有构造方法
可以构造多个构造方法,但多个构造方法的参数表一定不同,参数顺序不同即属于不同的构造方法:
-----------------------构造方法的重载
publicstudent(stringname,inta){
publicstudent(inta,stringname){
为两个不同的构造方法。
如果我们未给系统提供一个构造方法,那么系统会自动提供一个为空的构造方法。
如果我们提供了有参的构造方法,那么系统不会再提供无参的构造方法了。
这样当被子类继承时,如果子类构造方法不人为调用父类的有参构造方法就会出现异常。
数据的隐藏―――封装
publicclassPerson{
----------------------数据的隐藏
publicStringgetName(){-------------------方法尽量公开
returnname;
publicintgetAge(){
returnage;
方法的重载
Overloading在一个类中可以定义多个同名方法,各个方法的参数表一定不同。
但修饰词可能相同,返回值也可能相同。
在程序的编译过程中根据变量类型来找相应的方法。
Overloading被认为是编译时的多态。
Overloading只是为方便程序员编程的解决方法,编译之后的方法名实际加上了各参数类型成为唯一的名字。
普通方法
publicvoidaa(inta,doubleb)throwsIOException{}
privateintaa(doublea,intb){}
protecteddoubleaa(Stringa,Stringb){}
构造方法也可以实现overloading。
publicvoidteach(){};
publicvoidteach(inta){};
publicvoidteach(Stringa){}为三种不同的方法。
Overloading方法对于不匹配的参数是从低向高转换的。
Byte—short—float—int—long—double。
高级语言特性
封装(encapsulation)
a.把数据和行为结合在一个包中,并对对象的使用者隐藏数据的实现过程。
对象中的数据称为对象的实例字段(instancefield),操作数据的函数和过程称为对象的方法(method)。
一个特定对象就是类在实例字段上有着特定值的某个实例。
b.实现封装的关键在于绝不让方法直接访问其他类的实例字段。
继承(inherit)
JAVA继承特点
1.在现有类的基础上构建新的类。
当继承一个现有类时,就重用(继承)了那个类的方法和字段,同时,还可以向新类中增添新的方法和字段。
2.在通过扩展超类来定义子类时,只需要说明子类和超类的区别就行。
所以在设计类时,把最通用的方法放在超类中,把更专门的方法放在子类中。
3.JAVA中不允许多继承,一个类有且只有一个父类。
所以JAVA的数据结构为树型结构,而非网状。
(JAVA通过接口实现多继承)
父类(SuperClass)和子类(SubClass)的关系
父类的非私有化属性(不同包的子类无法访问default修饰符)和方法可以默认继承到子类。
ClassSonextendsFather{
而如果父类中的私有方法被子类调用的话,则编译报错。
父类的构造方法子类不可以继承,更不存在覆盖的问题。
所以子类构造方法默认调用父类的无参构造方法。
(所以养成写无参构造的习惯)
如果子类访问父类的有参构造方法,必须在子类构造方法第一行使用super(参数)
当构造一个对象的时候,系统先构造父类对象,再构造子类对象。
系统构造一个对象的顺序
1先为最里层类成员属性赋初值;
2再构造该类对象;
3返回外层,重复1(上一层类)、2步骤直到完成最外层类的构造。
多态(polymorphism)
多态:
一个对象变量可以指向多种实际类型的现象。
方法的覆盖(overridding)
当子类从父类继承一个无参方法,而又定义了一个同样的无参方法,则子类新写的方法覆盖父类的方法,称为覆盖。
(注意返回值类型也必须相同,否则编译出错。
)
如果方法参数表不同,则成重载。
特点:
1.对于方法的访问限制修饰词,子类方法要比父类的访问权限更高。
父类为public,那么子类为private则出现错误。
2.子类抛出的异常应该是父类抛出的异常或其子类。
多态的分类
多态分两种:
1编译时多态:
编译时动态重载;
2运行时多态:
指一个对象可以具有多个类型。
猫,小鸟,狗都是动物,都可以安上动物的标签。
InterfaceAnimal{}
ClassCarimplementsAnimal{}
ClassBirdimplementsAnimal{}
ClassDogimplementsAnimal{}
方法中
Animala=newCar();
Animalb=newBird();
Animalc=newDog();
运行时多态的三原则
1.对象不变;
(改变的是主观认识)
2.对于对象的调用只能限于编译时类型的方法,如调用运行时类型方法报错。
在上面的例子中:
Animala=newDog();
对象a的编译时类型为Animal,运行时类型为dog。
注意:
编译时类型一定要为运行时类型的父类或者同类型。
对于语句:
Dogd=(Dog)a。
将d强制声明为a类型,此时d为Dog(),此时d就可以调用运行时类型。
a和d指向同一对象。
3.动态类型判定实际调用的方法。
即它调用覆盖后的方法。
关系运算符:
instanceof
instanceofAnimal;
(这个式子的结果是一个布尔表达式)
上面语句是判定a是否可以贴Animal标签。
如果可以贴则返回true,否则返回false。
在上面的题目中:
ainstanceofAnimal返回
True,
ainstanceofDog也返回
用于判定前面的对象是否是后边的类或者子类。
If(ainstanceofDog){
Dogb=(Dog)a;
elseif(ainstanceofCar){
Carc=(Car)a
不会错。
静态变量,方法和类
静态变量
Staticintdata语句说明data为类变量,为一个类的共享变量,属于整个类。
ClassM{
staticintdata;
Mm1=newM();
Mm2=