Java-Grundlagenbeispiele für Schnittstellen und abstrakte Klassen

Nun, Sie müssen es verstehen und selbst eingeben! ! ! Diese Fragen haben mir geholfen, mehr über Schnittstellen und abstrakte Klassen zu erfahren.

1. Entwerfen Sie ein Produktfeld:

Produktname, Gewicht, Preis, Menge des Zubehörs, Zubehörhersteller (eine Reihe, da es mehrere Hersteller geben kann)

Anforderungen : Haben Sie einen Konstruktor

Schreiben Sie die toString-Methode neu

Schreiben Sie die equal-Methode neu, um zwei Elemente zu vergleichen

package TT;

 import java.util.Arrays;

 public class G {
     private int 重量;
     private String 商品名称;
     private int 价格;
     private int 配件数量;
   private String[] 配件制造厂商列表;

    public G(int 重量, String 商品名称, int 价格, int 配件数量, String[] 配件制造厂商列表) {
        super();
        this.重量 = 重量;
        this.商品名称 = 商品名称;
        this.价格 = 价格;
        this.配件数量 = 配件数量;
        this.配件制造厂商列表 = 配件制造厂商列表;
    }

    @Override
    public String toString() {
        return "G [重量=" + 重量 + ", 商品名称=" + 商品名称 + ", 价格=" + 价格 + ", 配件数量="
                + 配件数量 + ", 配件制造厂商列表=" + Arrays.toString(配件制造厂商列表) + "]";
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj instanceof G) {
            G goods = (G) obj;

            if (this.重量 == goods.重量 && this.价格 == goods.价格
                    && this.商品名称.equals(goods.商品名称) && this.配件数量 == goods.配件数量) {
                for (int i = 0; i < this.配件制造厂商列表.length; i++) {
                    if (this.配件制造厂商列表[i] != goods.配件制造厂商列表[i]) {
                        return false;
                    }
                }
                return true;
            } else {
                return false;
            }
        } else {
            return false;
        }
    }
    //将测试类和上面的放一块儿了
    public static void main(String[] args) {

        String[] 厂商列表1 = { "微软", "索尼", "三星" };
        String[] 厂商列表2 = { "微软", "索尼", "三星" };
        G g1 = new G(40, "电脑", 4000, 30, 厂商列表1);
        G g2 = new G(40, "显示器", 4000, 30, 厂商列表2);

        System.out.println(g1);
        System.out.println(g2);

        System.out.println(g1.equals(g2));
    }
}

2. Entwerfen Sie eine abstrakte Klasse und Demonstrieren Sie die Verwendung (Stufe 3)

package TT;

 //抽象类
abstract class 数学老师标准{
abstract void 讲数学();
abstract int add(int a,int b);
}

 //第二级抽象类
abstract class 普通数学老师标准  extends 数学老师标准{
void 讲数学(){
System.out.println("我能讲数学");
}
}

//第三级抽象类
class 真正的数学老师 extends 普通数学老师标准{  //注意这里能不能用abstract修饰，修饰了以后会对上下的影响
//可以重写，也可以不重写
void 讲数学(){
System.out.println("我能讲高数");
}
int add(int a,int b){
return a+b;
}
}
class Test{
    public static void main(String[] args) {
        数学老师标准 t1=new  真正的数学老师();
        int result=t1.add(44, 4444);
        System.out.println("计算结果是:"+result);
        t1.讲数学();
    }
}

3. Entwerfen Sie eine Schnittstelle und entwerfen Sie eine Implementierungsklasse, um diese Schnittstelle zu implementieren

package TT;
interface 银行标准{
    int MONEY=9900000;
    void 取钱();
    void 存钱();
}
class 工商银行 implements 银行标准{
     public void 取钱(){
         System.out.println("钱进银行了");
         }
     @Override//全部方法都拿来
     public void 存钱() {
         System.out.println("钱出去了");
         }
     }
 public class Test {
     public static void main(String[]args){
          银行标准  bank=new 工商银行();
          bank.取钱();
          bank.存钱();
          System.out.println("银行的老底是"+银行标准.MONEY);//此处银行标准用bank会报错,The static field 银行标准.MONEY should be accessed in a static way
     }
 }

5. Entwerfen Sie eine Klasse und implementieren Sie beim Erben der Klasse ihre beiden Schnittstellen (insbesondere die Schnittstellen, die Sie selbst entworfen haben)

package TT;

interface 建筑标准 {
    void kaimen();

    void guanmen();
}

interface 银行标准 {
     int MONEY = 9999;

     void 取钱();

     void 存钱();
 }

 class 工商银行 implements 银行标准,建筑标准 {

     @Override
     public void kaimen() {
         System.out.println("我能开门");

     }

     @Override
     public void guanmen() {
         // TODO Auto-generated method stub
         System.out.println("我能关门");

     }

     @Override
     public void 取钱() {
         // TODO Auto-generated method stub
         System.out.println("我能取钱");
     }

     @Override
     public void 存钱() {
         // TODO Auto-generated method stub
         System.out.println("我能存钱");

     }

 }

 public class Test2 {
     public static void main(String[] args) {
         工商银行 bank = new 工商银行();
         bank.取钱();
         bank.存钱();
         System.out.println("銀行的底是" + 工商银行.MONEY);

         bank.kaimen();
         bank.guanmen();
     }
 }

Das letzte Easter Egg! ! ! !

Da ich diese Beispiele während des Trainings unter dasselbe TT-Paket gestellt habe, gibt es insgesamt 5 Dateien. Schließlich begannen die letzten drei Beispiele oben, Fehler zu melden (z. B. Fehler: Der Typbankstandard ist bereits definiert).

Ahhhhhh, eine halbe Stunde lang debuggen und es immer noch nicht richtig hinbekommen. Später beruhigte ich mich und dachte: Da Eclipse auffordert, dass XXX definiert wurde, bedeutet das, dass Dateien mit demselben Klassennamen nicht wiederholt definiert werden können, solange sie sich im selben Paket befinden, egal wie viele Klassen Sie erstellen? Dann fing ich an, zwei zu löschen, und tatsächlich war es erfolgreich. Wenn Sie sorgfältig darüber nachdenken, ist diese Exklusivität eine Überprüfung und kann auch viele Ressourcen sparen, da auf öffentliche Klassen im selben Paket zugegriffen werden kann.

Das obige ist der detaillierte Inhalt vonJava-Grundlagenbeispiele für Schnittstellen und abstrakte Klassen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!