java面试题_基础_1

连续两次被java基础面试干倒，总结下相关问题。

参考文档：https://www.zhihu.com/question/272185241/answer/366129174

https://blog.csdn.net/cyl101816/article/details/92797558

怎样实现单例？

　　之前一直在想怎样再多线程中保证单例，忘记了基础：私有构造方法，防止被实例化

  /* 静态工程方法，创建实例 */  
    public static Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }

什么叫泛型？有什么作用？

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常.

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

参数化类型:

  • 把类型当作是参数一样传递
  • <数据类型>只能是引用类型
  • ArrayList<E>中的E称为类型参数变量
  • ArrayList<Integer>中的Integer称为实际类型参数
  • 整个称为ArrayList<E>泛型类型

  • 为什么需要泛型

    早期Java是使用Object来代表任意类型的，但是向下转型有强转的问题，这样程序就不太安全

    首先，我们来试想一下：没有泛型，集合会怎么样

    • Collection、Map集合对元素的类型是没有任何限制的。本来我的Collection集合装载的是全部的Dog对象，但是外边把Cat对象存储到集合中，是没有任何语法错误的。
    • 把对象扔进集合中，集合是不知道元素的类型是什么的，仅仅知道是Object。因此在get()的时候，返回的是Object。外边获取该对象，还需要强制转换

    有了泛型以后：

    • 代码更加简洁【不用强制转换】
    • 程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】
    • 可读性和稳定性【在编写集合的时候，就限定了类型】 

    泛型类

    泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来....这样的话，用户明确了什么类型，该类就代表着什么类型...用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。

    用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。
　　如果使用泛型方法：用户传递进来的是什么类型，返回值就是什么类型。
　　泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承
  • 当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量

描述一下JVM加载Class文件的原理和机制：

JVM中类的加载是由ClassLoader和它的子类来实现的，Java ClassLoader是一个很重要的java运行时系统组件，他负责在运行时查找和装入类文件的类。java中的所有类，都需要装载到JVM中才能运行，

类加载器本省就是一个类，它的工作就是将class文件从硬盘读取到内存中。

2、类装载的方式有两种：

隐式转载：程序在运行过程中碰道通过new等方式生成对象时，隐式调用类加载器加载对应的类到jvm中

显示装载：通过class.forname()等方法，显示加载需要的类

Cookie与Session的作用与原理

　　1、cookie是流浪器保存在用户电脑上的一小段文本，用来保存用户在网站上的必要信息。web页面或者服务器告诉浏览器按照一定的规范存储这些信息，并且在以后的所有请求中，这些信息就会自动加在http

请求头中发送给服务器，服务器根据这些信息判断不同的用户，并且cookie本身是安全的

　　2、session的作用和cookie差不多，但是session是存储在服务器端的，不会在网络中进行传输，所以比cookie更加安全一些。但是session是依赖cookie的，当用户访问某个站点的时候，服务器会为这个用户产生

唯一的session_id，并把这个session_id以cookie的形式，发送到客户端，以后的客户端请求都会自动携带则cookie。

泛型常用特点，List<String>能否转为List<Object>。

　　答案是不行的，因为String的list不是Object的list，String的list持有String类和其子类型，Object的list持有任何类型的Object，String的list在类型上不等价于Object的list。

　　泛型实现了参数化类型的概念，使得我们的代码可以在更多的场景使用。泛型的好处在于在编译时进行类型的安全检查，并且在运行的时候所有的转换都是强制的，隐式的，大大的提高了代码的重用率。

JDK和JRE的区别：

　　JDK：它是Java开发运行环境，在程序员的电脑上当然要安装JDK；

　　JRE：Java Runtime Environment它是Java运行环境，包含了java虚拟机，java基础类库。如果只需要运行Java程序，可以安装JRE。
　　JDK包含了JRE。JRE中包含虚拟机JVM。

java中的异常有哪几类，分别怎么使用？

　　Throwable是所有异常的根，java.lang.Throwable
　　Error:错误，Java.lang.Error
　　Exception：异常，java.lang.Exception
　　Exception分为CheckedException和RuntimeException，所有RuntimeException类及其子类的实例被称为Runtime异常，不属于该范畴的异常则被称为CheckedException。
　　①checkedException：只有Java语言提供了Checked异常，Java认为checked异常都是可以被处理的异常，所以Java程序必须显示处理checked异常。如果程序没有处理checked异常，该程序在编译时会发生错误无法编译。这体现了Java的设计哲学：没有完善错误处理的代码根本没有机会被执行。对Checked异常处理方法有两种：
　　　　1、当前方法知道如何处理该异常，则用try...catch块来处理。
　　　　2、当前方法不知道如何处理，则在定义该方法时声明抛出该异常。
　　我们比较熟悉的Checked异常有：
　　　　Java.lang.ClassNotFoundException
　　　　Java.lang.NoSuchMethodException
　　　　java.io.IOException
　　②RuntimeException
　　Runtime如除数是0和数组下标越界等，其产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。当然如果你有处理要求也可以显示捕获它们。
　　　　Java.lang.ArithmeticException　　Java.lang.ArrayStoreExcetpion　　Java.lang.ClassCastException
　　　　Java.lang.IndexOutOfBoundsException　　Java.lang.NullPointerException
Exception，Error，Throwable，RuntimeException：
　　Throwable是java.lang包中一个专门用来处理异常的类。它有两个子类，即Error 和Exception。 
　　Error用来处理程序运行环境方面的异常，比如，虚拟机错误、装载错误和连接错误，这类异常主要是和硬件有关的，而不是由程序本身抛出的。 
　　Exception是Throwable的一个主要子类。Exception下面还有子类，其中一部分子类分别对应于Java程序运行时常常遇到的各种异常的处理，其中包括隐式异常。比如，程序中除数为0引起的错误、数组下标越界错误等，这类异常也称为运行时异常，因为它们虽然是由程序本身引起的异常，但不是程序主动抛出的，而是在程序运行中产生的。
　　1.Throwable 类是 Java 语言中所有错误或异常的超类。它的两个子类是Error和Exception； 
　　2.Error 是 Throwable 的子类，用于指示合理的应用程序不应该试图捕获的严重问题。大多数这样的错误都是异常条件。
　　3.Exception 类及其子类是 Throwable 的一种形式，它指出了合理的应用程序想要捕获的条件。 
　　4.RuntimeException 是那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。可能在执行方法期间抛出但未被捕获的RuntimeException 的任何子类都无需在 throws 子句中进行声明。它是Exception的子类。 

在以下 4 种特殊情况下，finally 块不会被执行: 

　　1. 在finally语句块中发生了异常。

　　2. 在前面的代码中用了System.exit()退出程序。

　　3. 程序所在的线程死亡。
　　4. 关闭CPU。

Error类和Exception类都继承自Throwable类。
二者的不同之处： 
　　Exception：
　　　　1．可以是可被控制(checked) 或不可控制的(unchecked) 
　　　　2．表示一个由程序员导致的错误 
　　　　3．应该在应用程序级被处理 
　　Error：
　　　　1．总是不可控制的(unchecked) 
　　　　2．经常用来用于表示系统错误或低层资源的错误 
　　　　3．如何可能的话，应该在系统级被捕捉

Java语言如何进行异常处理，throws，throw，try catch finally代表什么意义，try块中可以抛出异常吗?

Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。 

用try来指定一块预防所有”异常”的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的”异常”的类型。 

throw语句用来明确地抛出一个”异常”。  

throws用来标明一个成员函数可能抛出的各种”异常”，声明的方法表示此方法不处理异常，而交给方法调用处进行处理，例如A方法名后使用throws Exception，则B在调用A方法后，必须要在B中处理此异常，使用try catch。

Finally为确保一段代码不管发生什么”异常”都被执行一段代码。 

可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，”异常”的框架就放到堆栈上面，直到所有的try语句都完成。

如果下一级的try语句没有对某种”异常”进行处理，堆栈就会展开，直到遇到有处理这种”异常”的try语句。

Switch能否用string做参数？

　　switch语句中的变量类型byte，short，int，char。从jdk1.7后可以使用String类型，是通过switch中的String.hashcode将String转换成int进行判断。 

String strA = "abc";
String StrB = new String("abc");这两行代码中分别创建了几个对象？ 

第一行代码创建了1个对象，第二行代码创建了2个对象；

　　首先 String strA = "abc"; 创建了一个对象StrA并且把“abc”在内存中的地址赋值给了对象StrA，所以这个过程只创建了一个对象StrA;

　　可能会创建一个对象或者不会创建对象，这里会出现一个名词：字符串实例池；

　　而在String StrB = new String("abc")中，则创建了StrB对象，其存放的是存放“abc”地址的对象的引用地址；所以这个过程创建了StrB对象和存放“abc”地址的引用对象；

Java 序列化中如果有些字段不想进行序列化怎么办？

　　对于不想进行序列化的变量，使用 transient 关键字修饰。

　　transient 关键字的作用是:阻止实例中那些用此关键字修饰的的变量序列化; 当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。 　　transient 只能修饰变量，不能修饰类和方法。

static关键字的含义及使用场景:

　　static关键字可以用来修饰代码块表示静态代码块，修饰成员变量表示全局静态成员变量，修饰方法表示静态方法。

　　静态是指Java程序还没有运行时，JVM就会为加载的类分配空间存储被static关键字修饰的内容；如静态成员变量，Java类加载到JVM中，JVM会把类以及类的静态成员变量存储在方法区，方法区是线程共享，所以被static关键字修饰的内容都是全局共享的，且只会为其分配一次存储空间。

static关键字的的作用:

　　1 修饰代码块:静态代码块是当Java类加载到JVM内存中而执行的代码块，类的加载在JVM运行期间只会发生一次，所以静态代码块也只会执行一次。

　　因为静态代码块的主要作用是用来进行一些复杂的初始化工作，所以静态代码块跟随类存储在方法区的表现形式是静态代码块执行的结果存储在方法区，即初始化量存储在方法区并被线程共享。

　　2 修饰成员变量:在类加载到JVM内存中，JVM会把静态变量放入方法区并分配内存，也由线程共享。访问形式是：类名.静态成员名。　　

　　3 修饰方法:用static关键字修饰的方法称为静态方法，否则称为实例方法。通过类名.方法名调用，但需要注意静态方法可以直接调用类的静态变量和其他静态方法，不能直接调用成员变量和实例方法(除非通过对象调用)。

一个类的静态变量和该类的静态代码块的加载顺序。类会优先加载静态变量，然后加载静态代码块，但有多个静态变量和多个代码块时，会按照编写的顺序进行加载。

获取用键盘输入常用的的两种方法：

方法 1:通过 Scanner

Scanner input = new Scanner(System.in); 
String s = input.nextLine(); 
System.out.println(s);
input.close();

方法 2:通过 BufferedReader

BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine();

System.out.println(s);

Object有哪些公用方法？

1、clone()创建斌返回此对象的副本

2、equals()判断

3、getclass（）返回object的运行类

4、hashcode（）返回对象的哈希码值

5、notify（）唤醒正在等待对象监听器的单个进程

6、notifyAll（）唤醒正在等待对象监听器的所有进程

7、wait（）导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。

8、toString（）返回此对象的字符串表示形式

9、finalize（）当垃圾收集确定不需要该对象时，垃圾回收器调用该方法

Integer 与 int 的区别

　　int 是 java  8 种原始数据类型之一。Integer 是 java 为 int 提供的封装类。int 的默认值为 0，而 Integer 的默认值为 null。

　　Integer 提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer 中还定义了表示整数的最大值和最小值的常量。

Integer和int相互转换？

自动装箱与拆箱 装箱:将基本类型用它们对应的引用类型包装起来;

拆箱:将包装类型转换为基本数据类型;

　　在jdk1.5以后，可以使用自动装箱机制：
　　　　int i = 0;
　　　　Integer wrapperi = i;
　　　Integer转int
　　　　Integer wrapperi = new Integer(0);
　　　　int i = wrapperi.intValue();

当某一个类实现了两个接口的时候，两个接口中存在两个相同的方法，会不会报错？

　　在实现的类中只需实现一个方法的方法体。不会报错。

　　当一个类继承一个类，并且实现一个或者多个接口的时候，其中，父类和父接口中存在相同的方法。

　　如果子类中存在该方法的实现体或者说是覆盖，则使用该类的对象去调用该方法时候，其实掉用的是来自接口的实现方法，而不是来自父类方法的覆盖。

　　如果子类中不存在该方法的实现[或者覆盖],在使用该类对象掉用该方法的时候，就会使用从父类继承的方法。同时将这个从父类继承来的方法当作接口方法的实现，也就可以不再实现接口的方法体。

　　注意：extends & implements 的书写顺序不能改变。

　　接口的优先级别要高于父类。

get和post请求的区别？

  • GET在浏览器回退时是无害的，而POST会再次提交请求。
  • GET产生的URL地址可以被Bookmark，而POST不可以。
  • GET请求会被浏览器主动cache，而POST不会，除非手动设置。
  • GET请求只能进行url编码，而POST支持多种编码方式。
  • GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。
  • 对参数的数据类型，GET只接受ASCII字符，而POST没有限制。
  • GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。
  • GET参数通过URL传递，POST放在Request body中。
  • GET请求在URL中传送的参数是有长度限制的，而POST么有。

　　GET产生一个TCP数据包；POST产生两个TCP数据包。

　　　　GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；

　　　　而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

java中一个字符占多少个字节，扩展：int，double，long...占多少字节？
2字节（16位）。
Java基本类型占用的字节数：
1字节： byte , boolean
2字节： short , char 
4字节： int , float
8字节： long , double
注：1字节(byte)=8位(bits)
 

成员变量与局部变量的区别有那些？

  1. 从语法形式上，成员变量是属于类的，局部变量是在方法中定义的变量或是方法的参数;

  2. 成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰;成员变量和局部变量都能被 final 所修饰;

  3. 从变量在内存中的存储方式来看，成员变量是对象的一部分，而对象存 在于堆内存，局部变量存在于栈内存。
  4. 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对 象的创建而存在，而局部变量随着方法的调用而自动消失。
  5. 成员变量如果没有被赋初值，则会自动以类型的默认值而赋值(一种情 况例外被 final 修饰的成员变量也必须显示地赋值);而局部变量则不会自动赋值。

接口和类的区别是什么

  1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始 接口方法可以有默认实现)，抽象类可以有非抽象的方法

  2. 接口中的实例变量默认是 final 类型的，而抽象类中则不一定

  3. 一个类可以实现多个接口，但最多只能实现一个抽象类

  4. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定

  5. 接口不能用 new 实例化，但可以声明，但是必须引用一个实现该接口的对象 从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是 行为的抽象，是一种行为的规范。 

  6. 接口的类是abstract类，则它可以不实现该接口所有的方法。但其非abstract的子类中必须拥有所有抽象方法的实在的方法体；

构造方法有哪些特性：　　

　　1. 名字与类名相同;

　　2. 没有返回值，但不能用void声明构造函数; 
　　3. 生成类的对象时自动执行，无需调用。

静态方法和实例方法有何不同：

  1. 在外部调用静态方法时，可以使用"类名.方法名"或者"对象名.方法名"的方式。调用静态方法可以无需创建对象，实例方法必须创建对象，调用方法。

  2. 静态方法在访问本类的成员时，只允许访问静态成员(即静态成员变量和静态方法)，而不允许访问实例成员变量和实例方法;实例方法则无此限制.

对象的相等与指向他们的引用相等，两者有什么不同?

　　对象的相等，比的是内存中存放的内容是否相等。而引用相等，比较的是他们指向的内存地址是否相等。

在调用子类构造方法之前会先调用父类没有参数 的构造方法，其目的是?

　　帮助子类做初始化工作。

说说&和&&的区别.

　　&和&&都可以用作逻辑与的运算符，表示逻辑与(and)，当运算符两边的表达式的结果都 为 true 时，整个运算结果才为 true，否则，只要有一方为 false，则结果为 false。 &&还具有短路的功能，即如果第一个表达式为 false，则不再计算第二个表达式，例如，对 于 if(str != null && !str.equals(“”))表达式，当 str 为 null 时，后面的表达式不会执行，所以不 会出现 NullPointerException 如果将&&改为&，则会抛出 NullPointerException 异常。If(x==33 & ++y>0) y 会增长，If(x==33 && ++y>0)不会增长 &还可以用作位运算符，当&操作符两边的表达式不是 boolean 类型时，&表示按位与操作， 我们通常使用 0x0f 来与一个整数进行&运算，来获取该整数的最低 4 个 bit 位，例如，0x31 & 0x0f 的结果为 0x01。

short s1=1;s1=s1+1;有什么错?shorts1=1;s1+=1;有什么错?

　　对于 short s1 = 1; s1 = s1 + 1; 由于 s1+1 运算时会自动提升表达式的类型，所以结果是 int 型， 再赋值给short 类型 s1 时，编译器将报告需要强制转换类型的错误。s1=s1+1 需要改为s1=(short)s1+1;
　　对于 short s1 = 1; s1 += 1;由于 += 是 java 语言规定的运算符，java 编译器会对它进行特殊处理，因此可以正确编译。

char型变量中能不能存贮一个中文汉字?为什么?

　　char 型变量是用来存储 Unicode 编码的字符的，unicode 编码字符集中包含了汉字，所以， char 型变量中当然可以存储汉字。不过，如果某个特殊的汉字没有被包含在 unicode 编码 字符集中，那么，这个 char 型变量中就不能存储这个特殊汉字。补充说明:unicode 编码占 用两个字节，所以，char 类型的变量也是占用两个字节。

用最有效率的方法算出 2 乘以 8 等於几?

　　2 << 3

"=="和 equals 方法究竟有什么区别?

　　String 中的 equals 方法是被重写过的，因为 object 的 equals 方法是 比较的对象的内存地址，而 String 的 equals 方法比较的是对象的值。

　　当创建 String 类型的对象时，虚拟机会在常量池中查找有没有已经存 在的值和要创建的值相同的对象，如果有就把它赋给当前引用。如果没 有就在常量池中重新创建一个 String 对象。

　　1.==是判断两个变量或实例是不是指向同一个内存空间，equals是判断两个变量或实例所指向的内存空间的值是不是相同 
　　2.==是指对内存地址进行比较 ， equals()是对字符串的内容进行比较
　　3.==指引用是否相同， equals()指的是值是否相同
hashCode 与 equals（面试官可能会问你:你重写过 hashcode 和 equals 么，为什么重写 equals 时必须重写 hashCode 方法?）

　　hashCode() 的作用是获取哈希码，也称为散列码;它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。hashCode() 定义在 JDK 的 Object.java 中，这就意味着 Java 中的任何类都包含有 hashCode() 函 数。

hashCode()与 equals()的相关规定：

  1. 如果两个对象相等，则hashcode一定也是相同的

  2. 两个对象相等,对两个对象分别调用equals方法都返回true

  3. 两个对象有相同的hashcode值，它们也不一定是相等的

  4. 因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

  5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode()，则该 class 的两个对象无论如何都不会相等(即使这两个

    对象指向相同的数据)

wait方法和sleep方法的区别

sleep是线程类Thread的方法，导致此线程暂停执行时间，把执行机会给其他的线程，但是监控状态依然保持，到时会自动恢复，调用sleep不会释放对象锁

wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待锁定池，只有针对此对象发出notify方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。

进程和线程的区别
  • 线程在进程下行进（单纯的车厢无法运行）
  • 一个进程可以包含多个线程（一辆火车可以有多个车厢）
  • 不同进程间数据很难共享（一辆火车上的乘客很难换到另外一辆火车，比如站点换乘）
  • 同一进程下不同线程间数据很易共享（A车厢换到B车厢很容易）
  • 进程要比线程消耗更多的计算机资源（采用多列火车相比多个车厢更耗资源）
  • 进程间不会相互影响，一个线程挂掉将导致整个进程挂掉（一列火车不会影响到另外一列火车，但是如果一列火车上中间的一节车厢着火了，将影响到所有车厢）
  • 进程可以拓展到多机，进程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在行进的不同的轨道上）
  • 进程使用的内存地址可以上锁，即一个线程使用某些共享内存时，其他线程必须等它结束，才能使用这一块内存。（比如火车上的洗手间）－"互斥锁"
  • 进程使用的内存地址可以限定使用量（比如火车上的餐厅，最多只允许多少人进入，如果满了需要在门口等，等有人出来了才能进去）－“信号量”

final 关键字主要用在三个地方:变量、方法、类。

  1. final修饰变量，初始化之后便不能再改变。

  2. final修饰类，这个类不能被继承。final类中的所有成员方法都会被隐式地指定为 final 方法。

  3. final方法不允许任何从此类继承的类来重写这种方法，但是继承仍然可以继承这个方法，也就是说可以直接使用。在声明类中，一个 final 方法只被实现一次。

　　类中所有的 private 方法都隐式地指定为 final。

静态变量和实例变量的区别? 

　　语法定义上的区别:静态变量前要加 static 关键字，而实例变量前则不加。

　　程序运行时的区别:实例变量属于某个对象的属性，必须创建了实例对象，才会被分配空间并使用。静态变量属于类，只要程序加载了类的字节码，不用创建实例对象，静态变量就会被分配空间。总之，实例变量必须创建对象后才可以通过这个对象来 使用，静态变量则可以直接使用类名来引用。

是否可从一个static方法内发出对非static方法的调用?

　　不可以。因为非 static 方法是要与对象关联在一起的，必须创建对象后，在该对象上进行方法调用，而static 方法调用可以直接调用。

Math.round(11.5)等於多少? Math.round(-11.5)等於多少?

　　Math 类中提供了三个与取整有关的方法:ceil（向上取整）、floor（向下取整）、round（四舍五入）。

　　Math.round(11.5)的结果为 12，Math.round(-11.5)的结果为-11。

在 Java 中定义一个不做事且没有参数的构造 方法的作用

　　Java 程序在执行子类的构造方法之前，如果没有用 super() 来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super() 来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。解决办法是在父类里加上一个不做事且没有参数 的构造方法。

Overload 和 Override 的区别。Overloaded 的方法是否可以改变返回值的类型?

　　Overload 是重载的意思，Override 是覆盖的意思，也就是重写。

　　重载 Overload 表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相 同(即参数个数或类型不同)。

　　重写 Override 表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类 创建的实例对象调用这个方法时，将调用子类中的定义方法，这也是面向对象编程的多态性的一种表现。因为子类可以解决 父类的一些问题，子类覆盖方法只能比父类抛出更少的异常。

　　如果两个方法的参数列表完全一样，不可以让它们的返回值不同来实现重载 Overload。如果可以，接收数据的类型就没办法确定。

　　在覆盖要注意以下的几点: 

　　　　1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果; 

　　　　2、覆盖的方法的返回值必须和被覆盖的方法的返回一致; 

　　　　3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类;

　　　　4、被覆盖的方法不能为 private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。

StringBuffer 与 StringBuilder 的区别?

　　StringBuilder线程不安全，多线程下使用StringBuffer。

　　StringBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升， 但却要冒多线程不安全的风险。

　　AbstractStringBuilder 是 StringBuilder 与 StringBuffer 的公共父类，StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。

hashCode方法的作用？
　　Set集合中元素是无序的,且不可重复的,就是根据hashCode方法确保元素的唯一,hashCode就像人的身份证一样,用于区分元素是否重复。
　　hashcode方法返回该对象的哈希码值，主要是用于查找的快捷性，如Hashtable，HashMap等，hashCode是用来在散列存储结构中确定对象的存储地址的。
      hashCode()方法可以用来来提高Map里面的搜索效率的,Map会根据不同的hashCode()来放在不同的位置,Map在搜索一个对象的时候先通过hashCode()找到相应的位置，然后再根据equals()方法判断这个位置上的对象与当前要插入的对象是不是同一个。

构造器Constructor是否可被override?
　　构造器 Constructor 不能被继承，因此不能重写 Override，但可以被重载 Overload。

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具 体类(concrete class)? 抽象类中是否可以有静态的 main 方法?

　　接口可以继承接口。抽象类可以实现(implements)接口，抽象类可以继承具体类。抽象类 中可以有静态的 main 方法。

　　抽象类与普通类的唯一区别就是不能创建实例对象和允许有 abstract 方法。

写clone()方法时，通常都有一行代码，是什么?
　　clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

面向对象的特征有哪些方面?

　　面向对象的编程语言有封装、继承 、抽象、多态4个主要的特征。

java 中实现多态的机制是什么?

　　靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方 法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运 行的那个对象的方法，而不是引用变量的类型中定义的方法。

抽象类不能直接通过new去实例化一个对象，那它就是不能实例化，要获取抽象类的对象， 需要先用一个类继承抽象类，  然后去实例化子类。
接口和抽象类（抽象类使用abstract修饰）的区别：
　　相同点：
　　　（1）都不能被实例化
　　　（2）接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。
　　不同点：
　　（1）接口只有定义，不能有方法的实现，而抽象类可以有定义与实现，方法可在抽象类中实现。
　　（2）实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
　　（3）接口强调特定功能的实现，而抽象类强调所属关系。
　　（4）接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。
　　（5）接口被用于常用的功能，便于日后维护和添加删除，而抽象类更倾向于充当公共类的角色，不适用于日后重新对立面的代码修改。功能需要累积时用抽象类，不需要累积时用接口。

什么是内部类?Static Nested Class 和 Inner Class 的不同?

　　使用 static 声明的内部类就是外部类，可以通过外部类.内部类直接访问。

内部类可以引用它的包含类的成员吗?有没有什么限制?

　　完全可以。如果不是静态内部类，那没有什么限制!

　　如果你把静态嵌套类当作内部类的一种特例，那在这种情况下不可以访问外部类的普通成员 变量，而只能访问外部类中的静态成员。

Anonymous Inner Class (匿名内部类) 是否可继承其它类，是否可以 implements 接口? 

　　可以继承其他类或实现其他接口。不仅是可以，而是必须!因为匿名内部类就是在抽象类和接口的基础上发展起来的。

String s = "Hello";s = s + " world!";这两行代码执行后，原始的 String 对象中的内容 到底变了没有?

　　没有。因为 String 被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。s 原先指向一个 String 对象，内容是 "Hello"，然后我们对 s 进行了+操作，这时，s 指向了另一个 String 对象，内容为"Hello world!"，原来那个对象还存在于内存中，只是 s 这个引用 变量不再指向它了。

是否可以继承String类? 

　　String 类是 final 类故不可以继承.

String s = new String("xyz");创建了几个 String Object? 二者之间有什么区别?

　　两个或一个，”xyz”对应一个对象，这个对象放在字符串常量缓冲区，常量”xyz”不管出现多 少遍，都是缓冲区中的那一个。New String 每写一遍，就创建一个新的对象。如果以前就用过’xyz’，这句代表就不会创 建”xyz”自己了，直接从缓冲区拿。

数组有没有length()这个方法?String有没有length()这个方法?

　　数组没有 length()这个方法，有 length 的属性。String 有有 length()这个方法。

try {}里有一 return 语句，那紧跟在这个 try 后的 finally {}里的 code 是否被执行，什 么时候被执行，在 return 前还是后?

　　答案是在 return 之前，但往更细地说，我的答案是在 return 中间执行.　

public class Test {
public static void main(String[] args) { System.out.println(new Test().test());
}
static int test(){
int x = 1; try{
return x; }
finally{ ++x;
} }
}
运行结果是 1

　　　主函数调用子函数并得到结果的过程，好比主函数准备一个空罐 子，当子函数要返回结果时，先把结果放在罐子里，然后再将程序逻辑返回到主函数。所谓 返回，就是子函数说，我不运行了，你主函数继续运行吧，这没什么结果可言，结果是在说 这话之前放进罐子里的。

介绍Collection框架的结构　　

ArrayList 和 Vector 的区别?

　　这两个类都实现了 List 接口(List 接口继承了 Collection 接口)，他们都是有序集合，即存 储在这两个集合中的元素的位置都是有顺序的,其中的数据是允许重复的.　　

　　接着才说 ArrayList 与 Vector 的区别，这主要包括两个方面:　　　　

　　(1)同步性:　Vector 是线程安全的，也就是说是它的方法之间是线程同步的，而 ArrayList 是线程序不安 全的，它的方法之间是线程不同步的。

　　(2)数据增长:　　Vector 增长原来的一倍，ArrayList 增加原来的 0.5 倍。

HashMap 和 Hashtable 的区别?

　　　HashMap:JDK1.2 之后推出，是新的类。采用异步处理方式，性能较高，非线程 安全。允许设置 null。

　　　Hashtable:JDK1.0 时推出，是旧的类。采用同步处理方式，性能较低，线程安全。 

　　　HashMap 允许将 null 作为一个 entry 的 key 或者 value，而 Hashtable 不允许。

　　　HashMap 把 Hashtable 的 contains 方法去掉了，改成 containsvalue 和 containsKey。因为 contains 方法容易让人引起误解。

　　　Hashtable 继承自 Dictionary 类，而 HashMap 是 Java1.2 引进的 Map interface 的一个实现。 最大的不同是，Hashtable 的方法是 Synchronize的。

List, Set, Map 是否继承自 Collection 接口? 

　　List，Set 是，Map 不是

List、Map、Set 三个接口，存取元素时，各有什么特点?

　　List 表示有先后顺序的集合，add()的先后顺序就是list存储的先后顺序，List 除了可以以 Iterator 接口取得所有的元素，再逐一遍历各个元 素之外，还可以调用 get(index i)来明确说明取第几个。

　　Set 集合无序插入，add 方法有一个 boolean 的返回值，当集合中没有某个元素，此时 add 方法可成功加入该元素时， 则返回 true，当集合含有与某个元素 equals 相等的元素时，此时 add 方法无法加入该元素， 返回结果为 false。

　　Map put(obj key,obj value)， 每次存储时，要存储一对 key/value，不能存储重复的 key，这个重复的规则也是按 equals 比较相等。取则可以根据 key 获得相应的 value，即 get(Object key)返回值为 key 所对应的 value。另外，也可以获得所有的 key 的结合，还可以获得所有的 value 的结合，还可以获得 key 和 value 组合成的 Map.Entry 对象的集合。

说出ArrayList,Vector,LinkedList的存储性能和特性

　　ArrayList 和 Vector 都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增 加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存 操作，所以索引数据快而插入数据慢，Vector 由于使用了 synchronized 方法(线程安全)， 通常性能上较 ArrayList 差，而 LinkedList 使用双向链表实现存储，按序号索引数据需要进 行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

Collection 和 Collections 的区别。

　　Collection: 是集合类的上级接口，继承与他的接口主要有 Set 和 List.

　　Collections:是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、 排序、线程安全化等操作。

两个对象值相同(x.equals(y) == true)，但却可有不同的 hash code，这句话对不对?

　　对。如果对象要保存在 HashSet 或 HashMap 中，它们的 equals 相等，那么，它们的 hashcode 值就必须相等。

说出一些常用的类，包，接口，请各举5个

　　常用的类:BufferedReader BufferedWriter FileReader FileWirter String Integer java.util.Date，System，Class，List,HashMap

　　常 用 的 包 : java.lang java.io java.util java.sql ,javax.servlet,org.apache.strtuts.action,org.hibernate
　　常 用 的 接 口 : Remote List Map Document NodeList ,Servlet,HttpServletRequest,HttpServletResponse,Transaction(Hibernate) 、Session(Hibernate),HttpSession

java 中有几种类型的流?JDK 为每种类型的流提供了一些抽象类以供继承，请说出 他们分别是哪些类?

　　字节流，字符流。字节流继承于 InputStream OutputStream，字符流继承于 InputStreamReader OutputStreamWriter。在 java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。

字节流与字符流的区别？

　　计算机中的一切最终都是二进制的字节形式存在。

　　底层设备只接受字节数据，写字符串到底层设备，要将字符串转成字节再进行写入。字符流是字节流的包装，字符流则是直接接受字符串，它内部将串转成字节，再写入底层设备。

什么是java序列化，如何实现java序列化?或者请解释Serializable接口的作用？

　　　要将 java 对象存储到硬盘或者传送给网络上的其他计算机，要 被传输的对象必须实现 serializable 接口，这就是所谓的序列化；

 

posted @ 2020-11-24 16:35  c++c鸟  阅读(233)  评论(0)  编辑  收藏  举报