java面向对象，数据类型深入

java程序员面试题day02

1.类和对象有什么区别？

java中的类通过class关键字进行定义，代表的是一种抽象的集合，在类中可以定义各种的属性和方法，代表的是每一个类的实例的特定的数据和动作，java虚拟机对类仅仅加载一次，对类中的静态成员也仅仅加载一次。

对象指的是某一个特定抽象的实例，它属于某一种类型，也就是对象是通过类来确定的，它必须从属于某个类，通过new关键字进行创建，代表的是一个特定类型的实例，对象可以被多次的创建。

类是一种抽象，对象是类的具体实现。

2.java中如何利用继承来重用代码？

首先，java中的继承只有单继承，也就是子类只能去继承一个父类，而不能继承多个父类，子类中对父类的方法进行覆盖，在子类中定义一个和父类方法名相同的方法就可以参数类型和返回值类型保持一致。这种手段也叫方法覆盖（重写）。

通过继承，子类就拥有父类除开私有成员的所有的成员，对于方法上，子类可以使用多态，让子类拥有自己的独特的方法实现方式。

3.谈谈一下java中的多态？

多态的本质在于，发送消息给某个对象，让该对象自行决定去响应何种行为，通过将子类对象的引用赋值给超类对象的引用变量来实现动态方法的调用。

 package test;

 class Man {

 public int eyes = 2;

 void getEyesColor() {

 System.out.println("父类眼睛颜色");

 }

 }

 class Asian extends Man {

 void getEyesColor() {

 System.out.println("black eyes");

 }

 }

 class Euro extends Man {

 void getEyesColor() {

 System.out.println("blue eyes");

 }

 }

 public class Main {

 public static void main(String[] args) {

 Man man1 = new Asian();

 Man man2 = new Euro();

 man1.getEyesColor();

 man2.getEyesColor();

 }

 }

4.介绍下java中静态成员的特点？

类的静态成员是指用static修饰的成员，包括静态成员变量，静态方法，静态代码块.

共同的特点是：

<1>在类的加载时进行创建和初始化或者执行代码；

<2>对于一个类而言，都只有一份；

<3>类的所有的实例都可以访问到他们。

一个例子：

 package test;

 public class Main {

 static int a=5;

 public static void testMethod(){

 System.out.println("static method testing");

 }

 static{

 System.out.println("static code block testing");

 }

 public static void main(String[] args) {

 System.out.println(Main.a);

 Main.testMethod();

 }

 }

 运行结果：

 static code block testing

 5

 static method testing

 静态代码块在类加载时执行了，然后再执行main主函数中要求输出的信息。

 5.派生类中的构造方法如何为父类传递参数？

 一个例子：

 package test;

 class Base{

 static int a ;

 Base(){

 }

 //基类的带参构造方法

 Base(int a ){

 this.a = a;

 }

 }

 class Child extends Base{

 //子类的无参构造器

 Child(){

 super(100);

 }

 //子类的带参构造器

 Child(int a){

 super(a);

 }

 }

 public class Main {

 public static void main(String[] args) {

 new Child();

 //new Child(200);

 System.out.println(Base.a);

 }

 }

结果：

100       200

在java中，使用super关键字加（）的形式为父类的 构造方法提供参数，通过参数的数目和类型去决定调用哪一个构造方法，如果调用的是父类的默认的无参数构造方法，则可以不必显式地使用super().但是需要注意的是，super的使用必须放在子类的构造方法的第一行。

6.Java中的接口和抽象类的区别和联系？

联系：1>接口和抽象类指的都是不能具体描述一个对象的类型，包含了不完整的信息，需要实现类来进行具体的实现。

2>接口和抽象类都可以用于进行类型的强制转换

3>两者都不可以被实例化

区别：1>所有的对象都是通过类来描述的，但是如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类，往往用来表示在对问题领域进行分析，设计中得出的抽象的概念。

2>接口是在抽像类上的进一步的抽象，所有的方法都是抽象的，没有任何的实现。

3>如果一个类中包含一个或者多个抽象的方法，该类必须申明为 抽象类。

4>接口是一种特殊形式的抽象类，在java中抽象类表示一种继承关系，一个类只能继承一个抽象类 ，而一个类 可以实现多个接口。

7.简述一下内部类的实质？

内部类生存在其他的类内部，包括四种类型：

 package test;

 /*

 * 静态内部类：定义在一个外部类中，被static所修饰

 * */

 class Outter{

 static class Inner{

 }

 }

 /*

 * 成员内部类：定义在一个外部类中，没有被static修饰

 * */

 class Outter2{

 class Inner2{

 }

 }

 /*

 * 局部内部类,定义在一个方法中

 * */

 class Test{

 public void abc(){

 class MyLocalClass{

 }

 }

 }

 /*

 * 匿名内部类：定义在一个方法中，但是没有指明类的具体名字,在这里仅仅是实现一个接口

 * */

 class Test2{

 public void abc(){

 new myInterface(){

 public void interMethod(){

 }

 };

 }

 }

 public class Main {

 public static void main(String[] args) {

 //访问一个成员内部类

 Outter2 o2 = new Outter2();

 Outter2.Inner2 i = o2.new Inner2();

 }

 }

1>静态内部类：相当于 外部类的静态成员，使用static修饰的内部类，隶属于外部类，使用起来相当于一个独立的外部类。

2>成员内部类：相当于外部类的普通成员，隶属于外部类的具体对象，定义时需要先创建外部类的对象，再创建它的实例。

3>局部内部类：定义在一个方法的方法体中，往往仅作为方法短暂的使用，只能访问用final修饰的局部变量。

4>匿名内部类：定义在方法体中，没有指定具体的名字。工作本质和局部内部类类似。

8.包如何被创建和使用？

避免重名，package a.b.c

9.说明private protected public default的区别？使用范围

Public:具有最大的访问权限，可以访问任何一个在classpath下的类、接口和异常，往往用于对外的情况，也就是对象或者类对外的一种接口的形式。

Protected:用于保护子类，子类可以用它所修饰的成员，相当于传递给子类的一种继承的东西。

Defalut:针对本包访问而设计的，任何处于本包下的类、接口和异常都可以相互访问。

Private:只能在本类内部被访问到和修改，其他类则不可以。

10.int和integer的区别？

Int的字节的长度为4，用于表示现实中的正负整形数字，由于属于基础数据类型，它的创建不会再堆内存中分配空间，一般是保存在栈内存中，可以直接进行加减乘除的基本算数运算，同时它作为参数传递的时候，直接传递的是它的值。

Integer是int的包装类，可以说，它是一个类。它不能直接参与基本的算数运算，必须转换成int才可以进行运算，同时它作为参数传递时，传递的是对象的一个引用。

看一个他们之间相互转换的例子：

 package test;

 public class Main {

 public static void main(String[] args) {

 //基本数据类型的int

 int a = 10;

 //通过构造器或者valueOf的静态方法得到包装类型

 Integer b = new Integer(a);

 Integer c  = Integer.valueOf(a);

 //将包装类型转换为基本数据类型

 b.intValue();

 c.intValue();

 }

 }

11.int型数据的取值范围？

int型用四个字节进行存储，范围是：-2^31~(2^31)-1

12.如何用八进制和十六进制表示整形数据？

int型的字面量都为十进制、八进制的字面量采用0开头、十六进制采用0x开头。十六进制：0 1 2 3 4 5 6 7 8 9 a b c d e f八进制：0 1 2 3 4 5 6 7 8

13.long型的数据的表示范围？

long型数据用8位进行存储，取值范围为-2^63~(2^63)-1

14.java中的float和double类型数据的精度？

Float:范围是3.4E+10^(-38)~3.4E+10^(38)

Double:范围是1.7E+10^(-308)~1.7E+10^(308)

在java中默认的浮点型数据为double型

报错：float i = 1.2;

正确: float i = 1.2f;或者 float i = (float)1.2;

15.整类和实型的相互转换？

整形转换为实型时，不会有精度的丢失，但是实型转换为整形时会有。转换的过程分为隐式和显式的，后者是通过强制类型转换来实现的，前者是系统的自动的行为。

16.如何利用bigDecimal进行精确的计算？

 自己分装的类：

 package test;

 import java.math.BigDecimal;

 public class Main {

 //加法运算

 public static double add(Double num1,Double num2){

 BigDecimal b1 = new BigDecimal(Double.toString(num1));

 BigDecimal b2 = new BigDecimal(Double.toString(num2));

 return b1.add(b2).doubleValue();

 }

 //减法运算

 public static double substract(Double num1,Double num2){

 BigDecimal b1 = new BigDecimal(Double.toString(num1));

 BigDecimal b2 = new BigDecimal(Double.toString(num2));

 return b1.subtract(b2).doubleValue();

 }

 //乘法运算

 public static double multiply(Double num1,Double num2){

 BigDecimal b1 = new BigDecimal(Double.toString(num1));

 BigDecimal b2 = new BigDecimal(Double.toString(num2));

 return b1.multiply(b2).doubleValue();

 }

 //除法运算

 public static double divided(Double num1,Double num2){

 if(num2==0){

 System.out.println("divided by zero!");

 System.exit(0);

 }

 BigDecimal b1 = new BigDecimal(Double.toString(num1));

 BigDecimal b2 = new BigDecimal(Double.toString(num2));

 return b1.divide(b2).doubleValue();

 }

 public static void main(String[] args) {

 System.out.println(add(0.05,0.01));

 }

 }

17.java中可以用0来表示true吗？

编译错误的例子：

1>If(100){

}

括号中或者为true或者为false

2>boolean a ;

If(a){

}

布尔类型的变量在用之前必须进行初始化，否则编译报错。

18.boolean和Boolean的区别？

boolean是基础数据类型，boolean是类。

boolean一般存在栈空间中，Boolean存在堆空间中。

boolean有true和false两种值，Boolean有true false null。

19.char类型数据的取值范围？

char采用unicode编码，用两个字节表示一个字符，所有的char型数据的字节长度都是2个字节，一共16位。

范围是：0~(2^16)-1

20.char能否存储汉字？

由于每个中文字符都有对应的Unicode编码，则可以存储汉字。

一个例子：

 package test;

 public class Main {

 public static void main(String[] args) {

        //char c = '中';

        int i = 20013;

        char res = (char)i;

        System.out.println(" "+res);

 }

 }