Data types in Java can be divided into two categories:
Basic data types, also called primitive data types
To compare byte, short, char, int, long, float, double, boolean, use the double equal sign (==), and compare their values.
Reference type (class, interface, array)
When they compare using (==), they compare their storage addresses in memory. Therefore, unless they are the same new object, the result of their comparison is true, otherwise the result of the comparison is false. Objects are placed on the heap, and the reference (address) of the object is stored on the stack. First look at the virtual machine memory map and code:
public class testDay {
public static void main(String[] args) {
String s1 = new String("11");
String s2 = new String("11");
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
}
}
Copy after login
The result is:
false true
Both s1 and s2 store the addresses of the corresponding objects. Therefore, if s1== s2 is used, the address values of the two objects are compared (that is, whether the references are the same), which is false. When calling the equals direction, the value in the corresponding address is compared, so the value is true. Here we need to describe equals() in detail.
2. Detailed explanation of equals() method
The equals() method is used to determine whether other objects are equal to this object. It is defined in Object, so any object has the equals() method. The difference is whether the method is overridden or not.
Let’s take a look at the source code first:
public boolean equals(Object obj) { return (this == obj);
}
Copy after login
Obviously, Object defines a comparison of the address values of two objects (that is, comparing whether the references are the same). But why does calling equals() in String compare not the address but the value in the heap memory address? Here is the key point. When encapsulation classes such as String, Math, Integer, Double, etc. use the equals() method, they have already covered the equals() method of the object class. Take a look at the rewritten equals() in String:
public boolean equals(Object anObject) { if (this == anObject) { return true;
} if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length; if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false;
i++;
} return true;
}
} return false;
}
Copy after login
After rewriting, this is the content comparison, and it is no longer the comparison of the previous address. By analogy, classes such as Math, Integer, Double, etc. all override the equals() method to compare contents. Of course, basic types perform value comparisons.
It should be noted that when the equals() method is overridden, hashCode() will also be overridden. According to the implementation of the general hashCode() method, equal objects must have equal hashcodes. Why is this so? Here we briefly mention hashcode.
3. A brief discussion of hashcode()
It is obviously a question about the difference between ==, equals and hashCode in Java, but why is it suddenly related to hashcode(). You must be very depressed, okay, let me give a simple example and you will know why hashCode is involved when == or equals.
For example: If you want to find out whether a collection contains an object, how should you write the program? If you don't use the indexOf method, just traverse the collection and compare whether you think of it. What if there are 10,000 elements in the collection, it would be tiring, right? So in order to improve efficiency, the hash algorithm was born. The core idea is to divide the collection into several storage areas (can be seen as buckets). Each object can calculate a hash code and can be grouped according to the hash code. Each group corresponds to a certain storage area. In this way, an object can be grouped according to the hash code. Its hash code can be divided into different storage areas (different areas).
So when comparing elements, the hashcode is actually compared first, and if they are equal, the equal method is compared.
Look at the hashcode diagram:
#An object generally has a key and a value, and its hashCode value can be calculated based on the key. Then it is stored in different storage areas according to its hashCode value, as shown in the figure above. Multiple values can be stored in different areas because hash conflicts are involved. Simple: If the hashCode of two different objects is the same, this phenomenon is called a hash conflict. Simply put, it means the hashCode is the same but equals is a different value. For comparing 10,000 elements, there is no need to traverse the entire collection. You only need to calculate the hashCode of the key of the object you want to find, and then find the storage area corresponding to the hashCode. The search is over.
Fu f1=new Zi();
Fu f2=new Son();if(f1 instanceof Zi){
System.out.println("f1是Zi的类型");
}else{
System.out.println("f1是Son的类型");
}
Copy after login
4.多态的转型
多态的转型分为向上转型和向下转型两种
向上转型：多态本身就是向上转型过的过程
使用格式：父类类型 变量名=new 子类类型();
适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。
向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型
使用格式：子类类型 变量名=（子类类型）父类类型的变量；
适用场景：当要使用子类特有功能时。
5.多态案例：
例1：
package day0524;
public class demo04 {
public static void main(String[] args) {
People p=new Stu();
p.eat();
//调用特有的方法
Stu s=(Stu)p;
s.study();
//((Stu) p).study();
}
}
class People{
public void eat(){
System.out.println("吃饭");
}
}
class Stu extends People{
@Override
public void eat(){
System.out.println("吃水煮肉片");
}
public void study(){
System.out.println("好好学习");
}
}
class Teachers extends People{
@Override
public void eat(){
System.out.println("吃樱桃");
}
public void teach(){
System.out.println("认真授课");
}
}
Copy after login
答案：吃水煮肉片
好好学习
例2：
请问题目运行结果是什么？
package day0524;
public class demo1 {
public static void main(String[] args) {
A a=new A();
a.show();
B b=new B();
b.show();
}
}
class A{
public void show(){
show2();
}
public void show2(){
System.out.println("A");
}
}
class B extends A{
public void show2(){
System.out.println("B");
}
}
class C extends B{
public void show(){
super.show();
}
public void show2(){
System.out.println("C");
}
}
Copy after login
答案：A B
5. String、StringBuffer和StringBuilder区别
1、长度是否可变
String 是被 final 修饰的，他的长度是不可变的，就算调用 String 的concat 方法，那也是把字符串拼接起来并重新创建一个对象，把拼接后的 String 的值赋给新创建的对象
7. The difference between abstract classes and interfaces
Abstract classes must be inherited by subclasses, and interfaces must be implemented by classes.
Interfaces can only make method declarations, while abstract classes can make method declarations and method implementations.
The variables defined in the interface can only be public static constants, and the variables in the abstract class are ordinary variables.
Interface is the result of design, and abstract class is the result of refactoring.
Abstract classes and interfaces are used to abstract specific objects, but interfaces have the highest abstraction level.
Abstract classes can have specific methods and properties, while interfaces can only have abstract methods and immutable constants.
Abstract classes are mainly used to abstract categories, and interfaces are mainly used to abstract functions.
8. The meaning of abstract class
Abstract class:
If a class contains abstract methods, the class should be declared as an abstract class using the abstract keyword.
Meaning:
Provides a public type for subclasses;
encapsulates repeated content (member variables and methods) in subclasses ;
defines an abstract method. Although subclasses have different implementations, the definition of this method is consistent.
9. Application scenarios of abstract classes and interfaces
1. Application scenarios of interfaces:
Necessary specificity between classes interface, regardless of how it is implemented.
Exists as an identifier that can implement a specific function, or it can be a pure identifier without any interface methods.
It is necessary to treat a group of classes as a single class, and the caller only contacts this group of classes through the interface.
Need to implement specific multiple functions, and these functions may have no connection at all.
2. Application occasions of abstract class (abstract.class):
In a word, when both a unified interface and instance variables or default methods are needed , you can use it. The most common ones are:
defines a set of interfaces, but does not want to force each implementation class to implement all interfaces. You can use abstract.class to define a set of method bodies, or even empty method bodies, and then the subclass can choose the methods it is interested in to cover.
In some cases, pure interfaces alone cannot satisfy the coordination between classes. Variables representing states in the class must also be used to distinguish different relationships. The intermediary role of abstract can satisfy this very well.
Specifies a set of mutually coordinated methods, some of which are common, independent of state, and can be shared without the need for subclasses to implement them separately; while other methods require each subclass to implement it according to its own specific State to achieve specific functions
10. Can an abstract class have no methods and attributes?
The answer is: Yes
There can be no abstract methods in abstract classes, but those with abstract methods must be abstract classes. Therefore, there can be no abstract methods in abstract classes in Java. Note that even abstract classes without abstract methods and properties cannot be instantiated.
11. 接口的意义
定义接口的重要性：在Java编程，abstract class 和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在，才使得Java成为面向对象的编程语言。
public class Food {}
public class Fruit extends Food {}
public class Apple extends Fruit {}
public class Banana extends Fruit{}
public class GenericTest {
public void testExtends(List extends Fruit> list){
//报错,extends为上界通配符,只能取值,不能放.
//因为Fruit的子类不只有Apple还有Banana,这里不能确定具体的泛型到底是Apple还是Banana，所以放入任何一种类型都会报错
//list.add(new Apple());
//可以正常获取
Fruit fruit = list.get(1);
}
public void testSuper(List super Fruit> list){
//super为下界通配符，可以存放元素，但是也只能存放当前类或者子类的实例，以当前的例子来讲，
//无法确定Fruit的父类是否只有Food一个(Object是超级父类)
//因此放入Food的实例编译不通过
list.add(new Apple());
// list.add(new Food());
Object object = list.get(1);
}
}
class Fruit{
static String color = "五颜六色";
static public void call() {
System.out.println("这是一个水果");
}
}
public class Banana extends Fruit{
static String color = "黄色";
static public void call() {
System.out.println("这是一个香蕉");
}
public static void main(String[] args) {
Fruit fruit = new Banana();
System.out.println(fruit.color); //五颜六色
fruit.call(); //这是一个水果
}
}
Definition: A process is a running activity of a program on a certain data collection; a thread is an execution path in a process. (A process can create multiple threads)
Role aspect: In a system that supports the thread mechanism, the process is the unit of system resource allocation, and the thread is the unit of CPU scheduling.
Resource sharing: Resources cannot be shared between processes, but threads share the address space and other resources of the process in which they are located. At the same time, the thread also has its own stack, stack pointer, program counter and other registers.
In terms of independence: The process has its own independent address space, but the thread does not. The thread must depend on the process to exist.
In terms of overhead. Process switching is expensive. Threads are relatively small. (As mentioned before, the introduction of threads is also due to cost considerations.)
You can read this article: juejin.im/post/684490…
15. The difference between final, finally, and finalize
final is used to declare properties, methods and classes, which respectively means that properties are immutable, methods cannot be overridden, and classes cannot be inherited.
finally is exception handling Part of the statement structure, indicating that it is always executed.
finalize is a method of the Object class. This method of the recycled object will be called when the garbage collector is executed. This method can be overridden to provide other functions during garbage collection. Resource recycling, such as closing files, etc.
16. The difference between serialization Serializable and Parcelable
If Intent in Android wants to transfer class objects, it can be achieved in two ways.
Method 1: Serializable, the class to be passed implements the Serializable interface to pass the object,
Method 2: Parcelable, the class to be transferred implements the Parcelable interface to transfer the object.
Serializable (comes with Java): Serializable means serialization, which means converting an object into a storable or transmittable state. Serialized objects can be transmitted over the network or stored locally. Serializable is a tagged interface, which means that Java can efficiently serialize this object without implementing methods.
Parcelable (Android-specific): The original design intention of Android's Parcelable is because Serializable is too slow (using reflection), in order to facilitate communication between different components in the program and between different Android programs (AIDL) Designed to efficiently transfer data that only exists in memory. The implementation principle of the Parcelable method is to decompose a complete object, and each part after decomposition is a data type supported by Intent, thus realizing the function of passing the object.
Efficiency and selection:
The performance of Parcelable is better than that of Serializable, because the latter frequently GCs during the reflection process, so it is recommended to use Parcelable when transferring data between memories, such as transferring data between activities. Serializable can persist data for easy storage, so choose Serializable when you need to save or transmit data over the network. Because Parcelable may be different in different versions of Android, it is not recommended to use Parcelable for data persistence. Parcelable cannot be used when data is to be stored on disk, because Parcelable cannot guarantee the persistence of data when the outside world changes. Although Serializable is less efficient, it is still recommended to use Serializable at this time.
When passing complex data types through intent, one of the two interfaces must be implemented first. The corresponding methods are getSerializableExtra() and getParcelableExtra().
17. Can static properties and static methods be inherited? Can it be rewritten? And why?
The static properties and methods of the parent class can be inherited by the subclass
cannot be overridden by the subclass : When the reference of the parent class points to the subclass When using an object to call a static method or static variable, the method or variable in the parent class is called. It is not overridden by subclasses.
Reason:
Because the static method has allocated memory since the program started running, which means it has been hard-coded. All objects that reference this method (either objects of the parent class or objects of the subclass) point to the same piece of data in memory, which is the static method.
If a static method with the same name is defined in a subclass, it will not be overridden. Instead, another static method in the memory should be allocated to the subclass, and there is no such thing as rewriting.
18 The design intention of static inner classes in .java
Inner classes
Inner classes are classes defined inside a class. Why are there inner classes?
We know that in Java, classes are single inheritance, and a class can only inherit another concrete class or abstract class (which can implement multiple interfaces). The purpose of this design is that in multiple inheritance, when there are duplicate attributes or methods in multiple parent classes, the call results of the subclass will be ambiguous, so single inheritance is used.
The reason for using inner classes is that each inner class can independently inherit an (interface) implementation, so whether the outer class has inherited an (interface) implementation, it has no effect on the inner class.
In our programming, sometimes there are some problems that are difficult to solve using interfaces. At this time, we can use the ability provided by internal classes to inherit multiple concrete or abstract classes to solve these programs. Design issues. It can be said that interfaces only solve part of the problem, and inner classes make the solution of multiple inheritance more complete.
Static inner classes
Before talking about static inner classes, first understand the member inner classes (non-static inner classes).
Member inner class
Member inner class is also the most common inner class. It is a member of the outer class, so it can have unlimited access to all the outer classes. Although the member attributes and methods are private, if the outer class wants to access the member attributes and methods of the inner class, it needs to access it through the inner class instance.
Two points should be noted in the member inner class:
There cannot be any static variables and methods in the member inner class;
The member inner class is attached to the outer class, so the inner class can only be created after the outer class is created first.
Static inner class
There is one biggest difference between static inner classes and non-static inner classes: non-static inner classes are compiled after they are compiled A reference is then implicitly held to the outside world in which it was created, but the static inner class does not.
The absence of this reference means:
Its creation does not need to depend on the peripheral class.
It cannot use non-static member variables and methods of any peripheral class.
The other two internal classes: local internal classes and anonymous internal classes
Local internal classes
Local internal classes are Nested within methods and scopes, the use of this class is mainly to apply and solve more complex problems. We want to create a class to assist our solutions, but by then we do not want this class to be publicly available, so we A local inner class is generated. The local inner class is compiled like the member inner class, but its scope changes. It can only be used in this method and attribute, and it will become invalid when the method and attribute are removed.
Anonymous inner classes
Anonymous inner classes have no access modifiers.
new Anonymous inner class, this class must exist first.
When the formal parameter of the method needs to be used by the anonymous inner class, then the formal parameter must be final.
Anonymous inner classes have no explicit constructor, and the compiler will automatically generate a constructor that references the outer class.
The above is the detailed content of Summary of 2020 new Java basic interview questions. For more information, please follow other related articles on the PHP Chinese website!
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
