Programski Jezici 1.Kol

An abstract class is defined by adding the keyword "abstract" in the class header. This indicates that the class cannot be instantiated and may contain abstract methods, which are methods without a body. By adding the "abstract" keyword, it is explicitly stating that the class is abstract.

The most likely organization of classes is that the class "Vozilo" is the base class, while "PutnickoVozilo" and "TeretnoVozilo" are derived classes from the class "Vozilo". This means that "PutnickoVozilo" and "TeretnoVozilo" inherit properties and methods from the base class "Vozilo".

The correct answer is "final". In Java, the "final" keyword is used to prevent further derivation or extension of a class. When a class is declared as "final", it cannot be subclassed or inherited by any other class. This is useful when we want to ensure that the class remains unchanged and cannot be modified or extended by other developers.

The correct answer is "toString". In order to enable the use of an object of our class as if it were a String data type, we need to define the toString method in our class. This method is used to convert an object to its string representation, allowing it to be used as a String.

The correct answer is "Object". In Java, the Object class is at the top of the class hierarchy. This means that all other classes in Java are subclasses of the Object class, either directly or indirectly. The Object class provides common methods and behaviors that are inherited by all other classes, such as toString(), equals(), and hashCode(). Therefore, Object is the most general and fundamental class in Java.

In Java, objects that are no longer needed in the program are automatically removed by the Garbage Collection process. This process identifies and collects objects that are no longer referenced by any part of the program, freeing up the memory allocated to those objects. This automated process helps in managing memory efficiently and eliminates the need for manual removal of objects.

The output of the program is "Dete" because the main method creates an object of the Dete class and assigns it to a reference variable of type Roditelj. When the prikazi() method is called on this object, the version of the method defined in the Dete class is executed, which prints "Dete" to the console. This demonstrates polymorphism, where a subclass object can be assigned to a superclass reference variable and the appropriate method is called based on the actual type of the object.

The correct answer is instanceof. The instanceof operator is used in programming to check if an object belongs to a specific class. It returns true if the object is an instance of the specified class or any of its subclasses, and false otherwise. This operator is commonly used in object-oriented programming languages to perform type checking and determine the class hierarchy of objects.

The correct answer is "Ubacivanjem kljucne reci abstract u zaglavlje klase" (By inserting the keyword abstract in the class header). This is because when the abstract keyword is used in the class header, it indicates that the class is abstract. An abstract class is a class that cannot be instantiated and is meant to be subclassed. It can contain abstract methods, which are methods without a body, and concrete methods with implementations.

In Java, when an object is no longer needed in the program, we can explicitly indicate this by assigning the reference to null. This means that the reference no longer points to any object, allowing the Java garbage collector to eventually remove the object from memory. This is a common practice to free up memory and optimize the performance of the program.

The given code is allowed in Java because it demonstrates a classic example of method overloading. The two methods in the class "Sabiranje" have the same name but different parameter lists, which is allowed in method overloading. This means that the methods can be called with different arguments, and the appropriate method will be executed based on the number and types of the arguments. Therefore, the code is valid and demonstrates the concept of method overloading.

It is allowed to have an empty catch block in Java, but it is not considered good practice because the purpose of the catch block is to handle and recover from the exception. Without any code inside the catch block, the exception will not be handled or recovered from, which can lead to unexpected behavior or errors in the program. It is recommended to at least print the error message by using e.getMessage() to provide some information about the exception.

The code creates an instance of the Student class with the name "Pera" and the JMBG "25252525012501". The constructor used is the one that takes in the name, JMBG, and year of enrollment as parameters. Since the year of enrollment is not provided, the default value of 2018 is used. The ispisi() method is then called on the created instance, which prints out the name, JMBG, and year of enrollment as "Ime: Pera, jmbg: 25252525012501, godina upisa: 2018".

The correct answer is that the class must implement the Comparable interface and define the compareTo() method. This is because the compareTo() method is used by the sorting algorithm to compare objects and determine their order. By implementing the Comparable interface and providing the compareTo() method, we allow the sorting method (e.g. Arrays.sort()) to correctly sort objects of our class based on our specified criteria.

The program will not compile because class B is trying to inherit from a final class A.

When a new class extends an existing class in inheritance, the new class inherits all the fields and methods of the existing class. This means that the new class can access and use all the variables and functions that are defined in the existing class. There is no restriction on the visibility of the fields and methods being inherited, so both protected and public fields and methods are inherited by the new class. However, private fields and methods are not inherited. Therefore, the correct answer is "Nasledjuje sva polja i metode postojece klase" which translates to "It inherits all the fields and methods of the existing class".

The program will output "Complex@8e2fb5 (8e2fb5 is the hashcode of object c)". This is because when we try to print an object directly, it will call the toString() method of the object. Since the Complex class does not have a toString() method, it will use the default implementation from the Object class, which returns the class name followed by the hashcode of the object.

The correct answer states that a class can have one or more constructors, but all of them must have different signatures. This means that a class can have multiple ways of being instantiated, each with different parameters. The requirement for different signatures ensures that the constructors can be differentiated and called appropriately based on the arguments provided.

The code creates an instance of the Student class and sets its name to "Bob". Then, a reference variable studentClone is created and assigned the same memory address as student. When the name of studentClone is changed to "Alice", it also changes the name of the original student object. Therefore, when the code prints the name of the student object, it will be "Alice".

The correct answer is "Metod se poziva naredbom Ispit.test(), bez potrebe da se prvo instancira objekat klase ispit." This means that the method can be called directly using the class name followed by the method name, without the need to create an instance of the class.

The class D is incorrectly defined because it extends the class C which is final.

This answer correctly states the principle of subtype polymorphism in Java. It means that an object of a derived class (subtype) can always be used where an object of its base class (supertype) is expected. This is a fundamental concept in object-oriented programming, as it allows for code reusability and flexibility by treating objects of different derived classes as objects of their common base class.

The correct answer is "Preopterecenje metoda (overload)". This term refers to the process of defining multiple methods with the same name but different parameters within the same class. Overloading allows for more flexibility and versatility in programming, as it enables the same method name to be used for different purposes based on the input parameters. This helps to improve code readability and maintainability.

In Java, the keyword "this" is used to refer to the current instance of a class. It is used to access the members (variables and methods) of the current object. By using "this", we can differentiate between the instance variables and parameters with the same name. It is commonly used in constructors and setter methods to set the values of instance variables.

The correct answer is MyClass mc = new MyClass(i);. This is because the class MyClass has two constructors - a default constructor with no parameters and another constructor with an int parameter. Therefore, we can create an object of this class by using the constructor with the int parameter and passing the desired value for the parameter. The other options are incorrect because they either do not use the correct constructor or have incorrect syntax.

The code will not compile because the class A does not have a declaration for class B. Therefore, the line "B b1 = new A();" will cause a compilation error.

The correct answer is "Hello from an instance of the class B!" because the code creates an object of class B and assigns it to a reference of type A. Since class B extends class A and overrides the say() method, when the say() method is called on the object, it will execute the version of the method defined in class B, which prints "Hello from an instance of the class B!"

The given method is not correctly defined because it is missing a clause in the method header to indicate that it can throw an exception of type IllegalArgumentException.

The correct answer is a combination of three options. The first option "public class MyClassSub extends MyClass implements MyInterface{}" is syntactically correct because it extends the class MyClass and implements the interface MyInterface. The second option "public class MyClass{}" is also correct as it defines the class MyClass. The third option "public class MyClassSub extends MyClass{}" is also valid as it extends the class MyClass. Therefore, the correct answer includes all three options.

The correct answer is "super". In object-oriented programming, the "super" keyword is used to access members of the base class that are hidden by members of the derived class. It allows the derived class to call the overridden method or constructor of the base class. By using "super", the derived class can access and use the functionality of the base class while still being able to override or extend it.

The correct answer is "value=i;" and "this.value=i;". In order to assign the value of the parameter "i" to the attribute "value", we can use either "value=i;" or "this.value=i;". Both statements achieve the desired result of assigning the value of "i" to the attribute "value".

The correct answer is B because when the code is executed, an ArithmeticException is thrown due to the division by zero (5/0). This exception is caught by the catch block that specifically handles ArithmeticException. Therefore, "B" is printed on the standard output.

The correct answer is "eksplicitno deklarise u zaglavlju klase da implementira interfejs A kljucnom reci implements, definise sve metode iz interfejsa A". This is because in order for a specific class to implement a given interface, it must explicitly declare in the class header that it implements interface A using the keyword "implements". Additionally, the class must define all the methods from interface A.

Variables of an abstract class type can point to objects of both the specific abstract class and objects of classes derived from that abstract class.

The code creates an object of the "box" class and assigns values to its height, length, and width attributes. Then, it uses the toString() method to print the object. Since the "box" class does not have a custom implementation of the toString() method, the default implementation is used, which prints the class name followed by the object's hash code. Therefore, the output will be "imeKlase@hashcode".

The correct answers for the given question are "Radnik (Radnik r) { }" and "Radnik () { }". These are the correct constructors for the class "Radnik". The first constructor takes an object of type "Radnik" as a parameter, which allows for creating a new object based on an existing one. The second constructor is a default constructor with no parameters, which allows for creating a new object without any initial values.

The correct answer is "Greska prilikom prevodjenja programa, ne moze se instancirati apstraktna klasa". This is because class A is defined as an abstract class, which means it cannot be instantiated directly. Abstract classes are meant to be extended by other classes, and objects can only be created from concrete subclasses of the abstract class. Therefore, attempting to create an object of type A will result in a compilation error.

The code will result in a compilation error because the class A does not have a defined constructor.

Polimorfizam se manifestuje kroz princip podtipa, preopterećenje i nadjačavanje metoda. Princip podtipa se odnosi na mogućnost korišćenja objekata izvedenih klasa kao objekata baznih klasa. Preopterećenje metoda se odnosi na mogućnost definisanja više metoda sa istim imenom, ali sa različitim parametrima. Nadjačavanje metoda se odnosi na mogućnost da izvedena klasa implementira metodu koju je već definisala bazna klasa, ali sa drugačijom implementacijom.

The given code snippet is attempting to assign an object of type Vozilo to a variable of type Automobil without explicit type conversion. In Java, when assigning objects to variables of different types, explicit type conversion is required if the assignment is not directly compatible. In this case, since Vozilo is the superclass of Automobil, the assignment from Automobil to Vozilo is allowed. However, the assignment from Vozilo to Automobil is not allowed without explicit type conversion. Therefore, it is not allowed to assign an object of type Vozilo to a variable of type Automobil without explicit type conversion.

The code creates two objects of class A, a1 and a2, with the same values for the variables a and b. However, when comparing the objects using the "==" operator, it checks if the two object references are pointing to the same memory location, which is not the case here. Therefore, the condition "a1==a2" evaluates to false and the statement "Sa==nisu jednaki." is printed.

On the other hand, when using the "equal" method defined in class A, it compares the values of the variables a and b of the two objects. Since the values are the same, the condition "a1.equal(a2)" evaluates to true and the statement "Sa equal su jednaki." is printed.

The given code does not define a constructor. In Java, every class should have at least one constructor, either explicitly defined or implicitly provided by the compiler. Since the abstract class "xy" does not have a constructor, it is considered incorrect.

Static methods can be called in a program independently of the objects of their class, meaning that they can be accessed without creating an instance of the class. Additionally, static methods can only access static fields, as they do not have access to object-specific fields.

The correct answers are "Ljubimac a1 = lj;", "Zivotinja z1 = new Ljubimac();", and "Zivotinja z2 = lj;". These statements are valid because they involve creating objects of the appropriate classes and assigning them to variables of compatible types. "Ljubimac a1 = lj;" is valid because a Ljubimac object can be assigned to a Ljubimac variable. "Zivotinja z1 = new Ljubimac();" is valid because a Ljubimac object can be assigned to a Zivotinja variable. "Zivotinja z2 = lj;" is valid because a Ljubimac object can be assigned to a Zivotinja variable.

Dynamic binding refers to the process of determining which overridden method will be called for a class variable. In dynamic binding, the method that is called depends on the actual type of the object that the variable points to, regardless of the declared type of the variable. Therefore, the correct answer states that the overridden method that is called for a class variable depends on the actual type of the object it points to, regardless of the declared type.

The correct answer is "Program se nece kompajlirati, greska je u konstruktoru klase Student". This is because in the constructor of the Student class, there is a syntax error where the keyword "this" is missing before the variable "godinaUpisa". This causes a compilation error and the program will not be able to run. Additionally, the answer also states that there is an error in the method "ispisi" of the Student class, but this is incorrect as there is no error in that method.

The correct answer states that encapsulation is an important object-oriented principle that involves allowing access to the values of class fields only through public methods, protecting all fields and internal methods within the class, allowing them to be modified only in a controlled manner, and hiding all object fields of the class. This ensures that the internal implementation of the class cannot be changed without affecting the programs that use it.

If class B implements methodA(), it means that it provides a concrete implementation of the abstract method defined in class A. In this case, class B is a concrete class that can be instantiated. On the other hand, if class B does not implement methodA(), it must also be defined as abstract and cannot be instantiated.

Interfejsi se sastoje od skupa apstraktnih metoda bez implementacije, što znači da samo deklarišu metode koje treba implementirati u klasama koje ih implementiraju. Ovo omogućava da se definiše zajednički skup metoda koje klase moraju implementirati, ali ne definiše njihovu konkretne implementaciju. Takođe, interfejsi omogućavaju klasama da implementiraju više interfejsa, što pruža slične mogućnosti kao višestruko nasleđivanje.

An abstract class must have one or more abstract methods. An abstract class can contain a main method. An abstract class can have static methods. An abstract class can implement an interface. However, an abstract class cannot be defined with the final modifier in the class header.