java面向对象高级篇在上一章已经了解类基本使用方法对于程序而言它精华

继承的基本概在讲解继承的基本概念之前，可以先想这样一个问题：现在假设有一个 如图6-1所示，从这里可以发现 中已经存在有name和age两个属性，所以不希望在Student类中再重新这两个属性，这个时候就需要考虑是不是可以将 继续保留到Student类中，也就是引出了接下来所要介绍的类的继承概念。图6- 与Student的继承关为子类(派生类)。在java中用关键字extends来实现单继承，Java类的继承，可用下面的语class父 //定义父{}class子类 父 //用extends关键字实现类的继{}比如：人类不能继承自鸟类。范例 class{Stringname;intage;}classStudentextends{String}publicclassTest{publicstaticvoidmain(String[]{Students==" //类中的name属s.age= //类中的age属s.school="";//Student类中的school属System.out.println("："++"，："+s.age+"，学校}}输出结果：，：25，学校：1、程序1~5行一个名 的类，里面有name与age两个属性2、程序第6~9行一个名为Student的类，并继承 类3、程序第14行并实例化一个Student类的对415~17Studentname、age、school属性。StudentnameagenameageStudent类直接继承自类，也就是说Student类直接继承了类中的属性，所以Student类的对象才可以到父类中的成员。以上6-2表示：再举个例子

图6- 与Student类的继承ManagerEmployee，代码如下：classEmployee{publicString publicint //publicfloatsalary=0.0f; publicStringgetEmpDetails() }classManagerpublicString publicint //publicfloat //publicStringdept; publicStringgetEmpDetails()//员工信息 }通过分析得知，在类Employee和类Manager中存在许多共同的属性和行为，在现实生Manager如下:classManagerextendsEmployeepublicString //publicStringgetEmpDetails(){return"ThisisManager!";}}用UML（UnifiedModelingLanguage，统模语言）中的类图表示如图6-图6- 类·减少代码从上面的例子就可以看出，类Manager通过继承而无需再定义属性(name,work_age,·变得简(需修改每一个级别的员工类)Employee·扩展变得Employee，接着注意候也应注意：子类是不能直接父类中的私有成员的，但可以调用父类中的非私有方法。在javajava多重继承图6- 多重继classclassclassCextendsA,CABC类同时继承了两个父类，这JAVA中是不允许的。多层继承图6- 多层继classclassBextendsclassCextendsCA的孙子类。多次继承图6- 多次继classclassBextendsclassCextends子类对象的实例化方法。但是，可以在子类中父类的构造方法。请看下面的范例：范例 class{Stringname;intage; //{ }}classStudent{Stringpublic //{System.out.println("2.public}}publicclass {publicstaticvoidmain(String[]{Students=new}}输出结果publicpublic程序说明1、程序1~9行，一个类，此类中有一个无参构造方法2、程序10~17行，一个Student类，此类继承自类，此类中也有一个无参3、程序22行，并实例化一个Student类的对象s22行实例化的是子类的对象，但是程序却先子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。classStudentextends{Stringpublic //{super() //🡨实际上在程序的这里隐含了这样一条语System.out.println("2.public}}小提示 {Stringname;intage; (Stringnameint //{=name;this.age=age;}}classStudent{Stringpublic //{}}publicclassTest{publicstaticvoidmain(String[]{Students=new}}编译结果TestStudentDemo2.java:15:(java.lang.String,int)incannotbe

1由编译结果可以发现，系统提供的出错信息是因为无法找到类，所以造成了，译错误，这是为什么呢？在类中提供了一个有两个参数的构造方法，而并没有明确的写出无参构造方法面已提到过，如果程序中指定了构造方法，则默认构造方法不会所以程序出现了错误，而只要在类中增加一个什么都不做的构造方法，就这一问题就可以解决了。对范例TestStudentDemo2.java作相应的修改就形成了范例，范例 class{Stringname;intage; //增加一个什么都不做的无参构造 (Stringname,intage)//{=name;this.age=age;}}classStudent{StringpublicStudent()//}publicclass {publicstaticvoidmain(String[]{Students=new}}在程序的第6行了一个类的无参的且什么都不做的构造方法，所以程序在super关键字的使在上面的程序中曾经提到过super的使用，那super到底是什么呢？从范例 class{Stringname;intage;public(Stringname,int //父类的构造方{=name;this.age=age;}}classStudent{Stringpublic //{super("",25);//在这里用super显示调用父类中带两个参数的构造方}}publicclass {publicstaticvoidmain(String[]{Students=news.school=" //为Student类中的school赋System.out.println("："++"，："+s.age+"，学校}}输出结果：，：25，学校：1、程序第1~10行一名为 的类，里面有name与age两个属性，并了一2、程序第11~18行，一个名为Student的类，此类继承自类，在16~20行子类的构造方法，在此方法中用super("",25)调用父类中有两个参数的构造方法。3、程序在第23行并实例化一个Student类的对象s。第24行为Student对象s中的school赋值为“。注意用super调用父类中的构造方法，只能放在程序的第一行范例 class{Stringname;intage;public //父类的构造方{}publicString{return我是："++"，今年："+this.age+"岁}}classStudent{StringpublicStudent(Stringname,intage,String //{//在这里super调用父类中的属=name;super.age=age;//调用父talk()方法//schoolthis.school=}}publicclass {publicstaticvoidmain(String[]{Students=newStudent("",25,"");}}输出结果：，：25，学校：1、程序第1~12行一个名为的类，并name与age两个属性、一个返Stringtalk()2、程序第13~26行一个名为Student的类，此类直接继承自类319、20age属性，并分别422talk()Studentsuper调用父类中的属性或方法，当19、20、22this调用也是可以的。关于this与super关键字的使用，对于一些初学者来说可能有些，表6-1对thissuper表6- this与super的比从上表中不难发现，superthis调用构造方法时都需要放在首行，所以，super与this调用构造方法的操作是不能同时出现的。super与this不能出现在static修饰的方法中。super来显示调用父类的构造方法的话，系统将会在执行子类限制子类·尽量隐藏父类的内部数据，把父类的所有属性设置为private类型，不用让子类直接父类属性。·父类中的一些不能被子类复写的方法，应该使用private将其隐，让子类无法该方法。如果父类的方法需要外部类调用，但不希望子类覆盖，可以使用publicfinal联合修饰如果希望父类某个方法被子类重写但不希望其他类自由可以使用protected范例 {//在这里将属性封装privateStringname;privateintage;}classStudentextends{//在这里父类中被封装的属publicvoid{name="age=}}{publicstaticvoidmain(String[]{new}}编译结果TestStudentDemo6.java:12:namehasprivateaccessinname="";^ StudentDemo6.java:13:agehasprivateaccessinage=25;^2由编译器的错误提示可以发现，name与age属性在子类中无法进行。它了。那么有没有什么其它方法可以到这些私有属性呢？ //添加了两个setXxx()方法publicvoidsetName(Stringname){=}publicvoidsetAge(int{this.age=}Student//在这里通过父类的公共接口去父类中被封装的属publicvoid{}修饰在java中是通过各种区分符来实现数据封装的，共分为四种级别(控制级别从小到大)：private(私有)、friendly(default)、protected(受保护)、public(公共)。公共级别(嵌套类除外)。四种修饰符的权限如表6-2所示：表6- 四种修饰控制符的使用原类里的绝大部分属性都应该使用private修饰，除了一些static修饰的、类似全局变量的private修饰。protected修饰这些方法。希望出来给其他类自由调用的方法应该使用public修饰。类的构造器通过使用public修饰，给其他类中创建该类的对象，因为顶级类通常都希望被其他类自由使用，public修饰。复而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中的这个方法复写了父类中的方法。同理，如果子类中重复定义了父类中已有的属性，则称此子类中的属性复写了父类中的属性。class{权限方法返回值类型方法1（参}classSubextends{权限方法返回值类型方法1（参数 复写父类中的方}作用域：指的子类方法的权限应该比父类方法更大或者相等，这是“一大型更小或者相等，子类方法抛出的异常应比父类方法抛出异常类更小或者相等。对于一个private方法，因为它仅在当前类中可见，其他子类无法该方法，所以子private方法有相同方法名、相同形参列6-36-3重载与重写的比重覆盖(重写单概方法的权限不能更加严范范例class{StringintpublicString{return我是："++"，今年："+this.age+"岁}}classStudent{StringpublicStudent(Stringname,intage,String{//分别为属性赋值=name;this.age=age;this.schoolschool;}//此处复写 中的talk()方法publicStringtalk(){return我在"+this.school+"上学}}class{publicstaticvoidmain(String[]{Students=newStudent("",25,"//talk()方法}}输出结果我在上学1、程序1~9行一个名为的类，里面了name与age两个属性，和一与age属性同时了一个与父类中同名的talk()方法也可以说此时Student类中的talk()方法复写了类中的talk()方法。330432talk()talk()由输出结果可以发现，在子类中复写了父类中的talk()方法，所以子类对象在调用talk()talk()方法与父类的talk()方法，在权限时，都为public，也就是说这两个方法的权限都是一注意子类复写父类中的方法时，被子类复写的方法不能拥有比父类更严格的权限，即{publicStringtalk}classStudent{//此处会因为权限出现Stringtalk}在子类中talk()方法处并没有权限，如果不则权限为default，但父类中的talk方法有public，而public权限要高于default权限，所以此时子类的方法比父类中拥有更严格的权限，所以会出现错误。由TestOverDemo1.java程序中可以发现在程序32行调用talk()方法实际上调用的只是TestOverDemo1.java。{Stringname;intage;publicString{return我是："++"，今年："+this.age+"岁}}classStudentextends{StringpublicStudent(Stringname,intage,String{//分别为属性赋值=name;this.age=age;this.schoolschool;}//此处复写类中的talk()方publicStringtalk(){}}class{publicstaticvoidmain(String[]{Students=newStudent("",25,"")}}输出结果我是：，今年：25岁，我在上学1、程序1~9行类，里面了name与age两个属性，和一个talk()方法。2、程序10~25行Student类，此类继承 ，也就继承了name与age属性同时了一个与父类中同名的talk()方法，也可以说此时Student类中的talk()方法复写了talk()23super.talk()talk()方法。330432talk()talk()ObjectJavaObject类，它是所有类的父类java.langextends关键字明确标识继承另外一个类，那么这个类就默认继承Object类。因此，Object类是Java类层中的最类，是所有类的超类。换句话说，Java中任何一个类都是它的子类。由于所有的类都是由Object类衍生出来的，所以Ojectpublicclass//当没有指定父类时，会默认Object类为其父{…}publicclassextends{…}clone方法抛出异常。函数原型：protectedObjectclone()throws范例classUserimplementsCloneable{privateintid;privateStringname;publicintgetId(){return}publicvoidsetId(intid){this.id=id;}publicStringgetName(){returnname;}publicvoidsetName(Stringname){=name;}protectedObjectclone()throwsCloneNotSupportedException{returnsuper.clone(); //super.clone()}}publicclassTestClonepublicstaticvoidmain(String[]args){try{Useruser=newUseruUser)user.clone();//Useruuser;的区别}catch(CloneNotSupportedExceptione){}}}函数原型：publicfinalClass<?>范例class}publicclassTestpublicstaticvoidmain(String[]args) }}ObjectpublicStringpublicbooleanequals(Objectobj)publicinthashCode()JDK函数原型：publicString函数说明：返回该对象的字符串表示。通常，toString方返回一个“以文本方式表函数返回：默认情况下Object类的toString方法返回一个字符串，该字符串由类名、@的值等于：getClass().getName()+'@'+Integer.toHexString(hashCode())toString()的使用，此方法是在打印对象时被调用的，下面有两个范例，一toString()toString()方法，可比较两者的区别。范例classextendsObject{Stringname="";intage=25;}classpublicstaticvoidmain(String[]p=new();}}输出结果程序说明1、程序1~5行一个类，并明确继承自Object类2、程序第10行并实例化一个类的对象p，11行打印对象p的时候实际上打印出的是一些无序的字符串，ObjecttoString()方法。范例 extendsObject{Stringname="";intage=25;//ObjecttoString()publicStringreturn"我是："++"，今年："+this.age+"岁}}classpublicstaticvoidmain(String[]p=new }}输出结果我是：，今年：25TestToStringDemo1.javaTestToStringDemo2.java程序在类中明确复写了toString()方法，这样在打印对象p的时候，实际上是去调用了toString()方法，toString()16行相当于：java==函数原型：publicbooleanequals(Object函数说明：指示其他某个对象是否与此对象“相等equals方法在非空对象上实现相等关系·自反性：对于任何非空值x，x.equals(x)都应返回true·对称性：对于任何非空值x和y，当且仅当y.equals(x)返回true时，x.equals(y)true。·传递性：对于任何非空值x、y和z，如果x.equals(y)返回true，并且·一致性：对于任何非空值x和y，多次调用x.equals(y)始终返回true或始终返falseequals·对于任何非空值x，x.equals(null)都应返回falseObject类的equals方法实现对象上差别可能性最大的相等关系即对于任何非空x和y，当且仅当x和y同一个对象时，此方法才返回true（x==y具有值true规协定，该协定相等对象必须具有相等的哈希码。函数参数：obj-要与之比较的对象函数返回objtruefalse privateStringname;privateintage; (Stringname,intage){=name;this.age=}}classpublicstaticvoidmain(String[]p1= ("p2= ("//p1和p2}}输出结果1、程序第1~10行一 类，并一个构造方法为类的属性初始化2、程序第15、16行两个对象p1、p2，其内容相等318p1p2equals比Objectequals方法，但可以发现此方法并不好用，所以在开equals方法，请看下面的范例：范例classprivateStringname;privateintage;public(Stringname,intage){=name;this.age=}//复写父类（Object类）equalspublicbooleanequals(Objectif(this==obj)returntrue; if(obj==null)returnfalse; //不与null进行比较if(this.getClass(obj.getClass())returnfalse;//检测两个对象是否属于同一类if(objinstanceof)//判断Object类对象是否是的实例{p2=()obj;//如果是类实例，则进行向下//Stringequalsreturn(.equals()&&}return //如果不 }}publicclasspublicstaticvoidmain(String[]p1= ("",p2= ("",//判断p1p2System.out.println(p1.equals(p2)是同一个人！不是同一个人}}输出结果1、程序1~21行一 类，并在类中复写了Object类的equals方法2、第13行，判断传进去的实例对象obj是否属于 进行，否则返回false。317false529p1equalsp2equals方法之中，比较两函数原型：publicint函数说明：返回该对象的哈希码值hashCode·在Java应用程序执行期间，在对同一对象多次调用hashCode方法时，必须一致地返equals比较时所用的信息没有被修改。从某一应用程序·如果根据equals(Object)方法，两个对象是相等的，那么对这两个对象中的每个对象hashCode方法都必须生成相同的整数结果。·两个对象利用equals(java.lang.Object)方法比较不相等，但两个对象的hashCode可以相等（程序员应该，为不相等的对象生成不同整数结果可以提高哈希表的性能）ObjecthashCode（这函数返回：此对象的一个哈希码值 类中增加如下代码publicintreturnname.hashCode()+}抽象以保留原有的类的功能，而且还可以拥有的功能。Java抽象方法：只而未实现(未实现，就是说方法后面没有“{}”)的方法称为抽象 关键字。如：Animal类，动物的方法enjoy()，父类定义其，没有什么意义，因为每个子类，具体的某种动物，它的是不一样的。因此，在父类Animal中，只需要一下，有这个方法，具体的实现，就交由子类来进行。抽象类定义规则·抽象类和抽象方法都必须 ·new关键字去产生对象。但是可以通过非抽象·抽象方法只需，而不需实现抽象类的定义格式注意的方法没有什么两样；另一种是“抽象方法关键字为开头的方法，此方法只了返回值的数据类型、方法名称与所需的参数，但没有定义方法体。范例 class{Stringname;intage;String // String //一个抽象方法}classStudentextends//Student类继承自{publicStudent(Stringname,intage,String{=this.age=age;this.occupation=occupation;}publicString //talk(){return学生——姓名："++""+this.age+"，职业：}}classWorker //Worker类继承 {publicWorker(Stringname,intage,String{=name;this.age=age;this.occupation=}publicString //talk(){return工人——姓名："++""+this.age+"，职业：}}class {publicstaticvoidmain(String[]{Students=newStudent("",20,"学生");Workerw=newWorker("",30,"工人");}}输出结果学生——>：，：20，职业：学生！工人——>：，：30，职业：工人程序说明1、程序1~7行一个名为的抽象类，在中了三个属性，和一个以需要复写类中的抽象方法——talk()。3、程序21~33行一个Worker类，此类继承自类，而且此类不为抽象类，所以需要复写类中的抽象方法——talk()。540、41talk()6-7表示，如下所示：小提示

图6- 抽象类的继承关与一般类相同，在抽象类中，也可以拥有构造方法，此时也可以在子类的构造方法中通过er来显示调用父类的构造函数。{Stringname;intage;Stringpublic(Stringname,intage,String{=name;this.age=age;this.occupation=} String}classStudentextends{publicStudent(Stringname,intage,String{//父类没有无参构造方法，所占在这里要明确调用抽象类中的构造方super(name,age,}publicStringtalk()return学生——姓名："++""+this.age+"，职业：}}class {publicstaticvoidmain(String[]{Students=newStudent("",20,"学生");}}输出结果学生——>：，：20，职业：学生更重要的是还可以有一些抽象方法，留给子类去实现，而且在抽象类中构造方法后，在抽象类的作final关键在Java中类、属性和方法时，可使用关键字final来修饰1、final标记的类不能被继承2、final标记的方法不能被子类复写3、final标记的变量（成员变量或局部变量）即为常量，只能赋值一次finaljava.lang.String、java.lang.Mathfinal类，它们范例finalclass{}classStudentextends{}编译结果TestFinalDemo1.java:4:cannotinheritfromfinalclassStudentextends^1任何子类重写这个方法。final修饰的方法不能重写，但可以重载。范例class{//此方法为final不能被子类复finalpublicString{return }}classStudent{publicString{return}}编译结果TestFinalDemo2.java:11:talk()inStudentcannotoverridetalk()in ;overriddenmethodisfinalpublicString^1FinalFinalfinal修饰成员变量时，要么在定义程序变量的时候指定初始化值，要么在初始化Final修饰局部变量，必须由程序员显示初始化，可以先定义，后赋值，但只能一次，范例class{publicstaticvoidmain(String[]{finalinti //final修饰的变量}}编译结果TestFinalDemo1.java:6:cannotassignavaluetofinalvariablei^1可以将static和final结合起来使用，此时的变量称为全局常量，例如publicstaticfinalStringINFO=接口 抽象方法的定义，而没有变量和方法的实现。可以说接口是抽象方法和常量值定义的集合如果一个类中完全是由全局变量(staticfinal)和抽象方法( 1、接口里的数据成员必须初始化，且数据成员均为常量2、接口里的方法必须全部为 interface接口名 //定义接{publicstaticfinal数据类型成员名称=常量；//数据成员必须赋初值 返回值的数据类型方法名称(参数…);//抽象方法，注意在抽象方法里，没有定义方法主体}法，所以抽象方法的关键字public staticfinal也可省略。事实上只要记得：、接口里的“抽象方法”只要做即可，而不用定义其处理的方式java中接口是用于实现多继承的一种机制java设计中最重要的一个环节，每（implementation接口实现的语法如下class类名称implements接口A,接口 //接口的实{…}范例interface{//三个常量Stringname="";intage=25;Stringoccupation学生//一个抽象方法talk() String}//Student类实 接classStudent{//talk()方法，publicpublicString{return学生——姓名："++""+this.age+"，职业：}}class{publicstaticvoidmain(String[]{Students=newStudent();}}输出结果学生——>：，：25，职业：学生！1程序1~9行一个接口并在里面了三个常量：nameageoccupation，2、程序10~18行一个Student类，此类实现接口，并复写中的323Students24行调用talk()方法，打印信息。interface{voidprint();void}//类没有全部实现接口中的方法，所以必须classimplements{publicvoid void}//Student继承自，实现了所有的抽象方法，所以可以实例化对classStudentextends{publicvoidpublicvoid}Java允许多个类(抽象类、非抽象类)Java允许同一个类（抽象类、非抽象类）接口不能继承抽象类但是在Java中一个接口可以通过extends关键字同时继承多个接interface子接口名extends父接1，父接口{…}范例interface{inti=publicvoid}interface{intx=publicvoid}BA、EinterfaceBextendsA,{intj=publicvoid}CBA、B、EclassCimplements{publicvoid{System.out.println("i=}publicvoid{System.out.println("j=}publicvoid{System.out.println("e=}}class{publicstaticvoidmain(String[]{Cc=newC();}}输出结果i=j=程序说明1、程序1~5行一个接口A，并一个常量i和一个抽象方法sayI()2、程序6~10行一个接口E，并一个常量x和一个抽象方法sayE()sayJ()。对象多态动态绑定是指“在执行期间（而非编译期间”判断所对象的实际类型，根据其实执行期间：运行java…编译期间：运行javac{

publicvoid{ }publicvoid{ }}//Student类扩展自 classStudentextends{//在这里复写了 publicvoidfun1(){}publicvoid{}}class{publicstaticvoidmain(String[]{//p=new//fun1()fun1()}}输出结果2.程序说明1、程序1~11行一个类，此类中有fun1()、fun2()两个方法2、程序14~25行一个Student类，此类继承自类，并复写了fun1()方法3、程序第32行一个类（父类）的对象，之后由子类对象去实例化此对象434fun1()从程序的输出结果中可以发现，pfun1()1、向上特点：程序会自动完成格式：父 父类对象 子类实例的向上。向上是不需要进行强制类型转换的，但是向上会丢失精度。2、向下格式：子 子类对象=(子类)父类实例与向上对应的一个概念就是“向下，所谓向下，也就是说父类的对象可有个小孩在马看见了一辆跑车，他指着跑车说那是汽车。相信大家都会认为这句话没有错，跑车的确是符合汽车的标准，所以把跑车说成汽车并没有错误，只是确而已。所以它们都可以叫做汽车，那么这种概念就称为向上。而相反，假如说把所有的汽车都一、向上可以自动完成；二、向下必须进行强制类型转换。范例class{publicvoid{}publicvoid{}}//Student类继承类，也就继承了类的fun1()、fun2()方classStudent{//在这里复写了 publicvoidfun1(){}publicvoid{}}class{publicstaticvoidmain(String[]{//p= //p对象向下StudentsStudent)p;}}运行结果Exceptioninthread"main"java.lang.ClassCastException由程序可以发现，程序32行对象p是由类本身实例化的，在第34行将对象p强制转换为子类对象，这样写在语法上是没有任何错误的，但是在运行时可以可以想一下在现实生活中的例子，假如你今天刚买完一些生活用品，回家的时候在碰见“，32行的代码修p=newinstanceof操作符。对象在进行向下之前一定要先发生向上，要使用instanceof关键字判断instanceof关键字的否属于一个类。instanceof的语法格式为：instanceof类(或接口或抽象类它的返回值是型的，或真(true)、或假(false) void}classCatextendsAnimal{publicvoidcall(){}publicvoidcat }}classDogextendsAnimal{publicvoidcall(){}publicvoidfill(){}}classPlayAnimal{PlayAnimal(Animalani){if(aniinstanceofCat) elseif(aniinstanceofDog)}}publicclass{publicstaticvoidmain(String[]{newPlayAnimal(newCat());newPlayAnimal(new}}抽象类和接口对象的实例Java中可以通过对象的多态性，为抽象类和接口实例化，这样再使用抽象类和接口范例{publicvoid}classStudent{publicvoid{System.out.println("Student}}class{publicstaticvoidmain(String[]{p=newStudent();}}输出结果Student程序说明1、程序第1~4行一个接口，此接口中只有一个抽象方法fun1()2、程序第5~11行一个Student类，此类实现接口，并复写fun1()方法3、程序第16行一个接口的对象p，并通过子类Student去实例化此对象417fun1()fun1() 假设一种场景“假设动物分为猫和狗，每种动物都可以发出，很明显，猫和狗的接口的应用——定义标“UUSBinterface{publicvoidstart();publicvoid}classMoveDiskimplements{publicvoid{System.out.println("MoveDisk}publicvoid{System.out.println("MoveDisk}}classMp3implements{publicvoid{System.out.println("Mp3}publicvoid{System.out.println("Mp3}}class{publicvoidwork(Usb{}}class{publicstaticvoidmain(String[]{newComputer().work(newMoveDisk());newComputer().work(newMp3());}}输出结果MoveDiskstart...MoveDiskstop...Mp3start...Mp3程序说明1、程序1~5行一个Usb接口，此接口中有两个抽象方法：start()、stop()2、程序6~16行一个MoveDisk类，此类实现Usb接口，并复写了里面的两个抽象3程序17~27行一个Mp3类此类实现Usb接口并复写了里面的两个抽象方法4、程序29~36行一个Computer类，在类中有一个work()方法，此方法接收start、stop542、43Computerwork()方法，并根据传进对象接口和抽象类的关内部个类。如果在类Outer的内部再定义一个类Inner，此时类Inner就称为内部类，而类Outer我们知道，如果将一个类的属性设置为private之后，外部和子类都是不可的。内部类的出现，初始思想是JDK1.2版本为解决一个类能另外一个类的私有成员。它分为class //privateStringinfo="o";//定义外部类的私有属性privateintage=24; //定义外部类的私有属性classInner{ //定义内部类privateString //privateintage= //publicvoid ////直接外部类的私有属System.out.println(info+",mynameis"+//内部类的System.out.println("我今年"+age+"岁");System.out.println("我今年this.age岁");//外部类的System.out.println("我今年Outer.this.age岁}}publicvoid //Innerin==" //通过内部类的实例化对象调用内部类属 //}}publicclasspublicstaticvoidmain(Stringnew //fun()}}内部类可以直接外部类的属性和方法，包括private的；外部类不能直接内部类的成员，哪怕是public的。外部类内部类的成员，包括private的，是通过内部类的法的局部变量同名，则可以通过使this（内部类属性、外部类名.this（外部类属性）来性”一样，在构造内部类对象的时候，也会在堆里为内部类的属性分配空间。类，用static的内部类叫静态内部类（外部类，但是用static的内部类不能static的外部类属性和方法。非静态内部类不能定义静态成员。范例class //privatestaticStringinfo o";//privatestaticintage=staticclass //privateString //privateintage=publicvoid ////直接外部类的私有属System.out.println(info+",mynameis"+//内部类的System.out.println("我今年"+age+"岁");System.out.println("我今年this.age岁");//外部类的System.out.println("我今年Outer.age岁}}publicvoid //Innerin==" //通过内部类的实例化对象调用内部类属 //}}publicclasspublicstaticvoidmain(Stringnew //fun()}}在外部类之外非静态内部前面的例子内部类的对象总是创建在外部类中。内部类也可以在外部类之外的地方创建对象，从外部类之外调用内部类方法，通常将内部类为c。非静态内部类，必须首先创建外部类对象，然后使用下面语法来创建内部类对象：外部类.内部类内部类对象= 范例class //privateStringinfo="o";//定义外部类的私有属性privateintage=24; //定义外部类的私有属性classInner{ //定义内部类privateString //privateintage= //publicvoid ////直接外部类的私有属System.out.println(info+",mynameis"+//内部类的System.out.println("我今年"+age+"岁");System.out.println("我今年this.age岁");//外部类的System.out.println("我今年Outer.this.age岁}}publicvoid //Innerin==" //通过内部类的实例化对象调用内部类属 //}}publicclasspublicstaticvoidmain(Stringnew //fun()//newOuter().newInner()实例化非静态内部类对象newOuter().newInner().print();}}在外部类之外静态内部外部类.内部类内部类对象= new外部类.内部类();class //privatestaticStringinfo o";//privatestaticintage=staticclass //privateString //privateintage=publicvoid ////直接外部类的私有属System.out.println(info+",mynameis"+//内部类的System.out.println("我今年"+age+"岁");System.out.println("我今年this.age岁");//外部类的System.out.println("我今年Outer.age岁}}publicvoid //Innerin==" //通过内部类的实例化对象调用内部类属 //}}publicclasspublicstaticvoidmain(Stringnew //fun()newOuter.Inner().print();//利用newOuter.Inner()实例化静态内部类对}}常见的创建内部类对象方式来创建内部类对象，阅读费解，且相应Java的原则。一般来说，构造内部类对象，InnergetInnerInstance(){returnnewInner();}范例class //privatestaticStringinfo= staticclass //privateStringname="";publicvoidprint(){System.out.println(info+",mynameis"+}}publicstaticInnergetInnerInstance(){returnnewInner();}}publicclasspublicstaticvoidmain(Stringnew}}方法内部范例classprivateintscore=95;voidinst(){classvoidSystem.out.println("成绩score}}new}}publicclasspublicstaticvoidmain(String[]args){newOuter().inst();}}需要注意的是：在方法中定义的内部类只能方法中的final类型的局部变量，因为用final定义的局部变量相当于是一个常生命周期超出方法运行的生命周期在方法中定义的内部类不能加上任何的封装操作符（public也不行。如下面范例所示：范例classintscore=voidinst(finalintinttemp //finalpublicclassInner{//voidSystem.out.println("成绩score}}new}}publicclasspublicstaticvoidmain(String[]args){newOuter().inst(5);}}的变量temp，所以需要在第6行的变量时，加上一个final修饰：finalinttemp=public内部使用内部类可以更进一步缩短内部类。因为内部类主要用来创建Java事件的Android的事件课程会具体讲解。，一个类在整个操作中只使用一次的话，就可以将其定义成内部类内部类是在，interface{publicvoid}class{classCimplements{publicvoid{System.out.println("测试内部类}}publicvoidget(A{}publicvoid{this.get(new}}class{publicstaticvoidmain(String[]{new}}新介绍一遍内部类的概念，而是为了引出下面的概念——内部类。范例interface{publicvoid}class{publicvoidget(A{}publicvoid{{publicvoid{System.out.println("测试内部类}})}}class{publicstaticvoidmain(String[]{new}}由此程序可以发现，在程序中并没有明确的出实现接口A的类，但是在程序实现了接口A中的fun1()方法，并把整个的一个实现类，传递到了方法get中，这就是所谓的匿名内部类。它不用实质上的类，就可以使用。枚在JDK1.5之前，Java可以有两种方式定义新类型：类和接口。对于大部分面向对象ColorRed、GreenBlue三种值，其他的任何值都是的。通过private将构造器隐，把这个类的所有可能实例都使用publicstaticclasspublicstaticfinalColorREDnewColor("红色");//定义第一个对象publicstaticfinalColorGREENnewColor("绿色");//定义第一个对象publicstaticfinalColorBLUEnewColor("蓝色");//privateStringprivateColor(Stringname){//构造方法私有=name;}publicvoidsetName(Stringname){=name;}publicStringgetName(){return;}publicstaticColorgetInstance(inti){casereturnRED;case2:returnGREEN;case3:returnBLUE;return}}}publicclasspublicstaticvoidmain(String[]args) }}·枚举的定[public]enum 枚举对象1,枚举对枚举对}3publicenum //}·枚举的使现在，可以这样的枚举变量Colorc=foreach进行全部的输出，使用“枚举.values()publicclasspublicenum //枚举的定}publicstaticvoidmain(String[] for(Colorc //}}switchpublicclasspublicenumColor{}publicstaticvoidmain(String[]args){for(Colorc:Color.values())}publicstaticvoidprint(Colorc){casecasecaseSystem.out.println("未知颜色}}}枚举java.lang.Enum classEnum<EextendsEnum<E>>extendsObjectimplementsComparable<E>,Serializable此类定义的时候使用了泛型机制，而且实现了Comparable接口以及Serializable接口，EnumprotectedEnum(Stringname,intenumRED("红色GREEN("绿色BLUE("蓝色privateString //定义nameprivateColor(Stringname){=name;}publicStringgetName(){return;}}publicclasspublicstaticvoidmain(String[]args){for(Colorc:Color.values())}}枚举的应·可以使用枚举实现一个接枚举类型可以跟普通的类一样实现一个接口但是实现接要求枚举中的每个对interfacepublicString}enumColorimplementsPrint{publicStringgetColor(){return"红色";}publicStringgetColor(){return"绿色";}publicStringgetColor(){return"蓝色";}}publicclassInterfaceEnumDemopublicstaticvoidmain(Stringargs[]){for(Colorc:Color.values()){}}}·可以在枚举类中定义抽象方enumpublicStringgetColor(){return"红色";}publicStringgetColor(){return"绿色";}publicStringgetColor(){return"蓝色";} String //}public publicstaticvoidmain(Stringargs[]){for(Colorc:Color.values()){}}}Java系统常见系统常见SystemSystemstatic。其方法涉SystemidentityHashCode(Objectx)方法，该方法返回指定对象的精确hashCodehashCodehashCode方法被重写之后，该类实例的hashCode方法就不能唯一地标识该对象。但通过identityHashCodehashCodehashCode值。identityHashCode值相同，则两个对象绝对是一个对象。系统常见RuntimeRuntimejvm进程的类。代表与虚拟机实例关联的运行时“环Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相javajvmjvm进程都是对应这RuntimejvmRuntime类实例，Runtime.getRuntime获得当前运行时实例。publicclassTest{publicstaticvoidmain(String[]RuntimerunTime=Runtime.getRuntime();}catch(Exception}}}系统常见MathMathjava.lang包中，包含一组静态方法和两个常intceil(doubled)d的最小整数。intfloor(doubled)d的最大整数。intround(floatf)f的整数（int（long极值、绝对值（float,int,long有类似的函数：doubleabs(do