总概
- 命名规范
- 数据类型
- eclipse常用快捷键
1、java开发中的命名规则
除去一些硬性要求，比如不能用关键字、不能以数字开头等，最好遵循以下的建议写法：
1、类：
每个首字母大写，如 Student、HelloWorld
2、接口：
同上
3、变量：
第一个单词完全小写，后续更多的单词首字母大写，如 age、ageOfMyGirlfriend
4、方法：
与变量一样，如 show()、getAge()
5、常量：
所有字母大写。如：public static final int MAX_ROW = 100
6、包（其实就是文件夹，用于对类进行管理）：
全部小写，多级包用点隔开。公司域名的反写。
如 cn.pandastudio (相当于两级文件夹：cn\pandastudio)；
com.baidu (相当于两级文件夹 com\baidu)
2、Java数据类型
基本类型：包括8种，整型（byte、short、int【默认】、long），浮点型（float、double【默认】），字符型（char），布尔型（boolean）。
引用类型：（除了基本类型，都算引用类型），包括数组、类、接口、lambda等。
注意事项：
1、定义long型数据，在数值之后要用L做后缀（大小写均可，推荐大写），如520000L。
2、定义一个float型数据，在数值后要加字母F做后缀（同上）
3、eclipse中常用快捷键整理
1、快速修正：Ctrl+1
2、单词补全：Alt+/
3、删除行：Ctrl+D
4、在当前行上插入一行：Ctrl+Shift+Enter
5、在当前行下插入一行： Shift+Enter
6、上下移动选中的行：Alt+Up/Down
7、反悔：Ctrl+Z
8、上下移动选中的行：Alt+Up/Down
9、保存：Ctrl+S
10、注释：Ctrl+/
11、查找：Ctrl+F
12、排版：Ctrl+Shift+F
13、设置缩略和展开：
缩略：Window-->preferences-->key-->Collapse All
展开：Window-->preferences-->key-->Expand All
14、设置自动提示：
Eclipse -> Window -> Perferences -> Java -> Editor -> Content Assist
15、shift+enter：快速换行
4、栈的深度
栈的深度与局部变量有关，局部变量越多，栈越浅。
验证，通过自己调用自己，异常等验证。
5、i++和++的区别
1、首先，单独拿出来说++i和i++，意思都是一样的，就是i=i+1。
2、如果当做运算符来说，就是a=i++或者a=++i这样的形式。情况就不一样了。
先说a=i++，这个运算的意思是先把i的值赋予a，然后在执行i=i+1；
而a=++i，这个的意思是先执行i=i+1，然后在把i的值赋予a；
举个例子来说，如果一开始i=4。
那么执行a=i++这条语句之后，a=4，i=5；
那么执行a=++i这条语句之后，i=5，a=5；
同理，i--和--i的用法也是一样的。
例如:设x = 1 , y = 2 , z = 3，则表达式y＋＝z－－/＋＋x 的值是(A )。
A. 3 B. 3. 5 C. 4 D. 5
解：按从左往右先乘除后加减的顺序。z--除以++x，此时z为3，x为2，所以3/2取整为1，y加上后边的结果为2+1=3。
6、String创建的对象个数问题
String str = "hello";
String str1 = "hello";
Syso(str==str1); //比较的是地址值。输出为True。指向的是同一个
String str2 = new String("hello"+str); //有两个对象。"hello"和str为同一个对象，str2为另一个对象。
String str2 = new String("hell"+str);
str.equals(str1) //String中的equal()重写了，相当于只比较数值。
7、java 内部类为什么不能用静态方法 ？
非static的内部类，在外部类加载的时候，并不会加载它，所以它里面不能有静态变量或者静态方法。
static类型的属性和方法，在类加载的时候就会存在于内存中。
要使用某个类的static属性或者方法，那么这个类必须要加载到jvm中。
基于以上两点，可以看出，如果一个非static的内部类如果具有static的属性或者方法，那么就会出现一种情况：内部类未加载，但是却试图在内存中创建static的属性和方法，这当然是错误的。原因：类还不存在，但却希望操作它的属性和方法。
8、&& 和 &
9、再谈i++和++i（经常错！！！无语）
看个例子：
```public class Tmp {
public static void main(String[] args) {
int i = 1;
int j = 10;
do {
if (i++ > --j)
continue;
} while (i < 5);
System.out.println("i: "+i+" j: "+j);
}
}```
输出结果：
i: 5 j: 6
分析：
下面是转载自知乎的解释，可参考。
（1）如果只是看i++和++i，这两个是等价的，都等同于i=i+1，都是变量自身加1。
（2）在一般情况下，它们都是跟赋值联系在一起。
比如：
int a;
a=i++;//将i的值赋值给a，即a=i；然后再执行i=i+1；
也就是【a=i++;】与【a=i; i=i+1;】等价。
a=++i;//将i+1的值赋给a,即a=i+1;然后再执行i=i+1；
也就是【a=++i;】与【a=i+1;i=i+1;】等价。
（3）【总结一下】
①前置++是将自身加1的值赋值给新变量，同时自身也加1；
②后置++是将自身的值赋给新变量，然后才自身加1.
作者：知乎用户
链接：https://www.zhihu.com/question/19811087/answer/83748442
来源：知乎
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
10、值传递、引用传递
CSDN博客：https://blog.csdn.net/zhzhao999/article/details/53449504
11、AutoCloseable接口
从jdk1.7开始，引入了资源自动关闭的接口AutoCloseable。一些资源也实现了该接口，如preparedStatement、Connection、InputStream、outputStream等等资源接口。在使用的时候只需要把资源在try块中用小括号括起来就可以了。
12、String str="test"和String str=new String("test")区别
该部分可以再详细研究一下java中的特殊类String涉及到常量池的设计思想很巧妙
先去看看常量池的概念： http://blog.csdn.net/cquptzg/article/details/72457389
"test"是存放在常量池中的对象，常量池中不会存放相同的对象，
new String("test")是存放在堆中的对象，即使内容相同也会创建不同的对象。
【例】
String str1 = "test";
String str2 = "test";
String str3 = new String("test);
String str4 = new String("test);
str1==str2的值为true；因为"test"存放在常量池中，所以str1与str2均是"test"的同一个引用
str1==str3的值为false；
str3==str4的值为false；即使他们内容都是"test"，但也会分别创建对象。
若用equals()方法，因为内容都是"test"，则结果都是ture，
【对于==与equals的疑问，跳转：http://blog.csdn.net/cquptzg/article/details/72158040】
【总结】 通过常量池创建的对象，若内容相同，则只会有一个，而通过new创建的则不管之前有没有创建过内容相同的都会在堆里新创建一个对象
案例分析：
String str1="java";//指向字符串池
String str2="blog";//指向字符串池
String s = str1+str2;
+运算符会在堆中建立起两个String对象，这两个对象的值分别是“java”,"blog",也就是说从字符串常量池中复制这两个值，然后再堆中创建两个对象。然后再建立对象s,然后将“javablog”的堆地址赋给s. 这句话共创建了3个String对象。
String str1 = “str1”：
1、 在栈中创建str1的引用。
2、 去常量池中查看是否有相同Unicode编码的字符串常量。如果有将str1指向该常量，如果没有则创建一个内容为”str1”的字符串常量，将str1的引用指向该常量。
3、 如果str1进行了赋值str1= “123”,则栈中的str1的引用指向新的内容为“123”的字符串常量。
4、 String str1 = “str1”; String str2 = “str1”;str2的引用指向常量池中已经存在的内容为“str1”的常量，不会重新创建新的常量，str1和str2的引用指向同一个常量。
str1 == str2; str1+”a” != str2+”a”;
String str1 = new String(“str1”)：
1、 在常量池中创建内容为“str1”的对象，在堆中创建内容为“str1”的对象。
2、 String str1 = new String(“str1”); String str2 = new String(“str1”);str2不会指向之前创建的对象，而是重新创建一个对象。
str1 != str2;
代码如下：
String str1 = "str1";
String str2 = "str1";
String str3 = new String("str1");
String str4 = new String("str1");
System.out.println(str1==str2);//true地址一样
System.out.println(str3==str4);//false,但地址不一样
System.out.println(str3.equals(str4));//true,值一样
System.out.println(str2.equals(str3));//true,值一样
System.out.println((str1+"a")==(str2+"a"));//false;进行了+连接地址不一样
System.out.println((str1+"a").equals((str2+"a")));//true;进行了+连接值一样
13、声明对象和声明对象并赋值为null的区别，以及null调用方法，运行时出现空指针异常
Object o与Object o=null的区别
class Test {
public static void main(String[] args) {
Object o1;
o1.toString(); /*这里编译不能通过，编译器只认定o1是个引用，没指向任何对象，所以不能调用方法。*/
Object o2 = null;
o2.toString(); /*这里编译可以过，但是有空指针异常，编译器认定o2是一个对象，虽然是一个空对象。*/
}
}
null对象是一个特殊的对象，他可以是任何类型。他只是作为一个标记而已，只是为了标记不存在而存在的。也没必要去追究他在内存是什么样。null就是一个标记而已。容器可以接受一个空对象，但是一个空引用则是不接受的。
Object o; //这种写法只是分配一个引用，没有分配内存。
Object o = null; //这么写则是给引用指向了一个空对象。分配了内存（空对象），所以编译不会报错，运行时报空指针异常。