常见的一种情况是需要某个整数类型变量增加 1 或减少 1，Java 提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++)和自减运算符（–）。 ++ 和 - - 运算符可以放在变量之前，也可以放在变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。例如，当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值(赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 值。用一句口诀就是：“符号在前就先加/减，符号在后就后加/减”。

& 有两个作用，分别是 位与 和 逻辑与

&& 就是逻辑与

作为逻辑与， & 和 && 分别表示长路与和短路与

长路与 两侧，都会被运算

短路与 只要第一个是false，第二个就不进行运算了

• continue ：指跳出当前的这一次循环，继续下一次循环。
• break：指跳出整个循环体，继续执行循环下面的语句。
• return 用于跳出所在方法，结束该方法的运行。return 一般有两种用法：
  • return ：直接使用 return 结束方法执行，用于没有返回值函数的方法
  • return value ：return 一个特定值，用于有返回值函数的方法

heap: 堆 stack: 栈 (在一些书籍里，会被翻译为堆栈，实际上指的就是单纯的这个栈) 存放的内容不一样：

• heap: 是存放对象的
• stack: 是存放基本类型(int, float, boolean 等等)、引用(对象地址)、方法调用

存取方式不一样：

• heap: 是自动增加大小的，所以不需要指定大小，但是存取相对较慢
• stack: 是固定大小的，并且是FILO 先入后出的顺序，并且存取速度比较快

• 静态方法是属于类的，在类加载的时候就会分配内存，可以通过类名直接访问。而非静态成员属于实例对象，只有在对象实例化之后才存在，需要通过类的实例对象去访问。
• 在类的非静态成员不存在的时候静态成员就已经存在了，此时调用在内存中还不存在的非静态成员，属于非法操作

1. 调用方式
   1. 静态方法： 可以直接通过类名.方法名的方式进行方法调用
   2. 非静态方法： 必须通过对象的实例进行方法调用
2. 访问类成员是否存在限制 静态方法在访问本类的成员时，只允许访问静态成员（静态成员和静态方法），不允许访问实例成员（成员变量和实例方法），而实例方法不存在这个限制

静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个；静态变量可以实现让多个对象共享同一个变量。

实例变量必须依存于某一实例，创建对象的实例 通过对象的实例才能访问到它。

所有整型包装类对象之间值的比较，全部使用 equals 方法比较。

1. 数字类型
   1. 整数型： byte，short，int ，long
   2. 浮点型： float，double
2. 字符类型
   1. char
3. 布尔类型
   1. Boolean

八种基本数据类型的默认值以及所占空间的大小如下：

这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean 。

1.包装类型不赋值就是 null ，而基本类型有默认值且不是 null。 2. 包装类型可用于泛型，而基本类型不可以。 3. 基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。 4. 相比于对象类型， 基本数据类型占用的空间非常小。

什么是自动拆装箱？

• 装箱：将基本类型用它们对应的引用类型包装起来；
• 拆箱：将包装类型转换为基本数据类型；

• 语法形式 ：从语法形式上看，成员变量是属于类的，而局部变量是在代码块或方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
• 存储方式 ：从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
• 生存时间 ：从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡。
• 默认值 ：从变量是否有默认值来看，成员变量如果没有被赋初始值，则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

• 对象的相等一般比较的是内存中存放的内容是否相等。
• 引用相等一般比较的是他们指向的内存地址是否相等。

构造方法是一种特殊的方法，主要用于完成对象的初始化工作。 一个类中默认有一个无参构造，如果自己添加一个类的构造器时，java 便不再添加默认的无参构造方法

• 名字与类名相同

• 没有返回值，不能使用void声明构造函数

• 生成类的对象时自动执行，无需调用

  构造方法不能被重写（override），但是可以重载（overload），一个类中可以有多个构造函数的情况，也就构成了构造器重载。

相同点:

1. 都不可被实例化
2. 接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化

不同点:

1. 抽象类中的方法可以有方法体，接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能有静态代码块以及静态方法，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，一个类可以实现多个接口。
5. 接口只有定义，不能有方法的实现，抽象类可以有定义与实现
6. 接口强调特定功能的实现，而抽象类强调所属关系。
7. 接口成员变量默认为public static final，必须赋初值，不能被修改；其所有的成员方法都是public、abstract的。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；抽象方法被abstract修饰，不能被private、static、synchronized和native等修饰，必须以分号结尾，不带花括号。

• 深拷贝：深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。
• 浅拷贝：浅拷贝会在堆上创建一个新的对象（区别于引用拷贝的一点），不过，如果原对象内部的属性是引用类型的话，浅拷贝会直接复制内部对象的引用地址，也就是说拷贝对象和原对象共用同一个内部对象。
• 引用拷贝：就时两个不同的引用指向同一个对象

==

• 基本数据类型 : 比较的是他们的值是否相等

• 引用数据类型 : 比较的是引用的地址是否相同\

  因为 Java 只有值传递，所以，对于 == 来说，不管是比较基本数据类型，还是引用数据类型的变量，其本质比较的都是值，只是引用类型变量存的值是对象的地址。

equals

• 用来比较两个对象是否相等

• 两个对象的内容是否相等

  equals() 不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。equals()方法存在于Object类中，而Object类是所有类的直接或间接父类，因此所有的类都有equals()方法。

switch 可以作用在 byte，short，int，String，Enum(枚举) 上，但是不能作用在long上面

注: switch 作用在String上从JDK1.7开始支持，实质是编译时将字符串替换为了其对应的hash值

• Hash Code() 的作用是获取哈希码（int 整数），也称为散列码。这个哈希码的作用是确定该对象在哈希表中的索引位置。
• 散列表存储的是键值对(key-value)，它的特点是：能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码！（可以快速找到所需要的对象）

我们以“HashSet 如何检查重复”为例子来说明为什么要有 hash Code？

当你把对象加入 HashSet 时，HashSet 会先计算对象的 hash Code 值来判断对象加入的位置，同时也会与其他已经加入的对象的 hash Code 值作比较，如果没有相符的 hash Code，HashSet 会假设对象没有重复出现。但是如果发现有相同 hash Code 值的对象，这时会调用 equals() 方法来检查 hash Code 相等的对象是否真的相同。如果两者相同，HashSet 就不会让其加入操作成功。如果不同的话，就会重新散列到其他位置。这样我们就大大减少了 equals 的次数，相应就大大提高了执行速度。

Hash Code() 和 equals()都是用于比较两个对象是否相等。

hash code： 性能高，只需要计算对象的哈希值

equals： 可靠性高

因为在一些容器中 比如：hash map , hash set 中，有了hash code 后，判断元素是否在对应的容器中的效率会比较高。

• 如果两个对象的hash Code 值相等，那这两个对象不一定相等（哈希碰撞）。
• 如果两个对象的hash Code 值相等并且equals()方法也返回 true，我们才认为这两个对象相等。
• 如果两个对象的hash Code 值不相等，我们就可以直接认为这两个对象不相等。

因为 hash code 所使用的哈希算法也许刚好会让多个对象传回相同的哈希值，越糟糕的哈希算法越容易碰撞（指的是不同的对象得到相同的hash code）

• 因为两个相同的对象的hash code 值必须相等，也就是说如果equals 方法判断两个对象相等，那这两个对象的hash code 值也要相等。
• 如果重写 equals 方法时没有重写hash code 方法的话就会导致equals 方法判断时相等的两个对象他们的hash code 不相同

总结：

• equals 方法判读两个对象是相等的，那这两个对象的hash code 值也要相等
• 两个对象有相同的hash code 值，他们有不一定是相等的（哈希碰撞）

数组获取长度的手段是 .length 属性 String获取长度的手段是 length()方法 集合获取长度的手段是 size()方法 文件获取长度的手段是 length()方法

可变字符串在追加，删除，修改，插入和拼接等操作不会产生新的对象。 String Buffer 和 String Builder Java 提供了两个可变字符串类 string buffer 和 string builder ，中文翻译为 字符串缓冲区

String Buffer 是线程安全的，他的方法是支持线程同步，线程同步会操作串行顺序执行，在单线程环境下会影响效率。 StringBuilder 是 StringBuffer单线程版本，它不是线程安全的，但它的执行效率很高。

StringBuffer和 StringBuilder 具有完全相同的 API ，即构造方法和方法等内容一样。

线程同步是一个多线程概念，就是当多个线程访问一个方法时，只能由一个优先级别高的线程先访问，在访问期间会锁定该方法，其他线程只能等到它访问完成释放锁，才能访问。

• 可变性：
  • Stirng 是不可变的，内部采用的是final数组的方式来实现存储的 所以string 是不可被修改的，如果使用字符串拼接的时候是两个不同的空间
  • String Builder 与 String Buffer 都继承自 Abstract String Builder 类，在 Abstract String Builder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，使用字符串拼接时都是使用的是append()方法在原有的基础上进行拼接的
• 线程安全性：
  • String 中的对象是不可变的，可以理解为常量，线程安全
  • String Buffer 是线程安全的
  • String Builder 是线程不安全的
• 性能：
  • 每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。String Buffer 每次都会对 String Buffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用 StringBuilder 相比使用 String Buffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。
• 总结：
  • 操作少量的数据: 适用 String
  • 单线程操作字符串缓冲区下操作大量数据: 适用 String Builder
  • 多线程操作字符串缓冲区下操作大量数据: 适用 String Buffer
  • 所以 String< String Buffer < String Builder

String 中使用final关键字来修饰字符数组保存字符串， 使用final关键字修饰的类不可以被继承，修饰的方法不可以被重写，修饰的变量是基本数据类型值不可被再次修改，修饰的变量是引用数据类型则不能再指向其他对象。 主要原因如下几点：

• 板寸字符串的数组被final修饰且为私有，并且string 类没有提供/暴露修改这个字符串的方法
• String 类被final 修饰导致其不可被继承，进而避免了子类破坏string不可变

String 中的equals 方法是被重写过的，比较的是string 字符串的值是否相等。

Obj 中的equals 方法比较的是对象的内存地址

是JVM为了提升性能和减少内存消耗针对字符串（string类）专门开辟的一块区域，主要目的是为了字符串的重复创建

不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中。

在前面的学习过程中细心的读者可能会发现，前面的示例代码中获得字符串对象时都是直接使用字符串常量，但Java中对象是使用new关键字创建，字符串对象也可以使用new关键字创建，代码如下：

String s9 = "Hello"; // 字符串常量

String s7 = new String("Hello"); //使用new关键字创建

使用new关键字与字符串常量都能获得字符串对象，但它们之间有一些区别。先看下面代码运行结果：

String s7 = new String("Hello"); ① 

String s8 = new String("Hello"); ② 

String s9 = "Hello"; ③ 

String s10 = "Hello"; ④ 

System.out.printf("s7 == s8 : %b%n", s7 == s8); 

System.out.printf("s9 == s10: %b%n", s9 == s10); 

System.out.printf("s7 == s9 : %b%n", s7 == s9); 

System.out.printf("s8 == s9 : %b%n", s8 == s9);

输出结果：

s7 == s8 : false 

s9 == s10: true 

s7 == s9 : false 

s8 == s9 : false

==运算符比较的是两个引用是否指向相同的对象，从上面的运行结果可见，s7和s8指的是不同对象，s9和s10指向的是相同对象。

这是为什么？Java中的不可变字符串String常量，采用字符串池（StringPool）管理技术，字符串池是一种字符串驻留技术。采用字符串常量赋值时（见代码第③行），如图所示，会字符串池中查找"Hello"字符串常量，如果已经存在把引用赋值给s9，否则创建"Hello"字符串对象，并放到池中。根据此原理，可以推定s10与s9是相同的引用，指向同一个对象。但此原理并不适用于new所创建的字符串对象，代码运行到第①行后，会创建"Hello"字符串对象，而它并没有放到字符串池中。代码第②行又创建了一个新的"Hello"字符串对象，s7和s8是不同的引用，指向不同的对象。

										字符串池

简洁答案: 两个对象，一个是静态存储区的"xyz",一个是用new创建在堆上的对象。

标准答案: 两个，一个是字符串字面量"xyz"所对应的、存在于全局共享的常量池中的实例，另一个是通过new String(String)创建并初始化的、内容（字符）与"xyz"相同的实例。考虑到如果常量池中如果有这个字符串，就只会创建一个。同时在栈区还会有一个对new出来的String实例的s。

final 修饰的类叫最终类，该类不能被继承。 final 修饰的方法不能被重写。 final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

重载： (方法名相同,参数列表不同) 构成方法的重载 重载就是同⼀个类中多个同名⽅法根据不同的参数来执⾏不同的逻辑处理。⽅法名必须相同，参数列表不同，⽅法返回值和访问修饰符可以不同。

重写： 发生在继承中, 子类重写父类的公开方法 ⼦类对⽗类⽅法的重新改造，外部样⼦不能改变

是⼦类对⽗类允许访问的⽅法的实现过程进⾏重新编写。(子类重写父类的公开方法)

1. 返回值类型、⽅法名、参数列表必须相同，抛出的异常范围⼩于等于⽗类，访问修饰符范围⼤于等于⽗类。
2. 如果⽗类⽅法访问修饰符为 private/final/static 则⼦类就不能重写该⽅法，但是被 static 修饰的⽅法能够被再次声明。
3. 构造⽅法⽆法被重写

抽象方法需要子类重写，静态方法是不能被重写的。 本地方法是由本地代码实现的方法，而抽象方法是没有实现的。 synchronized和方法的实现细节有关，抽象方法不涉及实现细节。

GC是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理

在Java 体系中，共用三种常量池。分别是字符串常量池、Class 常量池和运行时常量池。

Class 常量池可以理解为是Class 文件中的资源仓库。Class 文件中除了包含类的版

本、字段、方法、接口等描述信息外，还有一项信息就是常量池(constant pool table)，

用于存放编译器生成的各种字面量(Literal)和符号引用(Symbolic References)。

由于不同的Class 文件中包含的常量的个数是不固定的，所以在Class 文件的常量池

入口处会设置两个字节的常量池容量计数器，记录了常量池中常量的个数。

接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承具体类，但前提是具体类必须有明确的构造函数。

一个内部类对象可以访问创建它的外部类对象的成员，包括私有成员。

final：修饰符（关键字）修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。 finally：通常使用在try…catch的后面，在处理异常的时候不管是否出现异常，该代码块都会执行 finalize：是一个方法，属于Object类的一个方法，而Object类是所有类的父类，Java 中允许使用 finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。

• 构造方法的方法名与类名相同
• 构造方法没有返回值类型
• 可以有多个构造方法,他们之间构成重载 (默认有一个无参构造)
• 如果定义有参构造函数，默认的无参构造函数将被自动屏蔽
• 构造方法不能被继承
• 构造方法不能手动调用，在创建类实例的时候自动调用构造方法

静态: 又叫类方法.属于类的，不属于对象， 在实例化对象之前就可以通过类名.方法名调用静态方法。 （静态属性，静态方法都是属于类的，可以直接通过类名调用

非静态: 是不含有static关键字修饰的普通方法，又称为实例方法，成员方法。属于对象的，不属于类的。必须通过对象的实例进行调用。

三个基本特性

封装性，继承性，多态性

封装能够使外部访问者不能随意存取对象的内部数据，隐藏了对象的内部细节，只保留有限的对外接口。外部访问者不用关心对象的内部细节，使得操作对象变得简单。

在现实世界中继承也是无处不在。例如：轮船与客轮之间的关系，客轮是一种特殊轮船，拥有轮船的全部 特征和行为，即数据和操作。在面向对象中轮船是一般类，客轮是特殊类，特殊类拥有一般类的全部数据和操作，称为特殊类继承一般类。在 Java 语言中一般类称为“父类”，特殊类称为“子类” 。 Java语言是单继承的，即只能有一个父类，但Java可以实现多个接口，可以防止多继承所引起的冲突问题。

多态性是指在父类中成员变量和成员方法被子类继承之后，可以具有不同的状态或表现行为

同名字的方法之所以能够在一个类中同时存在，是因为它们的方法参数列表，调用时根据参数列表调用相应重载方法。

方法重载中参数列表不同的含义是：参数的个数不同或者是参数类型不同。另外，返回类型不能用来区分方法重载。

分别有四个等级

私有，默认，保护，公有

• 私有级别 私有级别的关键字是 private 私有级别 的成员变量和方法只能在其所在类的内部自由使用，在其他的类中则不允许直接访问。 私有级别 限制性最高。

• 默认级别 默认级别没有关键字，也就是没有访问修饰符，默认 级别 的成员变量和方法，可以在其所在类内部和同一个包的其他类中被直接访问，但在不同包的类中则不允许直接其所在类内部和同一个包的其他类中被直接访问，但在不同包的类中则不允许直接访问。

• 保护级别 保护级别的关键字是 protected ，保护 级别 在同一包中完全与默认访问级别一样，但是不同包中子类能够继承父类中的 protec ted 变量和方法，这就是所谓的保护 级别 ，“保护”就是保护某个类的子类都能继承该类的变量和方法。

• 公有级别 公有级别的关键字是 public ，公有级别 的成员变量和方法可以在任何场合被直接访问，是最宽松的一种访问控制等级。

访问成员有两种方式，一种是调用，通过类或对象调用它的成员，另一种是继承，子类继承父类的成员变量和方法

• 公有访问级别任何情况下两种方式都可以
• 默认访问级别在同一包中两种访问方式都可以，不能在包之外访问。
• 保护访问级别在同一包中与默认访问级别一样，两种访问方式都可以，但是在不同包之外只能继承访问。
• 私有访问级别只能在本类中通过调用方法访问，不能继承访问。

Static 修饰的成员变量是静态变量，static修饰的方法是静态方法。 相反，没有用static修饰的变量是实例变量，没有用static修饰的方法是实例方法

注意：

• 静态方法可以访问静态变量和其他静态方法，
• 实例方可以访问实例变量，其他的实例方法,静态变量和静态方法

静态代码块在类第一次加载的时候执行，并只执行一次

声明方式

// 静态方法 
public static double interestBy(double amt) { 
         
// 静态方法可以访问静态变量和其他静态方法 
return interestRate * amt; 
}

// 静态代码块 
static { 
         ① 
System.out.println("静态代码块被调用..."); 
// 初始化静态变量 
interestRate = 0.0668; ② 
}

构造方法是类中特殊方法，用来初始化类的实例变量，

特点：

• 构造方法名必须和类名相同
• 构造方法没有任何返回值，包括void
• 构造方法只能与new 运算符结合使用

在一个类中可以有多个构造方法，他们具体有相同的名字（与类名相同），参数列表不同，所以他们之间一定是重载关系。

This 指向对象本身，一个类可以通过this 来获取一个代表它自身的对象变量。This 使用在如下三种情况中：

• 调用实例变量
• 调用实例方法
• 调用其他构造方法

一般情况下，一个子类只能继承一个父类，称为单继承，但有的情况下一个子类可以有多个不同的父类，称为多重继承。在java中，类的继承只能是单继承，多重继承可以通过实现多个接口实现。也就是说一个类只能继承一个父类，但是可以实现多个接口。

当子类实例化时，不仅需要初始化子类成员变量，也需要初始化父类成员变量，初始化父类变量需要调用父类构造方法，子类使用super关键字调用父类构造方法。 Super 语句必须位于子类构造方法的第一行

概念：

发生堕胎要有三个前提条件：

• 继承。多态发生一定要和子类和父类之间
• 覆盖。子类覆盖了父类的方法
• 声明的变量类型是父类类型，大门实例则指向子类实例

在运行时判断一个对象是否属于某个引用类型，这时可以使用 instanceof 运算符 instanceof 运算符语法格式如下：

Obj instanceof type

其中obj 是一个对象， type 是引用类型，如果obj 对象是type 引用类型实例则返回true 否则返回 false

Final 关键字可以修饰 变量，方法和类。

• 修饰变量 Final 修饰的变量称为常量，只能赋值一次，但是final所修饰局部便变量和成员变量有所不同。
  • Final 修饰的局部变量必须在使用之前被赋值才能使用
  • Final 修饰的成员变量在声明时没有赋值的叫 “空白 finall 变量”。空白final变量必须在构造方法和静态代码块中初始化

无论修饰哪一种常量只能赋值一次。

• 修饰方法

  • Final 修饰的方法不能被子类继承覆盖。