java基础问题

1、long(8) 和 float(4)取值范围谁大？

因为long是8个字节，float是4个字节。按常理来说不能向上转换。但因为float是浮点型，计算方式与整形不一样，所以

Ⅰ、首先long可以自动转换成float;

例如：

Long number=88888;//88888

Float newNumber=number;//88888.0

Ⅱ、long表示的数值范围：2^63-1

float表示的数值范围：3.4 * 10^38

long和float的存储结构都不一致：

1） long是整数类型，直接是1，08位那么存储；

2） float是浮点类型，是带小数的二进制换算，存储的是有效数字位（科学计数法）

   

2、位异或运算符的特点：

^的特点：一个数据对另一个数据位异或两次，该数本身不变。

​int a = 1;

int b = 2;

a = a ^ b;

b = a ^ b;//b = 1

a = a ^ b;//a = 2

异或运算符其本质就是将十进制转化成二进制，然后同位相同则为0,不同为1.

十进制	二进制
1 = 0* 2^1  +  1 * 2^0	01
2 = 1 * 2^ 1 +  0 * 2^0	10
11= 1 * 1^2 + 1 * 1^1 =3	11
101= 1 * 2^2 + 0 +1 * 2^0=5	101

   

   

3、位运算效率最快，其核心都是二进制

例如：2 * 8 = 2 * 2^3 = 2 << 3

   

4、switch支持byte/lang/String(1.8).

   

5、continue、break 、return 的区别？

Continue ：跳出此次循环，只能在循环里面使用。

Break ：结束当前循环，只能在循环里面使用。

Return ：终止当前方法，不局限于循环。

   

6、面向对象的三大特征：

封装、继承、多态

   

7、数组

一维数组初始化：

①String[] strs = new String[x]. x是定长只是声明一个strs长度为x的字符串数组

②String[] strs = {strs1,strs2…}; 声明并初始化

二维数组的初始化：二维数组就是一堆一维数组的数组（集合）。

①String[][] strs = {arr1,arr2…}; arr1:指数组

②String[][] strs = new String[4][3]; 4：指数组长度，3：指包含每一个数组的最大长度（经测试,直接给二维数组赋值才会报错，其他时候没什么球用）。

③String[][] strs = new String[4][];[]为赋值代表变长。

   

8、继承执行顺序

   

   

   

   

   

执行顺序：father_static > son_static >father_codePiece>father_comnstructor>son_codePiece>son_constructor

注意：静态代码块只会被调用一次，执行构造方法前会执行构造代码块一次。

   

9、方法的重载和重写问题

Overload 重载：重载可以改变返回值类型，方法的重载只看参数列表的不同。

Override 重写：一般是子类重写父类方法，重写只与返回值类型有关。子类方法的返回值只能是父类返回值的子类。

   

10、抽象方法和接口

关键字	abstrct	Interface
定义	抽象类不能创建实例，它只能作为父类被继承。抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象。从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类的随意性。	接口只是一种行为规范，是一种要使用就要满足该规则的要求
方法	抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类	只能有方法声明，不能有方法体
规则	具体派生类必须覆盖基类的抽象方法，如果不覆盖所有的抽象方法，那么这个派生类仍然是个抽象类	接口中不能包含字段(域)、构造函数、析构函数、静态成员
构造方法	可以有	不能有
普通成员变量	可以有	不能有,可以有常量
静态方法	可以有	不能有
继承/实现	一个class只能继承一个抽象方法	一个class可以同时实现多个接口
抽象方法修饰	不能与private（子类调用）\final（终态属性/方法/类）\static一起使用	不能与private、protected、final一起使用
实现/继承后	继承抽象方法可以实现或者不实现抽象方法	实现接口类必须实现每一个接口方法。但是抽象方法可以实现接口类，同时可以不实现接口方法。留给子类去实现。

   

11、final和static

Final:

修饰类，类不能被继承

修饰方法，方法不能被重写

修饰变量，变量就变成常量，只能被赋值一次。

常量的命名规范：

Public static final String STRING_NAME = "zhangsan";

修饰引用类的变量：

 

static:

随着类加载而加载

优先于对象存在

被类的所有对象共享

·如果某个成员变量是被所有对象共享的，那么就可以把他定义为静态的。

   

①静态方法可以直接通过className.staticFunction()调用

也可以通过对象。staticFunction()调用

   

②静态成员不能访问常规成员，但常规成员可以访问静态成员

   

③静态方法中没有this关键字，因为this关键字随着对象创建而存在

如果一个类中全是静态成员，那么建议把这个类的构造方法设置为private.

   

12、package 、 import 、class 的顺序关系

顺序 package > import > class

Package : 当前类所在的包，有且必须只有1个

Import ：引入的其他类，可以有n个

Class:修饰当前类的，必须有。

   

13、外部类和内部类

   

    public static void main(String[]args){

        Person.Sonps = new Person().newSon();

            ps.showNum();

        }

   

14、匿名内部类

    Public interface A{

        Void show();

    }

      

    Public class B {

        //填空

 Public static A aFunction(){

            Return new A(){

                @override

                Show(){

                    Syso("helloworld");

                }

            }

        }

    }

      

    Class Test{

        Main{

            B.aFunction.show();//会输出"helloWorld"

        }

    }

   

15、String的特征。

不能被继承，因为它是被fianl修饰，同时也没有子类。

   

16、==和equals的区别

== ：比较基本数据类型是字面量，比较引用数据类型是内存地址

Equals: 只能比较引用数据类型，如果对象没有重写equals方法，那么和==并无区别（字面量）。

重写后，一般比较的是对象里每一个属性。

17、异常

Try…catch和throws的区别：

Try…catch不会中断程序，而throws会中断程序。通常自己能处理的就用try…catch,处理不了就用throws.

   

throw和throws的区别：

theow一般在catch（）里面

Throws-搬接在方法的后面

18、JVM是多线程启动吗？

是的

1、主程序main方法的启动

2、finaliza垃圾回收机制也会启动

   

19、适配器模式（adapter）

概述：在不修改原来2个类的模板情况下，通过转换是他们能够协作起来.

定义：把一个类的的接口转变成客户期待的接口。

设配器模式有3种：

Target: 期望接口（USB）

Adaptee:被适配接口(PS2)

AdapteeSon:实现被适配接口

Adapter ：适配器类

①类适配器

Interface Target:

>> void usb();//此处没有方法体

Interface Adaptee:

>>void ps2();//此处没有方法体

AdapteeSon implement Adaptee:

>>void ps 2(){};

Adapter extends Adaptee implements Target :

>>void usb(){

Super.ps2(); //实现接口是直接使用父类（被设配）的实现方法

}

②对象适配器

Target:

>>void usb(){};

Adaptee:

>>void ps2(){};

Adapter extends Target:

Adaptee adptee;

Public Adaptee(Adapter adapter){this.adapter = adapter}

@overload

Void usb(){

Adapter.ps2();

}

③接口适配器

简单讲就是某个接口种有n个方法

而且恰好你要使用其中2、3个方法

此时，实现接口就要实现接口中的所有方法，这种方案肯定不太理想。

于是就有了接口适配器：

定义一个abstrct类，实现 implements类。但只实现其中需要使用的2、3个方法。

定义一个是适配器Adapter类，继承abstrct类。那就ok了。

   

	优点	缺点
适配器	1、通过适配器，可以调用统一接口，更简单、直接 2、将目标类和适配者类解耦，通过引入一个适配器类，重用适配者类无需修改源码。 3、一个对象适配器可以适配多个适配者Adaptee	1、对于更换适配器来说，对象适配器的实现比较复杂 2、
应用场景	1、系统需要使用的类，但是这些类又不符合系统的接口 2、2个类相似，但具有不同的接口 3、使用第三方插件，插件接口的定义有些不同。同时又不希望修改自己已完成好的类。