1. super()与this()的差别？ 

super和this的差别：

    1)super（參数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句） 

    2)this（參数）：调用本类中还有一种形成的构造函数（应该为构造函数中的第一条语句）

    3)super:　它引用当前对象的直接父类中的成员（用来訪问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有同样成员定义时如：super.变量名    super.成员函数据名（实參）

    4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象。假设函数的形參与类中的成员数据同名，这时需用this来指明成员变量名）

    5）调用super()必须写在子类构造方法的第一行，否则编译不通过。

每一个子类构造方法的第一条语句，都是隐含地调用super()，假设父类没有这样的形式的构造函数，那么在编译的时候就会报错。

    6）super()和this()类似,差别是。super()从子类中调用父类的构造方法。this()在同一类内调用其他方法。

    7）super()和this()均需放在构造方法内第一行。

    8）虽然能够用this调用一个构造器，但却不能调用两个。

    9）this和super不能同一时候出如今一个构造函数里面，由于this必定会调用其他的构造函数。其他的构造函数必定也会有super语句的存在。所以在同一个构造函数里面有同样的语句。就失去了语句的意义，编译器也不会通过。

    10）this()和super()都指的是对象，所以，均不能够在static环境中

    11）从本质上讲。this是一个指向本对象的指针, 然而super是一个Javakeyword。

2. 作用域public,protected,private,以及不写时的差别？

权限级不一样。假设不填写即为默认(default)。

权限的差别
范围	private	default	private	public
同一个类	✔	✔	✔	✔
同一包中的类		✔	✔	✔
不同包的子类			✔	✔
其它包中的类				✔

 

3. 在Java中。怎样跳出当前的多重嵌套循环？

1)Break

2)Return

3)标签：实例

public static void main(String[] args){

   lableB:  

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

            for(int j=0;j<3;j++){  

                System.out.println(j);  

                if(j==1){  

                    break lableB;  

                }  

            }  

        }  

} 

4. 一个”.java”源文件里能否够包含多个类（不是内部类）？有什么限制？

在java中能能够包括多个类。但是仅仅同意有一个公共类（public）。且公共类名与Java源文件名称同样。

5. Overload和Override的差别。

Overloaded的方法能否够改变返回值的类型?

Overload : 重载。是有同样的方法名。但參数类型或个数彼此不同；

Overrode : 重写，是在子类与父类中。子类中的方法的方法名，參数个数、类型都与父类中的全然一样。在子类中覆盖掉了父类的改方法；

6. 列举5种排序方法？请列举。用Java实现一个冒泡排序和一个选择排序？

1) 插入类排序

主要就是对于一个已经有序的序列中，插入一个新的记录。

它包含：直接插入排序，折半插入排序和希尔排序

2) 交换类排序

这类排序的核心就是每次比較都要“交换”，在每一趟排序都会两两发生一系列的“交换”排序。可是每一趟排序都会让一个记录排序到它的终于位置上。它包含：起泡排序。高速排序

3) 选择类排序

每一趟排序都从一系列数据中选择一个最大或最小的记录。将它放置到第一个或最后一个为位置交换。仅仅有在选择后才交换。比起交换类排序。降低了交换记录的时间。属于它的排序：简单选择排序。堆排序

4) 归并类排序

将两个或两个以上的有序序列合并成一个新的序列

5) 基数排序

主要基于多个keyword排序的。

// 冒泡排序

 int[] Array11 = { 1, 8, 5, 6, 2, 77, 3, 9, 10, 0 };

int[] Array12 = { 1, 8, 5, 6, 2, 77, 3, 9, 10, 0 };

int cont = 0;

for (int j = 0; j < Array11.length; j++) {

for (int i = 1; i < Array11.length; i++) {

if (Array11[i - 1] <= Array11[i]) {

cont = Array11[i - 1];

Array11[i - 1] = Array11[i];

Array11[i] = cont;

}

}

}

System.out.print("冒泡排序法：");

for (int i = 0; i < Array11.length; i++) {

System.out.print(Array11[i] + "    ");

}

//选择排序

cont = 0;

int cont1 = 0;

for(int i = 0;i < Array12.length;i++){

cont1 = i;

for(int j = i+1;j <Array12.length;j++ ){

if(Array12[cont1] > Array12[j]){

cont1 = j;

}

}

cont = Array12[cont1];

Array12[cont1] = Array12[i];

Array12[i] = cont;

}

System.out.println();

System.out.print("选择排序法：");

for (int i = 0; i < Array12.length; i++) {

System.out.print(Array12[i] + "    ");

}

7. final能够改动哪些地方？各有什么特征？ 

1)final能够修饰类。修饰的类不能被继承。

2)final修饰的变量成了常量(不能被又一次赋值，命名为全大写，多个单词用下划线切割,修饰的常量必需要有默认值,被public static修饰的常量叫全局常量,final修饰引用数据类型的变量，能够改动内容。但不能改动引用)。

3)final修饰的方法不能被重写

8. Java编程,打印20天后的当前时刻，并按yyyy-MM-dd HH:mm:ss格式输出？

Calendar cal=Calendar.getInstance();

        cal.add(Calendar.DATE, +20);

SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        String time=   sdf.format( new  Date());

9. 说出一些经常使用的类。包，异常？ 

经常使用的工具类

注：Java默认导入了java.lang.*!

1)Scanner：与用户输入交互的类，java.util.Scanner;

2)BigInteger：大数运算，java.math.BigInteger

3)BigDecimal：精确运算，java.math.BigDecimal

4)Random：随机数生成，java.util.Random

5)ArrayList：弹性数组的实现，java.util.ArrayList;

6)Arrays：数组操作类。java.util.Arrays

7)File：文件或文件夹信息操作（不能改文件内容）。java.io.File;

 

常见的异常：

1）数组下标越界：java. lang.ArrayIndexOutOfBoundsException: 3

2）空指针（没有给栈分配指定）：java.lang.NullPointerException

3）栈溢出错误：java.lang.StackOverflowError

10. Java中会存在内存泄漏吗。请简单描写叙述。

内存泄露就是指一个不再被程序使用的对象或变量一直被占领在内存中。java中有垃圾回收机制，它能够保证一对象不再被引用的时候，即对象变成了孤儿的时候，对象将自己主动被垃圾回收器从内存中清除掉.

11. 垃圾回收器的基本原理是什么？垃圾回收器能够立即回收内存吗？有什么办法主动通知虚拟机进行垃圾回收？

原理是：在程序执行过程中，每创建一个对象都会被分配一定的内存用以存储对象数据。

假设仅仅是不停的分配内存，那么程序迟早面临内存不足的问题。

所以在不论什么语言中。都会有一个内存回收机制来释放过期对象的内存。以保证内存可以被反复利用。

内存回收机制能够分为两种。一种是手动实现内存的释放，还有一种则是语言内建的内存回收机制。

在java中，java虚拟机提供了一个系统级的垃圾回收（GC，Carbage Collection）线程。它负责回收失去引用的对象占用的内存。

对于GC来说，当创建对象时。GC就開始监控这个对象的地址、大小以及使用情况。

通常，GC採用有向图的方式记录和管理堆(heap)中的全部对象。通过这样的方式确定哪些对象是"可达的"，哪些对象是"不可达的"。当GC确定一些对象为"不可达"时，GC就有责任回收这些内存空间。能够。程序猿能够手动运行System.gc()。通知GC运行。可是Java语言规范并不保证GC一定会运行。

强制运行垃圾回收：System.gc()。Runtime.getRuntime().gc()

静态类：static的是属于类的。而不是属于对象的，相当于是全局的，不可能被回收

静态变量本身不会被回收，可是它所引用的对象应该是能够回收的。

gc仅仅回收heap里的对象，对象都是一样的,仅仅要没有对它的引用,就能够被回收(可是不一定被回收). 对象的回收和是否static没有什么关系!

如：static Vector pane = new Vector();  pane = null;  假设没有其他引用的话，原来pane指向的对象实例就会被回收。

Java中的对象不再有"作用域"的概念。仅仅有对象的引用才有"作用域"。垃圾回收能够有效的防止内存泄露，有效的使用能够使用的内存。垃圾回收器一般是作为一个单独的低级别的线程执行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清楚和回收。不能实时的调用垃圾回收器对某个对象或全部对象进行垃圾回收。

12. 静态变量和实例变量的差别？

java类的成员变量有俩种：

一种是被statickeyword修饰的变量，叫类变量或者静态变量

没有被statickeyword修饰的变量叫实例变量。

成员变量的差别：

被static修饰的静态变量存放在堆中的静态区，静态变量能够直接通过类名进行訪问，其生命周期取决于类的生命周期。

没有被static修饰的静态变量存放在堆中的常量区，每创建一个实例。java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中，其生命周期取决于实例的生命周期。

13. 能否够从一个static方法内部发出对非static方法的调用？为什么？

不能够。静态方法仅仅能訪问静态成员，非静态既能够訪问静态，又能够訪问非静态，static修饰的方法能够直接用类名调用 ，静态变量能够被对象调用。还能够被类名调用，非static修饰的被对象调用，必须用类new出对象才干调用。

14. 去除字符串的反复值，并排序输出去重后的结果？（如：1,2,2,3,33,1,4，去重应为：1,2,3,4,33）

思路：数组使用弹性数组，先进行排序然后把反复的替换掉

15. 面向对象的特征有哪些？请各作简述。

1）.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解所有问题，而仅仅是选择当中的一部分，临时不用部分细节。

抽象包含两个方面，一是过程抽象，二是数据抽象。

2).继承：继承是一种联结类的层次模型，而且同意和鼓舞类的重用。它提供了一种明白表述共性的方法。

对象的一个新类能够从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性。新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。

派生类能够从它的基类那里继承方法和实例变量，而且类能够改动或添加新的方法使之更适合特殊的须要。

3).封装：封装是把过程和数据包围起来，对数据的訪问仅仅能通过已定义的界面。面向对象计算始于这个基本概念。即现实世界能够被描绘成一系列全然自治、封装的对象，这些对象通过一个受保护的接口訪问其它对象。

4). 多态性：多态性是指同意不同类的对象对同一消息作出响应。多态性包括參数化多态性和包括多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，非常好的攻克了应用程序函数同名问题。int是java提供的8种原始数据类型之中的一个。

16. int 和 Integer 有什么差别？

Java为每一个原始类型提供了封装类。Integer是java为int提供的封装类。

int的默认值为0，而Integer的默认值为null，即Integer能够区分出未赋值和值为0的差别，int则无法表达出未赋值的情况。

17. &和&&的差别？

 &和&&的差别在于：前者是位运算符。后者是逻辑运算符。

&作为逻辑运算符时。即使第一个操作符是false。那么它仍然会计算第二个操作符。&&（短路与）。假设第一个操作符为false。那么它不会再去计算第二个操作符。

18. final, finally, finalize的差别？ 

final—修饰符（keyword）假设一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final。能够保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值。而在以后的引用中仅仅能读取。不可改动。

被声明为final的方法也相同仅仅能使用。不能重载。

 

finally—再异常处理时提供 finally 块来运行不论什么清除操作。假设抛出一个异常，那么相匹配的 catch 子句就会运行，然后控制就会进入 finally 块（假设有的话）。 

finalize—方法名。Java 技术同意使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这种方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。

它是在 Object 类中定义的。因此全部的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者运行其它清理工作。

finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

19. short s1 = 1; s1 = s1 + 1;有什么错?

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

s1是short型，s1+1运算结果是int型，须要强制转换类型才干够正确的编译，所以short s1 = 1; s1 = s1 + 1;是错的，而short s1 = 1; s1 += 1;中s1 += 1为自加，相当于s1++，当中并没有复制过程，就不须要类型的转换。或者说是自己主动类型的转换。

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

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

Math.round()方法是先将參数加上0.5然后去取它的Math.floor()值，Math.floor()能够获得一个数的整数部分。Math.floor求最大的整数但不大于本身，而不是四舍五入。

Math.round(11.5)==12

Math.round(-11.5)==-11

21. 数组有没有length()这种方法?

 String有没有length()这种方法？

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

String有有length()这种方法。

22. 构造器Constructor是否可被override?为什么？

构造器是用来生成一个类的实例。是用来初始化这个实例用的

构造器Constructor不能被继承，因此不能重写（Overriding），但能够被重载（Overloading）。

23. 能否够继承String类?

String类是final类故不能够继承。一切由final修饰过的都不能继承

24. swtich能否作用在byte上，能否作用在long上。能否作用在String上?

switch（expr1）中，expr1是一个整数表达式。

因此传递给 switch 和 case 语句的參数应该是 int、 short、 char 或者 byte。

long,string 都不能作用于swtich。

25. 编程题: 用最有效率的方法算出2乘以8等於几? 

用移位运算 int a=2<<3; 

a就是2乘以8 最后结果是16 这是最省内存 最有效率的方法 

26. 当一个对象被当作參数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这是值传递还是引用传递?

 

值传递。Java 编程语言仅仅有值传递參数。当一个对象实例作为一个參数被传递到方法中时，參数的值就是对该对象的引用。

对象的内容能够在被调用的方法中改变，但对象的引用是永远不会改变的。

27. 编程题: 写一个Singleton出来。

Singleton模式主要作用是保证在Java应用程序中，一个类Class仅仅有一个实例存在。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类。它的构造函数为private的。它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用当中的方法。

public class Singleton {

private Singleton(){}

//注意这是private 仅仅供内部调用

private static Singleton instance = new Singleton();

//这里提供了一个供外部訪问本class的静态方法。能够直接訪问

public static Singleton getInstance() {

return instance;

}

}

另外一种形式:

public class Singleton {

private static Singleton instance = null;

public static synchronized Singleton getInstance() {

//这种方法比上面有所改进，不用每次都进行生成对象，仅仅是第一次

//使用时生成实例。提高了效率！

if (instance==null)

instance＝new Singleton();

return instance;  }

}

其它形式:

定义一个类，它的构造函数为private的。全部方法为static的。

一般觉得第一种形式要更加安全些

28. 去了解一下JVM载入class文件的原理机制?

并作简单描写叙述？

在Java中。类装载器把一个类装入Java虚拟机中，要经过三个步骤来完毕：装载、链接和初始化。当中链接又能够分成校验、准备、解析

装载：查找和导入类或接口的二进制数据； 

链接：运行以下的校验、准备和解析步骤，当中解析步骤是能够选择的； 

校验：检查导入类或接口的二进制数据的正确性。 

准备：给类的静态变量分配并初始化存储空间； 

解析：将符号引用转成直接引用。

初始化：激活类的静态变量,初始化Java代码和静态Java代码块

29. char型变量中能不能存贮一个中文汉字?

为什么?

能够。JAVA默认的编码是UNICODE不是ASCII的char

UNICODE编码字符集中包括了汉字。所以char型变量能够存储汉字。假设某个特殊的汉字没有被包括在UNICODE编码字符集中。那么这个char型变量中就不能存储这个特殊汉字。

补充说明：UNICODE编码占用两个字节，所以，char类型的变量也是占用两个字节。

30. 一列数的规则例如以下: 1、1、2、3、5、8、13、21、34...... 求第30位数是多少？用递归算法实现。

 public class Dugui {

 private  long Fibonacci(int n)

     {

         long result = 1;//当n<=2时都返回1

         if(n>2)            //当n>2时，进行递归计算

         {

          result= Fibonacci(n-1)+Fibonacci(n-2);

         }

         return result;

    }

public static void main(String[] args) {

Dugui a =new Dugui();

long  s = a.Fibonacci(30);

System.out.println(s);

}

}