1long(8) float(4)取值范围谁大?

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

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

例如:

Long number=88888;//88888

Float newNumber=number;//88888.0

long表示的数值范围:2^63-1

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

longfloat的存储结构都不一致:

1 long是整数类型,直接是108位那么存储;

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 = 1^1

01

2 = 1 ^ 2 + 0^1

10

1 ^ 2 = 1^2 +1^1 =3

11

1 ^ 2 ^ 2 = 1

01

   

   

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

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

   

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

   

5continuebreak 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一起使用

不能与privateprotectedfinal一起使用

   

实现/继承后

继承抽象方法可以实现或者不实现抽象方法

实现接口类必须实现每一个接口方法。但是抽象方法可以实现接口类,同时可以不实现接口方法。留给子类去实现。

  

  

   

11finalstatic

Final:

修饰类,类不能被继承

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

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

常量的命名规范:

Public static final String STRING_NAME = "zhangsan";

修饰引用类的变量:

 

static:

随着类加载而加载

优先于对象存在

被类的所有对象共享

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

   

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

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

   

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

   

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

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

   

12package 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"

        }

    }

   

15String的特征。

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

   

16==equals的区别

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

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

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

17、异常

Try…catchthrows的区别:

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

   

throwthrows的区别:

theow一般在catch()里面

Throws-搬接在方法的后面

18JVM是多线程启动吗?

是的

1、主程序main方法的启动

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

   

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个方法

而且恰好你要使用其中23个方法

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

于是 就有了接口适配器:

定义一个abstrct类,实现 implements类。但只实现其中需要使用的23个方法。

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

   

  

优点

缺点

适配器

1、通过适配器,可以调用统一接口,更简单、直接

2、将目标类和适配者类解耦,通过引入一个适配器类,重用适配者类无需修改源码。

3、一个对象适配器可以适配多个适配者Adaptee

1、对于更换适配器来说,对象适配器的实现比较复杂

2

应用场景

1、系统需要使用的类,但是这些 类又不符合系统的接口

22个类相似,但具有不同的接口

3、使用第三方插件,插件接口的定义有些不同。同时又不希望修改自己已完成好的类。

  

   

内容来源于网络如有侵权请私信删除

文章来源: 博客园

原文链接: https://www.cnblogs.com/tiankx/p/13899993.html

你还没有登录,请先登录注册
  • 还没有人评论,欢迎说说您的想法!

相关课程