Java面向对象程序设计

Java面向对象程序设计2024/2/232教材和参考书教材Y.Daniel

Liang(李娜译），Java语言程序设计（第8版）（基础篇/进阶篇），机械工业出版社，2011.参考书1、WalterSavitch,Java

程序设计与问题解决(第4版,英文),人民邮电出版社，2006.2、朱仲杰，Java2全方位学习，机械工业出版社，2006.3、张大治，精通Eclipse,清华大学出版社，2006.2024/2/233一、Java编程基础1.Java基本数据类型TypeNameKindofvalueMemoryUsedSizeRangebyteinteger1byte-128to127shortinteger2bytes-32768to32767intinteger4bytes-2147483648to2147483647longinteger8bytes-9223372036854775808to…07floatfloating-point4bytes+/-3.40282347e+38to+/-1.40239846e-45doublefloating-point8bytes+/-1.76769313486231570e+308to+/-4.94065645841246544e-324charcharacter(Unicode)2bytesallUnicodecharactersbooleantrueoffalse1bitnotapplicable2024/2/234一、Java编程基础2.常量（1）匿名常量intx=1;floaty=1.0;charz=‘A’;booleanflag=true;（2）命名常量finaldoublepi=3.14159;2024/2/235一、Java编程基础3.控制台输入Scannerinput=newScanner(System.in);doublex=input.nextDouble();inty=input.nextInt();Scanner的方法nextByte() nextShort(),nextInt(),nextLong()nextFloat(),nextDouble()next() //读取一个字nextLine() //读取一行文本2024/2/2361.1.4ConsoleI/O3.控制台输入importjava.util.*;publicclassScannerDemo{ publicstaticvoidmain(String[]args){

intn1,n2; ScannerscannerObject=newScanner(System.in);

System.out.println(“Entertwowholenumbers:”);n1=scannerObject.nextInt(); n2=scannerObject.nextInt();//scannerObject.next()readsoneword//scannerObject.nextLine()readsanentireline.

System.out.println(“Youentered“+n1+“and“+n2); }}2024/2/237一、Java编程基础4.控制台输出System.out.println(“abc”);System.out.print(“abc”);System.out.print(“abc\n”);2024/2/238一、Java编程基础5.赋值语句

charsymbol; symbol=‘A’; charch=‘B’;

intm; m=4;

intn=5; doublex=4.5;

booleanmale=true;2024/2/239一、Java编程基础6.类型转换（1）强制类型转换doubledistance=9.0;intpoints=(int)distance;charch=‘7’;inta=(int)ch; //variableahasvalue55.（2）隐含类型转换byteshortintlongfloatdoubledoublex=7;2024/2/2310一、Java编程基础7.优先规则HighestPrecedence(1)theunaryoperators:+,-,++,--,and!(2)thebinaryarithmeticoperators:*,/,and%(3)thebinaryarithmeticoperators:+and–LowestPrecedence

2024/2/2311一、Java编程基础8.类和对象Datamembers（数据成员）InstanceVariablesClassVariablesMethods（方法）InstanceMethodsClassMethodsObjects（对象）TheInstanceofaClass2024/2/2312一、Java编程基础8.类和对象（static)2024/2/2313一、Java编程基础8.类和对象(static)2024/2/2314一、Java编程基础8.类和对象(1)staticstatic修饰的变量（方法）称为类变量（方法）;没有static修饰的变量（方法）称为实例变量（方法）;类变量不属于任何一个特定的实例，在创建实例之前就已经存在，实例变量属于特定的实例，创建实例之前实例变量不存在；类方法是不依赖于实例数据的方法，因此它不能对实例数据进行操作，也不能调用实例方法（因为实例方法有可能间接操作实例数据）；实例方法可以操作类变量，也可以调用类方法；2024/2/2315一、Java编程基础8.类和对象(2)封装将数据（方法）设为私有，防止客户代码直接操作该数据（方法），便于程序的升级；将数据和对数据进行操作的方法置于同一模块中，防止方法对数据进行误操作，一个实例的方法只能对该实例以及该实例所属类的数据进行操作，一个类的方法只能对该类的数据进行操作；减少命名冲突2024/2/2316一、Java编程基础9.JavaAPI（应用编程接口）PackagesandimportStatementThejava.lang.StringClassThejava.util.StringTokenizerClassTheWrapperClasses2024/2/2317一、Java编程基础（1）PackagesandimportStatementTheclassesintheJavaAPIaregroupedintopackages.Apackageissimplyacollectionofrelatedclasses.

java.util.GregorianCalendar

firstDate=new java.util.GregorianCalendar(2004,1,1);

java.util.GregorianCalendar

lastDate=new java.util.GregorianCalendar(2004,12,31);

importjava.util.GregorianCalendar; //importjava.util.*;

GregorianCalendar

firstDate= newGregorianCalendar(2004,1,1);

2024/2/2318一、Java编程基础(2)Thejava.lang.StringClassThefollowingisalistofsomeofthemethodsdefinedinclassString:String().String(char[]value

String(Stringoriginal)intlength()charcharAt(intindex)boolean

equals(Object

anObject)int

indexOf(int

ch)

int

indexOf(String

str)boolean

startsWith(Stringprefix).Stringsubstring(int

beginIndex,int

endIndex)

2024/2/2319一、Java编程基础(2)Thejava.lang.StringClassJavastringconcatenationoperator(+)."one"+"two""onetwo”"hello"+anyObject.toString()"hello"+anyObject"hello"+5System.out.println(2+3+"5"); //prints55System.out.println(2+""+3+"5"); //prints2352024/2/2320一、Java编程基础(2)Thejava.lang.StringClass

publicclassStringDemo{publicstaticvoidmain(String[]args){Stringsentence=“TextProcessingishard!”;

intposition=sentence.indexOf(“hard”);

System.out.println(sentence);

System.out.println(“Theword\”hard\”startsatindex +position); sentence=sentence.substring(0,position)+“easy!”;

System.out.println(“Thechangedstringis:”);

System.out.println(sentence); }}2024/2/2321一、Java编程基础(3)Thejava.util.StringTokenizerClassTheStringTokenizerclassispartofthepackage

java.util.ThefollowingisalistofsomeofthemethodsintheclassStringTokenizer:StringTokenizer(String

str)

StringTokenizer(String

str,Stringdelim)boolean

hasMoreTokens()StringnextToken(String

delim)

int

countTokens()2024/2/2322一、Java编程基础(3)Thejava.util.StringTokenizerClass

//ProductInfo.javaimportjava.util.*;publicclassProductInfo{ publicstaticvoidmain(String[]args){ Stringdata="MiniDiscs74Minute(10-Pack)_5_9.00";

StringTokenizer

tknzr=newStringTokenizer(data,"_"); Stringname= tknzr.nextToken(); Stringquantity=tknzr.nextToken(); Stringprice=tknzr.nextToken();

System.out.println("Name:"+name);

System.out.println("Quantity:"+quantity);

System.out.println("Price:"+price); }}2024/2/2323一、Java编程基础(4)TheWrapperClasses(1)java.lang.Byte(2)java.lang.Short(3)java.lang.Integer(4)java.lang.Long(5)java.lang.Character(6)java.lang.Float(7)java.lang.Double(8)java.lang.Boolean2024/2/2324一、Java编程基础TheWrapperClasses2024/2/2325一、Java编程基础TheWrapperClasses2024/2/2326二、方法1.参数传递（1）基本数据类型传递数值（2）对象类型传递引用r9.09.0radiusabcstrarg02024/2/2327二、方法2.方法重载方法重载是多态的表现形式之一，方法重载用同名操作完成不同的运算逻辑，操作接口的一致性减轻了用户学习和使用的负担，比如doubleadd(doublea,doubleb)int

add(inta,intb)2024/2/2328三、数组1.数组的声明、创建和初始化(1)声明数组double[]values;(2)声明和创建数组double[]values=newdouble[10];数组一旦创建，系统给数组元素赋缺省值，数值型和字符型赋值为0，布尔型赋值为false,对象类型赋值为null(3)声明、创建和初始化数组int[]

ages={21,19,35,27,55};String[]names={"Bob","Achebe",null};2024/2/2329三、数组2.数组的length变量数组为对象类型，任何数组都有一个length变量表示数组中元素的个数int[]values={3,6,9,8,10,78};inttotal=0;for(intk=0;k<values.length;k++){total+=values[k];}2024/2/2330三、数组3.foreach循环foreach循环写出的代码可读性更强int[]values={3,6,9,8,10,78};inttotal=0;for(intk:values){total+=k;}2024/2/2331三、数组4.数组作为参数传递(1)失败的数据交换swap(inta,intb){

intt=a;a=b;b=t;}intx=5;inty=6;swap(x,y);5665xyabt2024/2/2332三、数组4.数组作为参数传递(2)成功的数据交换swap(int[]a){

intt=a[0];a[0]=a[1];a[1]=t;}int[]b={5,6};swap(b)56bat2024/2/2333三、数组5.Java与C++参数传递比较(1)基本数据类型参数传递值传递(Java,C++)voidswap(intx,inty){

intt=x;x=y;y=t;}传递引用(C++)voidswap(int&x,int&y){…}引用变量为实际变量的别名56abtxy2024/2/2334三、数组5.Java与C++参数传递比较(1)基本数据类型参数传递传递指针(C++)voidswap(int*px,int*py){

intt=px[0];px[0]=py[0];py[0]=t;}

inta=5;

intb=6;

swap(&a,&b);56abtpypx2024/2/2335三、数组5.Java与C++参数传递比较(2)对象类型参数传递值传递(C++)Java语言的对象之所以不能传递对象的值是因为Java语言没有拷贝构造函数。传递引用(Java，C++)Java的引用完全区别于C++的引用，Java的引用本质上等同于C++的指针，C++的引用变量是另外一个变量的别名(引用变量与它引用的变量标识同一段存储单元)。传递指针(C++)Java语言没有指针语法，其引用变量起到了指针的作用。2024/2/2336三、数组5.java.util.Arrays类sort,binarySearch,equals和fill方法

intvalues={5,23,8,19};

intlist1={5,23,8,19};

intlist2={5,23,19,8};

java.util.Arrays.sort(values);

java.util.Arrays.sort(values,1,3);

java.util.Arrays.binarySearch(values,9);

java.util.Arrays.fill(values,10);

java.util.Arrays.fill(values,1,3,20);java.util.Arrays.equals(list1,list2);//equals(values,list1);2024/2/2337三、数组6.多维数组创建多维数组的两种方式

int[][]values={{1,2,3},{3,5},{5,8,10}};

int[][]values=newint[3][];values[0]=newint[3];values[1]=newint[4];values[2]=newint[2];2024/2/2338四、对象和类1.时间和日期(1)时间(1970.01.01.00)(见p30)System.currentTimesMillis()(2)日期(Date类)Date()Date(long

elapseTime)toString()getTime()setTime(long

elapseTime)2024/2/2339四、对象和类2.类变量和实例变量3.类方法和实例方法4.访问控制(可见性)public(package)protectedprivate5.数据封装赋值(set)方法和读取(get)方法2024/2/2340五、字符串和文本IO1.String类格式化字符串doublex=3.14159;Stringstr=String.format(“%5.2f”,x);2.Character类Character类是char的包装类，用于字符的比较和字母的大小写变换。2024/2/2341五、字符串和文本IO3.StringBuilder/StringBuffer类String类实例中存放的数据不能更改，要对字符串中的数据进行修改，就必须使用StringBuilder类或StringBuffer类。这两个类的方法基本相似，区别在于StringBuffer可用于并发访问。StringBuilder类的主要方法

appenddeleteinsertreplace2024/2/2342五、字符串和文本IO4.String和StringBuilder比较2024/2/2343五、字符串和文本IO5.File类File类的主要方法

File(String

pathName) //目录是一个特殊的文件

File(Stringparent,Stringchild)exists()

canRead()

canWrite()

isDirectory()

isFile()

getName()

getPath()2024/2/2344五、字符串和文本IO6.文件输出

java.io.PrintWriter

PrintWriter(Filefile)

PrintWriter(String

fileName)

print(Stringstring)//println

print(char

ch)//println

print(intx) //short,long,doublefloat…close()2024/2/2345五、字符串和文本IO6.文件输出

java.io.PrintWriter

importjava.io.*publicclassWriteData{publicstaticvoidmain(String[]args)throwsException{Filefile=newFile(“test.txt”);

if(file.exists()){

System.out.println(“test.txtalreadyexists”);System.exit(0);}

PrintWriteroutput=newPrintWriter(file);

output.print(“abcdefgh”);

output.close();}}2024/2/2346五、字符串和文本IO7.文件输入

java.util.Scanner

Scanner(Filefile)

Scanner(String

fileName)

hasNext()

nextLine()

nextInt() //long,short,double…close()next() //getnextword

useDelimiter(Stringpattern)2024/2/2347五、字符串和文本IO7.文件输入

java.util.Scanner

importjava.io.*;importjava.util.*;publicclassReadData{publicstaticvoidmain(String[]args)throwsException{Filefile=newFile(“test.txt”);Scannerinput=newScanner(file);

while(input.hasNext()){Stringword=next(); //System.out.println()Stringline=nextLine(); //}

input.close();}}2024/2/2348五、字符串和文本IO8.文件对话框

javax.swing.JFileChooser类

importjava.util.Scanner;importjavax.swing.JFileChooser;importjava.io.*;publicclassReadFile{publicstaticvoidmain(String[]args)throwsException{

JFileChooserchooser=newJFileChooser();if(chooser.showOpenDialog(null)==

JFileChooser.APPROVE_OPTION){Scannerinput=newScanner(chooser.getSelectedFile());

input.close();}}}2024/2/2349六、继承1.抽象面向对象编程的一个重要目标是提高代码的重用率(以尽可能低的成本获得更多的回报)2024/2/2350六、继承1.抽象(1)抽象可以有效地提高代码的重用率(2)派生可以适应用户需求的变化(3)父类(基类，超类)，子类(派生类，扩展类)，Object类2024/2/2351六、继承2.extends和super关键字

publicclassPerson{privateStringname;privateStringaddress;publicPerson(Stringname,Stringaddress){

this.name=name;

this.address=address;}publicStringgetName(){returnname;}publicStringgetAddress(){returnaddress;}publicStringtoString(){returnname+“_”+address;}}2024/2/2352六、继承2.extends和super关键字

publicclassStudentextendsPerson{privatedouble[]score;publicStudent(Stringname,Stringaddress){

super(name,address);//firststatement,superscore=newdouble[40];

for(intk=0;k<40;k++){

score[k]=-1.0;}}2024/2/23532.extends和super关键字

publicdoublegetScore(intindex){

if(index>=0&&index<40){returnscore[index];}return-1.0;}publicvoidsetScore(intindex,doublescore){

if(index>=0&&index<40){

score[index]=score;}}六、继承2024/2/2354六、继承publicdoublegetAverageScore(){doubletotal=0.0;

intcount=0;

for(intk=0;k<40;k++){

if(score[k]>-1.0){total+=score[k];count++;}}

if(count>0){returntotal/count;}return-1;}2024/2/2355六、继承publicStringtoString(){Stringstr=super.toString();//super

for(intk=0;k<40;k++){

str=str+“_”+score[k];}returnstr;}}2024/2/2356六、继承3.方法覆盖在Object类中定义了equals和toString方法，程序员可以在自己定义的类中覆盖这两个方法。在以下代码中，toString()调用是对象实际所属类型的方法。

publicclassTest{publicstaticvoidmain(String[]args){Studentstudent=newStudent(“cxg”,“abc”);student.setScore(1,90.0);student.setScore(2,85.0);

System.out.println(student.toString());}}2024/2/2357六、继承4.protected关键字类可见性和成员可见性关系如下表publicclass(package)classpublicmember对任意子类和客户都可见对同一包中的子类和客户可见protectedmember对任意子类可见，对同一包中的客户可见对同一包中的子类和客户可见packagemember对同一包中的子类和客户可见对同一包中的客户可见privatemember对子类和客户不可见对子类和客户不可见2024/2/2358六、继承5.final类和final方法一个类如果被申明为final类，那么该类不能作为其它类的父类。一个方法如果被申明为final方法，那么该方法在子类中不能被覆盖。2024/2/2359七、多态1.多态的表现形式(1)方法重载

int

add(inta,intb){returna+b;}doubleadd(doublea,doubleb){returna+b;}(2)通过基类变量引用子类方法2024/2/2360七、多态publicclassEmployeeextendsPerson{privatedoublehourSalary;privatedoubleworkHour;publicEmployee(Stringname,Stringaddress,doublehourSalary){

super(name,address);

this.hourSalary=hourSalary;}publicvoidsetHourSalary(double

hourSalary){

this.hourSalary=hourSalary;}publicdoublegetHourSalary(){returnhourSalary;}publicvoidsetWorkHour(double

workHour){

this.workHour=workHour;}2024/2/2361七、多态

publicdoublegetWorkHour(){returnworkHour;}publicdoublegetSalary(){returnworkHour*hourSalary;}publicStringtoString(){

Strint

str=super.toString();

str=str+“_”+getSalary();returnstr;}2024/2/2362七、多态

publicclassTestPolymorphism{publicstaticvoidmain(String[]args){Studentstudent=newStrudent(“Jack”,“abc”);Employeeemployee=newEmployee(“Ada”,“def”,100.0);

Perseonperson;person=student; //implicitcasting

System.out.println(person.toString());person=employee; //implicitcasting

System.out.println(person.toString());}}2024/2/2363七、多态2.多态的作用（1）提供一致的操作接口；（2）提供动态绑定（联编）功能，有利于扩展系统的功能。2024/2/2364七、多态3.instanceof操作符和ArrayList

importjava.util.ArrayList;publicclassTest{publicstaticvoidmain(String[]args){

ArrayListlist=newArrayList();

list.add(new

Student(“Jack”,“abc”));

list.add(new

Empolyee(“Smith”,“def”,10.0));

list.add(new

Student(“Hilber”,“xyz”));

list.add(“cxg”);

intsize=list.size();

for(intk=0;k<size;k++){Objectobject=list.get(i);

if(object

instanceofStudent){ //Students=(Student)object;explicitcasting

System.out.println(object.toString());}}}}2024/2/2365七、面向对象编程的特征（1）封装将数据（方法）设为私有，防止客户代码直接操作该数据（方法），便于系统的升级；将数据和对数据进行操作的方法置于同一模块中，尽可能防止方法对数据进行误操作；对封装服务器中数据（间接）进行操作需要指定服务器名称，减少了命名冲突（在两个对象中用相同的变量名和函数名不会引起冲突）。（2）继承抽象可以有效地提高代码的重用率，提高劳动生产率；派生可以适应用户需求的变化；Object类为最常见的操作（toString,equals)提供了一致接口。（3）多态为程序员提供一致的编程接口，减轻程序员的学习和使用负担；提供动态绑定（联编）功能，有利于扩展系统的功能。2024/2/2366九、异常1.错误处理在程序的执行过程中，无效的输入或者无法预见的环境条件有可能导致执行中的程序无法继续，健壮的程序必须预见性地做好安排，使得程序能够优雅地执行。结构化错误处理机制不仅关注错误处理本身，更关注错误处理的方式。2024/2/2367九、异常1.错误处理（1）非结构化错误处理非结构化错误处理破坏程序的逻辑结构，在阅读程序时程序员注意力常常被错误处理代码分散。2024/2/2368九、异常1.错误处理（2）结构化错误处理结构化错误处理能够保持程序的完整逻辑结构，在阅读程序时程序员可将注意力集中于程序逻辑的正确性2024/2/2369九、异常1.错误处理（3）当前方法无法确定该如何处理如果当前方法不知道该如何处理发生的错误，它就用一个异常对象通知调用方法。

Integer.parseInt(String

str)

Scanner.nextLine()2024/2/2370九、异常2.异常在Java语言中把错误分为Error和Exception两个类型，并把它们抽象为Throwable2024/2/2371九、异常3.Exception类Throwable

有两个子类:ErrorandException.Error用于问题严重、程序无法从错误中恢复的情况，比如“outofmemory”错误。

Exception用于有可能处理的错误，比如文件读写出错，文件没有找到。2024/2/2372九、异常3.Exception类Java语言的Exception分为两个类型:checkedexceptions

和uncheckedexceptions.“unchecked”和“checked”是指编译器是否对异常情况进行检查。NumberFormatException--uncheckedIOException--checked2024/2/2373九、异常4.Exception对象当出现不正常情况的时候,在一个方法内可以创建并抛出（throw

）异常对象，把问题交给调用该方法的上一级方法来处理，如果上一级方法也不准备处理问题，则把异常对象再次抛出，由更高层的调用方法来处理，依此类推。

异常对象传递所经历的方法序列叫调用栈(callstack)，调用栈的信息将会保留在异常对象中供捕获将对象的方法使用。如果异常对象在传递的路径上从未处理过，则最终被传送到虚拟机，由虚拟机来处理。2024/2/2374九、异常4.Exception对象异常对象包含的信息:(1)异常类型（即异常类的名称）；(2)调用栈；(3)描述异常对象的字符串。2024/2/2375九、异常4.Exception对象2024/2/2376九、异常4.Exception对象2024/2/2377九、异常4.Exception对象上一程序中的关键知识点

throw操作

throws子句被调用的方法抛出了异常，异常未捕获的情况

catch语句之后的操作2024/2/2378九、异常4.Exception对象2024/2/2379九、异常5.用户自定义异常类checked异常类可以从Exception类派生；unchecked异常类从RuntimeException类派生。2024/2/2380九、异常5.用户自定义异常类2024/2/2381九、异常6.异常处理try-catch块如果准备在一个方法中处理异常，就要用到如下try-catch块try{//codethatmaythrowexceptions}catch(ExceptionTypee){//codetohandletheexception}2024/2/2382九、异常6.异常处理Thetry-catchBlock2024/2/23831.1.5ExceptionObjects6.异常处理Thetry-catchBlock2024/2/2384九、异常6.异常处理2024/2/2385九、异常7.错误处理小结（1）为了清晰地反映程序员的思维逻辑，应采用结构化异常处理机制，编写程序时，首先要关心的是程序的执行逻辑，然后考虑在何处将会出现哪种类型的错误，最后处理错误。（2）在Java语言中错误分为Error和Exception两个类型,这两个类型抽象为ThrowableError:严重错误，无法恢复的错误Exception:可以处理的错误，错误被处理之后程序可继续执行2024/2/2386九、异常7.错误处理小结（3）Exception分为checked和unchecked异常两个类型自定义unchecked异常可直接从RuntimeException继承；自定义checked异常通常从Exception继承。（4）用throw产生异常，用throws抛出异常（5）用try{…}catch(){}捕获和处理异常一个try块可对应多个catch块，捕获的异常按catch（）块的顺序匹配，应先捕获子类异常2024/2/2387九、异常7.错误处理小结（6）未捕获的checked异常必须用throws子句抛出，throws抛出的异常交由上一级程序程序处理；（7）从main方法抛出异常由虚拟机来处理。2024/2/2388十、抽象类1.抽象方法一个抽象方法只有方法签名，没有实现代码；抽象方法用带有abstract修饰符；publicabstractvoideat(intamount);publicabstractvoidsleep(inthours);拥有抽象方法的类必须声明为抽象类。publicabstractclassclassName{...}2024/2/2389十、抽象类2.抽象类的作用为子类提供基类；阻止创建基类对象；一个抽象类不一定包含抽象方法，如果不希望客户创建某个类的对象，则可将该类声明为抽象类。为子类提供一致的操作接口。2024/2/23902.3.1AbstractClasses2024/2/2391十、抽象类3.抽象类的子类如果抽象类的子类没有实现基类的所有抽象方法，则子类必须声明为抽象类；当子类实现了基类的所有抽象方法时也可以将子类声明为抽象类。2024/2/2392十、抽象类2024/2/2393十、抽象类2024/2/23942.3.1AbstractClasses2024/2/23952.3.1AbstractClasses2024/2/2396十、抽象类2024/2/2397十、抽象类2024/2/23982.3.1AbstractClasses2024/2/23992024/2/231002024/2/23101十、抽象类4.创建具体类的对象Personperson=newPerson("John");//illegalPersonperson=newEmployee(“John”,21);Employeeemployee=newEmployee("John",21);Clientclient=newClient("Mary",6000.0);2024/2/23102十、抽象类5.多态多态允许一个方法名与多个实现相关联，当Java虚拟机通过（引用）变量名调用方法时，虚拟机检查变量实际引用的对象来确定方法实现代码。Containercontainer;container=newWagon(1,1,3);container=newTank(1,3);doublevolume=puteVolume();2024/2/231032.3.2Polymorphism2024/2/23104十一、接口

本讲的内容包括：1.接口2.接口的UML表示3.使用接口4.比较抽象类和接口2024/2/23105十一、接口1.接口在Java语言中,接口定义为抽象方法的集合，也允许包括常量声明.

接口声明使用关键词interface，而不是关键词class.2024/2/23106十一、接口1.接口2024/2/23107十一、接口1.接口接口中的方法隐含为public和abstract方法，不必显式使用关两个关键词.接口中的数据隐含为public,static,andfinal.不必显式使用这三个关键词.2024/2/23108十一、接口1.接口2024/2/23109十一、接口1.接口一个类实现某个接口，就必须实现接口中的所有方法（对那么些没有真正用处的方法提供一个空实现），除非把类声明为抽象类..2024/2/23110十一、接口1.接口一个接口可以继承另外一个或多个接口，被继承的接口称superinterface,新接口称为subinterface.2024/2/23111十一、接口2.接口的UML表示接口在UML中包括两个部分：（1）带<<interface>>字头的接口名；（2）若干方法名.

接口在UML中无属性.2024/2/23112十一、接口2024/2/23113十一、接口2024/2/23114十一、接口3.使用接口2024/2/23115十一、接口2024/2/23116十一、接口3.使用接口实现接口的（具体）类必须实现接口的所有方法.2024/2/23117十一、接口3.使用接口2024/2/231182024/2/231192.3.3Interfaces2024/2/231202.3.3Interfaces2024/2/231212.3.3Interfaces2024/2/23122十一、接口4.接口与抽象类的比较（1）抽象类允许有实现细节，包括变量和方法定义，由于抽象类有实现细节，所以抽象类只能单继承.（2）接口只包括签名约定，因此可多继承，可出现在类（继承）层次的任何位置，接口不能有构造方法.（3）接口与类一样被当做类型使用.2024/2/23123复习1.使用命令行环境（1）编译程序//Test.javapublicclass{publicstaticvoidmain(String[]args){

if(args.length>0){System.out.println(args[0]);}else{

System.out.println(“hollow!”);}}}D:\cxg>javac

Test.java //产生Test.class2024/2/23124复习1.使用命令行环境（2）运行程序D:\cxg>javaTest //执行Test.class（3）JDK包含的内容

Java程序编译器javac.exeJava程序解释器java.exeJava应用编程接口JavaAPI（即JDK提供的库）

jre（Java运行环境）

不包含IDE（集成开发环境），如Eclipse,JCreator（3）排错（1）语法；（2）逻辑；（3）运行错误（异常处理）2024/2/23125复习2.语法（1）关键字（2）标识符（变量，常量，函数，类名）标识符规则3.常量和变量赋值（1）赋值

int[]a={1,2,3}; //用常量赋值

Strings=“abc”; //用常量赋值

shortx=10; //其他常量自己复习（2）扩展赋值

s+=“def”;（3）final关键字2024/2/23126复习4.函数（1）签名publicstaticvoidmain(String[]args)修饰符函数类型函数名参数表：类型名和顺序（参数名无关紧要，仅占位）2024/2/23127复习4.函数（2）可变长参数列表

publicclassDemo{publicstaticvoidmain(String[]args){print(3,5,5.4);

print(newdouble[]{1,2,3});}publicstaticvoidprint(double

…numbers){

for(intk=0;k<numbers.length;k++){

System.out.println(numbers[k]);

}}}2024/2/23128复习4.函数（3）toString和equalspublicStringtoString(){…}publicStringequals(Objectobject){…}

关系运算符==Object类的equals（）方法等同于==,子类的equals()由用户确定子类方法覆盖基类方法时，不能缩小可见性范围，不能改变返回值类型，可去掉throws出子句（如果编译器允许），错误示例

voidtoString(){System.out.println(“abc”);}2024/2/23129复习5.static修饰符（1）类变量与实例变量（2）类方法与实例方法实例方法可以访问类变量和类方法类方法不可访问实例变量和实例方法（3）子类可覆盖基类的类变量和类方法

publicstaticvoidmain(String[]args)

变量覆盖与作用域大小2024/2/23130复习6.数组（1）定义和初始化（2）ArrayList2024/2/23131复习7.常用类（1）String,StringBuilder和StringBuffer类

voidchange(StringBuffer

str){

str.append(“abc”);}//StringBuffer

str=newStringBuffer(“xxx”);//change(str); 真正改变了实际参数strvoidchange(String

str){

str+=“abc

ef”; //int

charNumber=str.length();}//Stringstr=“abc”;//change(str); 实际参数str不变2024/2/23132复习7.常用类（2）Math类三角函数指数函数取整数函数

min、max和abs函数

random函数类常量Math.PI（3）Date和Random类2024/2/23133复习7.常用类（5）包装类Integer

int

compareTo(Integeri) //returnvalue-1,0,1

boolean

equals(Object

obj)doubledoubleValue()Character

int

compareTo(Character

ch)

boolean

equals(Object

obj)

boolean

isDigit(char

ch)

boolean

isDigit(int

ch)

boolean

isUpperCase(char

ch)2024/2/23134复习7.常用类（6）File类和booleanexists()publicclassCount{publicstaticvoidmain(String

args[])throwsException{

int

charCount=0,lineCount=0;if(args.length!=1){

System.out.println("Usage:javaCountfileName");System.exit(0);}FilesourceFile=newFile(args[0]);if(!sourceFile.exists()){

System.out.println("Sourcefile"+args[0]+"notexist");System.exit(0);}……2024/2/23135复习7.常用类（7）Scanner类

Scannerinput=newScanner(sourceFile);while(input.hasNext()){

//检查是否到文件结尾

Strings=input.nextLine();

…..}编程：（1）文件输入输出；（2）数据进制转换。2024/2/23136复习7.常用类（8）Exception类常用异常类使用异常类在子类覆盖有异常子句的基类方法publicstaticvoidmain(String

args[])throwsException{…}2024/2/23137复习8.类（1）构造函数（2）this对象用引用当前对象的数据或方法，成员变量参数同名时常用此法（3）super不能直接调用基类构造函数用super(…)调用基类构造函数，必须是子类构造函数中的第1条语句用super.funName(…)调用基类方法，在子类方法中调用基类方法时使用（尤其是子类方法覆盖基类方法时），不能有这样的调用super.super.funName(…)2024/2/23138复习9.抽象类和接口（1）抽象类

publicabstractclassA{…}publicclassabstractB{…} //非法

publicclassC{Ax; //非法

inty;

…}（2）接口常量publicstaticfinal方法publicabstract接口为类型，是一个纯抽象类，可用instanceof测试实例是否实现了某接口（3）比较接口和抽象类2024/2/231392.3.4DesignPatternsDesignpatternsdescribepracticalsolutionstocommondesignproblemsthatoccurrepeatedlyinsoftwaredevelopment.Adesignpatterndescriptionconsistsof:AnamethatidentifiesthepatternAdescriptionoftheproblemthatthepatternaddressesAdescriptionofthesolutionthatincludestheclassstructuresthatsolvetheproblemAdiscussionoftheconsequencesofusingthepattern2024/2/231402.3.4DesignPatternsDesignpatternsdocumentgooddesignsolutionsthatcanbeusedforsimilarproblemsandformasharedvocabularyforproblem-solvingdiscussions.Inaddition,designpatternsaregoodillustrationsofobject-orientedconcepts.2024/2/231412.3.4DesignPatternsCatalogofdesignpatternsCreationalPatterns:Singleton,AbstractFactory,Builder,FactoryMethod,PrototypeStructuralPatterns:Adapter,Bridge,Composite,Decorator,Façade,Flyweight,ProxyBehavioralPatterns:Strategy,ChainofResponsibility,Command,Iterator,Mediator,Memento,Observer,State,Visitor,Interpreter,TemplateMethod2024/2/231422.3.5SingletonPattern1.Description2.Structure3.Example4.Consequences2024/2/231432.3.5SingletonPatternDescriptionInsomea