Java语言程序设计课件

第二章Java语言基础Java数据类型运算符与表达式流程控制语句2.1Java数据类型基本数据类型类型之间的转换Java数据类型的分类简单数据类型Integeral：byte,short,int,longFloating:float,doubleTextual:charLogical:boolean复合数据类型（对象引用类型）

class interface

数组几个概念

1标识符与保留字标识符(identifier):在程序中用来标识各变量或者常量的符号。必须由字母、下划线或$开始，其余字母可以为上述三种字母或者数字合法的标识符：

var_list_a $var2 _var$_2不合法的标识符：

1var var% interface保留字由系统中预定义的，留作专用的标识符。保留字不可以作为标识符。2常量与变量常量:恒值的量必须使用final关键字定义常量，例如

finalfloatCOUNT_RATE=0.02;

finalintAREA=100;系统提供的常量：Math.PI,Math.E变量

floatlength=1.11;intcount=20;2.1.1基本数据类型整型浮点型字符型布尔型整型数据分类

byte shortint long

字节数

1 24 8

数字范围

-128~127-32768~-2,147,483,64832767~2,143,483,647表示法

十进制：12，…

十六进制:0xC1,0x2A34F5,….

八进制：010,…整型数据的使用默认的整型常量为int型

x=12;//此处常量12为int型对于long型常量，当值超出了int范围时，需要添加后缀”L” longx=12000000000L;//正确,“l”亦可

longx=12000000000;//错误

longx=12;//正确整型数据的使用2对于byte,short型变量，在赋值时存在两种情况：如果值不超过规定的范围，不会出现问题如果值超出了规定的范围，会引起语法错误例如

byteb=12;//noproblembyteb=256;//error

声明和初始化intnumber;//这是一个声明

longpopulation=100L;//声明变量并且初始化变量在使用之前必须初始化

bytenum1=56,num2;bytenum3=num1+num2;//错误，num2未初始化浮点型分类

floatdouble

字节数4 8

小数点后6～715

有效位数表示法

十进制小数:0.12,3.14,.56,…

科学计数法:12E-2,314E-2,56E-2

默认的小数都是double型的

floatx=1.2f;//正确

floatx=1.2;//错误字符型数据字符集ASCII字符集：1字节，128个字符扩展的ACSII集：256个字符Unicode字符集：2字节，0~65535char类型占2字节表示法chara=‘a’;charb=“b”；//错误转义字符：为了简便的表达一些常用的特殊字符而采用的方法，即\后跟某个字符组合后被赋予新的意义的字符。常见的如

\u:unicode字符

\t: 制表

\r:回车字符串由标准库提供的String类,并非基本数据类型。每个被双引号引起来的字符串都是String类的一个实例

Stringe=“”;Stringgreeting=“hello”;串的连接:使用符号“+”把两个字符串连接起来

intanswer=2; System.out.println(“theansweris”+answer);布尔型数据布尔型数据只有两个值：false和true。表示：

booleandone=true;2.1.2数据类型之间的转换不同类型的数据在进行各类计算和赋值时需要进行类型转换，转换的原因：数据存储的格式不同，例如整型和浮点型的不同数据在存储空间中所占大小的不同，例如int型和long型的字节数不同不同方向上的转换类型之间的转换

示例1intn=123456789; floatf=n;//有问题：fis1.23456792E8bytea=12;intb=a;//不会出现问题

floatx=1.2f; doubley=x;//noproblem造型（cast）inti=25;byteb=(byte)i;bytec=i;//wrong,

Typemismatch:cannotconvertfrominttobytedoublex=1.25;floaty=(float)x;//rightfloatz=x;//wrong,Typemismatch:cannotconvertfromdoubletofloat1同类型之间大到小的转换必须造型1造型2floatx=1.8f;intn=(int)x;//n=1;

longl=(long)x;intnn=(int)1.8;

整数

实数cast2任何实数到任何整数的转换必须造型2混合运算规则如果存在double类型的数据，则运算的结果为double；否则如果存在float类型的数据，则运算的结果为float；否则如果存在long类型的数据，则运算的结果为long；否则表达式的结果为Int算术混合运算混合运算byteb=1; shortc=2; shorta=b+c;//错误，不能将int类型直接转换为short问：下列语句哪些是正确的，哪些是错误的1longx=32000000000

2intx=24;byteb=x;3byteb=24;byteb=128;4floatx=1.2;booleanbDone=0;6floatx=1.02f;intn=x;7byteb=1;shortc=2;shorta=b+c;2.2运算符与表达式算术运算递增和递减运算关系和布尔运算位运算算术运算运算符号：+,-,*,/,%0除整数发生异常，除浮点数得到无穷大或NaN简便形式：+=，-=,*=,/=,%=18%5=?5%1=?自增、自减运算符号：++,--前、后位置的不同单条语句：

i++;<==>++i;表达式中的项

intm=7;intm=7;intn=++m;<==>intn=m++;

(here,n=8,m=8)

(here,n=7,m=8)

解释：m=m+1n=mn=mm=m+1关系和布尔运算关系运算:比较两个数是否相等符号：==,!=,<,>,>=,<=运算结果只能是true或者false，例如

3==7isfalse3!=7istrue布尔运算（逻辑运算）符号：与(&&),或(||),非(!)A&&B----短路求值

x!=0&&(1/x>x+y)

如果x等于0，则第二个表达式不会被求值

A||B类似。条件运算 （条件）?E1:E2（如果条件真，计算E1，否则计算E2）。

E=x<y?x:y//ifx<y,E=x;else,E=y;位运算位运算处理数据的各个独立位。要理解该运算需要先将数据展成二进制形式。几种位运算方式：&:各位进行“与”运算|:………..“或”运算^:………..“异或”运算~:………..取“反”例子a:5b:‘c’(99)0000,01010110,0011a&b0000,0001a|b0110,0111a^b0110,0110~a1111,1010（－6）~b1001,1100屏蔽的例子intfourthBitFromRight=(n&8)/8;n:****,****8:0000,1000解释：通过适当的2的幂指数，可以把所有其他数据位屏蔽掉，而只剩下单独的某一位。移位运算移位运算<<:将运算对象左移指定的位数，低位补0>>:有符号右移运算符，若对象为正，则高位补0，否则补1>>>:无符号右移，高位补0，对char,byte,short进行移位运算时，会自动转换成int位运算符号也可以与=共同使用，形成&=,|=,^=，>>=,>>>=,<<=。移位的例子publicstaticvoidmain(String[]args){ inti=-1; i>>>=10;

byteb=-1; b>>>=10;

shorts=-1; s>>>=10;

longl=-1; l>>>=10; System.out.println(i); System.out.println(b); System.out.println(s); System.out.println(l);}结果：-1: 11111111111111111111111111111111419430300000000001111111111111111111111-1-118014398509481983几点说明几乎所有的运算符都只能操作基本类型，唯一的例外是“=”，“==”,“!=”；另外，String类支持“+”和“+=”。在C和C++中，一种常见的错误如下：

if(x=y){ //…}

在java里，x=y的值不是布尔值，因此不会被当作布尔结果作条件判断，从而阻止程序的执行。说明(2)：“UlcerAddictsReallyLikeCAlot”，即“溃疡患者特别喜欢（维生素）C”。

运算符的优先顺序助记词运算符类型运算符UlcerUnary+-++–

AddictsArithemetic(andshift)*/%+-<<>>

ReallyRelational><>=<===!=LikeLogical(andbitwise)&&||&|^

CConditionalA>B?X:Y

ALotAssignment=2.3流程控制语句结构化程序设计选择结构循环结构结构化程序设计三种基本结构

结构化程序设计的特点只有一个入口只有一个出口结构内的每一部分都有机会执行到不存在死循环块结构一个块（复合语句）是用一对花括号括起的任意数量的简单Java语句，例如

publicstaticvoidmain(String[]args) { intn; …. { intk; …. } }块范围块作用域块结构决定了块内定义的变量的作用域；块可以嵌套，同时，不可以在嵌套的块内定义已有的变量名。

publicstaticvoidmain(String[]args){ intn; { intk;//kisonlydefineduptohere intn;//error–cannotredefinen

} }条件语句If-else语句是控制程序流程的最基本的形式，其中else是可选的，可按下述两种形式来使用if：

if(bool-expr) statements;

或者

if(bool-expr) statements; else statements;简单的if例子…if(yourSales>=target){ performance=“Satisfactory”; bonus=100+0.01*(yourSales-target);}else{ performance=“Unsatisfactory”; bonus=0;}….重复的if-else选择形如：

if(condition) statement1; elseif(condition2) statement2; elseif(condition3) statement3; …. else//最后一个必须是else statement;例子2staticinttest(inttestval){//matchwithtarget intresult=0; if(testval>target) result=-1; elseif(testval<target) result=1; else result=0; returnresult;}开关语句多个分支结构的判断类型相同时，可以使用switch语句。形如

switch(int-expr) { caseval1:block1; break; caseval2:block2; break; … default:block; }switch语句说明表达式的值必须是整型或者字符型。case后的语句可以是多条语句，此时不需要大括号。每个case的末尾应该用break语句结束。switch语句的例子1chargrade=‘B’;switch(grade) { case‘A’:score=5; break;

case‘B’:score=6; break; case‘C’:score=3; break; default:score=0; }chargrade=‘B’;switch(grade) { case‘A’:score=5; break; case‘B’:score=6; //nobreak case‘C’:score=3; break; default:score=0; }2switch语句的例子3chargrade=‘B’;switch(grade) {

default:score=0; break; case‘A’:score=5; break; case‘B’:score=6; break; case‘C’:score=3; break; }4

switch(month) { case1: case3:case7: days=31;break;case4:case6:days=30;break; }在匹配之后的case语句都被看作是语句标号，不再进行匹配。循环语句满足条件时，反复执行某段程序。三种循环语句while语句do-while语句for语句while语句while语句在循环刚开始时，会计算一次“布尔表达式”的值。后来的每一次循环，都会在开始前重新计算一次。语法形式：

while(bool-expr) statements;例子1while(s=1)//error,Typemismatch:cannotconvertfrominttoboolean

{ i=4; }例子2//:WhileTest.javaWhileTest{ publicstaticvoidmain(String[]args){ doubler=0; while(r<0.99){ r=Math.random(); System.out.println(r); } }}do-while语句while和do-while唯一的区别就是do-while肯定会至少执行一次；而在while循环结构中，若条件第一次就为false，那么其中的语句根本不会执行。在实际应用中，while比do-while更常用一些。语法格式

do{ statements; }while(bool-expr);for循环for循环常常被称为计数器循环，在第一次反复之前要进行初始化。随后，它会进行条件测试，而且在每一次反复的时候，进行某种形式的“步进”（Stepping）。语法形式：

for(初始表达式;布尔表达式;步进)

语句;例子//:ListCharacters.java//Demonstrates"for"loopbylisting//alltheASCIIcharacters.publicclassListCharacters{publicstaticvoidmain(String[]args){for(charc=0;c<128;c++)if(c!=26)//ANSIClearscreenSystem.out.println("value:"+(int)c+"character:"+c);}}说明可以在for语句里定义多个变量，但它们必须具有同样的类型，例如

for(inti=0,j=1;i<10&&j!=11;i++,j++)

/*bodyofforloop*/说明2逗号表达式：使用逗号连接的各表达式按照顺序进行计算。例

//:CommaOperator.javapublicclassCommaOperator{publicstaticvoidmain(String[]args){for(inti=1,j=i+10;i<5;i++,j=i*2){System.out.println("i="+i+"j="+j);}}}输出如下：i=1j=11i=2j=4i=3j=6i=4j=8中断与继续在任何循环语句的主体部分，可用break和continue控制循环的流程。其中，break用于强行退出循环，不执行循环中剩余的语句。而continue则停止执行当前的循环，然后退回循环起始处，开始新的反复。如果在for循环里使用continue，那么它会跳转到for循环的”步进“部分。

while(years<=100){ balance+=payment; doubleinterest=balance*interestRate/100; balance+=interest; if(balance>=goal)

break; years++;}labelledbreakintn;read_data:while(...){ ... for(...) { ... if(n<0) breakread_data;//breakoutofloop } ...}例子//BreakandContinue.javapublicclassBreakandContinue{ publicstaticvoidmain(String[]args){ for(inti=0;i<100;i++){ if(i==74)

break; if(i%9!=0)

continue; System.out.println(i); }

}}执行结果0918273645546372程序设计举例例1----标准输出//文件BasicJava.javapublicclassBasicJava{ publicstaticvoidmain(String[]args){

System.out.println(“Hello,world”); System.out.print(“Hello”); System.out.print(“world”); }}

System类是标准Java类，位于java.lang包内。out是System类的一个静态成员，它是一个输出流对象，流用来控制键盘，显示器等输入输出设备。.是Java的选择器，表示选择类或对象的某个成员。在屏幕输出文字串可以使用out对象的print/println方法：println:输出一行后，光标移到下一行。print:输出一行之后，光标停留在行尾。输出结果：Hello,worldHelloWorldPressanykeytocontinue….例1a----println的使用以及字符串连接publicclassBasicJava{ publicstaticvoidmain(String[]args){ System.out.println(1);//打印整数1

System.out.println(1+2+"DGraphics"); System.out.println("Java"+1+1); }}A println提供重载版本，允许接受以下几类参数:1所有基本类型

2字符串类型String 3Object对象类型B当参数为字符串类型时，允许通过“+”来连接字符串和其他类型

1int+int+“…”;

此时先做加法，再完成连接

2“….”+int+int输出结果：13DGraphicsJava11例1b----打印多行文字publicclassBasicJava{ publicstaticvoidmain(String[]args){ System.out.println(“Javaisanobject orientedprogramminglanguage");//error System.out.println(“Javaisanobject” +”orientedprogramminglanguage”);//right }

}一条Java语句可以分行，但不允许作为参数的字符串分行例2---简单计算：摄氏温度转换成华氏温度publicclassBasicJava{ publicstaticvoidmain(String[]args){ //Temperaturetransition intcelsius=20; intfahrenheit=32+(9*celsius)/5; System.out.println("CelsiusTemperature:"+celsius); System.out.println("FahrenheitTemperature:"+fahrenheit); }}Result:CelsiusTemperature:20FahrenheitTemperature:68如果转换公式写成下面会怎么样？fahrenheit=32+(9/5)*celsiut例2a---简单计算---大小写字母转换publicclassBasicJava{ publicstaticvoidmain(String[]args){

//大小写转换

charlowerChar=‘c’;//或者

lowerChar=99; charupperChar=‘c’-32;//方式1

intupperChar2=(‘A’-‘a’)+lowerChar;//方式2,等号右边是int型

System.out.print(“Character"+lowerChar); System.out.println("\'suppercaseletteris"+(char)upperChar);

}}Characterc’suppercaseletterisC….例2a---简单计算-----英镑和公斤转换publicclassBasicJava{ publicstaticvoidmain(String[]args){

finaldouble

KILOGRAM_PER_POUND=0.454; //KILOGRAM_PER_POUND=1.0;//error,常量不能被修改

doubleweightInPounds=75.5; doubleweightInKilo=weightInPounds*KILOGRAM_PER_POUND;

System.out.println("AweightinPounds"+weightsInPounds); System.out.println("isequalto Kilograms"+Math.round(weightsInKilo));

}}声明常量使用final关键字。常量采用大写字母加下划线的形式。round方法返回浮点数的四舍五入值。例3---输入流要使用输入流，需要创建一个BufferedReader类的对象：1该类位于java.io包内，因此需要一条import语句。2创建一个对象使用new运算符

BufferedReaderstdin=newBufferedReader( newInputStreamReader(System.in));

在这个过程里，用到了一个InputStreamReader对象，而该对象又需要通过一个

System.in变量来创建；3使用输入流可能会造成异常，比如一次非法的输入，因此需要 一条声明程序可能会抛出异常的语句。

publicstaticvoidmain(String[]args)throwsIOException{例3---输入流importjava.io.*;publicclassBasicJava{ publicstaticvoidmain(String[]args)throwsIOException{ …..

BufferedReaderstdin=newBufferedReader(newInputStreamReader(System.in)); doublepounds=Double.parseDouble(stdin.readLine());

doubleweight=pounds*KILOGRAM_PER_POUND; System.out.println("Thepounds"+pounds+"is"+weight+"kilograms"); }}例3---输入流----方法说明1

BufferedReader类提供了readLine方法，该方法可以从输入流中截取字符串：

readLine等待用户输入，将全部输入作为字符串返回，并且不包括用户最后的换行符。

Stringinput=stdin.readLine();2将字符串转换成其他类型的方法：

doublepounds=Double.parseDouble(input);

这里需要使用到double类型的包装类(wrapper)Double，该类位于java.lang包内，它提供了一个静态方法parseDouble，可以从字符串中析取出一个浮点数。 对于整型: intpounds=Integer.parseInt(input);第三章面向对象基础对象、消息和类控制和使用对象数组3.1对象、消息和类

抽象的计算机世界classCar{intcolor_number;intdoor_number;

intspeed;

voidbrake(){…}voidspeedUp(){…};voidslowDown(){…}}

计算机中的对象的原型

现实生活中的对象

数据抽象(ADT)对象的基本组成实例变量：对象拥有什么样的性质和特征？代表了对象的状态。方法：对象能做什么事？是对象的功能单元。对象B对象Amessage什么是消息？软件对象通过相互间传递消息来相互作用和通信一个消息由三部分组成:1.接受消息的对象2.要完成方法的名字3.方法需要的参数System.out.println(…..);123对象的例子

购物车contentsaddToCart()remove()checkOut()Dogsizebreednamebark()eat()instancevariable(state)methods(behavior)instancevariablesmethods对象的类型----类什么是类？类不是对象，类是用于创建对象的。类是描述对象的“基本原型”，它定义一种对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是程序的基本单元。variablesmethods从一个类可以产生很多对象，这些对象都属于这个类，所有对象也称为该类的实例。建立、使用第一个对象需要两个类：实际的类，用来创建具体对象测试类（tester），拥有main()方法，在这里创建并访问对象。1编写实际的类classDog{intsize;Stringbreed;Stringname;voidbark(){System.out.println(“Ruff!”);}}instancevariablesamethod2编写测试类classDogTestDrive{publicstaticvoidmain(String[]args){ //Dogclasstestcode}}只有一个main方法3在测试类内，创建一个对象，并访问该对象的变量和方法。classDogTestDrive{publicstaticvoidmain(String[]args){ Dogd=newDog();d.size=40;d.bark();}}创建一个Dog对象使用点运算符设置Dog的大小并调用它的bark()方法点运算符3.2控制和使用对象与基本类型的变量不同，并不存在“对象变量”。…inta=20;…a++;a(20)内存…a(21)内存通过名字a直接控制变量（它所处的内存）。Dogd=newDog();d.bark();变量d是一个对象引用变量堆内存Dog。。d通过“对象引用”变量(reference)可以操纵对象。byte8short16int32long64reference

引用本身也是值，它是可以访问对象的方式的位码。一个对象引用变量存储“一种访问该对象的方式”的位码。对象创建的步骤DogmyDog=newDog();123声明一个引用变量

DogmyDog=newDog();

告诉虚拟机为该变量分配空间，并命名为myDog。该变量始终是Dog类型的。创建一个对象

Dog

myDog=newDog();

告诉虚拟机在堆中为新的Dog对象分配空间3将该对象与引用连接起来。

Dog

myDog=new

Dog();

现在可以通过这个引用myDog远程控制该Dog对象在堆中的对象Bookb=newBook();Bookc=newBook();b12Book对象Book对象c垃圾回收的堆1References:2Objects:2b12Book对象Book对象c垃圾回收的堆1dBookd=c;d并不引入任何新的对象，只是把c的值复制给d，使得c，d同时控制同一个book对象。References:3Objects:2b12Book对象Book对象c1dc=b;同上，变量b的值复制给c，现在c与b都指向了同一个对象。References:3Objects:2对象的存活和消亡b12Book对象Book对象c垃圾回收的堆1Bookb=newBook();Bookc=newBook();现在两个Book对象在堆中开始各自的生命期。ActiveReferences:2ReachableObjects:2b12Book对象Book对象c垃圾回收的堆1b=c;现在对象1被废弃，不再有任何它的引用存在，它将被回收。ActiveReferences:2ReachableObjects:1b12Book对象Book对象c垃圾回收的堆1c=null;null引用null引用不再引用任何对象。当然c仍然是引用变量，仍然可以通过被赋值，继续引用其他对象。3.3数组在Java里，数组也是对象int[]nums;nums=newint[7];nums[0]=6;nums[1]=22;….1声明一个int数组变量，它是对数组对象的引用2创建一个数组对象，长度为7，将控制赋值给变量nums3为数组中的每个元素赋值数组的元素由变量组成。numsint[]622整型数组可以存放整型的元素对象数组－－元素不是简单数据类型Dog[]pets;pets=newDog[7];pets[0]=newDog();pets[1]=newDog();…1声明一个Dog数组变量2创建一个数组对象，长度为7，将控制赋值给变量pets3注意！每个元素只是一个Dog引用变量，它的对象还没有创建数组初始化

在数组定义时，可以进行初始化；也可以不进行int[]a;char[]b;double[]c;-a-b-c表示值未定义也可以不使用new运算符进行初始化，方法是列举出数组的元素,称为静态初始化（或显式初始化）。

int[]smallPrimes={2,3,5,7,11,13}; System.out.println(smallPrimes.length);可以对数组进行重新初始化，而不必创建一个新的变量。

smallPrimes=newint[]{17,19,23,29,31,37};

相当于

int[]temp=newint[]{17,19,23,29,31,37}; smallPrimes=temp;数组初始化—例int[]number=newint[3];//变量number引用了一个int类型的数组。double[]value=newdouble[3];//…String[]str=newString[3];//….数组元素是字符串对象000number0.0value0.00.0nullnullnullstr在初始化时，如果没有指定数组元素的值，则所有的元素采用默认值初始化数组变量访问数组元素引用单个数组元素的方式是下标法或索引法。在数组中每个元素都有自己的下标，首下标从0开始。访问方式：

a[0]=0; a[1]=1; … a[i+3]=4;下标可以是非负整数，或者非负整数表达式。与其它语言不同，Java自动检查下标是否合法，如果认为某下标非法，将生成一个IndexOutOfBoundsException的异常，阻止程序继续执行。int[]a=newint[100];a[-1]=0;//illegala[100]=0;//illegal元素访问----为所有元素赋值一旦创建了数组，其大小是不可以改变的。利用”数组名.length”可以知道数组的大小。利用循环语句为数组元素赋值，注意数组下标从0开始。

for(inti=0;i<a.length;i++) a[i]=i;数组的复制如果把一个数组变量赋值给另外一个数组变量，将使双方都指向同一组数据。int[]d={1,2,3};int[]e={4,5,6};d=e;//dis{4,5,6}问题:下面的程序有错吗classBooks{Stringtitle;}classBooksTest{publicstaticvoidmain(String[]args){Books[]myBooks=newBooks[2];myBooks[0].title=“JavaCookbook”;myBooks[1].title=“ThinkinginJava”;

inti=0;while(i<myBooks.length){ System.out.println(myBooks[i].title); i++;}}

12classBooks{Stringname;publicstaticvoidmain(String[]args){Books[]b=newBooks[3];

intz=0;while(z<4){ z=z+1; b[z]=newBooks(); b[z].name=“bile”; if(z==1)b[z].name=“ff”; if(z==2)b[z].name=“kk”; System.out.println(b[z].name);}}}

classBooks{intid=0;publicstaticvoidmain(String[]args){Books[]b=newBooks[5];intz=0;while(z<3){ b[z]=newBooks(); b[z].id=z; z=z+1;}b[3]=b[1];b[4]=b[1];b[3]=null;b[4]=b[0];b[0]=b[3];b[3]=b[2];b[2]=b[0];}}

3画出程序中元素与对象之间的对应关系，有的引用是空的，有的对象被多个引用关联。第四章面向对象特性类和封装继承和多态4.1类和封装基本结构Methods封装instancevariables构造器和初始化Java类的基本结构class

class_name{

constructor1//构造器

constructor2 …

method1//方法

method2 … instancevariable1//实例变量

field2 ….}Method

behaviorandstate一个类的每个对象可以拥有不同的实例变量，而它们的方法行为呢？应该说，同一类的每个实例具有同样的方法，但是这些方法也可以具有不同的行为，取决于实例变量。MethodSongtitleartistsetTitle()setArtist()play()State(knows)Behavior(does)voidplay(){soundPlayer.playSound(title);}所有实例的play方法都是一样的；play()方法的行为将因title的不同而不同。Songt1=newSong();t1.setTitle(“Travel”);t1.play();Songt2=newSong();t2.setTitle(“Sing”);t2.play();Song“Travel”Song“Sing”behaviorandstateMethodDogsizenamebark()voidbark(){if(size>60)System.out.println(“Woof!”);elseif(size>14)System.out.println(“Ruuf!”);elseSystem.out.println(“Yip!”);}size不同，bark()的是不一样的。behaviorandstateMethod

passsomethingtomethodDogd=newDog();d.bark(3);d.bark(4);voidbark(intnumOfBarks){while(numOfBarks>0){System.out.println(“ruff”);

numOfBarks--;}}argumentsparameter在方法内充当局部变量值3被发送出去Method

getthingsbackfromamethodvoidgo(){//returnnothing}intt=life.giveSecret();intgiveSecret(){return42;}类型必须匹配这里必须是一个int值42被发送出去每个方法必须声明返回类型，它也叫该方法的类型Method

Javaispass-by-valueintx=7;00000111xvoidgo(intz){}z00000111xz0000011100000111xz2foo.go(x);传递的是变量的值，而不是变量的地址3如果z改变，x不会受影响voidgo(intz){z=0;}1Method

GetterandSetterEmployeesalarynamesetName()用来读取和设置属性setSalary()getName()getSalary()classEmployee{doublesalary;Stringname;

StringgetName(){returnname;}voidsetName(Strings){name=s;}}封装防止实例变量的值被随意设置theCat.height=27通过引用可以访问对象的变量或者调用对象的方法theCat.height=0对象theCat的实例变量height被设置没有任何限制的访问权限造成height被置0，或者为负数。publicvoidsetHeight(intht){if(ht>9){ height=ht;}}通过强制的方法，让用户只能通过setHeight方法来设置实例变量，可以确保任何不合理的值被排除掉。封装的方法使用访问修饰符（accessmodifier)：

public&private

尽量让实例变量private，并提供public的getter&&setter.

封装例子classDog{privateintsize;

publicintgetSize(){returnsize;}publicvoidsetSize(ints){size=s;}voidbark(){if(size>60)System.out.println(“wwof”);elseSystem.out.println(“yep”);}}classDogTestDrive{publicstaticvoidmain(String[]args){ Dogd=newDog();d.size=40;d.bark();}}classDogTestDrive{publicstaticvoidmain(String[]args){ Dogd=newDog();d.setSize(40);System.out.println(“Dog1:“+ d.getSize());d.bark();}}instancevariables声明和初始化对于局部变量intsize;Stringname;name

typeintsize=10;Stringname=“DL”;声明初始化System.out.println(“sizeis“+size);size=10;System.out.println(“sizeis”+size);在使用变量之前必须初始化或者变量被赋值。使用instancevariables声明和初始化对于实例变量classPoorDog{privateintsize;

publicintgetSize(){returnsize;}}publicclassDogTestDrive{publicstaticvoidmain(String[]args){Dogd=newDog();

System.out.println(“Dogsizeis“ +d.getSize();}返回的值是多少？instancevariables声明和初始化实例变量总会得到一个缺省的值：

integers0floatingpoints0.0booleansfalsereferencesnull但是，局部变量是没有缺省值的，它们必须保证先得到一个值！构造器和初始化objectcreation

声明一个引用变量

DogmyDog=newDog();

虚拟机为该变量分配空间，并命名为myDog。创建一个对象

Dog

myDog=newDog();

虚拟机在堆中为新的Dog对象分配空间将该对象与引用连接起来。

Dog

myDog=new

Dog();

现在可以通过这个引用myDog远程控制该Dog对象123对象是怎样被创建的？构造器和初始化objectcreationDog

myDog=newDog();类似于一个方法调用注意这实际并不是方法，而是调用了Dog类的构造器（Constructor）：

当你说new时，它启动一段特定的代码。构造器和初始化Everyclasshasatleastaconstructor构造器在哪儿？－－－自己编写，或者如果不提供，编译器会提供一个缺省构造器：publicDog(){//constructorcodehere}注意到它与method的区别了吗？构造器和初始化EveryclasshasatleastaconstructorpublicDog(){//constructorcodehere}1它没有返回类型2它必须和类同名构造器和初始化ConstructaDuck声明对象引用变量创建对象连接这两个变量gotoConstructorpublicclassDuck{publicDuck(){System.out.println(“Quack”);}publicclassUseDuck{publicstaticvoidmain(String[]args){

Duckd=newDuck();}构造器和初始化InitializationpublicclassDuck{intsize;publicvoidsetSize(ints){ size=s;}}

publicclassDuckTest{publicstaticvoidmain(String[]args){Duckd=newDuck();

d.setSize(42);}}编译器插入一段缺省构造器代码。但是在这之间，Duck的size为01如果自己不提供，编译器会安排一个默认的构造器，此时，实例变量将得到所属类型的缺省值。这样有时是不安全的，下例中要求使用者必须把两句话连起来写。

构造器和初始化2构造器的基本作用是初始化对象的状态。InitializationpublicDuck(){size=34;}设置实例变量的值publicclassDuckTest{publicstaticvoidmain(String[]args){Duckd=newDuck();….}}从此处起，d的默认size是34构造器和初始化Initialization3如果要由用户来指定初始值，应该设计带参的构造器publicclassDuck{intsize;publicDuck(ints){ size=s;}}

publicclassDuckTest{publicstaticvoidmain(String[]args){Duckd=newDuck(42);….}}这次不需要再调用setSize加一个参数用这个参数为实例变量赋值构造器和初始化Initialization4如果你在构造的时候并不很确定size的值时，应该提供两个构造器：缺省的和带参的。publicclassDuck{intsize;publicDuck(){size=34;}publicDuck(ints){ size=s;}}

用户可以根据情况选择构造的方式；当你的类里出现带参的构造器时，编译器不再为你提供缺省的构造器。构造器和初始化Initialization5如果类里出现一个以上的构造器，称作重载的构造器。当参数的类型、个数或者顺序不同时，才构成重载。publicclassRoom{publicRoom(intsize){}publicRoom(){}publicRoom(booleanisOccupied){}publicRoom(booleanisOccupied,intsize){}publicRoom(intsize,booleanisOccupied){}}overloaded构造器和初始化小结1构造器是在new一个对象时运行的代码Duckd=newDuck();2构造器必须与类同名，而且无返回类型publicDuck(intsize){..}3如果你不提供，编译器会提供一个缺省的构造器，它总是无参的。4可以有多个带不同参数的构造器，每种提供不同的构造方式。多个构造器的存在意味着出现了重载的构造器。4.2继承和多态继承多态子类的初始化假设在GUI上有这样几个图形。设计这样的程序：当用户点击某个图形时，该图形会顺时针旋转360度，并播放一个特定于该图形的声音文件。squarecircletriangle1继承的引入继承Squarerotate()playSound()Circlerotate()playSound()Trianglerotate()playSound()1这些类存在着共同点Shaperotate()playSound()2它们都属于图形，都可以旋转和播放。把这些共同点抽离，并组织成一个新的类：Shape。Shaperotate()playSound()SquareCircleTrianglesuperclasssubclass3将三个图形类和新的Shape类连接起来，形成如图的关系叫做继承。Shaperotate()playSound()SquareCircleTrianglesuperclasssubclassAmoebarotate()//amoeba特定//的rotate代码playSound()//amoeba特定的//playsound4增加一个子类Amoeba，它的旋转和播放声音的方式假设与其他图形是不一样的：让Amoeba类覆盖这两个方法，覆盖意味着重新定义，是对源方法进行修改或扩充的重要手段。Overridingmethods2理解继承概念1父类更为抽象，子类更为具体。父类里包含了子类的公共特征。

雇员

经理秘书程序员董事长2“子类继承父类”意味着子类继承了父类的所有“成员”，包括实例变量和方法。EmployeenamesalarySecretaryProgrammersuperclasssubclassgetSalary()3子类可以增加自己的实例变量和方法，更重要的是，它可以覆盖从父类继承来的方法。EmployeenamesalarySecretaryManagersuperclasssubclassgetSalary()bonusgetSalary()新的实例变量覆盖的方法4Java里我们把子类继承父类叫做扩展。语法：classAextendsB子类A父类B扩展例子publicclassDoctor{booleanatHospital;voidtreatPatient(){…}}publicclassFamilyDoctorextendsDoctor{booleanmakeHouseCalls;voidgiveAdvice(){…}}publicclassSurgeonextendsDoctor{voidtreatPatient(){…}voidmakeIncision(){…}}问题：1FamilyDoctor和Surgeon各有几个实例变量？2各有几个方法？3FamilyDoctor可以treatPatient()吗？4FamilyDoctor可以makeIncision()吗？3继承的好处1避免编写重复的代码把公共的代码放在父类里，让各个子类继承父类的同时也拥有了该代码。2方便、安全的改动代码

如果要改动公共代码的行为，只需要修改父类，子类的行为自动的改动。而不需要逐个的修改子类代码。3为所有的子类定义了一个公共的“合约”。父类为所有子类提供了必须遵循的特征和行为。多态1类之间的关系类与类之间有三种基本的关系：依赖(use-a):类A的方法中使用了类B的对象聚合(has-a):类A的对象包含了类B的对象继承(is-a):类A的对象也是类B的一个对象。classA{ publicA(){ Bb=newB(); … }}classA{ privateBb; ….}classAextendsB{..}依赖聚合继承子类对象与父类对象的关系:is-aclassAaclassBbis-a每个子类对象也是一个父类对象，即每个b也是一个a例如：EmployeeManager员工经理每个经理也是一个员工manageris-aemployeeDogmyDog=newDog();2多态的具体表现myDog可以引用其他的Dog对象，如：

Dogd=newDog();myDog=d;但是不能引用其他类型的对象，如不可以象这样：DogmyDog=new