Java中的对象、类、抽象类、接口、继承之间的联系
正文：
举个例子：如果现在要想定义一个动物，那么动物肯定是一个公共的标准，而这个公共标准就可以通过接口来完成。
在动物中又分为两类：哺乳动物、卵生动物，而这个标准属于对动物的标准进一步细化，应该称为子标准，所以此种关系可以使用接口的继承来表示。
而哺乳动物可以继续划分为人、狗、猫等不同的类型，由于这些类型不表示具体的事物标准，所以可以使用抽象类进行表示。
如果要表示出工人或者学生这样的概念，则肯定是一个具体的定义，则使用类的方式。
然后每个学生或者每个工人都是具体的，那么就通过对象来表示；
由下面的图可知，所有的设计中，接口应该是最先被设计出来的，被子类所继承。
代码实例化：
packageJava从入门到项目实战.抽象类与接口;
//动物
interfaceanimal{
publicabstractStringbreathe();
}
//哺乳动物---接口继承extend
//类实现的话--implements
interfacemammalsextendsanimal{
//全局方法
//抽象方法
}
//卵生动物
interfaceEgg_laying_animalsextendsanimal{
//全局方法
//抽象方法
}
//定义人类抽象类（属于哺乳动物）
abstractclasspeopelimplementsmammals{
}
//定义非人类抽象类(输入哺乳动物)
abstractclasssmall_animalimplementsmammals{
}
//学生属于人类中
classstudentextendspeopel{
@Override
publicStringbreathe(){
returnnull;
}
}
publicclass接口综合{
publicstaticvoidmain(String[]args){
//对象：类的实例化
studentstd=newstudent();
System.out.println(std.breathe());
}
}
接口：
1.接口的基本定义：
packageJava从入门到项目实战.抽象类与接口;
interfaceIMessageF{
//在接口可以定义全局变量、抽象方法（public权限）、default方法以及static方法；
//如果接口中有抽象方法，那么接口必须需要子类进行实例化
publicstaticfinalStringINFO="xbhog";//全局变量
publicabstractStringgetInfo();//抽象方法
}
classMessageIpmlimplementsIMessageF{
@Override
publicStringgetInfo(){//方法覆写
return"helloxbhog!";//获取消息
}
}
publicclass接口的基本使用{
publicstaticvoidmain(String[]args){
//接口的调用实例化
IMessageFmsg=newMessageIpml();//子类实例化父类接口
System.out.println(msg.getInfo());
}
}
2.子类实现多个父接口与实例转换
packageJava从入门到项目实战.抽象类与接口;
interfaceImessage1{
publicstaticfinalStringINFO="xbhog";
publicabstractStringgetInfo();
}
interfaceIChannel{
publicabstractbooleanconnect();
}
//实现多个接口，继承了两个，所以在子类中需要进行覆写父类中的抽象方法
classMessageImpl1implementsImessage1,IChannel{
@Override
publicStringgetInfo(){
if(this.connect()){
return"博客地址：www.cnblogs.com/xbhog/";
}
return"【默认消息】"+Imessage1.INFO;
}
@Override
publicbooleanconnect(){
returntrue;
}
}
publicclass子类实现多个父接口{
publicstaticvoidmain(String[]args){
Imessage1msg=newMessageImpl1();
System.out.println(msg.getInfo());
//--------观察接口实例转换-------------
Imessage1msg1=newMessageImpl1();
Objectobj=msg1;//向上转型
IChannelchannel=(IChannel)obj;//对象强制转换成IChannel接口实例
System.out.println(channel.connect());
}
}
3.子类继承抽象类同时实现接口
packageJava从入门到项目实战.抽象类与接口;
//消息接口
interfaceIMessage1{
publicstaticfinalStringINFO="xbhog";
publicabstractStringgetInfo();
}
//通道接口
interfaceIChannel1{
publicabstractbooleanconnect();
}
//定义一个抽象类
abstractclassDatabaseAbstract{
publicabstractbooleangetDatabaseConnection();
}
//继承于抽象类，同时实现接口
classMessageImpl2extendsDatabaseAbstractimplementsIMessage1,IChannel1{
@Override
publicStringgetInfo(){
if(this.connect()){
if(this.getDatabaseConnection()){
return"【数据库消息】博客地址：https://www.cnblogs.com/xbhog/";
}else{
return"数据库消息无法访问！";
}
}
return"【默认消息】："+IMessage1.INFO;
}
@Override
publicbooleanconnect(){
returntrue;
}
@Override
publicbooleangetDatabaseConnection(){
returntrue;
}
}
publicclass子类继承抽象类并实现接口{
publicstaticvoidmain(String[]args){
IMessage1msg=newMessageImpl2();
System.out.println(msg.getInfo());
}
}
4.extends继承多个父接口
关于接口的简化：在定义接口时，对于全局常量和抽象方法可以省略staticfinal与abstract关键字;
packageJava从入门到项目实战.抽象类与接口;
interfaceImessage3{
publicstaticfinalStringINFO="xbhog";
publicabstractStringgetInfo();
}
interfaceIChannel3{
publicbooleanconnect();//抽象方法，省略了abstract;
}
interfaceIServiceextendsImessage3,IChannel3{
publicStringservice();//抽象方法，省略了abstract;
}
classMessageServiceimplementsIService{
@Override
publicStringgetInfo(){
returnImessage3.INFO;
}
@Override
publicbooleanconnect(){
returnfalse;
}
@Override
publicStringservice(){
return"【数据库消息服务】：https://www.cnblogs.com/xbhog/";
}
}
publicclass使用extends继承多个父接口{
publicstaticvoidmain(String[]args){
}
}
5.接口的加强
为什么需要加强接口：首先需要明白，在接口下的子类需要覆写父类的方法，如果该接口下有1000多个子类，不巧的是接口需要增加方法，那么每个子类都要覆写一遍新添的方法，想想都很恐怖；在此基础上增加了弥补的方法
5.1增加default定义普通方法：便于扩充接口同时简化设计结构
packageJava从入门到项目实战.抽象类与接口;
interfaceIMessage{
//必须覆写
publicStringmessage();//抽象类
publicdefaultStringmessageSmple(){
return"null";
};
//定义接口普通方法，增加了接口的灵活性
//当子类过多是，增加一个新的方法，那么需要每个子类都需要覆写一边
//default的普通方法解决了该问题，当子类需要的时候覆写，不需要时放置
publicdefaultbooleanconnect(){
System.out.println("建立关注xbhog的通道....");
returntrue;
}
}
classMessageImplimplementsIMessage{
publicStringmessage(){
return"xbhog";
}
}
publicclass接口定义加强使用default定义普通方法{
publicstaticvoidmain(String[]args){
IMessagemsg=newMessageImpl();
if(msg.connect()){
System.out.println(msg.message());
}
}
}
5.2default缺点：必须通过接口实例化对象才能调用，为了避免实例化对象的依赖，可以使用static方法，隐藏接口调用的细节
packageJava从入门到项目实战.抽象类与接口;
interfaceImessageS{
publicStringmessage();
//定义公共方法，被所有子类继承
publicdefaultbooleanconnect(){
System.out.println("建立订阅xbhog博客的通道.....");
returntrue;
}
//建立static静态方法，可以通过接口名称直接调用
publicstaticImessageSgetInstance(){
//获得子类对象
returnnewMessageImple();
}
}
classMessageImpleimplementsImessageS{
publicStringmessage(){
if(this.connect()){
return"www.cnblogs.com/xbhog";
}
return"null";
}
}
publicclass在接口中定义static方法{
publicstaticvoidmain(String[]args){
//实例化子类接口对象
ImessageSmsg=ImessageS.getInstance();
System.out.println(msg.message());
}
}
抽象类：
抽象类的特点：
- 含有抽象方法的类一定是抽象类
- 抽象类不一定还有抽象方法
- 抽象类中既可以有抽象方法也可以有非抽象放方法
- 如果子类继承了抽象方法，要么重写抽象类中的抽象方法，要么子类就声明为抽象类
- 不能创建对象，因为方法没有具体实现，创建对象没有作用，抽象类是用来继承的
- 基本定义
abstractclassMessage{
privateStringtype;
publicabstractStringgetConnectInfo(); //抽象方法
publicvoidsetType(Stringtype){//普通方法
this.type=type;
}
}
7.抽象类的构造方法
packageJava从入门到项目实战.抽象类与接口;
//构造抽象方法
abstractclassabMessage{
privateStringtype;
//此时抽象类中没有提供无参构造方法，所以在子类必须明确调用单参构造方法
publicabMessage(Stringtype){
this.type=type;
}
publicabstractStringgetContentInfo();
publicStringgetType(){
returntype;
}
publicvoidsetType(Stringtype){
this.type=type;
}
}
classDatabaseextendsabMessage{
//子类构造
publicDatabase(Stringtype){
//调用父类单参构造方法
super(type);
}
//覆写抽象类方法
@Override
publicStringgetContentInfo(){
return"【"+super.getType()+"】数据库连接信息";
}
}
publicclass构造方法{
publicstaticvoidmain(String[]args){
abMessagedemo=newDatabase("xbhog");
System.out.println(demo.getContentInfo());
}
}
8.抽象类中定义static方法：该类方法不受到抽象类实例化对象的限制
packageJava从入门到项目实战.抽象类与接口;
abstractclassmessage{
publicabstractStringgetInfo();
publicstaticmessagegetInstance(){
returnnewdatamessage();
}
}
classdatamessageextendsmessage{
@Override
publicStringgetInfo(){
return"xbhog数据库连接";
}
}
publicclass抽象类定义static{
publicstaticvoidmain(String[]args){
//因为该方法被static修饰，全局使用message.getInstance相当于newdatamessage();
messagemes=message.getInstance();
System.out.println(mes.getInfo());
}
}
9.模板设计模式
packageJava从入门到项目实战.抽象类与接口;
//抽象三个公共行为
abstractclassAction{
staticfinalintEAT=1;//吃饭指令
staticfinalintSLEEP=5;//睡觉指令
staticfinalintWORK=10;//工作指令
publicabstractvoideat();
publicabstractvoidsleep();
publicabstractvoidwork();
publicvoidcommand(intcode){
switch(code){
caseEAT:{
this.eat();
break;
}
caseSLEEP:{
this.sleep();
break;
}
caseWORK:{
this.work();
break;
}
caseEAT+SLEEP+WORK:{
this.eat();
this.sleep();
this.work();
break;
}
}
}
}
//具象化机器人
classRebotextendsAction{
@Override
publicvoideat(){
System.out.println("机器人需要接通电源充电");
}
@Override
publicvoidsleep(){}//机器人不需要睡觉
@Override
publicvoidwork(){
System.out.println("机器人按照固定的设置进行工作");
}
}
//具象化人
classPersonextendsAction{
@Override
publicvoideat(){
System.out.println("人需要吃五谷杂粮来维持生命力");
}
@Override
publicvoidsleep(){
System.out.println("不睡觉会死的");
}
@Override
publicvoidwork(){
System.out.println("每天工作996");
}
}
//具象化猪
classpigextendsAction{
@Override
publicvoideat(){
System.out.println("使劲吃，养肥了卖钱");
}
@Override
publicvoidsleep(){
System.out.println("不睡觉，养不肥");
}
@Override
publicvoidwork(){
}
}
publicclass模板设计模式{
publicstaticvoidmain(String[]args){
ActionrebotAction=newRebot();
ActionpersonAction=newPerson();
ActionpigAction=newpig();
System.out.println("机器人行为---------");
rebotAction.command(Action.SLEEP);
rebotAction.command(Action.WORK);
System.out.println("人类行为----------");
personAction.command(Action.WORK+Action.SLEEP+Action.EAT);
System.out.println("猪的行为-------");
pigAction.command(Action.SLEEP);
}
}
综合案例练习：
实现相关代码：
packageJava从入门到项目实战.抽象类与接口;
//定义人这个类
abstractclasspeople{
privateStringname;
privateStringage;
publicpeople(){}
publicpeople(Stringname,Stringage){
this.name=name;
this.age=age;
}
publicabstractvoideats();//定义抽象方法
publicvoidsetName(Stringname){
this.name=name;
}
publicvoidsetAge(Stringage){
this.age=age;
}
publicStringgetName(){
returnname;
}
publicStringgetAge(){
returnage;
}
}
//定义运动员抽象类
abstractclassathletesextendspeople{
publicathletes(){}
publicathletes(Stringname,Stringage){
super(name,age);
}
//抽象方法
publicabstractvoidstudy();
}
interfacespeakEnglish{
publicabstractvoidspeak();
}
//定义教练的抽象类
abstractclasscoachextendspeople{
publiccoach(){}
publiccoach(Stringname,Stringage){
super(name,age);
}
publicabstractvoidteach();
}
//篮球运动员
classBasketball_playerextendsathletes{
publicBasketball_player(Stringname,Stringage){
super(name,age);
}
@Override
publicvoideats(){
System.out.println("篮球运动员正在吃饭....");
}
@Override
publicvoidstudy(){
System.out.println("篮球运动员正在学习......");
}
}
//乒乓球远动员
classpingpangextendsathletesimplementsspeakEnglish{
publicpingpang(Stringname,Stringage){
super(name,age);
}
@Override
publicvoideats(){
System.out.println("乒乓球运动员正在吃饭....");
}
@Override
publicvoidstudy(){
System.out.println("乒乓球运动员正在学习......");
}
@Override
publicvoidspeak(){
System.out.println("乒乓球运动员练习英语口语......");
}
}
//乒乓球教练
classpingpangCoachextendscoachimplementsspeakEnglish{
publicpingpangCoach(Stringname,Stringage){
super(name,age);
}
@Override
publicvoideats(){
System.out.println("乒乓球教练正在吃饭.....");
}
@Override
publicvoidteach(){
System.out.println("乒乓球教练正在授课....");
}
@Override
publicvoidspeak(){
System.out.println("乒乓球教练练习英语口语.....");
}
}
//篮球教练
classBasketballCoachextendscoach{
publicBasketballCoach(Stringname,Stringage){
super(name,age);
}
@Override
publicvoideats(){
System.out.println("篮球教练正在吃饭");
}
@Override
publicvoidteach(){
System.out.println("篮球教练正在授课......");
}
}
publicclass综合案例实现{
publicstaticvoidmain(String[]args){
}
}
到此这篇关于Java中的对象、类、抽象类、接口、继承之间的联系的文章就介绍到这了,更多相关Java中的对象、类、抽象类、接口、继承之间的联系内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。