编译器给我一条错误消息，说它无法找到电影[x] .getTitle（）和电影[x] .getYear。我一直想知道通过界面进入类
是否有问题这是错误：
MathewBorumP5.java:68: error: cannot find symbol
System.out.printf("%-26s%-6s%-10s%-9s%-11s\n", movies[x]
.getTitle(),
^
symbol: method getTitle()
location: interface Profitable
MathewBorumP5.java:69: error: cannot find symbol
movies[x].getYear(), movies[x].calcRevenue(),
^
symbol: method getYear()
location: interface Profitable
2 errors
这是我的客户端类：
import java.util.Scanner;
public class MathewBorumP5 {
public static void main(String[] args) {
int choice;
boolean restart = true;
Scanner input = new Scanner(System.in);
Profitable[] movies = new Profitable[6];
movies[0] = new Animated("Beauty and the Beast", "Gary Trousdale", 1991,
10.0, 5.0, 2.0);
movies[1] = new Animated("Peter Pan", "Clyde Geronimi", 1953, 2.0, 1.2,
.5);
movies[2] = new Documentary("Planet Earth", "Alastair Fothergill", 2006,
10, 20, 5);
movies[3] = new Documentary("Drain the Ocean", "Steve Nichols", 2009, 9,
2,3);
movies[4] = new Drama("The Shawshank Redemption", "Frank Darabont",
1994, 89, 7, 2);
movies[5] = new Drama("The Godfather", "Francis Coppola", 1972, 10, 3,
5);
do {
menu();
System.out.print("Enter a number from 1 - 5: ");
choice = input.nextInt();
System.out.print("\n");
switch(choice) {
case 1:
item1(movies);
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
restart = false;
break;
default:
System.out.print("You didn't enter a number between 1"
+ " and 5.\n");
break;
}
} while(restart == true);
}
public static void menu() {
System.out.print("Warren Moore Movie Menu\n");
System.out.print("1. Show the list of movies in the array\n");
System.out.print("2. Display the total number of movies and the total" +
" revenues\n");
System.out.print("3. Search movie by title\n");
System.out.print("4. Display movies sorted by profit in decreasing" +
" order\n");
System.out.print("5. Exit\n");
}
public static void item1(Profitable[] movies) {
double revenue;
System.out.printf("%-26s%-6s%-10s%-9s%-11s\n", "Title", "Year",
"Revenue", "Profit", "Category");
for(int x = 0; x <= 6; x++) {
revenue = movies[x].calcRevenue();
System.out.printf("%-26s%-6s%-10s%-9s%-11s\n", movies[x].getTitle(),
movies[x].getYear(), movies[x].calcRevenue(),
movies[x].calcProfit(revenue), movies[x].category());
}
}
}
这是我的超类：
public class Movie implements Profitable {
protected String title;
protected String director;
protected int year;
protected double productionCost;
private int totalMovies = 0;
public Movie() {
totalMovies++;
}
public Movie(String newTitle, String newDirector, int newYear,
double newCost) {
totalMovies++;
title = newTitle;
director = newDirector;
year = newYear;
productionCost = newCost;
}
public int getTotalMovies() {
return totalMovies;
}
public String getTitle() {
return title;
}
public void setTitle(String newTitle) {
this.title = title;
}
public String getDirector() {
return director;
}
public void setDirector(String director) {
this.director = director;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public double getProductionCost() {
return productionCost;
}
public void setProductionCost(double productionCost) {
this.productionCost = productionCost;
}
public String toString() {
return "";
}
}
这是我的单独课程。 public class Animated extends Movie实现Profitable { 私人双倍率; 私人双重收入;
public Animated() {
super();
}
public Animated(String title, String director, int year, double cost,
double rate, double income) {
super(title, director, year, cost);
this.rate = rate;
this.income = income;
}
public double getRate() {
return rate;
}
public void setRate(double rate) {
this.rate = rate;
}
public double getIncome() {
return income;
}
public void setIncome(double income) {
this.income = income;
}
public String category() {
return "Animated";
}
public double calcRevenue() {
return (income * rate);
}
public double calcProfit(double revenue) {
return (revenue - super.productionCost);
}
public String toString() {
return (super.toString() + "");
}
}
2号
public class Documentary extends Movie implements Profitable {
private int distributors;
private double premium;
public Documentary() {
super();
}
public Documentary(String title, String director, int year, double cost,
int distributors, double premium) {
super(title, director, year, cost);
this.distributors = distributors;
this.premium = premium;
}
public int getDistributors() {
return distributors;
}
public void setDistributors(int distributors) {
this.distributors = distributors;
}
public double getPremium() {
return premium;
}
public void setPremium(double premium) {
this.premium = premium;
}
public String category() {
return "Documentary";
}
public double calcRevenue() {
return (distributors * premium);
}
public double calcProfit(double revenue) {
return (revenue - super.productionCost);
}
public String toString() {
return (super.toString() + "");
}
}
3号
public class Drama extends Movie implements Profitable {
private int tickets;
private double avgPrice;
public Drama() {
super();
}
public Drama(String title, String director, int year, double cost,
int tickets, double avgPrice) {
super(title, director, year, cost);
this.tickets = tickets;
this.avgPrice = avgPrice;
}
public int getTickets() {
return tickets;
}
public void setTickets(int tickets) {
this.tickets = tickets;
}
public String category() {
return "Drama";
}
public double calcRevenue() {
return (tickets * avgPrice);
}
public double calcProfit(double revenue) {
return (revenue - super.productionCost);
}
public String toString() {
return (super.toString() + "");
}
}
最后我的界面。
public interface Profitable {
public abstract String category();
public abstract double calcRevenue();
public abstract double calcProfit(double revenue);
}
答案 0 :(得分：1)
Profitable接口没有您尝试调用的方法，因此编译器向您投诉是正确的。数组变量不知道每个数组项可能包含哪种类型的对象，实际上只有一种类型的项只能在以后更改它，因此编译器以这种方式运行是有意义的。一个kludge将测试数组持有的每个项目，看看它实际是什么类型，比如使用instanceof，但这是一个非常脆弱的解决方案，不建议使用。最安全的是只在Profitable数组项上调用Profitable方法，并尝试使用多态的魔力来允许每个对象为同一个方法调用执行不同的行为。
请注意，如果数组持有的所有项目始终是Movie或Movie子项目，那么请务必使用Movie数组而不是Profitable数组。
答案 1 :(得分：0)
你是对的，问题在于你的盈利界面。 当您创建数组项（Profitable [] movies）时，这意味着只有您可以使用此界面中定义的方法。
Movie对象的数组可能就是你在这里的样子。所有这些对象都显示为扩展电影并实现盈利，因此您可以通过这种方式访问所有内容。