大数据——抽象类和接口

最新推荐文章于 2022-06-25 13:56:58 发布
最新推荐文章于 2022-06-25 13:56:58 发布
阅读量391 收藏
点赞数 2
文章标签： 大数据 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsjia2970727/article/details/107549225
版权

抽象类和接口

初识抽象类和抽象方法

区分普通方法和抽象方法

在Java中，当一个类的方法被abstract关键字修饰时，该方法称为抽象方法。抽象方法所在的类必须定义为抽象类。
当一个方法被定义为抽象方法后，意味着该方法不会有具体的实现，而是在抽象类的子类中通过方法重写进行实现。定义抽象方法的语法格式如下：
[访问修饰符]abstract<返回类型><方法名>([参数列表]);
abstract关键字表示该方法被定义为抽象方法。
普通方法和抽象方法相比，主要有下列两点区别：
抽象方法需要需要用修饰符abstract修饰，普通方法不需要。
普通方法有方法体，抽象方法没有方法体。

区分普通类和抽象类

在Java中，当一个类被abstract关键字修饰时，该类称为抽象类。
定义抽象类的语法格式如下：
abstract class<类名>{
}
abstract关键字表示该类被定义为抽象类。
普通类和抽象类相比，主要有下列两点区别：
抽象类需要用修饰符abstract修饰，普通类不需要。
普通类可以实例化，抽象类不能被实例化。

定义一个抽象类

当一个类被定义为抽象类时，它可以包含各种类型的成员，包括属性、方法等，其中方法又可分为普通方法和抽象方法，如下面的抽象类结构示例：
public abstract class 类名称{
修饰符 abstract 返回类型 方法名();
修饰符 返回类型 方法名(){
方法体
}
}
注意：抽象方法只能定义在抽象类中。但是抽象类中可以包含抽象方法，也可以包含普通方法，还可以包含普通类包含的一切成员。

使用抽象类描述抽象的事物

下面通过一个实例简单认识抽象类和抽象方法的用法。
示例一：

public abstract class Man {
   private String name;
    String sex;
    int age;
    double height;
    double weight;
    public abstract void eat();
    public abstract void drink();
    public void shit(){
        System.out.println("Shit!!!!");
    }
    public void sleep(){
        System.out.println("睡就是了！！！！     ");
    }

    protected String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public class Student extends Man {
    @Override
    public void eat() {
    }
    @Override
    public void drink() {
    }
    @Override
    public void sleep() {
        super.sleep();
    }
}

总结

抽象类abstract关键字修饰类
抽象类不能被实例化（不能创建对象）
抽象方法：
抽象方法必须在抽象类中
抽象方法没有结构体
子类继承抽象类的时候，必须实现父类的抽象方法，除非这个子类也是抽象类

接口

生活中的接口

在现实生活中，USB接口实际上是某些企业和组织制定的一种约定或标准，规定了接口的大小、形状等。按照该约定设计的各种设备，如U盘、USB风扇、USB键盘都可以插到USB接口上正常工作。USB接口相关工作是按照如下步骤进行的。
（1）约定USB接口标准。
（2）制作符合USB接口约定的各种具体设备。
（3）把USB设备插到USB接口上进行工作。
Java中接口的作用和生活中的接口类似，它提供一种约定，使得实现接口的类（或结构）在形式上保持一致。
如果抽象类中所有的方法都是抽象方法，就可以使用Java提供的接口来表示。从这个角度来讲，接口可以看作是一种特殊的“抽象类”，但是采用与抽象类完全不同的语法来表示，两者的设计理念也不同。

定义和实现一个简单的接口

简单来说，接口是一个不能实例化的类型。接口类型的定义类似于类的定义，语法格式如下：
public interface 接口名{
//接口成员
}
和抽象类不同，定义接口使用interface修饰符，访问修饰符只能是public，且可选。
接口成员可以是全局变量和公共的抽象的方法。
与抽象类一样，使用接口也必须通过子类，子类通过implements关键字实现接口。
实现接口的语法格式如下：
public 类名 implements 接口名{
实现方法
普通方法
}
实现接口使用implements关键字。
实现接口必须实现接口中定义的所有抽象方法。接口的实现类允许包含普通方法。
示例二：
实现USB接口。

public interface USB {
    public static final int LENGTH=10;//长度
    int WIDTh = 3;//宽度
    double POWER=1.5;
   // void power();
    void connect();
}
public class USBMouse implements USB {
    @Override
    public void connect() {
        System.out.println("点击鼠标，啪啪啪，LOL玩起来");
    }
}
public class USBFlash  implements USB{
    @Override
    public void connect() {
        System.out.println("500G的种子请拿走！");
    }
}
public class Computer {
    public void control(USB usbDevice){
        usbDevice.connect();
    }
    public static void main(String[] args) {
        Computer c=new Computer();
        USBMouse m=new USBMouse();
        USBFlash f=new USBFlash();
        c.control(m);
        c.control(f);
    }
}

输出结果：
在这里插入图片描述

更复杂的接口

接口本身也可以继承接口。
接口继承的语法格式如下：
[修饰符]interface 接口名 extends 父接口1，父接口2…{
常量接口
方法定义
}
一个普通类只能继承一个父类，但能同时实现多个接口，也可以同时继承抽象类和实现接口。
实现多个接口的语法格式如下：
class 类名 extends 父类名 implements 接口1，接口2，…{
类的成员
}
关于定义和实现接口，需要注意以下几个方面的内容。
接口和类、抽象类是一个层次的概念，命名规则相同。
修饰符如果是public，则该接口在整个项目中可见。如果省略修饰符，该接口只在当前包中可见。
接口中可以定义常量，不能定义变量。接口中的属性都默认用“public static final”修饰，即接口中的属性都是全局静态常量。接口中的常量必须在定义时指定初始值，举例如下：
public static final int PI=3.14；
int PI-3.14；//在接口中，这两个定义语句的效果完全相同
int PI; //错误，在接口中定义时必须指定初始值，如果在类中定义会有默认值
接口中的所有方法都是抽象方法，接口中的方法都默认为public。
和抽象类一样，接口同样不能实例化，接口中不能有构造方法。
接口间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类。
类只能继承一个父类，但可以通过implements实现多个接口。一个类必须实现接口的全部方法，否则必须定义为抽象。若一个类在继承父类的同时又实现了多个接口，extends必须位于implements之前。
示例三：
门有“开”和“关”的功能，锁有“上锁”和“开锁”的功能
将门定义为抽象类，锁定义为接口。
防盗门继承门，实现锁的接口。

public abstract class Door {
    public abstract void open();
    public abstract void close();
}
public interface Lock {//interface关键字声明接口
    //接口中所有的方法都是公共抽象方法
    public abstract void lockUp();
    void lockDown();
}
public interface Camera {
    void takePhoto();
}
public class DefenderDoor extends Door implements Lock,Camera{
    @Override
    public void open() {
        System.out.println("门开了！");
        takePhoto();
    }
    @Override
    public void close() {
        System.out.println("门关了！");
        takePhoto();
    }
    @Override
    public void lockUp() {
        System.out.println("锁开了！");
    }
    @Override
    public void lockDown() {
        System.out.println("锁上了！");
    }
       @Override
    public void takePhoto() {
        System.out.println("拍照");
    }
}
public class Master {
    String name;
    DefenderDoor door;
    public void getIn(){
        System.out.println(name+"掏出一串钥匙,插入锁孔开始转动");
        door.lockUp();
        door.open();
        System.out.println("进入房间！");
    }
    public void getOut(){
        System.out.println("走出房间");
        door.close();
        System.out.println("掏出一串钥匙,插入锁孔，开始转动");
        door.lockDown();
    }
}
public class TestMaster {
    public static void main(String[] args) {
        Master m=new Master();
        m.name="包租婆";
        m.door=new DefenderDoor();
        m.getIn();
        m.getOut();
    }
}

输出结果：
在这里插入图片描述
示例四：
原始的手机，可以发短信，通电话。随着发展，手机增加了功能：音频、视频播放、拍照、上网。使用接口实现手机功能。
在这里插入图片描述

public abstract class Handset {
      public  abstract void sengInfo();
      public abstract void call();
      public abstract void info();
}
public interface TheakePictures {
    void takePictures();
}
public interface Network {
    void networkConn();
}
public interface PlayWiring {
    void play(String content);
}
public class Phone {
    String pinpai;
    String xinhao;
    public Phone(String xinhao, String pinpai) {
        this.xinhao=xinhao;
        this.pinpai=pinpai;
        System.out.println("这是一款型号为："+this.xinhao+",品牌是："+this.pinpai+"的手机！");
}
public class CommonHandset extends Handset implements PlayWiring ,Network,TheakePictures{
    @Override
    public void sengInfo() {
        System.out.println("发信息。。。");
    }
    @Override
    public void call() {
        System.out.println("打电话。。。");
    }
    @Override
    public void info() {
        System.out.println("接收信息。。。");
    }
    @Override
    public void play(String content) {
        System.out.println("播放"+content);
    }
    @Override
    public void networkConn() {
        System.out.println("已经启动移动网络。。。");
    }
    @Override
    public void takePictures() {
        System.out.println("咔嚓。。。拍照成功。。");
    }
}
public class TextCommon {
    public static void main(String[] args) {
        Phone phone1 = new Phone("G502c ", "索尼爱立信 ");
        CommonHandset c=new CommonHandset();
        c.sengInfo();
        c.info();
        c.play("《热血》");
        Phone phone2=new Phone("HTC","I9100");
        c.networkConn();
        c.play("《小时代》");
        c.takePictures();
        c.sengInfo();
        c.call();
    }
}

输出结果：
在这里插入图片描述
示例五：
开发打印机
墨盒：彩色、黑白
纸张类型：A4、B5
墨盒和纸张都不是打印机厂商提供的
打印机厂商要兼容市场上的墨盒、纸张
在这里插入图片描述

public interface Paper {
String getSize();
}
public interface InkBox {
    String getcolcor();
}
public class A4Paper implements  Paper {
    @Override
    public String getSize() {
        return "A4";
    }
}
public class B5Paper implements Paper {
    @Override
    public String getSize() {
        return "B5";
    }
}
public class BlackInkBox implements InkBox {
    @Override
    public String getcolcor() {
        return "黑色";
    }
}
public class ColorfulInkBox implements InkBox {
    @Override
    public String getcolcor() {
        return "彩色";
    }
}
public class PaperAndInkBox extends Paper  {
}
public  class Printer {
     public  void print(Paper p,InkBox box){
         System.out.println("使用" + box.getcolcor()+ "墨盒在" +p.getSize()+"纸上打印");
     }
    public static void main(String[] args) {
         Printer p=new Printer();
        Paper paper = new A4Paper();
        InkBox box = new ColorfulInkBox();
        p.print(paper, box);
    }
}

输出结果：
在这里插入图片描述
示例六：组装一台计算机
需求说明：
采用面向接口编程思想组装一台计算机
计算机的主要组成部分
CPU
硬盘
内存
在这里插入图片描述

实现思路：
定义CPU的接口CPU，返回CPU品牌和主频
定义内存的接口EMS，返回类型和容量
定义硬盘的接口HardDisk，返回容量
编写各组件厂商分别实现CPU、EMS、和HardDisk接口
编写计算机类，组装计算机并显示相关信息
编写测试类运行

public interface CPU {
    void cpu();
    void zhupin();
}
public interface EMS {
    void leixing();
    void rongliang();
}
public interface HardDisk {
    void yingpan();
}
public class ChanShang implements CPU,EMS, HardDisk {
    @Override
    public void cpu() {
    }
    @Override
    public void zhupin() {
    }
    @Override
    public void leixing() {
    }
    @Override
    public void rongliang() {
    }
    @Override
    public void yingpan(){
    }
}
public class computer {
    String pingpai;
    String zhupin;
    String leixing;
    int ronglianng;
    int liang;

    public   computer(String pingpai,String zhupin,int rongliang ,int liang){
        this.pingpai=pingpai;
        this.zhupin=zhupin;
        this.ronglianng=rongliang;
        this.liang=liang;
        System.out.println("Cpu品牌是：" + pingpai +
                ",主频是：" + zhupin+"，硬盘容量是："+rongliang+",内存容量："+liang );
    }
    public class TestComputer {
    public static void main(String[] args) {
        System.out.println("这个电脑的信息是：");
        computer c=new computer("Intel","3.8GHz",3000,4);
    }
}

输出结果：
在这里插入图片描述

接口的使用

接口中的成员变量：
默认都是public static final的，必须显式初始化。
接口中的方法：
默认都是public abstract的。
接口没有构造方法，不能被实例化。
一个接口不能实现另一个接口，但可以继承多个其他接口。
一个类必须实现接口抽象方法（implements），除非这个类也是抽象类。

抽象类vs接口

相同点：
代表系统的抽象层。
都不能被实例化。
都能包含抽象方法。
用于描述系统提供的服务，不必提供具体实现。
不同点：
在抽象类中可以为部分方法提供默认实现，而接口中只能包含抽象方法。
抽象类便于复用，接口便于代码维护。
一个类只能继承一个直接的父类，但可以实现多个接口。
使用原则：
接口做系统与外界交互的窗口。
接口提供服务。
接口本身一旦制定，就不允许随意修改。
抽象类可完成部分功能实现，还有部分功能可作为系统的扩展点。
面向对象设计原则：
多用组合，少用继承。
针对接口编程。
针对扩展开放，针对改变关闭。

总结

Java中的接口：
属性全都是全局静态常量。
方法都是全局抽象方法。
无构造方法。
一个类可以实现多个接口，非抽象类实现接口时必须实现接口中的全部方法。
抽象类利于代码复用，接口利于代码维护。

蜂蜜柚子加苦茶
关注
大数据必学Java基础（四十四）：接口讲解
Lansonli（蓝深李）的博客
07-26 827
访问修饰符]interface接口名[extends父接口1，父接口2…（4）接口当做方法的返回值，返回的是具体的实现类的对象。定义规则，只是跟抽象类不同地方在哪？（2）父类当做方法的返回值，返回的是具体的子类的对象。（3）接口当做方法的形参，传入具体的实现类的对象。（1）父类当做方法的形参，传入具体的子类的对象。接口定义好规则之后，实现类负责实现即可。...
C#抽象类，接口，集合
NeverMore741的博客
09-28 172
一.抽象类 定义：抽象是把多个事物的共性的内容抽取出来，本质就是把我们关注具有共性的内容抽取出来，类是一个具有相同特征和行为的抽象，而抽象类（class 前加上 abstract）没有指出行为的具体细节，而由他的子类去实现相应的行为。 特征：1.抽象类中的方法可以有方法体，但也可以没有； 2.抽象类是不能被实例化的； 3.抽象类中没有方法体的方法则需要子类去实现。 抽象方法特点：1.抽象方法没有方法体； ...
大数据学习：抽象类
09-25 148
大数据学习：抽象类 5.3.1抽象类的定义 定义一个抽象类： 如果某个类至少存在一个抽象方法或一个抽象字段，则该类必须声明为abstract。 abstract class Person{ //没有初始值，抽象字段 var name:String //没有方法体，是抽象方法 def id: Int } class Employ extends Person{ var name:String=“Fr...
【大数据开发】Java基础-总结11-抽象类的注意点
99滴神
03-16 124
1、抽象类的定义：在类中只有方法的声明没有方法体的方法叫抽象方法，而拥有抽象方法的类叫做抽象类。 2、抽象方法的特点： 抽象方法只有方法的声明，没有实现（也就是说没有方法体） 并且抽象方法只能定义在抽象类中。 3、抽象类的注意点： 抽象类不一定有抽象方法，但有抽象方法的类一定是抽象类。 继承了抽象类的子类一定要实现抽象方法，如果不实现就只能将自己也变成抽象的。 抽象类不能直接创建对象，而是通过子类实现创建对象，所以抽象类一定会有子类。 3、普通类与抽象类的区别： 普通类可以直接创建...
java中 代表集合的抽象数据类型是_面向对象编程之：Java中的抽象数据类型
weixin_29798025的博客
02-28 258
ption异常。UnsupportedOperationException 类继承了RuntimeException类。这使得调用者能够调用所有的集合操作而不需要把每次调用都放在一个try-catch对里。List线性表List接口继承了Collection接口并定义了一个允许相同元素存在的有序集合。List接口还附加了一些使用一个数值型索引值并基于元素在线性表中的位置来操作Collection中...
大数据——Scala进阶（begin）
艾维的博客
02-16 377
一、统一类型（Unified Types） 1.1 Scala类型层次解构 Scala类型层次解构 Any 是所有类型的超类型，也称为顶级类型。 Any 定义了通用的方法：equals、hashCode、toString Any 有两个子类：AnyVal 和 AnyRef AnyVal 代表值类型。分为四类八种 + Unit 四类八种：四类（整型，浮点型，字符型，布尔...
大数据——Scala基础（Basics）
艾维的博客
02-04 181
输出语句（Hello World） Java中的输出语句 System.out.println("Hello World"); Scala中的输出语句 println("Hello World!"); 常量（Constant） 常量的定义：（使用关键字：val） val constant = "常量"; println("这是:"+constant); //Console: ...
接口，类与接口的关系，接口与抽象类的区别
weixin_59606855的博客
07-17 868
接口 1 接口的概念 与之前学习过的抽象类一样,接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准. 2 接口格式 3 接口的特点: 通过interface关键字来定义接口 通过implements让子类来实现接口 接口中的方法全部都是抽象方法(JAVA8) 可以把接口理解成一个特殊的抽象类(但接口不是类!!!) 类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法 接口突破了java单继承的局限性 接口.
大数据技术实践——Spark词频统计
08-23
【Spark技术实践——词频统计】在大数据领域，Spark作为一种高效的数据处理框架，以其快速、通用和可扩展性而受到广泛关注。本实践旨在基于已经搭建的Hadoop平台，利用Spark组件进行文本词频统计，以此深入理解Scala...
第八章——大数据
chy3232的博客
06-25 7150
一、大数据概述 1.大数据概念 大数据(big data)是一个抽象的概念，至今尚无确切、统一的定义，不同的研究机构与学者对其有着不同的定义。 全球最具权威的IT研究与顾问研究机构高德纳(TheGartner Group)咨询公司给出了这样的定义：“大数据”是需要新处理模式才能具有更强的决策力、洞察发现力和流程优化能力的海量、高增长率和多样化的信息资产。 麦肯锡全球研究所对大数据的定义是：一种规模大到在获取、存储、管理、分析方面大大超出了传统数据库软件工具能力范围的数据集合，具有海量的数据规模、快速
计算机接口教程,运用接口实现计算机各组件信息
weixin_36256917的博客
07-09 343
实现思路定义计算机组成部分定义CPU的接口CPU，返回CPU品牌和主频定义内存的接口EMS,返回容量定义硬盘接口HardDsik,返回容量实现计算机各组件信息编写各组件厂商分别实现CPU EMS 和HardDisk接口，编写计算机类，组装计算机并显示相关信息编写测试类运行定义CPU的接口CPU、定义内存的接口EMS、定义硬盘接口HardDsik/*** cpu接口* 返回品牌* 返回主频*/pub...
运用接口实现计算机各组件信息
不吃豆芽儿的博客
04-17 1296
实现思路 定义计算机组成部分 定义CPU的接口CPU，返回CPU品牌和主频 定义内存的接口EMS,返回容量 定义硬盘接口HardDsik,返回容量 实现计算机各组件信息 编写各组件厂商分别实现CPU EMS 和HardDisk接口，编写计算机类，组装计算机并显示相关信息 编写测试类运行 定义CPU的接口CPU、定义内存的接口EMS、定义硬盘接口HardDsik /** * cp...
面向接口编程开发打印机墨盒：彩色，黑白纸张类型：A4，B5墨盒和纸张都不是打印机厂商提供的打印机厂商要兼容市场上的墨盒，纸张
qq_62205007的博客
09-28 1784
开发打印机 墨盒：彩色，黑白 纸张类型：A4，B5 墨盒和纸张都不是打印机厂商提供的 打印机厂商要兼容市场上的墨盒，纸张 墨盒接口 package org.cc.demo1; public interface InkBox { public String color(); } 黑色 package org.cc.demo1; public class BlackBox implements InkBox{ @Override public String color() {
99%的人不知道大数据分析现状是什么，主要的分析技术是什么？
热门推荐
浩天的博客
01-08 1万+
近年来互联网的高速发展引领人类进入了一个信息量爆炸性增长的时代。每个人的生活中都充满了结构化和非结构化的数据。随着人类生活全面向互联网转移，大数据时代将会不可避免的到来！   作为全球互联网的前沿概念，大数据主要包括两方面特征：一方面整个社会的信息量急剧增长，另一方面个人可获取的信息也呈指数增长。从科技发展的角度来看，“大数据”是“数据化”趋势下的必然产物！并且随着这一趋势的不断深入，在不...
Java：利用接口实现打印机案例（墨盒有彩色和黑白色，纸张有A4纸和B5纸）
xuehyunyu的博客
08-15 1万+
把纸张和墨盒都定义为接口，让以后的实现类去实现它。 package com.jredu.oop.ch03; /** * 纸张接口 * @author Administrator * */ public interface Paper { /** * 纸张 */ void paper(); } package com.jredu.oop.ch03; public cla
Java中抽象类实现接口
qq_44887733的博客
05-06 7992
抽象类 Java中的抽象类主要是作为一个公共父类的作用，它可以抽象出用来描述一种类型应该具备的基本特征与功能，具体行为则由子类通过方法重写来完成。 抽象类具有的性质 类定义前需要加上abstract关键字 抽象类中可以没有抽象方法 抽象类中可以有非抽象方法 如果一个类中有至少一个抽象方法，那么它一定是抽象类，则类名前必须加上abstract关键字，抽象方法没有方法体。 抽象类无法实例化 只有覆盖了抽象类中所有的抽象方法后，其子类才可以实例化。如果存留未实现的抽象方法则该子类仍为一个抽象类，无法创建对象。
关于抽象类abstract的基础语法
weixin_44546294的博客
05-18 271
abstract基础语法 1.如何定义抽象类? class关键字前加abstract 2.抽象类无法被实例化 3.虽然抽象类没有办法实例化，但是抽象类也有构造方法，该构造方法是给子类创建对象用的。 4.抽象类中可以定义抽象方法. 抽象方法的语法：在方法的修饰符列表中添加abstract关键字.并且抽象方法应该以“;”结束,不能带有“{}” 例如：public abstract void m1(); 5.抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中。 6.一个非抽象的类继承抽象类，
【JAVA】接口
未入门的程序员笔记
08-03 4396
Java接口笔记
Java抽象（abstract）类的详解（语法规则，设计思想，代码实例）
qq_43514707的博客
12-07 8249
首先用关键字abstract修饰的类成为abstract类，如： abstract A{ ... } 用关键字abstract修饰的方法称为abstract方法。 注意：对于abstract方法，只允许声明，不允许实现，而且不能使用final和abstract同时修饰一个方法，例如： abstract int min（int x，int y） 1.abstract类中可以有abstract方法，也可以有非abstract方法 2.abstract类不能使用new运算创建对象 重点：如果一个非抽象类是某
Java与Hadoop：大数据面试关键点解析
内容包括面向对象的四大特征——抽象、继承、封装和多态性，以及Java语言的基础语法和特性，如作用域、数据类型和操作。此外，还涉及到了Hadoop相关的面试题目，帮助程序员准备大数据技术的面试挑战。" 在Java部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值