Java面试精华：Android OOP概念详解与面试技巧

需积分: 10 94 浏览量更新于2024-07-18 收藏 1.79MB PDF 举报

在Android面试中，面试官经常会询问关于Android开发的基础知识以及面向对象编程（Object-Oriented Programming，OOP）的相关概念。本文档提供了一系列常见的Android面试问题，其中包括对OOP核心概念的解释。首先，OOP是通过类（Classes）、对象（Objects）、继承（Inheritance）、多态（Polymorphism）和封装（Encapsulation）等原则来设计程序的方法论。以下是这四个关键概念的详细阐述： 1. **抽象（Abstraction）**：抽象允许开发者使用简单的事物来表示复杂性。例如，我们使用遥控器开关电视，无需了解其内部工作原理也能正常使用。在Java中，抽象表现为对象、类和变量，它们代表更复杂的底层代码和数据结构。通过抽象，我们可以避免在多个地方重复相同的实现，提高代码的可维护性和复用性。 2. **封装（Encapsulation）**：封装是指将类的字段（数据）设置为私有状态，只通过公共方法（Public Methods）提供访问权限。这样做形成了一个保护屏障，确保数据的安全性，防止系统范围内的其他部分直接修改数据。这使得我们能够像复用代码组件或变量一样重用对象，保持代码的完整性。 3. **继承（Inheritance）**：这是Java中面向对象的一个重要特性，它允许创建新的类，这些新类可以继承现有类的属性和行为。通过继承，程序员可以在已有基础上扩展功能，减少代码冗余，实现代码的层次化和模块化设计。 4. **多态（Polymorphism）**：多态性允许不同类的对象使用相同的接口执行不同的操作。在Java中，通过方法重写（Overriding）和方法重载（Overloading），同一个方法名可以有不同的实现，根据对象的实际类型动态决定执行哪个版本，增强了代码的灵活性和可扩展性。掌握这些OOP概念对于Android开发人员来说至关重要，因为它们是构建Android应用程序的基础，无论是设计用户界面、处理数据结构，还是创建可维护的模块化代码，都离不开这些概念的运用。面试时，准备对这些概念的深入理解和实践经验，将有助于你在Android面试中脱颖而出。

29. What is the difference between instantiation and initialization of an object ?

Ans.

Initialization is the process of the memory allocation, when a new variable is created. Variables should be explicitly given a value, otherwise they may

contain a random value that remained from the previous variable that was using the same memory space. To avoid this problem Java language assigns

default (right after initialization) values to some data types:

boolean defaults to false;

byte defaults to 0;

short defaults to 0;

int defaults to 0;

long defaults to 0L;

char defaults to \u0000;

float defaults to 0.0f;

double defaults to 0.0d;

object defaults to null.

Instantiation is the process of assigning definitive value to a declared variable:

int j; // Initialized variable (int defaults to 0 right after)

j = 10; // Instantiated variable

30. When is a static block run ?

Ans.

Static initialization blocks are run when the JVM (class loader - to be specific) loads StaticClass (which occurs the first time it is referenced in code).

You could force this method to be invoked by explicitly calling StaticClass.init() which is preferable to relying on the JVM.

You could also try using Class.forName(String) to force the JVM to load the class and invoke its static blocks.

Example:-

public class StaticClass {

static {

init();

}

public void static init () {

// do some initialization here

}

31. Explain Generics in Java ?

Ans.

Consider the following scenario: You wish to develop a container that will be used to pass an object around within your application. However, the object type

is not always going to be the same. Therefore, you need to develop a container that has the ability to store objects of various types.

Given this scenario, the most obvious way to achieve the goal would be to develop a container that has the ability to store and retrieve the Object type itself,

and then cast that object when using it with various types. The class in Listing 1 demonstrates development of such a container.

public class ObjectContainer {

private Object obj;

/**

* @return the obj

public Object getObj() {

return obj;

}

/**

* @param obj the obj to set

public void setObj(Object obj) {

this.obj = obj;

}

Listing 1

Although this container would achieve the desired result, it would not be the most suitable solution for our purpose, because it has the potential to cause

exceptions down the road, since it is not type-safe and it requires you to use an explicit cast whenever the encapsulated object is retrieved. The code in

Listing 2 demonstrates how you would use this container to store and retrieve values.

ObjectContainer myObj = new ObjectContainer();

// store a string

myObj.setObj("Test");

System.out.println("Value of myObj:" + myObj.getObj());

// store an int (which is autoboxed to an Integer object)

myObj.setObj(3);

System.out.println("Value of myObj:" + myObj.getObj());

List objectList = new ArrayList();

objectList.add(myObj);

// We have to cast and must cast the correct type to avoid ClassCastException!

String myStr = (String) ((ObjectContainer)objectList.get(0)).getObj();

System.out.println("myStr: " + myStr);

Listing 2

Generics could be used to develop a better solution using a container that can have a type assigned at instantiation, otherwise referred to as a generic type,

allowing the creation of an object that can be used to store objects of the assigned type. A generic type is a class or interface that is parameterized over

types, meaning that a type can be assigned by performing generic type invocation, which will replace the generic type with the assigned concrete type. The

assigned type would then be used to restrict values being used within the container, which eliminates the requirement for casting, as well as provides

stronger type-checking at compile time.

The class in Listing 3 demonstrates how to create the same container that was previously created, but this time using a generic type parameter, rather than

the Object type.

public class GenericContainer<T> {

private T obj;

public GenericContainer(){

}

// Pass type in as parameter to constructor

public GenericContainer(T t){

obj = t;

}

/**

* @return the obj

public T getObj() {

return obj;

}

/**

* @param obj the obj to set

public void setObj(T t) {

obj = t;

}

Listing 3

The most notable differences are that the class definition contains <T>, and the class field obj is no longer of type Object, but rather, it is the generic type T.

The angle brackets in the class definition enclose the type parameter section, introducing the type parameter (or parameters) that will be used within the

class. T is a parameter that is associated with the generic type that is being defined in this class.

To use the generic container, you must assign the type of the container by specifying it at instantiation using the angle bracket notation. Therefore, the

following code would instantiate a GenericContainer of type Integer and assign it to the field myInt.

GenericContainer<Integer> myInt = new GenericContainer<Integer>();

If we tried to store a different type of object within the container that we've instantiated, the code would not compile:

myInt.setObj(3); // OK

myInt.setObj("Int"); // Won't Compile

How Can You Use Generics?

There are many different use cases for generics. The first example in this article covered the use case of generating a generic object type. This is a good

starting point to learn about the syntax of generics at a class and interface level. Examining the code, the class signature contains a type parameter section,

which is enclosed within angle brackets (< >) after the class name, for example:

public class GenericContainer<T> {

...

Type parameters, also known as type variables, are used as placeholders to indicate that a type will be assigned to the class at runtime. There may be one

or more type parameters, and they can be utilized throughout the class, as needed. By convention, type parameters are a single uppercase letter, and the

letter that is used indicates the type of parameter being defined. The following list contains the standard type parameters for each use case:

E: Element

K: Key

N: Number

T: Type

V: Value

S, U, V, and so on: Second, third, and fourth types in a multiparameter situation

In the example above, the T indicates that a type will be assigned, so GenericContainer can be assigned any valid type upon instantiation. Note that the T

parameter is utilized throughout the class to indicate the type that is specified at instantiation. When the following line is used to instantiate the object, each

of the T parameters is replaced with the String type:

GenericContainer<String> stringContainer = new GenericContainer<String>();

Generics can also be used within constructors to pass type parameters for class field initialization. GenericContainer has a constructor that allows any type

to be passed in at instantiation:

GenericContainer gc1 = new GenericContainer(3);

GenericContainer gc2 = new GenericContainer("Hello");

Note that a generic that does not have a type assigned to it is known as a raw type. For instance, to create a raw type of GenericContainer, you could use

the following:

GenericContainer rawContainer = new GenericContainer();

Raw types can sometimes be useful for backward compatibility, but it is not a good idea to use them in everyday code. Raw types eliminate type-checking

at compile time, allowing code to become error-prone at runtime.

next>><<prev

Generics in Java

The Java Generics programming is introduced in J2SE 5 to deal with type-safe objects.

Before generics, we can store any type of objects in collection i.e. non-generic. Now generics, forces the java programmer to store specific type of objects.

Advantage of Java Generics

There are mainly 3 advantages of generics. They are as follows:

Type-safety : We can hold only a single type of objects in generics. It doesn’t allow to store other objects.

Type casting is not required: There is no need to typecast the object.

Before Generics, we need to type cast.

List list = new ArrayList();

list.add("hello");

String s = (String) list.get(0);//typecasting

After Generics, we don't need to typecast the object.

List<String> list = new ArrayList<String>();

list.add("hello");

String s = list.get(0);

Compile-Time Checking: It is checked at compile time so problem will not occur at runtime. The good programming strategy says it is far better to handle

the problem at compile time than runtime.

List<String> list = new ArrayList<String>();

list.add("hello");

list.add(32);//Compile Time Error

Syntax to use generic collection

ClassOrInterface<Type>

Example to use Generics in java

ArrayList<String>

32. Difference between StringBuffer and StringBuilder ?

Ans.

There are many differences between StringBuffer and StringBuilder. A list of differences between StringBuffer and StringBuilder are given below:

StringBuffer

1) StringBuffer is synchronized i.e. thread safe. It means two threads can't call the methods of StringBuffer simultaneously.

2) StringBuffer is less efficient than StringBuilder.

StringBuilder

1) StringBuilder is non-synchronized i.e. not thread safe. It means two threads can call the methods of StringBuilder simultaneously.

2) StringBuilder is more efficient than StringBuffer.

StringBuffer Example

public class BufferTest{

public static void main(String[] args){

StringBuffer buffer=new StringBuffer("hello");

buffer.append("java");

System.out.println(buffer);

}

hellojava

StringBuilder Example

public class BuilderTest{

public static void main(String[] args){

StringBuilder builder=new StringBuilder("hello");

builder.append("java");

System.out.println(builder);

}

hellojava

Performance Test of StringBuffer and StringBuilder

Let's see the code to check the performance of StringBuffer and StringBuilder classes.

public class ConcatTest{

public static void main(String[] args){

long startTime = System.currentTimeMillis();

StringBuffer sb = new StringBuffer("Java");

for (int i=0; i<10000; i++){

sb.append("Tpoint");

}

System.out.println("Time taken by StringBuffer: " + (System.currentTimeMillis() - startTime) + "ms");

startTime = System.currentTimeMillis();

StringBuilder sb2 = new StringBuilder("Java");

for (int i=0; i<10000; i++){

sb2.append("Tpoint");

}

System.out.println("Time taken by StringBuilder: " + (System.currentTimeMillis() - startTime) + "ms");

}

Time taken by StringBuffer: 16ms

Time taken by StringBuilder: 0ms

33. How is a StringBuilder implemented to avoid the immutable string allocation problem ?

Ans.

How StringBuilder works internally?

String and StringBuilder, Immutability and Mutability are famous topics and they are discussed around everywhere, but i wondered how StringBuilder had

aided advantages over String and StringBuffer.

There are few things that matter.

1. String is immutable, which means each time you try to concatenate or use any method, it creates a new object and returns you the modified object.

2. StringBuffer, is a buffer but its synchronized, and too expensive for memory, so it should be avoided. If you need synchronization You can use locks etc.

otherwise.

3. StringBuilder in JSE 1.5 is superior to above two, its mutable, its not synchronized. Its mutable because it does not create String reference each time you

try to invoke its methods, i.e. append(), rather it changes. It should be used if your String opperations are larger. Do not use it if you just want to concatenate

a String for 3 or 4 times or known number of times.

How StringBuilder Works?

It's Object maintains a buffer to accommodate the concatenation of new data. New data is added to the end of the buffer if room is available; otherwise, a

new, larger buffer is allocated, data from the original buffer is copied to the new buffer, then the new data is appended to the new buffer.

Following is the code snippet from AbstractStringBuilder which is super class of StringBuilder.

public AbstractStringBuilder append(String str) {

if (str == null) str = "null";

int len = str.length();

if (len == 0) return this;

int newCount = count + len;

if (newCount > value.length)

expandCapacity(newCount);

str.getChars(0, len, value, count);

count = newCount;

return this;

}

void expandCapacity(int minimumCapacity) {

int newCapacity = (value.length + 1) * 2;

if (newCapacity <>

newCapacity = Integer.MAX_VALUE;

} else if (minimumCapacity > newCapacity) {

newCapacity = minimumCapacity;

}

value = Arrays.copyOf(value, newCapacity);

}

34. What is Autoboxing and Unboxing ?

Ans.

Java 5 introduced autoboxing and unboxing feature that is a convenient way to auto transform primitive data type to it’s corresponding java wrapper classes

and vice versa.

Autoboxing in Java

Converting a primitive data type into an object of the corresponding wrapper class is called autoboxing. For example, converting int to Integer or converting

long to Long object.

Java compiler applies autoboxing when a primitive value is:

Passed as a parameter to a method that expects an object of the corresponding wrapper class. For example a method with Integer argument can be called

by passing int, java compiler will do the conversion of int to Integer.

Assigned to a variable of the corresponding wrapper class. For example, assigning a Long object to long variable.

Unboxing in Java

Converting an object of a wrapper type to its corresponding primitive data type is called unboxing.

Java compiler applies unboxing when an object of a wrapper class is:

* Passed as a parameter to a method that expects a value of the corresponding primitive type.

* Assigned to a variable of the corresponding primitive type.

Here is a small java program showing examples of autoboxing and unboxing in java.

AutoboxingUnboxing.java

package com.journaldev.misc;

import java.util.ArrayList;

import java.util.List;

public class AutoboxingUnboxing {

public static void main(String[] args) {

int i = 5;

long j = 105L;

//passed the int, will get converted to Integer object at Runtime

doSomething(i);

List<Long> list = new ArrayList<>();

//autoboxing to add primitive type in collection classes

list.add(j);

}

private static void doSomething(Integer in){

//unboxing, at runtime Integer.intValue() is called implicitly to return int

int j = in;

//unboxing, Integer is passed where int was expected

doPrimitive(in);

}

private static void doPrimitive(int i) {

}

35. What’s the difference between an Enumeration and an Iterator ?

Ans.

Enumeration and Iterator are two interfaces in java.util package which are used to traverse over the elements of a Collection object. Though they perform

the same function i.e traversing the Collection object, there are some differences exist between them. Using Enumeration, you can only traverse the

Collection object. But using Iterator, you can also remove an element while traversing the Collection. This is the one major difference between Enumeration

and Iterator in java. You can say Iterator is some what advanced version of Enumeration.

Differences Between Enumeration And Iterator In Java :

1) Introduction

Iterator interface is introduced from JDK 1.2 where as Enumeration interface is there from JDK 1.0.

2) remove() method

This is the main difference between Enumeration and Iterator interface. Enumeration only traverses the Collection object. You can’t do any modifications to

Collection while traversing the Collection using Enumeration. Where as Iterator interface allows us to remove an element while traversing the Collection

object. Iterator has remove() method which is not there in the Enumeration interface. Below is the list of Enumeration and Iterator methods.

Iterator Enumeration

hasNext() hasMoreElements()

next() nextElement()

remove() (Not Available)

3) Legacy Interface

Enumeration is a legacy interface used to traverse only the legacy classes like Vector, HashTable and Stack. Where as Iterator is not a legacy code which

is used to traverse most of the classes in the collection framework. For example, ArrayList, LinkedList, HashSet, LinkedHashSet, TreeSet, HashMap,

LinkedHashMap, TreeMap etc.

4) Fail-Fast Vs Fail-Safe

Iterator is a fail-fast in nature. i.e it throws ConcurrentModificationException if a collection is modified while iterating other than it’s own remove() method.

Where as Enumeration is fail-safe in nature. It doesn’t throw any exceptions if a collection is modified while iterating. [See more]

5) Safe And Secure

As Iterator is fail-fast in nature and doesn’t allow modification of a collection by other threads while iterating, it is considered as safe and secure than

Enumeration.

6) Which One To Use

According to Java API Docs, Iterator is always preferred over the Enumeration. Here is the note from the Enumeration Docs.

NOTE: The functionality of this interface is duplicated by the Iterator interface. In addition, Iterator adds an optional remove operation, and has shorter

method names. New implementations should consider using Iterator in preference to Enumeration.

Enumeration Vs Iterator In Java :

Enumeration

1. Using Enumeration, you can only traverse the collection. You can’t do any modifications to collection while traversing it.

2. Enumeration is introduced in JDK 1.0

3. Enumeration is used to traverse the legacy classes like Vector, Stack and HashTable.

4. Methods : hasMoreElements() and nextElement()

5. Enumeration is fail-safe in nature.

6. Enumeration is not safe and secured due to it’s fail-safe nature.

Iterator

剩余95页未读，继续阅读

粉丝: 0
资源: 1

Java面试精华：Android OOP概念详解与面试技巧

英文面试：101 GREAT ANSWERS TO THE TOUGHEST INTERVIEW QUESTIONS

Android代码-AndroidInterview-Q-A

webpack面试题整理链接

用swing写一个在线考试系统

用java写一个问答小程序

算术运算测试:功能要求:该程序实现十道100以内加减法数学 题，能根据题目计算出答案，与输入答案对比，判断做题是否正确， 最后计算分数

最新资源

算术运算测试:功能要求:该程序实现十道100以内加减法数学题，能根据题目计算出答案，与输入答案对比，判断做题是否正确，最后计算分数