Java中的对象、类、抽象类、接口、继承之间的联系
正文:
举个例子:如果现在要想定义一个动物,那么动物肯定是一个公共的标准,而这个公共标准就可以通过接口来完成。
在动物中又分为两类:哺乳动物、卵生动物,而这个标准属于对动物的标准进一步细化,应该称为子标准,所以此种关系可以使用接口的继承来表示。
而哺乳动物可以继续划分为人、狗、猫等不同的类型,由于这些类型不表示具体的事物标准,所以可以使用抽象类进行表示。
如果要表示出工人或者学生这样的概念,则肯定是一个具体的定义,则使用类的方式。
然后每个学生或者每个工人都是具体的,那么就通过对象来表示;
由下面的图可知,所有的设计中,接口应该是最先被设计出来的,被子类所继承。
代码实例化:
package Java从入门到项目实战.抽象类与接口; //动物 interface animal{ public abstract String breathe(); } //哺乳动物---接口继承extend //类实现的话--implements interface mammals extends animal { // 全局方法 // 抽象方法 } //卵生动物 interface Egg_laying_animals extends animal { // 全局方法 // 抽象方法 } //定义人类抽象类(属于哺乳动物) abstract class peopel implements mammals{ } //定义非人类抽象类(输入哺乳动物) abstract class small_animal implements mammals{ } //学生 属于人类中 class student extends peopel{ @Override public String breathe() { return null; } } public class 接口综合 { public static void main(String[] args) { // 对象:类的实例化 student std = new student(); System.out.println(std.breathe()); } }
接口:
1.接口的基本定义:
package Java从入门到项目实战.抽象类与接口; interface IMessageF{ //在接口可以定义全局变量、抽象方法(public权限)、default方法以及static方法; //如果接口中有抽象方法,那么接口必须需要子类进行实例化 public static final String INFO = "xbhog"; //全局变量 public abstract String getInfo(); //抽象方法 } class MessageIpml implements IMessageF{ @Override public String getInfo(){ //方法覆写 return "hello xbhog!"; //获取消息 } } public class 接口的基本使用 { public static void main(String[] args) { //接口的调用 实例化 IMessageF msg = new MessageIpml(); //子类实例化父类接口 System.out.println(msg.getInfo()); } }
2.子类实现多个父接口与实例转换
package Java从入门到项目实战.抽象类与接口; interface Imessage1{ public static final String INFO = "xbhog"; public abstract String getInfo(); } interface IChannel{ public abstract boolean connect(); } //实现多个接口,继承了两个,所以在子类中需要进行覆写父类中的抽象方法 class MessageImpl1 implements Imessage1,IChannel{ @Override public String getInfo(){ if(this.connect()){ return "博客地址:www.cnblogs.com/xbhog/"; } return "【默认消息】"+ Imessage1.INFO; } @Override public boolean connect(){ return true; } } public class 子类实现多个父接口 { public static void main(String[] args) { Imessage1 msg = new MessageImpl1(); System.out.println(msg.getInfo()); //--------观察接口实例转换------------- Imessage1 msg1 = new MessageImpl1(); Object obj = msg1; //向上转型 IChannel channel = (IChannel) obj; //对象强制转换成IChannel接口实例 System.out.println(channel.connect()); } }
3.子类继承抽象类同时实现接口
package Java从入门到项目实战.抽象类与接口; //消息接口 interface IMessage1{ public static final String INFO = "xbhog"; public abstract String getInfo(); } //通道接口 interface IChannel1{ public abstract boolean connect(); } //定义一个抽象类 abstract class DatabaseAbstract{ public abstract boolean getDatabaseConnection(); } //继承于抽象类,同时实现接口 class MessageImpl2 extends DatabaseAbstract implements IMessage1,IChannel1{ @Override public String getInfo() { if (this.connect()){ if(this.getDatabaseConnection()){ return "【数据库消息】博客地址:https://www.cnblogs.com/xbhog/"; }else { return "数据库消息无法访问!"; } } return "【默认消息】:"+IMessage1.INFO; } @Override public boolean connect() { return true; } @Override public boolean getDatabaseConnection() { return true; } } public class 子类继承抽象类并实现接口 { public static void main(String[] args) { IMessage1 msg = new MessageImpl2(); System.out.println(msg.getInfo()); } }
4.extends继承多个父接口
关于接口的简化:在定义接口时,对于全局常量和抽象方法可以省略static final与 abstract关键字;
package Java从入门到项目实战.抽象类与接口; interface Imessage3{ public static final String INFO = "xbhog"; public abstract String getInfo(); } interface IChannel3{ public boolean connect(); //抽象方法,省略了abstract; } interface IService extends Imessage3,IChannel3{ public String service(); //抽象方法,省略了abstract; } class MessageService implements IService{ @Override public String getInfo() { return Imessage3.INFO; } @Override public boolean connect() { return false; } @Override public String service() { return "【数据库消息服务】:https://www.cnblogs.com/xbhog/"; } } public class 使用extends继承多个父接口 { public static void main(String[] args) { } }
5.接口的加强
为什么需要加强接口:首先需要明白,在接口下的子类需要覆写父类的方法,如果该接口下有1000多个子类,不巧的是接口需要增加方法,那么每个子类都要覆写一遍新添的方法,想想都很恐怖;在此基础上增加了弥补的方法
5.1 增加default定义普通方法:便于扩充接口同时简化设计结构
package Java从入门到项目实战.抽象类与接口; interface IMessage{ // 必须覆写 public String message(); //抽象类 public default String messageSmple(){ return "null"; }; // 定义接口普通方法,增加了接口的灵活性 // 当子类过多是,增加一个新的方法,那么需要每个子类都需要覆写一边 // default的普通方法解决了该问题,当子类需要的时候覆写,不需要时放置 public default boolean connect(){ System.out.println("建立关注xbhog的通道...."); return true; } } class MessageImpl implements IMessage{ public String message(){ return "xbhog"; } } public class 接口定义加强使用default定义普通方法 { public static void main(String[] args) { IMessage msg = new MessageImpl(); if(msg.connect()){ System.out.println(msg.message()); } } }
5.2 default缺点:必须通过接口实例化对象才能调用,为了避免实例化对象的依赖,可以使用static方法,隐藏接口调用的细节
package Java从入门到项目实战.抽象类与接口; interface ImessageS{ public String message(); // 定义公共方法,被所有子类继承 public default boolean connect(){ System.out.println("建立订阅xbhog博客的通道....."); return true; } // 建立static静态方法,可以通过接口名称直接调用 public static ImessageS getInstance(){ // 获得子类对象 return new MessageImple(); } } class MessageImple implements ImessageS{ public String message(){ if(this.connect()){ return "www.cnblogs.com/xbhog"; } return "null"; } } public class 在接口中定义static方法 { public static void main(String[] args) { // 实例化子类接口对象 ImessageS msg = ImessageS.getInstance(); System.out.println(msg.message()); } }
抽象类:
抽象类的特点:
- 含有抽象方法的类一定是抽象类
- 抽象类不一定还有抽象方法
- 抽象类中既可以有抽象方法也可以有非抽象放方法
- 如果子类继承了抽象方法,要么重写抽象类中的抽象方法,要么子类就声明为抽象类
- 不能创建对象,因为方法没有具体实现,创建对象没有作用,抽象类是用来继承的
- 基本定义
abstract class Message{ private String type; public abstract String getConnectInfo(); //抽象方法 public void setType(String type){ //普通方法 this.type = type; } }
7.抽象类的构造方法
package Java从入门到项目实战.抽象类与接口; //构造抽象方法 abstract class abMessage{ private String type; //此时抽象类中没有提供无参构造方法,所以在子类必须明确调用单参构造方法 public abMessage(String type){ this.type = type; } public abstract String getContentInfo(); public String getType() { return type; } public void setType(String type) { this.type = type; } } class Database extends abMessage{ //子类构造 public Database(String type) { //调用父类单参构造方法 super(type); } //覆写抽象类方法 @Override public String getContentInfo() { return "【"+super.getType()+"】数据库连接信息"; } } public class 构造方法 { public static void main(String[] args) { abMessage demo = new Database("xbhog"); System.out.println(demo.getContentInfo()); } }
8.抽象类中定义static 方法:该类方法不受到抽象类实例化对象的限制
package Java从入门到项目实战.抽象类与接口; abstract class message{ public abstract String getInfo(); public static message getInstance(){ return new datamessage(); } } class datamessage extends message{ @Override public String getInfo() { return "xbhog数据库连接"; } } public class 抽象类定义static { public static void main(String[] args) { //因为该方法被static修饰,全局使用message.getInstance相当于new datamessage(); message mes = message.getInstance(); System.out.println(mes.getInfo()); } }
9.模板设计模式
package Java从入门到项目实战.抽象类与接口; //抽象三个公共行为 abstract class Action{ static final int EAT = 1; //吃饭指令 static final int SLEEP = 5; //睡觉指令 static final int WORK = 10; //工作指令 public abstract void eat(); public abstract void sleep(); public abstract void work(); public void command(int code){ switch (code){ case EAT:{ this.eat(); break; } case SLEEP:{ this.sleep(); break; } case WORK:{ this.work(); break; } case EAT+SLEEP+WORK:{ this.eat(); this.sleep(); this.work(); break; } } } } //具象化 机器人 class Rebot extends Action{ @Override public void eat() { System.out.println("机器人需要接通电源充电"); } @Override public void sleep() { } //机器人不需要睡觉 @Override public void work() { System.out.println("机器人按照固定的设置进行工作"); } } //具象化 人 class Person extends Action{ @Override public void eat() { System.out.println("人需要吃五谷杂粮来维持生命力"); } @Override public void sleep() { System.out.println("不睡觉会死的"); } @Override public void work() { System.out.println("每天工作996"); } } //具象化 猪 class pig extends Action{ @Override public void eat() { System.out.println("使劲吃,养肥了卖钱"); } @Override public void sleep() { System.out.println("不睡觉,养不肥"); } @Override public void work() { } } public class 模板设计模式 { public static void main(String[] args) { Action rebotAction = new Rebot(); Action personAction = new Person(); Action pigAction = new pig(); 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); } }
综合案例练习:
实现相关代码:
package Java从入门到项目实战.抽象类与接口; //定义人这个类 abstract class people{ private String name; private String age; public people() {} public people(String name,String age){ this.name = name; this.age= age; } public abstract void eats(); //定义抽象方法 public void setName(String name) { this.name = name; } public void setAge(String age) { this.age = age; } public String getName() { return name; } public String getAge() { return age; } } //定义运动员抽象类 abstract class athletes extends people{ public athletes(){} public athletes(String name, String age){ super(name,age); } // 抽象方法 public abstract void study(); } interface speakEnglish{ public abstract void speak(); } //定义教练的抽象类 abstract class coach extends people{ public coach(){} public coach(String name,String age){ super(name,age); } public abstract void teach(); } //篮球运动员 class Basketball_player extends athletes{ public Basketball_player(String name, String age){ super(name,age); } @Override public void eats() { System.out.println("篮球运动员正在吃饭...."); } @Override public void study() { System.out.println("篮球运动员正在学习......"); } } //乒乓球远动员 class pingpang extends athletes implements speakEnglish{ public pingpang(String name, String age){ super(name,age); } @Override public void eats() { System.out.println("乒乓球运动员正在吃饭...."); } @Override public void study() { System.out.println("乒乓球运动员正在学习......"); } @Override public void speak() { System.out.println("乒乓球运动员练习英语口语......"); } } //乒乓球教练 class pingpangCoach extends coach implements speakEnglish{ public pingpangCoach(String name, String age){ super(name,age); } @Override public void eats() { System.out.println("乒乓球教练正在吃饭....."); } @Override public void teach() { System.out.println("乒乓球教练正在授课...."); } @Override public void speak() { System.out.println("乒乓球教练练习英语口语....."); } } //篮球教练 class BasketballCoach extends coach{ public BasketballCoach(String name, String age){ super(name, age); } @Override public void eats() { System.out.println("篮球教练正在吃饭"); } @Override public void teach() { System.out.println("篮球教练正在授课......"); } } public class 综合案例实现 { public static void main(String[] args) { } }
上一篇:解决springboot 无法配置多个静态路径的问题
栏 目:JAVA代码
下一篇:Java代码读取文件缓存问题解决
本文标题:Java中的对象、类、抽象类、接口、继承之间的联系
本文地址:http://www.codeinn.net/misctech/226004.html