Fatal编程技术网
  • java/
  • Java 正确使用抽象方法

Java 正确使用抽象方法

java arrays list methods

Java 正确使用抽象方法,java,arrays,list,methods,abstract,Java,Arrays,List,Methods,Abstract,我很难掌握抽象方法的概念以及如何正确使用它们 基本上，我被指示编写一个带有抽象超类“Alien”和两个子类“Martian and Saturner”的代码，在这些类中存在invaine（）方法，该方法应接受外星人攻击的行星名称作为参数，并且不返回值 import java.util.Arrays; import java.util.List; import java.util.ArrayList; abstract class Alien { private String planet; p

我很难掌握抽象方法的概念以及如何正确使用它们

基本上，我被指示编写一个带有抽象超类“Alien”和两个子类“Martian and Saturner”的代码，在这些类中存在invaine（）方法，该方法应接受外星人攻击的行星名称作为参数，并且不返回值

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

abstract class Alien
{
private String planet;
private String age;
private String name;
private String skinColor;
private String alienPower;

public Alien(String planet, String age, String name, String skinColor, String alienPower)
{
    this.planet=planet;
    this.age=age;
    this.name=name;
    this.skinColor=skinColor;
    this.alienPower=alienPower;
}

public abstract void invade(String planetName); 
public String toString()
{
    return name + " is from " + planet + ", is " + age + " years old, "  + " has " + skinColor + " skin, and has the ability " + alienPower ;
}   
}

class Martian extends Alien {
public Martian(String p, String a, String n, String s, String ap) {
    super(p,a,n,s,ap);
}

@Override
public void invade(String strategy, String planetName) {
    System.out.println("I am a Martian " + strategy + planetName);
}

}


class Saturner extends Alien {
public Saturner(String p, String a, String n, String s, String ap) {
    super(p,a,n,s,ap);
}

public void invade(String strategy, String planetName) {
    System.out.println("I am a Saturner " + strategy + planetName);
}
}

public class TestAlien {
public static void main(String[]args) {
    ArrayList<Alien> alienList = new ArrayList<>();
    List<String> planets = Arrays.asList(new String[] {"Earth", "June", "Mercury", "Venus", "Neptune"});
    List<String> methods = Arrays.asList(new String[] {"shooting missiles at", "polluting the water systems of", "burning", "flooding"});

    alienList.add(new Martian("Mars", "148", "Zornok", "red", "Read minds"));
    alienList.add(new Saturner("Saturn", "89", "Hookman", "pitch black ", "Go invisible"));
    alienList.add(new Martian("Mars", "18", "Guthrax", "gray", "Teleport"));
    alienList.add(new Saturner("Saturn", "300", "Lamron", "blue", "Fly\n"));
    int i = 0;

    for (Alien al : alienList) {
        System.out.println("Alien race: " + al.getClass().getName() + " || description = " + al.toString());
        al.invade(methods.get(i) al.invade(planets.get(i));
        i++;
    }

导入java.util.array；
导入java.util.List；
导入java.util.ArrayList；
抽象类外星生物
{
私人弦行星；
私弦时代；
私有字符串名称；
私人串肤色；
私权；
公共外星人（字符串行星、字符串年龄、字符串名称、字符串肤色、字符串alienPower）
{
这个行星=行星；
这个。年龄=年龄；
this.name=name；
这个.skinColor=skinColor；
这个.alienPower=alienPower；
}
公共抽象无效入侵（字符串planetName）；
公共字符串toString（）
{
返回名称+”来自“+星球+”，是“+年龄+”岁，“+”有“+皮肤颜色+”皮肤，并有能力“+alienPower”；
}   
}
火星人级外星人{
公共火星人（p、a、n、s、ap）{
超级（p，a，n，s，ap）；
}
@凌驾
公共无效入侵（字符串策略、字符串planetName）{
System.out.println（“我是火星人”+战略+飞机名）；
}
}
类土星扩展外星人{
公共土星器（字符串p、字符串a、字符串n、字符串s、字符串ap）{
超级（p，a，n，s，ap）；
}
公共无效入侵（字符串策略、字符串planetName）{
System.out.println（“我是土星人”+策略+行星名）；
}
}
公共类遗嘱留置权{
公共静态void main（字符串[]args）{
ArrayList alienList=新的ArrayList（）；
列出行星=数组.asList（新字符串[]{“地球”、“六月”、“水星”、“金星”、“海王星”}）；
列表方法=Arrays.asList（新字符串[]{“向……发射导弹”、“污染……的水系”、“燃烧”、“泛滥”}）；
添加（新火星人（“火星”、“148”、“佐尔诺克”、“红色”、“读心术”）；
添加（新土星（“土星”、“89”、“钩人”、“漆黑”、“隐形”）；
添加（新火星人（“火星”、“18”、“古特拉克斯”、“灰色”、“传送”））；
添加（新土星（“土星”，“300”，“拉姆龙”，“蓝色”，“飞行”））；
int i=0；
对于（外星人al:alienList）{
System.out.println（“外星人种族：+al.getClass（）.getName（）+”|| description=“+al.toString（））；
入侵（方法获取（i）入侵（行星获取（i））；
i++；
}
如果您的invaine（）方法应该接受一个行星，那么第一步实际上是实现一个行星类型（读：class），然后为每个物种实现invaine方法，如下所示：

@Override
void invade(Planet target) {
    //attack planet
}

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

abstract class Alien {
    private String p;
    private String a;
    private String n;
    private String s;
    private String ap;

    public Alien(String p, String a, String n, String s, String ap) {
        this.p = p;
        this.a = a;
        this.n = n;
        this.s = s;
        this.ap = ap;
    }

    public abstract void invade(String planetName); 
}

class Martian extends Alien {
    public Martian(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    @Override
    public void invade(String planetName) {
        System.out.println("I am a Martian invading " + planetName);
    }

}


class Saturner extends Alien {
    public Saturner(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    public void invade(String planetName) {
        System.out.println("I am a Saturner invading " + planetName);
    }
}

public class TestAlien {
    public static void main(String[]args) {
        ArrayList<Alien> alienList = new ArrayList<>();
        List<String> planets = Arrays.asList(new String[] {"Earth", "June", "Mercury", "Venus", "Neptune"});

        alienList.add(new Martian("Mars", "148", "Zornok", "red", "Read minds"));
        alienList.add(new Saturner("Saturn", "89", "Hookman", "pitch black ", "Go invisible"));
        alienList.add(new Martian("Mars", "18", "Guthrax", "gray", "Teleport"));
        alienList.add(new Saturner("Saturn", "300", "Lamron", "blue", "Fly\n"));
        int i = 0;

        for (Alien al : alienList) {
            System.out.println("Alien race: " + al.getClass().getName() + " || description = " + al.toString());
            al.invade(planets.get(i));
            i++;
        }
    }
}
要攻击不同的行星，您需要一个可用行星的列表，迭代外星人，从行星列表中随机选择一个行星（查看java.util.random），并对每个外星人调用invaive方法：

Random rng = new Random();
for (Alien alien : aliens) {
    int roll = rng.nextInt(aliens.size());
    Planet target = planets.get(roll);
    alien.invade(target);
}
如果您的invaine（）方法应该接受一个行星，那么第一步实际上是实现一个行星类型（读：class），然后为每个物种实现invaine方法，如下所示：

@Override
void invade(Planet target) {
    //attack planet
}

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

abstract class Alien {
    private String p;
    private String a;
    private String n;
    private String s;
    private String ap;

    public Alien(String p, String a, String n, String s, String ap) {
        this.p = p;
        this.a = a;
        this.n = n;
        this.s = s;
        this.ap = ap;
    }

    public abstract void invade(String planetName); 
}

class Martian extends Alien {
    public Martian(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    @Override
    public void invade(String planetName) {
        System.out.println("I am a Martian invading " + planetName);
    }

}


class Saturner extends Alien {
    public Saturner(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    public void invade(String planetName) {
        System.out.println("I am a Saturner invading " + planetName);
    }
}

public class TestAlien {
    public static void main(String[]args) {
        ArrayList<Alien> alienList = new ArrayList<>();
        List<String> planets = Arrays.asList(new String[] {"Earth", "June", "Mercury", "Venus", "Neptune"});

        alienList.add(new Martian("Mars", "148", "Zornok", "red", "Read minds"));
        alienList.add(new Saturner("Saturn", "89", "Hookman", "pitch black ", "Go invisible"));
        alienList.add(new Martian("Mars", "18", "Guthrax", "gray", "Teleport"));
        alienList.add(new Saturner("Saturn", "300", "Lamron", "blue", "Fly\n"));
        int i = 0;

        for (Alien al : alienList) {
            System.out.println("Alien race: " + al.getClass().getName() + " || description = " + al.toString());
            al.invade(planets.get(i));
            i++;
        }
    }
}
要攻击不同的行星，您需要一个可用行星的列表，迭代外星人，从行星列表中随机选择一个行星（查看java.util.random），并对每个外星人调用invaive方法：

Random rng = new Random();
for (Alien alien : aliens) {
    int roll = rng.nextInt(aliens.size());
    Planet target = planets.get(roll);
    alien.invade(target);
}
我想你正在寻找这样的东西：

@Override
void invade(Planet target) {
    //attack planet
}

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

abstract class Alien {
    private String p;
    private String a;
    private String n;
    private String s;
    private String ap;

    public Alien(String p, String a, String n, String s, String ap) {
        this.p = p;
        this.a = a;
        this.n = n;
        this.s = s;
        this.ap = ap;
    }

    public abstract void invade(String planetName); 
}

class Martian extends Alien {
    public Martian(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    @Override
    public void invade(String planetName) {
        System.out.println("I am a Martian invading " + planetName);
    }

}


class Saturner extends Alien {
    public Saturner(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    public void invade(String planetName) {
        System.out.println("I am a Saturner invading " + planetName);
    }
}

public class TestAlien {
    public static void main(String[]args) {
        ArrayList<Alien> alienList = new ArrayList<>();
        List<String> planets = Arrays.asList(new String[] {"Earth", "June", "Mercury", "Venus", "Neptune"});

        alienList.add(new Martian("Mars", "148", "Zornok", "red", "Read minds"));
        alienList.add(new Saturner("Saturn", "89", "Hookman", "pitch black ", "Go invisible"));
        alienList.add(new Martian("Mars", "18", "Guthrax", "gray", "Teleport"));
        alienList.add(new Saturner("Saturn", "300", "Lamron", "blue", "Fly\n"));
        int i = 0;

        for (Alien al : alienList) {
            System.out.println("Alien race: " + al.getClass().getName() + " || description = " + al.toString());
            al.invade(planets.get(i));
            i++;
        }
    }
}

导入java.util.array；
导入java.util.List；
导入java.util.ArrayList；
抽象类外星生物{
私有字符串p；
私人字符串a；
私有字符串n；
私有字符串；
私有字符串ap；
公共外星人（字符串p、字符串a、字符串n、字符串s、字符串ap）{
这个，p=p；
这个a=a；
这个，n=n；
这个.s=s；
this.ap=ap；
}
公共抽象无效入侵（字符串planetName）；
}
火星人级外星人{
公共火星人（p、a、n、s、ap）{
超级（p，a，n，s，ap）；
}
@凌驾
公共无效入侵（字符串planetName）{
System.out.println（“我是火星人入侵”+行星名称）；
}
}
类土星扩展外星人{
公共土星器（字符串p、字符串a、字符串n、字符串s、字符串ap）{
超级（p，a，n，s，ap）；
}
公共无效入侵（字符串planetName）{
System.out.println（“我是一个正在入侵的土星人”+行星名）；
}
}
公共类遗嘱留置权{
公共静态void main（字符串[]args）{
ArrayList alienList=新的ArrayList（）；
列出行星=数组.asList（新字符串[]{“地球”、“六月”、“水星”、“金星”、“海王星”}）；
添加（新火星人（“火星”、“148”、“佐尔诺克”、“红色”、“读心术”）；
添加（新土星（“土星”、“89”、“钩人”、“漆黑”、“隐形”）；
添加（新火星人（“火星”、“18”、“古特拉克斯”、“灰色”、“传送”））；
添加（新土星（“土星”，“300”，“拉姆龙”，“蓝色”，“飞行”））；
int i=0；
对于（外星人al:alienList）{
System.out.println（“外星人种族：+al.getClass（）.getName（）+”|| description=“+al.toString（））；
入侵（行星获取（i））；
i++；
}
}
}
我想您正在寻找这样的产品：

@Override
void invade(Planet target) {
    //attack planet
}

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

abstract class Alien {
    private String p;
    private String a;
    private String n;
    private String s;
    private String ap;

    public Alien(String p, String a, String n, String s, String ap) {
        this.p = p;
        this.a = a;
        this.n = n;
        this.s = s;
        this.ap = ap;
    }

    public abstract void invade(String planetName); 
}

class Martian extends Alien {
    public Martian(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    @Override
    public void invade(String planetName) {
        System.out.println("I am a Martian invading " + planetName);
    }

}


class Saturner extends Alien {
    public Saturner(String p, String a, String n, String s, String ap) {
        super(p,a,n,s,ap);
    }

    public void invade(String planetName) {
        System.out.println("I am a Saturner invading " + planetName);
    }
}

public class TestAlien {
    public static void main(String[]args) {
        ArrayList<Alien> alienList = new ArrayList<>();
        List<String> planets = Arrays.asList(new String[] {"Earth", "June", "Mercury", "Venus", "Neptune"});

        alienList.add(new Martian("Mars", "148", "Zornok", "red", "Read minds"));
        alienList.add(new Saturner("Saturn", "89", "Hookman", "pitch black ", "Go invisible"));
        alienList.add(new Martian("Mars", "18", "Guthrax", "gray", "Teleport"));
        alienList.add(new Saturner("Saturn", "300", "Lamron", "blue", "Fly\n"));
        int i = 0;

        for (Alien al : alienList) {
            System.out.println("Alien race: " + al.getClass().getName() + " || description = " + al.toString());
            al.invade(planets.get(i));
            i++;
        }
    }
}

导入java.util.array；
导入java.util.List；
导入java.util.ArrayList；
抽象类外星生物{
私有字符串p；
私人字符串a；
私有字符串n；
私有字符串；
私有字符串ap；
公共外星人（字符串p、字符串a、字符串n、字符串s、字符串ap）{
这个，p=p；
这个a=a；
这个，n=n；
这个.s=s；
this.ap=ap；
}
公共抽象无效入侵（字符串planetName）；
}
火星人级外星人{
公共火星人（p、a、n、s、ap）{
超级（p，a，n，s，ap）；
}
@凌驾
公共无效入侵（字符串planetName）{
System.out.println（“我是火星人入侵”+行星名称）；
}
}
类土星扩展外星人{
公共土星器（字符串p，

public class WaterSystemDestructionStrategy implements InvadingStrategy {

    @Override
    public String getStrategyDescription() {
        return "polluting the water systems of";
    }

}



public class Driver {
    public static void main(String[] args) {
        ArrayList<Alien> alienList = new ArrayList<>();
        alienList.add(new Martian("Mars", "148", "Zornok", "red", "Read minds"));
        alienList.add(new Saturner("Saturn", "89", "Hookman", "pitch black ", "Go invisible"));
        alienList.add(new Martian("Mars", "18", "Guthrax", "gray", "Teleport"));
        alienList.add(new Saturner("Saturn", "300", "Lamron", "blue", "Fly\n"));

        List<String> planets = Arrays.asList(new String[] {"Earth", "June", "Mercury", "Venus", "Neptune"});
        List<InvadingStrategy> methods = Arrays.asList(new InvadingStrategy[]{new MissileStrategy(),new WaterSystemDestructionStrategy(),new BurningStrategy(),new FloodingStrategy()});

        int i = 0;
        for(Alien alien : alienList){
            alien.invade(planets.get(i) , methods.get(i));
            i++;
        }
    }
}