Sealed classes in Kotlin are a special kind of class that restricts class hierarchies to a limited set of types. They allow you to define a closed set of subclasses, which can be useful for representing restricted types in a type-safe manner, such as when modeling state machines or representing different outcomes in a result. You would use them when you want to ensure that all possible subclasses are known at compile time, enhancing type safety and making it easier to handle different cases in a `when` expression.
A companion object in Kotlin is an object that is tied to a class rather than to instances of the class. It allows you to define members (properties and methods) that can be accessed directly via the class name, similar to static members in Java.
– **Open**: A class marked as open can be subclassed. By default, classes are final and cannot be inherited.
– **Abstract**: An abstract class cannot be instantiated and may contain abstract methods (without implementation) that must be implemented by subclasses. It can also have concrete methods.
– **Interface**: An interface defines a contract with abstract methods (which do not have implementations) and can also contain default methods with implementations. Classes can implement multiple interfaces.
To optimize performance in Kotlin-based Android apps, you can:
1. Use lazy initialization for properties.
2. Minimize object allocations by using primitive types and avoiding unnecessary object creation.
3. Leverage coroutines for asynchronous programming to avoid blocking the main thread.
4. Use the `inline` keyword for higher-order functions to reduce overhead.
5. Optimize UI rendering by using RecyclerView and ViewHolder patterns.
6. Profile and analyze performance using Android Profiler to identify bottlenecks.
7. Use Kotlin's built-in functions like `map`, `filter`, and `reduce` efficiently.
8. Avoid using reflection as it can slow down performance.
9. Use data classes for immutable data structures to reduce boilerplate and improve performance.
In Kotlin, you handle exceptions using the `try`, `catch`, and `finally` blocks. You can wrap the code that may throw an exception in a `try` block, catch specific exceptions in `catch` blocks, and use a `finally` block for code that should run regardless of whether an exception occurred. Here's an example:
“`kotlin
try {
// Code that may throw an exception
} catch (e: SpecificException) {
// Handle the exception
} finally {
// Code that runs regardless of an exception
}
“`
Right Answer: RESTful APIs use standard HTTP methods and are based on resources, while SOAP is a protocol that relies on XML messaging and has strict standards. REST is generally more lightweight and easier to use, while SOAP provides more security and transactional reliability.
Right Answer: API versioning is the practice of managing changes to an API by assigning version numbers to different iterations of the API. It is important in RESTful design because it allows developers to introduce new features or make changes without breaking existing client applications that rely on older versions, ensuring backward compatibility and a smoother transition for users.
Right Answer: Statelessness in REST means that each request from a client to a server must contain all the information needed to understand and process that request. The server does not store any client context between requests, making each interaction independent.
Right Answer: Content negotiation in REST APIs is the process by which a client and server agree on the format of the response data. This is typically done through HTTP headers, allowing clients to specify their preferred media type (like JSON or XML) and the server to respond accordingly based on the client's request.
Right Answer: A RESTful API is an application programming interface that follows the principles of Representational State Transfer (REST). It uses standard HTTP methods (GET, POST, PUT, DELETE) to perform operations on resources, which are identified by URLs. Clients interact with the API by sending requests to these URLs, and the server responds with data, typically in JSON or XML format, allowing for stateless communication and easy scalability.
Right Answer: MongoDB offers several security features, including:
1. **Authentication**: Supports various methods like SCRAM, LDAP, and Kerberos to verify user identities.
2. **Authorization**: Role-based access control (RBAC) to manage user permissions and access to resources.
3. **Encryption**: Data encryption at rest and in transit using TLS/SSL.
4. **Auditing**: Tracks and logs database operations for security compliance and monitoring.
5. **Network Security**: IP whitelisting and VPC peering to restrict access to the database.
6. **Field Level Encryption**: Allows encryption of specific fields in documents for added security.
Right Answer: In MongoDB, schema design involves defining collections and documents based on the application's needs, using a flexible schema to accommodate varying data structures. Key considerations include embedding related data within documents for performance, using references for large or frequently updated data, and ensuring efficient indexing for query performance. It's important to anticipate data access patterns and optimize for read and write operations accordingly.
Right Answer: MongoDB is a NoSQL database that stores data in flexible, JSON-like documents, allowing for dynamic schemas, while MySQL is a relational database that uses structured tables with fixed schemas and SQL for querying.
Right Answer: Embedded documents are stored within a parent document, allowing for a nested structure and faster access to related data. Referenced documents, on the other hand, are stored separately and linked by a reference ID, which can help maintain data normalization and reduce duplication.
