关于Java中的对象、类、抽象类、接口、继承之间的联系
吴振华 · 95浏览 · 发布于2021-02-23 +关注

正文:

举个例子:如果现在要想定义一个动物,那么动物肯定是一个公共的标准,而这个公共标准就可以通过接口来完成。

在动物中又分为两类:哺乳动物、卵生动物,而这个标准属于对动物的标准进一步细化,应该称为子标准,所以此种关系可以使用接口的继承来表示。

而不如动物i可以继续划分为人、狗、猫等不同的类型,由于这些类型不表示具体的事物标准,所以可以使用抽象类进行表示。

如果要表示处工人或者学生这样的概念,则肯定是一个具体的定义,则使用类的方式。

然后每个学生或者每个工人都是具体的,那么就通过对象来表示;

由下面的图可知,所有的设计中,接口应该是最先被设计出来的,被子类所继承。

代码实例化:

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

综合案例练习:

image-20210221215011157

实现相关代码:

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的相关概念,理清思路。

如果有错误欢迎指正,感谢各位看到最后!


相关推荐

PHP实现部分字符隐藏

沙雕mars · 355浏览 · 2019-04-28 09:47:56
Java中ArrayList和LinkedList区别

kenrry1992 · 280浏览 · 2019-05-08 21:14:54
Tomcat 下载及安装配置

manongba · 331浏览 · 2019-05-13 21:03:56
JAVA变量介绍

manongba · 296浏览 · 2019-05-13 21:05:52
什么是SpringBoot

iamitnan · 291浏览 · 2019-05-14 22:20:36
加载中

0评论

评论
坐标是江苏.南京,行业是互联网,技术是PHP和java,还有熟悉前后端等。
分类专栏
小鸟云服务器
扫码进入手机网页