数组和集合的区别

一、数组声明了它容纳的元素的类型，而集合不声明。

二、数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了。而集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求。

三、数组的存放的类型只能是一种（基本类型/引用类型）,集合存放的类型可以不是一种(不加泛型时添加的类型是Object)。

[if !supportLists]四、[endif]数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查都是最快的

集合的集成体系

Map集合能否迭代器遍历

[if !supportLists]1. [endif]在map中虽然不能直接实例化迭代器，但map集合提供了keySet（）方法和value（）方法，可以通过先将键值输出到一个集合，可意识list集合或者map集合。

2.通过键的集合就可以直接实例化迭代器。

3.在进行迭代操作时，可以通过get（）方法，找出每个键对应的值，输出即可。

Vector & ArrayList区别

1）  Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。

2） 当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。

LinkedList和ArrayList底层如何实现，如何选择使用

ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但LinkedList的内部实现是基于一组连接的记录，所以，它更象一个链表结构，所以，它们在性能上有很大的差别： 从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，所以,当你的操作是在一列 数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能； 而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，所以,当你的操作是在一列数据的前面或中 间添加或删除数据，并且按照顺序访问其中的元素时，就应该使用LinkedList了。

TreeSet中成员如何确定比较算法

A:自然排序：要在自定义类中实现Comparerable<T>接口  ，并且重写compareTo方法

B:比较器排序：在自定义类中实现Comparetor<t>接口，重写compare方法

Hashtable & HashMap

Hashtable和HashMap它们的性能方面的比较类似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。

HashSet不能添加重复的元素，当调用add（Object）方法时候，

首先会调用Object的hashCode方法判hashCode是否已经存在，如不存在则直接插入元素；

如果已存在则调用Object对象的equals方法判断是否返回true，如果为true则说明元素已经存在，如为false则插入元素。

Entry是什么,如何理解

接口Entry是Map<K,V>的内部接口，该接口是用来表示一个键值对的，一个这样的实例就包含K类型的键和V类型的值。包含获取Key、获取value以及设置value的方法，同时需要重写equals和hashCode方法。

该接口有四中方式获取比较器：

1:多态是什么，前提是什么?

多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既能可以调用父类的方法，又能调用子类的方法。

2:多态中成员访问的特点?

成员变量   

成员方法

静态方法

多态中的成员访问特点：

A:成员变量

编译看左边，运行看左边。

B:构造方法

    创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

C:成员方法

        编译看左边，运行看右边。

D:静态方法

编译看左边，运行看左边。

(静态和类相关，算不上重写，所以，访问还是左边的)

由于成员方法存在方法重写，所以它运行看右边。

3:多态的好处及弊端？

好处：提高了代码的扩展性。

弊端：前期建立父类的引用虽然可以接收后期所有该类的子类对象。

  但是只能使用父类中的功能，不能使用子类中的特有功能，

  因为前期的程序无法知道后期的子类的特有内容的。

  但是前期的程序可以使用子类覆盖了父类的方法的内容。

4:什么是向上转型？什么是向下转型？

子类引用的对象转换为父类类型称为向上转型。通俗地说就是是将子类对象转为父类对象。此处父类对象可以是接口。

向下转型是把父类对象转为子类对象

5:抽象类概述及其特点?

抽象类的特点

a：抽象类和抽象方法必须用abstract关键字修饰

abstract class 类名 {}

public abstract void eat();

b：抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

c：抽象类不能实例化那么，抽象类如何实例化呢?

按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

d:抽象类的子类

要么是抽象类

要么重写抽象类中的所有抽象方法

6:抽象类成员特点?

A：抽象类的成员特点

a.成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量

b.构造方法：有。

用于子类访问父类数据的初始化。

c.成员方法：既可以是抽象的，也可以是非抽象的。

B:

抽象类的成员特点

C:抽象类的成员方法特性：

a.抽象方法 强制要求子类做的事情。（子类必须对其重写）

b.非抽象方法 子类继承的事情，提高代码复用性。

1.有一个类A，有以下两个构造方法

public A(){}

public A(){

super();

}

没有区别，因为super中调用的也是父类中的无参构造器，而第一个构造器也是系统默认调用该构造器

上述两个构造器有没有区别，为什么？

2.有一个类A，有以下两个构造方法

public A(){

A("Hello")

}

public A(String s){

System.out.println(s);

}

测试类Test

public class Test{

public static void main(String[] args){

A a = new A();

}

}

问：输出结果？为什么？

Hello 因为用类创建对象时并没有参数，所以调用A的无参构造器

3.

public class Test3 {

new B();

}

class A {

public A(String s) {

System.out.println(s);

}

}

class B extends A{

}

问：输出结果？为什么？

  编译错误，因为A中没有无参构造器,但又自己定义了构造器，所以没有默认的无参构造器，B得写super(s)才能调用,并且创建B对象是也没有参数；

4.this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

通过上课、习题以及自己测试，理解总结，尽量详细。

this：本类对象的引用

super：父类存储空间的标识（父类对象的引用）

    使用场景

            成员变量：

                    this.变量 本类的成员变量。

                    super.变量 父类的成员变量。

          构造方法：

                      this（）本类的构造方法

                      super（）父类的构造方法

            成员方法：

                      this.方法名（）本类的成员方法

                      super.方法名（）父类的成员方法

5.重写和重载的区别。

通过上课、习题以及自己测试，完善之前总结的。

重载不需要看返回值是否一致，而重写需要，重载值是通过参数列表来调用不同方法，而重写是对方法的不同实现。

Overload（重载）

（1） 重载Overload是一个类中多态性的一种表现。是编译时的多态性。方法重载是让类以统一的方式处理不同类型数据的一种手段。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载。

（2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数列表。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

（3） 重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。

（4） 不能通过访问权限、返回类型、抛出的异常进行重载；

（5） 方法的异常类型和数目不会对重载造成影响；

Override（重写、覆盖）

（1） 父类与子类之间的多态性，对父类的函数进行重新定义。是运行时的多样性。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Override)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

（2）若子类中的方法与父类中的某一方法具有相同的方法名、参数列表和兼容的返回类型，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

（3）子类函数的访问修饰权限不能少于父类的。

6.为什么main()写法固定？

从修饰符、返回值类型、方法名、参数列表等角度说明。

public static void main(String[] args)  public : 说明访问权限  static :说明只要加载该类，该模块先执行  main是程序的入口 。 参数列表是一个String 类型的数组，如果编译时后加输入,则可以按照普通String类型数组理解

7.

public class Test7 {

public static void main(String[] args) {

Y y1 = new Y();

Y y2 = new Y();

}

}

class X {

static {

System.out.println("X的静态代码块");

}

{

System.out.println("X的构造代码块");

}

public X() {

System.out.println("X的无参构造器");

}

}

class Y extends X{

static {

System.out.println("Y的静态代码块");

}

{

System.out.println("Y的构造代码块");

}

public Y() {

System.out.println("Y的无参构造器");

}

}

问：输出结果？为什么？

X的静态代码块

Y的静态代码块

X的构造代码块

X的构造代码块

Y的构造代码块

Y的无参构造器

X的构造代码块

X的构造代码块

Y的构造代码块

Y的无参构造器

4.1整型数据

30  int和Integer有什么区别？

31  int的取值范围

32如何使用八进制和十六进制来表示整型数据

33  long的取值范围

4.2实型数据

34  float和double的取值范围

Float型，内存分配4个字节，占32位

Double型，内存分配8个字节

35实型与整型的相互转换

36如何用BigDecimal类进行精确计算

4.3布尔型数据

37  Java可以用非0来代表true吗？

38  boolean和它的包装类的区别在哪里？

4.4字符型数据

39  char的取值范围

40  char能否存储汉字

41如何使用转义字符

4.5 String型数据（重点背诵）

42字符串字面量是否自动生成一个String对象

43字符串对象池的作用是什么

44  StringBuffer和StringBuilder存在的作用是什么

45如何输出反转过后的字符串

46如何使用指定的字符集创造String对象