interface、implement、extends、class、super区别

最新推荐文章于 2023-02-15 16:18:12 发布
最新推荐文章于 2023-02-15 16:18:12 发布
阅读量940 收藏 1
点赞数 2
分类专栏： 前端 js基础 文章标签： js vscode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/galaxyfanqi/article/details/122435535
版权

interface接口：只声名成员方法，不做实现

implement实现：实现接口（接口可实现多个）

extends继承类：可重写父类的方法（类只能继承一个）

class类：声明并实现方法

super:调用父类的方法，引用父类的构造函数


export enum TaskEnum {
    ACCNPP,
    AVEFVC,
    QIMonthly,
    NPPSLOPE,
    FVCSLOPE,
    QISLOPE,
    BIOMASS,
    BIOMASSSLOPE
}
const TEND = ["上", "中", "下"];
export class TaskFactory {
    static getTask(initTask, taskEnum: TaskEnum): Task {
        switch (taskEnum) {
            case TaskEnum.ACCNPP:
                if (initTask) {
                    let task = initTask["ACCNPP"];
                    class ACCNPP extends BaseTask {
                        readonly task_type = TaskEnum.ACCNPP;
                        readonly title_add = task["title_add"];
                        readonly task_name = task["task_name"];
                        readonly task_url = task["task_url"];
                        public style_name = task["style_name"];
                    }
                    return new ACCNPP();
                }
                break;
        }

    }

export interface TaskParam {
    sy: string;
    ey: string;
    sm: string;
    em: string;
    reso?: string;
    type: string;
    asy?: string;
    aey?: string;
    remake?: string;
    forestType?: string;
    sat?: string
}

export interface Task {
    readonly task_type: TaskEnum;
    readonly title_add: string;
    readonly task_name: string;
    readonly task_url: string;
    style_name: string;
    taskParam: TaskParam;
    initTaskParam(year: number, syear: number, winter: boolean, sDate: Date, eDate: Date, reso: string, sat: string, type: string, asy: string, aey: string, forestType: string)
    analysisTaskParam(args: string)
    translateDate(winter?: boolean): string;
    translateType(): string;
    initProductRuleName(style?: number, coverage?: string, formatter?: string): string;
    getProductStartDate(dateStr: string, sIndex: number, eIndex: number): string;
    getTitle(): string;
    getStyle(style?: number): string;
    isTaskParamNull(): boolean;
    initGridInfoName(coverage?: string, formatter?: string, type?: string, argv?: string): string;
}

class BaseTask implements Task {
    readonly task_type: TaskEnum;
    readonly title_add: string;
    readonly task_name: string;
    readonly task_url: string;
    public style_name: string;
    private _taskParam: TaskParam;
    public set taskParam(taskParam: TaskParam) {
        this._taskParam = taskParam;
    }
    public get taskParam(): TaskParam {
        if (!this._taskParam) {
            throw new Error("taskParam is " + this._taskParam);
        }
        return this._taskParam;
    }
    
    getTitle(): string {
        try {
            return this.translateDate() + this.title;
        } catch (error) {
            return this.title;
        }
    }

    getStyle(): string {
        try {
            return this.style_name;
        } catch (error) {
            return this.style_name;
        }
    }

    isTaskParamNull(): boolean {
        try {
            return this.taskParam == null
        } catch (error) {
            return true;
        }
    }

    initTaskParam(sDate: Date, eDate: Date, reso: string,) {
        this.taskParam = {
            meteo_type: this.meteo_type,
            sy: sDate.getFullYear().toString(),
            ey: eDate.getFullYear().toString(),
            sm: (sDate.getMonth() + 1).toString().padStart(2, "0"),
            em: (eDate.getMonth() + 1).toString().padStart(2, "0"),
            vege_type: this.vege_type,
            type: this.type,
            // relevant: this.relevant == "QI-Monthly" ? "QI" : this.relevant,
            reso: reso
        }
        return this.taskParam;
    }

    analysisTaskParam(args: string) {
        /**
         * 标准参数格式：
         * meteo_type:   温度v12001   日照v14032  降水v13201  
         * type      :   1  统计        TAV,RRR,SSH
         * type      :   2  均值        AVETAV
         * type      :   4  趋势率      TAV-SLOPE
         * type      :   5  相关        TAV-RELE-NPP  TAV-RELE-FVC  TAV-RELE-QI
         * type      :   6  影响        TAV-EFCT-NPP
         */

        try {
            this.taskParam = null;
            if (!args) {
                console.warn("args is empty");
                return;
            }
            let taskParam: TaskParam = JSON.parse(args) as TaskParam;
            // console.log(taskParam)
            if (taskParam.meteo_type == this.meteo_type && taskParam.type == this.type && taskParam.vege_type == this.vege_type && taskParam.ey && taskParam.sy && taskParam.em.length == 2 && taskParam.sm.length == 2) {
                if (this.isYears == "false" && taskParam.sy != taskParam.ey) { return }
                if (this.isYears == "true" && taskParam.sy == taskParam.ey) { return }
                this.taskParam = taskParam;
                // console.log(this.taskParam);
            }
        } catch (error) {
            // console.warn(`JSON解译失败【${args}】`);
            return;
        }
    }

    translateType() {
        try {
            return this.title;
        } catch (error) {
            return;
        }
    }

    translateDate(): string {
        if (this.isYears == 'true') {
            return `${this.taskParam.sy}年-${this.taskParam.ey}年${Number(this.taskParam.sm)}月-${Number(this.taskParam.em)}月`;
        } else {
            return `${this.taskParam.sy}年${Number(this.taskParam.sm)}月-${Number(this.taskParam.em)}月`;
        }
    }

    initProductRuleName(coverage = "CHN", formatter = "img") {
        let year = Number(this.taskParam.ey)
        let eMonth = Number(this.taskParam.em)
        let dayCount = ((new Date(year, eMonth, 1).getTime() - new Date(year, eMonth - 1, 1).getTime()) / 24 / 3600 / 1000).toString().padStart(2, "0");
        let style = this.getStyle() == 'TAV' && this.taskParam.type == '2' ? 'AVETAV' : this.getStyle();
        return `Z_AGME_C_BABJ_${this.taskParam.ey}${this.taskParam.em.padStart(2, "0")}${dayCount}000000_P_CAGMSS_WCRMECO_SCOP-${style}-${this.taskParam.sy}${this.taskParam.sm.padStart(2, "0")}01000000_1KM_${coverage.toUpperCase()}_L88_PD_000_00.${formatter.toLowerCase()}`;
    }

    getProductStartDate(dateStr: string, sIndex: number, eIndex: number) {
        return dateStr.split("-")[dateStr.split("-").length - 1].substring(sIndex, eIndex);
    }

static getTask(initTask, taskEnum: TaskEnum): Task {
        switch (taskEnum) {
            case TaskEnum.ACCNPP:
                if (initTask) {
                    let task = initTask["ACCNPP"];
                    class ACCNPP extends BaseTask {
                        readonly task_type = TaskEnum.ACCNPP;
                        readonly title_add = task["title_add"];
                        readonly task_name = task["task_name"];
                        readonly task_url = task["task_url"];
                        public style_name = task["style_name"];
                    }
                    return new ACCNPP();
                }
                break;
            case TaskEnum.AVGQW:
                if (initTask) {
                    let task = initTask["AVGQW"];
                    return new AVGQW(task);
                }
                break;
        }
    }

class AVGQW extends BaseTask {
    readonly task_type = TaskEnum.AVGQW;
    readonly isYears: string;
    readonly title: string;
    readonly meteo_type: string;
    readonly type: string;
    readonly vege_type: string;
    readonly task_name: string;
    readonly task_url: string;
    public style_name: string;
    constructor(json) {
        super();
        this.isYears = json.isYears;
        this.title = json.title;
        this.meteo_type = json.meteo_type;
        this.type = json.type;
        this.vege_type = json.vege_type;
        this.task_name = json.task_name;
        this.task_url = json.task_url;
        this.style_name = json.style_name;
    }
}```
我爱甜甜圈
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C Interface and Implement
04-03
Every programmer and software project manager must master the art of creating reusable software modules; they are the building blocks of large, reliable applications. Unlike some modern object-oriented languages, C provides little linguistic support or motivation for creating reusable application programming interfaces (APIs). While most C programmers use APIs and the libraries that implement them in almost every application they write, relatively few programmers create and disseminate new, widely applicable APIs. C Interfaces and Implementations shows how to create reusable APIs using interface-based design, a language-independent methodology that separates interfaces from their implementations. This methodology is explained by example. The author describes in detail 24 interfaces and their implementations, providing the reader with a thorough understanding of this design approach.
两种接口的简单调用方法
03-12
public class ActivityA extends AppCompatActivity implements MyInterface { @Override public void onEventHappened() { // 处理事件 } } // Activity B 调用接口 public class ActivityB extends ...
TypeScript 基本语法
weixin_34384915的博客
06-14 170
TypeScript 是微软开发的 JavaScript 的超集，TypeScript兼容JavaScript，可以载入JavaScript代码然后运行。TypeScript与JavaScript相比进步的地方 包括：加入注释，让编译器理解所支持的对象和函数，编译器会移除注释，不会增加开销；增加一个完整的类结构，使之更新是传统的面向对象语言。 TypeScript 微软官方网站 http:/...
Interface、extends、implement的区别
Wpan的博客
06-04 7753
解释Interface、extends、implement关键字的区别
java extends/interface/implement三者的联系与区别
qq_32929981的博客
12-22 1148
extends 顾名思义是继承，继承一个父类的所有功能。interface 是接口的意思，在其中定义某些虚函数，但没有具体实现。implement 是执行实现的意思，在继承了接口定义的虚函数并实现。public class LoginAction extends ActionSupport { @Override public String execute() throws
接口 interface implements
JasonZi的博客
09-12 313
/*  当抽象类中所有的方法都是抽象的。  这时，可以把抽象类用另一种形式来表示，接口。    初期可以理解为接口是特殊的抽象类。  */ //定义接口 //interface Inter //{ // public static final int NUM=4;          //全局常量 // public abstract void show1();         
java 接口 Interface，抽象类,普通类的区别，实现接口,implement.
半亩方糖
04-16 621
一、接口，抽象类，和具体的实现普通类类，的区别 1.普通类: 只有具体的实现, 2.抽象类:具体实现 和 规范(抽象方法) 都有.单继承 3.接口 : 只有规范(抽象方法)，可多继承。 二、接口的注意事项: 1.接口的方法默认, public static 修饰, 属性默认常量(public static final)。一般开发中不在接口中定义常量，只定义抽象方法。 2.class类实现imple...
Fragment与Activity使用接口进行交互
06-27
public class MainActivity extends AppCompatActivity implements OnFragmentInteractionListener { @Override public void onSomeAction(String data) { // 在这里处理Fragment传来的数据或执行相应操作 } }...
Fragment和Activity交互（接口方式）
07-24
public class MainActivity extends AppCompatActivity implements OnFragmentInteractionListener { @Override public void onButtonClicked() { // 这里处理Fragment传递过来的事件 } } ``` 3. **设置监听...
通过animal类及其子类来联系继承以及虚拟类、接口
08-20
public class Bird extends Animal implements Flyable { public Bird(String name) { super(name); } @Override public void makeSound() { System.out.println("鸟儿在歌唱"); } @Override public void...
Java 中桥接模式——对象结构型模式的实例详解
08-29
public class RefinedAbstraction extends Abstraction { public RefinedAbstraction(Implementor implementor) { super(implementor); } public void refinedOperation() { // 对 Abstraction中的方法进行...
JAVA 接口 Interface 学习笔记 implements
qq_34110260的博客
06-06 288
http://blog.csdn.net/zhangyufeng0126/article/details/51538685
接口（interface、implement）
古城的博客
10-06 2682
接口 接口：interface 接口的类中 所有的属性默认为：public static final 所有的方法默认为：public abstract 在jdk1.8之前只能定义静态的常量和公共的抽象方法，在jdk1.8之后就可以定义静态方法和默认方法 （常量一般都建议使用大写字母） 特性 ● 接口不可以被实例化 ● 实现类必须重写接口的所有方法（抽象的方法） ● 实现类可以实现多个接口 ● 接口中的变量都是静态常量 ...
final 和abstract interface 和implement
ice
07-15 224
final：  作用：提高安全性，和可读性修饰过的类不能被继承修饰过的变量不能更改值修饰过的方法不能被重写abstract：一般用作父类，由于父类一般普遍，所以设计的比较抽象，没有具体的实例注意：含有抽象方法的类必须声明为抽象类抽象类不能被实例化，只能用作继承，并且子类必须重写全部的抽象方法，并提供方法体。若没有重写所有方法，仍为抽象类...
【Java基础】implement 与 extends
qq_39535439的博客
02-15 1739
Java基础 implement extends 使用
interface，implement和extends
hellocsz的博客
08-16 416
interface是定义接口的关键字，所谓的接口说白了就是一个规则，用电脑的USB插口打个比方 public interface USB接口{ 这个接口只能插标准USB接口（）；/所谓接口中的方法就是定义了个规范，而我这个标准USB接口中要插鼠标还是优盘，那就是在你的实现类中根据具体情况来看了/ } 而implement就是实现接口的关键字，你要是现实了一个接口，那就必须实现里边的方法，接...
java interface和类的 extends与implement 的简单总结
小yi的博客
01-24 2065
interface和类、extends与implement 接口 一个接口则可以同时extends多个接口，却不能implements任何接口 类 一个类只能extends一个父类，但可以implements多个接口 转自java interface和类的 extends与implement 的简单总结 ...
接口（implements）的与继承（extends）总结及比较用法
Pasby的博客
03-31 2141
作为一名学生，这都是我平时在学习中遇到的一些问题，不清楚不明白的地方，总结给大家的，希望能够帮助到大家 1.接口的定义 使用interface来定义一个接口。接口定义同类的定义类似，也是分为接口的声明和接口体，其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下： [修饰符] interface 接口名 [extends 父接口名列表]{ [public] [static] [fina...
implement, extends, super in Java
天下事有难易乎？
10-17 439
今天的Java课上楼sir讲了这三个概念，但讲的不大清楚，特此来总结学习一下。关键字extends和implement的区别 extends: 继承 implement：接口在C++中一个子类可以有多个父类，称之为多层继承（multiple inheritance). 但是这个特性在JAVA中是被禁止的。作为补偿，Java有一个特性称之为接口（interface）, 接口是一种与类相似的结构，只
Design an abstract class named Bird to represent a bird. The class contains an void sing() method to print This bird sings. Design an interface named Flyable to represent anything can fly and contai
最新发布
05-28
ns a void fly() method. The Bird class should implement the Flyable interface and override the fly() method to print This bird flies. Additionally, the Bird class should have a protected string field named color to represent the color of the bird. The class should have a constructor that takes a string parameter to set the color of the bird. Finally, the Bird class should have a public getColor() method that returns the color of the bird. Here's an example implementation in Java: ``` public interface Flyable { void fly(); } public abstract class Bird implements Flyable { protected String color; public Bird(String color) { this.color = color; } public String getColor() { return color; } @Override public void fly() { System.out.println("This bird flies."); } public abstract void sing(); } public class Sparrow extends Bird { public Sparrow(String color) { super(color); } @Override public void sing() { System.out.println("This bird sings."); } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值