继承多态和接口.docx
《继承多态和接口.docx》由会员分享，可在线阅读，更多相关《继承多态和接口.docx（22页珍藏版）》请在冰点文库上搜索。
继承多态和接口
一、访问控制符
（1）类的访问权限：
①公共访问权限（public）。
②包访问权限。
（2）成员的访问权限
①public
②private
③protected
④默认包访问
★结论：
public
包访问
protected
private
相同包中的非子类中被访问
YES
YES
YES
NO
相同包中的子类中被访问
YES
YES
YES
NO
不同包中的非子类中被访问
YES
NO
NO
NO
不同包中的子类中被访问
YES
NO
NO
NO
二、继承
（一）Java中继承的实现
①extends关键字
例题：
classPerson{
String name;
intage;
voidwalk（）{
System.out.println（"会走路"）;
}
}
classStudentextendsPerson{
Stringno;
voidtakeLessons（）{
System.out.println（"我喜欢所有的课程"）;
}
}
（二）构造方法在继承中的作用
①若子类没有定义构造方法，创建对象时将无条件的调用父类的无参构造方法。
②对于父类的有参构造方法，子类可以在自己的构造方法中使用关键字super来调用它，但super语句必须是子类构造方法的第一条语句。
③子类在自己的构造方法中如果没有使用super明确调用父类的构造方法，则在创建对象时，将自动先执行父类的无参构造方法，然后再执行自己定义的构造方法。
例题：
classParent{
Stringmy;
publicParent（Stringx）{
my=x;
}
}
publicclass SubClassextendsParent{
publicstaticvoidmain（String[]args）{
}
}
（三）子类的继承性
①子类和父类在同一包中的继承性：
例题：
②子类和父类不在同一个包中的继承性：
例题：
★结论：
public
包访问
protected
private
可被相同包中的子类继承后直接访问
YES
YES
YES
NO
可被不同包中的子类继承后直接访问
YES
NO
YES
NO
（四）变量的继承和隐藏
例题：
classParent{
inta=3;
intm=2;
}
publicclassSubClassextendsParent{
inta=4;
intb=1;
publicstaticvoidmain（String[]args）{
SubClassmy=newSubClass（）;
System.out.println（"a="+my.a+",b="+my.b+",m="+my.m）;
}
}
三、多态性
①方法的重载
例题：
publicclassA{
intx=0;
voidtest（intx）{
System.out.println（"test（int）:
"+x）;
}
voidtest（longx）{
System.out.println（"test（long）:
"+x）;
}
voidtest（doublex）{
System.out.println（"test（double）:
"+x）;
}
publicstaticvoidmain（String[]args）{
Aa1=newA（）;
a1.test（5.0）;
a1.test（5）;
}
}
★ 方法的覆盖
例题：
classA{
intx=0;
voidtest（intx）{
System.out.println（"inA.test（int）:
"+x）;
}
voidtest（longx）{
System.out.println（"inA.test（long）:
"+x）;
}
voidtest（doublex）{
System.out.println（"inA.test（double）:
"+x）;
}
}
publicclassBextendsA{
voidtest（intx）{
System.out.println（"inB.test（int）"+x）;
}
voidtest（Stringx,inty）{
System.out.println（"inB.test（String,int）:
"+x+","+y）;
}
publicstaticvoidmain（String[]args）{
Bb1=newB（）;
b1.test（"abcd",10）;
b1.test（5）;
b1.test（5.0）;
}
}
②运行时刻多态
例题：
classAnimal{
voidcry（）{}
}
classCatextendsAnimal{
voidcry（）{
System.out.println（"喵喵..."）;
}
}
classDogextendsAnimal{
voidcry（）{
System.out.println（"汪汪..."）;
}
}
publicclassTestCry{
publicstaticvoidmain（String[]args）{
Animala=newCat（）;
a.cry（）;
a=newDog（）;
a.cry（）;
}
}
四、this和super
（一）关键字this
关键字this表示“当前对象”。
有下面几种用法：
（1）调用当前对象的其他方法或访问当前对象的实例变量；
例如：
classTestThis1{
intx=1;
voidf（）{}
voidg（）{
inta=this.x+1;//此时this可以省略。
this.f（）;//此时this可以省略。
}
publicstaticvoidmain（String[]args）{
}
}
（2）当做方法的返回值返回或作为参数传递；
例题：
当作方法的返回值：
publicclassLeaf{
inti=0;
Leafincrement（）{
i++;
returnthis;
}
voidprint（）{
System.out.println（"i="+i）;
}
publicstaticvoidmain（String[]args）{
Leafx=newLeaf（）;
x.increment（）.increment（）.increment（）.increment（）.increment（）.print（）;
}
}
例题：
作为参数传递：
classA{
voidf（）{
System.out.println（"IamfinclassA"）;
}
A（）{
newTestThis2（this）;
}
};
publicclassTestThis2{
TestThis2（Aa）{
a.f（）;
}
publicstaticvoidmain（String[]args）{
newA（）;
}
};
（3）区分成员变量和局部变量同名的情况；
例题：
classTestThis3{
intx;
publicTestThis3（intx）{
this.x=x+10;
}
publicstaticvoidmain（String[]args）{
TestThis3t=newTestThis3（5）;
System.out.println（t.x）;
}
}
（4）一个构造方法中调用另外一个构造方法。
例题：
classTestThis4{
intx,y;
publicTestThis4（intx,inty）{
this.x=x;
this.y=y;
}
publicTestThis4（intx）{
this（x,3）;
}
publicstaticvoidmain（String[]args）{
TestThis4t=newTestThis4
（1）;
System.out.println（"t.x="+t.x）;
System.out.println（"t.y="+t.y）;
}
}
（二）关键字super
①通过super访问父类成员
例题：
publicclassSubClassextendsParent{
inta=6;
voidf（）{
super.f（）;
a=a+super.a-3;
}
publicstaticvoidmain（String[]args）{
SubClassmy=newSubClass（）;
my.f（）;
System.out.println（"a="+my.a）;
}
}
②调用父类的构造方法
例题：
classParent{
Parent（）{
System.out.println（"iamParent（）"）;
}
}
publicclassSubClassextendsParent{
SubClass（）{
super（）;
System.out.println（"iamSubClass（）"）;
}
publicstaticvoidmain（String[]args）{
SubClassmy=newSubClass（）;
}
}
五、final修饰符
①final修饰的类：
不能有子类。
②final修饰的函数：
不能被重写。
③final修饰的域：
不能被修改。
④final修饰的数组（引用）：
不能被修改，但所指向的数组（对象）中的内容可以被修改。
⑤空白final：
必须在域的定义处或者每个构造器中用表达式对final进行赋值。
六、抽象类和抽象方法
由abstract修饰的类为抽象类，由abstract修饰的方法为抽象方法。
性质：
（1）抽象类不能制造对象。
（2）抽象类中可以包含一般函数和抽象函数，可以没有抽象函数，但抽象函数必须在抽象类中定义。
（接口是完全抽象类）
（3）如果抽象类的子类不是抽象类，它必须实现父类的所有抽象函数。
（4）如果抽象类的子类也是抽象类，那么它可以实现一部分或者不实现父类的抽象函数。
七、接口
（1）接口的说明
例题：
interfaceMyInterface{
publicstaticfinalintI=1;
publicabstractvoidf（）;
}
★ 接口中的变量是常量，默认的修饰符为publicstaticfinal，可以省略。
★ 接口中的方法是抽象方法，默认的修饰符为publicabstract，可以省略。
★ 一个要实现某个接口，它必须实现接口中的所有抽象方法，并且必须加上public的访问权限。
（2）接口回调
例题：
interface ShowMessage{
void显示商标（Strings）;
}
classTVimplementsShowMessage{
publicvoid显示商标（Strings）{
System.out.println（s）;
}
}
classPCimplementsShowMessage{
publicvoid显示商标（Strings）{
System.out.println（s）;
}
}
publicclassExample4_27{
publicstaticvoidmain（Stringargs[]）{
ShowMessagesm;
sm=newTV（）;
sm.显示商标（"长城牌电视机"）;
sm=newPC（）;
sm.显示商标（"联想奔月5008PC机"）;
}
}
（3）接口作为参数
例题：
interfaceSpeakHello{
voidspeakHello（）;
}
classChineseimplementsSpeakHello{
publicvoidspeakHello（）{
System.out.println（"中国人习惯问候语：
你好，吃饭了吗？
"）;
}
}
classEnglishimplementsSpeakHello{
publicvoidspeakHello（）{
System.out.println（"英国人习惯问候语：
你好，天气不错"）;
}
}
classKindHello{
publicvoidlookHello（SpeakHellohello）{
hello.speakHello（）;
}
}
publicclassExample4_29{
publicstaticvoidmain（Stringargs[]）{
KindHellokindHello=newKindHello（）;
kindHello.lookHello（newChinese（））;
kindHello.lookHello（newEnglish（））;
}
}
八、内嵌类
（1）成员类
例题：
publicclassOuterOne{
privateintx=3;
InnerOneino=newInnerOne（）;
//成员类开始
publicclassInnerOne{
privateinty=5;
publicvoidinnerMethod（）{
System.out.println（"yis"+y）;
}
publicvoidinnerMethod2（）{
System.out.println（"x2is"+x）;
}
};//成员类结束
publicvoidouterMethod（）{
System.out.println（"xis"+x）;
ino.innerMethod（）;
ino.innerMethod2（）;
}
publicstaticvoidmain（String[]args）{
OuterOnemy=newOuterOne（）;
my.outerMethod（）;
}
}
★ 从上面的程序可以看出，内嵌类和外层类的其它成员处于同级别位置，所以也称为成员类。
★ 在内嵌类中可以访问外围类的成员。
★ 成员类中不能定义静态方法。
★ 在外围类中访问内嵌类的方法：
① 在外围类的成员定义处创建内嵌类的对象。
② 在外围类的某个成员方法中创建内嵌类的对象，然后通过该对象访问内嵌类的成员。
③ 在外围类的静态方法中不能直接创建内嵌类的对象，此时，必须先创建外围类的对象，然后通过外围类的对象创建内嵌类的对象。
例如：
publicstaticvoidmain（String[]args）{
OuterOne.InnerOnei=newOuterOne（）.newInnerOne（）;
i.innerMethod（）;
}
★ 在内嵌类中使用关键字this：
在内嵌类中，this是指内嵌类的对象，要访问外层类的当前对象必须加上外层类的名作为前缀。
例题：
publicclassA{
privateintx=3;
//内嵌类
publicclassB{
privateintx=5;
publicvoidM（intx）{
System.out.println（"x="+x）;
System.out.println（"this.x="+this.x）;
System.out.println（"A.this.x="+A.this.x）;
}
};
publicstaticvoidmain（String[]args）{
Aa=newA（）;
A.Bb=a.newB（）;
b.M（6）;
}
}
（2）嵌套类：
内嵌类可以定义为静态的，也称为静态内部类。
例题：
publicclassOuterTwo{
privatestaticintx=3;
privateinty=5;
//静态内部类
publicstaticclassInnerTwo{
publicstaticvoidMethod（）{
System.out.println（"xis"+x）;
}
publicvoidMethod2（）{
System.out.println（"xis"+x）;
//System.out.println（"yis"+y）;
}
};//静态内部类结束
publicstaticvoidmain（String[]args）{
OuterTwo.InnerTwo.Method（）;
newOuterTwo.InnerTwo（）.Method2（）;
}
}
★ 静态内部类中可以定义实例方法和静态方法。
静态方法可以通过类名直接访问，而实例方法必须通过内部类的对象访问。
（3）局部内部类
① 方法中的内部类
例题：
publicclassOuterThree{
privateintx=3;
publicvoidouterMethod（intm）{
finalintn=x+2;
//局部内部类
classInnerThree{
privateinty=5;
publicvoidinnerMethod（）{
System.out.println（"yis"+y）;
System.out.println（"nis"+n）;
//System.out.println（"mis"+m）;
System.out.println（"xis"+x）;
}
};//局部内部类结束
In
升级会员 