基础语法

1. Java有哪些数据类型

定义：Java语言是强类型语言，对于每一种数据都定义了明确的具体的数据类型，在内存中分配了不同 大小的内存空间。   细化的数据类型就是占用空间的基本元素。

分类：

基本数据类型

• 数值型
  整数类型(byte,short,int,long)
  浮点类型(float,double)
• 字符型(char)
• 布尔型(boolean)

引用数据类型

• 类(class)   eg:String
• 接口(interface)
• 数组([])

 1-24-8-4-2-1 空间大小对称记忆

2. switch 是否能作用在 byte 上，是否能作用在 long 上，是否 能作用在 String 上

在 Java 5 以前，switch(expr)中，expr 只能是 byte、short、char、int。从 Java5 开始，Java 中引入 了枚举类型，expr 也可以是 enum 类型，从 Java 7 开始，expr 还可以是字符串（String），但是长整 型（long）在目前所有的版 本中都是不可以的。

3. 用最有效率的方法计算 2 乘以 8

    public static void main(String[] args) {System.out.println(2<<3);}

4. Math.round(11.5) 等于多少？Math.round(-11.5) 等于多少

5. float f=3.4;是否正确

6. short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗

涉及Java的强制类型转换  支持向上自动转型

7.注释

单行注释 格式： // 注释文字

多行注释 格式： /* 注释文字 */

文档注释 格式：/ 注释文字 */

8. 访问修饰符 public,private,protected,以及不写（默认）时的 区别

9. final 有什么用？

• 被final修饰的类不可以被继承
• 被final修饰的方法不可以被重写
• 被final修饰的变量不可以被改变，被final修饰不可变的是变量的引用，而不是引用指向的内容，引
• 用指向的内容是可以改变的

10. final finally finalize区别

11. this与super的区别

• super: 它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函 数，基类与派生类中有相同成员定义时如：super.变量名 super.成员函数据名（实参）
• this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的 形参与类中的成员数据同名，这时需用this来指明成员变量名）
• super()和this()类似,区别是，super()在子类中调用父类的构造方法，this()在本类内调用本类的其 它构造方法。
• super()和this()均需放在构造方法内第一行。
• 尽管可以用this调用一个构造器，但却不能调用两个。
• this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造 函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意 义，编译器也不会通过。
• this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：
• static变量,static方法，static语句块。
• 从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

12. static存在的主要意义

因此比较常见的static应用场景有：

static注意事项

13. 抽象类和接口的对比

相同点

• 接口和抽象类都不能实例化
• 都位于继承的顶端，用于被其他实现或继承
• 都包含抽象方法，其子类都必须覆写这些抽象方法

 不同点

15. 创建一个对象用什么关键字？对象实例与对象引用有何不同？

变量与方法

16. 成员变量与局部变量的区别有哪些

 变量：在程序执行的过程中，在某个范围内其值可以发生改变的量。从本质上 讲，变量其实是内存中的 一小块区域

成员变量：方法外部，类内部定义的变量

局部变量：类的方法中的变量。 成员变量和局部 变量的区别。

作用域

存储位置

 生命周期

18 静态方法和实例方法有何不同？

1 public class Outer {
2
3 private static int radius = 1;
4
5 static class StaticInner {
6 public void visit() {
7 System.out.println("visit outer static variable:" + radius);
8 }
9 }
10 }

1 Outer.StaticInner inner = new Outer.StaticInner();
2 inner.visit

 定义在类内部，成员位置上的非静态类，就是成员内部类。

1 public class Outer {
2
3 private static int radius = 1;
4 private int count =2;
5
6 class Inner {
7 public void visit() {
8 System.out.println("visit outer static variable:" + radius);
9 System.out.println("visit outer variable:" + count);
10 }
11 }
12 }

1 Outer outer = new Outer();
2 Outer.Inner inner = outer.new Inner();
3 inner.visit();

 定义在方法中的内部类，就是局部内部类

1 public class Outer {
2
3 private int out_a = 1;
4 private static int STATIC_b = 2;
5
6 public void testFunctionClass(){
7 int inner_c =3;
8 class Inner {
9 private void fun(){
10 System.out.println(out_a);
11 System.out.println(STATIC_b);
12 System.out.println(inner_c);
13 }
14 }
15 Inner inner = new Inner();
16 inner.fun();
17 }
18 public static void testStaticFunctionClass(){
19 int d =3;
20 class Inner {
21 private void fun(){
22 // System.out.println(out_a); 编译错误，定义在静态方法中的局部类不可以访问外
部类的实例变量
23 System.out.println(STATIC_b);
24 System.out.println(d);
25 }
26 }
27 Inner inner = new Inner();
28 inner.fun();
29 }
30 }

1 public static void testStaticFunctionClass(){
2 class Inner {
3 }
4 Inner inner = new Inner();
5 }

匿名内部类

 匿名内部类就是没有名字的内部类，日常开发中使用的比较多。

1 public class Outer {
2
3 private void test(final int i) {
4 new Service() {
5 public void method() {
6 for (int j = 0; j < i; j++) {
7 System.out.println("匿名内部类" );
8 }
9 }
10 }.method();
11 }
12 }
13 //匿名内部类必须继承或实现一个已有的接口
14 interface Service{
15 void method();
16 }

• 匿名内部类必须继承一个抽象类或者实现一个接口。
• 匿名内部类不能定义任何静态成员和静态方法。
• 当所在的方法的形参需要被匿名内部类使用时，必须声明为 final。
• 匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方 法。

匿名内部类创建方式： 

1 new 类/接口{
2 //匿名内部类实现部分
3 }

• 我们为什么要使用内部类呢？因为它有以下优点：
• 一个内部类对象可以访问创建它的外部类对象的内容，包括私有数据！
• 内部类不为同一包的其他类所见，具有很好的封装性；
• 内部类有效实现了“多重继承”，优化 java 单继承的缺陷。
• 匿名内部类可以很方便的定义回调。

20. 重载（Overload）和重写（Override）的区别。重载的方法能 否根 据返回类型进行区分？

 == : 它的作用是判断两个对象的地址是不是相等。即，判断两个对象是不是同 一个对象。(基本数据类型 == 比较的是值，引用数据类型 == 比较的是内存地址)

1 public class test1 {
2 public static void main(String[] args) {
3 String a = new String("ab"); // a 为一个引用
4 String b = new String("ab"); // b为另一个引用,对象的内容一样
5 String aa = "ab"; // 放在常量池中
6 String bb = "ab"; // 从常量池中查找
7 if (aa == bb) // true
8 System.out.println("aa==bb");
9 if (a == b) // false，非同一对象
10 System.out.println("a==b");
11 if (a.equals(b)) // true
12 System.out.println("aEQb");
13 if (42 == 42.0) { // true
14 System.out.println("true");
15 }
16 }
17 }

22. hashCode 与 equals (重要)

 HashSet如何检查重复

 我们以“HashSet 如何检查重复”为例子来说明为什么要有 hashCode：

 当你把对象加入 HashSet 时，HashSet 会先计算对象的 hashcode 值来判断对 象加入的位置，同时也 会与其他已经加入的对象的 hashcode 值作比较，如果 没有相符的hashcode，HashSet会假设对象没 有重复出现。但是如果发现有相 同 hashcode 值的对象，这时会调用 equals()方法来检查 hashcode 相 等的对 象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不 同的话，就会重 新散列到其他位置。。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速 度。

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

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