JAVA继承抽象类接口.docx
《JAVA继承抽象类接口.docx》由会员分享，可在线阅读，更多相关《JAVA继承抽象类接口.docx（25页珍藏版）》请在冰豆网上搜索。
JAVA继承抽象类接口
JAVA继承、抽象类、接口
编辑人：
星辰·樱
联系QQ：
838826112
1．类的继承
通过继承可以实现代码的复用，被继承的类称为父类或超类（superclass），由继承而得到的类称为子类（subclass）。
一个父类可以拥有多个子类，但一个类只能有一个直接父类，这是因为JAVA语言中不支多重继承。
子类继承父类的成员变量和成员方法，同时可以修改父类的成员变量或重写父类的方法，还可以添加新的成员变量或成员方法。
JAVA语言中有一个名为java.lang.Object的特殊类，所有的类都是直接或间接地继承该类而得到的。
1.子类的创建
类的继承是通过extends关键字来实现的，在定义类时若使用ectends关键字指出新定义类的父类，就是在两个类之间建立了继承关系。
新定义的类称为子类，它可以从父类那里继承所有非private的成员作为自己的成员。
子类的创建：
*格式：
classSubClassextendsSuperClass
*{
*.
*.
*.
*}
2.调用父类中特定的构造方法
在没有明确地指定构造方法时，子类还是会先调用父类中没有参数的构造方法，以便进行初始化的操作。
在子类的构造方法中可以通过super（）来调用父类特定的构造方法。
例：
//以Person作为父类，创建学生子类Student，并在子类中调用父类里某指定的构造方法。
classPerson2
{
privateStringname;
privateintage;
publicPerson2（）//定义Person2类的无参构造方法
{
System.out.println（"调用了Person2类的无参构造方法"）;
}
publicPerson2（Stringname,intage）//定义Person2类的有参构造方法
{
System.out.println（"调用了Person2类的有参构造方法"）;
this.name=name;
this.age=age;
}
publicvoidshow（）
{
System.out.println（"姓名：
"+name+"年龄：
"+age）;
}
}
classStudent2extendsPerson2//定义继承自Person2类的子类Student2
{
privateStringdepartment;
publicStudent2（）//定义Student2类的无参构造方法
{
System.out.println（"调用了学生类的无参构造方法Student2（）"）;
}
publicStudent2（Stringname,intage,Stringdep）//定义Student2类的有参构造方法
{
super（name,age）;//调用父类的胡参构造方法
department=dep;
System.out.println（"我是"+department+"学生"）;
System.out.println（"调用了学生类的有参构造方法Student2（Stringname,intage,Stringdep）"）;
}
}
publicclassApp8_2{
publicstaticvoidmain（String[]args）
{
Student2stu1=newStudent2（）;//创建对象，并调用无参构造方法
Student2stu2=newStudent2（"李小四",23,"信息系"）;//创建对象并调用有参构造方法
stu1.show（）;
stu2.show（）;
}
}
/*在子类中访问你类的构造方法，其格式为super（参数列表）。
*super（）可以重载，也就是说，super（）会根据参数的个数与类型，执行父类相应的构造方法。
*调用父类构造方法的super（）语句必须写在子类构造方法的第一行。
*super（）与this（）的功能相似，但super（）是从子类的构造方法调用父类的构造方法，而this（）则是在同一个类内调用其他的构造方法。
*super（）与this（）均必须放在构造方法内的第一行，也就是这个原因，super（）与this（）无法同时存在同一个构造方法内。
*与this关键字一样，super指的也是对象，所以super同样不能在static环境中使用，包括静态方法和静态初始化器（static语句块）。
3.在子类中访问父类的成员
例：
//在学生子类Student中访问父类Person的成员。
用protected修饰符和super关键字访问父类的成员
classPerson3
{
protectedStringname;//用protected（保护成员）修饰符修饰
protectedintage;
publicPerson3（）//定义Person3类的“不做事”的无参构造方法
{
}
publicPerson3（Stringname,intage）//定义Person3类的有参构造方法
{
this.name=name;
this.age=age;
}
protectedvoidshow（）
{
System.out.println（"姓名：
"+name+"年龄：
"+age）;
}
}
classStudent3extendsPerson3//定义子类Student3，其父类为Person3
{
privateStringdepartment;
intage=20;//新添加了一个与父类的成员变量age同名的成员变量
publicStudent3（Stringxm,Stringdep）//定义Student3类的有参构造方法
{
name=xm;//在子类里直接访问父类的protected成员name
department=dep;
super.age=25;//利用super关键字将父类的成员变量age赋值为25
System.out.println（"子类Student3中的成员变量age="+age）;
super.show（）;//去掉super而只写sho（）亦可
System.out.println（"系别：
"+department）;
}
}
publicclassApp8_3{
publicstaticvoidmain（String[]args）
{
@SuppressWarnings（"unused"）
Student3stu=newStudent3（"李小四","信息系"）;
}
}
/*在子类中访问父类的成员：
*在子类中使用super不但可以访问父类的构造方法，还可以访问父类成员就是和成员方法，
*但super不能访问在子类中添加的成员。
子类中访问父类成员的格式如下：
*1.super.变量名;2.super.方法名;
*用protected修饰的成员可以被三种类所引用：
该类自身、与它在同一个包中的其他类、在其他包中该的子类。
*将成员声明为protected的最大好处是可以同时兼顾到成员的安全性和便利性。
4.覆盖
重载是指在同一个类内定义名称相同，但参数个数或类型不同的方法。
覆盖（overriding）：
是指在子类中，定义名称，参数个数与类型均与父类完全相同的方法，用于重写父类里同名方法的功能。
例：
//以个人类Person为父类，创建学生子类Student，并用子类中的方法覆盖父类的方法。
classPerson4
{
protectedStringname;
protectedintage;
publicPerson4（Stringname,intage）
{
this.name=name;
this.age=age;
}
protectedvoidshow（）
{
System.out.println（"姓名：
"+name+"年龄：
"+age）;
}
}
classStudent4extendsPerson4
{
privateStringdepartment;
publicStudent4（Stringname,intage,Stringdep）
{
super（name,age）;
department=dep;
}
protectedvoidshow（）//覆盖父类Person4中的同名方法
{
System.out.println（"系别：
"+department）;
}
}
publicclassApp8_4
{
publicstaticvoidmain（String[]args）
{
Student4stu=newStudent4（"王永涛",24,"电子"）;
stu.show（）;
}
}
*覆盖父类的方法：
子类在重新定义父类已有的方法时，应保持与父类完全相同的方法声明，即应与父类有完全相同的方法名、返回值类型和参数列表，否则就不是方法的覆盖，而是子类定义自己的与父类无关的方法，父类的方法末被覆盖，所以仍然存在。
*注意：
子类中不能覆盖父类中声明为final或static的方法。
在子类中覆盖父类的方法时，可以扩大父类中方法权限，但不可以缩小父类方法的权限。
5.用父类的对象访问子类的成员
例：
//利用父类Person5的对象调用子类Student5中的成员。
与不可被继承的成员与最终类
classPerson5
{
protectedStringname;//如果声明为静态最终变量，则不能被覆盖。
protectedintage;
publicPerson5（Stringname,intage）
{
this.name=name;
this.age=age;
}
protectedvoidshow（）
{
System.out.println（"姓名：
"+name+"年龄：
"+age）;
}
}
classStudent5extendsPerson5
{
privateStringdepartment;
publicStudent5（Stringname,intage,Stringdep）
{
super（name,age）;
department=dep;
}
protectedvoidshow（）
{
System.out.println（"系别：
"+department）;
}
}
publicclassApp8_5
{
publicstaticvoidmain（String[]args）
{
Person5per=newStudent5（"王永涛",24,"电子"）;//声明父类变量per指向子类对象
per.show（）;//利用父类对象per调用show（）方法
}
}
通过父类的对象访问子类的成员，只限于“覆盖”的情况发生时。
6.不可被继承的成员与最终类
*如果父类的成员不希望被子类的成员所覆盖，可以将它们声明为final。
*
*如果就final来修饰成员变量，则说明该成员变量是最终变量，即常量，程序中的其他部分可以访问，但不能修改。
*如果用final修饰成员方法，则该成员方法不能被子类所覆盖，即该方法是最终方法。
*
*所以已被private修饰符限定为私有的方法，以及所有包含在final类中的方法，都被默认是final的。
*
*final成员变量与final局部变量的区别：
final成员变量和定义在方法中的final局部变量，它们一旦给定，就不能更改。
*大体上说，final成员变量和final局部变量都是只读量,它们能且只能被赋值一次，而不能赋值多次。
*
*一个成员变量若被staticfinal两个修饰符所限定时，它实际的含义，就是常量，所以在程序中通常用static和final一起来指定一个常量。
*
*定义一个成员变量时，若只用final修饰而不用static修饰，则必须且只能赋值一次，不能缺省。
这种成员变量的赋值方式有两种：
*一种是在定义变量时赋初值；另一种是在某个构造方法中进行赋值。
2．Object类
1.equals（）方法
equals（）方法：
判断两个对象是否相等。
equals（）方法与==运算符比较方式的一同：
“==”运算符用于比较两个变量本身的值，即两个对象在内存中的首地址，而equals（）方法则是比较两个字符串中所包含的内容是否相同；而对于非字符串类型的变量来说，“==”运算符和equals（）方法都用来比较其所指对象在堆内存中的首地址。
换句话说，“==运算符和equals（）方法都是用来比较两个类类型的变量是否指向同一个对象。
”
2.toString（）方法与getClass（）方法
toString（）方法：
toString（）方法的功能是将调用该方法的对象的内容转换成字符串，并返回其内容，但返回的是一些没有意义且看不懂的字符串。
*因此，如果要用toString（）方法返回对象的内容，可以重新定义该方法用于覆盖父类中的同名方法以满足需要。
*
*getClass（）方法：
该方法的功能是返回运行该方法的对象所属的类。
getClass（）方法返回值是Class类型。
3.对象运算符instanceof
对象运算符instanceof：
判断一个指定对象是否是指定类或它的子类的实例，若是，则返回true，否则返回false。
getName（）方法返回一个类的名称，返回值是String类型。
getSuperclass（）方法获得父类。
例：
//运算符instanceof及getName（）、getSuperclass（）方法的使用。
publicclassPerson8
{
staticintcount=0;
protectedStringname;
protectedintage;
@SuppressWarnings（"static-access"）
publicPerson8（Stringn1,inta1）
{
name=n1;
age=a1;
this.count++;
}
publicStringtoString（）
{
returnthis.name+","+this.age;
}
@SuppressWarnings（"static-access"）
publicvoiddisplay（）
{
System.out.println（"本类名＝"+this.getClass（）.getName（）+";"）;
System.out.println（"父类名＝"+this.getClass（）.getSuperclass（）.getName（））;
System.out.println（"Person.count="+this.count+""）;
System.out.println（"Student.count="+Student8.count+""）;
Objectobj=this;
if（objinstanceofStudent8）
System.out.println（obj.toString（）+"是Student类对象。
"）;
else
if（objinstanceofPerson8）
System.out.println（obj.toString（）+"是Person类对象"）;
}
}
classStudent8extendsPerson8
{
staticintcount=0;
protectedStringdept;
@SuppressWarnings（"static-access"）
protectedStudent8（Stringn1,inta1,Stringd1）
{
super（n1,a1）;
dept=d1;
this.count++;
}
publicStringtoString（）
{
returnsuper.toString（）+","+dept;
}
@SuppressWarnings（"static-access"）
publicvoiddisplay（）
{
super.display（）;
System.out.print（"super.count="+super.count）;
System.out.println（";this.count="+this.count）;
}
publicstaticvoidmain（String[]args）
{
Person8per=newPerson8（"王永涛",23）;
per.display（）;
Student8stu=newStudent8（"张小三",22,"计算机系"）;
stu.display（）;
}
}
3．抽象类
1.抽象类与抽象方法
抽象类是以修饰符abstract修饰的类，定义抽象类的语法格式如下：
abstractclass类名
{
声名成员变量;
返回值的数据类型方法名（参数表）——————一般方法
{
……
}
abstract返回值的数据类型方法名（参数表）;——————抽象方法
}
注意：
1.由于抽象类是需要被继承的，所以abstract类不能用final来修饰。
也就说，一个类不能既是最终类，又是抽象类，即关键字abstract与final不能合用。
2.abstract不能与private、stastic、final或native并列修饰同一方法。
3.抽象类的子类必须实现父类中的所有方法，或者将自己也声明为抽象的。
4.抽象类中不一定包含抽象方法，但包含抽象方法的类一定要声明为抽象类。
5.抽象类可以有构造方法，且构造方法可以被子类的构造方法所调用，但构造方法不能被声明为抽象的。
6.一个类被定义为抽象类，则该类就不能用new运算符创建具体实例对象，而必须通过覆盖的方式来实现抽象类中的方法。
7.抽象方法在抽象方法里，不能定义方法体。
例：
//抽象类的应用举例。
定义一个形状抽象类Shape，以该形状抽象类为父类派生出圆形子类Cricle和矩形子类Pectangle。
abstractclassShape9//定形状抽象类Shape
{
protectedStringname;
publicShape9（Stringxm）//抽象类中一般方法，本方法是构造方法
{
name=xm;
System.out.print（"名称：
"+name）;
}
abstractpublicdoublegetArea（）;//声明抽象方法，没有方法体
abstractpublicdoublegetLength（）;//声明抽象方法
}
classCricle9extendsShape9//定义继承自Shape9的圆形子类Cricle9
{
privatedoublepi=3.14;
privatedoubleradius;
publicCricle9（StringshapeName,doubler）
{
super（shapeName）;
radius=r;
}
publicdoublegetArea（）//实现抽象类中的getArea（）方法
{
returnpi*radius*radius;
}
publicdoublegetLength（）//实现抽象类中的getLength（）方法
{
return2*pi*radius;
}
}
classRectangle9extendsShape9//定义继承自Shape9的圆形子类Rectangle9
{
privatedoublewidth;
privatedoubleheight;
publicRectangle9（StringshapeName,doublewidth,doubleheight）
{
super（shapeName）;
this.width=width;
this.height=height;
}
publicdoublegetArea（）
{
returnwidth*height;
}
publicdoublegetLangth（）
{
return2*（width+height）;
}
@Override
publicdoublegetLength（）{
//TODO自动生成方法存根
return0;
}
}
publicclassApp8_9
{
publicstaticvoidmain（String[]args）
{
Shape9rect=newRectangle9（"长方形",6.5,10.3）;//声明父类对象指向子类
System.out.print（";面积＝"+rect.getArea（））;对象
System.out.println（";周长＝"+rect.getLength（））;
Shape9circle=newCricle9（"圆",10.2）;
System.out.print（";面积＝"+circle.getArea（））;
System.out.println（";周长＝"+circle.getLength（））;
}
}
4．接口
1.接口的定义、实现与引用
接口与抽象类的不同：
1.接口的数据成员必须初始化。
2.接口中的方法必须全部都声明为abstract，也就是，接口不能像抽象类一样拥有一般的方法，而必须全部是抽象方法。
*接口定义的语法格式如下：
*[public]interface接口名称[extends父接口名列表]
*{
*[public][static][final]数据类型成员变量名＝常量;
*……
*[public][ab
升级会员 