Use LEFT and RIGHT arrow keys to navigate between flashcards;
Use UP and DOWN arrow keys to flip the card;
H to show hint;
A reads text to speech;
36 Cards in this Set
- Front
- Back
|
OOP Languages: Definition & your experience on it
|
Is a programming paradigm based on the concept of "objects", which may contain data, in the form of fields, often known as attributes; and code, in the form of procedures, often known as methods.
|
|
|
Class
|
Is an extensible program-code-template for creating objects, providing initial values for state (member variables) and implementations of behavior (member functions or methods).
|
|
|
Inheritance
|
The process where one class acquires the properties (methods and fields) of another
|
|
|
Class access modifiers
|
The access modifiers in java specifies accessibility (scope) of a data member, method, constructor or class.There are 4 types of java access modifiers:privatedefaultprotectedpublic
|
|
|
Web services: SOAP
|
SOAP stands for Simple Object Access Protocol. It is a XML-based protocol for accessing web services.
|
|
|
Web services: REST uses & types |
REST stands for REpresentational State Transfer.REST is an architectural style for designing distributed systems. |
|
|
Web services: JAX - WS |
The Java API for XML Web Services (JAX-WS) is a Java programming language API for creating web services, particularly SOAP services. |
|
|
Polymorphism
|
Polymorphism is the ability of an object to take on many forms.
The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object. Any Java object that can pass more than one IS-A test is considered to be polymorphic. |
|
|
Hashmap / Hashtable |
Synchronization, Null keys and values, Iterating values , Fail fast iterator , Performance, Superclass . |
|
|
Garbage collector |
Is a program which runs on the Java Virtual Machine which gets rid of objects which are not being used by a Java application anymore. |
|
|
Multithreading |
A multi-threaded program contains two or more parts that can run concurrently and each part can handle a different task at the same time making optimal use of the available resources. |
|
|
Synchronization |
The capability to control the access of multiple threads to any shared resource. |
|
|
JSP
|
JavaServer Pages (JSP) is a technology that helps software developers create dynamically generated web pages based on HTML, XML, or other document types.
|
|
|
Servlets |
Is a Java program that extends the capabilities of a server. They most commonly implement applications hosted on Web servers. |
|
|
Servlets: Life cycle
|
Servlets - Life Cycle. The servlet is initialized by calling the init () method. The servlet calls service() method to process a client's request. The servlet is terminated by calling the destroy() method.
|
|
|
doGet()
|
The doGet and doPost methods in the Servlet API are methods for processing HTTP GET and POST requests respectively.
|
|
|
doPost()
|
The doGet and doPost methods in the Servlet API are methods for processing HTTP GET and POST requests respectively.
|
|
|
Web Applications structure
|
Web applications have a directory structure, which is fully accessible from a mapping to the application's document root (for example, /hello). The document root contains JSP files, HTML files, and static files such as image files.A WAR file (web archive file) contains a complete web application in compressed form.A special directory under the document root, WEB-INF, contains everything related to the application that is not in the public document tree of the application. No file contained in WEB-INF can be served directly to the client. The contents of WEB-INF include:/WEB-INF/classes/* - The directory for servlet and other classes./WEB-INF/web.xml and /WEB-INF/sun-web.xml - XML-based deployment descriptors that specify the web application configuration, including mappings, initialization parameters, and security constraints.The web application directory structure follows the structure outlined in the Java EE specification. The following example shows a sample directory structure of a simple web application.
|
|
|
Implicit Objects
|
These objects are created by JSP Engine during translation phase (while translating JSP to Servlet). They are being created inside service method so we can directly use them within Scriptlet without initializing and declaring them. There are total 9 implicit objects available in JSP.Implicit Objects and their corresponding classes:out javax.servlet.jsp.JspWriterrequest javax.servlet.http.HttpServletRequestresponse javax.servlet.http.HttpServletResponsesession javax.servlet.http.HttpSessionapplication javax.servlet.ServletContextexception javax.servlet.jsp.JspExceptionpage java.lang.ObjectpageContext javax.servlet.jsp.PageContextconfig javax.servlet.ServletConfig
|
|
|
Forward / Sendredirect
|
To simply explain the difference, response.sendRedirect("login.jsp");doesn't prepend the contextpath (refers to the application/module in which the servlet is bundled)but, whereas request.getRequestDispathcer("login.jsp").forward(request, response);will prepend the contextpath of the respective applicationFurthermore, Redirect request is used to redirect to resources to different servers or domains. This transfer of control task is delegated to the browser by the container. That is, the redirect sends a header back to the browser / client. This header contains the resource url to be redirected by the browser. Then the browser initiates a new request to the given url.Forward request is used to forward to resources available within the server from where the call is made. This transfer of control is done by the container internally and browser / client is not involved.
|
|
|
Stateless / Statefool Session Bean
|
Types of Session BeansSession beans are of three types: stateful, stateless, and singleton.Stateful Session BeansThe state of an object consists of the values of its instance variables. In a stateful session bean, the instance variables represent the state of a unique client/bean session. Because the client interacts (“talks”) with its bean, this state is often called the conversational state.As its name suggests, a session bean is similar to an interactive session. A session bean is not shared; it can have only one client, in the same way that an interactive session can have only one user. When the client terminates, its session bean appears to terminate and is no longer associated with the client.The state is retained for the duration of the client/bean session. If the client removes the bean, the session ends and the state disappears. This transient nature of the state is not a problem, however, because when the conversation between the client and the bean ends, there is no need to retain the state.Stateless Session BeansA stateless session bean does not maintain a conversational state with the client. When a client invokes the methods of a stateless bean, the bean’s instance variables may contain a state specific to that client but only for the duration of the invocation. When the method is finished, the client-specific state should not be retained. Clients may, however, change the state of instance variables in pooled stateless beans, and this state is held over to the next invocation of the pooled stateless bean. Except during method invocation, all instances of a stateless bean are equivalent, allowing the EJB container to assign an instance to any client. That is, the state of a stateless session bean should apply across all clients.Because they can support multiple clients, stateless session beans can offer better scalability for applications that require large numbers of clients. Typically, an application requires fewer stateless session beans than stateful session beans to support the same number of clients.A stateless session bean can implement a web service, but a stateful session bean cannot.Singleton Session BeansA singleton session bean is instantiated once per application and exists for the lifecycle of the application. Singleton session beans are designed for circumstances in which a single enterprise bean instance is shared across and concurrently accessed by clients.Singleton session beans offer similar functionality to stateless session beans but differ from them in that there is only one singleton session bean per application, as opposed to a pool of stateless session beans, any of which may respond to a client request. Like stateless session beans, singleton session beans can implement web service endpoints.Singleton session beans maintain their state between client invocations but are not required to maintain their state across server crashes or shutdowns.Applications that use a singleton session bean may specify that the singleton should be instantiated upon application startup, which allows the singleton to perform initialization tasks for the application. The singleton may perform cleanup tasks on application shutdown as well, because the singleton will operate throughout the lifecycle of the application.
|
|
|
Database Admin tool or IDE
|
An integrated development environment (IDE) is a software application that provides comprehensive facilities to computer programmers for software development. |
|
|
DBA: Store procedure
|
The main types of program units you can create with PL/SQL and store in the database are standalone procedures and functions, and packages. Once stored in the database, these PL/SQL components, collectively known as stored procedures, can be used as building blocks for several different applications. |
|
|
DBA: Function
|
Schema-level, or standalone subprograms such as functions (which return a value) and procedures (which do not return a value) are compiled and stored in an Oracle Database. Once compiled, they become stored procedure or stored function schema objects, and can be referenced or called by any applications connected to Oracle Database. |
|
|
DBA: Trigger
|
Triggers are similar to stored procedures. A trigger stored in the database can include SQL and PL/SQL or Java statements to run as a unit and can invoke stored procedures. ... Triggers are implicitly fired by Oracle when a triggering event occurs, no matter which user is connected or which application is being used.https://docs.oracle.com/cd/B19306_01/server.102/b14220/triggers.htm
|
|
|
Scrum: Definition
|
Scrum is an iterative and incremental agile software development framework for managing product development.[1][2] It defines "a flexible, holistic product development strategy where a development team works as a unit to reach a common goal",[3] challenges assumptions of the "traditional, sequential approach"[3] to product development, and enables teams to self-organize by encouraging physical co-location or close online collaboration of all team members, as well as daily face-to-face communication among all team members and disciplines involved.A key principle of Scrum is its recognition that during product development, the customers can change their minds about what they want and need (often called requirements volatility[4]), and that unpredicted challenges cannot be easily addressed in a traditional predictive or planned manner. As such, Scrum adopts an evidence-based empirical approach—accepting that the problem cannot be fully understood or defined, focusing instead on maximizing the team's ability to deliver quickly, to respond to emerging requirements and to adapt to evolving technologies and changes in market conditions.
|
|
|
Scrum: Advantages
|
https://www.scrumalliance.org/why-scrumThe ProsScrum ensures effective use of time and moneyLarge projects are divided into easily manageable sprintsDevelopments are coded and tested during the sprint reviewWorks well for fast-moving development projectsThe team gets clear visibility through scrum meetingsScrum, being agile, adopts feedback from customers and stakeholdersShort sprints enable changes based on feedback a lot more easilyThe individual effort of each team member is visible during daily scrum meetings |
|
|
Scrum: Sizing
|
Pendiente |
|
|
Spring: Components
|
Spring components integrate Spring Beans into the TIBCO ActiveMatrix platform.A Spring component is very similar to Java component, but its implementation can consist of more than one Java class. The classes are specified in a Spring Bean configuration file. Each Spring Bean corresponds to a Java class. In Spring components, each service, reference, and property is associated with a Bean (as opposed to all being associated with the same Java class in the case of Java components).
|
|
|
Spring: Inverse Control
|
IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse, hence the name Inversion of Control (IoC), of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes, or a mechanism such as the Service Locator pattern. |
|
|
Spring: Attributes
|
public @interface SessionAttributesAnnotation that indicates the session attributes that a specific handler uses.This will typically list the names of model attributes which should be transparently stored in the session or some conversational storage, serving as form-backing beans. Declared at the type level, applying to the model attributes that the annotated handler class operates on. |
|
|
Spring: Bean
|
A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. These beans are created with the configuration metadata that you supply to the container, for example, in the form of XML definitions. |
|
|
AOP
|
Aspect-Oriented Programming (AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. |
|
|
Hibernate: Purpose
|
Hibernate (framework) Hibernate ORM (Hibernate in short) is an object-relational mapping tool for the Java programming language. It provides a framework for mapping an object-oriented domain model to a relational database.
Hibernate is a pure Java object-relational mapping and persistence framework that allows you to map plain old Java objects to relational database tables using XML configuration files. |
|
|
Hibernate: inheritance
|
Defines the inheritance strategy to be used for an entity class hierarchy. We can map the inheritance hierarchy classes with the table of the database. |
|
|
Hibernate: Strategies
|
There are three inheritance mapping strategies defined in the hibernate:Table Per HierarchyTable Per Concrete classTable Per Subclass SINGLE TABLE STRATEGY, WITH TABLE PER CLASS STRATEGY, WITH JOINED STRATEGY |
