java面试题java基础部分

https://blog.csdn.net/qq_41701956/article/details/80250226

必须记下来，概念性问题。（知其然更要知其所以然）

一，如何理解封装，继承，多态和抽象

封装
封装给对象提供了隐藏内部特性和行为的能力。对象提供一些能被其他对象访问的方法来改
变它内部的数据。在 Java 当中，有 4 种修饰符： public， private 和 protected，默认（friendly）。每一种修饰符
给其他的位于同一个包或者不同包下面对象赋予了不同的访问权限。
下面列出了使用封装的一些好处：

通过隐藏对象的属性来保护对象内部的状态。
提高了代码的可用性和可维护性，因为对象的行为可以被单独的改变或者是扩展。
禁止对象之间的不良交互提高模块化

继承
继承给对象提供了从基类获取字段和方法的能力。继承提供了代码的重用行，也可以在不修改类的情况下给现存的类添加新特性。

多态
多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。一个多态类型上的操作可以应用到其他类型的值上面。

抽象
抽象是把想法从具体的实例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类。 Java 支持创建只暴漏接口而不包含方法实现的抽象的类。这种抽象技术的主要目的是把类的行为和实现细节分离开。

二，final, finally, finalize 的区别
final
修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。很显然，final和abstract不能共存

finally
在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。有finally块一定有try，但不一定有catch块（但没有catch块毫无意义，finally块非必须，最好写上，比如强制操作）

finalize
方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

三，int 和 Integer 有什么区别
int 是基本数据类型，非对象
Integer是其包装类，注意是一个类。

引申：为什么要提供包装类呢？？？
一是为了在各种类型间转化，通过各种方法的调用。否则你无法直接通过变量转化。
包装类，比较多的用途是用在于各种数据类型的转化中
比如，现在int要转为String

int a=0;
String result=Integer.toString(a);
我写几个demo
//通过包装类来实现转化的

int num=Integer.valueOf("12");
int num2=Integer.parseInt("12");
double num3=Double.valueOf("12.2");
double num4=Double.parseDouble("12.2");

//其他的类似。通过基本数据类型的包装来的valueOf和parseXX来实现String转为XX
String a=String.valueOf(“1234”);//这里括号中几乎可以是任何类型
String b=String.valueOf(true);
String c=new Integer(12).toString();//通过包装类的toString()也可以
String d=new Double(2.3).toString();
再举例下。比如我现在要用泛型

List nums;
这里<>需要类。如果你用int。它会报错的。

四，重载和重写的区别

override（重写）

方法名、参数、返回值相同。
子类方法不能缩小父类方法的访问权限。（向上扩大权限）
子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
存在于父类和子类之间。
方法被定义为final不能被重写。

overload（重载）

参数类型、个数、顺序至少有一个不相同。
不能重载只有返回值不同的方法名。
存在于父类和子类、同类中。

在这里插入图片描述

五，抽象类abstract和接口interface有什么区别
接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，
另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。
还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用。

六，说说反射的用途及实现
Java反射机制主要提供了以下功能：在运行时构造一个类的对象；判断一个类所具有的成员变量和方法；调用一个对象的方法；生成动态代理。反射最大的应用就是框架

Java反射的主要功能：

确定一个对象的类
取出类的modifiers,数据成员,方法,构造器,和超类.
找出某个接口里定义的常量和方法说明.
创建一个类实例,这个实例在运行时刻才有名字(运行时间才生成的对象).
取得和设定对象数据成员的值,如果数据成员名是运行时刻确定的也能做到.
在运行时刻调用动态对象的方法.
创建数组,数组大小和类型在运行时刻才确定,也能更改数组成员的值.
反射的应用很多，很多框架都有用到

spring 的 ioc/di 也是反射….
javaBean和jsp之间调用也是反射….
struts的 FormBean 和页面之间…也是通过反射调用….
JDBC 的 classForName()也是反射……
hibernate的 find(Class clazz) 也是反射….

反射还有一个不得不说的问题，就是性能问题，大量使用反射系统性能大打折扣。因此要合理使用反射。

//-------------------------------------------------------（以下略）
https://uule.iteye.com/blog/1423512

Reflection 是 Java 程序开发语言的重要特征之一，是学习Java必须知识点。

Java反射机制主要提供了以下功能：在运行时构造一个类的对象；判断一个类所具有的成员变量和方法；调用一个对象的方法；生成动态代理。反射最大的应用就是框架

Java.lang.Class和Java.lang.reflect包下的API，用于表示或者处理当前JVM中的类，接口和对象。

Java反射的主要功能：

Class类是Java反射的基础，Class类表示正在运行的java应用程序中的类和接口。Class只有私有的构造函数。Class类在加载类时由Java虚拟机以及调用类加载器中的 defineClass方法自动创建的。只在内存中存在一份加载类的Class类。
三种方式得到某个Java类的Class类，以java.lang.String为例：

Java代码收藏代码
String s = “aaa”;
Class cls1 = s.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName(“java.lang.String”);
if (cls1 == cls2) {
System.out.println(“cls1 == cls2”);
}
if (cls2 == cls3) {
System.out.println(“cls2 == cls3”);
}

为什么他们三个会==呢？因为他们描述的都是同一个类java.lang.String类。

Class类还有很多方法，配合java.lang.reflect包下的一些API可以实现更多的功能。

一个javabean

Java代码收藏代码
package org.legend.reflect;
public class UserInfo {
private String userName;
private Integer age;
public String school;

public UserInfo() {  
}  
public UserInfo(String name, Integer age, String shool) {  
    this.userName = name;  
    this.age = age;  
    this.school = shool;  
}  
public UserInfo(String name, Integer age) {  
    this.userName = name;  
    this.age = age;  
}  
public String getInfo(String n, Integer i) {  
    return "success" + n + i;  
}  
public void getMyInfo(String mName, String mBirth, Integer age) {  
    System.out.println("我是一个来自" + mBirth + "的名叫：" + mName + "的" + age  
            + "岁的选手");  
}  
public Integer getAge() {  
    return age;  
}  
public void setAge(Integer age) {  
    this.age = age;  
}  
public String getUserName() {  
    return userName;  
}  
public void setUserName(String userName) {  
    this.userName = userName;  
}

}

一个操作类:

Java代码收藏代码
package org.legend.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

/**

反射操作类
*/
public class GetMyInfo {

public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchMethodException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

 Class mclass = Class.forName("org.legend.reflect.UserInfo");  
 System.out.println("------------输出类名-----------------------");  
 System.out.println(mclass.getName());          
 System.out.println(mclass.getSimpleName()); //基础类的简称  
   
 //获取属性(字段)  
 System.out.println("------------输出所有属性--------------------");  
 Field[] fileds=mclass.getDeclaredFields();  //得到所有的字段，包括公共，保护，默认（包）和私有变量，但不包括继承的字段。  
     //Field[] fileds = mclass.getFields();      //得到所有的公共字段。  
 for(Field field:fileds)  
 {  
     String fieldName = field.getName();    //属性名称  
     int fieldFangWen = field.getModifiers(); //属性访问权限修饰符  
     Class fieldType = field.getType();     //属性类型  
     System.out.println(Modifier.toString(fieldFangWen)+" "+fieldType.getSimpleName()+" "+fieldName);  
 }  
   
 //获取方法  
 System.out.println("------------输出所有方法--------------------");  
 Method [] methods=mclass.getDeclaredMethods();  
      //Method[] medthods = mclass.getMethods();  
 for(Method method:methods)  
 {  
     String methodName = method.getName();      //方法名称  
     int methodFangWen = method.getModifiers(); //访问修饰符  
     Class methodRetrunType = method.getReturnType();//返回类型  
     Class [] methodParameter = method.getParameterTypes();//方法的参数列表  
     System.out.print(Modifier.toString(methodFangWen)+" "+methodRetrunType.getSimpleName()+" "+methodName+"(");  
     for(int k=0;k<methodParameter.length;k++)  
     {     
         String parameterName=methodParameter[k].getSimpleName();  
         if(k!=methodParameter.length-1)  
         {  
             System.out.print(parameterName+" arg"+k+",");  
         }  
         else  
         System.out.print(parameterName+" arg"+k);  
     }  
     System.out.println(");");  
       
 }  
   
 //获取构造  
 System.out.println("------------输出所有构造器--------------------");  
 Constructor[]constructors = mclass.getConstructors();  
 for(Constructor constructor:constructors)  
 {  
     String constructorName = constructor.getName();  
     Class[] constructorParameter = constructor.getParameterTypes();  
     System.out.print(mclass.getSimpleName()+" "+constructorName.substring(constructorName.lastIndexOf(".")+1, constructorName.length())+"(");  
     for(int h=0;h<constructorParameter.length;h++)  
     {  
         String parameterName = constructorParameter[h].getSimpleName();  
         if(h!=constructorParameter.length-1)  
             System.out.print(parameterName+" arg"+h+",");  
         else  
             System.out.print(parameterName+" arg"+h);  
     }  
     System.out.println(");");  

 }  
   
 //如何执行指定的方法  
 System.out.println("------------反射执行方法--------------------");  
 String name ="getMyInfo";  
 Class[] parameterTypes = new Class[3];  
 parameterTypes[0]= String.class;  
 parameterTypes[1]= String.class;  
 parameterTypes[2]= Integer.class;  
   
 Method me = mclass.getDeclaredMethod(name, parameterTypes);  
 Object obj = mclass.newInstance();  
 Object[] arg = new Object[3];  
 arg[0]="范晶晶";  
 arg[1]="AAA风景区";  
 arg[2]=new Integer(18);  
 me.invoke(obj, arg);

}

反射的应用很多，很多框架都有用到

spring 的 ioc/di 也是反射…
javaBean和jsp之间调用也是反射…
struts的 FormBean 和页面之间…也是通过反射调用…
JDBC 的 classForName()也是反射…
hibernate的 find(Class clazz) 也是反射…

反射还有一个不得不说的问题，就是性能问题，大量使用反射系统性能大打折扣。怎么使用使你的系统达到最优就看你系统架构和综合使用问题啦，这里就不多说了。。。

（如何做到反射优化，框架中是如何使用反射的！思考）

java面试题java基础部分

猜你喜欢