一、 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. 整型变量 可以自动转换，在运算的时候的转换规则如下:
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) jdk 1.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的。