Java基础知识（基本概念）

最新推荐文章于 2022-01-03 19:03:54 发布

加加大了

最新推荐文章于 2022-01-03 19:03:54 发布

阅读量290

点赞数

分类专栏：程序员面试笔试宝典笔记文章标签： java 编程语言

本文链接：https://blog.csdn.net/qq_33700236/article/details/106908607

版权

程序员面试笔试宝典笔记专栏收录该内容

24 篇文章 2 订阅

订阅专栏

1.基本概念

1.1 java的优点

1.Java 为纯面向对象的语言，它能够直接反应现实生活中的对象，例如火车、动物等，因此通过它，开发人员更容易编写程序。
2.平台无关性。Java 语言可以一次编译，到处运行。由于 Java 为解释型语言，编译器会把 Java 代码变成“中间代码”，然后在 JVM（Java Virtual Machine，Java 虚拟机）上被解释执行。由于中间代码与平台无关，所以，Java 语言可以很好地跨平台执行，具有很好的可移植性。
3.Java 提供了很多内置的类库，通过这些类库，简化了开发人员的程序设计工作，同时缩短了项目的开发时间。最重要的一点是提供了垃圾回收器，把开发人员从对内存的管理中解脱出来。
4.提供了对 Web 应用开发的支持，例如 Applet、Servlet 和 JSP 可以用来开发 Web应用程序。
5.具有较好的安全性和健壮性。Java 语言提供了一个防止恶意代码攻击的安全机制（数组边界检测和 byte code 校验等）。Java 的强类型机制、垃圾回收器、异常处理和安全检查机制使得使用 Java 语言编写的程序有很好的健壮性。
6.去除了 C++语言中难以理解、容易混淆的特性，例如头文件、指针、结构、单元、运算符重载、虚拟基础类、多重继承等，使得程序更加严谨、简洁。

1.2 java与c/c++的区别

1.Java 为解释性语言，运行的过程为：源代码经过 Java 编译器编译成字节码，然后由 JVM 解释执行。
C/C++为编译型语言，源代码经过编译和链接后生成可执行的二进制代码。因此，Java 的执行速度比 C/C++慢，但是 Java 能够跨平台执行，而 C/C++不能。
2.Java 为纯面向对象语言，所有的代码（包括函数、变量等）必须在类中来实现，除基本数据类型（包括 int、float 等）以外，所有的类型都是类。Java 语言中不存在全局变量或全局函数，而 C++兼具面向过程和面向对象编程的特点，可以定义全局变量和全局函数。
3.与 C/C++语言相比，Java 语言中没有指针的概念
4.与 C++语言相比，Java 语言不支持多重继承，但是 Java 语言引入了接口的概念，可以同时实现多个接口，由于接口也具有多态的特性，因此在 Java 语言中可以通过实现多个接口来实现与 C++语言中多重继承类似的目的。
5.在 C++语言中，需要开发人员去管理对内存的分配（包括申请与释放），而 Java语言提供了垃圾回收器来实现垃圾的自动回收，不需要程序显式地管理内存的分配。
6.Java 具有平台无关性，即对每种数据类型都分配固定长度

Java 提供对注释文档的内建支持，所以源码文件也可以包含它们自己的文档。
Java 包含了一些标准库，用于完成特定的任务，同时这些库简单易用，能够缩短开发周期。

1.3 为什么需要 public static void main(String[] args)这个方法？

该方法为程序的入口方法，JVM在运行程序时，先查找main方法。public为权限修饰符，表示任何类或对象都可以访问这个方法，static表明main方法是一个静态方法，即方法中的代码存在静态存储区中，当类被加载后，就可以使用该方法而不需要通过实例化对象访问，可以查找通过类名.main直接访问，JVM在启动时按照上述方法的签名（必须有public与static修饰，返回值为void，方法的参数为字符串数组）查找方法的入口地址，如果能找到就执行，找不到就不会报错。void表示方法没有返回值，main方法是JVM识别的特殊方法名，字符串数组参数args为在命令行下雨程序交互提供一种手段。
因为main为程序入口方法，因此当程序运行时，第一个执行的方法就是main方法，有main是程序的入口方法，此时没有实例化对象，因此在编写main方法的时候要求不需要实例化对象就可以调用这个方法。
注：
1.main方法的其他可用的定义格式：

1.由于public与static没有先后顺序，则 static public void main(String[] args)也合理。
2.也可以将main方法定义为final，public static final void main(String[] args)。
3.用synchronized修饰main方法，static public synchronized void main(String[] args)。

但是，这些格式都必须保证main方法的返回值为void，有static与public修饰。
2.同一个.java 文件中是否可以有多个 main 方法？
只有与文件名相同的用public修饰的类中的main方法才能作为整个程序的入口方法。

1.4 在main方法执行前输出“hello word”

由于静态块在类被加载的时候就被调用，所以可以在main方法执行前，使用静态块实现。

public class Test {
static{
	System.out.println("Hello World1");
}
public static void main(String args[]) {
 	System.out.println("Hello World2");
	} 
}

1.5 java程序初始化的顺序

当实例化对象时，对象所在的类的所有成员变量先要进行初始化，只有当所有类成员完成初始化，才会调用对象所在类的构造函数创建对象。
java的初始化一般遵循以下三个原则：
1.静态对象（变量）优于非静态对象（变量）初始化，其中静态对象（变量）只初始化一次，非静态对象（变量）会初始化多次。
2.父类优于子类进行初始化。
3.按照成员变量定义顺序进行初始化。即使变量定义散布在方法定义中，依然在任何方法被调用之前先初始化。
java程序初始化可在许多不同代码中完成。执行顺序：父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量、父类非静态代码块、父类构造函数、子类非静态变量、子类非静态代码块、子类构造函数。

1.6 Java作用域

java中主要有三种类型变量：成员变量、静态变量、局部变量。类的成员变量作用范围与类实例化对象作用范围一样，当类被实例化，成员变量会在内存中分配空间并初始化，直到被实例化对象的生命周期结束，成员变量的生命周期才结束。被static修饰的变量为静态变量或全局变量，静态变量不依赖于特定的实例，被所有实例共享，只要一个类被加载，JVM给类的静态变量分配存储空间。局部变量作用范围与可见性为所在的花括号中。
在这里插入图片描述
这些修饰符只能修饰成员变量，不能用来修饰局部变量。private与protected不能用来修饰类。

1.7 什么是构造函数

构造函数是一种特殊的函数，用来在对象实例化时初始化对象的成员变量。在 Java 语言中，构造函数具有以下特点。
（1）构造函数必须与类的名字相同，并且不能有返回值（返回值也不能为 void）。
（2）每个类可以有多个构造函数。当开发人员没有提供时，系统会有一个默认无参构造函数；若开发人员提供构造函数，则编译器不再创建默认构造函数。
（3）构造函数可以有 0 个、1 个或 1 个以上的参数。
（4）构造函数总是伴随着 new 操作一起调用，不能由程序的编写者直接调用，必须要由系统调用。构造函数在对象实例化的时候会被自动调用，且只运行一次，而普通的方法是在程序执行到它的时候被调用的，可以被该对象调用多次。
（5）构造函数不能被继承，因此，它不能被覆盖，但是构造函数能够被重载，可以使用不同的参数个数或参数类型来定义多个构造函数。
（6）子类可以通过 super 关键字来显式地调用父类的构造函数，当父类没有提供无参数的构造函数时，子类的构造函数中必须显示地调用父类的构造函数，如果父类中提供了无参数的构造函数，此时子类的构造函数就可以不显式地调用父类的构造函数，在这种情况下编译器会默认调用父类的无参数的构造函数。当有父类时，在实例化对象时会首先执行父类的构造函数，然后才执行子类的构造函数。

1.8 Java中有些接口没有任何方法

接口是抽象方法定义的集合，是一种特殊的抽象类。接口中只有方法的定义，没有实现。接口中所有方法都是抽象的，接口中的成员作用域修饰符是public，常量值默认用public static final修饰。一个类可以实现多个接口。
有些接口没有任何声明的方法，实现这些接口的类不需要重写任何方法，称为标识借口，表示实现他的类属于一个特定的类型。

1.9 Java中的clone方法的作用

该方法的作用是返回一个Object对象的拷贝，该拷贝函数返回一个新的对象而不是一个引用。使用clone方法的步骤：
1）实现 clone 的类首先需要继承 Cloneable 接口。Cloneable 接口实质上是一个标识接口，没有任何接口方法。
2）在类中重写 Object 类中的 clone 方法。
3）在 clone 方法中调用 super.clone()。
4）把浅拷贝的引用指向原型对象新的克隆体。
浅拷贝与深拷贝的区别
1.浅拷贝：被复制对象的所有变量都含有与原对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。
2.深拷贝：深拷贝把复制的对象所引用的对象都复制了一遍。
在这里插入图片描述

1.10 反射机制

1、定义：
反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法。在 java 中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。
2、反射机制主要提供了以下功能：
在运行时判定任意一个对象所属的类；在运行时创建对象；在运行时判定任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
3、使用反射机制的地方：
jdbc 中有一行代码： Class.forName(‘com.mysql.jdbc.Driver.class’);//加载 MySql 的驱动类。这就是反射，现在很多框架都用到反射机制，hibernate，struts 都是用反射机制实现的。
4、反射的实现方法：
在 Java 中实现反射最重要的一步，也是第一步就是获取 Class 对象，得到 Class 对象后可以通过该对象调用相应的方法来获取该类中的属性、方法以及调用该类中的方法。
有 4 种方法可以得到 Class 对象：

1.Class.forName(“类的路径”);
2.类名.class。
3.对象名.getClass()。
4.如果是基本类型的包装类，则可以通过调用包装类的 Type 属性来获得该包装类的 Class 对象。

5、实现java反射的类：

1)Class：它表示正在运行的 Java 应用程序中的类和接口。
2)Field：提供有关类或接口的属性信息，以及对它的动态访问权限。
3)Constructor：提供关于类的单个构造方法的信息以及对它的访问权限
4)Method：提供关于类或接口中某个方法信息。

6、反射机制的优缺点：
优点：

（1）能够运行时动态获取类的实例，大大提高程序的灵活性。
（2）与 Java 动态编译相结合，可以实现无比强大的功能。

缺点：

（1）使用反射的性能较低。 java 反射是要解析字节码，将内存中的对象进行解析。

class Base{
public void f(){
System.out.println("Base");
} }
class Sub extends Base{ 
public void f(){
System.out.println("Sub");
} 
}
public class Test { 
 public static void main(String[] args) {
 try{//使用反射机制加载类
 Class c=Class.forName("Sub"); 
 Base b=(Base)c.newInstance();
 b.f();
 }catch(Exception e){
 e.printStackTrace();
 } 
 } 
}

在反射机制中获取Class类的方法：
（1）Class.forName(“类的路径”)；如上例所示。
（2）类名.class。
（3）实例.getClass()。

1.11 如何实现C语言中函数指针的功能

利用接口和类实现，首先定义一个接口，然后在接口中声明要调用的方法，实现这个接口，最后把这个实现类的一个对象作为参数传递到调用程序，调用程序通过这个参数调用指定的函数。

1.12 接口与抽象类的区别

1.语法层面上的区别
1）抽象类可以提供成员方法的实现细节（注：可以只包含非抽象方法），而接口中只能存在 public abstract 方法，方法默认是 public abstract 的，但是，java8 中接口可以有 default 方法；
2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的；
3）抽象类可以有静态代码块和静态方法和构造方法;接口中不能含有静态代码块以及静态方法以及构造方法。但是，java8 中接口可以有静态方法；
4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。
2.设计层面上的区别

抽象层次不同。抽象类是对类的整体抽象，包括属性和行为的抽象。而接口只是对行为的抽象。
跨域不同。抽象类所体现的是一种继承关系，父类和派生类之间必须存在"is-a" 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的，仅仅是实现了接口定义的契约而已，其设计理念是“has-a”的关系（有没有、具备不具备的关系），实现它的子类可以不存在任何关系，共同之处。
设计层次不同。对于抽象类而言，它是自下而上来设计的，我们要先知道子类才能抽象出父类，而接口则不同，它根本就不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。

1.13 静态内部类和非静态内部类

/* 下面程序演示如何在 java 中创建静态内部类和非静态内部类 */ 
class OuterClass { 
	private static String msg = "GeeksForGeeks"; 
	// 静态内部类 
	public static class NestedStaticClass { // 静态内部类只能访问外部类的静态成员和静态方法 			
		public void printMessage() { // 试着将 msg 改成非静态的，这将导致编译错误 
			System.out.println("Message from nested static class: " + msg); 
				} 
			}
	// 非静态内部类 
	public class InnerClass { 
		// 不管是静态方法还是非静态方法都可以在非静态内部类中访问 
		public void display() { 
			System.out.println("Message from non-static nested class: " + msg); 
				} 
			} 
		}
	public class Main { 
	// 怎么创建静态内部类和非静态内部类的实例 
		public static void main(String args[]) { 
		// 创建静态内部类的实例（注意前面还是要加外部类的名字的！！！） 	
			OuterClass.NestedStaticClass printer = new OuterClass.NestedStaticClass();
		// 调用静态内部类的非静态方法 
			printer.printMessage(); 
		// 为了创建非静态内部类，我们需要外部类的实例 
			OuterClass outer = new OuterClass(); 
			OuterClass.InnerClass inner = outer.new InnerClass(); 
		// 调用非静态内部类的非静态方法 
			inner.display(); 
		// 我们也可以结合以上步骤，一步创建的内部类实例 
			OuterClass.InnerClass innerObject = new OuterClass().new InnerClass(); 
		// 同样我们现在可以调用内部类方法 
			innerObject.display(); 
			} 
		}

（1）静态内部类不依赖于外部类实例而被实例化，而非静态内部类需要在外部类实例化后才可以被实例化。
（2）静态内部类不需要持有外部类的引用。但非静态内部类需要持有对外部类的引用。
（3）静态内部类不能访问外部类的非静态成员和非静态方法。它只能访问外部类的静态成员和静态方法。非静态内部类能够访问外部类的静态和非静态成员和方法。

1.14 局部内部类与匿名内部类

1、局部内部类
在外部类的方法中定义的类。其作用的范围是所在的方法内。它不能被 public,private,protected 来修饰。它只能访问方法中定义为 final 类型的局部变量。

class outerClass{ 
	public void f(){
		class innerClass{//局部内部类 
			} 
		} 
	}

2、匿名内部类

interface Person { 
	public abstract void eat(); 
		}
	public class Test4 { 
		public static void main(String[] args) { 
			Person p = new Person() { 
				public void eat() { 
					System.out.println("eat something"); 
						} 
					};
					p.eat(); 
				} 
			}

需要注意的是：
1 匿名内部类一定是在 new 的后面，这个匿名内部类必须继承一个父类或者实现一个接口。
2 匿名内部类不能有构造函数。
3 只能创建匿名内部类的一个实例。
4 在 Java 8 之前，如果匿名内部类需要访问外部类的局部变量，则必须使用 final 来修饰外部类的局部变量。在现在的 Java 8 已经去取消了这个限制。