java - 在java中使用 'this'关键字和扩展类

Question

我有一个名为“Items”的类，“Equips”从该类扩展，“Helmet”从“Equips”扩展。我有一个名为“getStats”的方法，它从 .txt 文件加载项目的统计信息。如果我将“getStats”方法放在“Items”类中，则我尝试使用“this”访问“Helmet”对象中的任何字段。显示为空。在加载文本文件之前创建 Helm 时，我尝试在“ Helm ”中访问的字段会被初始化。我可以很容易地将“getStats”方法放入“Equips”类中，并在“Items”类中放入一个空白的“getStats”方法，但我想知道是否有一种方法可以让它按原样工作。提前致谢!

Items.java:

package com.projects.aoa;

import static com.projects.aoa.Print.*;

import java.util.*;
import java.io.*;

class Items {

String name, type;
int id;
int hp, mp, str, def;
boolean vacent;

static void getAllStats(Items[] e){
    for(Items i : e){
        getItemStats(i);
    }
}

static void getItemStats(Items i){
    i.getStats();
}

void getStats(){
    try {
        //System.out.println(System.getProperty("user.dir"));

        print(this.name); //THIS shows up as null as well as those \/below\/
        FileInputStream fstream = new FileInputStream(System.getProperty("user.dir") 
                + "/src/com/projects/aoa/" + this.type + this.name + ".txt");

        DataInputStream in = new DataInputStream(fstream);

        BufferedReader br = new BufferedReader(new InputStreamReader(in));

        String line;
        int counter = 0;

        while ((line = br.readLine()) != null) {
            if (line.length() == 0){
                break;
            }

            switch (counter) {
            case 0:
                this.hp = Integer.parseInt(line);
                counter++;
                break;
            case 1:
                this.mp = Integer.parseInt(line);
                counter++;
                break;
            case 2:
                this.def = Integer.parseInt(line);
                counter++;
                break;
            case 3:
                this.str = Integer.parseInt(line);
                counter++;
                break;
            }   
        }


        in.close();
    } catch (Exception e) {
        e.printStackTrace();
    } 
}

Game.java:

Helmet headBand = new Helmet("HeadBand");
Helmet bronzeHelmet = new Helmet("BronzeHelmet");


    Items[] equips = {
            headBand, bronzeHelmet
    };



    getAllStats(equips);

Equips.java:

  package com.projects.aoa;

import static com.projects.aoa.Print.print;
import static com.projects.aoa.Print.println;

import java.io.*;



class Equips extends Items{
    String name, type;
    int hp, mp, str, def;




    void printStats(){
        println("[" + name + "]");
        println("Type: " + type);
        println("HP:  " + hp);
        println("MP:  " + mp);
        println("Def: " + def);
        println("Str: " + str);
    }
}

class Helmet extends Equips {
    Helmet(String name){
        this.name = name;
        this.type = "h_";
    }
}

Answer 1

您还没有向我们展示您的 Helmet 类，因此很难说发生了什么 - 但我猜测是您正在重新声明具有相同名称的字段在 Helm 中。这些将隐藏 Items 中的字段，而您实际上只想使用 Items 中的字段。

这是一个简短但完整的示例，它演示了我认为正在发生的事情:

class SuperClass {
    String name;

    public void setName(String newName) {
        // This writes to the field in SuperClass
        name = newName;
    }
}

class SubClass extends SuperClass {
    // This *hides* the field in SuperClass
    String name;

    public void showName() {
        // This reads the field from SubClass, which
        // nothing writes to...
        System.out.println("My name is " + name);
    }
}

public class Test {
    public static void main(String[] args) {
        SubClass x = new SubClass();
        x.setName("Test");
        x.showName();
    }
}

我建议:

• 您将所有字段设为私有(private)，编写属性以根据需要授予对其他类的访问权限
• 您删除了 Helmet 中隐藏 Items 中字段的字段
• 您更改类名称以避免复数 - Item 和 Equipment 而不是 Items

这是上述代码的修复版本:

class SuperClass {
    private String name;

    public void setName(String newName) {
        name = newName;
    }

    public String getName() {
        return name;
    }
}

class SubClass extends SuperClass {
    public void showName() {
        System.out.println("My name is " + getName());
    }
}

public class Test {
    public static void main(String[] args) {
        SubClass x = new SubClass();
        x.setName("Test");
        x.showName();
    }
}

(显然，您还需要考虑对属性等设置哪些访问权限，但这是一个单独的问题。)