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

抽象类：

抽象类的特点：

1. 含有抽象方法的类一定是抽象类
2. 抽象类不一定还有抽象方法
3. 抽象类中既可以有抽象方法也可以有非抽象放方法
4. 如果子类继承了抽象方法，要么重写抽象类中的抽象方法，要么子类就声明为抽象类
5. 不能创建对象，因为方法没有具体实现，创建对象没有作用，抽象类是用来继承的
6. 基本定义

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

 }
}

到此这篇关于Java中的对象、类、抽象类、接口、继承之间的联系的文章就介绍到这了,更多相关Java中的对象、类、抽象类、接口、继承之间的联系内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！