整数型: byte,short,int,long。
浮点型: float,double。
字符型： char。
逻辑型: boolean。
二、字符型char1. 字符常量常用单引号括起来的单个字符,如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. 整型变量可以自动转换，在运算的时候的转换规则如下:1) byte,short,char之间不会相互转换。
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和Double提供了快速的运算，但是这2种类型的数据做二进制转换的时候，有些数字不能完全转换，造成精度丢失。
float a1=1.2f;double b1=2.5;double c=a1*b1;System.out.println(c);
打印结果:
3.0000001192092896
实际在开发中，我们对数据的要求较高的时候,那么尽量使用BigDecimal类型来定义小数。
类型溢出: int a=1000000000;int b=1000;System.out.println(a*b);
打印结果: -727379968 乘算的结果明显超出了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("狗吃骨头"); }}测试类:Cat 和Dog都是Animal的实例，因此可以使用intanceof 作判断:
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的。