Java中对象、类、抽象类三者有什么关系

Java中对象、类、抽象类三者有什么关系？相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。

package Java从入门到项目实战.抽象类与接口;//动物interface animal{ public abstract String breathe();}//哺乳动物---接口继承extend//类实现的话--implementsinterface 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多个子类，不巧的是接口需要增加方法，那么每个子类都要覆写一遍新添的方法，想想都很恐怖；在此基础上增加了弥补的方法

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());  } }}

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()); }}

抽象类：

抽象类的特点：

1. 含有抽象方法的类一定是抽象类

2. 抽象类不一定还有抽象方法

3. 抽象类中既可以有抽象方法也可以有非抽象放方法

4. 如果子类继承了抽象方法，要么重写抽象类中的抽象方法，要么子类就声明为抽象类

5. 不能创建对象，因为方法没有具体实现，创建对象没有作用，抽象类是用来继承的

6. 基本定义

abstract class Message{ private String type; public abstract String getConnectInfo();//抽象方法 public void setType(String type){ //普通方法  this.type = type; }}

抽象类的构造方法

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()); }}

抽象类中定义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()); }}

模板设计模式

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) { }}

看完上述内容，你们掌握Java中对象、类、抽象类三者有什么关系的方法了吗？如果还想学到更多技能或想了解更多相关内容，欢迎关注编程网精选频道，感谢各位的阅读！