I could assign objects (ingredients) to an array in the main class, like this:
Ingredient[] ingredient = new Ingredient[5];
Ingredient potato = new Ingredient("Potatoes");
ingredient[0] = potato;
but what I really want to do is put the array inside another object (food), so I can access it like this:
fries.ingredient[0] = potato;
so that each food has its own collection of ingredients. However, everything I've tried leads to 'NullPointerException' or 'cannot find symbol'. How do I resolve this?
Edit:
Sorry for taking a while. I don't know how to indent inside blockquotes, but here goes. This was my (failed) attempt that causes NullPointerException.
Main.java:
public class Main {
public static void main (String[] args) {
Ingredient potato = new Ingredient("Potatoes");
Food fries = new Food("Fries");
fries.ingredient[0] = potato;
} }
Food.java:
public class Food {
Ingredient[] ingredient;
String name;
public Food(String name) {
this.name = name;
Ingredient[] ingredient = new Ingredient[5];
} }
Ingredient.java
public class Ingredient {
String name;
public Ingredient(String name) {
this.name = name;
} }
In your constructor, you have this:
Ingredient[] ingredient = new Ingredient[5];
You have declared a local variable named ingredient which shadows your instance variable of the same name. Change that line to
this.ingredient = new Ingredient[5];
As a next step in your learning, consider using a List<Ingredient> instead of the array. Arrays are non-resizable, among other inconveniences. Basically, their primary use is in the internals of an implementation, not in client code.
create a class:
public class Food{
public Object[] ingredient;
public food(int numOfIng){
this.ingredients=new Object[numOfIng]
}
}
now just do:
Food fries=new Food(5);
Ingredient potato = new Ingredient("Potatoes");
fries.ingredient[0] = potato;
You can try to do though interface, so as I think something like:
interface Food {
void takeInfo();
}
public class FoodSelection{
private List<Food> listOfFood = new ArrayList<>();
public void selectFries(){
initFood(new Fries());
}
// other food...
public void initFood(Food food){
food.takeInfo();
listOfFood.add(food);
}
}
Now it's time to create fries class..
class Fries implements Food{
private String[] ingredients;
public void takeInfo(){
// declare Fries ingredients.
}
}
So, to call it do something like this:
FoodSelection takeFood = new FoodSelection();
takeFood.selectFries();
you should do that as the following code:
Ingredient potato = new Ingredient("Potatoes");
fries = new ClassName(); //Replace with your class Constructor method
fries.ingredient = new Ingredient[5];
fries.ingredient[0] = potato;
Edit:
Your Food class must be like this:
public class Food {
Ingredient[] ingredient;
String name;
public Food(String name) {
this.name = name;
this.ingredient = new Ingredient[5];
}
}
and Main class:
public class Main {
public static void main(String[] args) {
Ingredient potato = new Ingredient("Potatoes");
Food fries = new Food("Fries");
fries.ingredient[0] = potato;
}
}
and Ingredient class
public class Ingredient {
String name;
public Ingredient(String name) {
this.name = name;
}
}
Related
I am following the example from:
https://www.baeldung.com/java-composite-pattern
public class FinancialDepartment implements Department {
private Integer id;
private String name;
public void printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
// standard constructor, getters, setters
}
public class SalesDepartment implements Department {
private Integer id;
private String name;
public void printDepartmentName() {
System.out.println(getClass().getSimpleName());
}
// standard constructor, getters, setters
}
public class HeadDepartment implements Department {
private Integer id;
private String name;
private List<Department> childDepartments;
public HeadDepartment(Integer id, String name) {
this.id = id;
this.name = name;
this.childDepartments = new ArrayList<>();
}
public void printDepartmentName() {
childDepartments.forEach(Department::printDepartmentName);
}
public void addDepartment(Department department) {
childDepartments.add(department);
}
public void removeDepartment(Department department) {
childDepartments.remove(department);
}
}
I want to prevent my self from able to add two of the same types to HeadDepartment
for example if it call add addDepartment twice for the same type, there should be only one
public class CompositeDemo {
public static void main(String args[]) {
Department salesDepartment = new SalesDepartment(
1, "Sales department");
Department salesDepartment2 = new SalesDepartment(
1, "Sales department");
Department salesDepartment3 = new SalesDepartment(
3, "Sales department");
Department financialDepartment = new FinancialDepartment(
2, "Financial department");
HeadDepartment headDepartment = new HeadDepartment(
3, "Head department");
headDepartment.addDepartment(salesDepartment);
headDepartment.addDepartment(financialDepartment);
// only keep the latest of same instanceof ie replace
headDepartment.addDepartment(salesDepartment2);
headDepartment.addDepartment(salesDepartment3);
// this should only print twice one for salesDepartment3 and financialDepartment
headDepartment.printDepartmentName();
}
}
i suppose do i just iterate the list and if instanceof, replace and put?
public void addDepartment(Department department) {
childDepartments.add(department);
}
i would like to keep the order as well if the instnaceof Department was the first, i would like it to keep it as 1st, meaning it should print salesDepartment3 before financialDepartment
Your addDepartment() needs to iterate over the list of children and compare each one's class to the class of the object you are adding.
Pseudo code:
Class addClass = itemToAdd.getClass();
for each child
{
if (child.getClass() == addClass)
{
//class is already in the list so replace it.
}
friends and colleagues. I have following class:
public class Department {
private String departmentName;
private int moneyForDepartment;
public Department(String departmentName, int moneyForDepartment){
if (moneyForDepartment < 0){
throw new IllegalArgumentException("invalid value");
}
this.departmentName = departmentName;
this.moneyForDepartment = moneyForDepartment;
}
public Department(){
}
public String getDepartmentName() {
return departmentName;
}
public void setDepartmentName(String departmentName) {
this.departmentName = departmentName;
}
public int getMoneyForDepartment() {
return moneyForDepartment;
}
public void setMoneyForDepartment(int moneyForDepartment) {
this.moneyForDepartment = moneyForDepartment;
}
}
and for example i will create two objects of this class:
Department dep1 = new Department("Storage", 100000);
Department dep2 = new Department("Storage", 200000);
Please tell me how can i forbid to create class object in case when object of this class with the same first parameter is already exists ?
It's probably not a good idea to do that globally across your entire application (in static state), because then testing becomes difficult. Instead, create a factory for your Department class, maybe looking something like this:
public class Department {
private Department(String departmentName, int moneyForDepartment) { ... }
...
public static class Factory {
private Set<String> seenDepartmentNames = new HashSet<>();
public Department create(String departmentName, int moneyForDepartment) {
if (!seenDepartmentNames.add(departmentName)) {
throw new IllegalArgumentException("Department already created");
}
return new Department(departmentName, moneyForDepartment);
}
}
}
This forces all construction to go through the Factory, since the Department constructor is private. Just use one Factory across your application, and you can still create new ones for testing without running into problems.
You could create a static field in the Department class and keep a Set with the department names already used:
public class Department {
private static final Set<String> usedDepartmentNames = new HashSet<>();
...
}
Then, in the constructor, do:
public Department(String departmentName, int moneyForDepartment) {
if (usedDepartmentNames.contains(departmentName)) {
throw new IllegalArgumentException("Department already exists");
}
if (moneyForDepartment < 0){
throw new IllegalArgumentException("invalid value");
}
this.departmentName = departmentName;
this.moneyForDepartment = moneyForDepartment;
usedDepartmentNames.add(departmentName);
}
I am a newbie in Java programming and was just wondering if you can do this:
I have a object class Person:
public class Person {
public String name;
public String[] friends;
}
If yes how to initialse it, i.e.
newPerson.name = "Max";
newPerson.friends = {"Tom", "Mike"};
I tried to do it like that, but it does not work.
try this
new Person("Max", new String[]{"Tom", "Mike"});
You would also need a constructor to initialize the variables.
public Person(String name, String[] friends){
this.name = name;
this.friends = friends;
}
As a good practice, you should also limit the access level of variables in your class to be private. (unless there is a very good reason to make them public.)
try
newPerson.friends = new String[]{"Tom", "Mike"}
You can do it like this
public static class Person {
public String name;
public String[] friends;
}
public static void main(String[] args) {
Person newPerson = new Person();
newPerson.name = "Max";
newPerson.friends = new String[] {"Tom", "Mike"};
}
Thats actually pretty simple
U can initialize in creation (thats the easiest method):
public class Person {
public String name = "Max";
public String[] friends = {"Adam","Eve"};
}
U could initialize variables in your constructor
public class Person {
public String name;
public String[] friends;
public Person(){
name = "Max";
friends = new String[] {"Adam", "Eve"};
}
}
I am trying to print the first element on the two arrays in my Athlete class, country and name. I also need to create a object that simulates three dive attemps an athlete had (that is initially set to zero). I am new to OOP and I dont know how to go abouts doing this in my main... as far as constructors go. This is what i have done so far...
this is the main:
import java.util.Random;
import java.util.List;
public class Assignment1 {
public static void main(String[] args) {
Athlete art = new Athlete(name[0], country[0], performance[0]);
}
}
I just really am not sure what to do...
And this is the class with the arrays.
import java.util.Random;
import java.util.List;
public class Athlete {
public String[] name = {"Art", "Dan", "Jen"};
public String[] country = {"Canada", "Germant", "USA"};
//Here i would like to create something that would be representing 3 dive attemps (that relate to dive and score. eventually.)
Athlete(String[] name, String[] country, Performance[] performance) {
this.name = name;
this.country=country;
this.performance=performance;
}
public Performance Perform(Dive dive){
dive.getDiveName();
return null;
}
public String[] getName() {
return name;
}
public void setName(String[] name) {
this.name = name;
}
public String[] getCountry() {
return country;
}
public void setCountry(String[] country) {
this.country = country;
}
}
thanks in advance for any help and input!
btw there is other classes too, just not relevant atm..
First, as for your Athlete class, you can remove your Getter and Setter methods since you have declared your instance variables with an access modifier of public. You can access the variables via <ClassName>.<variableName>.
However, if you really want to use that Getter and Setter, change the public modifier to private instead.
Second, for the constructor, you're trying to do a simple technique called shadowing. Shadowing is when you have a method having a parameter with the same name as the declared variable. This is an example of shadowing:
----------Shadowing sample----------
You have the following class:
public String name;
public Person(String name){
this.name = name; // This is Shadowing
}
In your main method for example, you instantiate the Person class as follow:
Person person = new Person("theolc");
Variable name will be equal to "theolc".
----------End of shadowing----------
Let's go back to your question, if you just want to print the first element with your current code, you may remove the Getter and Setter. Remove your parameters on your constructor.
public class Athlete {
public String[] name = {"Art", "Dan", "Jen"};
public String[] country = {"Canada", "Germany", "USA"};
public Athlete() {
}
In your main method, you could do this.
public static void main(String[] args) {
Athlete art = new Athlete();
System.out.println(art.name[0]);
System.out.println(art.country[0]);
}
}
Currently you can't access the arrays named name and country, because they are member variables of your Athelete class.
Based on what it looks like you're trying to do, this will not work.
These arrays belong in your main class.
Your attempt at an athlete class seems to be dealing with a group of athletes, which is a design fault.
Define a class to represent a single athlete, with fields that represent the athlete's attributes:
public class Athlete {
private final String name;
private final String country;
private List<Performance> performances = new ArrayList<Performance>();
// other fields as required
public Athlete (String name, String country) {
this.name = name;
this.country = country;
}
// getters omitted
public List<Performance> getPerformances() {
return performances;
}
public Performance perform(Dive dive) {
// not sure what your intention is here, but something like this:
Performance p = new Performance(dive, this);
// add new performance to list
performances.add(p);
return p;
}
}
Then your main method would use ti like this:
public class Assignment1 {
public static void main(String[] args) {
String[] name = {"Art", "Dan", "Jen"};
String[] country = {"Canada", "Germant", "USA"};
Dive[] dive = new Dive[]{new Dive("somersault"), new Dive("foo"), new Dive("bar")};
for (int i = 0; i < name.length; i++) {
Athlete athlete = new Athlete(name[i], country[i]);
Performance performance = athlete.perform(dive[i]);
// do something with athlete and/or performance
}
}
}
I think you are a little messed up with what you doing.
Athlete is an object, athlete has a name, i has a city where he lives.
Athlete can dive.
public class Athlete {
private String name;
private String city;
public Athlete (String name, String city){
this.name = name;
this.city = city;
}
--create method dive, (i am not sure what exactly i has to do)
public void dive (){}
}
public class Main{
public static void main (String [] args){
String name = in.next(); //enter name from keyboad
String city = in.next(); //enter city form keybord
--create a new object athlete and pass paramenters name and city into the object
Athlete a = new Athlete (name, city);
}
}
public static void main(String[] args) {
public String[] name = {"Art", "Dan", "Jen"};
public String[] country = {"Canada", "Germant", "USA"};
// initialize your performance array here too.
//Your constructor takes arrays as an argument so you need to be sure to pass in the arrays and not just objects.
Athlete art = new Athlete(name, country, performance);
}
First off, the arrays are pointless, let's get rid of them: all they are doing is providing values for mock data. How you construct mock objects has been debated ad nauseum, but clearly, the code to create the fake Athletes should be inside of a unit test. I would use Joshua Bloch's static builder for the Athlete class, but you only have two attributes right now, so just pass those in a Constructor. Would look like this:
class Athlete {
private String name;
private String country;
private List<Dive> dives;
public Athlete(String name, String country){
this.name = name;
this.country = country;
}
public String getName(){
return this.name;
}
public String getCountry(){
return this.country;
}
public String getDives(){
return this.dives;
}
public void addDive(Dive dive){
this.dives.add(dive);
}
}
Then for the Dive class:
class Dive {
private Athlete athlete;
private Date date;
private double score;
public Dive(Athlete athlete, double score){
this.athlete = athlete;
this.score = score;
this.date = new Date();
}
public Athlete getAthlete(){
return this.athlete;
}
public Athlete getAthlete(){
return this.athlete;
}
public Athlete getAthlete(){
return this.athlete;
}
}
Then make a unit test and just construct the classes, and manipulate them, make sure that they are working. Right now they don't do anything so all you could do is assert that they are retaining the Dives that you are putting in them. Example:
#Test
public void testThatDivesRetainInformation(){
Athlete art = new Athlete("Art", "Canada");
Dive art1 = new Dive(art, 8.5);
Dive art2 = new Dive(art, 8.0);
Dive art3 = new Dive(art, 8.8);
Dive art4 = new Dive(art, 9.2);
assertThat(art.getDives().size(), is(5));
}
Then you could go through and add tests for things like, making sure that you can't construct a dive without an athlete, etc.
You could move construction of the athletes into the setup method of the test so you could use it all over the place. Most IDEs have support for doing that with a refactoring.
I have a Java program where I have a main class and another class called Person (that makes a 'person' class) with 2 methods. The methods are non-static and are called getName and getAge that stores this info a person element of an ArrayList.
How do I call these in the main program? I know I have to declare an instance of the class but I'm still not sure how to actually do it.
Considering Person a Class with 2 methods:
public class Person{
private String mName;
private int mAge;
public Person(String name, String age){
this.mName = name;
this.mAge = age;
}
//If you want this class to be Immutable please remove the setter methods()//
public void setName(String name){
this.mName = name;
}
public void setAge(String age){
this.mAge = age;
}
public String getName(){
return this.mName ;
}
public String getAge(){
return this.mAge ;
}
}
The Class containing main() method:
public class TestMain{
public static ArrayList<Person> aList = new ArrayList<Person>();
public static void main(String[] args){
Person person1 = new Person("Vivek",26);
Person person2 = new Person("Vicky",27);
aList.add(person1);
aList.add(person2);
}
}
In your main code you can do something like:
Person p = new Person();
p.setName("Jericho Jones");
p.setAge(153);
Of course, it's impossible to tell exactly without seeing the Person class.
You need to instantiate an object for this class.
Person p = new Person();
p.getName()....