Java中的小知识
目录
- 1.String、StringBuffer与StringBuilder
- 2.java中的整型及原码、反码、补码的概念
- 3.int 与Integer
- 4.&与&&
- 5.java中的基本数据类型
- 6.抽象类与接口的区别
- 7.java的基本特性
1.String、StringBuffer与StringBuilder
###1.1 三者介绍 * String：字符串常量 * StringBuffer与StringBuilder：字符串变量1.2 三者执行速度比较
StringBuilder > StringBuffer > String
原因：String是字符串常量，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被ＧＣ回收掉，所以使得执行效率很低；而StringBuffer与StringBuilder是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作，这样就不会像String一样创建一些额外的对象，所以速度较快。
特例：
String str = “This is only a” + “ simple” + “ test”;
StringBuffer builder = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
以上代码StringBuffer 没有明显的优势。
原因：在JVM中实现时
String str = “This is only a” + “ simple” + “test”;
等价于
String str = “This is only a simple test”;
如果你的字符串是来自另外的String对象的话，速度就没那么快了,比如
str =str1 + str2 +str3；
1.3 线程安全
- StringBuilder：线程非安全的
- StringBuffer：线程安全的
说明：当我们在字符串缓冲被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，但是可以保证StringBuffer是可以正确操作的。但是由于大多数情况下我们的操作是在单线程下，所以大多数情况下，考虑到速度的原因，建议用StringBuilder而不用StringBuffer的。
1.4 使用场景
- String：操作少量的数据时
- StringBuilder 单线程使用字符串缓冲区操作大量数据时
- StringBuffer 多线程使用字符串缓冲区操作大量数据时
2. java中的整型及原码、反码、补码的概念
java中的整型有byte，short，int，long四类。java没有无符号类型（unsigned），所以各个整型能表示的最大整数大约是该类型能表示的数量的一半。
- byte：1字节 -128 ~ 127，
- short：2字节 -32 768 ~ 32 767；
- int：4字节 -2 147 483 648 ~ 2 147 483 647（20亿）
- long：8字节 -9 223 372 036 854 775 808 ~ 9 223 372 036 854 775 807
说明：java中用补码表示二进制数，补码的最高位是符号位，最高位为“0”表示正数，最高位为“1”表示负数。正数补码为其本身；负数补码为其绝对值各位取反加1；
步骤：
- byte为一字节8位，最高位是符号位，即最大值是01111111，因正数的补码是其本身，即此正数为01111111，十进制表示形式为127
- 最大正数是01111111，那么最小负是10000000(最大的负数是11111111，即-1)
- 10000000是最小负数的补码表示形式，我们把补码计算步骤倒过来就即可。10000000减1得01111111然后取反10000000，因为负数的补码是其绝对值取反，即10000000为最小负数的绝对值，而10000000的十进制表示是128，所以最小负数是-128
- 由此可以得出byte的取值范围是-128到+127
- 说明：各个类型取值范围的计算方法与此大致相同，感兴趣的同学可以自己试着计算
概念：
- [原码]就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
- [反码]表示法规定：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
- [补码]表示法规定：正数的补码与其原码相同；负数的补码是在其反码的末位加1。
3. int 与Integer
详细说明可以参考文献 [彻底让你明白 Integer 类和 int 基本数据类型的区别](https://blog.csdn.net/teacher_lee_zzsxt/article/details/79230501) ### 3.1 int 与Integer的基本区别 * Integer 是 int 包装类，int 是八大基本数据类型之一（byte,char,short,int,long,float,double,boolean） * Integer 是类，默认值为null，int是基本数据类型，默认值为0； * Integer 表示的是对象，用一个引用指向这个对象，而int是基本数据类型，直接存储数值。3.2 Integer 的自动拆箱和装箱
自动拆箱和自动装箱是 JDK1.5 以后才有的功能，在编译期，会根据代码的语法，在生成class文件的时候，决定是否进行拆箱和装箱动作。
3.2.1 自动装箱
一般我们创建一个类的时候是通过new关键字，比如：
Object obj = new Object();
但是对于 Integer 类，我们却可以这样：
Integer a = 128;
通过反编译工具，我们可以看到，生成的class文件是：
Integer a = Integer.valueOf(128);
这就是基本数据类型的自动装箱，128是基本数据类型，然后被解析成Integer类。
3.2.2 自动拆箱
我们将 Integer 类表示的数据赋值给基本数据类型int，就执行了自动拆箱。如，
Integer a = new Integer(128);
int m = a;
反编译生成的class文件：
Integer a = new Integer(128);
int m = a.intValue();
简单来讲：自动装箱就是Integer.valueOf(int i);自动拆箱就是 i.intValue();
3.3 实验
public static void main(String[] args) {
Integer i = 10;
Integer j = 10;
System.out.println(i == j); //true
Integer a = 128;
Integer b = 128;
System.out.println(a == b); //false
int k = 10;
System.out.println(k == i); //true
int kk = 128;
System.out.println(kk == a); //true
Integer m = new Integer(10);
Integer n = new Integer(10);
System.out.println(m == n); //false
Integer a1 = 1;
Integer b1 = 2;
Integer c = 3;
Integer e = 321;
Integer f = 321;
Long g = 3L;
Long h = 2L;
System.out.println(c == (a1 + b1));//true
System.out.println(c.equals((a1+b1)));//true
System.out.println(g == (a1+b1));//true
System.out.println(g.equals(a1+b1));//false
System.out.println(g.equals(a1+h));//true
}
说明：
- 第一个打印结果为true：对于 i == j ,我们知道这是两个Integer类，他们比较应该是用equals，这里用==比较的是地址，那么结果肯定为false，但是实际上结果为true。分析源码我们可以知道在 i >= -128 并且 i <= 127 的时候，第一次声明会将 i 的值放入缓存中，第二次直接取缓存里面的数据，而不是重新创建一个Ingeter 对象。那么第一个打印结果因为 i = 10 在缓存表示范围内，所以为 true。
- 第二个打印结果为 false：从上面的分析我们知道，128是不在-128到127之间的，所以第一次创建对象的时候没有缓存，第二次创建了一个新的Integer对象。故打印结果为false
- 第三个打印结果为true：Integer 的自动拆箱功能，也就是比较两个基本数据类型，结果当然为true
- 第四个打印结果为 true：解释和第三个一样。int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比较。
- 第五个打印结果为 false：因为这个虽然值为10，但是我们都是通过 new 关键字来创建的两个对象，是不存在缓存的概念的。两个用new关键字创建的对象用 == 进行比较，结果当然为 false。
- 第六个打印结果为true： 由于 a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法）,==比较符又将左边的自动拆箱，因此它们比较的是数值是否相等。
- 第七个打印结果为true： 对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。
- 第八个打印结果为true： 对于 g == (a+b)，首先计算 a+b,也是先调用各自的intValue方法，得到数值之后，由于前面的g是Long类型的，也会自动拆箱为long，==运算符能将隐含的将小范围的数据类型转换为大范围的数据类型，也就是int会被转换成long类型，两个long类型的数值进行比较。
- 第九个打印结果为false： 对于 g.equals(a+b),同理a+b会先自动拆箱，然后将结果自动装箱，需要说明的是 equals 运算符不会进行类型转换。所以是Long.equals(Integer)，结果当然是false
- 第十个打印结果为true： 对于g.equals(a+h),运算符+会进行类型转换，a+h各自拆箱之后是int+long，结果是long，然后long进行自动装箱为Long，两个Long进行equals判断。
3.4 其他封装类
其他的基本类型也有其对应的封装类，分别是：
- boolean Boolean
- char Character
- byte Byte
- short Short
- int Integer
- long Long
- float Float
- double Double
4. &与&&
* **&：**（1）按位与，（2）逻辑与 * **&&：**短路与说明：逻辑与跟短路与的差别是非常巨大的，虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为，如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算。很多时候我们可能都需要用&&而不是&，例如在验证用户登录时判定用户名不是null而且不是空字符串，应当写为：username != null &&!username.equals("")，二者的顺序不能交换，更不能用&运算符，因为第一个条件如果不成立，根本不能进行字符串的equals比较，否则会产生NullPointerException异常。
5. java中的基本数据类型
基本数据类型包括byte、int、short、long、float、double、boolean、char。说明：String 不是基本的数据类型，是final类型的类。
6. 抽象类与接口的区别
**说明：** 接口是对动作的抽象，抽象类是对根源的抽象。 抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么。比如，男人，女人，这两个类（如果是类的话……），他们的抽象类是人。说明，他们都是人。 人可以吃东西，狗也可以吃东西，你可以把“吃东西”定义成一个接口，然后让这些类去实现它. 所以，在高级语言上，一个类只能继承一个类（抽象类）(正如人不可能同时是生物和非生物)，但是可以实现多个接口(吃饭接口、走路接口)。区别如下：
- 抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
- 抽象类要被子类继承，接口要被类实现。
- 接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
- 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
- 抽象类可以有具体的方法 和属性, 接口只能有抽象方法和不可变常量
- 抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
- 抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
- 抽象类里可以没有抽象方法
- 如果一个类里有抽象方法，那么这个类只能是抽象类
- 抽象方法要被实现，所以不能是静态的，也不能是私有的。
- 接口可继承接口，并可多继承接口，但类只能单根继承。
- 抽象类 和 接口 都是用来抽象具体对象的. 但是接口的抽象级别最高
- 抽象类主要用来抽象类别,接口主要用来抽象功能.
- 抽象类中，且不包含任何实现，派生类必须覆盖它们。接口中所有方法都必须是未实现的。
7. java的基本特性
###7.1 抽象 现实生活中的事物被抽象成对象，把具有相同属性和行为的对象被抽象成类，再从具有相同属性和行为的类中抽象出父类。7.2 封装
隐藏对象的属性和实现细节，仅仅对外公开接口。
封装具有一下优点：
- 便于使用者正确、方便的使用系统，防止使用者错误修改系统属性；
- 有助于建立各个系统之间的松耦合关系；
- 提高软件的可重用性；
- 降低了大型系统的风险，即便整个系统不成功，个别独立的子系统有可能还有价值。
封装的两大原则：
- 把尽可能多的东西藏起来，对外提供简洁的接口；
- 把所有的属性封装起来。
7.3 继承
子类和父类之间的继承关系，子类可以获取到父类的属性和方法。
**注：关于子类能否继承父类的私有方法？ **
从语言角度上说：JDK官方文档明确说明子类不能继承父类的私有方法；
但从内存角度来说，jvm在实例化子类对象之前，会先在内存中创建一个父类对象，然后在父类对象外部放上子类独有的属性，两者合起来形成一个子类对象。所以子类确实拥有父类所有的属性和方法，但是父类中的私有方法子类无法访问。
7.4 多态
java语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。