text:
Certified ScrumMaster (CSM) Certification
Certified Scrum Product Owner(CSPO) Certification
Professional Scrum Master(PSM) Certification
SAFe5 Scrum Master with SSM Certification
Implementing SAFe 5.1 with SPC Certification
SAFe 5 Release Train Engineer (RTE) Certification
SAFe POPM Certification
Kanban Certification(KMP I: Kanban System Design)
ICP-ACC Certification
Professional Scrum Product Owner Level I (PSPO) Training
Accreditation Bodies
PMP Certification Training
Change Management Certification
Project Management Techniques Training
PgMP Certification Training
PfMP Certification Training
Oracle Primavera P6 Certification Training
Data Science Career Track Bootcamp
Python for Data Science
Machine Learning with R
Deep Learning Certification Training
Career Track
Enhance your career prospects with our Data Science Training
Embark on a Data Science career with our Data Analyst Bootcamp
Elevate your Data Science career with our AI Engineer Bootcamp
Docker with Kubernetes Training
Kubernetes Training
Docker Training
DevOps Training
DevOps Leader Training
Jenkins Training
Openstack Training
Ansible Certification
Puppet Training
Aws Certified Solutions Architect - Associate
Aws Cloud Practitioner Certification
Aws Devops Certification
Azure Fundamentals Certification
Azure Administrator Certification
Azure Data Engineer Certification
Azure Solution Architect Certification
Azure Devops Certification
Sysops Certification
TOGAF Certification
ITIL Certification Training (Foundation)
ITIL Practitioner Certification Training
ITIL Intermediate Service Strategy
ITIL Intermediate Service Transition Certification
ITIL Intermediate Continual Service Improvement
ITIL Intermediate Service Operation Certification
ITIL® Intermediate Service Design
ITIL Managing Across The Lifecycle Training
ITIL® Intermediate Operational Support and Analysis (OSA)
ITIL® Intermediate Planning, Protection and Optimization (PPO)
Full-Stack [Java Stack] Bootcamp
Backend Development Bootcamp
React Training
Node JS Training
Angular Training (Version 12)
PHP and MySQL Training
Work on real-world projects, build practical developer skills
Hands-on, work experience-based learning
Start building in-demand tech skills
Faang/Maang Interview Preparation
Advanced Python Course
R Programming Language Certification
Advanced R Course
Java Deep Dive
Scala Training
Advanced Scala
C# Training
Microsoft .Net Framework Training
Data Visualisation with Tableau Certification
Microsoft Power BI Certification
TIBCO Spotfire Training
Data Visualisation with Qlikview Certification
Sisense BI Certification
Blockchain Professional Certification
Blockchain Solutions Architect Certification
Blockchain Security Engineer Certification
Blockchain Quality Engineer Certification
Blockchain 101 Certification
Hadoop Administration Course
Big Data and Hadoop Course
Big Data Analytics Course
Apache Spark and Scala Training
Apache Storm Training
Apache Kafka Training
Machine Learning with Apache Mahout Training
Comprehensive Pig Training
Comprehensive Hive Training
IOS Development Course
React Native Course
Ionic Training
Xamarin Studio Training
Xamarin Certification
Opengl Training
NativeScript for Mobile App Development
ISTQB Foundation Certification
ISTQB Advanced Level Security Tester Training
ISTQB Advanced Level Test Manager Certification
ISTQB Advanced Level Test Analyst Certification
ISTQB Advanced Level Technical Test Analyst Certification
Silk Test Workbench Training
Automation Testing using TestComplete Training
Cucumber Training
Functional Testing Using Ranorex Training
Teradata Certification Training
CBAP Certification
ECBA Certification
CCBA Certification
Business Case Writing course
PMI-PBA Certification
Agile Business Analysis Certification
Six Sigma Black Belt Certification
Six Sigma Yellow Belt Certification
CMMIV1.3 Training
Ethical Hacking Certification (CEH v12)
CISA Certification
CISM Certification
CISSP Certification
CCSP Certification
CIPP/E-Certification Training
COBIT5 Foundation Certification
PCI DSS Certification
Introduction to Forensic
Web Analytics Course
Content Marketing Course
E-Mail Marketing Course
Display Advertizing Course
Conversion Optimization Course
Mobile Marketing Course
Introduction to the European Union General Data Protection Regulation
FRM® Level 1 Certification
FRM®Level 2 Certification
RISK MANAGEMENT AND INTERNAL CONTROLS
Data Protection-Associate
Credit Risk Management
Budget Analysis and Forecasting
IFRS for SMEs
Diploma In International Financial Reporting
Certificate in International Financial Reporting
Finance for Non-Finance Managers
Financial Modeling with Excel
Auditing and Assurance
MySQL Course
Redis Certification
MongoDB Developer Course
Postgresql Training
Neo4j Certification
Mariadb Course
Hbase Training
MongoDB Administrator Course
Communication Course
International Certificate In Advanced Leadership Skills
Soft Skills for Corporate Career Growth
Soft Skills Leadership Training
Building Team Trust Workshop
CompTIA Cloud Essentials Certification
CompTIA Cloud+ Certification
CompTIA Mobility+ Certification
CompTIA Network+ Certification
CompTIA Security+ Certification
CompTIA Server+ Certification
CompTIA Project+ Certification
MS Excel 2010
Advanced Excel 2013
Certified Supply Chain Professional
Software Estimation and Measurement Using IFPUG FPA
Software Size Estimation and Measurement using IFPUG FPA & SNAP
Leading and Delivering World Class Product Development Course
Product Management and Product Marketing for Telecoms IT and Software
Flow Measurement and Custody Transfer Training Course
OOPS Interview Questions and Answers Programming
50 Question(s)
30 Mins of Read
Object-oriented programming is a popular programming paradigm that enables developers to model problems and solutions in terms of objects. As someone who is looking to enter the world of programming, you may be wondering what types of Object oriented Programming interview questions you will be asked during an interview for your Object Oriented Programming (OOP) position. While there is no one-size-fits-all answer to this question, there are a few key topics that are likely to come up. Here, we'll review some common OOPS concepts interview questions and provide answers to help you prepare for your next interview. By being prepared to answer these Object oriented interview questions, you'll demonstrate your knowledge of object-oriented programming and give yourself a better chance of impressing potential employers. To get a better grasp onto the basic section, you must join a few Programming courses along with your interview preparations.
OOPS Interview Questions Programming
What do you mean by Object Oriented Programming?
Object-Oriented Programming, or OOP for short, is a style of programming that encourages the use of objects and methods. In object-oriented programming, programmers define not only the data type of a data structure, but also the types of operations (methods) that can be applied to the data structure. In addition, object-oriented programming languages typically provide mechanisms for organizing code into modular units (objects), which can be reused in other programs.
One advantage of object-oriented programming is that it can help to promote code reuse. For example, if you have written a method for sorting an array of integers, you can easily reuse that method in another program by creating a new object that uses the sorting method. Additionally, object-oriented programming can help to make code more maintainable and easier to understand. By encapsulating data and methods into logical units (objects), programmers can more easily modularize their code and make changes in one area without affecting other areas of the codebase.
Add Bookmark Add Bookmark
What is the need for Object Oriented Programming?
Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which can contain data, in the form of fields, and code, in the form of procedures. A feature of objects is an object's behavior, or its ability to perform actions. Object-oriented programming aims to implement real-world entities like inheritance, hiding, polymorphism etc. in programming.
The main purpose of OOP is to bind together code and data in a manner that makes it difficult to modify the data without affecting the code and vice versa. Most popularly known languages which follow the OOP paradigm are Java, C++ etc. Still confused? Let's take an example:
Consider a scenario where you are required to develop software for a bank. This software will maintain the records of all the customers who have an account in that particular bank. So basically you need to store their account number, name, date of birth, address, phone number etc. You will also need to provide them certain services like cash withdrawal, money transfer, balance enquiry etc.
Now think about how would you approach this problem if you had to use conventional programming methodologies? You would most probably start by creating individual variables like account Number, customer Name etc. which would store respective values. But as the number of customers grows it becomes really difficult to keep track of all these variables and manipulating them every time you need to perform some operation on them becomes a nightmare.
Also there is always a possibility that some other part of your program might unintentionally modify these values which can lead to serious consequences. Suppose you want to change the name of one customer, then you need to go through your entire program and make sure that there is no other variable whose value is getting modified because of this change(which is bound to happen). This can be a really cumbersome and time consuming task if your program is large enough. Now let's see how OOP can help us tackle this problem in a much more efficient manner:
You can create a Class called Customer which will act as a blueprint for all the future objects(or Customers) that you want to create. This class will contain certain properties like customer Name, customer Id, age etc. which will be common for all the objects belonging to this class(i.e all customers).
You can also put certain methods inside this class which performs operations on these properties(like getDetails(), updateDetails() etc). So now whenever you want to create an object(or customer), you just have to instantiate this class and provide initial values for all its properties. These property values can be different for different objects but they will access the same set of methods(or operations).
So now even if you want to change the name of one customer ,you can directly refer to that particular object and change its name property without affecting any other part of your program. This not only makes your code more readable but also less prone to errors to errors thus making it more reliable. Hence we can say that OOP provides better flexibility as well as security as compared to traditional programming paradigms making it more suitable for developing large scale applications.
What are some common Object Oriented Programming languages?
There are many different Object Oriented Programming languages, but some of the most popular ones include Java, Python, and C++. Each language has its own unique set of features and syntax, but they all share some common characteristics. For example, all Object Oriented Programming languages allow developers to create objects that contain both data and code. This allows for a more modular approach to programming, making it easier to reuse code and maintain a complex program.
In addition, all Object Oriented Programming languages support inheritance, which allows developers to create new classes that are based on existing ones. This can be a very powerful tool for creating reusable code libraries. Finally, all Object Oriented Programming languages provide some form of data encapsulation, which helps to protect the data within an object from being accessed or modified by other parts of the program.
What is meant by Structured Programming?
Structured programming is a programming paradigm that promotes logical correctness, program modularity, and code readability. It is based on the concept of control flow, which dictates the order in which the individual statements, or instructions, in a program are executed. In structured programming, this control flow is typically implemented through the use of subroutines, or blocks of code that can be invoked from other parts of the program.
This modularization makes it easier to understand and modify large programs, as well as to reuse code. As a result, structured programming is considered to be a more efficient and effective way of coding compared to other paradigms, such as unstructured programming.
What is a finally block?
A finally block is a block of code that follows a try block or catch block. A finally block always executes, whether or not an exception is thrown. This ensures that the finally block is always executed even if an unexpected exception occurs. Finally blocks are used to close resources, such as files or database connections, that were opened in the try block.
It is important to note that the finally block will not execute if the program exits the try or catch blocks before reaching the end of the block. Finally blocks are also used to perform cleanup tasks, such as removing temporary files or deleting unused data structures. Finally blocks are typically used in conjunction with try-catch statements to handle exceptions. However, it is important to note that finally blocks are not required to have a corresponding catch block. Finally blocks can also be used without try-catch statements, but in this case they will only execute if no exception is thrown.
How does procedural programming differ from object-oriented programming?
Object-oriented programming (OOP) is a programming paradigm that is based on the concept of objects. Objects are data structures that contain both data and methods. In contrast, procedural programming is based on the idea of procedures, or routines, which are blocks of code that carry out a specific task. OOP allows for greater flexibility and reusability than procedural programming.
With OOP, you can create objects that can be used in different ways and reused in different programs. OOP also makes it easier to maintain and modify code because related code is grouped together in objects. In addition, OOP allows for polymorphism, or the ability to create software that can be used with different types of objects. For these reasons, OOP is generally considered to be a more powerful and flexible paradigm than procedural programming.
What is dynamic polymorphism?
Dynamic polymorphism is a feature of some programming languages that allows for variables, functions, and objects to be dynamically bound to different implementations at runtime. This can be useful for creating software that is more extensible and flexible, as well as for libraries that need to support a variety of different types. In some cases, dynamic polymorphism can also lead to more efficient code execution.
For example, if a function needs to be called on an object that may have multiple subtypes, the function can be dynamically bound to the appropriate implementation based on the type of the object at runtime. This avoids the need to check the object's type before calling the function, which can save time and resources.
OOPs have limitations, what are they?
While object oriented programming offers many advantages, it also has a few potential limitations. One issue is that OOPs can sometimes lead to excessive complexity, making code difficult to understand and debug. Additionally, because object-oriented languages are designed to model real-world objects, they can sometimes be less efficient than other programming paradigms.
Finally, object-oriented programming can sometimes make it challenging to accurately estimate the time and resources required for development. Despite these potential drawbacks, object oriented programming remains a popular choice for many developers due to its flexibility and ease of use.
What is the use of 'finalize'?
The Finalize method is used to perform cleanup operations on an object before it is destroyed. The peak of an object's lifetime is when it becomes eligible for garbage collection, at which point the runtime will call the finalize method on the object. This gives the object a chance to free up any resources it is holding (such as open handles or files) before it is removed from memory. In most cases, an object will not need to override the finalize method, as the default implementation will be sufficient.
However, there are some cases where it may be necessary to provide a custom finalize method. For example, if an object is holding onto a large amount of memory, it may be important to release that memory in the finalize method so that it can be reclaimed by the GC. Alternatively, if an object is using a native resource (such as a file descriptor), it may be necessary to close that resource in the finalize method to prevent leaks.
What are virtual functions?
In object-oriented programming, a virtual function or virtual method is a function or method whose behavior can be overridden within an inheriting class by a function with the same signature, but with a different implementation.
Polymorphism is the ability to create a new object that has the same interface as an existing object, but with different behavior. A common use for virtual functions is to achieve polymorphic behavior. Inheritance allows derived classes to override virtual functions of their base class. This means that when a virtual function is called on an object, the actual function executed will be determined by the type of the object, not by its declared type. This can be useful when objects of different types need to be processed in the same way, but each type requires different internal processing.
For example, consider a class Shape that has a virtual function Draw(). Different kinds of shapes will have different implementations of Draw(). A Circle class might draw itself as a filled circle, while a Square class might draw itself as a four-sided polygon. If an application needs to draw many shapes, it can store them in an array or list of pointers to Shape; each element in the array can be any kind of shape. When it is time to draw them, the application can simply call Draw() on each element in the array, and each shape will draw itself appropriately. This would not be possible if Draw() were not a virtual function.
It should be noted that non-virtual functions are not statically bound; that is, their behavior is still determined by the runtime type of the object. The difference is that non-virtual functions are not intended to be overridden and thus their bindings are decided when the program is compiled (static binding), while virtual functions are intended to be overridden and their bindings are decided when the program executes (dynamic binding).
There are some cases where dynamic binding is undesirable because it incurs run-time overhead (due to the need to fetch and execute the correct code for the actual runtime type of an object) and because it can make code harder to understand (by making it harder to predict which code will actually execute in response to a given call).
In these cases, programmers can declare virtual functions as non-virtual, which prevents derived classes from overriding them and forces early binding. Another option is to use template polymorphism instead of inheritance-based polymorphism.
What are the access modifiers?
In object-oriented programming, there are several different ways to restrict access to members of a class. The most common access modifiers are public, private, and protected. Public members can be accessed by anyone. Private members can only be accessed by other members of the same class.
Protected members can be accessed by members of the same class and by subclasses. In addition, there are two less common access modifiers: internal and protected internal. Internal members can only be accessed by other members of the same assembly. Protected internal members can be accessed by members of the same assembly and by subclasses.
Access modifiers are an important part of object-oriented programming because they help to control the visibility of class members. By properly using access modifiers, programmers can improve the organization of their code and reduce the chances of errors.
What is hybrid inheritance?
Object-oriented programming is a programming paradigm that uses objects and their interactions to design and program applications. Hybrid inheritance is a combination of two or more types of inheritance. In hybrid inheritance, a derived class inherits from more than one base class. The most common type of hybrid inheritance is a combination of single and multiple inheritance. Multiple inheritance occurs when a derived class inherits from two or more base classes. Single inheritance occurs when a derived class inherits from only one base class.
Hybrid inheritance can be used to model relationships that cannot be easily expressed using other types of inheritance. For example, consider a scenario where you have a class hierarchy for shapes that includes a base Shape class and derived classes such as Circle, Square, and Triangle. You could create a separate hierarchy for colors with a base Color class and derived classes such as Red, Blue, and Green. If you wanted to create a shape that was both red and triangular, you could use hybrid inheritance to combine the Shape::Triangle and Color::Red classes.
What are the key features of OOPs?
There are four main features of OOPs which are encapsulation, abstraction, inheritance, and polymorphism.
Encapsulation is the process of hiding the implementation details from the users. It is used to achieve data hiding to protect the Object's data from being accessed by the external code. In encapsulation, the data and related methods are bundled together as a single unit which is known as an Object.
Abstraction is a process of hiding the complexity from the users and showing them only the functionality. It enables the user to work with an Object without knowing its internal implementation details. In simple words, it means representing essential features without including implementation details.
Inheritance is a concept of OOPs which allows one Object to inherit the properties of another Object. It helps in reusing the code and saving memory space. Inheritance allows us to create a new class by using the properties of an existing class. The existing class is known as base class or parent class while the new class is known as derived or child class.
Polymorphism is a concept of OOPs which allows us to perform a single action in different ways. In other words, we can define multiple methods with the same name but with different parameters list (number of parameters, type of parameters). Polymorphism allows us to write a program in a more efficient way because it eliminates the need for writing different codes for performing similar operations on different data types.
How do OOP and SOP differ?
Object Oriented Programming (OOP) and Structured Oriented Programming (SOP) are two common methods used in software development. Both serve the purpose of allowing developers to write applications that are optimized and easy to maintain, but they have several important differences. OOP is focused on using objects and classes to organize code while SOP is centered on working with functions or blocks of logic to achieve a certain task.
OOP also allows for data abstraction and code reuse, meaning that commonly used code can be kept as a "class" which can be reused anywhere needed without redeclaring it each time. It also permits code encapsulation which groups related data and behaviors together into a single unit making it easier for others to understand how the program works.
While SOP does not encourage abstraction or re-usability of code, it is often ideal for programs that simply need to carry out specific tasks in an ordered sequence such as mathematical calculations or file manager operations. Ultimately, each approach has its own strengths and weaknesses which must be taken into consideration when choosing an appropriate method for developing software applications.
What is static polymorphism?
Static polymorphism, also known as compile-time polymorphism, is a type of subroutine binding attribute in object-oriented programming languages. It occurs when the correct version of a method or function to execute is determined at the point of compilation, rather than at runtime. This capability allows developers to create applications that bind both concrete classes and virtual methods together without in-depth knowledge of the method's code. Static polymorphism carries its advantages by reducing the amount of time and effort needed to bind one set of methods from another since all titles are established beforehand.
Additionally, it helps simplify debugging processes since objects show their exact type which can be used for straightforward reference purposes. However, static polymorphism also carries its limitation in that there is often only a single concrete form of a method available at runtime and it cannot be changed once compiled. All in all, static polymorphism represents an important concept which allows subroutines to remain accessible while keeping each implementation discreet from one another.
It enables sophisticated implementations without industry knowledge in order to boost productivity but with the cost of flexibility when regarding specific method execution habits. Thus it has become an essential subject within Object Oriented Programming interviews.
What is a superclass?
Superclasses are classes in Object Oriented Programming that provide a common definition of methods and properties that can be inherited by their subclasses. They serve as the template for objects to subclass its properties and methods, providing shared functionality. A superclass is defined primarily through its access modifiers - public, protected, private - which indicate what type of data and elements can be accessed by other objects that the class is associated with.
Each method and data definition within the superclass only needs to be declared once, freeing up time from having to recreate them multiple times for each subclass. Superclasses are incredibly useful for enabling code reuse across an application's framework, as well as implementation flexibility for new objects or characteristics.
As a result, when developing programs using object-oriented programming (OOP), it's important to plan out your inheritance tree by considering the need for creating concise superclasses for reusing elements without repeating code.
What is a copy constructor?
A copy constructor is a type of constructor defined in the C++ programming language. It is designed to create an object based on another object, and it is usually used when the user attempts to pass objects by value rather than reference.
A copy constructor helps ensure that the data contained within the source object is properly copied into new space allocated for a copy of the source object. The signature of a copy constructor will generally include at least one parameter, which will be an address pointing to an instance of its class.
Typically, this address points to the source object being copied, although it can also point to other objects that can provide resources such as allocators or cast types for construction purposes. Generally speaking, when used correctly, a well-implemented copy constructor allows for efficient memory management and copying of objects between scope boundaries or function calls. Depending on its implementation, it may also help with error detection or provide additional flexibility in situations where passing by value may better suit application requirements.
Furthermore, copy constructors are often employed when performing deep copies as opposed to shallow ones. This practice ensures that even operations done on copies of objects do not modify their original values thus generating robust code and making for easy debugging during development stages. In short, knowing how to implement and use a copy constructor correctly is essential in any software written using C++ programming language and having knowledge of them might just be what you need when doing well at your next Object Oriented Programming interview question!
What is exception handling?
Exception handling is an essential concept in object-oriented programming (OOP). Put simply, it is a way of managing errors that arise during the execution of a program. Such errors can be caused by incorrect user input, database access issues, lost network connections and other unforeseen events. By using exception handling, these errors can be quickly identified and a suitable course of action taken to gracefully handle the problem.
Most commonly, exception handling takes the form of try/catch blocks where code is executed inside a try block first; if an error occurs, the catch block contains code that handles or reacts to errors in a predetermined way such as printing out an appropriate error message or restarting the program. Exception handling can also be used alongside validation rules to ensure that data passed into programs meet minimum requirements before being processed. As such, it can help save time and increase reliability when used correctly.
What is the difference between the public, private & protected access modifiers?
When using object-oriented programming, access modifiers are used to limit the scope of the class's members. The three most commonly used modifiers are public, private, and protected. By default, classes use the private modifier to protect their members from outside alterations. This means that only members of that class can access private variables or methods directly.
On the other hand, when a class member is given the public modifier, it is accessible by other objects inside and outside of that class. Protected modifiers work similarly to private, but they allow external subclasses to access the member as well. Ultimately designing classes with different kinds of modifiers depends on which features should remain hidden and which should be visible to both local and external classes—and following these guidelines can help support good software design practices in any OOP project.
What is Encapsulation?
Encapsulation is a core concept of object-oriented programming which allows developers to create objects that are data containers. This way, an object's state and behavior are packaged together, meaning they can be accessed and modified using a single interface. Encapsulation also includes the hiding of internal details of an object, so that only its externally defined interfaces are exposed to users.
Ultimately, encapsulation helps promote code reusability by ensuring that the structure and inner workings of an object remain hidden from external code while still allowing it to respond to certain requests. In addition to promoting reusability, encapsulation also helps improve reliability in programs by providing built-in protection against unwanted interaction between different parts of the program.
In essence, it provides a further layer of abstraction between the internal components and their external interactions to ensure better security for critical operations. Clearly, this makes encapsulation essential for creating robust and reliable software applications.
Can you create an instance of an abstract class?
The answer to this Object Oriented Programming (OOP) interview question is No. Generally speaking, abstract classes cannot have an instance associated with them, due to the fact that they consist of one or more abstract methods and do not contain an implementation for any of these methods. An abstract class is typically used as a basis for implementing higher-level objects which must use the same common framework or method calls; however, it cannot be used directly.
Firstly, because it lacks an implementation of any of its methods that it may extend or abstraction, and secondly, because any class extending from such a base will require a constructor specific to it. Therefore when trying to instantiate an abstract class, the compiler will throw an error as there is no valid constructor available since the definition of said class does not provide code regarding how to construct itself within memory.
What is Abstraction? How can you achieve data abstraction?
Abstraction is an important concept in object-oriented programming that involves the development of classes, objects, and data structures to separate out the details associated with certain types of data. By abstracting away from the details, we can create structures that are more flexible and easier to maintain.
Data abstraction can be achieved through the use of interfaces, which define the base set of methods needed for a particular type of data structure or class. For example, if we need to create a database of phone numbers, an interface might be defined that requires the implementation of methods related to retrieving and saving data; the details of how these methods work will be handled by any concrete database class created from the interface.
Additionally, abstract classes can help provide structure and re-usability by defining key features and behaviors shared by many subclasses without having to code each behavior individually. This approach allows us to build on existing code rather than rewriting from scratch every time. By properly employing abstraction techniques in our object oriented programming, we can improve efficiency and make our applications more robust.
What is the difference between an error & an exception?
An error typically occurs when there is a mistake in your code, such as a syntax error or a logical bug. This type of issue will cause your program to terminate abruptly because the runtime environment cannot interpret and execute your instructions correctly. On the other hand, an exception happens when you encounter a situation that requires special attention from the user or developer.
For example, if you attempt to access an element beyond the range of an array, then an "IndexOutOfBoundsException" will be thrown. In this scenario, the program does not immediately terminate; instead, it will pause at this point until you can respond accordingly. The ability to handle exceptions gracefully is a crucial feature of OOP programming and can save untold hours of debugging and troubleshooting time. With these points in mind, one should take care to understand how errors and exceptions are differentiated during their development workflow or interview process.
What is Garbage Collection(GC)?
Garbage Collection (GC) is a process by which unreachable objects or memory that is no longer being used or referenced is automatically removed from the program. GC typically works iteratively, first identifying the "garbage" and then freeing up memory for reuse. To identify garbage, GC will inspect the references used in an application and determine which objects can no longer be accessed via those references.
This could be due to a variable being referenced by another variable that has since been deleted, or a data structure being emptied so that its elements are unreachable. By eliminating these useless objects and reclaiming their memory, GC helps keep applications running smoothly while avoiding "memory leaks."
Differentiate between a class and a method.
Object-oriented programming (OOP) is a vital part of software engineering, and there are many concepts that programmers need to know. Two of those concepts are classes and methods. Understanding the difference between them is useful both when writing code and when interviewing for coding jobs.
A class is a template for objects, or real-world concepts, that are used in your code. It contains variables and functions, which store information and execute instructions respectively. Think of a class as a blueprint for how data should be structured within an object. An example would be defining a "person" class with characteristics such as height or age.
Methods, on the other hand, are functions found in classes responsible for performing some task on an object. Put simply, they are commands that cause something to happen within an object, such as calculating the person's BMI from their height and weight values stored in the class' variables.
Classes have methods because it's generally easier to reuse chunks of logic multiple times than to completely rewrite it every time you need something similar. They also allow for maintainability; if changes occur within a method, it can easily be adjusted because all instances using that specific method refer back to one central one instead of needing individual rewrites everywhere.
What is Cohesion in OOP?
In Object Oriented Programming, cohesion refers to the degree to which the elements of a class work together to fulfill a single responsibility. A class with high cohesion is tightly focused and its methods are highly cohesive with one another. In contrast, a class with low cohesion is more sprawling and its methods are only loosely related.
Cohesion is considered an important design principle in OOP because it can impact the understandability, maintainability, and reusability of a class. When designing classes, developers should aim for high cohesion in order to make their code more understandable, maintainable, and reusable.
One way to achieve high cohesion is to use the Single Responsibility Principle, which states that a class should only have one responsibility. This helps to ensure that all of the methods in a class are closely related and working together towards a common goal.
Another way to achieve high cohesion is by keeping your methods short and focused. Long methods tend to be more complex and difficult to understand. By keeping your methods short, you can make it easier for yourself and others to understand what each method does and how it fits into the overall functionality of the class.
Finally, you can also achieve high cohesion by using well-defined interfaces. Interfaces help to clearly specify the contract that a class must adhere to. This helps to ensure that all of the methods in a class are working together in a consistent way. By following these guidelines, you can help to ensure that your classes have high cohesion and are more understandable, maintainable, and reusable.
How do methods and functions differ in OOP context?
There are a few key ways in which methods and functions differ in an OOP context.
First, methods are always associated with a specific object, while functions are not. This means that a method can access the data within its associated object, while a function cannot.
Second, methods can be overridden, while functions cannot. This means that a subclass can define its own version of a method, which will be used in place of the parent class's method.
Finally, methods can be overloaded, while functions cannot. This means that a single method can have multiple implementations, each of which is invoked depending on the number and type of arguments passed to the method. These differences are important to keep in mind when working with objects in an OOP context.
What is Inheritance?
Inheritance is when an Object or Class "is a'' kind of another Object or Class . For example a car "is a '' vehicle. So we can say inheritance is one way to reuse code. When one Object or Class inherits from another, the former acquires all the Properties and Methods defined in the latter, in addition to any it may have defined itself. So basically inheritance provides extensibility. That's one advantage it has over Composition.
However multiple inheritance (when an Object or Class inherits from more than one parents) leads to diamond problem among other issues, so most languages including java do not support multiple inheritance at all while some like C++ support multiple inheritance with restrictions In simple terms ,inheritance means existing things gained some more properties or behaviors while composition means putting existing things together to get something new .
Java only supports single inheritance i.e., a child can only have one parent. However multiple inheritance is supported through Interfaces in java 8 which we will see later on. Also java does not support hierarchical Inheritance where multiple levels in hierarchy could lead to ambiguity. Composition should be used whenever possible rather than Inheritance as it avoids ambiguity and is more flexible .It's best practice to avoid using Inheritance unless it's really required.
What are pure virtual functions?
In OOP, a virtual function is defined as one that is declared in a base class with the intention that derived classes will later override its implementation. Pure virtual functions take this one step further; they provide an interface for derived classes to be able to declare their own implementations, while not providing anybody or implementations themselves. The defining keyword "pure" means that it must be implemented by an overriding class in order for the program to compile properly, otherwise there will be an error.
Pure virtual functions serve as a sort of template or placeholder, indicating that derived classes need their own implementations but not providing them itself. This allows for greater flexibility and polymorphism, as different types of objects can act differently on the same type of data or perform different operations at the same point in code. By utilizing pure virtual functions within your project's OOP architecture, you can create a program with more robustness and extensibility.
Which OOPS concept is used as the reuse mechanism?
Object-Oriented Programming (OOP) has become an integral part of modern software programming, and the concept of code reuse is a key factor in this. Reuse enables developers to quickly build on existing projects without needing to write a large amount of new code from scratch. One key OOP feature used as a reuse mechanism is inheritance.
Inheritance describes how objects can acquire properties from parent objects, allowing extended classes to share behaviors and properties with their base class without needing to reconstruct that behavior every time. This not only helps teams develop more quickly, but also foster code integrity and maintainability. Other important OOP concepts that help developers achieve reuse include polymorphism, encapsulation, and interfaces.
What is Coupling in OOP, & why is it important?
Coupling is a term used in the Object Oriented Programming (OOP) field to refer to how cohesive linked modules are. In other words, it helps describe the degree of dependency between classes, subroutines and overall libraries. Coupling is divided into two categories: high and low coupling.
High coupling occurs when there is direct interaction between connected components, meaning any changes made within one module requires changes in its partner module as well. It results in complexity as each module must remain aware of ongoing updates made in the other connected module.
Low coupling on the other hand allows for greater flexibility and scalability of connected components, as they can easily be tweaked separately without requiring updates across different modules. This makes system maintenance much simpler, which improves code organization and testing capabilities resulting in more reliable functioning software.
What are the levels of data abstraction?
Data abstraction is one of the pillars of Object Oriented Programming, and it's also a key interview question for many programming roles. Simply put, data abstraction is a process that allows us to hide irrelevant information from users, focusing instead on the essential features of a given set of data. When performing data abstraction, there are three distinct levels that can be identified: physical level, logical level and view level.
At the physical level, we focus on the actual implementation of the data structure; this involves working with the bits and bytes outside of any programming language environment. At the logical level, we are concerned with how data elements relate to each other. For example, if we have two columns containing numeric values related to time (e.g., hours and minutes), we might group them together in order to calculate some result (e.g., total duration).
Finally, at the view level we look at what information is necessary for interactions between entities – such as humans interacting with computers – and filter out everything else. Understanding these three levels of data abstraction will help you answer this type of question in an interview setting confidently.
Can you specify the accessibility modifier for methods inside the interface?
In object-oriented programming, the accessibility modifier is used to determine which methods may be accessed from outside of a class. In the case of an interface, all methods declared in the interface must have the same access modifier and this must be specified when declaring each method. The default accessibility for any method inside an interface is public, meaning that it can be accessed both inside and outside of the implementing class.
However, if another access modifier such as private or protected is declared explicitly then available visibility decreases accordingly. It's important to keep in mind that regardless of what access modifier is specified, interfaces are always published and can never be hidden.
What is the significance of a virtual destructor?
A virtual destructor provides the ability to delete an instance of a derived class without knowing its exact type, thus ensuring correct memory management. The virtual keyword in a destructor signifies that derived classes can override the base class's destructor and therefore the most-derived destructor will get called when using these types of destructors.
This is especially useful when dealing with objects of different types from a base class, as it allows all such objects to be deleted automatically and correctly at the same time instead of having to manually identify and delete each object type in sequence.
An added benefit of virtual destructors is that they ensure that any resources used by a derived class are also released correctly and efficiently; for example, if a derived class uses new to create additional objects, those objects will be properly deleted when the parent object's virtual destructor is called.
What are the characteristics of an abstract class?
An abstract class is a class that cannot be instantiated, meaning that it cannot be used to create objects. Instead, it is meant to be subclassed by other classes. An abstract class can have abstract methods, which are methods that do not have an implementation. This means that the subclass must provide an implementation for the abstract method.
When subclassing an abstract class, the subclass must provide implementations for all of the abstract methods in the superclass. An abstract class can also have non-abstract methods, which means that the subclass can inherit the implementation from the superclass. Abstract classes are used to provide a general template for a group of related classes.
For example, if you had a shape hierarchy, you could create an abstract Shape class with subclasses such as Circle and Rectangle. The Shape class would define general characteristics that are shared by all shapes, such as having a certain number of sides. The subclasses would then define specific characteristics, such as being either a circle or a rectangle. By using an abstract class, you can ensure that all shapes have certain characteristics while still allowing each shape to have its own unique properties.
Similarly, an interface is a type of class that cannot be instantiated. Interfaces only contain static constants and abstract methods. A class can implement an interface, which means that the class must provide an implementation for all of the methods in the interface. Interfaces are used to define a set of operations that must be supported by any class that implements the interface.
For example, you could create an interface called Movable with methods such as move Forward and turn Left. Any object that implements the Movable interface would then be able to perform those actions. Interfaces are useful for defining contracts between different components of a system. By adherence to an interface, two components can work together even if they are not aware of each other's details.
An abstract class is different from an interface in several ways. First, an abstract class can contain both abstract and non-abstract methods whereas an interface can only contain abstract methods. Second, a class can only implement one interface but it can extend multiple classes. Finally, an abstract class can have static constants but an interface cannot.
What is constructor chaining?
In object-oriented programming, constructor chaining is the process of calling one constructor from another, in order to create a class hierarchy. In Java, for example, a subclass constructor can call the constructor of its superclass by using the super keyword. By doing so, the subclass inherits all of the fields and methods of the superclass, and can add its own unique functionality. Constructor chaining is a powerful tool for creating flexible and extensible code, and can be used to implement inheritance in a variety of ways.
However, it is important to use constructor chaining judiciously, as it can lead to complex code that is difficult to debug and maintain. When used correctly, however, constructor chaining can be a valuable asset in any object-oriented programming project.
What is Compile time Polymorphism & how is it distinct from Runtime Polymorphism?
Compile time Polymorphism is also known as method overloading whereas Runtime Polymorphism is also known as method overriding. Compile time Polymorphism is the ability to create a method in a class with the same name but different signatures (i.e. parameters). When an overloaded method is invoked, the Java compiler will select the appropriate method based on the number and types of arguments.
On the other hand, Runtime Polymorphism is the ability to create methods in a class with the same name and same signature (i.e. parameters). The Java compiler will not resolve these methods during compilation and will instead defer to the virtual machine to resolve them at runtime. When a method is invoked, the virtual machine will select the appropriate method based on the type of object that it is operating on.
In general, Compile time Polymorphism is more efficient because it can be resolved at compile time whereas Runtime Polymorphism is less efficient because it has to be resolved at runtime. However, Runtime Polymorphism is more flexible because it can be used to dynamically change the behavior of an object at runtime.
What is the diamond problem in inheritance?
The "diamond problem" is a term used in computer programming to describe an issue that can occur when multiple classes inherit from a common superclass. The problem arises when two subclasses override a method with different implementations, and a third subclass inherits from both of them.
In this scenario, the subclass will inherit two different implementations of the method, and it is not clear which one should be used. This can lead to errors or unexpected behavior at runtime. The diamond problem can be avoided by using careful design patterns, such as the template method pattern. However, it is still something that programmers need to be aware of when working with inheritance.
What is a constructor?
A constructor is a special type of subroutine that runs when an object is created in Object-Oriented Programming (OOP). Constructors are different from ordinary routines or methods as they have the ability to instantiate new objects.
They essentially act as a gateway for the objects, supplying it with data and other necessary components so that it can be put into use. One key feature of constructors, which sets them apart from other subroutines, is that they must have the same name as the class itself. This helps to ensure that the correct set of instructions gets called each time a new instance is made.
In addition, it allows all previous constructor characteristics to be passed onto any new objects made from this class. The fact that constructors are necessary for instantiating objects makes them an important element for OOP applications. With conditions such as these, interviewers often ask about constructors to find out if job applicants are extra familiar with how OOP languages and their related classes operate.
How does C++ support Polymorphism?
C++ supports polymorphism by providing constructors to create objects of different types and by allowing classes to be inherited from parent classes. The inheritance feature allows a class to inherit all the attributes and methods defined within its parent class, including any virtual functions that may exist.
Virtual functions allow for both static and dynamic inclusion of data and code elements based on user input, enabling true polymorphic behavior. Additionally, C++ also supports compile-time arguments known as templates, which allow you to pass type parameters directly into a method or class at compile time. By utilizing these features in conjunction with each other, developers can create powerful programs that leverage the power of polymorphism in C++.
What is a destructor?
A destructor is a special type of method in Object Oriented Programming (OOP) that allows an object to clean up resources allocated by the program. In OOP languages like C++, Java and Python, a destructor is known as the inverse of a constructor - while the constructor allocates memory and other resources for a new object, the destructor releases those same resources when the object is no longer going to be used.
While it can often go overlooked in OOP designs - since many programs are relatively short-lived and never need such a mechanism - general good practice dictates that any object should always have a working destructor in place. Destructors become particularly important if an application runs for large periods of time and endlessly creates objects, as this could lead to memory leaks due to unreleased resources.
Do we require a parameter for constructors?
The answer to this question depends on what type of constructor you are referring to. A default constructor, which is a type of constructor with no parameters, requires no argument in order for it to execute correctly. However, if you create a parameterized constructor (a constructor with one or more parameters), then those parameters must be provided in order to instantiate the class correctly. When providing arguments, they must match the data types declared in the parameter list.
An example of a parameterized constructor might be a class that has to receive an integer value as its parameter; when calling this constructor, you would need to provide an integer value as an argument. Without doing so, the call would fail and throw an exception. Thus depending on which type of the constructor it is linked with parameterized or default we need parameters or not respectively.
Is it always required to create objects from class?
When an object is instantiated, or created, the code in the class is executed in order to initialize the object's data and methods. In some cases, it might be more efficient or practical to not create an object from a class at all — for example, when a static method can provide a desired result without any external state having to be stored and managed.
However, as a general rule of thumb it's usually necessary to create an object from a class when developing with OOP since objects represent real-world entities, abstract concepts, and form collections that hold related data together.
All of these scenarios are impossible without instances of classes being created for them first. Thus, while it's possible in some cases to avoid creating objects from classes when using OOP, in many cases it's simply not possible or is not ideal when trying to properly organize code and efficiently achieve specific functions within software projects.
What are the differences between overloading & overriding?
Overloading refers to a feature of a programming language that allows different functions with the same name but different parameters to be created. This is done so that the same function can take multiple arguments and return different results depending on those parameters.
On the other hand, overriding allows functions within subclasses to have the same name, inputs and outputs as those in the superclass, but changes its behavior by replacing it with another implementation of the same method. This allows subclasses to provide their own implementations of functions which may be better suited to their intended purpose.
To sum up, overloading is about assigning multiple functionalities to one functional block while overriding is about using existing functionalities from parent classes and making customizations as needed.
How do you access an abstract class?
Accessing an abstract class is a powerful tool to make sure that certain behaviors or functions are included in a derived class if it extends from the abstract class. In general, one has to create an instance of the class that extends the abstract class. For example, if one creates a new concrete class from the abstract parent "Fruit", then he or she can access that specific fruit's attributes and methods through that instance. Depending on what language is being used for programming, there might be different binaries which are responsible for accessing the abstract classes.
For example, in Java this includes creating one or more interfaces as well as utilizing javap command-line tools to identify constructor signatures within any given object's inheritance tree. As such, creating an instance of such a concrete class gives access to the abstract ancestor's methods as they are inherited by all objects of concrete classes descending from it. This allows programmers to use strong typing and truly transform their designs into code.
Can you inherit a final class?
When it comes to classes in Java, there are two types: final and non-final. A final class cannot be inherited or extended, as its code is locked in place, while a non-final class can be extended to create a subclass. This allows a developer to add new features and behavior to the existing class without affecting the parent code.
However, attempting to inherit a final class will result in an error message as the compiler will not allow it. In many cases, making a class final is done for security purposes; if someone tries to extend the existing code, they won't be able to do so unless they have explicit permission from the developer. In other cases, inheritance just isn't necessary; either way, you cannot inherit from a final class.
To prevent this from happening, developers should be sure to make any classes that do not need to be inherited into final classes if possible. Doing this ensures that your code remains safe and secure from third parties trying to access or modify it without permission.
Give real-world examples of polymorphism?
Polymorphism is one of the core concepts behind object-oriented programming. It refers to the ability for a single interface or method to operate in different ways based on its underlying data types.
To illustrate this concept, consider a cooking class. Each student in the class might use the same essential techniques and kitchen tools, but depending on their chosen recipes, they could each be preparing meals with different ingredients and techniques. In other words, even though all of the students are using generally similar methods, the end result of their cooking can vary drastically – just like polymorphism.
Another example of polymorphism exists in operating systems. Many modern systems contain an emulation layer that allows software written for one platform or language to run on another without having to convert it into compatible code first. In this situation, a single abstraction layer is used to emulate multiple inputs and run them as if they were natively compatible programs – once again demonstrating polymorphism in action.
Name some operators that cannot be overloaded.
In C++ and many other programming languages, certain operators can be overloaded, allowing them to be used in new contexts or with different types of data. Overloading an operator allows it to have a new functionality, however not all operators can be overloaded. These include the basic arithmetic operators (+ - * / %) as well as bitwise operators (&& || ! & | ^ ~ << >>).
Furthermore, certain special operators that draw their functionality from the type of data they work with cannot be overloaded either. This includes the dot operator for accessing member variables (.), pointer dereference operator (*), address-of operator (&), and array indexing operator ([ ]). While these operators cannot be manipulated by overloading, other operators like comparison (== != > >= < <=) and conditional (?:) can be overloaded to change how they function under specific conditions.
Is it possible to run a Java program without implementing the OOPs concept?
As we know, Java is an object-oriented programming language. This means that code written in Java must follow the OOPs concept. The OOPs concept is based on the principle of objects and classes. Objects are the basic units of a Java program, and they are defined by their states and behavior.
States are represented by the data fields of an object, while behavior is represented by the methods of an object. On the other hand, a class is a blueprint for creating objects. It defines the states and behavior that all objects of that class will have.
So, when we create a Java application, we first create one or more classes. Each class defines the objects that we want to use in our application. Once we have defined our classes, we can then create objects from those classes and use them in our application. Therefore, it is not possible to run a Java application without implementing the OOPs concept since these applications are based on the OOPs model.
What are the different types of constructors in C++?
In C++, a constructor is a special member function that is called automatically when an object of a class is created. There are three different types of constructors that can be defined in a class: default, copy, and parameterized. Default constructors are used when no constructor is explicitly defined in a class. They initialize member variables to their default values. Copy constructors are used to create a new object as a copy of an existing object.
Parameterized constructors are used to initialize member variables with user-specified values. Each type of constructor has its own specific purpose and use cases. When designing a class, it is important to choose the right type of constructor based on the needs of the program.
Submit an interview question
Related Interview Questions
SQL JOINs Interview Questions and Answers for 2023
DBMS Interview Questions and Answers for 2023
TOGAF Interview Questions and Answers for 2023
Marketing Interview Questions and Answers for 2023
Content Marketing Interview Questions & Answers 2023
Copywriter Interview Questions and Answers for 2023
Content Writer Interview Questions and Answers 2023
Behavioral Interview Questions and Answers for 2023
Personal Interview Questions and Answers for 2023
MBA Interview Questions and Answers for 2023
Submitted questions and answers are subjecct to review and editing,and may or may not be selected for posting, at the sole discretion of Knowledgehut.
Enter your Answer
All fields are required, by clicking the button you agree with the Terms and Conditions of knowledgehut.LLC's Privacy Policy
Get a 1:1 Mentorship call with our Career Advisor
Book your free session today Book your free session today
Book your free session today
CSM®, CSPO®, CSD®, CSP®, A-CSPO®, A-CSM® are registered trademarks of Scrum Alliance®. KnowledgeHut Solutions Pvt. Ltd. is a Registered Education Ally (REA) of Scrum Alliance®. PMP is a registered mark of the Project Management Institute, Inc. CAPM is a registered mark of the Project Management Institute, Inc. PMI-ACP is a registered mark of the Project Management Institute, Inc. PMI-RMP is a registered mark of the Project Management Institute, Inc. PMI-PBA is a registered mark of the Project Management Institute, Inc. PgMP is a registered mark of the Project Management Institute, Inc. PfMP is a registered mark of the Project Management Institute, Inc. KnowledgeHut Solutions Pvt. Ltd. is a Premier Authorized Training Partner (ATP) of Project Management Institute, Inc. The PMI Premier Authorized Training Partner logo is a registered mark of the Project Management Institute, Inc. PMBOK is a registered mark of the Project Management Institute, Inc. ITIL®, PRINCE2®, PRINCE2 Agile®, AgileSHIFT® are registered trademarks of AXELOS Limited, used under permission of AXELOS Limited. The Swirl logo™ is a trademark of AXELOS Limited, used under permission of AXELOS Limited. All rights reserved. COBIT® is a registered trademark of Information Systems Audit and Control Association® (ISACA®). (ISC)2® is a registered trademark of International Information Systems Security Certification Consortium, Inc. CompTIA Authorized Training Partner, CMMI® is registered in the U.S. Patent and Trademark Office by Carnegie Mellon University. FRM®, GARP™ and Global Association of Risk Professionals™, are trademarks owned by the Global Association of Risk Professionals, Inc. Global Association of Risk Professionals, Inc. (GARP™) does not endorse, promote, review, or warrant the accuracy of the products or services offered by KnowledgeHut for FRM® related information, nor does it endorse any pass rates claimed by the provider. Further, GARP is not responsible for any fees or costs paid by the user. IIBA®, the IIBA® logo, BABOK®, and Business Analysis Body of Knowledge® are registered trademarks owned by the International Institute of Business Analysis. KnowledgeHut is an Endorsed Education Provider of IIBA®. TOGAF® is a registered trademark of The Open Group in the United States and other countries. Scaled Agile Framework® and SAFe® are registered trademarks of Scaled Agile, Inc.® KnowledgeHut is a Gold SPCT Partner of Scaled Agile, Inc®. KnowledgeHut is an Authorized Training Partner of CertNexus. KnowledgeHut is a Microsoft Partner. KnowledgeHut is an AWS Training Partner (ATP). KnowledgeHut is an ICAgile Member Training Organization. KnowledgeHut is a Professional Training Network member of scrum.org. KnowledgeHut is an Accredited Examination Centre of IASSC. KnowledgeHut is a Registered Education Partner (REP) of the DevOps Institute (DOI). KnowledgeHut is an ATO of PEOPLECERT. KnowledgeHut is an Authorized Training Partner (ATP) and Accredited Training Center (ATC) of EC-Council. KnowledgeHut is a Bronze Licensed Training Organization of Kanban University.
Cancel / Close Forgot password?
Cancel / Close Login
Log In With Facebook Log In With Google Login with linkedin We do not post without your permission.
Log In With Facebook Log In With Google Login with linkedin
We do not post without your permission.
Don't Miss Out on Exclusive Discounts on Courses!
Future-Proof Your Career with the Latest In-Demand Courses
Get Job-Ready Digital Skills
Experience Outcome-Based Immersive Learning
Get Trained by a Stellar Pool of Industry Experts
Best-In-Class Industry-Vetted Curriculum
Beginner 25
Advanced 25


text:
SBP wins IFN global award for 2nd year in a row
KARACHI: Islamic Finance News (IFN), an arm of RED money Group, Malaysia, has announced State Bank of Pakistan (SBP) as the best central bank of 2021 across the world in promoting Islamic finance, a statement said on Thursday.
IFN Best Banks Poll is regarded as a prestigious award in the global Islamic finance space. Bank Negara Malaysia stood second, while the Saudi Central Bank secured third position.
SBP has won this award five times in seven years. Previously, SBP was bestowed with this coveted award for the year 2015, 2017, 2018, and 2020.
IFN in its cover story, while congratulating the SBP for yet another win as the best central bank in promoting Islamic finance stated that they welcome back a leading light of the industry.
"In a closely fought contest, 2020s victor came roaring back to take the crown," said the IFN. IFN while announcing the poll result also stated that with its Governor, Dr Reza Baqir, recently promoted to be the new chairman of the Council of the IFSB, from his role as the Deputy Chairman in 2021, they can hopefully look forward to even stronger support and leadership from the central bank over the coming year.
The award is an endorsement of its initiatives for promotion of Islamic banking in the country. The award reflects an international recognition of the strategic measures undertaken by SBP to put in place a robust policy environment for Islamic banking to prosper.
SBP has consistently promoted and encouraged Islamic finance within Pakistan, and has taken several significant steps. These include launch of 3rd five year strategic plan for Islamic banking 2021-25, Shariah-compliant standing ceiling facility and open market operations, strengthening of Shariah governance mechanism, Shariah-compliant regulations for the lender of the last resort (LOLR) facility and licensing regime for digital banking covering the Islamic segment.
Besides, the central bank also took initiatives for promoting better awareness amongst the masses, and strengthening international linkages.
Strategic plan 2021-25 envisages taking Islamic banking share of 30 percent in terms of assets and 35 percent in terms of deposits in the overall banking system.
Amidst the Covid-19 chaos throwing unforeseen challenges to the global financial market, Islamic banking industry in Pakistan continued to maintain its impressive growth trajectory and assets and deposits of Islamic banking industry grew on a year-on-year basis by 28.2 percent and 26 percent, respectively by September 30, 2021.
The market share of Islamic banking assets and deposits stood at 17 percent and 18.6 percent, respectively in the overall banking system in the country as of September 30, 2021.
The industry operates through a huge network of 3,651 branches and 1,579 Islamic banking windows (dedicated counters at conventional branches) steered by 22 Islamic Banking Institutions (IBIs) which include 5 full-fledged Islamic banks and 17 conventional banks having dedicated Islamic banking branches and windows.

redpajama_set_name: RedPajamaCommonCrawl


text:
Batson claim › Criminal Prosecution
The Ups And Downs (And Up Again?) Of A Batson Challenge
Fox Rothschild LLP on 7/31/2020
In Batson v. Kentucky, 476 U.S. 79 (1986), the U.S. Supreme Court held that the Equal Protection Clause of the Fourteenth Amendment prevents prosecutors in criminal cases from exercising peremptory challenges to excuse...more
United States v. Altareb: Troubling Batson Concerns Weighed By The Court
Patterson Belknap Webb & Tyler LLP on 12/20/2018
In United States v. Altareb, 17-1717, the Second Circuit (Sack, Parker, Chin) issued a summary order affirming a conviction for, inter alia, operating an unlicensed money transmitting business and bulk cash smuggling. ...more
June 2016: Trial Practice Update
Quinn Emanuel Urquhart & Sullivan, LLP on 6/28/2016
Jury Selection—Batson v. Kentucky Is Alive and Well. Last month the United States Supreme Court issued its long-awaited decision in Foster v. Chatman, 578 U.S. (2016), reaffirming its 30-year-old decision in Batson v....more
Supreme Court Decides Foster v. Chatman
On May 23, 2016, the United States Supreme Court decided Foster v. Chatman, No. 14-8349, holding that it was clearly erroneous for a state habeas court to decide that a criminal defendant failed to show purposeful...more
Narrow By Topic
AppealsBurden-ShiftingCertiorariDissenting OpinionsEqual ProtectionFourteenth AmendmentJury SelectionNC Supreme CourtSCOTUS


Home › Real Estate › Treat everyone as you would like to be treated! Wonderful True Story!
secretary snapped. "We will wait," the lady replied.
couple would finally become discouraged and go away.
it was a chore she always regretted.
she said to him! He sighed in exasperation and nodded.
and homespun suits cluttering up his outer office.
here. But about a year ago, he was accidentally killed.
somewhere on campus." The president wasn't touched.
for every person who attended Harvard and died.
president's face wilted in confusion and bewilderment.
a memorial to a son that Harvard no longer cared about.
they treat those who they think can do nothing for them.


Prime Minister's ICT Affairs Adviser Sajeeb Wazed Joy on Thursday said information and communication technology (ICT) education will be introduced from the primary level in near future, reports BSS.
"Computer training is now being given from class VI. Hopefully the ICT education can be introduced from the primary level in next few years aimed at building skilled manpower," he said while presenting the keynote paper at the ministerial conference on the second day of 4-day mega event 'Digital World-2017' at the Bangabandhu International Conference Centre (BICC).
Joy, also grandson of Father of Nation Bangabandhu Sheikh Mujibur Rahman and son of Prime Minister Sheikh Hasina, said the text of ICT education at the primary level would be made easier for the kids.
He said Bangladesh does not want to remain as a cheap-wage labour exporting country rather it wants to be a technology exporting one.
"It is high time for us to talk about fourth industrial revolution as the rapidly changing technology has been bringing radical change to every part of human life resulting quick economic growth and industrialization," he also said.
He said the government along with the private sector has been working for the development of information and communication technology (ICT) sector while the countrymen also started getting yields of it.
The PM's ICT adviser said now 40 percent government services have been made digitized since the journey of Digital Bangladesh began while 80 percent services would be digitized in the coming days to help people get services at home by using smart phone.
He said the number of internet and social media users has also increased a lot.
Principal Adviser to the Prime Minister of Congo Diedonne Kalombo Nkile, Cambodian State Minister for Posts and Telecommunications Kan Channmeta, Bhutanese Information and Communication Minister Dina Nath Dungyel, Maldivian Deputy Minister for Defence and National Security Thariq Ali Luthufi and Philippines Department of ICT Director Nestor S Bongata took part in the conference.


text:
Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain: The Alliance A221304 Randomized Clinical Trial
Terence T. Sio, Jennifer G. Le-Rademacher, James L. Leenstra, Charles L. Loprinzi, Grant Rine, Amarinthia Curtis, Anurag K. Singh, James A. Martenson, Paul J. Novotny, Angelina D. Tan, Rui Qin, Stephen J. Ko, Paul L. Reiter, Robert C. Miller
Biomedical Statistics and Informatics
Importance: Oral mucositis causes substantial morbidity during head and neck radiotherapy. In a randomized study, doxepin mouthwash was shown to reduce oral mucositis-related pain. A common mouthwash comprising diphenhydramine-lidocaine-antacid is also widely used. Objective: To evaluate the effect of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash for the treatment of oral mucositis-related pain. Design, Setting, and Participants: A phase 3 randomized trial was conducted from November 1, 2014, to May 16, 2016, at 30 US institutions and included 275 patients who underwent definitive head and neck radiotherapy, had an oral mucositis pain score of 4 points or greater (scale, 0-10), and were followed up for a maximum of 28 days. Interventions: Ninety-two patients were randomized to doxepin mouthwash (25 mg/5 mL water); 91 patients to diphenhydramine-lidocaine-antacid; and 92 patients to placebo. Main Outcome and Measures: The primary end point was total oral mucositis pain reduction (defined by the area under the curve and adjusted for baseline pain score) during the 4 hours after a single dose of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash compared with a single dose of placebo. The minimal clinically important difference was a 3.5-point change. The secondary end points included drowsiness, unpleasant taste, and stinging or burning. All scales ranged from 0 (best) to 10 (worst). Results: Among the 275 patients randomized (median age, 61 years; 58 [21%] women), 227 (83%) completed treatment per protocol. Mucositis pain during the first 4 hours decreased by 11.6 points in the doxepin mouthwash group, by 11.7 points in the diphenhydramine-lidocaine-antacid mouthwash group, and by 8.7 points in the placebo group. The between-group difference was 2.9 points (95% CI, 0.2-6.0; P =.02) for doxepin mouthwash vs placebo and 3.0 points (95% CI, 0.1-5.9; P =.004) for diphenhydramine-lidocaine-antacid mouthwash vs placebo. More drowsiness was reported with doxepin mouthwash vs placebo (by 1.5 points [95% CI, 0-4.0]; P =.03), unpleasant taste (by 1.5 points [95% CI, 0-3.0]; P =.002), and stinging or burning (by 4.0 points [95% CI, 2.5-5.0]; P <.001). Maximum grade 3 adverse events for the doxepin mouthwash occurred in 3 patients (4%); diphenhydramine-lidocaine-antacid mouthwash, 3 (4%); and placebo, 2 (2%). Fatigue was reported by 5 patients (6%) in the doxepin mouthwash group and no patients in the diphenhydramine-lidocaine-antacid mouthwash group. Conclusions and Relevance: Among patients undergoing head and neck radiotherapy, the use of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash vs placebo significantly reduced oral mucositis pain during the first 4 hours after administration; however, the effect size was less than the minimal clinically important difference. Further research is needed to assess longer-term efficacy and safety for both mouthwashes. Trial Registration: ClinicalTrials.gov Identifier: NCT02229539.
JAMA - Journal of the American Medical Association
https://doi.org/10.1001/jama.2019.3504
10.1001/jama.2019.3504
Dive into the research topics of 'Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain: The Alliance A221304 Randomized Clinical Trial'. Together they form a unique fingerprint.
Doxepin Medicine & Life Sciences 100%
Diphenhydramine Medicine & Life Sciences 87%
Antacids Medicine & Life Sciences 84%
Mouthwashes Medicine & Life Sciences 84%
Stomatitis Medicine & Life Sciences 79%
Lidocaine Medicine & Life Sciences 67%
Radiotherapy Medicine & Life Sciences 44%
Placebos Medicine & Life Sciences 44%
Sio, T. T., Le-Rademacher, J. G., Leenstra, J. L., Loprinzi, C. L., Rine, G., Curtis, A., Singh, A. K., Martenson, J. A., Novotny, P. J., Tan, A. D., Qin, R., Ko, S. J., Reiter, P. L., & Miller, R. C. (2019). Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain: The Alliance A221304 Randomized Clinical Trial. JAMA - Journal of the American Medical Association, 321(15), 1481-1490. https://doi.org/10.1001/jama.2019.3504
Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain : The Alliance A221304 Randomized Clinical Trial. / Sio, Terence T.; Le-Rademacher, Jennifer G.; Leenstra, James L.; Loprinzi, Charles L.; Rine, Grant; Curtis, Amarinthia; Singh, Anurag K.; Martenson, James A.; Novotny, Paul J.; Tan, Angelina D.; Qin, Rui; Ko, Stephen J.; Reiter, Paul L.; Miller, Robert C.
In: JAMA - Journal of the American Medical Association, Vol. 321, No. 15, 16.04.2019, p. 1481-1490.
Sio, TT, Le-Rademacher, JG, Leenstra, JL, Loprinzi, CL, Rine, G, Curtis, A, Singh, AK, Martenson, JA, Novotny, PJ, Tan, AD, Qin, R, Ko, SJ, Reiter, PL & Miller, RC 2019, 'Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain: The Alliance A221304 Randomized Clinical Trial', JAMA - Journal of the American Medical Association, vol. 321, no. 15, pp. 1481-1490. https://doi.org/10.1001/jama.2019.3504
Sio TT, Le-Rademacher JG, Leenstra JL, Loprinzi CL, Rine G, Curtis A et al. Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain: The Alliance A221304 Randomized Clinical Trial. JAMA - Journal of the American Medical Association. 2019 Apr 16;321(15):1481-1490. https://doi.org/10.1001/jama.2019.3504
Sio, Terence T. ; Le-Rademacher, Jennifer G. ; Leenstra, James L. ; Loprinzi, Charles L. ; Rine, Grant ; Curtis, Amarinthia ; Singh, Anurag K. ; Martenson, James A. ; Novotny, Paul J. ; Tan, Angelina D. ; Qin, Rui ; Ko, Stephen J. ; Reiter, Paul L. ; Miller, Robert C. / Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain : The Alliance A221304 Randomized Clinical Trial. In: JAMA - Journal of the American Medical Association. 2019 ; Vol. 321, No. 15. pp. 1481-1490.
@article{55cc7d8679c34e269864b36b337a6b9b,
title = "Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain: The Alliance A221304 Randomized Clinical Trial",
abstract = "Importance: Oral mucositis causes substantial morbidity during head and neck radiotherapy. In a randomized study, doxepin mouthwash was shown to reduce oral mucositis-related pain. A common mouthwash comprising diphenhydramine-lidocaine-antacid is also widely used. Objective: To evaluate the effect of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash for the treatment of oral mucositis-related pain. Design, Setting, and Participants: A phase 3 randomized trial was conducted from November 1, 2014, to May 16, 2016, at 30 US institutions and included 275 patients who underwent definitive head and neck radiotherapy, had an oral mucositis pain score of 4 points or greater (scale, 0-10), and were followed up for a maximum of 28 days. Interventions: Ninety-two patients were randomized to doxepin mouthwash (25 mg/5 mL water); 91 patients to diphenhydramine-lidocaine-antacid; and 92 patients to placebo. Main Outcome and Measures: The primary end point was total oral mucositis pain reduction (defined by the area under the curve and adjusted for baseline pain score) during the 4 hours after a single dose of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash compared with a single dose of placebo. The minimal clinically important difference was a 3.5-point change. The secondary end points included drowsiness, unpleasant taste, and stinging or burning. All scales ranged from 0 (best) to 10 (worst). Results: Among the 275 patients randomized (median age, 61 years; 58 [21%] women), 227 (83%) completed treatment per protocol. Mucositis pain during the first 4 hours decreased by 11.6 points in the doxepin mouthwash group, by 11.7 points in the diphenhydramine-lidocaine-antacid mouthwash group, and by 8.7 points in the placebo group. The between-group difference was 2.9 points (95% CI, 0.2-6.0; P =.02) for doxepin mouthwash vs placebo and 3.0 points (95% CI, 0.1-5.9; P =.004) for diphenhydramine-lidocaine-antacid mouthwash vs placebo. More drowsiness was reported with doxepin mouthwash vs placebo (by 1.5 points [95% CI, 0-4.0]; P =.03), unpleasant taste (by 1.5 points [95% CI, 0-3.0]; P =.002), and stinging or burning (by 4.0 points [95% CI, 2.5-5.0]; P <.001). Maximum grade 3 adverse events for the doxepin mouthwash occurred in 3 patients (4%); diphenhydramine-lidocaine-antacid mouthwash, 3 (4%); and placebo, 2 (2%). Fatigue was reported by 5 patients (6%) in the doxepin mouthwash group and no patients in the diphenhydramine-lidocaine-antacid mouthwash group. Conclusions and Relevance: Among patients undergoing head and neck radiotherapy, the use of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash vs placebo significantly reduced oral mucositis pain during the first 4 hours after administration; however, the effect size was less than the minimal clinically important difference. Further research is needed to assess longer-term efficacy and safety for both mouthwashes. Trial Registration: ClinicalTrials.gov Identifier: NCT02229539.",
author = "Sio, {Terence T.} and Le-Rademacher, {Jennifer G.} and Leenstra, {James L.} and Loprinzi, {Charles L.} and Grant Rine and Amarinthia Curtis and Singh, {Anurag K.} and Martenson, {James A.} and Novotny, {Paul J.} and Tan, {Angelina D.} and Rui Qin and Ko, {Stephen J.} and Reiter, {Paul L.} and Miller, {Robert C.}",
note = "Funding Information: Funding/Support: This study was supported by grants UG1CA189823 (Alliance for Clinical Trials in Oncology National Cancer Institute Community Oncology Research Program), U10CA180790, U10CA180850, U10CA180866, UG1CA189858, and UG1CA189808 from the National Cancer Institute, National Institutes of Health, and by funding from the Mayo Clinic Symptom Intervention Program. Funding Information: This study is supported by the NCI Cancer Trials Support Unit (CTSU). Prior to the recruitment of a patient for this study, investigators must be registered members of a National Clinical Trials Network (NCTN) Group. Each investigator must have an NCI investigator number and must maintain an {\`O}active{\'O} investigator registration status through the annual submission of a complete investigator registration packet (FDA Form 1572 with original signature, current CV, Supplemental Investigator Data Form with signature, and Financial Disclosure Form with original signature) to the Pharmaceutical Management Branch, CTEP, DCTD, NCI. These forms are available on the CTSU Web site (enter credentials at https://www.ctsu.org; then click on the Register tab) or by calling the PMB at 301-496-5725 Monday through Friday between 8:30 a.m. and 4:30 p.m. Eastern time. Publisher Copyright: {\textcopyright} 2019 American Medical Association. All rights reserved.",
doi = "10.1001/jama.2019.3504",
journal = "JAMA - Journal of the American Medical Association",
T1 - Effect of Doxepin Mouthwash or Diphenhydramine-Lidocaine-Antacid Mouthwash vs Placebo on Radiotherapy-Related Oral Mucositis Pain
T2 - The Alliance A221304 Randomized Clinical Trial
AU - Sio, Terence T.
AU - Le-Rademacher, Jennifer G.
AU - Leenstra, James L.
AU - Loprinzi, Charles L.
AU - Rine, Grant
AU - Curtis, Amarinthia
AU - Singh, Anurag K.
AU - Martenson, James A.
AU - Novotny, Paul J.
AU - Tan, Angelina D.
AU - Qin, Rui
AU - Ko, Stephen J.
AU - Reiter, Paul L.
AU - Miller, Robert C.
N1 - Funding Information: Funding/Support: This study was supported by grants UG1CA189823 (Alliance for Clinical Trials in Oncology National Cancer Institute Community Oncology Research Program), U10CA180790, U10CA180850, U10CA180866, UG1CA189858, and UG1CA189808 from the National Cancer Institute, National Institutes of Health, and by funding from the Mayo Clinic Symptom Intervention Program. Funding Information: This study is supported by the NCI Cancer Trials Support Unit (CTSU). Prior to the recruitment of a patient for this study, investigators must be registered members of a National Clinical Trials Network (NCTN) Group. Each investigator must have an NCI investigator number and must maintain an ÒactiveÓ investigator registration status through the annual submission of a complete investigator registration packet (FDA Form 1572 with original signature, current CV, Supplemental Investigator Data Form with signature, and Financial Disclosure Form with original signature) to the Pharmaceutical Management Branch, CTEP, DCTD, NCI. These forms are available on the CTSU Web site (enter credentials at https://www.ctsu.org; then click on the Register tab) or by calling the PMB at 301-496-5725 Monday through Friday between 8:30 a.m. and 4:30 p.m. Eastern time. Publisher Copyright: © 2019 American Medical Association. All rights reserved.
N2 - Importance: Oral mucositis causes substantial morbidity during head and neck radiotherapy. In a randomized study, doxepin mouthwash was shown to reduce oral mucositis-related pain. A common mouthwash comprising diphenhydramine-lidocaine-antacid is also widely used. Objective: To evaluate the effect of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash for the treatment of oral mucositis-related pain. Design, Setting, and Participants: A phase 3 randomized trial was conducted from November 1, 2014, to May 16, 2016, at 30 US institutions and included 275 patients who underwent definitive head and neck radiotherapy, had an oral mucositis pain score of 4 points or greater (scale, 0-10), and were followed up for a maximum of 28 days. Interventions: Ninety-two patients were randomized to doxepin mouthwash (25 mg/5 mL water); 91 patients to diphenhydramine-lidocaine-antacid; and 92 patients to placebo. Main Outcome and Measures: The primary end point was total oral mucositis pain reduction (defined by the area under the curve and adjusted for baseline pain score) during the 4 hours after a single dose of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash compared with a single dose of placebo. The minimal clinically important difference was a 3.5-point change. The secondary end points included drowsiness, unpleasant taste, and stinging or burning. All scales ranged from 0 (best) to 10 (worst). Results: Among the 275 patients randomized (median age, 61 years; 58 [21%] women), 227 (83%) completed treatment per protocol. Mucositis pain during the first 4 hours decreased by 11.6 points in the doxepin mouthwash group, by 11.7 points in the diphenhydramine-lidocaine-antacid mouthwash group, and by 8.7 points in the placebo group. The between-group difference was 2.9 points (95% CI, 0.2-6.0; P =.02) for doxepin mouthwash vs placebo and 3.0 points (95% CI, 0.1-5.9; P =.004) for diphenhydramine-lidocaine-antacid mouthwash vs placebo. More drowsiness was reported with doxepin mouthwash vs placebo (by 1.5 points [95% CI, 0-4.0]; P =.03), unpleasant taste (by 1.5 points [95% CI, 0-3.0]; P =.002), and stinging or burning (by 4.0 points [95% CI, 2.5-5.0]; P <.001). Maximum grade 3 adverse events for the doxepin mouthwash occurred in 3 patients (4%); diphenhydramine-lidocaine-antacid mouthwash, 3 (4%); and placebo, 2 (2%). Fatigue was reported by 5 patients (6%) in the doxepin mouthwash group and no patients in the diphenhydramine-lidocaine-antacid mouthwash group. Conclusions and Relevance: Among patients undergoing head and neck radiotherapy, the use of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash vs placebo significantly reduced oral mucositis pain during the first 4 hours after administration; however, the effect size was less than the minimal clinically important difference. Further research is needed to assess longer-term efficacy and safety for both mouthwashes. Trial Registration: ClinicalTrials.gov Identifier: NCT02229539.
AB - Importance: Oral mucositis causes substantial morbidity during head and neck radiotherapy. In a randomized study, doxepin mouthwash was shown to reduce oral mucositis-related pain. A common mouthwash comprising diphenhydramine-lidocaine-antacid is also widely used. Objective: To evaluate the effect of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash for the treatment of oral mucositis-related pain. Design, Setting, and Participants: A phase 3 randomized trial was conducted from November 1, 2014, to May 16, 2016, at 30 US institutions and included 275 patients who underwent definitive head and neck radiotherapy, had an oral mucositis pain score of 4 points or greater (scale, 0-10), and were followed up for a maximum of 28 days. Interventions: Ninety-two patients were randomized to doxepin mouthwash (25 mg/5 mL water); 91 patients to diphenhydramine-lidocaine-antacid; and 92 patients to placebo. Main Outcome and Measures: The primary end point was total oral mucositis pain reduction (defined by the area under the curve and adjusted for baseline pain score) during the 4 hours after a single dose of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash compared with a single dose of placebo. The minimal clinically important difference was a 3.5-point change. The secondary end points included drowsiness, unpleasant taste, and stinging or burning. All scales ranged from 0 (best) to 10 (worst). Results: Among the 275 patients randomized (median age, 61 years; 58 [21%] women), 227 (83%) completed treatment per protocol. Mucositis pain during the first 4 hours decreased by 11.6 points in the doxepin mouthwash group, by 11.7 points in the diphenhydramine-lidocaine-antacid mouthwash group, and by 8.7 points in the placebo group. The between-group difference was 2.9 points (95% CI, 0.2-6.0; P =.02) for doxepin mouthwash vs placebo and 3.0 points (95% CI, 0.1-5.9; P =.004) for diphenhydramine-lidocaine-antacid mouthwash vs placebo. More drowsiness was reported with doxepin mouthwash vs placebo (by 1.5 points [95% CI, 0-4.0]; P =.03), unpleasant taste (by 1.5 points [95% CI, 0-3.0]; P =.002), and stinging or burning (by 4.0 points [95% CI, 2.5-5.0]; P <.001). Maximum grade 3 adverse events for the doxepin mouthwash occurred in 3 patients (4%); diphenhydramine-lidocaine-antacid mouthwash, 3 (4%); and placebo, 2 (2%). Fatigue was reported by 5 patients (6%) in the doxepin mouthwash group and no patients in the diphenhydramine-lidocaine-antacid mouthwash group. Conclusions and Relevance: Among patients undergoing head and neck radiotherapy, the use of doxepin mouthwash or diphenhydramine-lidocaine-antacid mouthwash vs placebo significantly reduced oral mucositis pain during the first 4 hours after administration; however, the effect size was less than the minimal clinically important difference. Further research is needed to assess longer-term efficacy and safety for both mouthwashes. Trial Registration: ClinicalTrials.gov Identifier: NCT02229539.
U2 - 10.1001/jama.2019.3504
DO - 10.1001/jama.2019.3504
JO - JAMA - Journal of the American Medical Association
JF - JAMA - Journal of the American Medical Association


text:
Avian Influenza update
Friday 5 November 2021 - 11:57
Measures to limit spread of the disease.
Following confirmation of avian influenza (H5N1) among a flock of kept birds in the Angus constituency, laboratory results have identified the strain as highly pathogenic in poultry.
Within these zones, a range of different controls are now in place, including restrictions on the movement of poultry, carcasses, eggs, used poultry litter and manure.
Animal and Plant Health Agency inspectors will conduct visits in the local area to support compliance among bird keepers.
Public health advice is that the risk to human health from the virus is very low and food standards bodies advise that avian influenzas pose a very low food safety risk for UK consumers, and that cooked poultry products including eggs are safe to eat.
Rural Affairs Secretary Marie Gougeon said:
"Following this confirmation I have put in place measures to help control any further spread of the disease in the surrounding area. We ask that the public remain vigilant and report any findings of dead wild birds."
Scotland's Chief Veterinary Officer Sheila Voas said:
"This highly pathogenic strain of avian influenza (H5N1) has been confirmed and all remaining birds are being humanely culled. All bird keepers – whether major businesses or small keepers with just a few birds – must ensure that their biosecurity is up to scratch to protect their birds from disease. Keepers who are concerned about the health or welfare of their flock should seek veterinary advice immediately. Private vets, or the local Animal and Plant Health Agency office, will also be able to provide practical advice on keeping birds safe from infection.
Declaration of Avian influenza Protection Zone and Protection, Surveillance and Restriction Zones.
Legislation for the H5N1 strain require a Restricted Zone (RZ) to also be declared, however this will also be 10 kilometres and will mirror the geographical footprint of the Surveillance Zone with no additional measures.
In light of evidence from the continent and ongoing high numbers of findings among wild bird populations in GB, the risk of incursion of HPAI H5 via wild birds in GB has increased from low (event is rare but does occur) to medium (event occurs regularly). The risk of poultry and captive bird exposure to HPAI H5 across the whole GB is still low (with medium uncertainty) where biosecurity is sub-optimal, and low (with low uncertainty) where stringent biosecurity measures are applied.
The UK government's outbreak assessment following recent cases in the UK.
In Great Britain, it is a legal requirement for keepers to register their birds if more than 50 birds are kept. Keepers with fewer than 50 birds are strongly encouraged to register. It is also a legal requirement to notify APHA of any significant changes in the average number of birds kept.
Bird flu is a notifiable animal disease. Suspicion of any type of bird flu must be reported immediately. Failure to do so is an offence. Keepers should familiarise themselves with the avian flu advice.
In Great Britain, if a single dead wild waterfowl (swans, geese or ducks), a single dead bird of prey, or five or more dead wild birds of any other species (including gulls) are found at the same place at the same time, they should be reported to Defra's national helpline (03459 33 55 77 - please select option 7). Do not touch or pick up any dead or visibly sick birds
Suspected cases of disease should be reported to the local APHA Field Services Office.
Further biosecurity information