关于Java中的对象、类、抽象类、接口、继承之间的联系:

导读:

寒假学习JavaSE基础,其中的概念属实比较多,关联性也比较大,再次将相关的知识点复习一些,并理顺其中的关系。

正文:

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

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

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

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

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

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

代码实例化:

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多个子类,不巧的是接口需要增加方法,那么每个子类都要覆写一遍新添的方法,想想都很恐怖;在此基础上增加了弥补的方法

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

综合案例练习:

实现相关代码:

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中的对象、类、抽象类、接口、继承之间的联系的更多相关文章

  1. Java中的实体类--Serializable接口、transient 关键字

    在java中,实体类是一个非常重要的概念,我们可以在实体类中封装对象.设置其属性和方法等.关于实体类,也经常涉及到适配器模式.装饰者模式等设计模式.那么在实际代码开发中,关于实体类的注意事项有哪些呢? ...

  2. Java基础(43):Java中的Object类与其方法(转)

    Object类 java.lang.Object java.lang包在使用的时候无需显示导入,编译时由编译器自动导入. Object类是类层次结构的根,Java中所有的类从根本上都继承自这个类. O ...

  3. java中的对象、类、包、模块、组件、容器、框架、架构的概念入门

    在Java中有那么一些概念:对象.类.包.模块.组件.容器.框架.这些概念都有一个共同的特点,就是[容纳]. 对象(Object) 在Java的世界里,对象是通过属性和方法来分别对应事务所具有的静态属 ...

  4. 在java中,List是个接口,那实现List接口的类有哪些,有什么区别?

    在java中,List是个接口,那实现List接口的类有哪些,有什么区别? 解答: ArrayList是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引 ...

  5. 将java中Map对象转为有相同属性的类对象(json作为中间转换)

    java中Map对象转为有相同属性的类对象(json作为中间转换) 准备好json转换工具类 public class JsonUtil { private static ObjectMapper o ...

  6. javaAPI中的常用 类 以及接口

    java.lang包中的常用类以及接口 类 1. Integer :Integer 类在对象中包装了一个基本类型 int 的值.Integer 类型的对象包含一个 int 类型的字段. 2. Math ...

  7. Java中的集合(三)继承Collection的Queue接口

    Java中的集合(三)继承Collection的Queue接口 一.Queue介绍 Queue接口继承自Collection接口,是Java中定义的一种队列数据结构,元素是有序的(按插入顺序排序),先 ...

  8. java 中常用的类

    java 中常用的类 Math Math 类,包含用于执行基本数学运算的方法 常用API 取整 l  static double abs(double  a) 获取double 的绝对值 l  sta ...

  9. 【学习笔记】Java中生成对象的5中方法

    概述:本文介绍以下java五种创建对象的方式: 1.用new语句创建对象,这是最常用的创建对象的方式. 2.使用Class类的newInstance方法 3.运用反射手段,调用java.lang.re ...

  10. 【Java】Java中的Collections类——Java中升级版的数据结构【转】

    一般来说课本上的数据结构包括数组.单链表.堆栈.树.图.我这里所指的数据结构,是一个怎么表示一个对象的问题,有时候,单单一个变量声明不堪大用,比如int,String,double甚至一维数组.二维数 ...

随机推荐

  1. PDF 补丁丁 0.4.2.891 测试版发布:合并PDF文件时设置书签文本和样式

    新的测试版在合并文件界面增加了设置书签样式的功能.除了可以为所合并的图片(或PDF文件)指定书签文本之外,还可以指定其文本样式(文本颜色.粗体.斜体).如下图所示. 此外,合并文件界面还添加了文件夹历 ...

  2. Mongod(5):启动命令mongod参数说明

    Mongodb启动命令mongod参数说明(http://blog.csdn.net/fdipzone/article/details/7442162) mongod的主要参数有: 基本配置 ---- ...

  3. Spring MVC整合logback日志框架实战

    1.引入依赖,本项目maven构建,普通项目导入想要的jar包即可 版本 <properties> <slf4j-api.version>1.7.7</slf4j-api ...

  4. block 浅析

    最近讲了一个关于block的例子 block 可以作为一个参数 进行传递 需要注意的地方是 :block 虽然作为一个参数 但是在函数方法执行的时候 block 是不会在定义它的地方调用 除非你在后边 ...

  5. HDFS概述(5)————HDFS HA

    HA With QJM 目标 本指南概述了HDFS高可用性(HA)功能以及如何使用Quorum Journal Manager(QJM)功能配置和管理HA HDFS集群. 本文档假设读者对HDFS集群 ...

  6. proc文件系统探索 之 根目录下的文件[二]

    包括对proc根目录下stat,uptime,swaps三个文件的解析. /proc/stat 文件包含了系统启动后的一些系统统计信息. Cat /proc/stat: cpu 77781 1077 ...

  7. .NET Core 2.1来了!

    太棒了! .NET Core 2.0正式发布至今已经过去了大半年,这大半年说长不长说短不短,这段时间里,我是充分地体会到了微软的诚意,那就是认认真真打造一个优秀的开源平台.这大半年的时间里,微软一直在 ...

  8. js 中导出excel 较长数字串会变成科学计数法

    在做项目中,碰到如题的问题.比如要将居民的信息导出到excel中,居民的身份证号码因为长度过长(大于10位),excel会自动的将过长的数字串转换成 科学计数法.现在网上找到解决方案之一: (在数字串 ...

  9. [python-opencv]超大图像二值化方法

    *分块 *全局阈值 VS 局部阈值 import cv2 as cv import numpy as np def big_image_binary(image): print(image.shape ...

  10. 关于ln(link)命令

    一. ln分为硬链接和软链接. 二. 硬链接命令为: ln test/a.text hard.text 1. 这样hard.text拥有 test目录下a.text相同的i节点(inode的id号)和 ...