JAVA 复习总结（四）

小灰灰 2022-06-14 04:43 150阅读 0赞

# Mod取余 #

*  实数取余整数
    
        使用实数的整数部分取余 小数部分不变
 *  实数取余实数
    
        可以运算 结果不定
 *  实数 mod 0
    
        结果全是NAN

exp: 17.2 mod 4 ====== 1.2XXXX

# equals与null #

null.equals(string) === > NOP异常
    string.equals(null) ====> false

所以一般将常量字符串放在equals的前面防止出现NOP异常

# 位运算 #

只能用于**整数系**(long int,short int,unsigned int ,int ),并把整数转换成二进制进行运算,如果给的两个数不是整数,编译会报错

java中是循环移位

int :  
c = a >> b ===> a/Math.pow(2,(b mod 32))

# 静态代码块和构造块 #

*  静态块:static申明 JVM加载类时执行 只执行一次
 *  构造块:类中直接使用\{\}定义 每次创建对象时执行

执行顺序优先级：

*  静态块>main()>构造块>构造方法  
    法

构造块按照**申明顺序**执行

# HashMap的实现 #

*  HashMap的底层主要是基于**数组和链表**来实现的，它之所以有相当快的查询速度主要是因为它是通过计算散列码来决定存储的位置。
 *  HashMap底层是通过**链表来解决hash冲突的**
 *  基本属性 loadFactor加载因子是表示Hsah表中元素的**填满的程度**.

若:加载因子越大,填满的元素越多,好处是,空间利用率高了,但:冲突的机会加大了.链表长度会越来越长,查找效率降低。

反之,加载因子越小,填满的元素越少,好处是:冲突的机会减小了,但:空间浪费多了.表中的数据将过于稀疏（很多空间还没用，就开始扩容了）  
冲突的机会越大,则查找的成本越高.

因此,必须在 “冲突的机会”与”空间利用率”之间寻找一种平衡与折衷. 这种平衡与折衷本质上是数据结构中有名的”时-空”矛盾的平衡与折衷.

如果机器内存足够，并且想要提高查询速度的话可以将加载因子设置小一点；相反如果机器内存紧张，并且对查询速度没有什么要求的话可以将加载因子设置大一点。不过一般我们都不用去设置它，让它取默认值**0.75**就好了。

# 类的继承和多态 #

创建子类会调用父类构造方法 但是不会创建父类对象

*  a.子类方法**不能缩小父类方法的访问权限**（可以扩大），而且子类**不能抛出比父类方法更多的异常**，其必须抛出和父类方法抛出的**相同的异常**，或者子类方法抛出的异常类是父类方法抛出的**异常类的子类**。
 *  b.父类的**静态方法不能被子类覆盖为非静态方法**。同样，**父类的非静态方法不能被子类覆盖为静态方法**
 *  c.子类可以定义与父类的静态方法同名的静态方法，以便在父类中隐藏父类的静态方法。子类覆盖静态方法和覆盖一般方法的区别是，运行时，JVM把静态方法和所属类绑定，而将一般方法和所属实例绑定。
 *  d.父类的**私有方法不能被子类覆盖**。虽然不会出现编译错误，但是实际上子类并没有从父类继承这个方法，所以，其并没有覆盖关系。
 *  e.父类的抽象方法通过子类实现父类的抽象方法或者子类重新声明父类的抽象方法来实现覆盖。
 *  f.父类的**非抽象方法可以被覆盖为抽象方法**

# 类的上下转型、 #

*  1、父类引用可以指向子类对象，子类引用不能指向父类对象。
 *  2、把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。  
    　　 如Father father = new Son();
 *  3、把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。  
    　　 如father就是一个指向子类对象的**父类引用**，把father赋给子类引用son 即Son son =（Son）father；  
    　　 其中father前面的（Son）必须添加，进行强制转换。
 *  4、upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效
 *  5、向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。

父类引用指向子类对象。

举个例子：有2个类，Father是父类，Son类继承自Father。

`Father f1 = new Son();` // 这就叫 upcasting （向上转型)  
// 现在f1引用指向一个Son对象  
`Son s1 = (Son)f1;` // 这就叫 downcasting (向下转型)  
// 现在f1还是指向Son对象

第2个例子：  
`Father f2 = new Father();`  
`Son s2 = (Son)f2;` // 出错，子类引用不能指向父类对象

# 静态绑定和动态绑定 #

*  静态绑定是指在程序**编译**过程中，把函数（方法或者过程）调用与响应调用所需的代码结合的过程称之为静态绑定。
 *  动态绑定是指在**执行**期间（非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法
 *  除了限制访问,访问方式也决定哪个方法将被子类调用或哪个属性将被子类访问. 函数调用与函数本身的关联,以及成员访问与变量内存地址间的关系,称为绑定.动态绑定则针对运行期产生的访问请求,只用到运行期的可用信息. 在面向对象的代码中,动态绑定意味着决定哪个方法被调用或哪个属性被访问,将基于这个类本身而不基于访问范围.

静态绑定和动态绑定区别：

*  静态绑定发生在编译时期，动态绑定发生在运行时
 *  使用**private**或**static**或**final**修饰的变量或者方法，使用**静态绑定**。而虚方法（**可以被子类重写的方法**）则会根据运行时的对象进行**动态绑定**。
 *  静态绑定使用类信息来完成，而动态绑定则需要使用对象信息来完成。
 *  重载(Overload)的方法使用静态绑定完成，而重写(Override)的方法则使用动态绑定完成。

# this和super关键字的用法 #

this的用法

1.  普通的直接引用 相当于是指向当前对象本身。
2.  形参与成员名字重名，用this来区分

super的用法

1.  普通的直接引用 相当于是指向当前对象的父类
2.  子类中的成员变量或方法与父类中的成员变量或方法同名
3.  引用构造函数

this和super异同:

1.  this和super不能同时出现在一个构造函数里面
2.  this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
3.  从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

# null #

*  在编译和运行时期，将null强制转换成任何引用类型都是可行的，在运行时期都不会抛出空指针异常。
 *  当你直接将null赋值给基本类型，会出现编译错误。但是如果将null赋值给包装类object，然后将object赋给各自的基本类型，编译器不会报，但是你将会在运行时期遇到空指针异常。这是Java中的自动拆箱导致的
 *  任何含有null值的包装类在Java拆箱生成基本数据类型时候都会抛出一个空指针异常
 *  如果使用了带有null值的引用类型变量，instanceof操作将会返回false

## `<init>`和`<clinit>`方法 ##

区别

*  `<clinit>`：在jvm第一次加载class文件时调用，包括静态变量初始化语句和静态块的执行
 *  `<init>`:在实例创建出来的时候调用，包括调用new操作符；调用Class或Java.lang.reflect.Constructor对象的newInstance()方法；调用任何现有对象的clone()方法；通过java.io.ObjectInputStream类的getObject()方法反序列化。

（1）`<clinit>`()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，点贵在他之后的变量，在前面的静态语句块中可以赋值但不能访问。

public class Test{
    static{
    i = 0;                                        //给变量赋值可以正常通过
    System.out.println(i);               //这句编译器会提示“非法向前引用”
    }
    static int i = 1;
    }

（2）`<clinit>`()方法与类的构造函数（或者说实例构造器中的()方法）不同， 它不需要显示的调用父类构造器，虚拟机会保证在子类的()方法执行之前，父类的`<clinit>`()方法已经执行完毕。因为在虚拟机中第一个被执行的`<clinit>`()方法的类肯定是java.lang.Object。

（3）由于父类的`<clinit>`()方法先执行，也就意味着父类中定义的静态语句块要优先于子类类的变量赋值操作。

（4）`<clinit>`()方法对于类或者接口来说并不是必须的，如果一个类没有静态语句块，也就没有变量的赋值操作，那么编译器可以不为这个类生成`<clinit>`()方法。

（5）接口中不能使用静态语句块，但仍然可以有变量初始化的赋值操作，因此接口与类一样都会生成`<clinit>`()方法。但接口与类不同，执行接口的`<clinit>`()方法不需要先执行父接口的`<clinit>`()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的`<clinit>`()方法。

（6）虚拟机会保证一个类的`<clinit>`()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的`<clinit>`()方法中有耗时很长的操作，就可能造成多个线程阻塞。

--------------------