CodeGym/Help with Java Tasks/Skipping this task too. Don't know what they want.

Level 27

Centurion, Pretoria

18.05.2020
591views
21comments

Skipping this task too. Don't know what they want.

Question about the task

Resolved

Lot's of talk about real order and new order, and an array of Column class objects passed as input parameter, but code is not understandable to me. Skip....

Make Column implement the Columnable interface. See the Javadocs for a description of its methods.
Implement the logic of the Column.getVisibleColumns() method.
The Column.configureColumns() method is already implemented. Don't change it.
Don't create additional fields.
The main() method is not tested.

Requirements:

Don't change the Columnable interface.
The Column class must implement the Columnable interface.
Don't create additional fields in the Column class.
The Column.configureColumns() method is already implemented. Don't change it.
The Column.getVisibleColumns() method must return a list of visible columns in the specified order.
The Column.getColumnName() method must return a column's full name.
The Column.isShown() method must return true if the column is visible. Otherwise, it must return false.
The Column.hide() method must hide the column and shift the indices of the other visible columns.

package com.codegym.task.task25.task2503; /* Make Column implement the Columnable interface. See the Javadocs for a description of its methods. Implement the logic of the Column.getVisibleColumns() method. The Column.configureColumns() method is already implemented. Don't change it. Don't create additional fields. The main() method is not tested. Requirements: 1. Don't change the Columnable interface. 2. The Column class must implement the Columnable interface. 3. Don't create additional fields in the Column class. 4. The Column.configureColumns() method is already implemented. Don't change it. 5. The Column.getVisibleColumns() method must return a list of visible columns in the specified order. 6. The Column.getColumnName() method must return a column's full name. 7. The Column.isShown() method must return true if the column is visible. Otherwise, it must return false. 8. The Column.hide() method must hide the column and shift the indices of the other visible columns. */ public class Solution { /** * Output: * <p/> * Available Amount * Account Number * Bank Name * -------------------- * Available Amount * Bank Name */ public static void main(String[] args) { Column.configureColumns(Column.Amount, Column.AccountNumber, Column.BankName); for (Columnable columnable : Column.getVisibleColumns()) { System.out.println(columnable.getColumnName()); } System.out.println("--------------------"); Column.AccountNumber.hide(); for (Columnable columnable : Column.getVisibleColumns()) { System.out.println(columnable.getColumnName()); } } }

Comments (21)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

18 May 2020, 14:43

Some things: #1 ordinal() on an enum type will return the index number of the actual value from the order it is declared in the Enum. So in this code, the actual ordinal return values are:

public enum Column {
    Customer("Customer"), // ordinal '0'
    BankName("Bank Name"), // ordinal '1'
    AccountNumber("Account Number"), // ordinal '2'
    Amount("Available Amount"); // ordinal '3'

and if you add more, they would be index 4, 5, 6 etc. Try this test code out to see what is happening inside the configureColumns method:

public static void main(String[] args) {
        Column.configureColumns(Column.BankName, Column.Customer);

        //Column.configureColumns(Column.AccountNumber, Column.Amount);
        //Column.configureColumns(Column.BankName, Column.Amount, Column.Customer);
        //Column.configureColumns(Column.BankName, Column.Amount, Column.Customer, Column.AccountNumber);
        //Column.configureColumns(Column.AccountNumber, Column.Amount, Column.Customer, Column.AccountNumber);
    }

Guadalupe Gagnon

Level 37 , Tampa, United States

18 May 2020, 14:43

public static void configureColumns(Column... newOrder) {
        System.out.println("All column values returned by values()");
        for(int i = 0; i < values().length; i++)
            System.out.println("\t" + i + ": " + values()[i]);
        System.out.println("All column values returned by arg 'newOrder'");
        for(int i = 0; i < newOrder.length; i++)
            System.out.println("\t" + i + ": " + newOrder[i]);
        System.out.println("-- Resetting 'realOrder' --");
        realOrder = new int[values().length];

        int loopCount = 0;
        System.out.println("--Starting loop--");
        for (Column column : values()) {
            System.out.println("\nLoop count index " + loopCount + ": Retrieved value '" + column + "'");
            realOrder[column.ordinal()] = -1;
            boolean isFound = false;

            System.out.println("Checking if value is contained within 'newOrder'");
            for (int i = 0; i < newOrder.length; i++) {
                if (column == newOrder[i]) {
                    if (isFound) {
                        throw new IllegalArgumentException("Column '" + column.columnName + "' is already configured.");
                    }
                    realOrder[column.ordinal()] = i;
                    isFound = true;
                    System.out.println("Value found in newOrder at index " + i + ". Setting index number at realOrder[" + loopCount + "]");
                }

            }
            if(!isFound)
                System.out.println("Value not found in newOrder, Setting realOrder[" + loopCount + "] to -1");
            loopCount++;
        }
        System.out.println("Final result of realOrder = " + Arrays.toString(realOrder));
    }

Guadalupe Gagnon

Level 37 , Tampa, United States

18 May 2020, 14:44

See if you can figure this task out with my hints/code review. Play with the test code in main to step through that configureColumns() until you better understand what it does. You should be able to figure out the rest with the task conditions and commented descriptions of what each Columnable method does.

Johannes

Level 27 , Centurion, Pretoria, South-Africa

19 May 2020, 07:03

Thanks Guada (1) I don't understand the concept of "ordinal" at all. We have an industry-wide used term: zero-based-index, that we've been using for decades. How does "ordinal" differ, except confuse me ? (2) the varargs list received in configureColumns(): is this (for example) 5 Columns class objects that were passed, each one consisting of it's 4 fields ? (3) how do I know how many were passed, and how to iterate through it ? What is values() ? I cannot find a single example of "values()" connected to varargs when I google, so I don't understand what I'm looking at (syntaxically speaking). (4) How does the program know if a column is hidden, if it loops through all of them and apparently make them all -1 (does that in some universe mean that you HIDE A COLUMN if you make a field -1 ?) (5) so making assumptions (because there's no help or study material available about this) I try to add columns from the column object array to the new array that I need to return in getVisibleColumns() method, and my code doesn't even compile: for (Integer i: realOrder){ if (i > -1){ //result.add(i); (this gives error) } } Sorry for the negativity: I pay for the course, and suddenly am swomped with work at my place of work, so cannot spend much time a day on the course, and I feel it's being neglected w.r.t. explanation and proper guidance from this "Multithreading" module, compared to the first 2 modules. It's almost as if they rushed to finish it, to be able to start charging for the course. I don't feel they spend nearly enough explanation on the topics in the module, and have skipped quite a few concepts up to here. It's easy to say "Google", but I'm not paying Google, I'm paying CodeGym in DOLLARS. Also, one cannot find what one doesn't know WHAT to google for. (example: values() method used above) I am a little more encouraged now, doing the threads part, but this "Column" exercise we're discussing here, sucks.

Guadalupe Gagnon

Level 37 , Tampa, United States

19 May 2020, 13:44

1) Ordinal is an object's position in a series, and the word is quite a bit older than 'zero based index'. I won't be able to tell you why Java developers chose to use this over indexPosition() or something similar, but it is the way it is. Since Java copied greater than 90% of the language from other languages (mostly C++), they most likely didn't come up with this concept. 2) Column is an enum and not a class. It sounds like you are confusing the two. Each enum object is only one of the possible values. 3a) You won't know how many are passed in with varargs. The only limit is how many values the enum has, in this case 4. The code will throw an error if two of the same enum types are passed in. 3b) The values() method is a method that is part of the enum data type that returns an array of all possible enum values. Because it is being used in the Column enum's code block, the qualified name of Column.values() is not required. You can use this in the main method, but would need the qualified name:

System.out.println(Arrays.toString(Column.values());

In the above code the returned array would be: [Customer, BankName, AccountNumber, Amount] 4) The realOrder array would determine that. It is a static array so all the different Column objects would all share that same array. The number at each index of the array are for the position of each Enum value such that: The position of 'Customer' is at index 0 The position of 'BankName ' is at index 1 The position of 'AccountNumber' is at index 2 The position of 'Amount' is at index 3 And if any of those numbers equal -1, then that means the Column should not be displayed. For example, lets say the realOrder equals this [1, -1, 0, -1]. That would translate to: 'Customer' will be displayed second 'BankName ' is hidden and will not be displayed 'AccountNumber' will be displayed first 'Amount' is hidden and will not be displayed

Johannes

Level 27 , Centurion, Pretoria, South-Africa

19 May 2020, 14:04

ok, it's starting to make a little more sense now. How did they think I'd be able to know all this ? I tried Google, it doesn't bring back what you don't know you don't know (*that age-old conundrum). What I meant with ordinal, is that Java uses both, so why refer to something's index as it's ordinal ? It already has the index value i.e. same thing, different name. In other words one could have used an inner loop with "int j" in this: realOrder[column.ordinal()] = i; (realOrder[j] = i; ? no worry. It will probably still make sense in future, anyways. The logic also now makes a little more sense, I just don't get why this is done: (first the method makes every column hidden in realOrder, then loops through it, and complains (throws exception) when it actually encouters a column that is equal to the incoming parameter ? Else it sets the column to the actual loop counter......omg. for (int i = 0; i < newOrder.length; i++) { if (column == newOrder[i]) { if (isFound) { throw new IllegalArgumentException("Column '" + column.columnName + "' is already configured."); } realOrder[column.ordinal()] = i; isFound = true; } } OK so if you can help me with ONE thing: how the heck can I get IntelliJ IDEA to actually enter the constructor and all code in the program when I debug, instead of just skipping it (even if I use F7), I could make sense from a lot of code that I still don't know WHEN it is executed (if ever). Like hash or equals or when working with serialization. You are a star, and explain very well. Have a nice evening (well, on your side it probably is day now).It's 16h04 here. Cheers

Guadalupe Gagnon

Level 37 , Tampa, United States

19 May 2020, 14:04

5) that code will not compile because it is attempting to add Integers to a list of Columns (List<Column>). You won't be able to do that in a foreach loop without keeping track of what index you are on, however a for loop would do that for you. Now as for the rest, it doesn't bother me helping people out so no need to apologize. I, too, understand the confusion and agree that google is very ineffective when you have no idea what you should be googling. Been there plenty of times trying to learn programming. My suggestion on this task is to take a breathe, then keep it simple. It looks like the only issue you are having on this task is that you haven't had a chance to understand the enum type. The rest of the task (hiding/showing Columns, real order, etc) is just simple code being obfuscated by thinking Column and Columnable is something needing a masters degree to understand. Take a look at the code I shared in my second post, copy it and run it in your IDE. Understand how realOrder is being determined and this task will make 99% more sense.

Guadalupe Gagnon

Level 37 , Tampa, United States

19 May 2020, 14:40

https://dzone.com/articles/18-points-every-java-developer-should-know-about-e In that link: "#9. All Enums are final". This means they are immutable and pre-loaded into memory at runtime before anything else is run, even main. You would have to set a break point somewhere between lines 7-18 to get the results you are looking for. Now with the configureColumns() method. The var args will hold the "real order" in the way that you, or the user if this was production code, pass them in. So if you call the method with (Column.Amount, Column.BankName), then you want Amount displayed first and Bank Name displayed second with all other columns hidden. The method accomplishes this by looping though each value that the Column enum has (line 29) in a for loop. I'll call this ColVal. The ordinal of the current ColVal in this loop will be used as the current index of realOrder. It then pre-sets that value to -1, which is done to erase any previously saved 'real order'. It then loops through the values in varArgs at line 33 until it finds a match to the current ColVal. Because varArgs is ordered in the way the real order should be, the current index of this loop can be used as the value to store in realOrder[ColVal.ordinal()]. If no match is found then -1 was already preset and wouldn't change. In this code the columns are only meant to be displayed once. It has a catch in this method that will throw an exception when it encounters the same value in varArgs more than once.

Johannes

Level 27 , Centurion, Pretoria, South-Africa

20 May 2020, 05:55

My soul: so the statement "Column column: values()" is not looping through the incoming varargs, but through the actual enum declared at the top ? FFS, that was difficult to realize.....I couldn't understand why they loop through the incoming newOrder with values() and set it all to -1, then check under that if it's -1..... Will try to work through it. Like I say: without the benefit of seeing the variable contents in the watch window of the debugger, it's difficult to grasp what is worked with at a point in time. Will let you know if I solve it. thanks Guada

Johannes

Level 27 , Centurion, Pretoria, South-Africa

20 May 2020, 08:13

OK, so at last configureColumns makes total sense to me, lol! Debugged it. Thanks for the help.

Johannes

Level 27 , Centurion, Pretoria, South-Africa

20 May 2020, 10:55

OK, took me a whole day, but I understand it better, and got it right. If you have time: Please explain in layman's terms why the interface Columnable is required ? I don't see the point. I also don't understand why it can be used in a for loop, i.e. for (Columnable columnable : Column.getVisibleColumns()) { System.out.println(columnable.getColumnName()); } I understand that I need a way to loop through the enums in "Column", but could do it the proper way (as they used in the program in another place): for (Column column : values()) Thanks for all your help!

Guadalupe Gagnon

Level 37 , Tampa, United States

20 May 2020, 13:37

This task is demonstrating how an enum data type can inherit an interface. The Columnable interface is one that is declared/designed for this task and is not a part of Java, though I am sure that this particular one is actually a real world example. However, because it is declared here the task designers could have called it anything and had the methods it exposed named anything, but I think the designers at code gym are trying to give the tasks a "real world use" feel. Now the Columnable interface is designed for a specific purpose, and one of those purposes is to get the visible columns. If you coded it in without using the interface and methods then the interface on Column would be superfluous in this code. The trick here is that a file, the Solution class, is using the code from Columnable to access the Column enum, which is what you are going to find in the real world. The code in the Solution class, lines 33-42 specifically (the first line setting up the Columns would only work for Columns) would work with any number of enum or classes that inherit the Columnable interface. The reusability of code is one of keymarks of OOP programming and why interfaces are such a powerful tool.

Johannes

Level 27 , Centurion, Pretoria, South-Africa

20 May 2020, 19:14

ok, but I was just discussing Interfaces with a collegue today. I can for the life of me not understand why they even exist ? It's EMPTY! It would have been obvious I would have to write code to hide or reorder columns in my Column class. I don't need empty methods to copy, then have to anyhow write my own code for them ? So I guess the only explanation to justify something looking so unnecessary as Interfaces, would be that it would only become clear once one works with big real-world applications, as it just looks silly in these programs, and confuse me ? I like these discussions, it's nice to get answers to stuff that bugs me, from someone knowledgeable, as well as doing the same course. cheers

Guadalupe Gagnon

Level 37 , Tampa, United States

20 May 2020, 20:48

As an example, Iterable is in interface that is implemented on List (which is subsequently the interface implemented by classes such as Vectors, ArrayLists, Stacks, etc). If Iterable was not implemented somewhere along the inheritance tree of these classes then they would not work in foreach loops. this is an interface you are familiar with though you may not realize it. I think of interfaces like a contract, or guarantee, that states that any class that implements the particular interface will absolutely have the methods declared in that interface. Let me try to explain in an example. Say that you had code that was essentially a car. The car could be anything, it doesn't matter so much. Lets say the car used an object to turn the car either left or right, essentially a steering wheel. So inside the car class there would be an interface object that could be used to call: turnLeft() turnRight() Steering wheels also do quite a bit more depending on the steering wheel. Some have radio controls, cruise control buttons, bluetooth buttons, etc. The car class however just needs those two methods. Now, as long as you pass in a class that implements Steerable, you can use any number of different steering wheels (or sticks, game pads, touchscreen computer etc) without having to redesign the car class. This is a very generic and basic example.

Guadalupe Gagnon

Level 37 , Tampa, United States

20 May 2020, 20:50

interface Steerable{
    void turnLeft();
    void turnRight();
}

//3 different steering wheels
//1
class genericWheel implements Steerable{
    @Override
    public void turnLeft() {
        // code to turn left
    }

    @Override
    public void turnRight() {
        // code to turn right
    }
}

//2
class wheelWithBlueTooth extends genericWheel {
    void doSomethingWithBluetooth() {
        // bluetooth code
    }
}


// 3
class wheelWithCruiseControl extends genericWheel{
    void doSomethingWithCruiseControl() {
        // the code for cruise control
    }
}

public class Car {
    // interface object
    Steerable control;

    // sets the control on Car implementation
    public Car(Steerable control) {
        this.control = control;
    }

    public static void main(String[] args) {
        // you could pass any class that implements steerable and the code
        // over the next few lines would work
        Car car = new Car(new wheelWithCruiseControl());

        car.control.turnLeft();
        car.control.turnRight();
    }
}

Johannes

Level 27 , Centurion, Pretoria, South-Africa

21 May 2020, 08:45

LOL! no.............?! *exasperated sigh because I am not yet at that level of comprehension* I don't get it. Your example has the class, and has to implement the interface's turnLeft and turnRight methods. And since an interface has no code, it's pretty pointless, so you also have to override it, and write your code that you initially wanted anyway. Its like implementing an empty header file, then declaring (overriding) the variables in your own class. The only advantage, as I see it at this point in time, is that you can use your IDE to automatically insert the methods you need to override, and then you can code further. Ignorant, I know, but I know more experienced OO programmers understand it better, it's just seemingly impossible to explain to newbies :)

Johannes

Level 27 , Centurion, Pretoria, South-Africa

21 May 2020, 08:47

// you could pass any class that implements steerable and the code // over the next few lines would work You can leave out the interface, and still pass the class (as you wrote the methods in the class that turns left or right, the interface had no code

Guadalupe Gagnon

Level 37 , Tampa, United States

21 May 2020, 13:46

All good points. In my car example above, the code is very linear and it is hard to see why an interface would be beneficial. It would seem, as you mentioned, because I just coded the left and right methods in a base class and derived child classes from that base, an interface would be unnecessary. Lets expand this example a little bit. Lets imagine the genericWheel's algorithm in the turnLeft and turnRight methods involved rotating the steering wheel clockwise/couterclockwise to get the car to turn left or right. Now lets say, for any reason, a developer came up with a whole new class that works completely different from a steering wheel, maybe a stick (think flight stick). This 'stick' class wouldn't be a child class of a steering wheel because you operate it a completely different way than rotating it; or in code terms the data structures, algorithms, methods for the two classes are completely different. I'm basically saying you can't copy+paste the code from the 'wheel' class into the code for the new stick class. Even though they are two separate classes, they can both turn the car. Now for whatever reason, maybe the client wants a 'stick' to steer the 'car', or after running numerous stress tests you find this class is just less resource intensive than the 'wheel' class; you decide that your car class is going to use a stick to turn the car. If your car class accepted a 'wheel' class to turn, then that would mean you would have to go and change all the references to 'wheel' and make them stick instead. In my example, that would take 2 seconds, but in the real world this car class could have thousands of, or more, lines of code with various uses of the 'wheel' class. Even with the tools in the IDE, this would be a time consuming task to go through all of that and make it work with a 'stick' class instead of a 'wheel' class.

Guadalupe Gagnon

Level 37 , Tampa, United States

21 May 2020, 14:06

solution

As with my code, if the 'stick' class implemented the interface 'steerable' then it is guaranteed to have the methods turnLeft() and turnRight(). To the car class, it doesn't care how those two methods accomplish their tasks, just that they do. Using interfaces you do not need to change the code in the car class to implement a new class to steer. If you manage a certain bit of code, like the car class, long enough, things are guaranteed to change over time. Interfaces allow flexibility and ease the burdens of development changes in the long run. As with anything in code, proper planning is essential. I can't tell you 100% when an interface is going to be the best choice over a class, but with experience you will start to understand when the benefits are there.

Johannes

Level 27 , Centurion, Pretoria, South-Africa

22 May 2020, 08:43

I agree, I don't see the full picture yet, but know that it wouldn't have been created (Interfaces) had it not had a useful purpose :) Thanks for the nice chat, and taking time out of your day to always reply.

Guadalupe Gagnon

Level 37 , Tampa, United States

22 May 2020, 13:08

anytime =)