1.接口简介

接口就是多个类的公共规范。只要符合规范标准，就可以大家通用。
接口是一种引用数据类型，最重要的内容就是其中的:抽象方法。

定义一个接口的格式:

    public interface 接口名称{
        //接口内容
    }

Note:换成了关键字interface之后，编译后所生成的字节码文件仍然是: .java –> .class。

Java 8中接口可以包含:
1. 常量
2．抽象方法工
3．默认方法
4．静态方法

如果是Java 9，还可以额外包含有:
1. 私有方法

2．抽象方法

1.接口当中的抽象方法，修饰符是两个固定的关键字:public abstract
2.这两个关键字修饰符，可以选择性地省略。
3.方法的三要素，可以随意定义。

public interface MyInterfaceAbstract {
    //这是一个抽象方法
    public abstract void method1();

    //这也是抽象方法
    abstract void method2();

    //这也是抽象方法
    public void method3();

    //这也是抽象方法
    int method4();
}

在初期我们创建了 IHasModel 接口用于对模组中的物品模型进行注册

public interface IHasModel {

    public void registerModels();

}

在 ItemBase、ArmorBase等物品类中我们均为 IHasModel 接口的实现类，并对该类中的registerModels()方法进行了重写

public class ItemBase extends Item implements IHasModel
public class ArmorBase extends ItemArmor implements IHasModel
public class FoodBase extends ItemFood implements IHasModel

(@Override)重写registerModels()

    @Override
    public void registerModels() {
        Main.proxy.registerItemRenderer(this, 0, "inventory");
    }

3.接口使用步骤

1. 接口不能直接使用，必须有一个”实现类”来”实现”该接口。
2. 接口的实现类必须覆盖重写(@Override)接口中所有的抽象方法。实现:去掉abstract关键字，加上方法体大括号。 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
3. 创建实现类的对象,进行使用。

public class 实现类名称 implements 接口名称{
    //...
}

4.默认方法

从Java8开始，接口允许定义默认方法。接口当中的默认方法，可以解决接口升级的问题。

public default 返回值类型 方法名称(参数列表){
    //方法体
}

假如我们定义了一个接口 MyInterface

public interface MyInterface{
    //抽象方法
    public abstract void method();//新添加了一个抽象方法

    //添加一默认方法
    public default void methodDefault(){
        system.out.println("这是一个默认方法");
    }
}

创建一个实现类 MyInterfaceDefault

public class MyInterfaceDefault implements MyInterface {
    @Override
    public void method() {
        System.out.println("实现了抽象方法一");
    }

}

此时接口类中没有重写 MyInterface 中的methodDefault()方法，仍可以在Demo中创建对象并使用methodDefault()方法。

public class Demo{
    pubiic static void main(String[] args) {
    //创建实现类对象
    MyInterfaceDefault a = new MyInterfaceDefault();
    a.method(); //调用抽象方法，实际运行的是右侧实现类。

    //调用默认方法，如果实现类当中没有，会向上找接口
    a.methodDefault();
}

此时调用a.methodDefault()会输出默认方法字样

这是一个默认方法

当然我们可以在实现类中重写接口的默认方法

public class MyInterfaceDefault implements MyInterface {
    @Override
    public void method() {
        System.out.println("实现了抽象方法一");
    }

    //重写默认方法
    @Override 
    public void methodDefault() {
        System.out.print1n("实现类覆盖重写了接口的默认方法");
    }
}

此时调用a.methodDefault()会输出以下字样

实现类覆盖重写了接口的默认方法

所以对于接口的默认方法:

1.可以通过接口实现类对象，直接调用。

2.也可以被接口实现类进行覆盖重写。

5.静态方法

从Java 8开始，接口当中允许定义静态方法。(将abstract或者default换成static即可，带上方法体。)

public static返回值类型方法名称(参数列表){
    方法体
}

新建一个 MyInterfaceStatic 接口

public interface MyInterfaceStatic {
    //创建静态方法
    public static void methodStatic(){
        System.out.println("这是接口的静态方法! ");
}

Note:不能通过接口实现类的对象来调用接口当中的静态方法。正确用法:通过接口名称,直接调用其中的静态方法。

所以调用静态方法，无需创建对象！

标准格式:

接口名称.静态方法名(参数);

新建Demo1 进行静态方法调用

public class Demo1 {
    public static void main(String[] args) {
    //直接通过接口名称调用静态方法
    MyInterfaceStatic.methodStatic();
    }
}

6.接口常量定义和使用

接口当中也可以定义”成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看,这其实就是接口的【常量】。

public static final 数据类型 常量名称 = 数据值;

Minecraft 1.12.2模组开发(十四) 建筑生成

在建筑生成一节我们介绍了如何在主世界生成自定义建筑

我们定义了一个 IStructure 的接口，其中使用的就是接口的常量定义

package com.Joy187.newmod.util;

import net.minecraft.util.Mirror;
import net.minecraft.util.Rotation;
import net.minecraft.world.WorldServer;
import net.minecraft.world.gen.structure.template.PlacementSettings;
import net.minecraftforge.fml.common.FMLCommonHandler;

public interface IStructure {
                        //世界服务器
    public static final WorldServer worldServer = FMLCommonHandler.instance().getMinecraftServerInstance().getWorld(0);
                       //方块放置相关设置
    public static final PlacementSettings settings = (new PlacementSettings()).setChunk(null).setIgnoreEntities(false).setIgnoreStructureBlock(false).setMirror(Mirror.NONE).setRotation(Rotation.NONE);
}

之后我们创建了一个 实现类 ModWorldGenStructure ,

package com.Joy187.newmod.world;

import java.util.Random;

import com.Joy187.newmod.util.IStructure;
import com.Joy187.newmod.util.Reference;

import net.minecraft.block.state.IBlockState;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.WorldServer;
import net.minecraft.world.gen.feature.WorldGenerator;
import net.minecraft.world.gen.structure.template.Template;
import net.minecraft.world.gen.structure.template.TemplateManager;

public class ModWorldGenStructure extends WorldGenerator implements IStructure{

    public static String structureName;
    public ModWorldGenStructure(String name) {
        this.structureName = name;
    }

    @Override
    public boolean generate(World worldIn, Random rand, BlockPos position) {
        this.generateStructure(worldIn, position);
        return true;
    }

    public static void generateStructure(World world,BlockPos pos) {
        MinecraftServer mcServer = world.getMinecraftServer();

        //调用中接口的常量
        TemplateManager manager = worldServer.getStructureTemplateManager(); 
        ResourceLocation location = new ResourceLocation(Reference.Mod_ID, structureName);  
        Template template = manager.get(mcServer,location);
        if(template != null) {
            IBlockState state = world.getBlockState(pos);
            world.notifyBlockUpdate(pos, state, state, 3);
            //调用中接口的常量
            template.addBlocksToWorldChunk(world, pos, settings);
        }
    }

}