一、Java的基本数据类型有哪些？

整数型: byte,short,int,long。

浮点型: float,double。

字符型： char。

逻辑型: boolean。

二、字符型char

1. 字符常量常用单引号括起来的单个字符,如char a='a'。

2. Java字符采用Unicode编码，每个字符占2个字节。因此可以用十六进制的编码形式表示。

char c1='\u00061';

3. Java语言中还允许使用'\'将其后的字符转变为其它的含义，如: char c1='\n'; c1表示换行符。

4. a对应的ascii码为97,A为65。

三、 整数类型

1. Java各整数类型有固定的表数范围和字段长度，不受操作系统的具体影响，以保证Java程序的可移植性。

2. Java整型常量的三种表现形式:

十进制: 12,0,-200;

八进制,要求以O开头，如: O12。

十六进制，要求以Ox开头，如Ox12。

3. Long类型的数据需要在后面添加L，否则会报错。

4. 字节范围:

byte 1字节,-128~127 ;

short 2字节，-2^15~2^15-1;

int 4字节,-2^31~2^31-1;

long 8字节：-2^63~2^63-1；

四、 浮点类型

1.浮点类型默认的是double类型，如果声明为float类型，那么需要在变量后面添加f,如 float a=1.2f;

2. float类型,4字节，小数点后7位，double 类型，8字节，小数点后15位,总结: 有效数字位数=整数位数+小数位数，7位以内的用float，15位以内的用double

3. 在使用float或者double进行计算时，会出现精度丢失，通常使用BigDecimal进行更为准确的精度运算。

五、基本数据类型的转换

1. boolean类型的变量不能转换为其他类型的数据。

2) byte,short,char ->int ->long->float->double, 容量小的会自动向容量大的转换。如:

int a=1;
Long b=2L;
Long result=a*b; //运算时会将int类型的a转换为Long类型。

3. 大类型向小类型转换为出现精度丢失、类型溢出，另外float强制转换为Long类型时，会直接舍弃小数部分。

float a1=1.2f;
double b1=2.5;
double c=a1*b1;
System.out.println(c);

打印结果:

3.000000

实际在开发中，我们对数据的要求较高的时候,那么尽量使用BigDecimal类型来定义小数。

类型溢出:
int a=;
int b=1000;
System.out.println(a*b);

打印结果: - 乘算的结果明显超出了Int类型的最大值。

六、为什么新建对象的时候需要重写equals方法的同时又需要重写hashCode()方法?

答:

因为所有的类是Object的子类，每个类都会根据hash算法计算的哈希值来对应一个hashCode, 不同的类的对象可能会计算生成相同的hashCode。主要有以下情况:

1) 如果2个对象hashCode不相等，那么2个对象肯定是不相同，因为hashcode的计算具有幂等性。

2) 如果2个对象使用equals()方法相等，那么hascode的值一定相等，2个对象肯定相同。

3) 如果2个对象是hashCode()方法结果相等，那么equals()方法的结果有可能为true，也有可能会false，2个对象不一定相等，这种情况存在于哈希表里的相同位置下的链表处的不同位置。

七、 final关键字的用法

答: 修饰在类上该类不能被继承，修饰方法，在子类该父类的方法不能被重写, 修饰变量相当于是个常量，但不能被重新赋值, ,否则会报错。

八、访问控制和继承

答：需要牢记一点: 子类的访问权限需要大于或者等于父类。 明细规则如下: ;

• 父类中声明为 public 的方法在人类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

九、 抽象类有哪些特性?

答:

1. 抽象类里的抽象方法必须使用Public或者protected访问权限来控制,不能使用private。

2. 抽象类可以含有构造方法,因为抽象类可以使用匿名内部来实例化。

3. 抽象类与具体的类不同点在于，抽象类可以包含抽象方法，由其子类去具体的实现抽象方法，而且抽象类需要使用abstract 来进行修饰。

例如:

package com.example.traditional; / *author:bingbing *日期:2020年7月13日 *时间:下午10:06:41 */ public abstract class Pizza { protected String name; public abstract void method(); Pizza(){ System.out.println("实例化抽象类!"); } } 

在Main方法里可以这样,只需要在匿名名内部类的形式来实现定义的抽象方法即可。

package com.example.traditional; / *author:bingbing *日期:2020年7月13日 *时间:下午10:10:24 */ public class Demo01 { public static void main(String[] args) { Pizza pizza=new Pizza() { @Override public void method() { // TODO Auto-generated method stub } }; } } 

十、静态内部类有哪些特性？

1.静态内部类可以在外部类的静态成员中访问或者实例化（非静态内部类不可以）---优势，例如单例模式的实例化。

 //使用静态内部类来创建实例 class Singleton { private static volatile Singleton instance; //私有构造器，防止被外部实例化 private Singleton() {} //静态内部类，该类内有一个私有的静态属性 private static class SingletonInstance { private static final Singleton INSTANCE = new Singleton(); } //提供一个公有的方法返回静态内部类创建的对象 public static synchronized Singleton getInstance() { return SingletonInstance.INSTANCE; } } 

2.静态内部类可以访问外部类的静态成员不可以访问非静态成员（非静态内部类可以访问类的静态和非静态成员）---限制

需要在a变量修改成static 才行，由此可以发现静态内部类只能访问外部类的静态成员属性和方法。

3. 静态内部类可以申明静态成员（非静态内部类则不可以申明静态成员）

package com.example.thread; public class Demo04 { private static Demo04 demo04; static int a=0; static class Test{ Demo04 demo04=new Demo04(); static int b=1; void test(){ a=5; } } } 

4.在外部类外创建该外部类的内部静态类，不用依附于外部类的实例（而非静态内部类则需要依赖于外部类的实例）,即访问的时候直接使用外部类.静态内部类类名 ，非静态内部类需要new一个实例出来，才能够访问。

十一、接口有哪些特性？

答:

1) 接口支持多继承。

2) 接口声明的方法一般是没有body的，默认为public修饰，不能使用private和protected修饰。

3) jdk1.8后，可以在接口里写入含有body的方法,但需要使用default 关键字修饰。

4) 接口不能继承实体和抽象类。

public interface Test implements A,B,C{ public int test1(); class a{ } default int test(){ return 0; } } 

十二、值传递和引用传递

答案: A C D 考查的是引用传递和值传递，值传递是指在会将实参的变量进行拷贝一份，不会影响到实参的内容，引用传递的形参和实参实际指向的是内存中的同一个地址,但是参数地址不同，因此引用传递改变内容的话，也会改变实参的内容。

以下i的打印结果为:

package com.tedu.day05; / *author:bingbing *日期:2020年7月15日 *时间:下午9:36:06 */ public class Demo01 { public static void main(String[] args) { int i=0; aow(i++); System.out.println(i); } private static void aow(int i) { i+=2; } } 

打印结果为: 1

考查值传递， 因为 aow方法的Int i为一个新的类型的Int,传参传的变量的一个拷贝，因此实际上i的值并没有发生改变。

十三、String 类型的学习

1. String str=new String("abc") ,创建了几个对象?

答: 1个或者2个,为什么是1个或者2个对象，那么我们可以先了解一下常量池的概念,JVM中 通过常量池来使字符串共享，那么使用常量池，可以避免字符串对象重复创建，比如常量池里面已经有了"abc", 那么String a="abc",就直接从常量池取出来。

分析: String str=new String("abc"); 可以将这一行代码拆分为"abc"和new String(),String类的构造方法同时也是一个String 类型的数据, String original也为一个字符串，如果常量池里没有这个字符串，因此会先在常量池里创建一个对象, 同时也会通过new来新建一个对象，此情况下是创建了2个对象。

 public String(String original) { this.value = original.value; this.hash = original.hash; }

如果常量池里已经存在了该字符串，那么就不会重复创建该对象，直接通过new来创建了一个对象。

2. String,StringBuilder,StringBuffer有什么区别?

String 是一个final类型，对值的修改是创建一个新的对象，如果常量池中存在，那么就不用重新创建，如果不存在那么就用重新创建对象，StringBuilder和StringBuffer对对象的修改可以多次，但不会创建新的对象。StringBuilder相比StringBuffer速度快，因为StringBuffer是线程安全的。

十四、 ==和equals的区别？

基本类型用==比较的时候，比较的是值的内容，如果是引用类型比较的是地址。

equals方法是Object类里的方法，用于比较地址，String类型重写了equals方法，比较的是内容值，包装类也重写了equals方法比较的也是值的内容。

object:

 public boolean equals(Object obj) { return (this == obj); }

String:

 public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length; if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }

十五、重载、重写、向上造型、向下造型？

答:

重载在一个类里面，方法名相同，方法的参数不同，返回类型可相同也可不同。

重写在不同的类里面发生，子类重写父类的方法，调用的时候还是子类重写的方法。

向上造型，指子类的对象赋值给父类的引用。

向下造型，把指向子类对象的父类引用赋值给子类引用叫向下造型。

十六、什么是多态？

答：

1. 多态是指同一个行为具有多个不同的表现形式或形态,多态其实就是用同一个接口去实现不同的目的,如打印机:

2. 多态存在的条件是什么？

继承、重写、父类引用指向子类对象。

看如下例子:

package com.example.day06; / *author:bingbing *日期:2020年7月19日 *时间:上午10:33:25 */ public abstract class Animal { abstract void eat(); } 

猫:

package com.example.day06; / *author:bingbing *日期:2020年7月19日 *时间:上午10:34:25 */ public class Cat extends Animal { @Override void eat() { System.out.println("猫吃鱼!"); } } 

狗:

package com.example.day06; / *author:bingbing *日期:2020年7月19日 *时间:上午10:34:02 */ public class Dog extends Animal{ @Override void eat() { System.out.println("狗吃骨头"); } } 

package com.example.day06; / *author:bingbing *日期:2020年7月19日 *时间:上午10:35:21 */ public class Test { public static void main(String[] args) { Cat c1=new Cat(); show(c1); Dog d1=new Dog(); show(d1); } public static void show(Animal a) { if(a instanceof Cat) { Cat c=(Cat)a; c.eat(); }else if(a instanceof Dog) { Dog d=(Dog)a; d.eat(); } } } 

打印结果:

十七、静态绑定和动态绑定的区别是什么？

答: 在java中，除了final、static、private修饰的方法和构造方法是静态绑定， 其他方式的方法均为动态绑定,在运行阶段绑定。区别有静态绑定是在编译阶段进行的，动态绑定是在运行阶段绑定的。

如下代码输出结果为:

public class Main { public static void main(String[] args) { Father father = new Son(); System.out.println(father.age); father.name(); father.age(); } } class Father{ public int age = 50; public static void name(){ System.out.println("Father name"); } public void age(){ System.out.println("Father age is " + age); } } class Son extends Father{ public int age = 20; public static void name(){ System.out.println("Son name"); } @Override public void age(){ System.out.println("Son age is " + age); } } 

打印结果:

50

Father name

Son age is 20

可以发现只有重写了的是动态绑定的，static修饰的方法时静态绑定的， fater.name() 方法仍然调用的是father的。