50%(2)Il 50% ha trovato utile questo documento (2 voti)
2K visualizzazioni18 pagine
Encapsulation is the inclusion within a program object of all the resources need for the object to function - basically, the methods and the data. In order to modularize / define the functionality of a one class, that class can uses functions / properties exposed by another class in many different ways.
Encapsulation is the inclusion within a program object of all the resources need for the object to function - basically, the methods and the data. In order to modularize / define the functionality of a one class, that class can uses functions / properties exposed by another class in many different ways.
Encapsulation is the inclusion within a program object of all the resources need for the object to function - basically, the methods and the data. In order to modularize / define the functionality of a one class, that class can uses functions / properties exposed by another class in many different ways.
Question 1: Design a chess game using OOP concepts?
Question 2: What data structure do you use for a game like chess? How would you go about coding a game of checkers?
DBMS vs. RDBMS
Question 3: I was given a function and asked what are all the things that could go wrong with it? Ans: access modifiers, return type, arguments, function of the function, requirement of the function.
Linked List implementation Question 4: Singly, doubly Linked List Insert, Delete and reverse etc.
Question 5: What is encapsulation?
Ans: The encapsulation is the inclusion within a program object of all the resources need for the object to function - basically, the methods and the data. In OOP the encapsulation is mainly achieved by creating classes, the classes expose public methods and properties. The class is kind of a container or capsule or a cell, which encapsulate the set of methods, attribute and properties to provide its indented functionalities to other classes. In that sense, encapsulation also allows a class to change its internal implementation without hurting the overall functioning of the system. That idea of encapsulation is to hide how a class does it but to allow requesting what to do.
In order to modularize/ define the functionality of a one class, that class can uses functions/ properties exposed by another class in many different ways. According to Object Oriented Programming there are several techniques, classes can use to link with each other and they are named association, aggregation, and composition. There are several other ways that an encapsulation can be used, as an example we can take the usage of an interface. The interface can be used to hide the information of an implemented class. IStudent myStudent = new LocalStudent(); IStudent myStudent = new ForeignStudent(); According to the example (Assuming LocalStudent and ForeignStudent are implemented by the IStudentinterface), we can see how LocalStudent and ForeignStudent are hiding their, localize implementing information through the IStudent interface.
Question 6: What's the difference in encapsulation and inheritance?
Encapsulation is the mechanism that binds together data structure (attributes) and behavior (operations) of an object into a single unit. It keeps the internal implementation details of the object hidden from other objects. In other words, encapsulation works as a protective sheet that prevents code and the data from being misused by other code outside the sheet. By the use of the encapsulation mechanism, the implementation of an object can be changed without having any side effect on the applications that use it. In Java, the basis of encapsulation is the class. It defines the code and data that will be shared by a group of instances of the class (called objects). Inheritance is a process by which objects of a class acquire the properties of the objects of another class. It supports the concept of hierarchical classification. It not only allows objects to be reused, but also allows the creation of new objects by extending the existing ones. By using the inheritance, a generic class can be created that can then be inherited by other more specific classes. In Java terminology, a class that is inherited is called a superclass, and the class that inherits another class is called a subclass. A subclass inherits all the instance variables (attributes) and methods (operations) defined in the superclass. In Java, a class is declared to inherit another class by using the extends keyword.
Question 7: What is database normalization?
Question 8: Make a binary tree where the nodes are the letters in "Cerner".
Question 9: Given a method signature for a method that would search and replace text in a string. If you were writing unit tests what would you test for?
Question 10: Given a String reversal program, explain the output.
Question 11: Question about unit testing. How to create unit test cases?
In computer programming, unit testing is a method by which individual units of source code, sets of one or more computer program modules together with associated control data, usage procedures, and operating procedures, are tested to determine if they are fit for use. One can view a unit as the smallest testable part of an application. In procedural programming a unit could be an entire module but is more commonly an individual function or procedure. In object-oriented programming a unit is often an entire interface, such as a class, but could be an individual method. Unit tests are created by programmers or occasionally by white box testers during the development process. Ideally, each test case is independent from the others: substitutes like method stubs, mock objects, fakes and test harnesses can be used to assist testing a module in isolation. Unit tests are typically written and run by software developers to ensure that code meets its design and behaves as intended. Its implementation can vary from being very manual (pencil and paper) to being formalized as part of build automation.
Question 12: If a user reports that an application is slow, what steps would you take? Ans: user is true, problem persists, full domain or only user.
Question 13: What are scopes in programming languages and their uses? Ans: Variable scopes public private and in general access modifiers.
The scope of a variable in a program is the lines of code in the program where the variable can be accessed. Two different types of scope have been used in programming languages: static scope and dynamic scope. Most modern programming languages such as Pascal, C++ and Java use static scope. Some languages such as APL, Snobol4 and early versions of LISP use dynamic scope.
The converse of scope is referencing environment. The referencing environment of a procedure is the set of all the variables whose scope extends to the procedure. The local referencing environment of a procedure consists of all the variables declared within the procedure, and includes any formal parameters of the procedure. The non-local referencing environment consists of all the variables not declared in the procedure, but whose scope extends to the procedure.
The concept of scope applies not only to variable names but also to the names of procedures. The scope of the name of a procedure determines all the procedures/functions in a program that can call the procedure.
1) Static Scope
The static scope of a variable is the most immediately enclosing block, excluding any enclosed blocks where the variable has been re-declared. Therefore, the static scope of a variable in Pascal is the procedure in which the variable is declared, excluding any procedures defined inside this procedure that declare another variable by the same name. The static scope of a variable in a program can be determined by simply studying the text of the program. Static scope is not affected by the order in which procedures are called during the execution of the program.
Example: What is the scope of the variable x declared in the procedure compute() in the following program?
program main var y: Real;
procedure compute() var x : Integer;
procedure initialize() var z: Real; begin {initialize} ... end {initialize}
procedure transform() var x: Real; begin {transform} ... end {transform}
begin {compute} ... end {compute} begin {main} ... end {main}
Answer: The procedure in which the variable is declared iscompute(). Therefore, compute() is in the scope of x. The procedure initialize() is defined within compute(). Since initialize() does not re- declare x, initialize() is within the scope of x declared in compute(). The procedure transform() is defined within compute(). Since transform() does re- declare x, transform() is not within the scope of x declared in compute().
Program main() is also an enclosing block (procedure) ofx. But, since it is not the immediately enclosing procedure, i.e., it is not the procedure in which x is declared, main() is not in the scope of x declared incompute().
Pragmatics:
Note that the concept of scope is essential to understanding programs. In the above example, you would not be able to correctly answer the following questions if you did not understand the concept of scope: 1. If transform() procedure prints the value of x, which variable would it be referencing? 2. If initialize() procedure prints the value of x, which variable would it be referencing? 3. If main() program attempts to use the value of x, would it be legal? Can you answer these questions?
Algorithms to determine Static Scope:
The structure of a Pascal program, in particular, the order in which procedure definitions are nested in the program can be graphically depicted as a tree. This tree is called the static tree of the program. It is quite convenient to use the static tree of a Pascal program to determine the static scope of a variable in the program.
Algorithm to draw the static tree of a Pascal program: 1. Draw the main() program as the root node of the tree. 2. Identify all the procedures/functions directly defined in main(). Draw them as child nodes of main() node. 3. Repeatedly carry out step 2 for all the leaf nodes of the tree, until there are no more nested procedures in the program. In the Pascal program presented earlier, compute() is the only procedure defined directly in main(). Hence, it is the only child of main(). The procedures initialize() and transform() are defined within compute() and are its children. The static tree of the program is shown below.
Algorithm to determine the static scope of a variable v declared in a procedure p() using the static tree of the program: 1. Identify the sub-tree of the static tree with procedurep() as its root. 2. In this sub-tree, identify any descendant nodes (i.e., procedures/functions) that re- declare the variable v. Eliminate the entire sub-trees with these nodes as root. The remaining nodes in the sub-tree identified in Step 1 are in the scope of the variable v declared in procedurep().
2) Dynamic Scope
The dynamic scope of a variable extends to all the procedures called thereafter during program execution, until the first procedure to be called that re-declares the variable. Therefore, in order to determine the dynamic scope of a variable, we must first know the sequence in which procedures are called during execution of the program. Unlike static scope, dynamic scope cannot be determined merely by studying the text of a program. Pascal uses static scope, not dynamic scope. For purposes of discussing dynamic scope, we will assume that the language we are considering is a Pascal-like language, and not Pascal itself. However, using the same Pascal syntax for all the modules in the courseware will help us focus on the concept of scope in this module.
Example:
What is the scope of the variable x declared in the procedure compute() in the following program, assuming that procedures are called in the following order: main()calls compute(), which in turn calls transform(), which in turn calls initialize()?
program main var y: Real;
procedure compute() var x : Integer;
procedure initialize() var x: Real; begin {initialize} ... end {initialize}
procedure transform() var z: Real; begin {transform} ... end {transform}
begin {compute} ... end {compute} begin {main} ... end {main}
Answer: The procedure in which the variable is declared iscompute(). Therefore, compute() is in the scope of x. Procedure compute() calls the procedure transform(). Since transform() does not re- declare x, transform() is within the scope of x declared in compute(). Procedure transform() in turn calls procedureinitialize(). Since initialize() does re- declare x, initialize() is not within the scope of x declared incompute(). Program main() is not called by/after compute(), but rather, before it. Therefore, main() is not in the scope of declared in compute().
Pragmatics:
Note that the concept of scope is essential to understanding programs. In the above example, you would not be able to correctly answer the following questions if you did not understand the concept of scope: 1. If transform() procedure prints the value of x, which variable would it be referencing? 2. If initialize() procedure prints the value of x, which variable would it be referencing? 3. If main() program attempts to use the value of x, would it be legal? Can you answer these questions?
Algorithm to determine Dynamic Scope:
In order to determine the dynamic scope of a variable in a program, it is convenient to use a directed graph of the order in which procedures are called during the execution of the program. The directed graph for the earlier program is shown below:
Algorithm to determine the dynamic scope of a variable v declared in a procedure p() using a directed graph of procedure calls: 1. Identify the sub-graph of the directed graph that begins with the procedure p(). 2. In this sub-graph, identify the first descendant node (i.e., procedure/function) that re- declares the variable v. Eliminate the entire sub-graph that begins with this node. The remaining nodes in the sub-graph identified in Step 1 are in the dynamic scope of the variable v declared in procedure p().
Question 14: Were the customers unhappy about your work anytime?
Question 15: Design a traffic signal using Java?
Question 16: Describe a situation where you have difficulties with your team members. Ans:
Question 17: Describe a situation where you have difficulties with your team members. Biggest mistake in IT/programming. How did you fix it? Ans:
Question 18: Describe a situation where you have difficulties with your team members.
Question 19: What is the difference between a Set and a List? Ans: List is an ordered sequence of elements whereas Set is a distinct list of elements which is unordered. You have to compare concrete implementations (for example HashSet with ArrayList); because the abstract interfaces Set/List don't really tell you anything about performance.
Here are few note worthy differences between List and Set in Java. Remember that both of them are used to store objects and provides convenient API to insert, remove and retrieve elements, along with to support Iteration over collection.
1) Fundamental difference between List and Set in Java is allowing duplicate elements. List in Java allows duplicates while Set doesn't allow any duplicate. If you insert duplicate in Set it will replace the older value. Any implementation of Set in Java will only contains unique elements.
2) Another significant difference between List and Set in Java is order. List is an Ordered Collection while Set is an unordered Collection. List maintains insertion order of elements, means any element which is inserted before will go on lower index than any element which is inserted after. Set in Java doesn't maintain any order. Though Set provide another alternative called SortedSet which can store Set elements in specific Sorting order defined by Comparable and Comparator methods of Objects stored in Set.
3) Set uses equals () method to check uniqueness of elements stored in Set, while List uses compareTo () method to implement natural sorting order of elements. In order for an element to behave properly in Set and SortedSet, equals and compareTo must be consistent to each other.
4) Popular implementation of List interface in Java includes ArrayList, Vector and LinkedList. While popular implementation of Set interface includes HashSet, TreeSet and LinkedHashSet.
When to use List and Set in Java Another good follow-up question is "when do you use List and Set in Java", which can also be answered based on properties of List and Set we have learn here. These differences between Set and List also teach us when to use Set and when to prefer List. It is pretty clear that if you need to maintain insertion order or object and you collection can contain duplicates than List is a way to go. On the other hand if your requirement is to maintain unique collection without any duplicates than Set is the way to go.
Important point to note is that both List and Set are derived from Collection Interface. In short, main difference between List and Set in Java is that List in an ordered collection which allows duplicates while Set is an unordered collection which doesnt.
Question 20: What type of job would you like within Software Engineering field? Ans: Code, test, analysis,
Question 21: Describe a scenario where you tried to troubleshoot and you failed Ans:
Question 22: Describe a scenario where you tried to troubleshoot and you succeeded
All long-lasting tasks should be run in separate thread, not in UI thread. You call getFileFromUrl(..) from onCreate(..) method. This cause hangings. I recommend you not to do any time consuming task in onCreate(..) method. In general an activity won't be shown till onCreate(..) is finished. In case of strings, use string buffer if appending is necessary, thus creating short lived temp objects. Virtual method calls are expensive c++ is gets inline in java directly access the variable. Know And Use The Libraries
Question 23: What is inheritance?
Ans: Inheritance is the capability of a class to use the properties and methods of another class while adding its own functionality. Ability of a new class to be created, from an existing class by extending it, is called inheritance. public class Exception { } public class IOException : Exception { } The new class (IOException), which is called the derived class or subclass, inherits the members of an existing class (Exception), which is called the base class or super-class. The class IOException can extend the functionality of the class Exception by adding new types and methods and by overriding existing ones.
Just like abstraction is closely related with generalization, the inheritance is closely related with specialization. It is important to discuss those two concepts together with generalization to better understand and to reduce the complexity.
One of the most important relationships among objects in the real world is specialization, which can be described as the is-a relationship. When we say that a dog is a mammal, we mean that the dog is a specialized kind of mammal. It has all the characteristics of any mammal (it bears live young, nurses with milk, has hair), but it specializes these characteristics to the familiar characteristics of canis domesticus. A cat is also a mammal. As such, we expect it to share certain characteristics with the dog that are generalized in Mammal, but to differ in those characteristics that are specialized in cats.
The specialization and generalization relationships are both reciprocal and hierarchical. Specialization is just the other side of the generalization coin: Mammal generalizes what is common between dogs and cats, and dogs and cats specialize mammals to their own specific subtypes.
Similarly, as an example you can say that both IOException and SecurityException are of type Exception. They have all characteristics and behaviors of an Exception, That mean the IOException is a specialized kind of Exception. A SecurityException is also an Exception. As such, we expect it to share certain characteristic with IOException that are generalized in Exception, but to differ in those characteristics that are specialized in SecurityExceptions. In other words, Exception generalizes the shared characteristics of both IOException and SecurityException, while IOException and SecurityException specialize with their characteristics and behaviors. In OOP, the specialization relationship is implemented using the principle called inheritance. This is the most common and most natural and widely accepted way of implement this relationship.
Question 24: What are your 3 biggest achievements so far?
Question 25: How would you go about designing a program that determines whether or not a number is prime? Java code:
import java.io.*;
class PrimeNumber { public static void main(String[] args) throws Exception { int i; Buffered Reader bf = new BufferedReader(new InputStreamReader (System.in)); System.out.println (Enter number :); int num = Integer.parseInt(bf.readLine()); System.out.println(Prime number: ); for (i=1; i<num; i++) { for(j=2; j<i; j++) { int n = i%j; if (n==0) { break; } } if (i==j) { System.out.println(Prime number: + +i); } } }
Question 26: If there was anything you wanted to change about a programming language, what would it be?
What is the biggest mistake you made in a past job.
Question 27: Tell me about OOP concepts. Explain some of the ideas behind Object Oriented programming
Ans: OOP is a design philosophy. It stands for Object Oriented Programming. Object- Oriented Programming (OOP) uses a different set of programming languages than old procedural programming languages (C, Pascal, etc.). Everything in OOP is grouped as self sustainable "objects". Hence, you gain re-usability by means of four main object-oriented programming concepts. In order to clearly understand the object orientation, lets take your hand as an example. The hand is a class. Your body has two objects of type hand, named left hand and right hand. Their main functions are controlled/ managed by a set of electrical signals sent through your shoulders (through an interface). So the shoulder is an interface which your body uses to interact with your hands. The hand is a well architected class. The hand is being re-used to create the left hand and the right hand by slightly changing the properties of it.
What is an Object? An object can be considered a "thing" that can perform a set of related activities. The set of activities that the object performs defines the object's behavior. For example, the hand can grip something or a Student (object) can give the name or address. In pure OOP terms an object is an instance of a class.
A class is simply a representation of a type of object. It is the blueprint/ plan/ template that describe the details of an object. A class is the blueprint from which the individual objects are created. Class is composed of three things: a name, attributes, and operations.
public class Student { } According to the sample given below we can say that the student object, named objectStudent, has created out of the Student class. Student objectStudent = new Student();
In the software world, though you may not have realized it, you have already used classes. For example, the TextBoxcontrol, you always used, is made out of the TextBox class, which defines its appearance and capabilities. Each time you drag a TextBox control, you are actually creating a new instance of the TextBox class.
Additionally to identify a class correctly, you need to identify the full list of leaf level functions/ operations of the system (granular level use cases of the system). Then you can proceed to group each function to form classes (classes will group same types of functions/ operations). However a well defined class must be a meaningful grouping of a set of functions and should support the re-usability while increasing expandability/ maintainability of the overall system.
In software world the concept of dividing and conquering is always recommended, if you start analyzing a full system at the start, you will find it harder to manage. So the better approach is to identify the module of the system first and then dig deep in to each module separately to seek out classes.
A software system may consist of many classes. But in any case, when you have many, it needs to be managed. Think of a big organization, with its work force exceeding several thousand employees (lets take one employee as a one class). In order to manage such a work force, you need to have proper management policies in place. Same technique can be applies to manage classes of your software system as well. In order to manage the classes of a software system, and to reduce the complexity, the system designers use several techniques, which can be grouped under four main concepts named Encapsulation, Abstraction, Inheritance, and Polymorphism. These concepts are the four main gods of OOP world and in software term, they are called four main Object Oriented Programming (OOP) Concepts.
1) Encapsulation: The encapsulation is the inclusion within a program object of all the resources need for the object to function - basically, the methods and the data. In OOP the encapsulation is mainly achieved by creating classes, the classes expose public methods and properties. The class is kind of a container or capsule or a cell, which encapsulate the set of methods, attribute and properties to provide its indented functionalities to other classes. In that sense, encapsulation also allows a class to change its internal implementation without hurting the overall functioning of the system. That idea of encapsulation is to hide how a class does it but to allow requesting what to do.
In order to modularize/ define the functionality of a one class, that class can uses functions/ properties exposed by another class in many different ways. According to Object Oriented Programming there are several techniques, classes can use to link with each other and they are named association, aggregation, and composition. There are several other ways that an encapsulation can be used, as an example we can take the usage of an interface. The interface can be used to hide the information of an implemented class. IStudent myStudent = new LocalStudent(); IStudent myStudent = new ForeignStudent(); According to the example (Assuming LocalStudent and ForeignStudent are implemented by the IStudentinterface), we can see how LocalStudent and ForeignStudent are hiding their, localize implementing information through the IStudent interface.
2) Abstraction
Abstraction is an emphasis on the idea, qualities and properties rather than the particulars (a suppression of detail). The importance of abstraction is derived from its ability to hide irrelevant details and from the use of names to reference objects. Abstraction is essential in the construction of programs. It places the emphasis on what an object is or does rather than how it is represented or how it works. Thus, it is the primary means of managing complexity in large programs.
While abstraction reduces complexity by hiding irrelevant detail, generalization reduces complexity by replacing multiple entities which perform similar functions with a single construct. Generalization is the broadening of application to encompass a larger domain of objects of the same or different type. Programming languages provide generalization through variables, parameterization, generics and polymorphism. It places the emphasis on the similarities between objects. Thus, it helps to manage complexity by collecting individuals into groups and providing a representative which can be used to specify any individual of the group. Abstraction and generalization are often used together. Abstracts are generalized through parameterization to provide greater utility. In parameterization, one or more parts of an entity are replaced with a name which is new to the entity. The name is used as a parameter. When the parameterized abstract is invoked, it is invoked with a binding of the parameter to an argument.
Abstract Abstract classes, which declared with the abstract keyword, cannot be instantiated. It can only be used as a super-class for other classes that extend the abstract class. Abstract class is the concept and implementation gets completed when it is being realized by a subclass. In addition to this a class can inherit only from one abstract class (but a class may implement many interfaces) and must override all its abstract methods/ properties and may override virtual methods/ properties.
Interface In summary the Interface separates the implementation and defines the structure, and this concept is very useful in cases where you need the implementation to be interchangeable. Apart from that an interface is very useful when the implementation changes frequently. Some say you should define all classes in terms of interfaces, but I think recommendation seems a bit extreme.
Interface can be used to define a generic template and then one or more abstract classes to define partial implementations of the interface. Interfaces just specify the method declaration (implicitly public and abstract) and can contain properties (which are also implicitly public and abstract). Interface definition begins with the keyword interface. An interface like that of an abstract class cannot be instantiated. If a class that implements an interface does not define all the methods of the interface, then it must be declared abstract and the method definitions must be provided by the subclass that extends the abstract class. In addition to this an interfaces can inherit other interfaces.
A class and an interface are two different types (conceptually). Theoretically a class emphasis the idea of encapsulation, while an interface emphasis the idea of abstraction (by suppressing the details of the implementation). The two poses a clear separation from one to another. Therefore it is very difficult or rather impossible to have an effective meaningful comparison between the two, but it is very useful and also meaningful to have a comparison between an interface and an abstract class.
1. Interface definition begins with a keyword interface so it is of type interface 2. Abstract classes are declared with the abstract keyword so it is of type class
3. Interface has no implementation, but they have to be implemented. 4. Abstract classs methods can have implementations and they have to be extended.
5. Interfaces can only have method declaration (implicitly public and abstract) and fields (implicitly public static) 6. Abstract classs methods cant have implementation only when declared abstract. 7. Interface can inherit more than one interfaces 8. Abstract class can implement more than one interfaces, but can inherit only one class
9. Abstract class must override all abstract method and may override virtual methods 10. Interface can be used when the implementation is changing
11. Abstract class can be used to provide some default behavior for a base class. 12. Interface makes implementation interchangeable
13. Interface increase security by hiding the implementation 14. Abstract class can be used when implementing framework
15. Abstract classes are an excellent way to create planned inheritance hierarchies and also to use as non-leaf classes in class hierarchies.
3) Inheritance
According to the above example the new class (IOException), which is called the derived class or subclass, inherits the members of an existing class (Exception), which is called the base class or super-class. The class IOException can extend the functionality of the class Exception by adding new types and methods and by overriding existing ones. Just like abstraction is closely related with generalization, the inheritance is closely related with specialization. It is important to discuss those two concepts together with generalization to better understand and to reduce the complexity. One of the most important relationships among objects in the real world is specialization, which can be described as the is-a relationship. When we say that a dog is a mammal, we mean that the dog is a specialized kind of mammal. It has all the characteristics of any mammal (it bears live young, nurses with milk, has hair), but it specializes these characteristics to the familiar characteristics of canis domesticus. A cat is also a mammal. As such, we expect it to share certain characteristics with the dog that are generalized in Mammal, but to differ in those characteristics that are specialized in cats. The specialization and generalization relationships are both reciprocal and hierarchical. Specialization is just the other side of the generalization coin: Mammal generalizes what is common between dogs and cats, and dogs and cats specialize mammals to their own specific subtypes. Similarly, as an example you can say that both IOException and SecurityException are of type Exception. They have all characteristics and behaviors of an Exception, That mean the IOException is a specialized kind of Exception. ASecurityException is also an Exception. As such, we expect it to share certain characteristic with IOException that are generalized in Exception, but to differ in those characteristics that are specialized in SecurityExceptions. In other words, Exception generalizes the shared characteristics of both IOException and SecurityException, while IOExceptionand SecurityException specialize with their characteristics and behaviors. In OOP, the specialization relationship is implemented using the principle called inheritance. This is the most common and most natural and widely accepted way of implement this relationship.
4) Polymorphism
Polymorphisms is a generic term that means many shapes. More precisely Polymorphisms mean the ability to request that the same operations be performed by a wide range of different types of things. At times, I used to think that understanding Object Oriented Programming concepts have made it difficult since they have grouped under four main concepts, while each concept is closely related with one another. Hence one has to be extremely careful to correctly understand each concept separately, while understanding the way each related with other concepts. In OOP the polymorphisms is achieved by using many different techniques named method overloading, operator overloading and method overriding,
Method Overloading The method overloading is the ability to define several methods all with the same name.
Operator Overloading The operator overloading (less commonly known as ad-hoc polymorphisms) is a specific case of polymorphisms in which some or all of operators like +, - or == are treated as polymorphic functions and as such have different behaviors depending on the types of its arguments.
Method Overriding Method overriding is a language feature that allows a subclass to override a specific implementation of a method that is already provided by one of its super-classes. A subclass can give its own definition of methods but need to have the same signature as the method in its super-class. This means that when overriding a method the subclass's method has to have the same name and parameter list as the super-class's overridden method.
Question 28: Some basic questions regarding data types and their usage.
Tell me about yourself
Why do u want to work at Cerner? young crowd, relaxed environment for developers
What was the challenging work in your career
Question 29: What is a deadlock? Deadlock is defined as the permanent blocking of a set of processes that compete for system resources, including database records and communication lines. Unlike some other problems in multiprogramming systems, there is no efficient solution to the deadlock problem in the general case. Deadlock occurs when a set of processes are in a wait state, because each process is waiting for a resource that is held by some other waiting process. Therefore, all deadlocks involve conflicting resource needs by two or more processes.
Two general categories of resources can be distinguished: Reusable: something that can be safely used by one process at a time and is not depleted by that use. Processes obtain resources that they later release for reuse by others. E.g., CPU, memory, specific I/O devices, or files. Consumable: these can be created and destroyed. When a resource is acquired by a process, the resource ceases to exist. E.g., interrupts, signals, or messages.
One other taxonomy again identifies two types of resources: Preemptable: These can be taken away from the process owning it without ill effect (needs save/restore). E.g., memory or CPU. Non-preemptable: Cannot be taken away from its current owner without causing the computation to fail. E.g., printer or floppy disk. Deadlocks occur when sharing reusable and non-preemptable resources. Four conditions that must hold for a deadlock to be possible: Mutual exclusion: processes require exclusive control of its resources (not sharing). Hold and wait: process may wait for a resource while holding others. No preemption: process will not give up a resource until it is finished with it. Processes irreversible: unable to reset to an earlier state where resources not held. These can lead to Circular wait. Each process in the chain holds a resource requested by another.
Question 29: Name a team project you have completed and some of the difficulties that came with it.
Question 30: If you can change some features of your favorite programming language, what are they?
Question 31: Explain the differences between searching through a linked list vs. a binary tree? Binary Trees Medium complexity to implement (assuming you can't get them from a library) Inserts are O(logN) Lookups are O(logN)
Linked lists (unsorted) Low complexity to implement Inserts are O(1) Lookups are O(N)
Hash tables High complexity to implement Inserts are O(1) on average Lookups are O(1) on average
Question 32: What were the most difficult task you came across in any of your projects at your current workplace or during masters
Question 33: Explain to me an incident where you ran into a significant problem in a project you were working on, whether it was for a college course or for a job that you had during college, and also explain how you overcame that problem.
Question 34: Explain to me your largest achievement in a college course you were taking or at a job you had while you were in college.
Question 35: What is your process when tackling a research project?
Question 36: How do you go about finding the root cause of any issue?
Question 37: What do you ultimately want your career to take you?
Question 38: What was your greatest achievement?
Question 39: Name a time when a coworker didn't follow through with a task and how did you overcome that?
Question 40: If you were to have a choice between Systems Engineer and Software Engineer, which one would you pick?
Question 41: How would you get someone resistant to change to adapt to new technology?
Question 42: Describe a situation where the requirements of a project changed, but the deadline did not. How did resolve this?
Question 43: Give me an example of a situation where you had to deliver bad news to a superior.
Question 44: Describe the approach you took in a situation where you were required to teach something to one of your peers.
Question 45: Print a string Foo if a number is divisible by 5 ,Bar if divisible by 7 ,Foo Bar if divisible by 35 continue this process till number 75.
Question 46: Name a time you were involved in a sensitive situation and how you handled it.
Question 47: Tell me about a time you had a conflict with a coworker or manager, and what was the not result.
Question 48: Tell me a time when you had to deal with ambiguity on a project?
Question 49: Tell about a time where you had to solve a problem with little resources? What did you do and how did it work out?
Question 50: Tell me about a time when you had two conflicting tasks and how you went about solving it?
Question 51: Tell me about a time you had to work with little direction. //break the problem into components and that thing wont be new / knowledge management portal / approach not the solution
Question 52: Tell me about a time you disagreed with a team members decision.
Question 53: What was a time you underachieved on a project job?
Question 54: Describe a time when you had to do something out of the ordinary to achieve a goal for your team.
Question 55: How do you make your work environment very enjoyable?
Question 56: if i want to develop my skills, how do i develop myself how can i?
Question 57: what kind of knowledge management portal do you use?
FHIR DATA SOLUTIONS WITH AZURE FHIR SERVER, AZURE API FOR FHIR & AZURE HEALTH DATA SERVICES: INCLUDES END-TO-END DESIGN PHI DATA LAKE FOR EHR, OMICS, IMAGING, IOMT, WEARABLES & BUSINESS DATA