- Java 中只有整型才能使用的运算符为%
- 静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。
- 类的 final 成员变量必须满足以下其中一个条件：初始化赋值或在构造函数中赋值。
- 理解 Try...catch...finally 与直接 throw 的区别：try catch 是直接处理，处理完成之后程序继续往下执行，throw 则是将异常抛给它的上一级处理，程序便不往下执行了。
- java object 默认的基本方法（九个默认方法）有：getClass()，hashCode()，equals()，clone()，toString()，notify()，notifyAll()，wait()，finalize()
- 形式参数只能被 final 修饰而且可被视为 local variable。
- java8 中，threadlocalmap 使用开放定址法解决 hash 冲突，hashmap 使用链地址法解决 hash 冲突。
- String 与 StringBuffer 的区别：String 是不可变的对象，StringBuffer 是可以再编辑的，字符串是常量，StringBuffer 是变量。
- instanceof 可以用来判断某个实例变量是否属于某种类的类型，但它的功能不局限于此，比如还可以判断某个类是否属于某个类的子类的类型。
- 一个类一旦没有显式的定义任何构造，那么 JVM 会默认给你一个无参构造。无参构造的第一行依然默认是 super()。
- 不管 catch 是否捕获异常，finally 语句块都是要被执行的，而且在 try 语句块或 catch 语句块中执行到 System.exit(0)直接退出程序。finally 语句块不会在 catch 语句块中的 return 语句之前执行，但 finally 块中的 return 语句会覆盖 try 块中的 return 返回。
- Java 没有任何无符号（unsigned）形式的 int、long、short 或 byte 类型。
- float 类型的数值有一个后缀 F 或 f（例如，3.14F）。没有后缀 F 的浮点数值（如 3.14) 默认为 double 类型。当然，也可以在浮点数值后面添加后缀 D 或 d（例如，3.14D）。
- Java中，中文字符所占的字节数取决于字符的编码方式。
| 编码方式 | 通常对应中文字符所占字节数 |
| ISO8859-1 | 1个字节 |
| GB2312或GBK | 2个字节 |
| UTF-8 | 3个字节 |
- Java 中整型值和布尔值之间不能进行相互转换。
- 尽管$是一个合法的 Java 字符，但不要在你自己的代码中使用这个字符。它只用在 Java 编译器或其他工具生成的名字中。
- 可以在一行中声明多个变量。不过，不提倡使用这种风格。逐一声明每一个变量可以提高程序的可读性。
- 在 Java 中，变量的声明尽可能地靠近变量第一次使用的地方，这是一种良好的程序编写风格。
- 在 Java 中，不区分变量的声明与定义。
- 关键字 final 表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上，常量名使用全大写。在 Java 中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字 static final 设置一个类常量。const 是 Java 保留的关键字，但目前并没有使用。在 Java 中，必须使用 final 定义常量。
- 在 Java 中，没有幂运算，因此需要借助于 Math 类的 pow 方法。pow(x，a) 表示 x 的 a 次幂，pow 方法有两个 double 类型的参数，其返回结果也为 double 类型。
- 重要：Java 中数值类型的转换（图中有 6 个实心箭头，表示无信息丢失的转换；有 3 个虚箭头，表示可能有精度损失的转换。）
- 两个数值进行二元操作时（例如 n + f，n 是整数，f 是浮点数），先要将两个操作数转换为同一种类型，然后再进行计算（double>float>long>int）。
转换规则：如果两个操作数中有一个是 double 类型，另一个操作数就会转换为 double 类型。否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float 类型。否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型。否则，两个操作数都将被转换为 int 类型。
- Java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度。
- equals()相等的两个对象他们的 hashCode()肯定相等，也就是用 equals()对比是绝对可靠的。hashCode()相等的两个对象他们的 equal()不一定相等，也就是 hashCode()不是绝对可靠的。
- 数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组。
- final 的作用：1. 修饰变量，变量的引用地址不可变，但是地址中的内容可以变。2. 修饰方法，方法不可被重写，但是还是可以重载。3. 修饰类，类不可继承。
- 不可变类，说的是一个类一旦被实例化，就不可改变自身的状态。常见的比如 String 和基本数据类型的包装类，对于这种不可变类，一旦在进行引用传递的时候，形参一开始就和实际参数指向的不是一个地址，所以在方法中对形参的改变，并不会影响实际参数。
- 局部内部类是放在代码块或方法中的就像一个局部变量一样，不能有访问控制符，且不能用 static 修饰，但是可以用 final 和 abstract 修饰。
- 类中声明的变量有默认初始值，但是在方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。
public class Pvf{
static boolean Paddy; // boolean 类型默认值是 false。
public static void main(String args[]){
System.out.println(Paddy);
}
} // 编译通过并输出结果 false。- Java 程序初始化顺序：父类的静态代码块（只执行一次）->子类的静态代码块（只执行一次）-> main 方法 ->父类的普通代码块->父类的构造方法->子类的普通代码块->子类的构造方法。（简化记忆：静态域（包括静态成员和静态块）->普通块->main->constructer）
// 静态代码块
static{
}
// 普通代码块
{
}
- 子类重写父类方法时，方法的访问权限不能小于原访问权限，在接口中，方法的默认权限如果是 public，子类重写后只能是 public。
- &按位与 |按位或 ～取反 ^异或 。
- Java 中所有的类都直接或间接继承自 Object，无论是否明确的指明，无论其是否是抽象类。
- Java 里面参数传递只有按值传递 java 方法的参数有两种，1.基本类型参数，基本类型传递的是本身拷贝的值，对于自身状态无影响。2.对象参数传递，方法参数会改变对象本身状态。如果是 final 不可变类(比如 String，int 的包装类型 Integer 等等)，方法参数不会改变对象参数状态（可以当成 1.基本类型参数）。
- 如果子类构造器没有显示地调用超类的构造器，则将自动地调用超类默认（没有参数）的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中有没有显示地调用超类的其他构造器，则 Java 编译器将报告错误。使用 super 调用构造器的语句必须是子类构造器的第一条语句。
- Java 中基本数据类型的大小参考。
| 整数类型 | byte (1 个字节）short (2 个字节）int (4 个字节）long (8 个字节） |
| 字符类型 | char (2 个字节） |
| 浮点类型 | float (4 个字节）double (8 个字节） |
- 一个子类继承某个父类时定义了与父类相同名称的变量时，不同的访问修饰符会影响变量的覆盖。private 变量受访问权限的限制，它不能被覆盖。friendly、protected 和 public 修饰符并不影响属性的覆盖。
- Java 中 final 的详细作用：
1.final 修饰变量，则等同于常量。
2.final 修饰方法中的参数，称为最终参数。
3.final 修饰类，则类不能被继承。（密封类）
4.final 修饰方法，则方法不能被重写。（密封方法）
5.final 不能修饰抽象类。（抽象类必须被用来继承）
6.final 修饰的方法可以被重载，但不能被重写。
- == 优先级高于 三目运算。
- 方法可以和类同名，和构造器区别在于必须要有返回值类型。
- 理解 Try...catch...finally 与直接 throw 的区别：try catch 是直接处理，处理完成之后程序继续往下执行，throw 则是将异常抛给它的上一级处理，程序便不往下执行了，但是后面会执行 finally 语句块。
- str.split()方法是把 str 字符串根据分割符划分成一个字符串数组，如果 str 字符串中找不到分隔符，则把整个 str 字符串放入字符串数组的第一个元素。
- 数值型变量在默认情况下为 Int 型，byte 和 short 型在计算时会自动转换为 int 型计算，结果也是 int 型。比如：
int fun(){
byte a = 1，b = 2;
return a + b; // a 和 b 会被自动处理为 int 型在进行加法运算
}
- override 表示重写覆盖，overload 表示重载。
- String 对象的两种创建方式:
第一种方式: String str1 = "aaa"; 是在常量池中获取对象，一共会创建一个字符串对象。
第二种方式: String str2 = new String("aaa"); 一共会创建两个字符串对象一个在堆中，一个在常量池中(前提是常量池中还没有 "aaa" 字符串对象)。
- 接口和抽象类的总结：
| 接口 |
|
| 抽象类 |
|
- Java中进制的表示：
- 二进制，必须在它前面加上一个 0b 或 0B，只能出现 0 或 1。
- 八进制，必须在它前面加上一个 0(零)，只能出现 0~7。
- 十六进制，必须在它前面加上 0x 或 0X，如：0xff，0xFF，0X102A 等等。
- 方法的重写(override)要遵循两同两小一大的原则：（子类方法相对于父类方法）
两同：方法名和签名。
两小：返回类型若为引用类型必须小于等于父类的，若为基本类型则必须相同；
抛出的异常必须小于等于父类的。
一大：子类方法的访问权限要大于等于父类方法的访问权限，比如 public > private。
- Java 中常见集合类归纳总结：
Collection<--List<--Vector
Collection<--List<--ArrayList
Collection<--List<--LinkedList
Collection<--Set<--HashSet
Collection<--Set<--HashSet<--LinkedHashSet
Collection<--Set<--SortedSet<--TreeSet
| List(有序，可重复) |
|
| Set(无序，唯一) |
|
| Map(映射) |
|
- Java 中每个包都是独立的，导入了一个包不可以访问其子包下的所有类。
- Java 源文件中 import 语句应位于 package 语句之后，在所有类的定义之前，当然也可以没有或者有多条，但是 package 语句必须放在第一行。
- Java 的三个基本特征 (面向对象的三个基本特征) :封装、继承、多态。
- 访问修饰符的权限大小：public > protected > default > private。
public：被其修饰的类成员能被所有的类直接访问。
default：该权限是 java 默认的权限，被其修饰的类成员只能被同一个保重的类访问。
private：被其修饰的类成员只能在修饰它的类中被访问，私有化成员一般用于封装，不可以被外部类访问，对外提供 get/set 方法对其进行访问。
protected：1. 父类的被 protected 修饰的类成员包内可见，并且对其子类可见。2. 父类与子类不在同一个包里，子类只可以访问从父类继承的 protected 成员，不能访问父类实例化的成员。
|
| 同一个类 | 同一个包 | 不同包的子类 | 不同包的非子类 |
| Private | √ |
|
|
|
| Default | √ | √ |
|
|
| Protected | √ | √ | √ |
|
| Public | √ | √ | √ | √ |
- 有些人认为 super 与 this 引用是类似的概念，实际上，这样比较并不太恰当。这是因为 super 不是一个对象的引用，不能将 super 赋给另一个对象变量，它只是一个指示编译器调用超类方法的特殊关键字。
- super 的作用：
- 表示调用父类的构造函数 super() super(参数)
- 调用父类的成员: super.method() super.field 可以借此调用父类中被重写的方法，也可以访问父类被隐藏的非私有(protected)成员。
- String 类型中没有 append()方法，要追加字符串可以使用 + 运算符。
- 如果子类的构造器没有显式地调用超类的构造器，则将自动地调用超类默认（没有参数）的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中又没有显式地调用超类的其他构造器，则 Java 编译器将报告错误。
- Java 继承中对构造函数是不继承的，只是显式或者隐式调用。
- 在方法中定义的局部变量，不是在该方法被执行时创建的，而是在该变量被声明并赋值时创建，可以理解为“当代码执行到该变量被赋值的代码时才被创建”。
- Java 中枚举属于一种类，而不是原始数据类型。
- Java 体系结构包括四个独立但相关的技术：
- Java 程序设计语言
- Java.class 文件格式
- Java 应用编程接口（API）
- Java 虚拟机
- 在 java 语言中，判断一块内存空间是否符合垃圾收集器收集标准的标准只有两个：
- 给对象赋值为 null，以下没有调用过。
- 给对象赋了新的值，重新分配了内存空间。
- 子类可以继承父类的全部数据域和方法，但是这里继承代表的是“拥有”，即：只是拥有父类的全部数据域和方法，但不具备对某些私有数据域或私有方法的使用权（调用）。
- 三元操作符如果遇到可以转换为数字的类型，会做自动类型提升。
Object o1 = (false) ? new Double(1.0) : new Integer(2);
System.out.println(o1); // 打印 2.0- 异常捕获中try必须，catch和finally不是必须，但是不能同时省略。
- final 不能修饰接口和抽象类（接口必须被实现，抽象类必须被继承）。
3225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
